def passage(self, request):
data = json.loads(request.body)
filter_user = Users.objects.filter(username=data['user_id'])
user = UserSerializer(filter_user, many=True).data[0]
data['user_id'] = user.get('id')
# print(data)
Passage.objects.create(**data)
res = {"success": True, "data": True}
return Response(res)
def update(self, request, *args, **kwargs):
# one = get_user_model().objects.all().filter(username__exact=kwargs['pk'])
if request.user.username != get_user_model().objects.all().filter(username__exact=kwargs['pk']):
raise PermissionError
else:
data = UserSerializer(JSONParser().parse(request.DATA))
if data.is_valid():
data.save()
else:
raise Http404
def update(self, request, *args, **kwargs):
# one = get_user_model().objects.all().filter(username__exact=kwargs['pk'])
if request.user.username != get_user_model().objects.all().filter(
username__exact=kwargs['pk']):
raise PermissionError
else:
data = UserSerializer(JSONParser().parse(request.DATA))
if data.is_valid():
data.save()
else:
raise Http404
def put(self, request, format = None):
contractor = Contractor.objects.get(user_id = request.user.id)
requestData = request.data.copy() # Make a mutable copy of the request
requestData['user'] = contractor.user_id # Set the user field to requesting user
#Check if user has a new device id. Update it if there is
device_id = request.data.get('registration_id')
if device_id != None:
device = contractor.device
device.registration_id = device_id;
device.save();
#Check if user's email is the same as the one in the database, don't update it if it is
oldEmail = request.user.username
if (oldEmail == requestData.get('username') ):
del requestData['username']
serializer = UserSerializer(request.user, data = requestData, partial = True)
if serializer.is_valid():
serializer.save()
else:
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
serializer = ContractorSerializer(contractor, data = requestData, partial = True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
def make_init_state(request, workflow=None, modules=None):
"""Build a dict to embed as JSON in `window.initState` in HTML."""
ret = {}
if workflow:
ret['workflowId'] = workflow.id
ret['workflow'] = WorkflowSerializer(workflow,
context={'request': request}).data
wf_modules = workflow.wf_modules \
.prefetch_related('parameter_vals__parameter_spec',
'module_version')
wf_module_data_list = WfModuleSerializer(wf_modules, many=True).data
ret['wfModules'] = dict([(str(wfm['id']), wfm)
for wfm in wf_module_data_list])
ret['selected_wf_module'] = workflow.selected_wf_module
del ret['workflow']['selected_wf_module']
if modules:
modules_data_list = ModuleSerializer(modules, many=True).data
ret['modules'] = dict([(str(m['id']), m) for m in modules_data_list])
if request.user.is_authenticated():
ret['loggedInUser'] = UserSerializer(request.user).data
if workflow and not workflow.request_read_only(request):
ret['updateTableModuleIds'] = load_update_table_module_ids()
return ret
def homeList(self, request):
topic = TopicSerializer(Topic.objects.all()[:5], many=True).data
topicList = []
for item in topic:
topicList.append({
"id": item.get('id'),
"title": item.get('title'),
"imgUrl": item.get('img')
})
article = PassageSerializer(Passage.objects.all()[:5], many=True).data
articleList = []
for item in article:
articleList.append({
"id": item.get('id'),
"title": item.get('title'),
"desc": item.get('content')[:75] + "...",
"imgUrl": item.get('pic')
})
recommend = HomeSerializer(Home.objects.filter(types='r'),
many=True).data
recommendList = []
for item in recommend:
recommendList.append({
"id": item.get('id'),
"imgUrl": item.get('pic')
})
carouse = HomeSerializer(Home.objects.filter(types='c'),
many=True).data
carouseList = []
for item in carouse:
carouseList.append({
"id": item.get('id'),
"imgUrl": item.get('pic')
})
writter = UserSerializer(Users.objects.all(), many=True).data
writterList = []
for item in writter:
desc = "写了%.1fk字 · %.1fk喜欢" % (item.get('total') / 1000,
item.get("like") / 1000)
writterList.append({
"id": item.get('id'),
"name": item.get('name'),
"desc": desc,
"imgUrl": item.get('imgUrl')
})
res = {
"success": True,
"data": {
"topicList": topicList,
"articleList": articleList,
"recommendList": recommendList,
"carouselList": carouseList,
"writterList": writterList
}
}
return Response(res)
def get(self, request: HttpRequest):
"""Render workflow-list page."""
# Separate out workflows by type
workflows = {}
workflows['owned'] = Workflow.objects \
.filter(owner=request.user) \
.filter(Q(lesson_slug__isnull=True) | Q(lesson_slug=''))
workflows['shared'] = Workflow.objects \
.filter(acl__email=request.user.email) \
.filter(Q(lesson_slug__isnull=True) | Q(lesson_slug=''))
workflows['templates'] = Workflow.objects \
.filter(in_all_users_workflow_lists=True) \
.filter(Q(lesson_slug__isnull=True) | Q(lesson_slug=''))
init_state = {
'loggedInUser': UserSerializer(request.user).data,
'workflows': {}
}
# turn queryset into list so we can sort it ourselves by reverse chron
# (this is because 'last update' is a property of the delta, not the
# Workflow. [2018-06-18, adamhooper] TODO make workflow.last_update a
# column.
for key, value in workflows.items():
value = list(value)
value.sort(key=lambda wf: wf.last_update(), reverse=True)
serializer = WorkflowSerializerLite(value,
many=True,
context={'request': request})
init_state['workflows'][key] = serializer.data
return TemplateResponse(request, 'workflows.html',
{'initState': init_state})
def make_init_state(request, workflow=None, modules=None):
"""Build a dict to embed as JSON in `window.initState` in HTML."""
ret = {}
if workflow:
ret['workflowId'] = workflow.id
ret['workflow'] = WorkflowSerializer(workflow,
context={'request': request}).data
wf_modules = workflow.wf_modules \
.prefetch_related('parameter_vals__parameter_spec',
'module_version')
wf_module_data_list = WfModuleSerializer(wf_modules, many=True).data
ret['wfModules'] = dict([(str(wfm['id']), wfm)
for wfm in wf_module_data_list])
ret['selected_wf_module'] = workflow.selected_wf_module
ret['uploadConfig'] = {
'bucket': minio.UserFilesBucket,
'accessKey': settings.MINIO_ACCESS_KEY, # never _SECRET_KEY
'server': settings.MINIO_EXTERNAL_URL
}
ret['user_files_bucket'] = minio.UserFilesBucket
del ret['workflow']['selected_wf_module']
if modules:
modules_data_list = ModuleSerializer(modules, many=True).data
ret['modules'] = dict([(str(m['id']), m) for m in modules_data_list])
if request.user.is_authenticated():
ret['loggedInUser'] = UserSerializer(request.user).data
if workflow and not workflow.request_read_only(request):
ret['updateTableModuleIds'] = load_update_table_module_ids()
return ret
def render_lesson_list(request):
lessons = Lesson.objects.all()
return TemplateResponse(request, 'lessons.html', {
'initState': json.dumps({
'loggedInUser': UserSerializer(request.user).data,
}),
'lessons': lessons,
})
def my_jwt_response_handler(token, user=None, request=None):
return {
'token': token,
'user': UserSerializer(user, context={
'request': request
}).data
}
return
def post(self, request, format=None):
user_serializer = UserSerializer(data=request.DATA)
errors = dict()
if user_serializer.is_valid():
user =user_serializer.save()
data = request.DATA.copy()
data['user'] = User.objects.latest('id').id
user_profile_serializer = UserProfileSerializer(data=data)
if user_profile_serializer.is_valid():
user_profile_serializer.save()
return Response(user_profile_serializer.data, status=status.HTTP_201_CREATED)
errors.update(user_profile_serializer.errors)
return Response(errors, status=status.HTTP_400_BAD_REQUEST)
errors.update(user_serializer.errors)
return Response(errors, status=status.HTTP_400_BAD_REQUEST)
def login(self, request):
data = json.loads(request.body)
filter_user = Users.objects.filter(username=data['username'])
if not len(filter_user):
res = {"success": True, "data": False}
return Response(res)
user = UserSerializer(filter_user, many=True).data[0]
check_pass_result = check_password(data['password'], user['password'])
if not check_pass_result:
res = {"success": True, "data": False}
return Response(res)
# print(user.get('username'))
# print(user.get('imgUrl'))
res = {
"success": True,
"data": True,
"username": user.get('name'),
"imgUrl": user.get('imgUrl'),
"userId": user.get('username')
}
return Response(res)
def render_lesson_list(request):
lessons = Lesson.objects.all()
logged_in_user = None
if request.user and request.user.is_authenticated:
logged_in_user = UserSerializer(request.user).data
return TemplateResponse(
request, 'lessons.html', {
'initState': json.dumps({
'loggedInUser': logged_in_user,
}),
'lessons': lessons,
})
def _render_course(request, course, lesson_url_prefix):
logged_in_user = None
if request.user and request.user.is_authenticated:
logged_in_user = UserSerializer(request.user).data
# We render using HTML, not React, to make this page SEO-friendly.
return TemplateResponse(request, 'course.html', {
'initState': json.dumps({
'loggedInUser': logged_in_user,
}),
'course': course,
'courses': AllCourses,
'lessons': list(course.lessons.values()),
'lesson_url_prefix': lesson_url_prefix,
})
def post(self, request, *args, **kwargs):
serializer = UserSerializer(data = request.data)
if serializer.is_valid():
serializer.save()
else:
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
device = GCMDevice.objects.create(registration_id=request.data.get('registration_id')) # create new GCMDevice with the given registration_id
user = User.objects.get(username = request.data.get('username'))
requestData = request.data.copy() # Make a mutable copy of the request
requestData['user'] = user.id # Set the user field to requesting user
requestData['device'] = device.id
serializer = LabourerSerializer(data = requestData)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status = status.HTTP_201_CREATED)
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
def _render_course(request, course, lesson_url_prefix):
logged_in_user = None
if request.user and request.user.is_authenticated:
logged_in_user = UserSerializer(request.user).data
# We render using HTML, not React, to make this page SEO-friendly.
return TemplateResponse(
request,
"course.html",
{
"initState": json.dumps({"loggedInUser": logged_in_user}),
"course": course,
"courses": AllCourses,
"lessons": list(course.lessons.values()),
"lesson_url_prefix": lesson_url_prefix,
},
)
def make_init_state(request, workflow=None, modules=None):
"""
Build a dict to embed as JSON in `window.initState` in HTML.
Raise Http404 if the workflow disappeared.
"""
ret = {}
if workflow:
try:
with workflow.cooperative_lock(): # raise DoesNotExist on race
ret['workflowId'] = workflow.id
ret['workflow'] = WorkflowSerializer(workflow,
context={
'request': request
}).data
tabs = list(workflow.live_tabs)
ret['tabs'] = dict(
(str(tab.slug), TabSerializer(tab).data) for tab in tabs)
wf_modules = list(WfModule.live_in_workflow(workflow))
ret['wfModules'] = {
str(wfm.id): WfModuleSerializer(wfm).data
for wfm in wf_modules
}
except Workflow.DoesNotExist:
raise Http404('Workflow was recently deleted')
ret['uploadConfig'] = {
'bucket': minio.UserFilesBucket,
'accessKey': settings.MINIO_ACCESS_KEY, # never _SECRET_KEY
'server': settings.MINIO_EXTERNAL_URL
}
ret['user_files_bucket'] = minio.UserFilesBucket
if modules:
modules_data_list = ModuleSerializer(modules, many=True).data
ret['modules'] = dict([(str(m['id_name']), m)
for m in modules_data_list])
if request.user.is_authenticated:
ret['loggedInUser'] = UserSerializer(request.user).data
return ret
def post(self, request, *args, **kwargs):
serializer = UserSerializer(data = request.data)
if serializer.is_valid():
serializer.save()
else:
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
device = GCMDevice.objects.create(registration_id=request.data.get('registration_id')) # create new GCMDevice with the given registration_id
user = User.objects.get(username = request.data.get('username'))
requestData = request.data.copy() # Make a mutable copy of the request
requestData['user'] = user.id # Set the user field to requesting user
requestData['device'] = device.id
token = request.data.get('stripe_token')
customer = stripe.Customer.create(source=token, description="customer id " + str(user.id))
requestData['customer_id'] = customer
serializer = ContractorSerializer(data = requestData)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status = status.HTTP_201_CREATED)
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
def make_init_state(request, workflow=None, modules=None):
ret = {}
if workflow:
ret['workflowId'] = workflow.id
ret['workflow'] = WorkflowSerializer(workflow, context={'user' : request.user}).data
ret['selected_wf_module'] = workflow.selected_wf_module
if modules:
ret['modules'] = ModuleSerializer(modules, many=True).data
if request.user.is_authenticated():
ret['loggedInUser'] = UserSerializer(request.user).data
ret['editCellsModuleId'] = edit_cells_module_id()
ret['sortModuleId'] = sort_module_id()
ret['reorderModuleId'] = reorder_module_id()
return ret
def make_init_state(request, workflow=None, modules=None):
"""
Build a dict to embed as JSON in `window.initState` in HTML.
Raise Http404 if the workflow disappeared.
Side-effect: update workflow.last_viewed_at.
"""
ret = {}
if workflow:
try:
with workflow.cooperative_lock(): # raise DoesNotExist on race
ret['workflowId'] = workflow.id
ret['workflow'] = WorkflowSerializer(workflow,
context={
'request': request
}).data
tabs = list(workflow.live_tabs)
ret['tabs'] = dict(
(str(tab.slug), TabSerializer(tab).data) for tab in tabs)
wf_modules = list(WfModule.live_in_workflow(workflow))
ret['wfModules'] = {
str(wfm.id): WfModuleSerializer(wfm).data
for wfm in wf_modules
}
workflow.last_viewed_at = timezone.now()
workflow.save(update_fields=['last_viewed_at'])
except Workflow.DoesNotExist:
raise Http404('Workflow was recently deleted')
if modules:
modules_data_list = ModuleSerializer(modules, many=True).data
ret['modules'] = dict([(str(m['id_name']), m)
for m in modules_data_list])
if request.user.is_authenticated:
ret['loggedInUser'] = UserSerializer(request.user).data
return ret
def put(self, request, format = None):
print request.body
if request.data.get('worker_id') != None:
labourer = Labourer.objects.get(id = request.data.get('worker_id'))
worker_rating = float(labourer.rating[:-1])
num = int(labourer.rating[-1:])
worker_rating = "%0.2f" % (worker_rating + float(request.data.get('rating')))
num = num + 1
labourer.rating = str(worker_rating) + str(num)
labourer.save()
return Response(status = status.HTTP_200_OK)
labourer = Labourer.objects.get(user_id = request.user.id)
requestData = request.data.copy() # Make a mutable copy of the request
requestData['user'] = labourer.user_id # Set the user field to requesting user
# Check if user has a new registration id. Update it if there is
device_id = request.data.get('registration_id')
if device_id != None:
device = labourer.device
device.registration_id = device_id;
device.save();
# Check if user's username(email) is the same as the one in the database, don't update it if it is
oldEmail = request.user.username
if (oldEmail == requestData.get('username')):
del requestData['username']
serializer = UserSerializer(request.user, data = requestData, partial = True)
if serializer.is_valid():
serializer.save()
else:
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
serializer = LabourerSerializer(labourer, data = requestData, partial = True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
def login(self, request, *args):
"""
Login endpoint
---
# YAML (must be separated by `---`)
omit_serializer: false
serializer: server.serializers.UserSerializer
parameters:
- name: Authorization
description: Basic HTTP authentication
required: true
type: string
paramType: header
responseMessages:
- code: 200
message: Correctly logged in
- code: 401
message: Invalid Authtentication
"""
return Response(UserSerializer(request.user).data)
def list(self, request):
queryset = get_user_model().objects.all()
serializer = UserSerializer(queryset, many=True)
return Response(serializer.data)
def current_user(request, format=None):
user_data = UserSerializer(request.user)
return Response(user_data.data)
def render_workflow(request, pk=None):
user = UserSerializer(request.user)
initState = {'user': user.data}
return TemplateResponse(request, 'workflow.html',
{'initState': json.dumps(initState)})
def get(self, request):
users = User.objects.filter()
serializer_class = UserSerializer(users, many=True)
return Response(serializer_class.data)
def post(self, request):
user = UserSerializer(data=request.data)
if user.is_valid():
user.save()
return Response({"success": "User created successfully"})
