def update_profile(request, body, *args, **kwargs):
update_profile_dto = UpdateProfileDTO()
body_extract(body, update_profile_dto)
timestamp = mills_timestamp()
user_id = request.session.get('user').get('id')
try:
user = User.objects.get(user_id=user_id, status=UserStatus.valid.key)
except ObjectDoesNotExist as e:
logger.info("Update Profile: %s" % e)
resp = init_http_response_my_enum(RespCode.server_error)
return make_json_response(HttpResponse, resp)
if update_profile_dto.first_name:
user.first_name = update_profile_dto.first_name
if update_profile_dto.last_name:
user.last_name = update_profile_dto.last_name
if update_profile_dto.avatar:
user.avatar_url = update_profile_dto.avatar
if update_profile_dto.theme:
user.theme = update_profile_dto.theme
if update_profile_dto.password:
user.password = update_profile_dto.password_md5
user.update_date = timestamp
user.save()
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(HttpResponse, resp)
def forget_password(request, body, *args, **kwargs):
try:
email = body['email']
user = User.objects.get(email=email, status=UserStatus.valid.key)
except Exception as e:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
existed_forget = ForgetPassword.objects.filter(
user_id=user.user_id, status=Status.valid.key).first()
if existed_forget:
existed_forget.status = Status.invalid.key
existed_forget.save()
code = get_validate_code()
timestamp = mills_timestamp()
expired = timestamp + FORGET_EXPIRED
forget = ForgetPassword(user_id=user.user_id,
code=code,
expired=expired,
status=Status.valid.key,
create_date=timestamp,
update_date=timestamp)
forget.save()
content = str(FORGET_TEMPLATE).replace(PATTERN_FULLNAME, user.full_name)\
.replace(PATTERN_URL, get_forget_link(forget.code))
smtp_thread.put_task(SendEmailAction.forget.value, user.user_id,
forget.record_id, user.email, content)
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(resp=resp)
def update_tab(request, body, *args, **kwargs):
tab_id = kwargs.get('id')
user_id = request.session.get('user').get('id')
tab_dto = TabDTO()
body_extract(body, tab_dto)
try:
tab = TabPage.objects.get(tab_id=tab_id,
user_id=user_id,
status=Status.valid.key)
if tab_dto.title:
tab.title = tab_dto.title
if tab_dto.content:
tab.content = tab_dto.content
tab.update_date = mills_timestamp()
tab.save()
except ObjectDoesNotExist as e:
logger.info('Update Tab: %s' % e)
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(HttpResponse, resp)
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(HttpResponse, resp)
def add_tab(request, body, *args, **kwargs):
user_id = request.session.get('user').get('id')
timestamp = mills_timestamp()
tab_dto = TabDTO()
body_extract(body, tab_dto)
if tab_dto.is_empty:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(HttpResponse, resp)
tab = TabPage(user_id=user_id,
title=tab_dto.title,
content=tab_dto.content,
status=Status.valid.key,
create_date=timestamp,
update_date=timestamp)
tab.save()
resp = init_http_response_my_enum(RespCode.success)
resp['data'] = dict(
tab_id=tab.tab_id,
title=tab.title,
)
return make_json_response(HttpResponse, resp)
def update_file(request, file_name, *args, **kwargs):
picture = request.FILES.get('picture', None)
if not picture or not file_name:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
with open(os.path.join(file_path, file_name + '.jpg'), 'wb+') as f:
for chunk in picture.chunks():
f.write(chunk)
data = dict(file_id=file_name, )
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def download_file(request, file_name, *args, **kwargs):
if not file_name:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
if not os.path.exists(file_path + '/' + file_name + '.jpg'):
resp = init_http_response_my_enum(RespCode.invalid_file)
return make_json_response(resp=resp)
resp = StreamingHttpResponse(file_iterator(
os.path.join(file_path, file_name + '.jpg')),
content_type='image/jpeg')
resp['Content-Disposition'] = 'attachment;filename="{}"'.format(file_name +
'.jpg')
return resp
def get_profile(request, *args, **kwargs):
user_id = request.session.get('user').get('id')
try:
user = User.objects.get(user_id=user_id, status=UserStatus.valid.key)
except ObjectDoesNotExist as e:
logger.info("Get Profile: %s" % e)
resp = init_http_response_my_enum(RespCode.server_error)
return make_json_response(HttpResponse, resp)
resp = init_http_response_my_enum(RespCode.success)
resp['data'] = dict(
first_name=user.first_name,
last_name=user.last_name,
avatar=user.avatar_url,
theme=user.theme,
)
return make_json_response(HttpResponse, resp)
def login(request, body, *args, **kwargs):
"""
Login
:param request:
:param body:
:param args:
:param kwargs:
:return:
"""
login_dto = LoginDTO()
body_extract(body, login_dto)
if login_dto.is_empty or login_dto.invalid_email:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(HttpResponse, resp)
try:
user = User.objects.get(email=login_dto.email,
password=login_dto.password_md5,
status=UserStatus.valid.key)
except ObjectDoesNotExist as e:
resp = init_http_response_my_enum(RespCode.login_fail)
return make_json_response(HttpResponse, resp)
session_data = dict(
id=user.user_id,
name=user.full_name,
is_login=True,
)
request.session['user'] = session_data
data = dict(
user_id=user.user_id,
name=user.full_name,
theme=user.theme,
avatar=user.avatar_url,
)
resp = init_http_response_my_enum(RespCode.success)
resp['data'] = data
return make_json_response(HttpResponse, resp)
def upload_file(request, *args, **kwargs):
picture = request.FILES.get('picture', None)
if not picture:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
file_name = get_validate_code(3)
logger.info('[FILE] Writing File ' + file_path + '/' + file_name + '.jpg')
# while os.path.exists(file_path + '/' + file_name + '.jpg'):
# file_name = get_validate_code(3)
with open(os.path.join(file_path, file_name + '.jpg'), 'wb+') as f:
for chunk in picture.chunks():
f.write(chunk)
data = dict(file_id=file_name, )
resp = init_http_response_my_enum(RespCode.success, data)
return make_json_response(resp=resp)
def get_tab(request, tab_id, *args, **kwargs):
user_id = request.session.get('user').get('id')
try:
tab = TabPage.objects.get(user_id=user_id,
tab_id=tab_id,
status=Status.valid.key)
except ObjectDoesNotExist as e:
logger.info('Get Tab: %s' % e)
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(HttpResponse, resp)
resp = init_http_response_my_enum(RespCode.success)
resp['data'] = dict(
title=tab.title,
content=tab.content,
update_time=tab.update_date,
)
return make_json_response(HttpResponse, resp)
def file_router(request, *args, **kwargs):
file_id = None
if isinstance(kwargs, dict):
file_id = kwargs.get('id', None)
if request.method == 'GET' and file_id:
return download_file(request, file_id, *args, **kwargs)
elif request.method == 'POST':
if file_id:
return update_file(request, file_id, *args, **kwargs)
else:
return upload_file(request, *args, **kwargs)
return make_json_response(HttpResponseBadRequest, None)
def forget_validate(request, body, *args, **kwargs):
reset_dto = ResetPasswordDTO()
body_extract(body, reset_dto)
if reset_dto.is_empty:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(resp=resp)
timestamp = mills_timestamp()
try:
record = ForgetPassword.objects.get(code=reset_dto.code,
status=Status.valid.key)
user = User.objects.get(user_id=record.user_id,
status=UserStatus.valid.key)
if record.expired <= timestamp:
with transaction.atomic():
record.status = Status.invalid.key
record.update_date = timestamp
record.save()
resp = init_http_response_my_enum(RespCode.expired)
return make_json_response(resp=resp)
with transaction.atomic():
user.password = reset_dto.password_md5
user.save()
record.status = Status.invalid.key
record.update_date = timestamp
record.save()
except ObjectDoesNotExist as e:
logger.info('Validate Error: %s' % e)
resp = init_http_response_my_enum(RespCode.validate_fail)
return make_json_response(resp=resp)
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(resp=resp)
def logout(request, *args, **kwargs):
"""
Logout
:param request:
:param args:
:param kwargs:
:return:
"""
request.session.flush()
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(HttpResponse, resp)
def multi_get_tab(request, *args, **kwargs):
user_id = request.session.get('user').get('id')
tabs = TabPage.objects.filter(
user_id=user_id, status=Status.valid.key).order_by('-create_date')
tabs = [dict(
tab_id=t.tab_id,
title=t.title,
) for t in tabs]
resp = init_http_response_my_enum(RespCode.success)
resp['data'] = dict(tabs=tabs, )
return make_json_response(HttpResponse, resp)
def delete_tab(request, *args, **kwargs):
tab_id = kwargs.get('id', None)
user_id = request.session.get('user').get('id')
if not tab_id:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(HttpResponse, resp)
try:
tab = TabPage.objects.get(tab_id=tab_id,
user_id=user_id,
status=Status.valid.key)
tab.status = Status.invalid.key
tab.update_date = mills_timestamp()
tab.save()
except ObjectDoesNotExist as e:
logger.info('Delete Tab: %s' % e)
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(HttpResponse, resp)
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(HttpResponse, resp)
def validate(request, body, *args, **kwargs):
code = body['code']
timestamp = mills_timestamp()
try:
record = RegisterRecord.objects.get(code=code, status=Status.valid.key)
print(record)
user = User.objects.get(user_id=record.user_id,
status=UserStatus.wait_accept.key)
print(user)
if record.expired <= timestamp:
with transaction.atomic():
record.status = Status.invalid.key
record.update_date = timestamp
user.status = UserStatus.expired.key
user.update_date = timestamp
record.save()
user.save()
resp = init_http_response_my_enum(RespCode.expired)
return make_json_response(HttpResponse, resp)
except ObjectDoesNotExist as e:
logger.info('Validate Error: %s' % e)
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(HttpResponse, resp)
with transaction.atomic():
record.status = Status.invalid.key
record.update_date = timestamp
user.status = UserStatus.valid.key
user.update_date = timestamp
user.save()
record.save()
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(HttpResponse, resp)
def register(request, body, *args, **kwargs):
"""
Register
:param request:
:param body:
:param args:
:param kwargs:
:return:
"""
register_dto = RegisterDTO()
body_extract(body, register_dto)
timestamp = mills_timestamp()
if register_dto.is_empty or register_dto.invalid_email:
resp = init_http_response_my_enum(RespCode.invalid_parameter)
return make_json_response(HttpResponse, resp)
"""
Check if the user register record expired, and if the user already existed
"""
existed_user = User.objects.filter(
email=register_dto.email, status__lte=UserStatus.valid.key).first()
if existed_user is not None:
if existed_user.status == UserStatus.valid.key:
resp = init_http_response_my_enum(RespCode.account_existed)
return make_json_response(HttpResponse, resp)
existed_record = RegisterRecord.objects.filter(
user_id=existed_user.user_id, status=Status.valid.key).first()
if existed_record is None:
resp = init_http_response_my_enum(RespCode.server_error)
return make_json_response(HttpResponse, resp)
if existed_record.expired <= timestamp:
logger.info('Registration Expired: %s' % existed_user)
with transaction.atomic():
existed_record.status = Status.invalid.key
existed_record.update_date = timestamp
existed_user.status = UserStatus.expired.key
existed_user.update_date = timestamp
existed_record.save()
existed_user.save()
else:
if existed_user.update_date + INVITATION_EXPIRED / 10 < timestamp:
logger.info('Resend Validation Email: %s' % existed_user)
content = str(INVITATION_TEMPLATE).replace(PATTERN_FULLNAME, existed_user.full_name) \
.replace(PATTERN_URL, get_invitation_link(existed_record.code))
smtp_thread.put_task(SendEmailAction.register.value,
existed_user.user_id,
existed_record.record_id,
existed_user.email, content)
resp = init_http_response_my_enum(RespCode.resend_email)
return make_json_response(HttpResponse, resp)
expired = timestamp + INVITATION_EXPIRED # 1min
code = get_validate_code()
try:
with transaction.atomic():
user = User(email=register_dto.email,
password=register_dto.password_md5,
avatar_url=DEFAULT_AVATAR,
first_name=register_dto.first_name,
last_name=register_dto.last_name,
theme=DEFAULT_THEME,
status=UserStatus.created.key,
create_date=timestamp,
update_date=timestamp)
user.save()
record = RegisterRecord(user_id=user.user_id,
code=code,
expired=expired,
status=Status.valid.key,
create_date=timestamp,
update_date=timestamp)
record.save()
except Exception as e:
logger.error(e)
resp = init_http_response_my_enum(RespCode.server_error)
return make_json_response(HttpResponse, resp)
content = str(INVITATION_TEMPLATE).replace(PATTERN_FULLNAME, user.full_name) \
.replace(PATTERN_URL, get_invitation_link(record.code))
smtp_thread.put_task(SendEmailAction.register.value, user.user_id,
record.record_id, user.email, content)
resp = init_http_response_my_enum(RespCode.success)
return make_json_response(HttpResponse, resp)
