def __init__(self, data, message="successfully", **kwargs): resp = {} resp['data'] = data resp['message'] = message resp['code'] = 200 resp['server_timestamp'] = time.mktime(now().timetuple()) super(JsonResponseRequest, self).__init__(resp, status=200, **kwargs)
def client_login(params): code = params.get("code") if not code or len(code) != 36: return {"error_code": 1, "msg": "params invalid"} key = "jump-%s" % code obj = misc.misc_get(key) if not obj: return {"error_code": 1, "msg": "code not exists"} dic = utils.loads(obj.value) obj.delete_instance() if dic['expire_at'] < utils.stamp(): return {"error_code": 1, "msg": "code expire"} user = User.select().where(User.id == dic['user_id']).first() res = {"error_code": 0, "msg": "ok"} res['session_token'] = generate_token() sess = Session() sess.user = user sess.session_key = res['session_token'] sess.expire_at = utils.timedelta(utils.now(), days=1) res['expire_at'] = 0 sess.save() res['identify'] = user.identify return res
def send_code(phone, code=None): if not phone: return {"error_code": 20037, "msg": "phone not exists"} vcode = VerifyCode.select().where(VerifyCode.phone == phone).first() if not vcode: vcode = VerifyCode() if not code: code = random.randint(100000, 999999) baiwu = BaiWuTong() flag, msg = baiwu.send(phone=phone, text=msg_template_code(code)) if not flag: return {"error_code": 20036, "msg": "send verify code failed"} now = utils.now() vcode.phone = phone vcode.code = code vcode.send_at = now vcode.vcount = 0 vcode.is_used = False vcode.last_verity_time = now vcode.create_at = now vcode.save() return {"error_code":0, "msg":"ok", "vcode":code}
def weekstone_day_report(body): now = utils.local_datetime(utils.now()) yestorday = utils.timedelta(now, days=-1) start = utils.datetime_day_min(yestorday, utc=False) end = utils.datetime_day_max(yestorday, utc=False) records = ShotRecord.select().where(ShotRecord.shot_at>=start, ShotRecord.shot_at<end) period = end.strftime('%Y%m%d') dic = {} for rd in records: weekstone_id = rd.weekstone_id if weekstone_id not in dic: dic[weekstone_id] = 1 else: dic[weekstone_id] += 1 for x in dic: ws = WeekStone.select().where(WeekStone.id == x).first() contract = ws.contract report = WeekStoneReport() report.contract = contract report.user = contract.user report.team = contract.team report.weekstone = ws report.period = period report.times = dic[x] report.hourly = contract.hourly if ws.status == "finish": report.status = ws.status else: report.status = "carry" report.save()
def count_weekstone(body): now = utils.now() start = utils.timedelta(now, days=-7) day_start = utils.datetime_day_min(start) day_end = utils.datetime_day_max(start) weekstones = WeekStone.select().where(WeekStone.start_at.between(day_start, day_end)) for ws in weekstones: # 合同状态和时薪周状态都是进行中的才自动提审 if ws.contract.status != "carry": continue if ws.status != "carry": continue with database.atomic() as txn: try: record = WeekStoneRecord() record.weekstone = ws record.save() ws.status = "carry_pay" ws.contract.stone_status = "carry_pay" ws.contract.save() ws.save() queue.to_queue({"type": "weekstone_freelancer_audit", "weekstone_id": ws.id}) except: txn.rollback()
def client_login(params): code = params.get("code") if not code or len(code) != 36: return {"error_code":1, "msg":"params invalid"} key = "jump-%s" % code obj = misc.misc_get(key) if not obj: return {"error_code":1, "msg":"code not exists"} dic = utils.loads(obj.value) obj.delete_instance() if dic['expire_at'] < utils.stamp(): return {"error_code":1, "msg":"code expire"} user = User.select().where(User.id==dic['user_id']).first() res = {"error_code":0, "msg":"ok"} res['session_token'] = generate_token() sess = Session() sess.user = user sess.session_key = res['session_token'] sess.expire_at = utils.timedelta(utils.now(), days=1) res['expire_at'] = 0 sess.save() res['identify'] = user.identify return res
def create(params): username = params.get('username', None) password = params.get('password', None) role_id = params.get('role_id', 2) if not username or not password or not role_id: return {"error_code":20021, "msg":"parameters required"} if SystemUser.select().where(SystemUser.username == username).first(): return {"error_code":20025, "msg":"user is exists"} if not utils.is_username(username): return {"error_code":20023, "msg":"username invalid"} with database.atomic() as txn: try: pwd, salt = generate_password(password.encode('utf-8')) user = SystemUser() user.username = username user.password = pwd user.salt = salt user.role_id = role_id user.create_at = utils.now() user.save() except Exception, e: logger.error(traceback.format_exc()) txn.rollback() return {"error_code":20026, "msg":"create system user error"}
def password_verify(user, params): password = params.get("password") if not check_password(password, user.password, user.salt): return {"error_code": 20391, "msg": "password invalid"} user.last_verify = utils.now() user.save() return {"error_code": 0, "msg": "ok"}
def test(): logger.error("%s generate test queue" % utils.now()) with queue_conn.connect(): with queue_conn.SimpleQueue(cron_queue) as queue: queue.put({"type":"create_group", "group_name":"测试团队", "user_id_list":[120, 104], "group_type":1, "user_id":144, "team_id":104, "req_user_id":120, "proposal_id":3, "contract_id":1})
def calc_user_discover(body): now = utils.now() start = utils.timedelta(now, days=-90) year_start = utils.timedelta(now, days=-365) id_start = 0 while 1: users = User.select(User.id).where(User.id>id_start).limit(200) if not users: break for u in users: user_id = u.id id_start = u.id us = UserStatistics.select().where(UserStatistics.user == u.id).first() if not us: us = UserStatistics() us.user = u.id count = UserDiscover.select(fn.SUM(UserDiscover.view_num)).where(UserDiscover.user==user_id, UserDiscover.update_at.between(start, now)).scalar() us.season_view = count if count else 0 # 90天内投标 count = Proposal.select().where(Proposal.user==user_id,Proposal.ptype=='D',Proposal.create_at.between(start, now)).count() us.season_proposal = count # 90内沟通中 count = Proposal.select().where(Proposal.user==user_id, Proposal.status=="interview", Proposal.update_at.between(start, now)).count() us.season_interview = count # 90天内被邀请 count = Proposal.select().where(Proposal.user==user_id,Proposal.ptype=='I',Proposal.create_at.between(start, now)).count() us.season_invite = count # 90天内被邀请回复 count = Proposal.select().where(Proposal.user==user_id, Proposal.ptype=='I',Proposal.status=="interview", Proposal.update_at.between(start, now)).count() us.season_reply = count # 90天内被邀请当天回复 count1 = Proposal.select().where(Proposal.user==user_id, Proposal.ptype=='I',Proposal.day_reply==True, Proposal.update_at.between(start, now)).count() us.season_day_reply = count1 # 90天内雇佣 count = Proposal.select().where(Proposal.user==user_id, Proposal.status=="hire", Proposal.update_at.between(start, now)).count() us.season_hire = count # 一年内收总金额 year_amount = MarginRecord.select(fn.SUM(MarginRecord.amount)).where(MarginRecord.user==user_id, MarginRecord.record_type=="income", MarginRecord.create_at.between(year_start, now)).scalar() us.year_amount = year_amount if year_amount else 0 us.update_at = now us.save()
def wrapper(params, *args): qs = user_question(params.user) if qs['error_code'] != 0: return params.render("public-setting-question.html") if not params.user.last_verify or params.user.last_verify and (utils.now() - params.user.last_verify).days >= 1: return params.render("public-verify-password.html") return func(params, *args)
def auto_pay_weekstone(body): now = utils.now() start = utils.timedelta(now, days=-2) start = utils.now() records = WeekStoneRecord.select().where(WeekStoneRecord.create_at<=start, WeekStoneRecord.audit_at.is_null(True)) for rd in records: ws = rd.weekstone if ws.status != "carry_pay": continue contract = ws.contract if contract.status != "carry": continue with database.atomic() as txn: try: if ws.shot_times > contract.workload * 6: pay_times = contract.workload * 6 amount = contract.amount else: pay_times = ws.shot_times amount = utils.decimal_two(contract.hourly * ws.shot_times / 6) ws.actual_amount = amount ws.status = "finish" ws.end_at = now order = margin.payment_freelancer(contract.team.user, contract.user, contract.team, amount, contract.job) ws.pay_order = order ws.save() contract.total_amount += amount contract.stone_status = "carry" contract.save() if amount != ws.amount: margin.refund_amount(contract.team.user, contract.team, contract.job, ws.amount-amount) rd.audit_at = now rd.save() contract.status = "pause" contract.save() except: logger.error(traceback.format_exc()) txn.rollback()
def get_jwt_token( data, token_type="access", expires_delta: timedelta = timedelta(minutes=15) ): to_encode = data.copy() expire = common_utils.now() + expires_delta to_encode.update({"exp": expire, "token_type": token_type}) encoded_jwt = jwt.encode( to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM ) return encoded_jwt
def im_session_verify(params): token = params.get("session_token") session = Session.select().where(Session.session_key==token, Session.expire_at>utils.now()).first() if not session: return {"error_code":1, "msg":"token not exist"} user = session.user role, tid = user.app_identify[0], int(user.app_identify[1:]) if role == "f": return {"error_code":0, "msg":"ok", "id":user.id} team = Team.select().where(Team.id == tid).first() if not team: return {"error_code":1, "msg":"token error"} return {"error_code":0, "msg":"ok", "id":team.id}
def job_view(body): if "uuid" not in body or "user_id" not in body: return job = Job.select().where(Job.job_uuid==body["uuid"]).first() if not job or job.user_id != body["user_id"]: return job.last_view_time = utils.now() job.save() qs = Proposal.update(is_view=True).where(Proposal.job==job) qs.execute() return
def post_bookmarks(version: Version) -> Dict[str, Any]: if not accept_new_syncs(): raise BadRequestException("Server is not accepting new syncs") bookmarks = BookmarksModel(id_=new_id(), bookmarks="", last_updated=now(), version=version.version) get_document(bookmarks.id_).set(bookmarks.dict()) return { "id": bookmarks.id_, "lastUpdated": bookmarks.last_updated.isoformat(), "version": bookmarks.version }
def identification(user, params): name = params.get("name") id_number = params.get("id_number") if not name or not id_number: return {"error_code": 80002, "msg": "no enough parameters"} if not 15 <= len(id_number) <= 18 or not id_number[:-1].isdigit(): return {"error_code": 80002, "msg": "id_number invalid"} profile = user.profile.first() # verify user record into profile table if profile.id_number: return {"error_code": 20262, "msg": "already verify"} tmp = Profile.select().where(Profile.id_number == id_number).first() if tmp: return {"error_code": 20262, "msg": "already verify"} key, value = misc.generate_verify_init_data(user, "id_number") m = misc.misc_get_or_create(key=key, value=value) misc_value = utils.loads(m.value) if misc_value['id_verify_count'] >= 3: return {"error_code": 20263, "msg": "verify too many times"} # verify remote try: is_verify = id_verify_remote(name, id_number) except: return {"error_code": 20264, "msg": "verify failed"} if not is_verify: misc_value['id_verify_count'] += 1 misc_value['last_verify_time'] = utils.now() misc.misc_update(key, misc_value) return {"error_code": 20264, "msg": "verify failed"} else: misc.misc_delete(key) profile.name = name profile.id_number = id_number profile.save() team_id = user.identify[1:] if user.identify[0] != "f" else None queue.to_queue({ "type": "user_identify", "user_id": user.id, "team_id": team_id }) return {"error_code": 0, "msg": "ok"}
def password_reset(params): uname = params.get('username') password = params.get('password') if not uname or not password: return {"error_code":20091, "msg":"parameters required"} user = User.select().where(User.username == uname).first() if not user: return {"error_code":20093, "msg":"user not exists"} pw, salt = generate_password(password) user.password = pw user.salt = salt user.update_at = utils.now() user.save() return {"error_code":0, "msg":"ok"}
def timediff_format(value, fmt="%Y-%m-%d %H:%M:%S"): dt = datetime.datetime.strptime(value, fmt) now = utils.now() delta = now - dt seconds = delta.total_seconds() if seconds < 60: return "%s second ago" % seconds if seconds >= 60 and seconds < 3600: return "%s minute ago" % int(seconds / 60) if seconds >= 3600 and seconds < 86400: return "%s hour ago" % int(seconds / 3600) if seconds >= 86400 and seconds < 2592000: return "%s day ago" % int(seconds / 86400) if seconds >= 2592000 and seconds < 31104000: return "%s month ago" % int(seconds / 2592000) return "%s year ago" % int(seconds / 31104000)
def password_reset(params): uname = params.get('username') password = params.get('password') if not uname or not password: return {"error_code": 20091, "msg": "parameters required"} user = User.select().where(User.username == uname).first() if not user: return {"error_code": 20093, "msg": "user not exists"} pw, salt = generate_password(password) user.password = pw user.salt = salt user.update_at = utils.now() user.save() return {"error_code": 0, "msg": "ok"}
def user_discover_view(body): if "uuid" not in body or "user_id" not in body: return now = utils.now() period = utils.datetime_to_day_number(now) user = User.select().where(User.uuid==body["uuid"]).first() if not user or user.id == int(body["user_id"]): return ud = UserDiscover.select().where(UserDiscover.user==user, UserDiscover.period==period).first() if not ud: ud = UserDiscover() ud.user = user ud.period = utils.datetime_to_day_number(now) ud.view_num += 1 ud.update_at = now ud.save() return
def put_bookmarks(id_: str, bookmarks_patch: BookmarksPatch) -> Dict[str, Any]: doc_ref = get_document(id_) doc = doc_ref.get() if not doc.exists: raise NotFoundException() bookmarks = BookmarksModel(**doc.to_dict()) if bookmarks.last_updated != bookmarks_patch.last_updated: raise BadRequestException( f"lastUpdated does not match: {bookmarks_patch.last_updated.isoformat()} != {bookmarks.last_updated.isoformat()}" ) bookmarks.bookmarks = bookmarks_patch.bookmarks bookmarks.last_updated = now() doc_ref.set(bookmarks.dict()) return {"lastUpdated": bookmarks.last_updated.isoformat()}
def check_offer_expire(body): # offer 2 天没处理就过期,钱退回到账户 now = utils.now() start = utils.timedelta(now, days=-2) # TODO 分页 records = Contract.select().where(Contract.create_at<=start, Contract.status=='paid') for contract in records: with database.atomic() as txn: try: contract.status = "expire" contract.expire_at = now contract.save() margin.refund_amount(contract.team.user, contract.team, contract.job, contract.amount) # send msg to user queue.to_queue({"type": "contract_expire", "contract_id": contract.id}) except: txn.rollback()
def mobile_descriptor(request, identifier, version): from repository.utils import MetadataXml metadata_xml = MetadataXml('preview', identifier, version) monitor = utils.CollectionXMLReferenceMonitor(identifier, version) if metadata_xml.mobile_variant is None: raise Http404() collection = utils.prefetch_collection(identifier, version, metadata_xml.mobile_variant, modules=False) last = format_timestamp(now()) ready = False formats = collection.get_static_formats_for_category('mobile') for f in formats: if f.uncompressed_size != None: ready = True if not ready: monitor.mark_failure() descriptor = { 'md_content_id': identifier, 'md_version': version, 'md_title': collection.md_title, 'state': { 'comment': 'Hello', 'ready': ready, 'lastmodified': last, 'lasttransformed': last, }, 'formats': [{ 'url': make_schemeless(f.get_absolute_url()), 'format': f.specification.public_name, 'size': f.uncompressed_size if f.uncompressed_size is not None else (-1) } for f in formats], } for app, ver in mobile_apps_versions().items(): descriptor['app_version_%s' % app] = ver return JsonResponse(descriptor)
def identification(user, params): name = params.get("name") id_number = params.get("id_number") if not name or not id_number: return {"error_code": 80002, "msg": "no enough parameters"} if not 15 <= len(id_number) <= 18 or not id_number[:-1].isdigit(): return {"error_code": 80002, "msg": "id_number invalid"} profile = user.profile.first() # verify user record into profile table if profile.id_number: return {"error_code": 20262, "msg": "already verify"} tmp = Profile.select().where(Profile.id_number == id_number).first() if tmp: return {"error_code": 20262, "msg": "already verify"} key, value = misc.generate_verify_init_data(user, "id_number") m = misc.misc_get_or_create(key=key, value=value) misc_value = utils.loads(m.value) if misc_value['id_verify_count'] >= 3: return {"error_code": 20263, "msg": "verify too many times"} # verify remote try: is_verify = id_verify_remote(name, id_number) except: return {"error_code": 20264, "msg": "verify failed"} if not is_verify: misc_value['id_verify_count'] += 1 misc_value['last_verify_time'] = utils.now() misc.misc_update(key, misc_value) return {"error_code": 20264, "msg": "verify failed"} else: misc.misc_delete(key) profile.name = name profile.id_number = id_number profile.save() team_id = user.identify[1:] if user.identify[0] != "f" else None queue.to_queue({"type": "user_identify", "user_id": user.id, "team_id": team_id}) return {"error_code": 0, "msg": "ok"}
def execute(action): print("=" * 80) print("== migration %s" % action) print("=" * 80) with open(action, "rb") as fh: cont = fh.read() cont = cont.decode() lines = cont.split(";") lines = [x.strip() for x in lines if x.strip() != ""] for line in lines: if line and not line.startswith("--") and not line.startswith( "/*"): print("execute sql : %s\n" % line) database.execute_sql(line) sql = "insert into migration (action, created_at) values ('%s','%s')" % ( action, utils.now()) database.execute_sql(sql)
def password_change(user, params): password_old = params.get("password_old") password = params.get("password") if not password_old or not password: return {"error_code": 80002, "msg": "no enough parameters"} if not validate.is_password(password_old) or not validate.is_password(password): return {"error_code": 80003, "msg": "parameters illegal"} if not check_password(password_old, user.password, user.salt): return {"error_code": 20094, "msg": "password invalid"} pw, salt = generate_password(password) user.password = pw user.salt = salt user.update_at = utils.now() user.save() return logout(user)
def login(uname, password): if not uname or not password: return {"error_code":20001, "msg":"parameters required"} user = SystemUser.select().where(SystemUser.username == uname).first() if not user: return {"error_code":20002, "msg":"user not exists"} if not check_password(password, user.password, user.salt): return {"error_code":20003, "msg":"username or password invalid"} res = {"error_code":0, "msg":"ok"} res['session_token'] = generate_token() sess = Session() sess.user = user sess.session_key = res['session_token'] sess.expire_at = utils.timedelta(utils.now(), days=1) res['expire_at'] = 0 sess.save() return res
def login(uname, password): if not uname or not password: return {"error_code":20001, "msg":"parameters required"} user = User.select().where(User.username == uname or User.email == uname or User.phone == uname).first() if not user: return {"error_code":20002, "msg":"user not exists"} if not check_password(password, user.password, user.salt): return {"error_code":20003, "msg":"username or password invalid"} res = {"error_code":0, "msg":"ok"} res['session_token'] = generate_token() sess = Session() sess.user = user sess.session_key = res['session_token'] sess.expire_at = utils.timedelta(utils.now(), days=1) res['expire_at'] = 0 sess.save() return res
def user_discover(body): if "user_ids" not in body or not body["user_ids"]: return now = utils.now() period = utils.datetime_to_day_number(now) with database.atomic() as txn: dis = UserDiscover.select().where(UserDiscover.user << body["user_ids"], UserDiscover.period == period) exist_ids = [] for ud in dis: ud.update_at = now ud.discover_num += 1 ud.save() exist_ids.append(ud.user_id) not_ids = list(set(body["user_ids"]) - set(exist_ids)) for user_id in not_ids: ud = UserDiscover() ud.user = user_id ud.period = period ud.update_at = now ud.discover_num = 1 ud.save() return
def question_update(user, params): question_id = utils.safe_id(params.get('question_id')) answer_old = params.get('answer_old') answer = params.get('answer') if not question_id or not answer_old or not answer: return {"error_code": 80002, "msg": "no enough parameters"} question = Question.select().where(Question.id == question_id).first() if not question: return {"error_code": 20242, "msg": "protect question not exists"} uq = UserQuestion.select().where(UserQuestion.user == user).first() if not uq: return {"error_code": 20241, "msg": "user protect question not exists"} if uq.answer != answer_old: return {"error_code": 20244, "msg": "error answer"} uq.question = question_id uq.answer = answer uq.create_at = utils.now() uq.save() return {"error_code": 0, "msg": "ok"}
def verify_code(phone, code): vcode = VerifyCode.select().where(VerifyCode.phone == phone).first() if not vcode: return {"error_code":20031, "msg":"verify code not exists"} if vcode.vcount >= 3: return {"error_code":20033, "msg":"verify large than 3 times"} if vcode.code != code: vcode.vcount += 1 vcode.save() return {"error_code":20032, "msg":"verify invalid"} now = utils.now() if (now - vcode.last_verity_time) >= datetime.timedelta(minutes=5): return {"error_code":20034, "msg":"verify is expires"} if vcode.is_used: return {"error_code":20035, "msg":"verify is used"} vcode.is_used = True vcode.vcount = 0 vcode.save() return {"error_code":0, "msg":"ok"}
def update_last_seen(self) -> None: """ Handles all the needed operations to update the last seen date """ self.last_seen = now() self.save()
def generate_token(): return utils.rand_str(24) + utils.md5(str(utils.now()))[8:24]
def cleanup_session(): logger.error("%s cleanup session" % utils.now()) with queue_conn.connect(): with queue_conn.SimpleQueue(cron_queue) as queue: queue.put({"type": "cleanup_session"})
def calc_user_discover(): logger.error("%s calc freelancer discover" % utils.now()) with queue_conn.connect(): with queue_conn.SimpleQueue(cron_queue) as queue: queue.put({"type": "calc_user_discover"})
def generate_weekstone_day_report(): logger.error("%s generate weekstone day report" % utils.now()) with queue_conn.connect(): with queue_conn.SimpleQueue(cron_queue) as queue: queue.put({"type": "weekstone_day_report"})
def auto_pay_weekstone(): logger.error("%s auto pay weekstone" % utils.now()) with queue_conn.connect(): with queue_conn.SimpleQueue(cron_queue) as queue: queue.put({"type": "auto_pay_weekstone"})
def count_weekstone(): logger.error("%s count weekstone" % utils.now()) with queue_conn.connect(): with queue_conn.SimpleQueue(cron_queue) as queue: queue.put({"type": "count_weekstone"})
def check_offer_expire(): logger.error("%s check expire offer" % utils.now()) with queue_conn.connect(): with queue_conn.SimpleQueue(cron_queue) as queue: queue.put({"type": "check_offer_expire"})
def cleanup_session(body): now = utils.now() qs = Session.delete().where(Session.expire_at <= now) qs.execute()
def initialize(self): token = self.get_cookie("session_token") self.is_mobile, self.is_desktop = False, False self.user = None if token: session = Session.select().where(Session.session_key==token, Session.expire_at>now()).first() if session: self.user = session.user self.params = {key: value[-1] for key, value in self.request.arguments.items()}