mvtc empty

api/src/messages/Validation.properties

@@ -10,6 +10,6 @@ UniqueViolationError=The value of the {0} field conflicts with another value in
 typeMismatch=This value could not be converted
 typeMismatch.int=Please enter a valid integer value
 typeMismatch.double=Please enter a valid floating point number
-tyepMismatch.Date=Please enter a valid date
+typeMismatch.Date=Please enter a valid date
 requiredError=This field is required
 uniqueConstraint=Value conflicts with existing data.  Please enter a unique value.

api/src/org/labkey/api/assay/actions/AssayRunUploadForm.java

@@ -509,7 +509,7 @@ else if (AbstractAssayProvider.PARTICIPANT_VISIT_RESOLVER_PROPERTY_NAME.equals(k
                     ColumnInfo pk = pks.get(0);
                     try
                     {
-                        Object filterValue = ConvertUtils.convert(value, pk.getJavaClass());
+                        Object filterValue = pk.convert(value);
                         SimpleFilter filter = new SimpleFilter(pk.getFieldKey(), filterValue);
                         Set<String> cols = new HashSet<>();
                         cols.add(lookupTable.getTitleColumn());

api/src/org/labkey/api/data/AbstractWrappedColumnInfo.java

@@ -848,4 +848,10 @@ public boolean isMultiValued()
     {
         return delegate.isMultiValued();
     }
+
+    @Override @Transient
+    public final SimpleConvert getConvertFn()
+    {
+        return ColumnRenderProperties.getDefaultConvertFn(this);
+    }
 }

api/src/org/labkey/api/data/BaseColumnInfo.java

@@ -75,6 +75,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
 /**
@@ -2229,4 +2230,10 @@ public void setRemapMissingBehavior(SimpleTranslator.RemapMissingBehavior missin
     {
         _remapMissingBehavior = missingBehavior;
     }
+
+    @Override @Transient
+    public final SimpleConvert getConvertFn()
+    {
+        return ColumnRenderProperties.getDefaultConvertFn(this);
+    }
 }

api/src/org/labkey/api/data/BeanViewForm.java

@@ -124,12 +124,14 @@ else if (o instanceof Map)
     }
 
     @Override
-    protected Class<?> getTruePropType(String propName)
+    protected SimpleConvert getSimpleConvert(String propName)
     {
-        var ret = _dynaClass.getTruePropType(propName);
-        if (null == ret)
-            ret = super.getTruePropType(propName);
-        return ret;
+        var type = _dynaClass.getTruePropType(propName);
+        if (null != type)
+        {
+            return ConvertHelper.getSimpleConvert(type);
+        }
+        return super.getSimpleConvert(propName);
     }
 
     // DynaBean

api/src/org/labkey/api/data/ColumnInfoTests.jsp

@@ -0,0 +1,259 @@
+<%@ page import="org.labkey.api.data.JdbcType" %>
+<%@ page import="org.junit.Test" %>
+<%@ page import="static org.junit.Assert.*" %>
+<%@ page import="org.labkey.api.data.BaseColumnInfo" %>
+<%@ page import="org.jetbrains.annotations.NotNull" %>
+<%@ page import="java.math.BigDecimal" %>
+<%@ page import="org.labkey.api.exp.PropertyType" %>
+<%@ page import="org.labkey.api.ontology.Quantity" %>
+<%@ page import="org.labkey.api.ontology.Unit" %>
+<%@ page import="org.labkey.api.ontology.KindOfQuantity" %>
+<%@ page import="org.labkey.api.data.MutableColumnInfo" %>
+<%@ page import="org.labkey.api.data.WrappedColumnInfo" %>
+<%@ page import="org.apache.commons.beanutils.ConversionException" %>
+<%@ page import="org.labkey.api.data.ColumnInfo" %>
+<%@ page import="org.labkey.api.data.dialect.SqlDialect" %>
+<%@ page import="org.labkey.api.data.CoreSchema" %>
+<%@ page import="java.nio.ByteBuffer" %>
+<%@ page extends="org.labkey.api.jsp.JspTest.BVT" %>
+<%--
+This tests uses MockRequest to test some expected Headers and Meta tags for various types of requests.
+--%>
+<%!
+    void testConvert(ColumnInfo col, Object expected, Object val)
+    {
+        var result = col.convert(val);
+        assertNotNull(result);
+        assertEquals(col.getJdbcType().getJavaClass(), result.getClass());
+        assertEquals(expected, result);
+    }
+
+    void testConvertsToNull(ColumnInfo col, Object val)
+    {
+        var result = col.convert(val);
+        assertNull(result);
+    }
+
+    void testConversionException(ColumnInfo col, Object val)
+    {
+        try
+        {
+            col.convert(val);
+            fail();
+        }
+        catch (ConversionException x)
+        {
+            return;
+        }
+    }
+
+    void testConvert(JdbcType type, Object expected, Object val)
+    {
+        var col = new BaseColumnInfo("~", null, type);
+        testConvert(col.lock(), expected, val);
+    }
+
+    void testConvertsToNull(JdbcType type, Object val)
+    {
+        var col = new BaseColumnInfo("~", null, type);
+        testConvertsToNull(col.lock(), val);
+    }
+
+    void testConversionException(JdbcType type, Object val)
+    {
+        var col = new BaseColumnInfo("~", null, type);
+        testConversionException(col.lock(), val);
+    }
+
+    void testConvert(PropertyType pt, Object expected, @NotNull Object val)
+    {
+        var col = new BaseColumnInfo("~", null, pt.getJdbcType());
+        col.setPropertyType(pt);
+        testConvert(col.lock(), expected, val);
+    }
+
+    void testConvertsToNull(PropertyType pt, Object val)
+    {
+        var col = new BaseColumnInfo("~", null, pt.getJdbcType());
+        col.setPropertyType(pt);
+        testConvertsToNull(col.lock(), val);
+    }
+
+    void testConversionException(PropertyType pt, Object val)
+    {
+        var col = new BaseColumnInfo("~", null, pt.getJdbcType());
+        col.setPropertyType(pt);
+        testConversionException(col.lock(), val);
+    }
+
+    void testQuantity(Unit displayUnit, Quantity expected, Object value)
+    {
+        // UNDONE: setDisplayUnit is NYI???
+        var col = new BaseColumnInfo("~", null, JdbcType.DOUBLE)
+        {
+            @Override
+            public Unit getDisplayUnit()
+            {
+                return displayUnit;
+            }
+
+            @Override
+            public KindOfQuantity getKindOfQuantity()
+            {
+                return null==displayUnit ? null : displayUnit.getKindOfQuantity();
+            }
+        };
+        testConvert(col.lock(), expected, value);
+    }
+
+
+    /** This test is for the integrated ColumnInfo.convert() logic.
+     * <p></p>
+     * A lot of this testing is redunant with lower-level unit testing,
+     * however, his till servers as a basic conversion smoke test.
+     * <p></p>
+     * In particualr, the PropertyType conversions are pretty
+     * redundant with ConvertHelper.convert() and JdbcType.convert()
+     * (PropertyType predates JdbcType), but there are some differenes
+     * in implementation.  We should try to reconcile these differences.
+     */
+//    @Test
+    public void testColumnConvert() throws Exception
+    {
+        // see also ConvertHelper.testEmpty()
+
+        // w/o propertyType
+        for (JdbcType type : JdbcType.values())
+        {
+            switch (type)
+            {
+                case BIGINT ->
+                {
+                    testConvert(type, Long.valueOf(5), Integer.valueOf(5));
+                    testConvert(type, Long.valueOf(5), "5");
+                    testConvert(type, Long.valueOf(5), Double.valueOf(5.00000));
+                    testConversionException(type, Double.valueOf(5.00001));
+                    testConvert(type, Long.valueOf(5), new BigDecimal("5.000"));
+                    testConversionException(type, new BigDecimal("5.001"));
+                    testConversionException(type, "5g");
+                    testConvertsToNull(type, "");
+                    testConvertsToNull(type, null);
+                }
+                case BINARY, LONGVARBINARY, VARBINARY ->
+                {
+                    testConvert(type, ByteBuffer.wrap(new byte[] {0x00,0x00,0x00,0x05}), Long.valueOf(5));
+                }
+                case BOOLEAN -> {}
+                case CHAR,LONGVARCHAR,VARCHAR ->
+                {
+                    testConvertsToNull(type, null);
+                    // NOTE StandardDataIterator optionally trims, but convert() does not.
+                    // see SimpleTranslator.createConvertColumn()
+                    testConvert(type, " no trim ", " no trim ");
+                    // JdbcType does not convert empty string to null, ColumnInfo.convert() and PropertyType.conver() do
+                    assertEquals("", type.convert(""));
+                    testConvertsToNull(type, "");
+                    testConvertsToNull(type, null);
+                }
+                case DECIMAL -> {}
+                case DOUBLE -> {}
+                case INTEGER -> {}
+                case REAL -> {}
+                case SMALLINT, TINYINT -> {}
+                case DATE -> {}
+                case TIME -> {}
+                case TIMESTAMP -> {}
+                case GUID -> {}
+                case ARRAY, NULL, OTHER -> { /* ignore */ }
+                default -> fail("We missed a JdbcType: " + type.name());
+            }
+        }
+
+        // testArray()
+
+        // w/ propertyType
+        for (var type : PropertyType.values())
+        {
+            switch (type)
+            {
+                case BOOLEAN -> {}
+                case STRING ->
+                {
+                    testConvertsToNull(type, null);
+                    testConvertsToNull(type, "");
+                    testConvert(type, " no trim ", " no trim ");
+                }
+                case MULTI_LINE ->
+                {
+                    testConvertsToNull(type, null);
+                    testConvertsToNull(type, "");
+                    testConvert(type, " no trim ", " no trim ");
+                }
+                case MULTI_CHOICE -> {}
+                case RESOURCE -> {}
+                case INTEGER -> {}
+                case BIGINT ->
+                {
+                    testConvert(type, Long.valueOf(5), Integer.valueOf(5));
+                    testConvert(type, Long.valueOf(5), "5");
+                    testConvert(type, Long.valueOf(5), new BigDecimal("5.001"));
+                    testConvertsToNull(type, null);
+                    testConvertsToNull(type, "");
+                    testConversionException(type, "5g");
+                }
+                case BINARY -> {}
+                case FILE_LINK -> {}
+                case ATTACHMENT -> {}
+                case DATE_TIME -> {}
+                case DATE -> {}
+                case TIME -> {}
+                case DOUBLE -> {}
+                case FLOAT -> {}
+                case DECIMAL -> {}
+                case XML_TEXT -> {}
+                default -> fail("We missed a PropertyType: " + type.name());
+            }
+        }
+
+        // Quantity
+        Unit unit = Unit.kg;
+        testQuantity(unit, Quantity.of(5000,unit.getBase()), "5");
+    }
+
+
+    public void testLocked(MutableColumnInfo col)
+    {
+        col.setAlias("!");
+        col.lock();
+        try
+        {
+            col.setAlias("!");
+            fail("not locked?");
+        }
+        catch (IllegalStateException x)
+        {
+            // success
+        }
+    }
+
+    static class _ColumnInfo extends BaseColumnInfo
+    {
+        _ColumnInfo()
+        {
+            super("~", JdbcType.INTEGER);
+        }
+
+        @Override
+        public SqlDialect getSqlDialect()
+        {
+            return CoreSchema.getInstance().getSqlDialect();
+        }
+    }
+
+//    @Test
+    public void testLocked()
+    {
+        testLocked(new _ColumnInfo());
+        testLocked(WrappedColumnInfo.wrap(new _ColumnInfo()));
+    }
+%>