def _wrapper(request, *args, **kwargs):
try:
return fn(request, *args, **kwargs)
except ArgumentError as e:
obj = {u'msg': e.message}
return HttpResponseBadRequest(json.dumps(obj))
except AppNotFoundExp as e:
obj = {u'msg': e.message}
return HttpResponseNotFound(json.dumps(obj))
except DeviceNotFoundExp as e:
obj = {u'msg': e.message}
return HttpResponseNotFound(json.dumps(obj))
except MultiDeviceFoundExp as e:
obj = {u'msg': e.message}
return HttpResponseServerError(json.dumps(obj))
except MultiAppFoundExp as e:
obj = {u'msg': e.message}
return HttpResponseServerError(json.dumps(obj))
except GatewayApiError as e:
obj = {u'msg': e.message}
return HttpResponseServerError(json.dumps(obj))
except GatewayTimeoutError as e:
obj = {u'msg': e.message}
return HttpResponseServerError(json.dumps(obj))
except GatewayCallError as e:
obj = {u'msg': e.message}
return HttpResponseServerError(json.dumps(obj))
def task_solve(request, task_pk):
response_data = {}
if request.method == "POST":
try:
task = Task.objects.get(pk=task_pk)
flag = request.POST["flag"]
if flag.strip() == task.flag:
solve = SolvedTasks(team=request.user, task=task)
try:
solve.save()
response_data["result"] = "success"
return HttpResponse(json.dumps(response_data),
content_type="application/json")
except ValidationError:
response_data["result"] = "failed"
return HttpResponse(json.dumps(response_data),
content_type="application/json")
else:
response_data["result"] = "failed"
return HttpResponse(json.dumps(response_data),
content_type="application/json")
except Task.DoesNotExist:
return HttpResponseNotFound("Task not found")
else:
return HttpResponseNotFound("Not Found")
def match_accept(request, user_id=None):
comrade = User.objects.get(id=str(user_id))
match = Match.objects.filter(user1=request.user, user2=comrade)
if match:
if len(match) > 1:
return HttpResponseNotFound(
'<h1>Error. W bazie sa 2 takie same matche. Skontaktuj sie z administracja</h1>')
m = match[0]
if m.personal_questions_match == Match.Agreement.AGREE_2_TO_1:
m.personal_questions_match = Match.Agreement.AGREE_BOTH
else:
m.personal_questions_match = Match.Agreement.AGREE_1_TO_2
m.save()
else:
match = Match.objects.filter(user2=request.user, user1=comrade)
if len(match) > 1:
return HttpResponseNotFound(
'<h1>Error. W bazie sa 2 takie same matche. Skontaktuj sie z administracja</h1>')
if match:
m = match[0]
if m.personal_questions_match == Match.Agreement.AGREE_1_TO_2:
m.personal_questions_match = Match.Agreement.AGREE_BOTH
else:
m.personal_questions_match = Match.Agreement.AGREE_2_TO_1
m.save()
else:
return HttpResponseNotFound('<h1>Error. W bazie nie ma danego matcha. Skontaktuj sie z administracja</h1>')
questions_delete(request.user, comrade) # usuwam odpowiedzi comrade'a na pytania zalogowanego uzytkownika
return redirect("view_answers")
def login_request(request):
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
attempt_user = User.objects.get(username=username)
attempt_my_user = MyUser.objects.get(user_id=attempt_user.id)
# print(attempt_my_user.retry_times)
if attempt_my_user.retry_times >= 3:
attempt_user.is_active = False
attempt_user.save()
return HttpResponseNotFound('<h1>This account is disabled</h1>')
if user is not None:
login(request, user)
attempt_my_user.retry_times = 0
attempt_my_user.save()
return HttpResponseRedirect(reverse('pm:index'))
else:
attempt_my_user.retry_times += 1
attempt_my_user.save()
return HttpResponseNotFound('<h1>User not found</h1>')
def open_task(request, contest_id, task_id, participant_id):
contest = get_object_or_404(models.TaskBasedContest, pk=contest_id)
task = get_object_or_404(tasks_models.Task, pk=task_id)
if not contest.has_task(task):
return HttpResponseNotFound()
if not is_manual_task_opening_available_in_contest(contest):
messages.error(request, 'Manual task opening is forbidden for this contest')
return redirect(urls.reverse('contests:task_opens', args=[contest.id, task.id]))
participant = get_object_or_404(models.AbstractParticipant, pk=participant_id)
if participant.contest_id != contest.id:
return HttpResponseNotFound()
qs = tasks_models.ManualOpenedTask.objects.filter(
contest=contest,
task=task,
participant=participant
)
# Toggle opens state: close if it's open, open otherwise
if qs.exists():
qs.delete()
if is_task_open(contest, task, participant):
messages.warning(request, 'Task is opened for this participant not manually, you can\'t close it')
else:
messages.success(request, 'Task is closed for %s' % participant.name)
else:
tasks_models.ManualOpenedTask(
contest=contest,
task=task,
participant=participant
).save()
messages.success(request, 'Task is opened for %s' % participant.name)
return JsonResponse({'done': 'ok'})
def get_file_view(request):
id = request.GET.get('id', None)
if id is None:
return HttpResponseNotFound()
# determine whether user has permission to download private file:
perm_private = request.user.has_perm(
'seminar.download_private_file') if request.user is not None else False
try:
s_file = SeminarFile.objects.get(id=id)
if not s_file.seminar.public and not perm_private:
return HttpResponseNotFound()
s_file.download_count += 1
s_file.save()
except SeminarFile.DoesNotExist:
return HttpResponseNotFound()
else:
response = FileResponse(open(s_file.path.path),
content_type='application/octet-stream')
response[
'Content-Disposition'] = 'attachment;filename="{filename}"'.format(
filename=urllib.quote(
s_file.filename.encode(sys.getdefaultencoding())))
return response
def task_file(request, contest_id, file_id):
contest = get_object_or_404(models.TaskBasedContest, pk=contest_id)
if not contest.is_visible_in_list and not request.user.is_staff:
return HttpResponseNotFound()
file = get_object_or_404(tasks_models.TaskFile, pk=file_id)
if not contest.has_task(file.task):
return HttpResponseNotFound()
if file.is_private:
return HttpResponseForbidden()
participant = contest.get_participant_for_user(request.user)
if not contest.is_started_for(participant) and not request.user.is_staff:
return HttpResponseForbidden('Contest is not started')
if not is_task_open(contest, file.task, participant) and not request.user.is_staff:
return HttpResponseForbidden('Task is closed')
if file.participant is not None and file.participant.id != request.user.id:
return HttpResponseForbidden()
file_path = file.get_path_abspath()
return respond_as_attachment(request, file_path, file.name, file.content_type)
def yatse_api(request):
try:
if request.method != 'PROPFIND':
api_login(request)
except PermissionDenied:
return HttpResponseForbidden(request.META.get('HTTP_API_USER'))
if request.method == 'PROPPATCH':
data = json.loads(request.body)
if 'ticket' in data and 'method' in data:
if data['method'] == 'notify':
tickets_participants.objects.filter(
ticket=data['ticket'], user=request.user).update(seen=True)
return HttpResponse('OK')
return HttpResponseNotFound('invalid method\n\n%s' % request.body)
elif request.method == 'PROPFIND':
fields = buildYATSFields([])
return JsonResponse(fields[0], safe=False)
elif request.method == 'SEARCH':
return JsonResponse(YATSSearch(request), safe=False)
else:
return HttpResponseNotFound('invalid method')
def edit_category(request, contest_id, category_id):
contest = get_object_or_404(models.TaskBasedContest, pk=contest_id)
participant = contest.get_participant_for_user(request.user)
if contest.tasks_grouping != models.TasksGroping.ByCategories:
return HttpResponseNotFound()
category = get_object_or_404(categories_models.Category, pk=category_id)
if not contest.categories_list.categories.filter(id=category.id).exists():
return HttpResponseNotFound()
if request.method == 'POST':
form = forms.CategoryForm(data=request.POST)
if form.is_valid():
new_category = categories_models.Category(
name=form.cleaned_data['name'],
description=form.cleaned_data['description']
)
new_category.id = category.id
new_category.save()
return redirect(urlresolvers.reverse('contests:tasks', args=[contest.id]))
else:
form = forms.CategoryForm(initial=category.__dict__)
return render(request, "contests/edit_category.html", {
'current_contest': contest,
'contest': contest,
'participant': participant,
'category': category,
'form': form,
})
def func_wrapper(request, *args, **kwargs):
if not request.user.is_authenticated:
return HttpResponseNotFound()
if request.user.is_superuser:
return handler(request, *args, **kwargs)
school = getattr(request, 'school', None)
matched_groups = AbstractGroup.objects.filter(
Q(short_name__in=group_names)
& (Q(school=school) | Q(school__isnull=True)))
groups_by_short_name = {}
for group in matched_groups:
groups_by_short_name[group.short_name] = group
# At first check all names for existing
for group_name in group_names:
if group_name not in groups_by_short_name:
raise ValueError(
'Invalid group_name in only_for_groups(): %s. '
'Can\'t find this group for school %s' %
(group_name, school))
for group_name in group_names:
group = groups_by_short_name[group_name]
if group.is_user_in_group(request.user):
return handler(request, *args, **kwargs)
return HttpResponseNotFound()
def edit(request, team_id):
team = get_object_or_404(models.Team, pk=team_id)
# Only staff and team's captain can edit team
if not request.user.is_staff and team.captain != request.user:
return HttpResponseNotFound()
if settings.DRAPO_ONLY_STAFF_CAN_EDIT_TEAM_NAME and not request.user.is_staff:
return HttpResponseNotFound()
if request.method == 'POST':
form = forms.TeamForm(data=request.POST)
if form.is_valid():
team_name = form.cleaned_data['name']
with transaction.atomic():
if models.Team.objects.filter(name=team_name).exists():
form.add_error('name', 'Team with same name already exists')
else:
team.name = team_name
team.save()
messages.success(request, 'Team %s saved' % team.name)
return redirect(team)
else:
form = forms.TeamForm(initial={'name': team.name})
return render(request, 'teams/edit.html', {
'team': team,
'form': form,
})
def get(self, request):
#1获取所有信息
categories = ArticleCategory.objects.all()
#2接受用户点击的信息
cat_id = request.GET.get('cat_id', 1)
#3根据分类id进行分类的查询
try:
category = ArticleCategory.objects.get(id=cat_id)
except ArticleCategory.DoesNotExist:
return HttpResponseNotFound('没有此分类')
#4获取分页参数
page_num = request.GET.get('page_num', 1)
page_size = request.GET.get('page_size', 10)
#5根据分类信息查询文章数据
articles = Article.objects.filter(category=category)
#6创建分页器
from django.core.paginator import Paginator, EmptyPage
paginator = Paginator(articles, per_page=page_size)
#7进行分页处理
try:
page_articles = paginator.page(page_num)
except EmptyPage:
return HttpResponseNotFound('empty page')
#总页数
total_page = paginator.num_pages
#8组织数据传递给模板
context = {
'categories': categories,
'category': category,
'articles': page_articles,
'page_size': page_size,
'total_page': total_page,
'page_num': page_num,
}
return render(request, 'index.html', context=context)
def image(request):
url = request.GET.get('url')
if not url:
return HttpResponseNotFound('Provide a url get param')
image_path = get_image_cache_path(url)
if os.path.isfile(image_path):
image_file = open(image_path, 'rb')
return HttpResponse(image_file, content_type='image/' + os.path.splitext(image_path)[1][1:])
try:
response = requests.get(url)
except ConnectionError:
return HttpResponseNotFound('Error connecting to image host')
if response.status_code != 200:
return HttpResponseNotFound('Not Found')
if 'Last-Modified' in response.headers:
modified = parse_http_date_safe(response.headers['Last-Modified'])
else:
modified = time.mktime(timezone.now().utctimetuple())
with open(image_path, 'wb') as image_file:
image_file.write(response.content)
os.utime(image_path, (int(modified), int(modified)))
response = HttpResponse(response.content, content_type=response.headers['Content-Type'])
response['Last-Modified'] = http_date(modified)
return response
def retrieve(self, request, pk=None):
if not pk:
return HttpResponseNotFound()
obj = Subreddit.objects.filter(pk=pk).first()
if not obj:
return HttpResponseNotFound()
return Response(self.get_serializer(obj).data)
def watch_video(request):
video_id = request.GET.get('id', '')
if not video_id:
return HttpResponseNotFound('Not Found')
video_id = int(video_id)
v = video.VideoUnit.objects.get(id=video_id)
if not v:
return HttpResponseNotFound('Not Found')
context = {'video': v}
return render(request, 'video/watch.html', context)
def delete_category(request, contest_id, category_id):
contest = get_object_or_404(models.TaskBasedContest, pk=contest_id)
if contest.tasks_grouping != models.TasksGroping.ByCategories:
return HttpResponseNotFound()
category = get_object_or_404(categories_models.Category, pk=category_id)
if not contest.categories_list.categories.filter(id=category.id).exists():
return HttpResponseNotFound()
contest.categories_list.categories.remove(category)
contest.categories_list.save()
return redirect(urlresolvers.reverse('contests:tasks', args=[contest.id]))
def get(self, request):
"""
1.获取所有分类信息
2.接收用户点击的分类id
3.根据分类id进行分类的查询
# 4.获取分页参数
5.根据分类信息查询文章数据
6.创建分页器
7.进行分页处理
8.组织数据传递给模板
:param request:
:return:
"""
# 1.获取所有分类信息
categories = ArticleCategory.objects.all()
# 2.接收用户点击的分类id
cat_id = request.GET.get('cat_id', 1)
# 3.根据分类id进行分类的查询
try:
category = ArticleCategory.objects.get(id=cat_id)
# category = ActicleCategory.objects.get()
print(category)
except ArticleCategory.DoesNotExist:
return HttpResponseNotFound('请在后台添加分类')
# 4.获取分页参数
page_num = request.GET.get('page_num', 1)
page_size = request.GET.get('page_size', 10)
# 5.根据分类信息查询文章数据
articles = Article.objects.filter(category=category)
# 6.创建分页器
from django.core.paginator import Paginator, EmptyPage
paginator = Paginator(articles, page_size)
# 7.进行分页处理
try:
page_articles = paginator.page(page_num)
except EmptyPage:
return HttpResponseNotFound('empty page')
# 总页数
total_page = paginator.num_pages
# 8.组织数据传递给模板
context = {
'categories': categories,
'category': category,
'articles': page_articles,
'page_size': page_size,
'page_num': page_num,
'total_page': total_page
}
return render(request, 'index.html', context=context)
def split_create(request, run_id):
try:
run = Run.objects.get(pk=run_id)
except Run.DoesNotExist:
return HttpResponseNotFound("Run does not exist")
try:
distance = int(request.POST['meters_traveled'])
except KeyError as e:
return HttpResponseBadRequest("Argument {} is required".format(
e.args[0]))
except ValueError:
return HttpResponseBadRequest("'meters_traveled' must be an integer")
if run.finished:
return HttpResponseForbidden("Run has already finished")
timestamp = datetime.now().replace(microsecond=0)
if run.start_datetime > timestamp:
return HttpResponseForbidden("Run hasn't started yet")
try:
participation = Participation.objects.get(run=run, user=request.user)
except Participation.DoesNotExist:
return HttpResponseNotFound("You don't participate in this run")
last_split = Split.objects.filter(
participation=participation).order_by('timestamp').last()
if not last_split is None:
if last_split.distance >= run.distance * 1000:
return HttpResponseForbidden("You already passed the finish line.")
if distance < last_split.distance:
return HttpResponseForbidden("Cannot run backwards.")
try:
split = Split(
participation=participation,
distance=distance,
timestamp=timestamp,
)
split.full_clean()
except exceptions.ValidationError as e:
return HttpResponseBadRequest(e.messages[0])
split.save()
if distance >= run.distance * 1000: # just reached the end
reached_finish(run, participation)
return JsonResponse(split.serialize())
def run_quit(request, run_id):
try:
run = Run.objects.get(pk=run_id)
except Run.DoesNotExist:
return HttpResponseNotFound("Run does not exist")
try:
participation = Participation.objects.get(run=run, user=request.user)
participation.delete()
except Participation.DoesNotExist:
return HttpResponseNotFound("You don't participate in this run")
return MessageResponse("Successfully quit.")
def stop_watching(request, run_id):
try:
run = Run.objects.get(pk=run_id)
except Run.DoesNotExist:
return HttpResponseNotFound("Run does not exist")
try:
watching = Watching.objects.get(run=run, user=request.user)
watching.delete()
except Watching.DoesNotExist:
return HttpResponseNotFound("You aren't watching this run")
return MessageResponse("Stopped watching")
def remove_like(request, run_id):
try:
run = Run.objects.get(pk=run_id)
except Run.DoesNotExist:
return HttpResponseNotFound("Run does not exist")
try:
like = Like.objects.get(run=run, user=request.user)
like.delete()
except Like.DoesNotExist:
return HttpResponseNotFound("You haven't liked this run")
return MessageResponse("Run unliked")
def get(self, request):
global article
#接收文章id
id = request.GET.get('art_id')
#根据文章id进行文章数据的查询
try:
article = Article.objects.get(id=id)
except Article.DoesNotExist:
HttpResponseNotFound('该文章不存在了')
else:
article.total_views += 1
article.save()
#查询分类数据
categories = ArticleCategory.objects.all()
#查询浏览量前十的文章数据
hot_articles = Article.objects.order_by('-total_views')[:9]
#获取分页请求参数
page_size = request.GET.get('page_size', 10)
page_num = request.GET.get('page_num', 1)
#根据当前文章查询评论数据
comments = Comment.objects.filter(article=article).order_by('-created')
#获取评论总数
total_count = comments.count()
#创建分页器
from django.core.paginator import Paginator, EmptyPage
paginator = Paginator(comments, page_size)
#分页处理
try:
page_comments = paginator.page(page_num)
except EmptyPage:
return HttpResponseNotFound('Empty Page')
#获取总页数
total_page = paginator.num_pages
context = {
'categories': categories,
'category': article.category,
'article': article,
'hot_articles': hot_articles,
'total_count': total_count,
'comments': page_comments,
'page_size': page_size,
'total_page': total_page,
'page_num': page_num
}
return render(request, 'detail.html', context=context)
def run(self, request, id=None, *args, **kwargs):
if id is None:
return HttpResponseNotFound()
try:
model = self.model_class.objects.get(pk=id)
redirect_url = self.get_redirect_url(model)
model.delete()
return redirect(redirect_url)
except self.model_class.DoesNotExist:
pass
return HttpResponseNotFound()
def sumpost(request):
if request.method != 'POST':
return HttpResponseNotFound()
if 'stu_id' not in request.session:
return redirect('home')
try:
subs = loads(request.POST['subjects'])
except ValueError:
return HttpResponseNotFound()
else:
request.session['subjects'] = subs
return redirect('doofen:summary')
def show_result(request, collection_id):
""" Show the ranking of a group for collection_id.
If the user is staff then it receives the following GET parameters:
* group = Group ID (optional). If not set, use the first group in the system
* start = date YYYY-MM-DD (optional). If not set, first day of the current course
* end = date YYYY-MM-DD (optional). If not set, today
If the user is standard, then it receives the following GET parameter:
* group = Group ID (optional). If not set, use the first group of the user
"""
collection = get_object_or_404(Collection, pk=collection_id)
result_staff_form = ResultStaffForm(request.GET)
result_student_form = ResultStudentForm(request.GET)
if request.user.is_staff and result_staff_form.is_valid():
available_groups = Group.objects.all().order_by('name')
group_id = result_staff_form.cleaned_data.get('group')
start = result_staff_form.cleaned_data.get('start')
end = result_staff_form.cleaned_data.get('end')
elif not request.user.is_staff and result_student_form.is_valid():
available_groups = request.user.groups.all().order_by('name')
group_id = result_student_form.cleaned_data['group']
start, end = None, None
elif request.user.is_staff and not result_staff_form.is_valid():
# Error 404 with all the validation errors as HTML
return HttpResponseNotFound(str(result_staff_form.errors))
elif not result_student_form.is_valid():
# Error 404 with all the validation errors as HTML
return HttpResponseNotFound(str(result_student_form.errors))
if not available_groups:
return render(request, 'generic_error_message.html',
{'error': [_('¡Lo sentimos! No existe ningún grupo para ver la clasificación')]})
if group_id is None:
group_id = available_groups[0].pk
group = get_object_or_404(Group, pk=group_id)
if group not in available_groups:
return HttpResponseForbidden("Forbidden")
# Set start and end if they were not provided
start = first_day_of_course(datetime.today()) if start is None else start
end = datetime.today() if end is None else end
# Extends 'end' to 23:59:59 to cover today's latest submissions. Otherwise, ranking is not
# updated until next day (as plain dates have time 00:00:00)
end = datetime(end.year, end.month, end.day, 23, 59, 59)
ranking = collection.ranking(start, end, group)
return render(request, 'results.html', {'collection': collection, 'groups': available_groups,
'current_group': group,
'end_date': end, 'start_date': start,
'ranking': ranking})
def process_roi(request):
uuid = request.GET.get('id')
if uuid is None:
return HttpResponseNotFound()
try:
roi = ROILink.objects.get(uuid=uuid)
roi.visits += 1
roi.save()
except ROILink.DoesNotExist:
return HttpResponseNotFound()
print(roi.link)
return HttpResponseRedirect(roi.link)
def show_submissions(request):
"""Shows all the submissions of the current user"""
try:
pk_problem = request.GET.get('problem_id')
id_user = request.GET.get('user_id')
if pk_problem is not None or id_user is not None:
if int(id_user) == request.user.id and not request.user.is_staff:
start = request.GET.get('start')
end = request.GET.get('end')
if start is not None or end is not None:
return HttpResponseForbidden("Forbidden")
problem = get_object_or_404(Problem, pk=pk_problem)
subs = Submission.objects.filter(user=request.user).filter(problem=problem.id).order_by('-pk')
elif request.user.is_staff:
start = request.GET.get('start')
end = request.GET.get('end')
starts = datetime.strptime(start, '%Y-%m-%d')
ends = datetime.strptime(end, '%Y-%m-%d')
problem = get_object_or_404(Problem, pk=pk_problem)
user = get_user_model().objects.filter(id=id_user)
subs = Submission.objects.filter(user=user.get()) \
.filter(problem=problem.id, creation_date__range=[starts, ends + timedelta(days=1)]).order_by('-pk')
else:
return HttpResponseForbidden("Forbidden")
else:
subs = Submission.objects.filter(user=request.user).order_by('-pk')
for submission in subs:
submission.veredict_pretty = VeredictCode(submission.veredict_code).html_short_name()
return render(request, 'submissions.html', {'submissions': subs})
except ValueError:
return HttpResponseNotFound("El identificador no tiene el formato correcto")
def set_password(request):
"""
修改用户密码
URL: /api/set_password/
Method: POST
Permission: 登录用户
Param:
password: 现密码
new_password: 新密码
"""
if request.method == 'POST':
if not request.user.is_authenticated:
# 未登录 401
return HttpUnauthorized()
try:
query = json.loads(request.body)
except json.decoder.JSONDecodeError:
# 参数错误 400
return HttpResponseBadRequest()
password = query.get('password')
if not request.user.check_password(password):
# 参数错误 400
return HttpResponseBadRequest()
new_password = query.get('new_password')
if not new_password:
# 参数错误 400
return HttpResponseBadRequest()
request.user.set_password(new_password)
request.user.save()
return HttpResponse()
return HttpResponseNotFound()
def get_detail_all(request):
"""
获取所有用户信息
URL: /api/get_detail_all/
Method: POST
Permission: 登录用户
Return: {
username: string, // 用户名
id: string, // 游戏id
level: number, // 等级
box: {
id: string, // 人物id
rank: number,
star: number,
max: boolean // 是否满强
}[]
}[]
"""
if request.method in ('POST', 'GET'):
if not request.user.is_authenticated:
# 未登录 401
return HttpUnauthorized()
detail = [
i.detail for i in User.objects.all()
]
return HttpResponse(json.dumps(detail))
return HttpResponseNotFound()
def signup(request):
""" 회원가입 기능 """
try:
logger.info("/account/signup")
if request.is_ajax() == False:
return HttpResponseNotFound('<h1>Page not found</h1>')
email = request.POST.get('email')
password = request.POST.get('password')
user = User.objects.create_user(email, password)
if user is not None: #Verify form's content existence
if user.is_active: #Verify validity
login(request, user)
result = ErrClass('NOERROR').toDict()
result['user_index'] = user.pk
result['email'] = user.email
return HttpResponse(json.dumps(result), content_type="application/json")
else:
return ErrClass("ID_OR_PASSWORD_MISMATCH").response()
except IntegrityError as e:
logger.error(traceback.format_exc() )
## 동일 이메일 중복으로 인한 에러
if "1062" in str(e):
return ErrClass('DUPLICATED_EMAIL').response()
return ErrClass('UNKNWON_ERROR').response()
except Exception as e:
logger.error(traceback.format_exc() )
return ErrClass('UNKNWON_ERROR').response()
