from sqlalchemy.ext.declarative import declarative_base
from sfa.util.sfalogging import logger
+from sfa.util.sfatime import utcparse, datetime_to_string
from sfa.util.xml import XML
from sfa.trust.gid import GID
if isinstance(v, StringTypes) and v.lower() in ['true']: v=True
if isinstance(v, StringTypes) and v.lower() in ['false']: v=False
setattr(self,k,v)
-
+
+ def validate_datetime (self, key, incoming):
+ if isinstance (incoming, datetime): return incoming
+ elif isinstance (incoming, (int,float)):return datetime.fromtimestamp (incoming)
+
# in addition we provide convenience for converting to and from xml records
# for this purpose only, we need the subclasses to define 'fields' as either
# a list or a dictionary
xml_record.parse_dict (input_dict)
return xml_record.toxml()
- def dump(self, dump_parents=False):
- for key in self.fields:
- if key == 'gid' and self.gid:
- gid = GID(string=self.gid)
- print " %s:" % key
- gid.dump(8, dump_parents)
- elif getattr(self,key,None):
- print " %s: %s" % (key, getattr(self,key))
+ def dump(self, format=None, dump_parents=False):
+ if not format:
+ format = 'text'
+ else:
+ format = format.lower()
+ if format == 'text':
+ self.dump_text(dump_parents)
+ elif format == 'xml':
+ print self.save_to_string()
+ elif format == 'simple':
+ print self.dump_simple()
+ else:
+ raise Exception, "Invalid format %s" % format
+
+ def dump_text(self, dump_parents=False):
+ # print core fields in this order
+ core_fields = [ 'hrn', 'type', 'authority', 'date_created', 'last_updated', 'gid', ]
+ print "".join(['=' for i in range(40)])
+ print "RECORD"
+ print " hrn:", self.hrn
+ print " type:", self.type
+ print " authority:", self.authority
+ date_created = utcparse(datetime_to_string(self.date_created))
+ print " date created:", date_created
+ last_updated = utcparse(datetime_to_string(self.last_updated))
+ print " last updated:", last_updated
+ print " gid:"
+ print self.get_gid_object().dump_string(8, dump_parents)
+
+ # print remaining fields
+ for attrib_name in dir(self):
+ attrib = getattr(self, attrib_name)
+ # skip internals
+ if attrib_name.startswith('_'): continue
+ # skip core fields
+ if attrib_name in core_fields: continue
+ # skip callables
+ if callable (attrib): continue
+ print " %s: %s" % (attrib_name, attrib)
+ def dump_simple(self):
+ return "%s"%self
+
# # only intended for debugging
# def inspect (self, logger, message=""):
# logger.info("%s -- Inspecting AlchemyObj -- attrs"%message)
elif isinstance(gid, StringTypes): return gid
else: return gid.save_to_string(save_parents=True)
+ @validates ('date_created')
+ def validate_date_created (self, key, incoming): return self.validate_datetime (key, incoming)
+
+ @validates ('last_updated')
+ def validate_last_updated (self, key, incoming): return self.validate_datetime (key, incoming)
+
# xxx - there might be smarter ways to handle get/set'ing gid using validation hooks
def get_gid_object (self):
if not self.gid: return None
def __repr__ (self):
return RegRecord.__repr__(self).replace("Record","Authority")
+####################
+# slice x user (researchers) association
+slice_researcher_table = \
+ Table ( 'slice_researcher', Base.metadata,
+ Column ('slice_id', Integer, ForeignKey ('records.record_id'), primary_key=True),
+ Column ('researcher_id', Integer, ForeignKey ('records.record_id'), primary_key=True),
+ )
+
####################
class RegSlice (RegRecord):
__tablename__ = 'slices'
__mapper_args__ = { 'polymorphic_identity' : 'slice' }
record_id = Column (Integer, ForeignKey ("records.record_id"), primary_key=True)
-
+ #### extensions come here
+ reg_researchers = relationship \
+ ('RegUser',
+ secondary=slice_researcher_table,
+ primaryjoin=RegRecord.record_id==slice_researcher_table.c.slice_id,
+ secondaryjoin=RegRecord.record_id==slice_researcher_table.c.researcher_id,
+ backref="reg_slices_as_researcher")
+
def __init__ (self, **kwds):
if 'type' not in kwds: kwds['type']='slice'
RegRecord.__init__(self, **kwds)
# these objects will have type='user' in the records table
__mapper_args__ = { 'polymorphic_identity' : 'user' }
record_id = Column (Integer, ForeignKey ("records.record_id"), primary_key=True)
+ #### extensions come here
email = Column ('email', String)
# can't use name 'keys' here because when loading from xml we're getting
# a 'keys' tag, and assigning a list of strings in a reference column like this crashes
- reg_keys = relationship ('RegKey', backref='reg_user')
+ reg_keys = relationship \
+ ('RegKey', backref='reg_user',
+ cascade="all, delete, delete-orphan")
# so we can use RegUser (email=.., hrn=..) and the like
def __init__ (self, **kwds):
assert '@' in address
return address
- # xxx this might be temporary
- def normalize_xml (self):
- if hasattr(self,'keys'): self.reg_keys = [ RegKey (key) for key in self.keys ]
-
####################
# xxx tocheck : not sure about eager loading of this one
# meaning, when querying the whole records, we expect there should
git://git.onelab.eu / sfa.git / blobdiff