Example #1
0
 def testWhat(self):
     query = stdModel.all()
     query.model(self.TModel.get_modelname(), 'a')
     query.what("a.f_int")
     query.what("a.f_str")
     query.filter("a.f_int =", 1)
     result = query.get()
     self.assertEqual(len(result._extproperties), 2)
     self.assertIn("f_int", result._extproperties)
     self.assertIn("f_str", result._extproperties)
     query = self.TModel().all("a")
     query.what("a.f_int")
     query.what("a.f_str")
     query.filter("a.f_int =", 1)
     result = query.get()
     self.assertEqual(result.f_int, 1)
     self.assertEqual(result.f_str, 'abcd')
     query = self.TModel().all("a")
     query.what("a.f_int", 'fint')
     query.what("a.f_str", "fstr")
     query.filter("a.f_int =", 1)
     result = query.get()
     self.assertIsNone(result.f_int, None)
     self.assertIsNone(result.f_str, None)
     self.assertEqual(result.fstr, 'abcd')
     self.assertEqual(result.fint, 1)
     self.assertEqual(len(result._extproperties), 2)
Example #2
0
def execute_oql(user_id, operation_key, oqlparam, limit=10000, offset=0, paging=False, metadata=None):
    operation = get_operation(operation_key=operation_key)
    results = []
    if operation != None:
        oql = operation.resource_oql
        query = stdModel.all()
        query = query.sql(oql, sql_vars=oqlparam.to_dict())
        results = query.fetch(limit, offset, paging, metadata)
    return results
Example #3
0
 def testSQL(self):
     query = self.TSubModel.all("a")
     query.sql("select * from %s where t_sub_name like $tname" % self.TSubModel.get_modelname(), sql_vars={'tname':"%_sub_%"})
     i = query.count()
     self.assertEqual(i, 7)
     result = query.get()
     self.assertTrue(isinstance(result.t_sub_bool, bool))
     self.assertEqual(result.t_sub_bool, True)
     query = stdModel.all()
     query.sql("select * from %s where t_sub_name like $tname" % self.TSubModel.get_modelname(), sql_vars={'tname':"%_sub_%"})
     self.assertEqual(i, 7)
     result = query.get()
     self.assertFalse(isinstance(result.t_sub_bool, bool))
     self.assertEqual(result.t_sub_bool, True)
     query = stdModel.all()
     query.sql("select * from %s where t_sub_name like $tname" % self.TSubModel.get_modelname(), sql_vars={'tname':"%_sub_%"})
     result = query.get(metadata={"t_sub_bool":properti.BooleanProperty("tsubbool")})
     self.assertTrue(isinstance(result.t_sub_bool, bool))
     self.assertEqual(result.t_sub_bool, True)
Example #4
0
def has_permission(user_id, operation_key, oqlparams=None):
    b = False
    cachekey = '%d:%s:%r' % (user_id, operation_key, oqlparams)
    perm = cache.get(CACHESPACE_PERMISSION, cachekey)
    if perm != None:
        return perm
    
    query = stdModel.all()
    query.model(UserRole.get_modelname(), "a")
    query.model(Role.get_modelname(), "b", join="inner", on="a.role_id=b.uid")
    query.model(RoleOperation.get_modelname(), "c", join="inner", on="c.role_id=b.uid")
    query.model(Operation.get_modelname(), "d", join="inner", on="c.operation_key=d.operation_key")
    query.what("a.user_id", alias="user_id")
    query.what("b.uid", alias="role_id")
    query.what("d.operation_key", alias="operation_key")
    query.what("d.handler_classes", alias="handler_classes")
    query.what("d.resource_oql", alias="resource_oql")
    query.what("a.user_id", alias="user_id")
    
    query.filter("a.user_id =", user_id)
    if operation_key is not None:
        query.filter("d.operation_key =", operation_key)
    std = query.get()
    
    if std != None:
        if std.resource_oql != None:
            operation = get_operation(operation_key=operation_key)
            params = operation.get_resource_oql_paramnames()
            if len(params) != len(oqlparams):
                raise UnauthorizedError()
            query = stdModel.all()
            if oqlparams != None and len(oqlparams) > 0 :
                query = query.sql(std.resource_oql, sql_vars=oqlparams)
            else:
                query = query.sql(std.resource_oql)
            if query.count() > 0:
                b = True
        else:
            b = True
    cache.put(CACHESPACE_PERMISSION, cachekey, b)
    return b
Example #5
0
 def test07ModelStd(self):
     tmodel = self.TModel()
     tmodel.f_str = "abcd"
     tmodel.f_int = 100
     tmodel.f_float = 1000.0
     tmodel.f_bool = False
     utc = datetime.datetime.utcnow()
     utc = utc.replace(microsecond=0)
     tmodel.f_datetime = utc
     tmodel.f_date = datetime.date(utc.year, utc.month, utc.day)
     tmodel.put()
     query = stdModel.all()
     query.model(self.TModel.get_modelname(), "a")
     try:
         query.filter("uid =", tmodel.get_keyvalue())
         self.assertFalse(True)
     except CoreError, e:
         self.assertIn("alias name", str(e))
Example #6
0
 def testAlias(self):
     query = self.TModel.all(alias="a")
     query.filter("a.f_int =", 1)
     i = query.count()
     self.assertEqual(i, 1)
     query = self.TModel.all()
     query.filter("f_int =", 1)
     i = query.count()
     self.assertEqual(i, 1)
     query = stdModel.all()
     query.what("b.uid")
     query.model(self.TModel.get_modelname(), 'b')
     query.filter("b.f_int =", 1)
     i = query.count()
     self.assertEqual(i, 1)
     
     query.what("b.f_int", "cccc")
     m = query.get()
     self.assertEqual(m.cccc, 1)
Example #7
0
 def fetch_tasks(self, user_id, whats=None, filters=None, limit=20, offset=0):
     def append_filters(query):
         for ft in filters:
             for (key, value) in ft.items():
                 for nr in TASKRESOLVERS:
                     nrinst = nr(key, value)
                     query.extend(nrinst, user_id=user_id)
     
     if whats == None:
         query = Task.all(alias="a")
         for key in Task.get_properties(persistent=True).keys():
             query.what("a.%s" % key, alias=key)
     else:
         query = stdModel.all()
         query.model(Task.get_modelname(), alias="a")
         for what in whats:
             query.what("a.%s" % what, alias=what)
     
     query.select("DISTINCT")
     query.what("a.uid", alias="uid")
     
     worksheet_ids = self.fetch_my_worksheets(user_id, onlyrtnids=True)
     if len(worksheet_ids) > 0:
         query.filter("a.worksheet_id in", worksheet_ids, parenthesis="(")
         query.filter("a.creator_id =", user_id, logic="or", parenthesis=")")
     else:
         query.filter("a.creator_id =", user_id)
     
     query.order("-a.uid")
     if filters is not None:
         append_filters(query)
     
     if not query.has_filter("a.is_trashed"):
         query = query.filter("a.is_trashed =", False)
     
     def task_proc(task):
         task.mclogs = mclog.fetch_mclogs(Task.get_modelname(), task.key(), worksheet_id=self.get_worksheet_name, assignee_id=ContactService.get_instance().get_contact_name)
         task.taskComments = self.fetch_taskcomments(task.key())
         
     pager = query.fetch(limit, offset, paging=True, model_proc=task_proc)
     return pager