Merge branch 't12'

EditorialModel/fields.py

 
 from EditorialModel.components import EmComponent, EmComponentNotExistError
 from EditorialModel.fieldtypes import *
+from EditorialModel.fields_types import Em_Field_Type
 from Database import sqlutils
 from Database.sqlwrapper import SqlWrapper
 from Database.sqlquerybuilder import SqlQueryBuilder
 
     table = 'em_field'
     _fields = [
-        ('fieldtype', EmField_char()),
-        ('fieldgroup_id', EmField_integer()),
-        ('rel_to_type_id', EmField_integer()),
-        ('rel_field_id', EmField_integer()),
-        ('optional', EmField_boolean()),
-        ('internal', EmField_boolean()),
-        ('icon', EmField_integer())
+        ('fieldtype', EmField_char),
+        ('fieldgroup_id', EmField_integer),
+        ('rel_to_type_id', EmField_integer),
+        ('rel_field_id', EmField_integer),
+        ('optional', EmField_boolean),
+        ('internal', EmField_boolean),
+        ('icon', EmField_integer)
     ]
 
-    ## __init__ (Function)
-    #
-    # Instanciates an EmField object with data fetched from the database
-    #
-    # @param id_or_name str\int: Identifier of the EmField (global_id or name)
-    # @throw TypeError
-    # @see EmComponent::__init__()
-    def __init__(self, id_or_name):
-        self.table = EmField.table
-        self._fields = self.__class__._fields
-        super(EmField, self).__init__(id_or_name)
-
     ## Create (Function)
     #
     # Creates a new EmField and instanciates it

EditorialModel/fields_types.py

+#-*- coding: utf-8 -*-
+
+from EditorialModel.fieldtypes import EmField_integer
+from EditorialModel.components import EmComponent
+
+from Database import sqlutils
+import sqlalchemy as sqla
+
+import logging
+
+logger = logging.getLogger('Lodel2.EditorialModel')
+
+## Em_Field_Type (Class)
+#
+# Represents an association between a field and a type
+class Em_Field_Type(object):
+
+    table = 'em_field_type'
+    _fields = [('type_id', EmField_integer),('field_id', EmField_integer)]
+
+    ## __init__ (Function)
+    #
+    # Instanciates an Em_Field_Type object with data fetched from the database
+    #
+    # @param type_id integer: Identifier of the type
+    # @param field_id integer: Identifier of the field
+    def __init__(self, type_id, field_id):
+        self.table = Em_Field_Type.table
+        self._fields = self.__class__._fields
+        self.type_id = type_id
+        self.field_id = field_id
+
+    ## Create (Function)
+    #
+    # Creates a relation between a field and a type
+    #
+    # @static
+    #
+    # @param emType EmType: Object representing the Type
+    # @param emField EmField: Object representing the Field
+    # @return Em_Field_Type object
+    @classmethod
+    def create(cls, emType, emField):
+        values = {
+                'type_id': emType.uid,
+                'field_id': emField.uid
+        }
+
+        createdRelation = Em_Field_Type._createDb(**values)
+        return createdRelation
+
+    @classmethod
+    def _createDb(cls, **kwargs):
+        dbe = EmComponent.getDbE()
+        conn = dbe.connect()
+        table = sqla.Table(cls.table, sqlutils.meta(dbe))
+        req = table.insert(kwargs)
+        res = conn.execute(req)
+        conn.close()
+        return Em_Field_Type(kwargs['type_id'], kwargs['field_id'])
+
+    ## Delete (Function)
+    #
+    # Deletes a relation between a field and a type
+    #
+    # @return Boolean
+    def delete(self):
+        return _deleteDb()
+
+    def _deleteDb(self):
+        dbe = EmComponent.getDbe()
+        table = sqla.Table(self.table, sqlutils.meta(dbe))
+        req = table.Delete().Where(table.c.type_id==self.type_id).Where(table.c.field_id==self.field_id)
+        conn = dbe.connect()
+        try:
+            conn.execute(req)
+            res = True
+        except:
+            res = False
+        conn.close()
+
+        return res
+
+    ## Exists (Function)
+    #
+    # Checks if a the relation exists in the database
+    #
+    # @return True if success, False if failure
+    def exists(self):
+        return _existsDb()
+
+    ## _ExistsDb (Function)
+    #
+    # Queries the database to see if a relation exists or not
+    #
+    # @return True if success, False if failure
+    def _existsDb(self):
+        dbe = EmComponent.getDbe()
+        table = sqla.Table(self.table, sqlutils.meta(dbe))
+        req = table.Select().Where(table.c.type_id==self.type_id).Where(table.c.field_id==self.field_id)
+        conn = dbe.connect()
+        res = conn.execute(req).fetchall()
+        conn.close()
+        return len(res)>0

EditorialModel/test/test_field.py

 from EditorialModel.classtypes import EmClassType
 from EditorialModel.types import EmType
 from EditorialModel.fieldgroups import EmFieldGroup
+from EditorialModel.fields_types import Em_Field_Type
 from EditorialModel.fieldtypes import *
 
 from Database.sqlsetup import SQLSetup
 
         pass
 
+
+    ## Get_Field_Type_Record (Function)
+    #
+    # Returns associations between field and type from the em_field_type table
+    #
+    # @param field EmField: Field object
+    # @param type EmType: Type object
+    # @return list of found associations
+    def get_field_type_record(self, field, type):
+        return self._get_field_type_record_Db(field, type)
+
+    ## _Get_Field_Type_Record_Db (Function)
+    #
+    # Queries the database to get the record from the em_field_type table corresponding to a given field and type
+    # @param field EmField: Field object
+    # @param type EmType: Type object
+    # @return found associations
+    def _get_field_type_record_Db(self, field, type):
+        sqlwrapper = SqlWrapper(read_db='default', write_db='default', alchemy_logs=False)
+        sql_builder = SqlQueryBuilder(sql_wrapper, 'em_field_type')
+        sql_builder.Select().From('em_field_type').Where('em_field_type.field_id=%s' % field.uid).Where('em_field_type.type_id=%s' % type.uid)
+        records = sql_builder.Execute().fetchall()
+        field_type_records = []
+        for record in records:
+            field_type_records.append(dict(zip(record.keys(),record)))
+
+        return field_type_records
+
+
     ## Get_Field_Records (Function)
     #
     # Returns the list of fields corresponding to a given uid
         field_column = sqla.Column(**field_column_args)
         self.assertIn(field_column,field_table_columns)
         pass
-