def map_field_attr(table_name, field_identifier, column_type): assert(field_identifier != None) if not field_exists(table_name, field_identifier): # Create new Field new_column = Column(field_identifier, column_type) table = setobject_table_registry.lookup_by_table(table_name) new_column.create(table) # re-map setobject type map_tables(exclude_sys_tables=True)
def map_computed_properties(cls): cls.sa_map_dispose() table_name = cls.get_table_name() table_type = setobject_table_registry.lookup_by_table(table_name) if not hasattr(cls, 'mapper_properties'): raise Exception("Can't map without mapping properties. Ensure that they are " \ "created beforehand with compute_mapper_properties." ) orm.mapper(cls, table_type, properties=cls.mapper_properties, )
def __setattr__(self, name, value): super(Dropdown, self).__setattr__(name, value) if name == 'linkage': if self.plan_identifier != None and value != None: # Get the table identifier from our plan identifier and set it as the linkage's target class table = setobject_table_registry.lookup_by_table('p2_model') plan = getUtility(IDbUtility).engine.execute(table.select(table.c.plan_identifier == self.plan_identifier)).first() plan_type = plan['so_type'] table_identifier = setobject_type_registry.lookup(plan_type).get_table_name() oldtargetclass = None try: oldtargetclass = self.linkage.target_classname except AttributeError: pass if oldtargetclass == None or oldtargetclass == "": self.linkage.target_classname = table_identifier
def orm_mapping(event=None): # Register table type for grokked ModelBase classes registered = [] for setobject_type in setobject_type_registry.values(): class_name = setobject_type.__name__ table_name = setobject_type.get_table_name() # Create SA table type if setobject_table_registry.get_by_table(table_name) == None: table_type = Table(table_name, metadata, autoload=True) else: table_type = setobject_table_registry.lookup_by_table(table_name) # And register it. setobject_table_registry.register_type(class_name, table_name, table_type) registered.append(class_name) # register all the non-grokked, remaining tables (e.g. user tables) register_remaining_tables(registered) map_tables()
def compute_orm_properties(self, THIS_IS_A_DIRTY_HACK_PROPERTIES_DICT): mappedsotype = setobject_type_registry.lookup(self.target_model.klass) xref_table_class = None sourcetable = setobject_table_registry.lookup_by_class(self.source_model.klass) targettable = setobject_table_registry.lookup_by_class(self.target_model.klass) if self.cardinality.id == 'MANY_TO_ONE' or \ self.cardinality.id == 'ONE(FK)_TO_ONE': # take primary key on our side primaryfk = getattr(sourcetable.c, self.relation.foreignkeycol) primaryidentifier = getattr(targettable.c, mappedsotype.get_primary_key_attr_name()) primaryjoin = (primaryfk == primaryidentifier) secondaryjoin = None elif self.cardinality.id == 'ONE_TO_MANY' or \ self.cardinality.id == 'ONE_TO_ONE(FK)': # take primary key on other side primaryfk = getattr(targettable.c, self.relation.foreignkeycol) primaryidentifier = getattr( sourcetable.c, setobject_type_registry.lookup(self.source_model.klass).get_primary_key_attr_name() ) primaryjoin = (primaryfk == primaryidentifier) secondaryjoin = None elif self.cardinality.id == 'MANY_TO_MANY': # xref! we actually need two clauses here. # Obtain table class: xref_table_class = setobject_table_registry.get_by_table(self.relation.xref_table) if xref_table_class is None: # Class is not mapped (probably not having a primary key or something like that) -> autoload xref_table_class = Table(self.relation.xref_table, metadata, autoload=True, useexisting=True, autoload_with=getUtility(IDbUtility).engine) # Compose two join clauses primaryjoin = (cls.get_primary_key_column() == getattr(xref_table_class.c, self.relation.foreignkeycol)) secondaryjoin = (mappedsotype.get_primary_key_column() == getattr(xref_table_class.c, self.relation.foreignkeycol2)) # add the obtained setobject to our mapped properties if self.cardinality.id == 'MANY_TO_ONE': # This mapping should really not happen here and now. # Instead, the linkage MUST be persisted into # table p2_linkage at save time! THIS_IS_A_DIRTY_HACK_PROPERTIES_DICT[self.attr_name] = orm.relation( mappedsotype, uselist=False, cascade=self.cascade, back_populates=self.back_populates, primaryjoin=primaryjoin, post_update=self.post_update ) relationarguments = { 'uselist' : False, 'cascade' : self.cascade, 'back_populates' : self.back_populates, 'primaryjoin' : primaryjoin, 'post_update' : self.post_update } else: # the other side has the foreign key, store things as a collection order_by = None collection_class = None # This is a special case for the spans as they should not be mapped as ordinary # dictionary, but rather as an orderable dictionary. This is necessary to retain the insert order # as a ordinary dict isn't ordered. Consider this to be implemented in a more generic way if this # use case is occuring for user relations as well. if self.attr_name == 'spans' and self.source_model.klass == 'WidgetType': collection_class=SpanCollectionClass span_table = setobject_table_registry.lookup_by_table('p2_span') order_by=span_table.c.order # This is another special case to ensure the widgets being tab ordered if self.attr_name == 'widgets' and self.source_model.klass == 'FormType': collection_class = WidgetCollectionClass widget_table = setobject_table_registry.lookup_by_table('p2_widget') order_by=widget_table.c.tab_order # Get collection class if collection_class == None: if self.ref_key is None: collection_class = column_mapped_collection(mappedsotype.get_primary_key_column()) else: mapped_column = mappedsotype.get_column(self.ref_key) collection_class = column_mapped_collection(mapped_column) # Compute arguments: relationarguments = { 'back_populates' : self.back_populates, 'collection_class' : collection_class, 'uselist' : True, 'primaryjoin': primaryjoin, 'cascade' : self.cascade, 'post_update' : self.post_update } if order_by is not None: relationarguments['order_by'] = order_by # Set xref table if we got one if xref_table_class is not None: relationarguments['secondary'] = xref_table_class if secondaryjoin is not None: relationarguments['secondaryjoin'] = secondaryjoin return relationarguments
def get_table_class(cls): return setobject_table_registry.lookup_by_table(cls.get_table_name())
def do(self, plan, searchterm, group, page, resultsperpage, uservars=[]): """ Do a search on the plan based on a generic search term and return the results. The results will also be associated with information about which fields actually matched the search query and whether there is a next page to the current one. Please note this implementation is most likely SLOW and could need optimization or replacement at some point. """ dbutility = getUtility(IDbUtility) # change searchterm into LIKE compatible syntax searchterm = self.replaceoperators(searchterm) # list to hold the search values/columns we collect from the widgets searchvalues = [] # collect all columns based on the widgets on the form and their mapping for form in plan.forms.itervalues(): for widget in form.widgets.itervalues(): if widget.widget_type == 'relation' or \ widget.widget_type == 'fileupload' or \ widget.widget_type == 'dropdown': continue for span in widget.spans.itervalues(): if hasattr(span, 'attr_name') and span.attr_name != None: # We got a new column to examine. if span.attr_name != 'span_value' and len(span.attr_name) > 0: self.addsearchvalue(searchvalues, span.attr_name, widget.widget_identifier, form.form_identifier) # do we have some columns to search through? #if len(searchvalues) <= 0: # return {'resultset' : None, 'searchfields' : None, 'nextpage': False} # nothing to search for! # get the table class object tableclass = setobject_table_registry.lookup_by_table(plan.table_identifier) # lists for composing the conditions/columns used in our query conditions = [] columns = [] # we always want to have the primary key column in our results klass = setobject_type_registry.lookup(plan.klass) columns.append(getattr(tableclass.c, klass.get_primary_key_attr_name())) # compose the search conditions based on the avilable input fields for value in searchvalues: if searchterm != '%': condition = getattr(tableclass.c, value['field']).like(searchterm, escape='\\') else: condition1 = getattr(tableclass.c, value['field']).like(searchterm, escape='\\') condition2 = (getattr(tableclass.c, value['field']) == None) condition = or_(condition1, condition2) conditions.append(condition) columns.append(getattr(tableclass.c, value['field'])) columns.append(condition.label("_field_matched_" + value['field'])) # compose our query if len(conditions) > 0: queryobj = select(columns).where(or_(*conditions)).offset((int(page)-1) * resultsperpage).limit(resultsperpage+1) else: queryobj = select(columns).offset((int(page)-1) * resultsperpage).limit(resultsperpage+1) # See if there is a next page to this one gotnextpage = False resultarray = [] results = queryobj.execute() for result in results: if len(resultarray) < resultsperpage: resultarray.append(result) else: gotnextpage = True return {'resultset' : resultarray, 'searchfields' : searchvalues, 'nextpage' : gotnextpage}