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 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 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 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 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 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 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 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 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()}
