def perform(self, args): opts=self.parse_args(args) try: _schema=Schema('config/schema.yaml') _schema.fix_tables() except TypeError: print red('The schema is not defined.') sys.exit(-1) gen=Generator(opts['verbose']) for model_name in _schema.get_tables_list(): print '\n'+bold('Generating {0} model...'.format(model_name)) templates=gen.create_b(model_name, _schema.find_table(model_name)) if opts['dump']: print '\napplication/model/base/{0}Base.py'.format( templates['base'][0]) print templates['base'][1] if templates.get('rel')!=None: for rel in templates['rel']: print '\n\napplication/model/relation/{0}.py'.format( rel[0]) print rel[1] else : gen.write_base_model(templates['base'][0], templates['base'][1]) if templates.get('rel')!=None: for rel in templates['rel']: gen.write_relation(rel[0], rel[1]) print bold('Model {0} created successfully.'.format(model_name))
def perform(self, args): model_name, opts = self.parse_args(args) try: _schema = Schema('config/schema.yaml') _schema.fix_tables() except TypeError: print red('The schema is not defined.') sys.exit(-1) if not check_model(model_name): print red('\n{0} model does not exist at the project schema.\n' \ 'Use model -l or model --list to show a list of available models.'\ .format(model_name if len(model_name) else 'Noname')) sys.exit(0) print '\n' + bold('Generating {0} model...'.format(model_name)) gen = Generator(opts['verbose']) templates = gen.create_b(model_name, _schema.find_table(model_name)) if opts['dump']: print '\napplication/model/base/{0}Base.py'.format( templates['base'][0]) print templates['base'][1] if templates.get('rel') != None: for rel in templates['rel']: print '\n\napplication/model/relation/{0}.py'.format( rel[0]) print rel[1] else: gen.write_base_model(templates['base'][0], templates['base'][1]) if templates.get('rel') != None: for rel in templates['rel']: gen.write_relation(rel[0], rel[1]) print bold('Model created successfully.')
def perform(self, args): model_name, opts=self.parse_args(args) try: _schema=Schema('config/schema.yaml') _schema.fix_tables() except TypeError: print red('The schema is not defined.') sys.exit(-1) if not check_model(model_name): print red('\n{0} model does not exist at the project schema.\n' \ 'Use model -l or model --list to show a list of available models.'\ .format(model_name if len(model_name) else 'Noname')) sys.exit(0) print '\n'+bold('Generating {0} model...'.format(model_name)) gen=Generator(opts['verbose']) templates=gen.create_b(model_name, _schema.find_table(model_name)) if opts['dump']: print '\napplication/model/base/{0}Base.py'.format( templates['base'][0]) print templates['base'][1] if templates.get('rel')!=None: for rel in templates['rel']: print '\n\napplication/model/relation/{0}.py'.format( rel[0]) print rel[1] else : gen.write_base_model(templates['base'][0], templates['base'][1]) if templates.get('rel')!=None: for rel in templates['rel']: gen.write_relation(rel[0], rel[1]) print bold('Model created successfully.')
def model_list(): """Return a list of available models at current schema""" try: _schema = Schema('config/schema.yaml') for table in _schema.get_tables_list(): print brown(table) except TypeError: print red('Schema is not defined.')
def __init__(self, verbose=False): self._verbose = verbose self._schema = Schema('config/schema.yaml') if self._verbose: print bold('Fixing null values on schema...') (success, msg) = self._schema.fix_tables() if not success: raise SchemaException(msg) if self._verbose: print green('Schema fixed!')
def model_list(): """Return a list of available models at current schema""" try: _schema=Schema('config/schema.yaml') for table in _schema.get_tables_list(): print brown(table) except TypeError: print red('Schema is not defined.')
def check_model(model_name): """Checks if a model given by model name exists at the current schema""" if not len(model_name): return False _schema=Schema('config/schema.yaml') if not model_name in _schema.get_tables_list(): return False return True
def check_model(model_name): """Checks if a model given by model name exists at the current schema""" if not len(model_name): return False _schema = Schema('config/schema.yaml') if not model_name in _schema.get_tables_list(): return False return True
def __init__(self): super(Database, self).__init__() self._schema = Schema('config/schema.yaml') try: self._db = create_database(self._schema.get_properties()['uri']) self._initialized = True except: self._initialized = False raise DatabaseException("Database schema is not defined")
class Database(Borg): _db = None _conn = None _schema = None _fixed = False def __init__(self): super(Database, self).__init__() self._schema = Schema('config/schema.yaml') try: self._db = create_database(self._schema.get_properties()['uri']) self._initialized = True except: self._initialized = False raise DatabaseException("Database schema is not defined") def is_valid(self): return self._initialized def get_database(self): return self._db def get_schema(self): if not self._schema.is_fixed(): self._schema.fix_tables() return self._schema def get_connection(self): if self._conn == None: self.connect() return self._conn def connect(self): if self._conn == None: self._conn = self._db.connect() def query(self, data): self._conn.execute(data) self._conn.commit() def create(self, script): drop = script.split('\n')[0] create = ''.join(script.split('\n')[2:]) try: self._conn.execute(drop) except ProgrammingError, e: print 'Drop fail: ', e[0] self._conn.commit() except OperationalError, e: print 'Drop fail: ', e[0] self._conn.commit()
class Database(Borg): _db=None _conn=None _schema=None _fixed=False def __init__(self): super(Database, self).__init__() self._schema=Schema('config/schema.yaml') try: self._db=create_database(self._schema.get_properties()['uri']) self._initialized=True except: self._initialized=False raise DatabaseException("Database schema is not defined") def is_valid(self): return self._initialized def get_database(self): return self._db def get_schema(self): if not self._schema.is_fixed(): self._schema.fix_tables() return self._schema def get_connection(self): if self._conn==None: self.connect() return self._conn def connect(self): if self._conn==None: self._conn=self._db.connect() def query(self, data): self._conn.execute(data) self._conn.commit() def create(self, script): drop=script.split('\n')[0] create=''.join(script.split('\n')[2:]) try: self._conn.execute(drop) except ProgrammingError, e: print 'Drop fail: ', e[0] self._conn.commit() except OperationalError, e: print 'Drop fail: ', e[0] self._conn.commit()
def __init__(self, verbose=False): self._verbose=verbose self._schema=Schema('config/schema.yaml') if self._verbose: print bold('Fixing null values on schema...') (success, msg)=self._schema.fix_tables() if not success: raise SchemaException(msg) if self._verbose: print green('Schema fixed!')
def __init__(self): super(Database, self).__init__() self._schema=Schema('config/schema.yaml') try: self._db=create_database(self._schema.get_properties()['uri']) self._initialized=True except: self._initialized=False raise DatabaseException("Database schema is not defined")
def perform(self, args): opts = self.parse_args(args) try: _schema = Schema('config/schema.yaml') _schema.fix_tables() except TypeError: print red('The schema is not defined.') sys.exit(-1) gen = Generator(opts['verbose']) for model_name in _schema.get_tables_list(): print '\n' + bold('Generating {0} model...'.format(model_name)) templates = gen.create_b(model_name, _schema.find_table(model_name)) if opts['dump']: print '\napplication/model/base/{0}Base.py'.format( templates['base'][0]) print templates['base'][1] if templates.get('rel') != None: for rel in templates['rel']: print '\n\napplication/model/relation/{0}.py'.format( rel[0]) print rel[1] else: gen.write_base_model(templates['base'][0], templates['base'][1]) if templates.get('rel') != None: for rel in templates['rel']: gen.write_relation(rel[0], rel[1]) print bold('Model {0} created successfully.'.format(model_name))
class Generator(object): _schema = None _mgr = TemplateManager() def __init__(self, verbose=False): self._verbose = verbose self._schema = Schema('config/schema.yaml') if self._verbose: print bold('Fixing null values on schema...') (success, msg) = self._schema.fix_tables() if not success: raise SchemaException(msg) if self._verbose: print green('Schema fixed!') def generate_models(self): for table, columns in self._schema.get_tables().iteritems(): mod_name, tpl = self.generate_model_base(table, columns) self.write_base_model(mod_name, tpl) mod_name, tpl = self.generate_model(table, columns) self.write_model(mod_name, tpl) def create_b(self, table, columns): templates = { 'base': self.generate_model_base(table, columns), 'rel': self.generate_many_2_many(table, columns) } return templates def create_m(self, table, columns, path): return {'work': self.generate_model(table, columns, path)} def generate_model(self, table, columns, path): t = self._mgr.get_sys_domain().get_template('tpl/model.evoque') model_name = self._generate_model_name(table) return (model_name, t.evoque( model_name=model_name, module_register_path=path, model_creation_date=datetime.now(), model_file='application/model/{0}'.format(model_name), )) def generate_model_base(self, table, columns): t = self._mgr.get_sys_domain().get_template('tpl/modelbase.evoque') relation = columns.get('_relation') model_name = self._generate_model_name(table) _attributes = [] _relations = [] _model_primary_keys = self._check_composed_keys(columns) cfg = config.ConfigManager().look_at_cur_path() if cfg == None: print red('No goliat configuration file found.') sys.exit(-1) for col in self._schema.reorder_table_fields( self._schema.find_table(table)): if col[0] in [ '_config', '_indexes', '_relation', '_order', '_parent' ]: continue attr_name = col[0] if len(_model_primary_keys): attr_type = self._parse_column(col[1], True) else: attr_type = self._parse_column(col[1]) _attributes.append((attr_name, attr_type)) if relation != None: for field, rel in relation.iteritems(): if rel['type'] == 'one2one': _reference = 'Reference' _attributes.append((field, '{0}({1}_id, "{2}.{3}")' \ .format(_reference, field, self._generate_model_name(\ rel['foreignTable']), rel['foreignKey']))) _relations.append(('application.model.base.{0}Base' \ .format(self._generate_model_name( rel['foreignTable'])), '{0}Base'.format(self._generate_model_name( rel['foreignTable'])))) elif rel['type'] == 'many2one': _reference = 'ReferenceSet' _attributes.append( (field, '{0}'.format('{0}("{1}.{2}", "{3}.{4}")'.format( _reference, self._generate_model_name(table), rel['localKey'], self._generate_model_name(rel['foreignTable']), rel['foreignKey'])))) _relations.append(('application.model.base.{0}Base' \ .format(self._generate_model_name(rel['foreignTable'])), '{0}Base'.format(self._generate_model_name( rel['foreignTable'])))) elif rel['type'] == 'many2many': _reference = 'ReferenceSet' reference = _reference + '(' reference += self._parse_relation(rel, table) reference += ')' _attributes.append(('{0}'.format(field), reference)) #_relations.append(('application.model.base.{0}Base' \ #.format(self._generate_model_name(rel['foreignTable'])), # '{0}Base'.format(self._generate_model_name( # rel['foreignTable'])))) _relations.append(( 'application.model.relation.{0}'.format( self._generate_model_name(table)+\ self._generate_model_name(rel['foreignTable'])), self._generate_model_name(table)+\ self._generate_model_name(rel['foreignTable']) )) reverse = self._schema.find_reverse_reference(table) if reverse != None: reverse_reference = 'ReferenceSet(' reverse_reference += self._parse_relation(reverse, table, True) reverse_reference += ')' _attributes.append( ('{0}'.format(reverse['field']), reverse_reference)) _relations.append(( 'application.model.relation.{0}'.format( self._generate_model_name(reverse['foreignTable'])+\ self._generate_model_name(table)), self._generate_model_name(reverse['foreignTable'])+\ self._generate_model_name(table) )) return (model_name, t.evoque( model_name=model_name, model_creation_date=datetime.now(), model_file='application/model/base/{0}'.format(model_name), model_table='{0}'.format(table), model_primary_keys=_model_primary_keys, attributes=_attributes, relations=_relations)) def generate_many_2_many(self, table, columns): if columns.get('_relation') == None: return None models = [] for field, relation in columns['_relation'].iteritems(): if not self._analyze(relation): raise SchemaException('%s table has an invalid _relation ' \ 'section, please fix it!!!'%(table)) if relation['type'] != 'many2many': continue # Not a m2m relationship t=self._mgr.get_sys_domain().get_template(\ 'tpl/modelrelation.evoque') modelSuffix=''.join([ word.capitalize() \ for word in table.split('_') ]) modelPreffix=''.join([ word.capitalize() \ for word in relation['foreignTable'].split('_') ]) model_name = modelSuffix + modelPreffix _model_primary_keys = self._generate_primary_keys(relation['keys']) _attributes = [] for key in relation['keys']: attr_name = key if type(key) == str else key.keys()[0] attr_type = 'Int()' _attributes.append((attr_name, attr_type)) if relation.get('fields') != None: for field in relation['fields']: for fname, fvalue in field.iteritems(): attr_name = fname attr_type = self._parse_column(fvalue, True) _attributes.append((attr_name, attr_type)) models.append( (model_name, t.evoque(model_name=model_name, model_creation_date=datetime.now(), model_file='application/model/relation/{0}'.format( model_name), model_table='{0}'.format(table + '_' + relation['foreignTable']), model_primary_keys=_model_primary_keys, attributes=_attributes))) return models def write_base_model(self, mod_name, tpl): fp = file('application/model/base/{0}Base.py'.format(mod_name), 'w') fp.write(tpl.encode('utf8')) fp.close() def write_model(self, mod_name, tpl): fp = file('application/model/{0}.py'.format(mod_name), 'w') fp.write(tpl.encode('utf8')) fp.close() def write_relation(self, mod_name, tpl): fp = file('application/model/relation/{0}.py'.format(mod_name), 'w') fp.write(tpl.encode('utf8')) fp.close() def _generate_model_name(self, table): return ''.join([word.capitalize() for word in table.split('_')]) def _check_composed_keys(self, cols): keys = [] for name, col in cols.iteritems(): if col in ['_relation', '_config', '_indexes']: continue if 'primaryKey' in col: keys.append(name) if len(keys) > 1: return self._generate_primary_keys(keys) return '' def _generate_primary_keys(self, keys): _new_keys = [] for key in keys: if type(key) == str: _new_keys.append(key) elif type(key) == dict: _new_keys.append(key.keys()[0]) return '__storm_primary__ = '+','.join([ '"'+k+'"' \ for k in _new_keys ]) def _analyze(self, config): """Analyzes a table _config section""" if config.get('type') == None or config.get('foreignTable') == None: return False return True def _parse_column(self, col, special=False): _primary = 'False' _allow_none = 'True' _default_value = 'Undef' _foreign_keys = False if col.get('type') != None: if col.get('primaryKey') != None and col.get('primaryKey') == True: _primary = 'True' if col.get('required') != None and col.get('required') == True: _allow_none = 'False' if col.get('default') != None: _default_value = col.get('default') if not special: return '{0}(primary={1}, value={2}, allow_none={3})' \ .format(tr(col.get('type')), _primary, _default_value, _allow_none) else: return '{0}(value={1}, allow_none={2})' \ .format(tr(col.get('type')), _default_value, _allow_none) def _parse_relation(self, rel, table, reverse=False): """Parses a model table relation.""" _new_keys = [] for key in rel['keys']: if type(key) == str: _new_keys.append(key) elif type(key) == dict: _new_keys.append(key.keys()[0]) if not reverse: ret = '"{0}.{1}", '.format(self._generate_model_name(table), rel['localKey']) ret+='"{0}.{1}", '.format(self._generate_model_name(table)+\ self._generate_model_name(rel['foreignTable']), _new_keys[0]) ret+='"{0}.{1}", '.format(self._generate_model_name(table)+\ self._generate_model_name(rel['foreignTable']), _new_keys[1]) ret += '"{0}.{1}"'.format( self._generate_model_name(rel['foreignTable']), rel['foreignKey']) else: ret = '"{0}.{1}", '.format(self._generate_model_name(table), rel['localKey']) ret += '"{0}.{1}", '.format( self._generate_model_name(rel['foreignTable']) + self._generate_model_name(table), _new_keys[0]) ret+='"{0}.{1}", '.format(self._generate_model_name( rel['foreignTable'])+\ self._generate_model_name(table), _new_keys[1]) ret += '"{0}.{1}"'.format( self._generate_model_name(rel['foreignTable']), rel['foreignKey']) return ret
def perform(self, args): cfg=self._look_at_cur_path() module_name, opts=self.parse_args(args) if not len(module_name): print self.long_help() sys.exit(-1) try: _schema=Schema('config/schema.yaml') _schema.fix_tables() except TypeError: if opts.get('model')!=None: print red('The schema is not defined.') sys.exit(-1) _module_model_import='' _module_get_schema_model='' if opts.get('path')==None: _module_register_path='"{0}"'.format(module_name.lower()) else: _module_register_path='"{0}"'.format(opts['path']) if opts.get('model')!=None: if not check_model(opts['model']): print red(\ '\n{0} model does not exist at the project schema.\nUse ' \ 'module -l or module --list to show a list of available ' \ 'models.'.format(\ opts['model'] if len(opts['model']) else 'Noname')) sys.exit(0) gen=Generator(opts['verbose']) _use_model=True _model_name=gen._generate_model_name(opts['model']) tmodel=gen.create_m(\ opts['model'], _schema.find_table(opts['model']), _module_register_path) _module_model_import='from application.model.{0} import {1}' \ .format(gen._generate_model_name(opts['model']), gen._generate_model_name(opts['model'])) _module_get_schema_model='''def get_schema_model(self, request, **kwargs): """Return the schema model %s architecture.""" model_schema, model_view = %s.get_model_info() if model_schema == None: return json.dumps({ "success" : False, "error" : "Unable to fetch a schema for model %s" }) return json.dumps({ "success" : True, "model" : model_schema, "view" : model_view })'''%(gen._generate_model_name(opts['model']), gen._generate_model_name(opts['model']), opts['model']) print '\n'+bold('Generating {0} module...'.format(module_name)) mgr=TemplateManager() t=mgr.get_sys_domain().get_template('tpl/module.evoque') module=t.evoque( module_file="application/controller/{0}".format(module_name), module_creation_date=datetime.now(), module_name=module_name, module_model_import=_module_model_import, module_register_path=_module_register_path, module_get_schema_model=_module_get_schema_model, use_model=_use_model, model_name=_model_name ) if opts['dump']: if opts.get('model')!=None: print '\napplication/model/{0}.py'.format(tmodel['work'][0]) print tmodel['work'][1] print '\napplication/controller/{0}.py'.format(module_name) print module else : if opts.get('model')!=None: gen.write_model(tmodel['work'][0], tmodel['work'][1]) fp=file('application/controller/{0}.py'.format(module_name), 'w') fp.write(module.encode('utf8')) fp.close() print bold('Module created successfully.')
class Generator(object): _schema=None _mgr=TemplateManager() def __init__(self, verbose=False): self._verbose=verbose self._schema=Schema('config/schema.yaml') if self._verbose: print bold('Fixing null values on schema...') (success, msg)=self._schema.fix_tables() if not success: raise SchemaException(msg) if self._verbose: print green('Schema fixed!') def generate_models(self): for table, columns in self._schema.get_tables().iteritems(): mod_name, tpl=self.generate_model_base(table, columns) self.write_base_model(mod_name, tpl) mod_name, tpl=self.generate_model(table, columns) self.write_model(mod_name, tpl) def create_b(self, table, columns): templates={ 'base' : self.generate_model_base(table, columns), 'rel' : self.generate_many_2_many(table, columns) } return templates def create_m(self, table, columns, path): return { 'work' : self.generate_model(table, columns, path) } def generate_model(self, table, columns, path): t=self._mgr.get_sys_domain().get_template('tpl/model.evoque') model_name=self._generate_model_name(table) return (model_name, t.evoque( model_name=model_name, module_register_path=path, model_creation_date=datetime.now(), model_file='application/model/{0}'.format(model_name), )) def generate_model_base(self, table, columns): t=self._mgr.get_sys_domain().get_template('tpl/modelbase.evoque') relation=columns.get('_relation') model_name=self._generate_model_name(table) _attributes=[] _relations=[] _model_primary_keys=self._check_composed_keys(columns) cfg=config.ConfigManager().look_at_cur_path() if cfg==None: print red('No goliat configuration file found.') sys.exit(-1) for col in self._schema.reorder_table_fields( self._schema.find_table(table)): if col[0] in [ '_config', '_indexes', '_relation', '_order', '_parent' ]: continue attr_name=col[0] if len(_model_primary_keys): attr_type=self._parse_column(col[1], True) else: attr_type=self._parse_column(col[1]) _attributes.append((attr_name, attr_type)) if relation!=None: for field, rel in relation.iteritems(): if rel['type']=='one2one': _reference='Reference' _attributes.append((field, '{0}({1}_id, "{2}.{3}")' \ .format(_reference, field, self._generate_model_name(\ rel['foreignTable']), rel['foreignKey']))) _relations.append(('application.model.base.{0}Base' \ .format(self._generate_model_name( rel['foreignTable'])), '{0}Base'.format(self._generate_model_name( rel['foreignTable'])))) elif rel['type']=='many2one': _reference='ReferenceSet' _attributes.append((field, '{0}'.format( '{0}("{1}.{2}", "{3}.{4}")'.format( _reference, self._generate_model_name(table), rel['localKey'], self._generate_model_name( rel['foreignTable']), rel['foreignKey'])))) _relations.append(('application.model.base.{0}Base' \ .format(self._generate_model_name(rel['foreignTable'])), '{0}Base'.format(self._generate_model_name( rel['foreignTable'])))) elif rel['type']=='many2many': _reference='ReferenceSet' reference=_reference+'(' reference+=self._parse_relation(rel, table) reference+=')' _attributes.append(('{0}'.format(field), reference)) #_relations.append(('application.model.base.{0}Base' \ #.format(self._generate_model_name(rel['foreignTable'])), # '{0}Base'.format(self._generate_model_name( # rel['foreignTable'])))) _relations.append(( 'application.model.relation.{0}'.format( self._generate_model_name(table)+\ self._generate_model_name(rel['foreignTable'])), self._generate_model_name(table)+\ self._generate_model_name(rel['foreignTable']) )) reverse=self._schema.find_reverse_reference(table) if reverse!=None: reverse_reference='ReferenceSet(' reverse_reference+=self._parse_relation(reverse, table, True) reverse_reference+=')' _attributes.append(('{0}'.format(reverse['field']), reverse_reference)) _relations.append(( 'application.model.relation.{0}'.format( self._generate_model_name(reverse['foreignTable'])+\ self._generate_model_name(table)), self._generate_model_name(reverse['foreignTable'])+\ self._generate_model_name(table) )) return (model_name, t.evoque( model_name=model_name, model_creation_date=datetime.now(), model_file='application/model/base/{0}'.format(model_name), model_table='{0}'.format(table), model_primary_keys=_model_primary_keys, attributes=_attributes, relations=_relations )) def generate_many_2_many(self, table, columns): if columns.get('_relation')==None: return None models=[] for field, relation in columns['_relation'].iteritems(): if not self._analyze(relation): raise SchemaException('%s table has an invalid _relation ' \ 'section, please fix it!!!'%(table)) if relation['type']!='many2many': continue # Not a m2m relationship t=self._mgr.get_sys_domain().get_template(\ 'tpl/modelrelation.evoque') modelSuffix=''.join([ word.capitalize() \ for word in table.split('_') ]) modelPreffix=''.join([ word.capitalize() \ for word in relation['foreignTable'].split('_') ]) model_name=modelSuffix+modelPreffix _model_primary_keys=self._generate_primary_keys(relation['keys']) _attributes=[] for key in relation['keys']: attr_name=key if type(key)==str else key.keys()[0] attr_type='Int()' _attributes.append((attr_name, attr_type)) if relation.get('fields')!=None: for field in relation['fields']: for fname, fvalue in field.iteritems(): attr_name=fname attr_type=self._parse_column(fvalue, True) _attributes.append((attr_name, attr_type)) models.append((model_name, t.evoque( model_name=model_name, model_creation_date=datetime.now(), model_file='application/model/relation/{0}'.format(model_name), model_table='{0}'.format(table+'_'+relation['foreignTable']), model_primary_keys=_model_primary_keys, attributes=_attributes ))) return models def write_base_model(self, mod_name, tpl): fp=file('application/model/base/{0}Base.py'.format(mod_name), 'w') fp.write(tpl.encode('utf8')) fp.close() def write_model(self, mod_name, tpl): fp=file('application/model/{0}.py'.format(mod_name), 'w') fp.write(tpl.encode('utf8')) fp.close() def write_relation(self, mod_name, tpl): fp=file('application/model/relation/{0}.py'.format(mod_name), 'w') fp.write(tpl.encode('utf8')) fp.close() def _generate_model_name(self, table): return ''.join([ word.capitalize() for word in table.split('_') ]) def _check_composed_keys(self, cols): keys=[] for name, col in cols.iteritems(): if col in ['_relation', '_config', '_indexes']: continue if 'primaryKey' in col: keys.append(name) if len(keys)>1: return self._generate_primary_keys(keys) return '' def _generate_primary_keys(self, keys): _new_keys=[] for key in keys: if type(key)==str: _new_keys.append(key) elif type(key)==dict: _new_keys.append(key.keys()[0]) return '__storm_primary__ = '+','.join([ '"'+k+'"' \ for k in _new_keys ]) def _analyze(self, config): """Analyzes a table _config section""" if config.get('type')==None or config.get('foreignTable')==None: return False return True def _parse_column(self, col, special=False): _primary='False' _allow_none='True' _default_value='Undef' _foreign_keys=False if col.get('type')!=None: if col.get('primaryKey')!=None and col.get('primaryKey')==True: _primary='True' if col.get('required')!=None and col.get('required')==True: _allow_none='False' if col.get('default')!=None: _default_value=col.get('default') if not special: return '{0}(primary={1}, value={2}, allow_none={3})' \ .format(tr(col.get('type')), _primary, _default_value, _allow_none) else: return '{0}(value={1}, allow_none={2})' \ .format(tr(col.get('type')), _default_value, _allow_none) def _parse_relation(self, rel, table, reverse=False): """Parses a model table relation.""" _new_keys=[] for key in rel['keys']: if type(key)==str: _new_keys.append(key) elif type(key)==dict: _new_keys.append(key.keys()[0]) if not reverse: ret='"{0}.{1}", '.format(self._generate_model_name(table), rel['localKey']) ret+='"{0}.{1}", '.format(self._generate_model_name(table)+\ self._generate_model_name(rel['foreignTable']), _new_keys[0]) ret+='"{0}.{1}", '.format(self._generate_model_name(table)+\ self._generate_model_name(rel['foreignTable']), _new_keys[1]) ret+='"{0}.{1}"'.format(self._generate_model_name(rel['foreignTable']), rel['foreignKey']) else: ret='"{0}.{1}", '.format(self._generate_model_name(table), rel['localKey']) ret+='"{0}.{1}", '.format(self._generate_model_name( rel['foreignTable'])+ self._generate_model_name(table), _new_keys[0]) ret+='"{0}.{1}", '.format(self._generate_model_name( rel['foreignTable'])+\ self._generate_model_name(table), _new_keys[1]) ret+='"{0}.{1}"'.format(self._generate_model_name(rel['foreignTable']), rel['foreignKey']) return ret