Changeset 8085


Ignore:
Timestamp:
03/02/12 13:45:58 (8 years ago)
Author:
mnagni
Message:

Correctly generates DB tables for CEDAEditor
added two Junit tests

Actually can import a configuration file to add further classes to the table generation

In sqlTables.py, still this has to be fixed by hand:

-- Column('role', CI_RoleCode.db_type(), nullable=False) ----> Column('role', CI_RoleCode.db_type())

Location:
mauRepo/xmi2sqlalchemy/trunk/src
Files:
4 added
1 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/NmParserHelper.java

    r8017 r8085  
    3232package ndg.services.newmoon; 
    3333 
     34import java.io.IOException; 
     35import java.io.InputStream; 
     36import java.util.Arrays; 
     37import java.util.HashSet; 
    3438import java.util.List; 
     39import java.util.Set; 
    3540 
    3641import ndg.services.newmoon.xmiModel.UMLAssociation; 
     
    4045import ndg.services.newmoon.xmiModel.UML_ID; 
    4146 
     47import org.apache.commons.io.IOUtils; 
    4248import org.apache.commons.lang.StringUtils; 
    4349import org.slf4j.Logger; 
     
    98104                return node; 
    99105        } 
     106         
     107        public static Set<String> getCSVFromInputStream(InputStream is) { 
     108                Set<String> ret = new HashSet<String>(); 
     109                try { 
     110                        String isText = IOUtils.toString(is); 
     111                        String[] ss = StringUtils.split(isText, ","); 
     112                        ret = new HashSet<String>(Arrays.asList(StringUtils.stripAll(ss))); 
     113                } catch (IOException e) { 
     114                        if (logger.isWarnEnabled()) { 
     115                                logger.warn("Cannot read the Additional Clases file");   
     116                        } 
     117                } 
     118                return ret; 
     119        } 
    100120} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/UmlToRDBM.java

    r8084 r8085  
    3535 
    3636import java.io.File; 
     37import java.io.IOException; 
    3738import java.io.InputStream; 
    38 import java.util.ArrayList; 
     39import java.util.Arrays; 
    3940import java.util.HashMap; 
    4041import java.util.HashSet; 
     
    5253import ndg.services.newmoon.velocity.python.GenerateFromClassModel; 
    5354import ndg.services.newmoon.velocity.python.GenerateTables; 
    54 import ndg.services.newmoon.xmiModel.UMLClass; 
    5555import ndg.services.newmoon.xmiModel.UMLModel; 
    5656 
     57import org.apache.commons.collections.CollectionUtils; 
    5758import org.apache.commons.io.FileUtils; 
     59import org.apache.commons.io.IOUtils; 
     60import org.apache.commons.lang.StringUtils; 
    5861import org.slf4j.Logger; 
    5962import org.slf4j.LoggerFactory; 
     
    8285                        UMLModel umlModel = myModel.get(); 
    8386                         
    84                          
    8587                        File outDir = new File(baseDir, params.get(NewmoonManager.NM_PARAM.OUTPUT_DIR)); 
    8688                        outDir.mkdir(); 
     
    9496                        substitutesSuperAttributes(cms); 
    9597                         
    96                         //Generates the python classes                   
     98                        //Generates the python classes 
    9799                        GenerateFromClassModel gen = new GenerateFromClassModel(new GenerateClasses(outDir, umlArchive)); 
    98100                        gen.execute(umlArchive.getClassModel()); 
    99101 
    100102                        //Generates the sqlalchemy tables 
    101                         GenerateTables gen2 = new GenerateTables(outDir, umlArchive); 
     103                        GenerateTables gen2 = new GenerateTables(outDir, umlArchive, NmParserHelper.getCSVFromInputStream(inputAddClass)); 
    102104                        gen2.execute(umlModel); 
    103105                } catch (Exception e) { 
     
    109111                } 
    110112        } 
    111          
    112113         
    113114        private void substitutesSuperAttributes(List<ClassModel> cms) { 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/collect/AttributeModel.java

    r8084 r8085  
    9595                } 
    9696                         
    97                 return upperBound > 1  
     97                return upperBound > 1                            
    9898                                || collectionType.equals(CollectionType.SET) 
    9999                                || collectionType.equals(CollectionType.SEQUENCE); 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateTables.java

    r8084 r8085  
    9797        private final File baseDir; 
    9898        private final UMLElementsArchive umlArchive; 
     99        private final Set<String> additionalClasses = new HashSet<String>(); 
    99100 
    100101        /** 
     
    102103         */ 
    103104        public GenerateTables(File baseDir, UMLElementsArchive umlArchive) { 
     105                this(baseDir, umlArchive, new HashSet<String>()); 
     106        } 
     107 
     108        public GenerateTables(File baseDir, UMLElementsArchive umlArchive, Set<String> additionalClasses) { 
    104109                super(); 
    105110                this.baseDir = baseDir; 
    106111                this.umlArchive = umlArchive; 
    107         } 
    108  
     112                this.additionalClasses.addAll(additionalClasses); 
     113        } 
     114         
    109115        public void execute(UMLModel umlModel) throws IOException { 
    110116                // Extracts the ClassModels belonging only to the given UMLModel 
     
    114120                // Adds some customer required ClassModel not directly binded to the 
    115121                // given UMLModel 
    116                 processOrphans(ccm); 
     122                CollectionUtils.forAllDo(additionalClasses, ccm); 
     123 
    117124 
    118125                // Generates the TableModels 
     
    121128                // then writes the result out 
    122129                writeAll(closure); 
    123         } 
    124  
    125         private void processOrphans(CollectClassModel ccm) { 
    126                 Set<String> externalClasses = new HashSet<String>(); 
    127                 externalClasses.add("MO_Organization"); 
    128                 CollectionUtils.forAllDo(externalClasses, ccm); 
    129130        } 
    130131 
     
    178179                Writer sqlTablesWriter = new FileWriter(new File(getHelper().getBaseDir(), "sqlTables.py"), true); 
    179180                sqlTablesWriter 
    180                                 .append("from sqlalchemy import Table, Column, Integer, String, ForeignKey, Sequence, event, MetaData\n"); 
    181                 sqlTablesWriter.append("from sqlalchemy.orm import relationship, backref, mapper, clear_mappers\n"); 
    182                 sqlTablesWriter.append("from sqlalchemy.ext.declarative import declarative_base\n"); 
    183                 sqlTablesWriter.append("from sqlalchemy.dialects.postgresql import ARRAY, TEXT, NUMERIC, BOOLEAN, DATE\n"); 
    184                 sqlTablesWriter.append("from sqlalchemy.types import DateTime\n"); 
     181                                .append("from sqlalchemy import Table, Column, ForeignKey, Sequence\n"); 
     182                sqlTablesWriter.append("from sqlalchemy.orm import relationship, mapper\n");                     
    185183                sqlTablesWriter.append("from sqlalchemy.orm.util import class_mapper\n"); 
    186                 sqlTablesWriter.append("from sqlalchemy.schema import ForeignKeyConstraint\n\n"); 
    187                 sqlTablesWriter.append("from ascore.astext import ASText\n\n"); 
     184                sqlTablesWriter.append("from sqlalchemy.dialects.postgresql import TEXT\n");             
    188185 
    189186                sqlTablesWriter.flush(); 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/NmVelocity.java

    r8060 r8085  
    8888         
    8989        public String fillTemplate(Context vcontext, String templateName) { 
    90                 vcontext.put("tab", "    "); //four spaces instead of a TAB as required by python standard 
     90                vcontext.put("tab", "    "); //four spaces instead of a TAB 
    9191                vcontext.put("nl", "\n"); 
    9292                vcontext.put("vh", NmVelocityHelper.class); 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/NmVelocityHelper.java

    r8084 r8085  
    8383                return StringUtils.containsNone(text, "[]<>.,*/|\\@:;+-#!%^£$()"); 
    8484        }  
     85         
     86        public static boolean validateClass(ClassModel classModel) { 
     87                for (ClassModel cm : classModel.getParents()) { 
     88                        if (!NmVelocityHelper.isValidPythonName(cm.getAssociatedClass().getName())) { 
     89                                return false; 
     90                        } 
     91                } 
     92                return NmVelocityHelper.isValidPythonName(classModel.getAssociatedClass().getName()); 
     93        }        
    8594         
    8695        /** 
     
    275284                } 
    276285                 
    277                 //Actually I cannot manage type like Sequance<Vector> and for this reason  
     286                //Actually I cannot manage type like Sequence<Vector> and for this reason  
    278287                // I set them by default to ARRAY<TEXT> 
     288                if (clazz.equalsIgnoreCase(substituteDBType("Vector"))){ 
     289                        return "ARRAY(" + substituteDBType("CharacterString") + ")"; 
     290                } 
     291                 
    279292                if (attribute.hasMultiplicity()) { 
    280                         if (clazz.equalsIgnoreCase(substituteDBType("Vector"))) { 
    281                                 return "ARRAY(" + substituteDBType("CharacterString") + ")"; 
    282                         } else { 
    283293                                return "ARRAY(" + clazz + ")";   
    284                         }                                
    285                 }                
     294                } 
    286295                return clazz; 
    287296        }        
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/PythonClassModel.java

    r8084 r8085  
    6969                                || this.getAssociatedClass().getClass().equals(ASCodeList.class) 
    7070                                || this.getAssociatedClass().getClass().equals(ASUnion.class) 
    71                                 || !validateClass(); 
    72         } 
    73          
    74         private boolean validateClass() { 
    75                 for (ClassModel cm : getParents()) { 
    76                         if (!NmVelocityHelper.isValidPythonName(cm.getAssociatedClass().getName())) { 
    77                                 return false; 
    78                         } 
    79                 } 
    80                 return NmVelocityHelper.isValidPythonName(this.getAssociatedClass().getName()); 
     71                                || !NmVelocityHelper.validateClass(this); 
    8172        } 
    8273         
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/velocity/python/pythonClass.vm

    r8084 r8085  
    8989${tab}def ${attr.name}(self, value): 
    9090#if($attr.getParentName()) 
    91 ${tab}${tab}${tab} self._${attr.getParentName().toLowerCase()}.${attr.name} = value 
     91${tab}${tab}${tab}self._${attr.getParentName().toLowerCase()}.${attr.name} = value 
    9292#elseif($attr.subTypes) 
    9393${tab}${tab}valueClass = "%s.%s" % (type(value).__module__,type(value).__name__) 
     
    109109 
    110110#setter($attribute) 
     111#end 
     112#end 
     113 
     114#macro ( enlistKeys $attributes) 
     115#foreach($attribute in $attributes) 
     116self.${attribute.name}#if($foreach.hasNext), #end 
    111117#end 
    112118#end 
     
    167173${tab}${tab}super(${classModel.associatedClass.name}, self).__init__() 
    168174#dogettersetter($attributes) 
     175 
     176${tab}def __key(self): 
     177${tab}${tab}return (#enlistKeys($attributes)) 
     178 
     179${tab}def __eq__(x, y): 
     180${tab}${tab}''' 
     181${tab}${tab}Cannot compare classes which do not define a "__key" attribute  
     182${tab}${tab}''' 
     183${tab}${tab}if hasattr(x, '_%s__key' % (type(x).__name__)) and hasattr(y, '_%s__key' % (type(y).__name__)): 
     184${tab}${tab}${tab}return x.__key() == y.__key() 
     185${tab}${tab}return id(x) == id(y) 
     186 
     187${tab}def __hash__(self): 
     188${tab}${tab}return hash(self.__key()) 
    169189#end 
Note: See TracChangeset for help on using the changeset viewer.