295 lines
8.4 KiB
Python
295 lines
8.4 KiB
Python
# loops.type
|
|
|
|
""" Type management stuff.
|
|
"""
|
|
|
|
from zope import component, schema
|
|
from zope.component import adapts
|
|
from zope.interface import implementer
|
|
from zope.cachedescriptors.property import Lazy
|
|
from zope.dottedname.resolve import resolve
|
|
from zope.security.proxy import removeSecurityProxy
|
|
from zope.traversing.api import getName, getPath
|
|
|
|
from cybertools.typology.type import BaseType, TypeManager
|
|
from cybertools.typology.interfaces import ITypeManager
|
|
from loops.interfaces import ILoopsObject, IConcept, IResource
|
|
from loops.interfaces import ITypeConcept
|
|
from loops.interfaces import IOptions
|
|
from loops.interfaces import IResourceAdapter, IFile, IExternalFile, IImage
|
|
from loops.interfaces import ITextDocument, INote
|
|
from loops.common import adapted
|
|
from loops.concept import Concept
|
|
from loops.resource import Resource, Document, MediaAsset
|
|
from loops.common import AdapterBase
|
|
|
|
|
|
class LoopsType(BaseType):
|
|
|
|
adapts(ILoopsObject)
|
|
|
|
factoryMapping = dict(concept=Concept, resource=Resource)
|
|
#document=Document)
|
|
containerMapping = dict(concept='concepts', resource='resources')
|
|
|
|
isForeignReference = False
|
|
|
|
@Lazy
|
|
def title(self):
|
|
tp = self.typeProvider
|
|
title = tp is None and u'Unknown Type' or tp.title
|
|
if self.isForeignReference:
|
|
title += (' (Site: %s)' % getName(self.root))
|
|
return title
|
|
|
|
@Lazy
|
|
def token(self):
|
|
tp = self.typeProvider
|
|
return tp is None and '.unknown' or self.root.getLoopsUri(tp)
|
|
|
|
@Lazy
|
|
def tokenForSearch(self):
|
|
tp = self.typeProvider
|
|
typeName = tp is None and 'unknown' or str(getName(tp))
|
|
if self.isForeignReference:
|
|
root = getPath(self.root)
|
|
else:
|
|
root = 'loops'
|
|
return ':'.join((root, self.qualifiers[0], typeName,))
|
|
|
|
@Lazy
|
|
def typeInterface(self):
|
|
adapter = component.queryAdapter(self.typeProvider, ITypeConcept)
|
|
if adapter is not None:
|
|
return removeSecurityProxy(adapter.typeInterface)
|
|
else:
|
|
if self.typeProvider is self.typeConcept:
|
|
return ITypeConcept # typeConcept always is a type concept
|
|
return None
|
|
|
|
@Lazy
|
|
def qualifiers(self):
|
|
ti = self.typeInterface
|
|
if ti is None or not issubclass(ti, IResourceAdapter):
|
|
qu = ['concept',]
|
|
else:
|
|
qu = ['resource',]
|
|
# check typeProvider for additional qualifiers:
|
|
if self.typeProvider in (self.typeConcept, self.predicateType,):
|
|
qu.append('system')
|
|
addQualifiers = self.optionsDict.get('qualifier')
|
|
if addQualifiers:
|
|
qu.extend(addQualifiers.split(','))
|
|
return tuple(qu)
|
|
|
|
@Lazy
|
|
def factory(self):
|
|
ti = self.typeInterface
|
|
return self.factoryMapping.get(self.qualifiers[0], Concept)
|
|
|
|
@Lazy
|
|
def defaultContainer(self):
|
|
if self.typeProvider:
|
|
cont = ITypeConcept(self.typeProvider).conceptManager
|
|
if cont and cont in self.root:
|
|
return self.root[cont]
|
|
return self.root[self.containerMapping.get(self.qualifiers[0], 'concept')]
|
|
|
|
@Lazy
|
|
def typeProvider(self):
|
|
# TODO: unify this type attribute naming...
|
|
return getattr(self.context, 'resourceType', None)
|
|
|
|
@Lazy
|
|
def options(self):
|
|
tp = self.typeProvider
|
|
return tp and ITypeConcept(tp).options or []
|
|
|
|
@Lazy
|
|
def optionsDict(self):
|
|
return getOptionsDict(self.options)
|
|
|
|
# general infos
|
|
|
|
@Lazy
|
|
def root(self):
|
|
return self.context.getLoopsRoot()
|
|
|
|
@Lazy
|
|
def typeConcept(self):
|
|
return self.root.getConceptManager().getTypeConcept()
|
|
|
|
@Lazy
|
|
def predicateType(self):
|
|
return self.root.getConceptManager().getPredicateType()
|
|
|
|
|
|
class LoopsTypeInfo(LoopsType):
|
|
""" The type info class used by the type manager for listing types.
|
|
"""
|
|
|
|
def __init__(self, typeProvider):
|
|
self.typeProvider = self.context = typeProvider
|
|
|
|
|
|
class ConceptType(LoopsType):
|
|
""" The IType adapter for concept objects.
|
|
Probably obsolete because all real stuff has gone to LoopsType.
|
|
"""
|
|
|
|
adapts(IConcept)
|
|
|
|
@Lazy
|
|
def typeProvider(self):
|
|
return self.context.conceptType
|
|
|
|
|
|
class ConceptTypeInfo(LoopsTypeInfo):
|
|
""" The type info class used by the type manager for listing types.
|
|
Probably obsolete because all real stuff has gone to LoopsTypeInfo.
|
|
"""
|
|
|
|
|
|
class ResourceType(LoopsType):
|
|
""" The 'old-style' resource type - different classes (Document, MediaAsset)
|
|
per type. Are replaced by new style types that are governed by
|
|
type concepts as is already the case for concepts.
|
|
"""
|
|
|
|
typeTitles = {}
|
|
|
|
typeInterface = None
|
|
qualifiers = ('resource',)
|
|
typeProvider = None
|
|
|
|
@Lazy
|
|
def title(self):
|
|
cn = self.className
|
|
return self.typeTitles.get(cn, unicode(cn))
|
|
|
|
@Lazy
|
|
def token(self):
|
|
return '.'.join((self.factory.__module__, self.className))
|
|
|
|
@Lazy
|
|
def tokenForSearch(self):
|
|
cn = self.className
|
|
return ':'.join(('loops:resource', cn.lower(),))
|
|
|
|
@Lazy
|
|
def defaultContainer(self):
|
|
return self.root.getResourceManager()
|
|
|
|
@Lazy
|
|
def factory(self):
|
|
return self.context.__class__
|
|
|
|
@Lazy
|
|
def className(self):
|
|
return self.factory.__name__
|
|
|
|
|
|
class ResourceTypeInfo(ResourceType):
|
|
|
|
def __init__(self, context, factory):
|
|
self.context = context
|
|
self.factory = factory
|
|
|
|
|
|
class LoopsTypeManager(TypeManager):
|
|
|
|
adapts(ILoopsObject)
|
|
|
|
def __init__(self, context):
|
|
self.context = context.getLoopsRoot()
|
|
|
|
def getType(self, token):
|
|
if token.startswith('.loops'):
|
|
return ConceptTypeInfo(self.context.loopsTraverse(token))
|
|
return ResourceTypeInfo(self.context, resolve(token))
|
|
|
|
@property
|
|
def types(self):
|
|
return self.conceptTypes()
|
|
#return self.conceptTypes() + self.resourceTypes()
|
|
|
|
def listTypes(self, include=None, exclude=None):
|
|
for t in self.types:
|
|
if include and not [q for q in t.qualifiers if q in include]:
|
|
continue
|
|
if exclude and [q for q in t.qualifiers if q in exclude]:
|
|
continue
|
|
yield t
|
|
|
|
def conceptTypes(self):
|
|
cm = self.context.getConceptManager()
|
|
to = cm.getTypeConcept()
|
|
tp = cm.getTypePredicate()
|
|
if to is None or tp is None:
|
|
return ()
|
|
result = to.getChildren([tp])
|
|
if to not in result:
|
|
result.append(to)
|
|
return tuple([ConceptTypeInfo(c) for c in result])
|
|
|
|
def resourceTypes(self):
|
|
return tuple([ResourceTypeInfo(self.context, cls)
|
|
for cls in (Document,)])
|
|
#for cls in (Document, MediaAsset)])
|
|
|
|
|
|
@implementer(ITypeConcept)
|
|
class TypeConcept(AdapterBase):
|
|
""" typeInterface adapter for concepts of type 'type'.
|
|
"""
|
|
|
|
_contextAttributes = list(ITypeConcept) + list(IConcept)
|
|
|
|
def getTypeInterface(self):
|
|
ti = getattr(self.context, '_typeInterface', None)
|
|
if ti is None:
|
|
conceptType = self.context
|
|
if conceptType == conceptType.getLoopsRoot().getConceptManager().getTypeConcept():
|
|
return ITypeConcept
|
|
return removeSecurityProxy(ti)
|
|
def setTypeInterface(self, ifc):
|
|
self.context._typeInterface = ifc
|
|
typeInterface = property(getTypeInterface, setTypeInterface)
|
|
|
|
def getOptions(self):
|
|
return getattr(self.context, '_options', [])
|
|
def setOptions(self, value):
|
|
self.context._options = value
|
|
options = property(getOptions, setOptions)
|
|
|
|
@property
|
|
def typeInstances(self):
|
|
tp = self.context.getConceptManager().getTypePredicate()
|
|
return [adapted(c) for c in self.context.getChildren([tp])]
|
|
|
|
|
|
@implementer(schema.interfaces.IIterableSource)
|
|
class TypeInterfaceSourceList(object):
|
|
|
|
typeInterfaces = (ITypeConcept, IFile, IExternalFile, ITextDocument, INote,
|
|
IOptions)
|
|
|
|
def __init__(self, context):
|
|
self.context = context
|
|
|
|
def __iter__(self):
|
|
return iter(self.typeInterfaces)
|
|
|
|
def __len__(self):
|
|
return len(self.typeInterfaces)
|
|
|
|
|
|
def getOptionsDict(options):
|
|
result = {'default': []}
|
|
for opt in options:
|
|
if ':' in opt:
|
|
key, value = opt.split(':', 1)
|
|
result[key.strip()] = value.strip()
|
|
else:
|
|
result['default'].append(opt.strip())
|
|
return result
|