Downloads Documentation Community Contribute Demo






Show Sidebar
Login | Register

Changeset 4389

Show
Ignore:
Timestamp:
05/27/08 18:44:05 (8 months ago)
Author:
tmdugan
Message:

-- atd

* updated dss jar
* changed providerName formatting
* refactored consume method

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • openmrs-modules/atd/.classpath

    r4279 r4389  
    6565        <classpathentry kind="lib" path="lib-common/bcel.jar"/> 
    6666        <classpathentry kind="lib" path="lib-common/openmrs-api-1.3.0.00.4178.jar"/> 
    67         <classpathentry kind="lib" path="lib-common/dss-2.15.jar"/> 
     67        <classpathentry kind="lib" path="lib-common/dss-2.16.jar"/> 
    6868        <classpathentry kind="output" path="build"/> 
    6969</classpath> 
  • openmrs-modules/atd/src/org/openmrs/module/atd/impl/ATDServiceImpl.java

    r4279 r4389  
    107107                } 
    108108                 
     109                //parse the xml 
    109110                LogicService logicService = Context.getLogicService(); 
    110111                TeleformExportXMLDatasource xmlDatasource =  
    111112                        (TeleformExportXMLDatasource) logicService 
    112113                                .getLogicDataSource("xml"); 
    113                  
    114                 //parse the xml 
    115114                try 
    116115                { 
     
    149148                String mode = "CONSUME"; 
    150149                 
    151                 HashMap<String,HashMap<String,HashMap<String, Object>>> rulesToRunByField =  
    152                         new HashMap<String,HashMap<String,HashMap<String, Object>>>(); 
    153                  
    154                 //consume fields 
     150                HashMap<String,HashMap<String,Rule>> rulesToRunByField =  
     151                        new HashMap<String,HashMap<String,Rule>>(); 
     152                 
     153                //find consume rules to execute 
     154                //set parameters for rules 
    155155                for(FormField currField:formFieldToValue.keySet()) 
    156156                { 
    157157                        String fieldName = currField.getField().getName(); 
    158158                        Concept currConcept = currField.getField().getConcept(); 
    159                         String defaultValue = currField.getField().getDefaultValue(); 
    160                         HashMap<String,HashMap<String, Object>> ruleToRun = null; 
    161                         HashMap<String, Object> parameters = null; 
     159                        String ruleName = currField.getField().getDefaultValue(); 
     160                        HashMap<String,Rule> rulesToRun = null; 
     161                        Map<String, Object> parameters = new HashMap<String,Object>(); 
     162 
    162163                        FormField parentField = currField.getParent(); 
    163164                         
    164165                        //if parent field is not null look at parent 
    165166                        //field for rule to execute 
     167                        Rule rule = null; 
    166168                        if(parentField != null) 
    167169                        { 
     170                                FieldType currFieldType = currField.getField().getFieldType(); 
     171 
     172                                if(currFieldType.equals(translator 
     173                                                .getFieldType("Prioritized Merge Field"))) 
     174                                { 
     175                                        ruleName = null;//no rule to execute unless patientATD finds one         
     176                                } 
    168177                                PatientATD patientATD =  
    169178                                        atdService.getPatientATD(formInstanceId,  
     
    172181                                if(patientATD != null) 
    173182                                { 
    174                                         Rule rule = patientATD.getRule(); 
    175                                         defaultValue = rule.getTokenName(); 
    176                                 } 
    177                         } 
    178                         if(defaultValue != null) 
    179                         { 
    180                                 ruleToRun = rulesToRunByField.get(fieldName); 
    181                                 if(ruleToRun == null) 
    182                                 { 
    183                                         ruleToRun  =  
    184                                                 new HashMap<String,HashMap<String, Object>>(); 
    185                                         rulesToRunByField.put(fieldName, ruleToRun); 
     183                                        rule = patientATD.getRule(); 
     184                                        ruleName = rule.getTokenName(); 
     185                                } 
     186                        } 
     187                        if(ruleName != null) 
     188                        { 
     189                                rulesToRun = rulesToRunByField.get(fieldName); 
     190                                if(rulesToRun == null) 
     191                                { 
     192                                        rulesToRun  =  
     193                                                new HashMap<String,Rule>(); 
     194                                        rulesToRunByField.put(fieldName, rulesToRun); 
    186195                                } 
    187196                                 
    188                                 parameters = ruleToRun.get(defaultValue); 
     197                                Rule ruleLookup = rulesToRun.get(ruleName); 
    189198                                 
    190                                 if(parameters == null) 
    191                                 { 
    192                                         parameters = new HashMap<String,Object>(); 
    193                                         ruleToRun.put(defaultValue, parameters); 
    194                                 } 
    195                         } 
    196          
    197                         if(parameters == null) 
    198                         { 
    199                                 parameters = new HashMap<String,Object>(); 
     199                                if(ruleLookup == null) 
     200                                { 
     201                                        ruleLookup = new Rule(); 
     202                                        ruleLookup.setParameters(parameters); 
     203                                       ruleLookup.setTokenName(ruleName); 
     204                                       rulesToRun.put(ruleName, ruleLookup); 
     205                               }else 
     206                               { 
     207                                       parameters = ruleLookup.getParameters(); 
     208                                } 
    200209                        } 
    201210                         
     
    206215                        parameters.put("mode", mode); 
    207216                        parameters.put("encounterId", encounterId); 
     217                        if(rule != null) 
     218                        { 
     219                                parameters.put("ruleId", rule.getRuleId()); 
     220                        } 
    208221                         
    209222                        if (currConcept != null) 
     
    227240                } 
    228241                 
    229                 //add processing to add parameters for children 
     242                //add child fields as parameters to parent field rules 
    230243                HashMap<String,Integer> childIndex = new HashMap<String,Integer>(); 
    231244                 
    232245                for(FormField currField:formFieldToValue.keySet()) 
    233246                { 
    234                         String fieldName = currField.getField().getName(); 
    235                         HashMap<String,HashMap<String, Object>> ruleToRun = null; 
    236                         HashMap<String, Object> parameters = null; 
     247                        HashMap<String,Rule> rulesToRun = null; 
     248                        Map<String, Object> parameters = new HashMap<String,Object>(); 
    237249                        FormField parentField = currField.getParent(); 
    238                          
     250 
    239251                        //look for parentField 
    240252                        if(parentField != null) 
    241253                        { 
    242                                 String defaultValue = parentField.getField().getDefaultValue(); 
    243                                 fieldName = parentField.getField().getName(); 
    244  
     254                                FieldType parentFieldType = parentField.getField().getFieldType(); 
     255 
     256                                String parentRuleName = parentField.getField().getDefaultValue(); 
     257                                String parentFieldName = parentField.getField().getName(); 
     258 
     259                                if(parentFieldType.equals(translator 
     260                                                .getFieldType("Prioritized Merge Field"))) 
     261                                { 
     262                                        parentRuleName = null;//no rule to execute unless patientATD finds one   
     263                                } 
    245264                                PatientATD patientATD =  
    246265                                        atdService.getPatientATD(formInstanceId,  
    247266                                                        parentField.getField().getFieldId(),formId); 
    248267                                 
    249                                 if(patientATD == null) 
    250                                 { 
    251                                         ruleToRun = rulesToRunByField.get(fieldName); 
    252                                         if(ruleToRun == null) 
     268                                if(patientATD != null) 
     269                                { 
     270                                        Rule rule = patientATD.getRule(); 
     271                                        parentRuleName = rule.getTokenName(); 
     272                                } 
     273                                //if there is a parent rule, add a parameter for the child's fieldname 
     274                                //add the parent rule if it is not in rules to run 
     275                                if(parentRuleName!=null) 
     276                                { 
     277                                        rulesToRun = rulesToRunByField.get(parentFieldName); 
     278                                        if(rulesToRun == null) 
    253279                                        { 
    254                                                 ruleToRun  =  
    255                                                         new HashMap<String,HashMap<String, Object>>(); 
    256                                                 rulesToRunByField.put(fieldName, ruleToRun); 
     280                                                rulesToRun  =  
     281                                                        new HashMap<String,Rule>(); 
     282                                                rulesToRunByField.put(parentFieldName, rulesToRun); 
    257283                                        } 
    258284                                         
    259                                         parameters = ruleToRun.get(defaultValue); 
     285                                        Rule ruleLookup = rulesToRun.get(parentRuleName); 
    260286                                         
    261                                         if(parameters == null) 
     287                                        if(ruleLookup == null) 
    262288                                        { 
    263                                                 parameters = new HashMap<String,Object>(); 
    264                                                 ruleToRun.put(defaultValue, parameters); 
     289                                                ruleLookup = new Rule(); 
     290                                                ruleLookup.setParameters(parameters); 
     291                                                ruleLookup.setTokenName(parentRuleName); 
     292                                                rulesToRun.put(parentRuleName, ruleLookup); 
     293                                        }else 
     294                                        { 
     295                                                parameters = ruleLookup.getParameters(); 
    265296                                        } 
    266                                         fieldName = currField.getField().getName(); 
    267                                         Integer index = childIndex.get(fieldName); 
     297                                         
     298                                        String childFieldName = currField.getField().getName(); 
     299                                        Integer index = childIndex.get(childFieldName); 
    268300                                        if(index == null) 
    269301                                        { 
    270302                                                index = 0; 
    271303                                        } 
    272                                         parameters.put("child"+index, fieldName); 
    273                                         childIndex.put(fieldName,index++); 
     304                                        parameters.put("child"+index, childFieldName); 
     305                                        childIndex.put(childFieldName,index++); 
    274306                                } 
    275307                        } 
     
    277309                 
    278310                //run all the consume rules 
    279                 for(HashMap<String,HashMap<String, Object>> currRule:  
     311                for(HashMap<String, Rule> rulesToRun:  
    280312                        rulesToRunByField.values()) 
    281313                { 
    282                         for(String currRuleName: currRule.keySet()) 
    283                         { 
    284                                 HashMap<String, Object> parameters =  
    285                                         currRule.get(currRuleName); 
     314                        for(String currRuleName: rulesToRun.keySet()) 
     315                        { 
     316                                Rule rule = rulesToRun.get(currRuleName); 
     317                                Map<String, Object> parameters =  
     318                                        rule.getParameters(); 
     319                                         
    286320                                if(baseParameters != null) 
    287321                                { 
  • openmrs-modules/atd/src/org/openmrs/module/atd/ruleLibrary/providerName.java

    r4279 r4389  
    5656                        if(provider != null) 
    5757                        { 
    58                                 String providerName = "Dr. "; 
     58                                String providerName = ""; 
    5959                                 
    6060                                if(provider.getGivenName() != null)