def set_properties(self): ckeditor = CKEditor(self.db) T = current.T self.fields = [ Field("author", "reference auth_user"), Field("title", "string", notnull=True), Field("description", "text"), Field("body_text", "text", notnull=True), Field("slug", "text", notnull=True), ] self.widgets = {"body_text": ckeditor.widget} self.visibility = {"author": (False, False)} self.representation = {"body_text": lambda row, value: XML(value)} self.validators = { "title": IS_NOT_EMPTY(), "body_text": IS_NOT_EMPTY() } self.computations = { "slug": lambda r: IS_SLUG()(r.title)[0], } self.labels = { "title": T("Your post title"), "description": T("Describe your post (markmin allowed)"), "body_text": T("The content") }
def set_properties(self): ckeditor = CKEditor() T = current.T self.fields = [ Field("price", "double", notnull=True, default=0), Field("manufacturer", "string", notnull=True), Field("in_stock", "boolean", notnull=True, default=True), Field("info", "text", notnull=True), Field("product_size", "string"), ] self.validators = { "info": IS_NOT_EMPTY(), "manufacturer": IS_NOT_EMPTY(), "product_size": IS_EMPTY_OR( IS_IN_SET([("L", T("Large")), ("M", T("Medium")), ("S", T("Small"))], zero=None)), } self.widgets = {"info": ckeditor.widget} self.labels = { "price": T("Product Price"), "manufacturer": T("Manufacturer name or brand"), "in_stock": T("Available?"), "info": T("Product specs"), "product_size": T("Product size"), }
def check_properties(self): f = [ 'author', 'author_nickname', 'title', 'description', 'picture', 'thumbnail', 'draft', 'tags', 'keywords', 'content_type_id', 'content_type', 'slug', 'search_index', 'publish_date', 'publish_tz', 'privacy', 'license', 'likes', 'dislikes', 'views', 'responses', 'favorited', 'subscribers', 'is_active', 'created_on', 'created_by', 'modified_on', 'modified_by' ] for name in f: if name in [field.name for field in self.fields]: raise NameError("You cant use '%s' as field name for content" % name) for field in self.fields: if field.type == "upload": raise TypeError( "You can define field type upload in content table") extra = [ Field("article_id", "reference article", notnull=True, writable=False, readable=False), # required field Field("type_id", "reference content_type", notnull=True, writable=False, readable=False), # required field ] self.fields.extend(extra)
def set_properties(self): self.fields = [ Field("content_type"), Field("item_id", "integer"), Field("slug"), Field("reason"), Field("details", "text") ] reasons = ["Publicação não é vegana", "Violação de direitos autorais", "Falta de referências/fontes", "Conteúdo ofensivo", "Publicação falsa/mentirosa", "Usuário falso", "Usuário ofensivo", "Usuário desrespeita os termos e condições da rede", "Outro motivo (Justifique abaixo)"] self.validators = { "reason": IS_IN_SET(reasons) } self.labels = { "content_type": self.db.T("Content Type"), "item_id": self.db.T("Item id"), "slug": self.db.T("Item url slug"), "reason": self.db.T("Reason"), "details": self.db.T("Details") }
def _fetch_columns(self): tables = self._tables.copy() cols = self.db((self.db.COLUMNS.TABSCHEMA == self.schema) & self.not_in_blacklist_condition( self.db.COLUMNS.TABNAME)).select() for col in cols: try: tables[col.TABNAME.lower()].append( Field(col.COLNAME.lower(), **self.__params_for_column(col))) except SyntaxError: try: # Some colnames may have non-ascii characters, wich needs to be removed and passed as rname normalized = normalize('NFKD', col.COLNAME.decode( self.db._db_codec)).encode('ASCII', 'ignore') tables[col.TABNAME.lower()].append(Field(normalized.lower(), **self.__params_for_column( col))) except SyntaxError as e: # É ascii e ainda sim é funny name. provavelemnte é palavra # reservado no python e fere a regra REGEX_PYTHON_KEYWORDS # todo: É a melhor abordagem? Estamos ignorando por enquanto print e except KeyError: print "Não foi possível adicionar a coluna %s de %s - tipo %s desconhecido" % ( col.COLNAME, col.TABNAME, col.TYPENAME) return tables
def __init__(self, fieldname, type="string", length=None, default=None, required=False, requires="<default>", ondelete="CASCADE", notnull=False, unique=False, uploadfield=True, widget=None, label=None, comment=None, writable=True, readable=True, update=None, authorize=None, autodelete=False, represent=None, uploadfolder=None, compute=None, sortby=None): self.sortby = sortby Field.__init__(self, fieldname, type, length, default, required, requires, ondelete, notnull, unique, uploadfield, widget, label, comment, writable, readable, update, authorize, autodelete, represent, uploadfolder, compute)
def _vw_opt_flds_select_json(self, opt_tbl, vw_opt_fields): ret = [] args = Storage( rname = opt_tbl._rname or opt_tbl._tablename, tbl= opt_tbl._entopt.vw_pref or opt_tbl._tablename ) if opt_tbl._entopt.type=='list': name_str_json = 'row_to_json(%(rname)s.*) AS %(vw_name)s' args.vw_name = args.tbl ret.append(name_str_json % args) fld = Field(args.vw_name, 'json') fld._entopt=Storage(vw_name = args.vw_name, is_optrow = True) vw_opt_fields.append(fld) else: name_str = '%(rname)s.%(fld)s AS %(vw_name)s' for fld in opt_tbl: if fld is opt_tbl._entopt.own_FK: continue args.fld = fld.name if not hasattr(fld, '_entopt'): fld._entopt = Storage() if fld._entopt.vw_name: args.vw_name = fld._entopt.vw_name else: args.vw_name = fld._entopt.vw_name = '%(tbl)s_%(fld)s' % args vw_opt_fields.append(fld) ret.append(name_str % args) return ret
def ref_field(enm, name=None, **kwargs): name = name or enm.FK_name _type = 'reference '+ enm.own._tablename nocahe = kwargs.pop('nocache', None) fld = Field(name, _type, **kwargs) def _get_enm_rec(id): cache = current.cache _enm = enm _nocahe = nocahe if _nocahe: enm_rows= _enm.db().select(_enm.own.ALL) else: enm_rows= _enm.db().select(_enm.own.ALL, cache = (cache.ram,60), cachable=True) if enm_rows.first() and id is not None: enm_rec = enm_rows.find(lambda row: row.id==id)[0] else: enm_rec = None return enm_rec def _get_repr(v, r): rec=_get_enm_rec(v) if rec: repr_fld = hasattr(rec,'code') and rec.code or rec.name else: repr_fld = None return repr_fld fld.represent = _get_repr fld._enm_rec = _get_enm_rec return fld
def set_properties(self): T = self.db.T self.fields = [ Field("user_id", "reference auth_user"), Field("event_type", "string", notnull=True), Field("way", "list:string", notnull=True), Field("unikey", unique=True, notnull=True) ] self.events = self.db.config.get_list('notification', 'event') self.ways = self.db.config.get_list('notification', 'way') self.validators = { "way": IS_IN_SET(self.ways, multiple=True), "event_type": IS_IN_SET([(key, value % ("", "")) for key, value in self.events]) } self.computations = { "unikey": lambda row: "%(user_id)s_%(event_type)s" % row } self.widgets = {"way": SQLFORM.widgets.checkboxes.widget} self.labels = { "event_type": T("When"), "way": T("You want to be notified by") }
def set_properties(self): self.fields = [ Field("user_id", "reference auth_user"), Field("sender", "reference auth_user"), Field("message_text", "text"), Field("x") ]
def test_factory(self): factory_form = SQLFORM.factory( Field('field_one', 'string', IS_NOT_EMPTY()), Field('field_two', 'string')) self.assertEqual( factory_form.xml(), '<form action="#" enctype="multipart/form-data" method="post"><table><tr id="no_table_field_one__row"><td class="w2p_fl"><label class="" for="no_table_field_one" id="no_table_field_one__label">Field One: </label></td><td class="w2p_fw"><input class="string" id="no_table_field_one" name="field_one" type="text" value="" /></td><td class="w2p_fc"></td></tr><tr id="no_table_field_two__row"><td class="w2p_fl"><label class="" for="no_table_field_two" id="no_table_field_two__label">Field Two: </label></td><td class="w2p_fw"><input class="string" id="no_table_field_two" name="field_two" type="text" value="" /></td><td class="w2p_fc"></td></tr><tr id="submit_record__row"><td class="w2p_fl"></td><td class="w2p_fw"><input type="submit" value="Submit" /></td><td class="w2p_fc"></td></tr></table></form>' )
def define_sms_email(self): if 'sms_email' in self.db.tables: return self.db.sms_email return self.db.define_table( 'sms_email', Field('email'), Field('phone', 'string'), #Field('credit','integer',default=0), migrate=self.migrate)
def set_properties(self): self.fields = [ Field("order_id", "reference product_order"), Field("product_id", "integer"), Field("quantity", "integer"), Field("current_price", "double"), Field("product_options") ]
def _auth(self): """Create a auth instance. """ auth = Auth(db=self.db, hmac_key=self.local_settings.hmac_key) # This may need to be set to True the first time an app is used. if not self.local_settings.disable_authentication: auth.settings.extra_fields['auth_user'] = [Field('name')] auth.define_tables(username=False, signature=False, migrate=True) if self.settings_loader: self.settings_loader.import_settings(group='auth', storage=auth.settings) auth.settings.mailer = self.mail auth.settings.verify_email_onaccept = self.verify_email_onaccept # Controller tests scripts require login's with same session. if self.get_server_mode() == 'test': # Resetting the session farks with controller test scripts auth.settings.renew_session_onlogin = False auth.settings.renew_session_onlogout = False else: auth.settings.renew_session_onlogin = True auth.settings.renew_session_onlogout = True host = '' request = self.environment['request'] if 'wsgi' in request.keys(): if hasattr(request['wsgi'], 'environ') and \ request['wsgi'].environ and \ 'HTTP_HOST' in request['wsgi'].environ: host = request['wsgi'].environ['HTTP_HOST'] elif 'env' in request.keys(): host = request.env.http_post if host: auth.messages.verify_email = 'Click on the link http://' + host \ + '/' + request.application \ + '/default/user/verify_email/%(key)s to verify your email' auth.messages.reset_password = '******' + host \ + '/' + request.application \ + '/default/user/reset_password/%(key)s to reset your password' # W0108: *Lambda may not be necessary* # pylint: disable=W0108 auth.signature = self.db.Table(self.db, 'auth_signature', Field('created_on', 'datetime', default=request.now, represent=lambda x: str(x), readable=False, writable=False, ), Field('updated_on', 'datetime', default=request.now, update=request.now, represent=lambda x: str(x), readable=False, writable=False, )) return auth
def define_page(self, migrate=False): db = self.db if 'page' in db.tables: return db.page return db.define_table('page', Field('name', unique=True, requires=IS_NOT_EMPTY()), Field('description', 'text', default=''), Field('content', 'text', default=''), migrate=migrate)
def define_box(self): if 'box' in self.db.tables: return self.db.box from gluon.dal import Field return self.db.define_table('box', Field('name',unique=True,required=True), Field('setting','text',default='{}'), Field('textcontent','text',default=''), Field('htmlcontent','text',default=''), Field('avatar','upload',autodelete=True), migrate=self.migrate)
def set_properties(self): self.fields = [ Field("user_id", "reference auth_user"), Field("writer", "reference auth_user"), Field("board_text", "string"), ] self.visibility = {"user_id": (False, False), "writer": (False, False)} self.validators = {"board_text": IS_NOT_EMPTY()}
def _t_post(self): self.db.define_table( 't_post', Field('f_user_id', 'reference auth_user', default=self.auth.user_id, writable=False, readable=False), Field('f_description', 'text'), )
def define_table(self, migrate=False): db = self.db if self.table not in db.tables: db.define_table(self.table, Field('tablename', writable=False, readable=False), Field('table_id', writable=False, readable=False), Field('name'), Field('filetype'), Field('extension'), Field('filesize', 'double'), Field('filepath', 'upload', autodelete=True, uploadfolder=os.path.join(self.path)), Field('created_by', 'integer', default=self.auth.user_id or 1, writable=False, readable=False), Field('created_on', 'datetime', default=current.request.now, writable=False, readable=False), migrate=migrate) db[self.table].tablename.default = self.tablename db[self.table].table_id.default = self.table_id return db[self.table]
def define_comment(self, migrate=False): if 'tcomment' in self.db.tables: return self.db.tcomment from gluon.dal import Field from plugin_ckeditor import CKEditor ckeditor = CKEditor(self.db) return self.db.define_table('tcomment', Field('tablename'), Field('table_id', 'integer'), Field('objects_id', 'integer'), Field('procedures', 'integer'), Field('process', 'integer'), Field('auth_group', 'list:integer'), Field('txtcontent', 'text', length=16777215, widget=ckeditor.widget), Field('created_by', 'integer', default=self.auth.user_id or 1, writable=False, readable=False), Field('created_on', 'datetime', default=current.request.now, writable=False, readable=False), migrate=migrate)
def define_tables(self): """Define needed tables for the extension manager. This is automatically called by constructor if a valid ``db`` is passed. """ from gluon.dal import Field db = self.db db.define_table( 'system_modules', Field('name', 'string', length=128, required=True, notnull=True, unique=True), Field('status', 'boolean', default=False), )
def myform(): form = SQLFORM.factory(Field('first_name', 'string'), Field('last_name', 'string')) def onvalidation(form): pass if form.process(session=application.session, onvaliidation=onvalidation).accepted: redirect(URL()) return dict(form=form)
def __init__( self, fieldname, type="string", length=None, default=None, required=False, requires="<default>", ondelete="CASCADE", notnull=False, unique=False, uploadfield=True, widget=None, label=None, comment=None, writable=True, readable=True, update=None, authorize=None, autodelete=False, represent=None, uploadfolder=None, compute=None, sortby=None, ): self.sortby = sortby Field.__init__( self, fieldname, type, length, default, required, requires, ondelete, notnull, unique, uploadfield, widget, label, comment, writable, readable, update, authorize, autodelete, represent, uploadfolder, compute, )
def set_properties(self): self.fields = [ Field("buyer", "reference auth_user"), Field("seller", "reference auth_user"), Field("total_items", "integer"), Field("total_value", "double"), Field("ship_address", "reference product_address"), Field("notes", "text"), Field("coupom"), Field("discount"), Field("discount_type"), Field("status"), ]
def set_properties(self): self.fields = [ Field("comment_id", "reference article_comments", notnull=True), Field("user_id", "reference auth_user", notnull=True), Field("vote", "integer", notnull=True, default=1), Field("unikey", unique=True, notnull=True) ] self.validators = {"vote": IS_IN_SET([(0, "Down"), (1, "Up")])} self.computations = { "unikey": lambda row: "%(user_id)s_%(comment_id)s_%(vote)s" % row }
def edit(): form = SQLFORM.factory( Field('first_name', 'string', requires=IS_NOT_EMPTY(error_message='Please enter first name')), Field('last_name', 'string', requires=IS_NOT_EMPTY(error_message='Please enter last name')), _action=URL('experiments', 'default', 'edit')) if form.process(session=application.session).accepted: redirect(URL()) return {'form': form}
def set_properties(self): self.fields = [ Field("article_id", "reference article", notnull=True), Field("user_id", "reference auth_user", notnull=True), Field("nickname", notnull=True), Field("parent_id", "reference article_comments"), Field("replies", "integer", notnull=True, default=0), Field("comment_text", "text", notnull=True), Field("commenttime", "datetime"), Field("answer", "boolean", default=False), ] self.visibility = { "article_id": (False, False), "user_id": (False, False), "parent_id": (False, False), "commenttime": (False, False), "replies": (False, False), "answer": (False, False), } self.computations = { "nickname": lambda r: self.db.auth_user[r.user_id].nickname } self.validators = {"comment_text": IS_LENGTH(1024, 2)}
def set_properties(self): """ """ self.fields = [ Field('first_name', 'string', requires=IS_NOT_EMPTY('Please enter a first name')), Field('last_name', 'string', requires=IS_NOT_EMPTY('Please enter a last name')), Field('email', 'string', requires=IS_EMAIL(error_message='Enter a valid email')) ]
def _t_comment(self): self.db.define_table( 't_comment', Field('f_user_id', 'reference auth_user', default=self.auth.user_id, writable=False, readable=False), Field('f_post_id', 'reference t_post'), Field('f_comment', 'text'), Field('f_created_on', 'datetime', default=self.request.now, writable=False), )
def set_properties(self): self.fields = [ Field("user_id", "reference auth_user"), Field("nickname", "string"), Field("event_type", "string"), Field("event_to", "string"), Field("event_reference", "integer"), Field("event_text", "text"), Field("event_image", "string"), Field("event_link", "string"), Field("event_image_to", "string"), Field("event_link_to", "string"), ] self.representation = {"created_on": lambda v: self.db.pdate(v)}
def set_properties(self): self.fields = [ Field("user_id", "reference auth_user"), Field("event_type", "string", notnull=True), Field("event_text", "string"), Field("event_link", "string"), Field("event_reference", "integer"), Field("event_image", "string"), Field("mail_sent", "boolean", default=False), Field("is_read", "boolean", default=False), Field("kwargs", "text"), ]
def testDALcache(self): s = Storage({'application': 'admin', 'folder': 'applications/admin'}) cache = Cache(s) db = DAL(check_reserved=['all']) db.define_table('t_a', Field('f_a')) db.t_a.insert(f_a='test') db.commit() a = db(db.t_a.id > 0).select(cache=(cache.ram, 60), cacheable=True) b = db(db.t_a.id > 0).select(cache=(cache.ram, 60), cacheable=True) self.assertEqual(a.as_csv(), b.as_csv()) c = db(db.t_a.id > 0).select(cache=(cache.disk, 60), cacheable=True) d = db(db.t_a.id > 0).select(cache=(cache.disk, 60), cacheable=True) self.assertEqual(c.as_csv(), d.as_csv()) self.assertEqual(a.as_csv(), c.as_csv()) self.assertEqual(b.as_csv(), d.as_csv()) e = db(db.t_a.id > 0).select(cache=(cache.disk, 60)) f = db(db.t_a.id > 0).select(cache=(cache.disk, 60)) self.assertEqual(e.as_csv(), f.as_csv()) self.assertEqual(a.as_csv(), f.as_csv()) g = db(db.t_a.id > 0).select(cache=(cache.ram, 60)) h = db(db.t_a.id > 0).select(cache=(cache.ram, 60)) self.assertEqual(g.as_csv(), h.as_csv()) self.assertEqual(a.as_csv(), h.as_csv()) db.t_a.drop() db.close()
def setUp(self): request = Request(env={}) request.application = 'a' request.controller = 'c' request.function = 'f' request.folder = 'applications/admin' response = Response() session = Session() T = translator('', 'en') session.connect(request, response) from gluon.globals import current current.request = request current.response = response current.session = session current.T = T self.db = DAL(DEFAULT_URI, check_reserved=['all']) self.auth = Auth(self.db) self.auth.define_tables(username=True, signature=False) self.db.define_table('t0', Field('tt'), self.auth.signature) self.auth.enable_record_versioning(self.db) # Create a user self.db.auth_user.insert(first_name='Bart', last_name='Simpson', username='******', email='*****@*****.**', password='******', registration_key=None, registration_id=None) self.db.commit()