Started LeRelation and childs implementation

Begin to work on fieldtypes

EditorialModel/classtypes.py

     }
 }
 
+relations_common_fields = {
+    'id_relation': {
+        'fieldtype': 'pk',
+        'internal': 'automatic',
+    },
+    'nature': {
+        'fieldtype': 'naturerelation',
+        'internal': 'automatic',
+    },
+    'depth': {
+        'fieldtype': 'integer',
+        'internal': 'automatic',
+    },
+    'rank': {
+        'fieldtype': 'integer',
+        'internal': 'automatic',
+    },
+}
+
 
 def pk_name():
     for name, option in common_fields.items():

EditorialModel/fieldtypes/generic.py

     ## @brief Text describing the fieldtype
     help = 'Generic field type : abstract class for every fieldtype'
     ## @brief Allowed type for handled datas
-    _allowed_ftype = ['char', 'str', 'int', 'bool', 'datetime', 'text', 'rel2type']
+    _allowed_ftype = ['char', 'str', 'int', 'bool', 'datetime', 'text', 'rel2type', 'leobject']
 
     ## @brief The basic lowlevel value type
     ftype = None

EditorialModel/fieldtypes/pk.py

         }
         # Checking args
         for name, value in kwargs.items():
-            if name not in allowed:
-                raise TypeError("Got an unexpected argument '%s' for pk EmFieldType" % name)
-            if value != allowed[name]:
+            if name in allowed and value != allowed[name]:
                 raise ValueError("The value '%s' for argument '%s' for pk EmFieldType is not allowed" % (value, name))
 
         kwargs.update(allowed)

leapi/lefactory.py

         with open(self._code_filename, "w+") as dynfp:
             dynfp.write(self.generate_python(model, datasource_cls, datasource_args))
 
+    ## @brief Generate fieldtypes for concret classes
+    # @param ft_dict dict : key = fieldname value = fieldtype __init__ args
+    # @return (uid_fieldtypes, fieldtypes) designed to be printed in generated code
+    def concret_fieldtypes(self, ft_dict):
+        res_ft_l = list()
+        res_uid_ft = None
+        for fname, ftargs in ft_dict.items():
+            ftargs = copy.copy(ftargs)
+            fieldtype = ftargs['fieldtype']
+            self.needed_fieldtypes |= set([fieldtype])
+            del(ftargs['fieldtype'])
+
+            constructor = '{ftname}.EmFieldType(**{ftargs})'.format(
+                ftname = GenericFieldType.module_name(fieldtype),
+                ftargs = ftargs,
+            )
+
+            if fieldtype == 'pk':
+                #
+                #       WARNING multiple PK not supported
+                #
+                res_uid_ft = "{ %s: %s }"%(repr(fname),constructor)
+            else:
+                res_ft_l.append( '%s: %s'%(repr(fname), constructor) )
+        return (res_uid_ft, res_ft_l)
+
     ## @brief Given a Model and an EmClass instances generate python code for corresponding LeClass
     # @param model Model : A Model instance
     # @param emclass EmClass : An EmClass instance from model
 import leapi
 import leapi.lecrud
 import leapi.leobject
+import leapi.lerelation
 from leapi.leclass import _LeClass
 from leapi.letype import _LeType
 """
             leobj_me_uid[comp.uid] = LeFactory.name2classname(comp.name)
         
         #Building the fieldtypes dict of LeObject
+        (leobj_uid_fieldtype, leobj_fieldtypes) = self.concret_fieldtypes(EditorialModel.classtypes.common_fields)
+        """
         leobj_fieldtypes = list()
         leobj_uid_fieldtype = None
         for fname, ftargs in EditorialModel.classtypes.common_fields.items():
                 #
                 #       WARNING multiple PK not supported
                 #
-                leobj_uid_fieldtype = "{ 'lodel_id': %s }"%constructor
+                leobj_uid_fieldtype = "{ %s: %s }"%(repr(fname),constructor)
             else:
                 leobj_fieldtypes.append( '%s: %s'%(repr(fname), constructor) )
-            
+        """
+        #Building the fieldtypes dict for LeRelation
+        (lerel_uid_fieldtype, lerel_fieldtypes) = self.concret_fieldtypes(EditorialModel.classtypes.relations_common_fields)
+        """
+        lerel_fieldtypes = list()
+        lerel_uid_fieldtype = None
+        for fname, ftargs in EditorialModel.classtypes.relations_common_fields.items():
+            ftargs = copy.copy(ftargs)
+            fieldtype = ftargs['fieldtype']
+            self.needed_fieldtypes |= set([fieldtype])
+            del(ftargs['fieldtype'])
+
+            constructor
+        """ 
 
         result += """
 ## @brief _LeCrud concret class
     _uid_fieldtype = {leo_uid_fieldtype}
     _leo_fieldtypes = {leo_fieldtypes}
 
+## @brief _LeRelation concret class
+# @see leapi.lerelation._LeRelation
+class LeRelation(LeCrud, leapi.lerelation._LeRelation):
+    _uid_fieldtype = {lerel_uid_fieldtype}
+    _rel_fieldtypes = {lerel_fieldtypes}
+    _rel_attr_fieldtypes = dict()
 
-class LeClass(LeObject, _LeClass):
+class LeHierarch(LeRelation, leapi.lerelation._LeHierarch):
+    _rel_attr_fieldtypes = dict()
+
+class LeRel2Type(LeRelation, leapi.lerelation._LeRel2Type):
     pass
 
+class LeClass(LeObject, _LeClass):
+    pass
 
 class LeType(LeClass, _LeType):
     pass
             me_uid_l = repr(leobj_me_uid),
             leo_uid_fieldtype = leobj_uid_fieldtype,
             leo_fieldtypes = '{\n\t' + (',\n\t'.join(leobj_fieldtypes))+ '\n\t}',
+            lerel_fieldtypes = '{\n\t' + (',\n\t'.join(lerel_fieldtypes))+ '\n\t}',
+            lerel_uid_fieldtype = lerel_uid_fieldtype,
         )
 
         emclass_l = model.components(EditorialModel.classes.EmClass)

leapi/lerelation.py

+#-*- coding: utf-8 -*-
+
+import copy
+
+import EditorialModel.fieldtypes.leo as ft_leo
+from . import lecrud
+
+## @brief Main class for relations
+class _LeRelation(lecrud._LeCrud):
+    
+    ## @brief Handles the superior
+    _lesup_fieldtype = ft_leo.EmFieldType(True)
+    ## @brief Handles the subordinate
+    _lesub_fieldtype = ft_leo.EmFieldType(False)
+    ## @brief Stores the list of fieldtypes that are common to all relations
+    _rel_fieldtypes = dict()
+    ## @brief Stores the list of fieldtypes handling relations attributes
+    _rel_attr_fieldtypes = dict()
+
+    def __init__(self, rel_id, **kwargs):
+       pass 
+ 
+    @classmethod
+    def fieldtypes(cls):
+        rel_ft = dict()
+        rel_ft.update(cls._lesup_fieldtype)
+        rel_ft.update(cls._lesub_fieldtype)
+        rel_ft.update(cls._rel_fieldtypes)
+        rel_ft.update(cls._rel_attr_fieldtypes)
+        return rel_ft
+
+    @classmethod
+    def _prepare_relational_fields(cls, field):
+        return LeApiQueryError("Relational field '%s' given but %s doesn't is not a LeObject"%(field,cls.__name__))
+
+            
+
+## @brief Abstract class to handle hierarchy relations
+class _LeHierarch(_LeRelation):
+    def __init__(self, rel_id):
+        pass
+
+## @brief Abstract class to handle rel2type relations
+class _LeRel2Type(_LeRelation):
+    pass
+    

leapi/test/test_lecrud.py

 """
-    Tests for _LeObject and LeObject
+    Tests for _LeCrud and LeCrud
 """
 
 import unittest