source: mauRepo/MolesManager/trunk/cedaMoles/MolesManager/views/moles2gui/__init__.py @ 8537

from json.encoder import JSONEncoder
from json import loads
import re
import logging
from abc import abstractmethod
from ea_model.moles3_4.utilities.mo_organisation import MO_Organisation
from ea_model.moles3_4.utilities.mo_individual import MO_Individual
from cedaMoles.MolesManager.djencoder import escapeForJSON
import operator
import inspect
from cedaMoles.libs.epb import isPrimitive

"""
    From now on we define:
    - cedaObject any instances or class defined in from the CedaMoles3 model
    - jsonObject any json representation generated by the CedaMolesGuiAdapter.encode method
"""

_encodeMapper = {'ea_model.iso_19115_2006_metadata_corrigendum.\
extent_information.ex_geographicboundingbox.EX_GeographicBoundingBox':
                    ('cedaMoles.MolesManager.views.moles2gui.ex.geographic_extent', 
                     'GeographicExtent'),
                 'ea_model.iso_19115_2006_metadata_corrigendum.\
reference_system_information.md_identifier.MD_Identifier':
                    ('cedaMoles.MolesManager.views.moles2gui.md.identifier', 
                     'Identifier'),                 
                 'ea_model.iso_19115_2006_metadata_corrigendum.\
citation_and_responsible_party_information.ci_citation.CI_Citation': 
                    ('cedaMoles.MolesManager.views.moles2gui.ci.citation', 'Citation'),                 
                 'ea_model.iso_19115_2006_metadata_corrigendum.\
citation_and_responsible_party_information.ci_date.CI_Date': 
                    ('cedaMoles.MolesManager.views.moles2gui.ci.date', 'Date'),                    
                 'ea_model.iso_19108_2006_temporal_schema.temporal_objects.\
tm_instant.TM_Instant': 
                    ('cedaMoles.MolesManager.views.moles2gui.om.instant', 'Instant'),
                 'ea_model.iso_19108_2006_temporal_schema.temporal_objects.\
tm_period.TM_Period': 
                    ('cedaMoles.MolesManager.views.moles2gui.om.period', 'Period'),                    
                 'ea_model.moles3_4.utilities.mo_organisation.MO_Organisation': 
                    ('cedaMoles.MolesManager.views.moles2gui.mo.party', 'Party'),
                 'ea_model.moles3_4.utilities.mo_individual.MO_Individual': 
                    ('cedaMoles.MolesManager.views.moles2gui.mo.party', 'Party'),
                 'ea_model.moles3_4.utilities.mo_responsiblepartyinfo.\
MO_ResponsiblePartyInfo': 
                    ('cedaMoles.MolesManager.views.moles2gui.mo.responsiblePartyInfo', \
                     'ResponsiblePartyInfo'),
                 'ea_model.ceda_metadatamodel.ceda_observation.\
ceda_observation.CEDA_Observation': 
                    ('cedaMoles.MolesManager.views.moles2gui.ceda.observation', \
                     'Observation')                    
                 }

def encodeCedaMoles2Json(cedaObj):
    adapter = _encodeCedaMoles2Adapter(cedaObj);
    if adapter is not None:
        return _Moles2guiEncoder().encode(adapter)
    
    # Then is a non mapped class
    return None

def decodeJson2CedaMoles(json= None, moles3EPB = None, cedaMoleObj = None):
    """
        Updates the given a cedaObject using a jsonObject object.
        If `moles3EPB` is given it overrride the value from `cedaMoleObj`
        
        **Parameters**
            * json: a json string
            * moles3EPB: an epb instance to retrieve the cedaObject by the json string
            * cedaMoleObj: a cedaObject
        
        **Raise**
            * Exception both `moles3EPB` and `cedaMoleObj` are `None`
    """    
    if (cedaMoleObj is None or moles3EPB is None) and json is None:
        raise Exception("No sufficient parameters to exploit the request")
       
    adapter = _decodeJson2Adapter(json)       
     
    if adapter == json:
        raise Exception("json string %s cannot be loaded") % json
    
    if cedaMoleObj is None:
        cedaMoleObj = moles3EPB.search(dynamicallyLoadClass(adapter._module, adapter._clazz), adapter.id).first()
    if cedaMoleObj is None:
        return cedaMoleObj
        
    adapter.decode(cedaMoleObj)
    return cedaMoleObj

def dynamicallyLoadClass(modulePath, className):
    mod = __import__(modulePath, fromlist=[className])
    return getattr(mod, className)

def dictByID(objList):
    """
        **Deprecated**
        Returns a dictionary where the key is the object id
    """    
    ret = {}
    for item in objList:
        ret[item.id] = item
    return ret

class CedaMolesGuiAdapter(object):
    internal = ['_module', '_clazz', '_adapter_module', '_adapter_clazz']
    mapper = {}
    acceptedTypes = []    

    def __init__(self):
        for item in self.mapper.items():
            setattr(self, item[0], None)

    @classmethod
    def _cedaObjToAdapterMapping(cls, instance, cedaObject):
        if type(cedaObject) in cls.acceptedTypes:       
            for item in cls.mapper.items():
                setattr(instance, item[0], getData(cedaObject, item[1]))

    @classmethod
    def _adapterToCedaObjMapping(cls, instance, cedaObj):
        for item in cls.mapper.items():            
            _setData(cedaObj, item[1], getattr(instance, item[0]))

    def postCedaObjToAdapterMapping(self, cedaObject):
        """
        Refines the mapping done using the internal `mapper`.
        If some mapping are possible only at a later moment override this method
        
        **Parameters**
                * cedaObj: the Ceda object instance which has to be mapped to the adapter
        """
        pass
    
    def postAdapterToCedaObjMapping(self, cedaObject):
        """
        Refines the mapping done using the internal `mapper`.
        If some mapping are possible only at a later moment override this method
        
        **Parameters**
                * cedaObject: the Ceda object instance which has to be mapped from the adapter
        """
    pass

    @classmethod
    def cedaObjToAdapter(cls, cedaObject):
        """
        Injects a new attribute in a CedaMolesGuiAdapter. Using the 2 component `attributeMap` tuple,
        the attribute has  
        - name as attributeMap[0] 
        - attributeMap as the attribute in `cedaObject` speficied by attributeMap[1]
           
        **Parameters**
            * cedaObject: a Ceda object instance 
        """
        adapter = cls()
        if type(cedaObject) not in cls.acceptedTypes:
            raise Exception ("Not accepted type mapping")
        
        if cedaObject is not None:
            setattr(adapter, 'id', None)
            if hasattr(cedaObject, 'id'):
                setattr(adapter, 'id', cedaObject.id)
                
            setattr(adapter, '_module', cedaObject.__module__)        
            setattr(adapter, '_clazz', cedaObject.__class__.__name__)        
        setattr(adapter, '_adapter_module', adapter.__module__)        
        setattr(adapter, '_adapter_clazz', adapter.__class__.__name__)
        cls._cedaObjToAdapterMapping(adapter, cedaObject)
        adapter.postCedaObjToAdapterMapping(cedaObject)
        
        return adapter

    def decode(self, cedaObject):       
        if type(cedaObject) not in self.acceptedTypes:
            raise Exception ("Not accepted type mapping")

        self._adapterToCedaObjMapping(self, cedaObject)
        self.postAdapterToCedaObjMapping(cedaObject)

class _Moles2guiEncoder(JSONEncoder):

    log = logging.getLogger('DJEncoder')
    
    def __init__(self):
        self.__markers = {}
        super(_Moles2guiEncoder, self).__init__()
        self.__pattern = re.compile('\D\D__*')
        self.__pattern2 = re.compile('\A\w+__id\Z')
        

    def default(self, obj):        
        # Convert objects to a dictionary of their representation
        d = {}
    
        if not hasattr(obj, "__dict__"):
            return d
    
        for key in obj.__dict__.keys():
            if key in CedaMolesGuiAdapter.internal or not (key.startswith("_") or self.__pattern.match(key) or self.__pattern2.match(key)):
                d.update({key: getattr(obj, key)})
        
        for key, value in d.items():
            if value is not None and id(value) in self.__markers and not isinstance(value, str) and not isinstance(value, int):
                continue
            else:
                self.__markers[id(value)] = value
                if isinstance(value, str) or isinstance(value, unicode):                    
                    self.__markers[id(value)] = escapeForJSON(value)
                else:
                    self.__markers[id(value)] = value
        return d

def getData(obj, attrString):
    """
    Returns an attribute value from an object. It is similar to getattr() function
    but in this case the `attr` parameter express a deeper argument than `obj.paramName`.
    For instance, call drillData(obj, 'a.b.c[1].d') is aquivalent to call
    obj.a.b.c[1].d

    **Parameters**         
            * obj: its an the instance from which the attribute is required
            * attrString: an attributes dot separated string expression 
    """
    if attrString is not None and isinstance(attrString, str):
        return _drillData(obj, attrString.split('.'))

def _setDataToAdapter(obj, attrString, value):
    if attrString is None or not isinstance(attrString, str) or value is None:
        return

    ret = None
    if isinstance(value, list):
        ret = []
        for item in value:
            ret.append(_decodeJson2Adapter(item))
    else:
        ret = _decodeJson2Adapter(value)        
    setattr(obj, attrString, ret)

def _setData(obj, attrString, value):
    if attrString is None or not isinstance(attrString, str):
        return
    
    attrOwner = obj
    attrName =  attrString
    
    items = attrString.split('.')             
    if len(items[:-1]) > 0:
        attrOwner = _drillData(obj, items[:-1], toAdapter = False)
        attrName =  items[-1:][0].partition('[')[0]             

    if attrOwner is not None and hasattr(attrOwner, attrName):
        attr = getattr(attrOwner, attrName)
        if isinstance(attr, list):
            #if len(value) == 0:
            #    del attr[:]
            
            if len(value) > 0 and not isinstance(value[0], CedaMolesGuiAdapter):
                del attr[:]
                if isinstance(value, list):
                    attr.extend(value)
                else:
                    attr.append(value)
            else:    
                sorted(attr, key = operator.attrgetter('id'))
                sorted(value, key = operator.attrgetter('id'))
                for item in attr:
                    for valueItem in value:
                        if item.id == valueItem.id:
                            valueItem.decode(item)                        
        else:
            setattr(attrOwner, attrName, value)        
    
def _drillData(obj, attr, toAdapter = True):
    """
        When the method is used by the cedaObjToAdapter the `toAdapter=True` condition 
        guarantees that an immediate conversion of the mapped classes is done.
        When the method is used by the adapterTocedaObj the `toAdapter=False` condition 
        guarantees that no 'cedaObjToAdapter' conversion is done.  
    """
    if attr is None or len(attr) == 0:
        return None
    
    item = attr[0]
    newobj = None
            
    # is an array?
    if re.search("\[\d+\]", item) is not None:
        index = int(re.search("\[\d+\]", item).group(0).replace('[', '').replace(']', ''))
        parName = item.partition('[')[0]
        if hasattr(obj, parName) and isinstance(getattr(obj, parName), list):
            objattr = getattr(obj, parName)
            if index < len(objattr):
                newobj = objattr[index]
            else:
                return None
        else:
            raise Exception ("Parameter call exception. Param:%s" % item) 
        
    # is a dictionary?
    elif re.search("\['\w+\'\]", item) is not None:            
        key = re.search("\['\w+\'\]", item).group(0).replace('[\'', '').replace('\']', '')
        parName = item.partition('[')[0]        
        if hasattr(obj, parName) and isinstance(getattr(obj, parName), dict):
            objattr = getattr(obj, parName)
        if objattr.has_key(key):
            newobj = objattr[key]
        
    # is just a simple attribute
    else:
        if hasattr(obj, item):
            newobj = getattr(obj, item)
    
    #is the last attr's item? 
    if len(attr) > 1:        
        return _drillData(newobj, attr[1:], toAdapter)
    
    if not toAdapter:
        return newobj

    if isinstance(newobj, list):
        ret = []
        for item in newobj:                
            ret.append(_encodeCedaMoles2Adapter(item))
        return ret
    else:
        return _encodeCedaMoles2Adapter(newobj)              
    
def _encodeCedaMoles2Adapter(cedaObj):
    if isPrimitive(cedaObj):
        return cedaObj
    
    # Is a mapped class?
    key = "%s.%s" % (cedaObj.__module__, cedaObj.__class__.__name__)
    if _encodeMapper.has_key(key):   
        module, clazz = _encodeMapper[key]
        encoder = dynamicallyLoadClass(module, clazz)
        return encoder.cedaObjToAdapter(cedaObj)

    
    # Then is a non mapped class
    return None

def _decodeJson2Adapter(json):
    decJson = json
    
    if isPrimitive(decJson) and not isinstance(decJson, str):
        return decJson 
    
    if not isinstance(json, dict):
        try:
            decJson = loads(json)
        except:
            return decJson
    
    adapter = dynamicallyLoadClass(decJson['_adapter_module'], decJson['_adapter_clazz'])()
    setattr(adapter, '_module', decJson['_module'])
    setattr(adapter, '_clazz', decJson['_clazz'])
    setattr(adapter, '_adapter_module', decJson['_adapter_module'])
    setattr(adapter, '_adapter_clazz', decJson['_adapter_clazz'])
    setattr(adapter, 'id', decJson['id'])
    for item in adapter.mapper.items():
        _setDataToAdapter(adapter, item[0], decJson[item[0]])
    return adapter

def unicode_to_string(text):
    if isinstance(text, unicode):
        return str(text)
    return text

def hasAttrNotNone(obj, name):
    return hasattr(obj, name) and getattr(obj, name) is not None