Changeset 825 for trunk/grails-app/domain

Timestamp:

Aug 17, 2010, 6:22:24 PM (10 years ago)

Author:

duh

Message:

• added TemplateField?: MODULE (AssayModule? --> module gscf can integrate with like SAM)
• added TemplateFiled?: LONG
• started working on wizard Assay page

Location:

trunk/grails-app/domain/dbnp/studycapturing

Files:

• Assay.groovy (modified) (1 diff)
• TemplateEntity.groovy (modified) (7 diffs)
• TemplateFieldType.groovy (modified) (4 diffs)

trunk/grails-app/domain/dbnp/studycapturing/Assay.groovy

@@ -6 +6 @@
  * this data can be found.
  */
-class Assay extends Identity {
-
-        /** The name of the assay, which should indicate the measurements represented in this assay to the user. */
+class Assay extends TemplateEntity {
+        // The name of the assay, which should indicate the measurements represented in this assay to the user.
         String name
 
-        /** The dbNP module in which the assay omics data can be found. */
+        // The dbNP module in which the assay omics data can be found. */
         AssayModule module
 
+        // The assay ID which is used in the dbNP submodule which contains the actual omics data of this assay.
+        // This ID is generated in GSCF, but is used in the submodules to refer to this particular Assay.
+        long externalAssayID
+
         /**
-                The assay ID which is used in the dbNP submodule which contains the actual omics data of this assay.
-                This ID is generated in GSCF, but is used in the submodules to refer to this particular Assay.
+         * return the domain fields for this domain class
+         * @return List
          */
-        long externalAssayID
+        static List<TemplateField> giveDomainFields() { return Assay.domainFields }
+        static List<TemplateField> domainFields = [
+                new TemplateField(
+                        name: 'name',
+                        type: TemplateFieldType.STRING,
+                        preferredIdentifier: true,
+                        required: true
+                ),
+                new TemplateField(
+                        name: 'module',
+                        type: TemplateFieldType.MODULE
+
+                ),
+                new TemplateField(
+                        name: 'externalAssayID',
+                        type: TemplateFieldType.LONG
+                )
+        ]
 
         // An Assay always belongs to one study.

trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy

@@ -31 +31 @@
         Map templateBooleanFields       = [:]
         Map templateTemplateFields      = [:]
+        Map templateModuleFields        = [:]
+        Map templateLongFields          = [:]
 
         // N.B. If you try to set Long.MIN_VALUE for a reltime field, an error will occur
@@ -40 +42 @@
         // define relationships
         static hasMany = [
-                templateStringFields: String,
-                templateTextFields: String,
+                templateStringFields    : String,
+                templateTextFields              : String,
                 templateStringListFields: TemplateFieldListItem,
-                templateIntegerFields: int,
-                templateFloatFields: float,
-                templateDoubleFields: double,
-                templateDateFields: Date,
-                templateTermFields: Term,
-                templateRelTimeFields: long,
-                templateFileFields: String,
-                templateBooleanFields: boolean,
-                templateTemplateFields: Template,
-                systemFields: TemplateField
+                templateIntegerFields   : int,
+                templateFloatFields             : float,
+                templateDoubleFields    : double,
+                templateDateFields              : Date,
+                templateTermFields              : Term,
+                templateRelTimeFields   : long,
+                templateFileFields              : String,
+                templateBooleanFields   : boolean,
+                templateTemplateFields  : Template,
+                templateModuleFields    : AssayModule,
+                templateLongFields              : long,
+                systemFields                    : TemplateField
         ]
 
@@ -314 +318 @@
                         return (!error)
                 })
-                templateTemplateFields(validator: { fields, obj, errors ->
-                        def error = false
-                        fields.each { key, value ->
-                                if (value && value.class != Template) {
-                                        try {
-                                                fields[key] = (value as Template)
-
-                                        } catch (Exception e) {
-                                                error = true
-                                                errors.rejectValue(
-                                                        'templateTemplateFields',
-                                                        'templateEntity.typeMismatch.template',
-                                                        [key, value.class] as Object[],
-                                                        'Property {0} must be of type Template and is currently of type {1}'
-                                                )
-                                        }
-                                }
-                        }
-                        return (!error)
-                })
                 templateBooleanFields(validator: { fields, obj, errors ->
                         def error = false
@@ -341 +325 @@
                                 } else {
                                         fields[key] = false;
+                                }
+                        }
+                        return (!error)
+                })
+                templateTemplateFields(validator: { fields, obj, errors ->
+                        def error = false
+                        fields.each { key, value ->
+                                if (value && value.class != Template) {
+                                        try {
+                                                fields[key] = (value as Template)
+                                        } catch (Exception e) {
+                                                error = true
+                                                errors.rejectValue(
+                                                        'templateTemplateFields',
+                                                        'templateEntity.typeMismatch.template',
+                                                        [key, value.class] as Object[],
+                                                        'Property {0} must be of type Template and is currently of type {1}'
+                                                )
+                                        }
+                                }
+                        }
+                        return (!error)
+                })
+                templateModuleFields(validator: { fields, obj, errors ->
+                        def error = false
+                        fields.each { key, value ->
+                                if (value && value.class != AssayModule) {
+                                        try {
+                                                fields[key] = (value as AssayModule)
+                                        } catch (Exception e) {
+                                                error = true
+                                                errors.rejectValue(
+                                                        'templateModuleFields',
+                                                        'templateEntity.typeMismatch.module',
+                                                        [key, value.class] as Object[],
+                                                        'Property {0} must be of type AssayModule and is currently of type {1}'
+                                                )
+                                        }
+                                }
+                        }
+                        return (!error)
+                })
+                templateLongFields(validator: { fields, obj, errors ->
+                        def error = false
+                        fields.each { key, value ->
+                                if (value && value.class != Long) {
+                                        try {
+                                                fields[key] = Long.parseLong(value.trim())
+                                        } catch (Exception e) {
+                                                error = true
+                                                errors.rejectValue(
+                                                        'templateLongFields',
+                                                        'templateEntity.typeMismatch.long',
+                                                        [key, value.class] as Object[],
+                                                        'Property {0} must be of type Long and is currently of type {1}'
+                                                )
+                                        }
                                 }
                         }
@@ -380 +421 @@
                         case TemplateFieldType.TEMPLATE:
                                 return templateTemplateFields
+                        case TemplateFieldType.MODULE:
+                                return templateModuleFields
+                        case TemplateFieldType.LONG:
+                                return templateLongFields
                         default:
                                 throw new NoSuchFieldException("Field type ${fieldType} not recognized")
@@ -583 +628 @@
                 }
 
-                // Magic setter for template fields
+                // Magic setter for TEMPLATE fields
                 if (field.type == TemplateFieldType.TEMPLATE && value && value.class == String) {
                         value = Template.findByName(value)
+                }
+
+                // Magic setter for MODULE fields
+                if (field.type == TemplateFieldType.MODULE && value && value.class == String) {
+                        value = AssayModule.findByName(value)
+                }
+
+                // Magic setter for LONG fields
+                if (field.type == TemplateFieldType.LONG && value && value.class == String) {
+                        // TODO, check for invalids?
+                        value = Long.parseLong(value.trim())
                 }
 
@@ -600 +656 @@
                                 // the value to 0, otherwise, setting it to NULL
                                 switch (field.type.toString()) {
-                                        case ['INTEGER', 'FLOAT', 'DOUBLE', 'RELTIME']:
+                                        case ['INTEGER', 'FLOAT', 'DOUBLE', 'RELTIME', 'LONG']:
                                                 this[field.name] = 0;
                                                 break;

trunk/grails-app/domain/dbnp/studycapturing/TemplateFieldType.groovy

@@ -3 +3 @@
 /**
  * Enum describing the type of a TemplateField.
+ *
  * Revision information:
  * $Rev$
@@ -9 +10 @@
  */
 public enum TemplateFieldType implements Serializable {
-        STRING('String'),
-        TEXT('Long string'),
-        INTEGER('Integer number'),
-        FLOAT('Floating-point number'),
-        DOUBLE('Double precision floating-point number'),
-        STRINGLIST('List of items'),
-        ONTOLOGYTERM('Ontology Reference'),
-        DATE('Date'),
-        RELTIME('Relative time'), // relative date, e.g. days since start of study
-        FILE('File'),
-        BOOLEAN('Boolean'),
-        TEMPLATE('Template')
+        STRING('String'),                                                                       // string
+        TEXT('Long string'),                                                            // text
+        INTEGER('Integer number'),                                                      // integer
+        FLOAT('Floating-point number'),                                         // float
+        DOUBLE('Double precision floating-point number'),       // double
+        STRINGLIST('List of items'),                                            // string list
+        ONTOLOGYTERM('Ontology Reference'),                                     // ontology reference
+        DATE('Date'),                                                                           // date
+        RELTIME('Relative time'),                                                       // relative date, e.g. days since start of study
+        FILE('File'),                                                                           // file
+        BOOLEAN('Boolean'),                                                                     // boolean
+        TEMPLATE('Template'),                                                           // template
+        MODULE('Module'),                                                                       // third party connected module,
+        LONG('Long number')                                                                     // long
     // TODO: add a timezone-aware date type to use for study start date
 
@@ -30 +33 @@
 
         static list() {
-                [STRING, TEXT, INTEGER, FLOAT, DOUBLE, STRINGLIST, ONTOLOGYTERM, DATE, RELTIME, FILE, BOOLEAN, TEMPLATE]
+                [STRING, TEXT, INTEGER, FLOAT, DOUBLE, STRINGLIST, ONTOLOGYTERM, DATE, RELTIME, FILE, BOOLEAN, TEMPLATE, MODULE, LONG]
         }
 
@@ -54 +57 @@
                                 return ""
                         case BOOLEAN:
-                                return false;
+                                return false
                         case TEMPLATE:
-                                return null;
+                                return null
+                        case MODULE:
+                                return null
+                        case LONG:
+                                return Long.MIN_VALUE
                         default:
                                 throw new NoSuchFieldException("Field type ${fieldType} not recognized")