Python SessionFactory.new方法代码示例

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
    def finger_tpl_save(self):
        index = Utils.parse_int(self.param("index"))
        tpl = self.param("tpl")
        archives_id = Utils.parse_int(self.param("archives_id"))
        sf = SessionFactory.new()
        obj = sf.query(ValidWorkFingerTemplate) \
            .filter(ValidWorkFingerTemplate.archives_id == archives_id) \
            .filter(ValidWorkFingerTemplate.finger_index == index).limit(1).scalar()

        machines_sn = sf.query(ValidWorkMachine.sn).all()
        machines_sn = [sn[0] for sn in machines_sn]
        name = sf.query(Archives.name).filter(Archives.id == archives_id).limit(1).scalar()
        for sn in machines_sn:
            ValidWorkHelper.push_user_fp_to_machine(sn, archives_id, name, index, tpl)

        if obj:
            obj.tpl = tpl
            sf.commit()
            return ["success"]
        else:
            if archives_id:
                sf = SessionFactory.new()
                obj = ValidWorkFingerTemplate()
                obj.card_no = ""
                obj.finger_index = index
                obj.tpl = tpl
                obj.archives_id = archives_id
                sf.add(obj)
                sf.commit()
                return ["success"]
        return ["failure"]

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
 def update(self, id_):
     message = dict()
     self.set_header("Content-Type", "text/json;charset=utf-8")
     meta = DataTableModule.__entity_mapping__.get(id_)
     if not meta:
         self.set_status(403, "Error!")
     entity = import_object(meta["name"])
     custom_filter = ObjectPool.datatable_provider.get(meta["name"])
     custom_filter_obj = None
     if custom_filter:
         custom_filter_obj = custom_filter()
     rec_id = self.get_argument("id")
     valid_msg = ""
     if not rec_id:
         message["flag"] = "add"
         sf = SessionFactory.new()
         obj = self.wrap_entity(entity())
         if hasattr(custom_filter_obj, "before_add"):
             valid_msg = custom_filter_obj.before_add(obj, sf, self)
             # 检查没有数据上的问题才执行保存动作
         if not valid_msg:
             sf.add(obj)
             sf.commit()
             if hasattr(custom_filter_obj, "after_add"):
                 custom_filter_obj.after_add(obj, sf, self)
             message["success"] = True
             message["msg"] = obj.id
             self.write(Utils.encode(message))
         else:
             message["success"] = False
             message["msg"] = valid_msg
             self.write(Utils.encode(message))
     else:
         message["flag"] = "update"
         sf = SessionFactory.new()
         cur_row = sf.query(entity).get(rec_id)
         self.wrap_entity(cur_row)
         if hasattr(custom_filter_obj, "before_modify"):
             valid_msg = custom_filter_obj.before_modify(cur_row, sf, self)
         if not valid_msg:
             sf.commit()
             if hasattr(custom_filter_obj, "after_modify"):
                 custom_filter_obj.after_modify(cur_row, sf, self)
             message["success"] = True
             message["msg"] = "Updated"
             self.write(Utils.encode(message))
         else:
             message["success"] = False
             message["msg"] = valid_msg
             self.write(Utils.encode(message))

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
 def count(self, kw, http_req):
     sf = SessionFactory.new()
     q = sf.query(func.count(ValidWorkAskForLeave.id))\
         .join(Archives, ValidWorkAskForLeave.archives_id == Archives.id)
     if kw:
         q = q.filter(Archives.name.contains(kw))
     return q.limit(1).scalar()

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
 def list(self, kw, start, limit, http_req):
     sf = SessionFactory.new()
     subq = sf.query(Archives.id, Archives.name).subquery()
     q = sf.query(ValidWorkAskForLeave, Archives.name, subq.c.name.label("creator"))\
         .join(Archives, ValidWorkAskForLeave.archives_id == Archives.id)\
         .outerjoin(subq, ValidWorkAskForLeave.creator == subq.c.id)
     if kw:
         q = q.filter(Archives.name.contains(kw))
     dataset = q.order_by(ValidWorkAskForLeave.id.desc()).offset(start).limit(limit).all()
     items = list()
     for row in dataset:
         ot = row[0]
         name = row[1]
         creator = row[2]
         item = dict()
         item["id"] = ot.id
         item["kind"] = ot.kind
         item["ask_date"] = Utils.format_date(ot.ask_date)
         item["start_datetime"] = Utils.format_datetime_short(ot.start_datetime)
         item["end_datetime"] = Utils.format_datetime_short(ot.end_datetime)
         item["create_datetime"] = Utils.format_datetime_short(ot.create_datetime)
         item["name"] = name
         item["creator"] = creator
         items.append(item)
     return items

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
    def post(self, *args, **kwargs):

        #记录机器访问数据
        params_ = self.wrap_params_to_dict()
        sn = params_.get("SN")
        sf = SessionFactory.new()
        machine = sf.query(ValidWorkMachine).filter(ValidWorkMachine.sn == sn).limit(1).scalar()
        table = params_.get("table")
        if table == "OPERLOG":
            op_stamp = params_.get("OpStamp")
            if op_stamp and machine:
                machine.opstamp = Utils.parse_int(op_stamp)
                sf.commit()
            self.write("OK")
        elif table == "ATTLOG":
            stamp = params_.get("Stamp")
            if stamp and machine:
                stamp = Utils.parse_int(stamp)
                machine.stamp = stamp
                sf.commit()

            if stamp and stamp > 0:
                records_text = self.request.body
                if records_text:
                    records_text = records_text.decode("utf-8")
                    records = list()
                    for line in records_text.split("\n"):
                        items = line.split("\t")
                        if len(items) >= 2:
                            records.append((items[0], items[1]))
                    for r in records:
                        archives_id = r[0]
                        touch_time = datetime.strptime(r[1], "%Y-%m-%d %H:%M:%S")
                        self.detect_chkon_status(archives_id, touch_time)
                    self.write("OK")

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
    def push_users_fp_to_machine(sn, items):
        """

        @param sn:
        @param items: [[pin, name, fid, tpl]..]
        """
        sf = SessionFactory.new()
        id_ = sf.query(ValidWorkCommands.id).filter(ValidWorkCommands.sn == sn).limit(1).scalar()
        cmds = list()
        for item in items:
            create = r"DATA DEL_USER PIN=%i\r\nDATA USER PIN=%i\tName=%s\r\n" % (item[0], item[0], item[1])
            update = r"DATA FP PIN=%i\tFID=%i\tTMP=%s\r\n" % (item[0], item[2], item[3])
            vwc = ValidWorkCommands()
            vwc.sn = sn
            vwc.validworkmachine_id = id_
            vwc.cmd = create
            vwc.create_date = Utils.current_datetime()
            vwc1 = ValidWorkCommands()
            vwc1.sn = sn
            vwc1.validworkmachine_id = id_
            vwc1.cmd = update
            vwc1.create_date = Utils.current_datetime()
            cmds += [vwc, vwc1]
        sf.add_all(cmds)
        sf.commit()

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
 def get(self, *args, **kwargs):
     sn = self.get_argument("SN")
     opts = self.get_argument("options")
     self.set_header("Content-Type", "text/plain;charset=utf-8")
     if opts == "all":
         self.write("GET OPTION FROM:" + sn + "\n")
         self.write("ErrorDelay=60\n")
         self.write("Delay=15\n")
         self.write("TransInterval=1\n")
         self.write("TransFlag=1111000000\n")
         self.write("Realtime=1\n")
         self.write("Encrypt=0\n")
         self.write("TransTimes=00:00;14:05\n")
         sf = SessionFactory.new()
         machine = sf.query(ValidWorkMachine).filter(ValidWorkMachine.sn == sn).limit(1).scalar()
         if machine:
             if machine.stamp:
                 self.write("Stamp=" + str(machine.stamp) + "\n")
             if machine.opstamp:
                 self.write("OpStamp=" + str(machine.opstamp) + "\n")
             if machine.photo_stamp:
                 self.write("PhotoStamp=" + str(machine.photo_stamp) + "\n")
         else:
             #初始化一个起始交互日期
             a = "100000000"
             self.write("Stamp=" + a + "\n")
             self.write("OpStamp=" + a + "\n")
             self.write("PhotoStamp=" + a + "\n")

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
 def render(self, **prop):
     self.dom_id = prop.get("id")
     self.cols = prop.get("cols")
     self.sort_sql = prop.get("sort_sql")
     self.entity_full_name = prop.get("entity")
     self.query_class = prop.get("query_class")  # obj prop `data` func return [(k,v),(k,v)...]
     self.allow_blank = prop.get("allow_blank")
     html = list()
     html.append("<select id='%s' name='%s' class='form-control'>" % (self.dom_id, self.dom_id))
     if self.allow_blank:
         html.append("<option value=''> </option>")
     if not self.query_class:
         if not self.entity_full_name:
             return "<small>Require entity full name.</small>"
         if self.entity_full_name:
             cls = import_object(self.entity_full_name)
             cnn = SessionFactory.new()
             q = cnn.query(cls)
             if self.sort_sql:
                 q = q.order_by(self.sort_sql)
             items = q.all()
             all = list()
             for item in items:
                 all.append([(getattr(item, col)) for col in self.cols.split(",")])
             for opt in all:
                 html.append("<option value='%s'>%s</option>" % (opt[0], opt[1]))
     else:
         obj = import_object(self.query_class)()
         if hasattr(obj, "data"):
             items = getattr(obj, "data")()
             for item in items:
                 html.append("<option value='%s'>%s</option>" % (item[0], item[1]))
     html.append("</select>")
     return "".join(html)

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
 def delete(self, id_, http_req):
     sf = SessionFactory.new()
     num = sf.query(ValidWorkAskForLeave).filter(ValidWorkAskForLeave.id == id_).delete(synchronize_session='fetch')
     sf.commit()
     if num > 0:
         return ""
     return "failure"

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
 def is_holiday(current_date_str):
     sf = SessionFactory.new()
     num = sf.query(func.count(Holiday.id))\
         .filter(Holiday.start_date <= current_date_str).filter(Holiday.end_date >= current_date_str).scalar()
     if num > 0:
         return True
     return False

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
 def delete(self, id_):
     self.set_header("Content-Type", "text/json;charset=utf-8")
     meta = DataTableModule.__entity_mapping__.get(id_)
     if not meta:
         self.set_status(403, "Error!")
     entity = import_object(meta["name"])
     custom_filter = ObjectPool.datatable_provider.get(meta["name"])
     custom_filter_obj = None
     if custom_filter:
         custom_filter_obj = custom_filter()
     valid_msg = ""
     message = dict()
     message["flag"] = "delete"
     rec_id = self.get_argument("id")
     sf = SessionFactory.new()
     cur_row = sf.query(entity).get(rec_id)
     if hasattr(custom_filter_obj, "before_delete"):
         valid_msg = custom_filter_obj.before_delete(cur_row, sf, self)
     if not valid_msg:
         sf.delete(cur_row)
         sf.commit()
         if hasattr(custom_filter_obj, "after_delete"):
             custom_filter_obj.after_delete(cur_row, sf, self)
         message["success"] = True
         message["msg"] = "Deleted"
         self.write(Utils.encode(message))
     else:
         message["success"] = False
         message["msg"] = valid_msg
         self.write(Utils.encode(message))

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
 def value(self):
     sf = SessionFactory.new()
     val = sf.query(ValidWorkFingerTemplateKey.tpl) \
         .filter(ValidWorkFingerTemplateKey.account_id == self.request.current_user).limit(1).scalar()
     if val:
         return [val]
     return [""]

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
    def post(self, *args, **kwargs):
        """
        do login action
        :param args:
        :param kwargs:
        """
        login_id = self.get_argument("login_id")
        login_pwd = self.get_argument("login_pwd")
        if not login_id or not login_pwd:
            self.redirect(self.get_login_url())
        cnn = SessionFactory.new()

        if Utils.is_email(Utils.trim(login_id)):
            rows = cnn.query(Account.id, Archives.name).outerjoin(Archives, Account.archives_id == Archives.id) \
                .filter(Archives.email == login_id).filter(Account.login_pwd == Utils.md5(login_pwd)) \
                .filter(Account.enabled == 1).limit(1).all()
            if len(rows) > 0:
                id_ = rows[0][0]
                name = rows[0][1]
                self.set_secure_cookie(IRequest.__key_account_id__, "%i" % id_)
                self.set_secure_cookie(IRequest.__key_account_name__, name)
                Login.update_last_login_datetime(id_)
        else:
            rows = cnn.query(Account.id, Archives.name).outerjoin(Archives, Account.archives_id == Archives.id) \
                .filter(Account.login_name == login_id).filter(Account.login_pwd == Utils.md5(login_pwd)) \
                .filter(Account.enabled == 1).limit(1).all()
            if len(rows) > 0:
                id_ = rows[0][0]
                name = rows[0][1]
                self.set_secure_cookie(IRequest.__key_account_id__, "%i" % id_)
                self.set_secure_cookie(IRequest.__key_account_name__, name)
                Login.update_last_login_datetime(id_)

        self.redirect("/workbench/dashboard")

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
 def list_fingers(self):
     sf = SessionFactory.new()
     archives_id = Utils.parse_int(self.param("archives_id"))
     items = sf.query(ValidWorkFingerTemplate.finger_index) \
         .filter(ValidWorkFingerTemplate.archives_id == archives_id).all()
     items = [item[0] for item in items]
     return items

# 需要导入模块: from tinyms.core.orm import SessionFactory [as 别名]
# 或者: from tinyms.core.orm.SessionFactory import new [as 别名]
 def list(self, taxonomy):
     cnn = SessionFactory.new()
     items = cnn.query(TermTaxonomy.id, Term.name) \
         .outerjoin((Term, Term.id == TermTaxonomy.term_id)) \
         .filter(TermTaxonomy.taxonomy == taxonomy) \
         .all()
     return items