def post(self, request, format=None): if request.method == "POST": streamData = request.data dataserializer = UserRegisterSerializer(data=request.data) passwd = request.data["password"] if dataserializer.is_valid(): newuser = dataserializer.save() newuser.set_password(passwd) newuser.save() group = Group.objects.get(name='user_permission') newuser.groups.add(group) status_code = HTTPStatus.HTTP_200_OK response = RestResponse( { 'success': 'true', "message": "user created" }, status=status_code) return response else: status_code = HTTPStatus.HTTP_200_OK response = RestResponse( { 'success': 'false', "message": "user not created" }, status=status_code) return response else: status_code = HTTPStatus.HTTP_405_METHOD_NOT_ALLOWED response = RestResponse({'success': 'false'}, status=status_code) return response
def put(self, request, *args, **kwargs): steps_to_update = request.data.copy() user_id = steps_to_update.pop('user_id', None) or request.user.id to_update = { k: bool(v) for k, v in list(steps_to_update.items()) if k in get_onboarding_steps() } if to_update and request.user.id: projection = {k: 1 for k, v in list(to_update.items())} projection['_id'] = 0 passed_steps = c_onboarding_status().find_one( {onboarding.USER_ID: user_id}, projection) or {} for step in to_update: if to_update[step] and not passed_steps.get(step): create_intercom_event(event_name='step-completed', created_at=int( time.mktime(time.localtime())), email=request.user.email, metadata={'step': step}) c_onboarding_status().update_one({onboarding.USER_ID: user_id}, {'$set': to_update}, upsert=True) return RestResponse({'status': 'Ok'}, status=status.HTTP_200_OK) return RestResponse({'status': 'Failed'}, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs): if self.button == 'datepicker': page = self.datepicker_page self.set_session_value( page, 'datepicker', json.loads( self.request.GET.get( 'value', self.request.session[page]['datepicker']))) elif self.button and self.button != 'undefined': next_tabs = { 'trend_detection': ('periodic_fluctuations', ), 'periodic_fluctuations': ('autoregressive', ), 'autoregressive': ('additive', 'frequency') }.get(self.active, ()) for tab in next_tabs: self.set_session_value('disabled', tab, 'enabled') self.set_session_value(self.active, self.button, self.value) self.request.session.modified = True try: return RestResponse(self.base_response) except calculator.CalculatorSampleAmountError: return RestResponse( {'error': 'Too little data points to calculate.'}) except ValueError: return RestResponse({'error': 'Value out of range.'})
def post(self, request): patient = Patient.objects.get(user_id=request.data['patient_id']) request.data.update({'attempt_number': patient.current_attempt_number}) serializer = ResponseSerializer(data=request.data) if serializer.is_valid(): serializer.save() return RestResponse(serializer.data, status=201) return RestResponse(serializer.errors, status=400)
def get(self, request, survey_name): try: survey = self.queryset.get(name=survey_name) except ObjectDoesNotExist as e: return RestResponse(e.__str__(), status=404) else: serializer = self.serializer_class(survey) return RestResponse(serializer.data, status=201)
def list(self, *args, **kwargs): try: results = self.filter_queryset(self.get_queryset()) if not results: raise ObjectDoesNotExist("No results found") else: serializer = self.get_serializer(results, many=True) return RestResponse(serializer.data, status=200) except ObjectDoesNotExist as e: return RestResponse(e.__str__(), status=404)
def put(self, request, *args, **kwargs): try: self.kwargs['id'] = request.data['id'] self.queryset.get(id=self.kwargs['id']) except ObjectDoesNotExist as e: return RestResponse(e.__str__(), status=400) except ValidationError as e: return RestResponse(e.__str__(), status=400) else: return self.update(request, *args, **kwargs)
def get(self, request, survey_name, question_number): try: survey = Survey.objects.get(name=survey_name) question = self.queryset.get(survey_id=survey, question_number=question_number) except ObjectDoesNotExist: return RestResponse("Question does not exist", status=404) else: serializer = self.serializer_class(question) return RestResponse(serializer.data, status=201)
def invite(self, request, pk=None): data = InviteToChannelSerializer(data=request.data) if data.is_valid(): for u in data.validated_data['users']: ChannelRelation.objects.create(user_id=u, channel_id=pk) return RestResponse({'status': 'users are invited'}) else: return RestResponse(data.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs): try: username = kwargs['username'] patient = Patient.objects.get(user_id__username=username) except ObjectDoesNotExist as e: return RestResponse(e.__str__(), status=404) else: serializer = self.serializer_class(patient) response = serializer.data response['attempts'], response[ 'time_taken'] = self.count_attempts_and_time_taken(patient) return RestResponse(response, status=200)
def get(self, request, format=None): course_id = request.GET.get('course_id') if not course_id: return RestResponse('course_id is not provided', status=400) course = get_object_or_404(Course, id=course_id) course_instructors = course.role_set.filter( role=Role.INSTRUCTOR).values_list('user_id', flat=True) if (request.user.id not in course_instructors and not course.addedBy == request.user): return RestResponse('action is not allowed', status=403) report.delay(course_id, request.user.id) return RestResponse(status=200)
def get(self, request, survey_name, question_number, patient_id): try: survey_id = Survey.objects.get(name=survey_name) question_id = Question.objects.get(survey_id=survey_id, question_number=question_number) response = self.queryset.get(question_id=question_id, patient_id=patient_id) except ObjectDoesNotExist as e: return RestResponse(e.__str__(), status=404) else: serializer = self.serializer_class(response) return RestResponse(serializer.data, status=201)
def join(self, request, pk=None): user = self.request.user r = ChannelRelation.objects.get(user=user, channel_id=pk) if not r: return RestResponse( {'status': 'invite you by channel members before join'}, status=status.HTTP_400_BAD_REQUEST) r.state = "JOINED" r.save() return RestResponse({'status': 'you joined!!'})
def mute(self, request, pk=None): user = self.request.user r = ChannelRelation.objects.get(user=user, channel_id=pk) if not r: return RestResponse( {'status': 'invite you by channel members before mute'}, status=status.HTTP_400_BAD_REQUEST) r.state = "MUTED" r.save() return RestResponse({'status': 'you have muted this channel'})
def csv(self, request, pk=None): """ get: Retrieve an asset report in CSV format. """ asset = AssetInstance.objects.filter(Q(owner=request.user) | Q(collaborations__in=request.user.groups.all())) \ .get(id=pk) csv = get_csv(asset) if csv: return RestResponse({"csv": csv}) else: return RestResponse(status=status.HTTP_204_NO_CONTENT)
def pdf(self, request, pk=None): """ get: Retrieve an asset report in PDF format. """ asset = AssetInstance.objects.filter(Q(owner=request.user) | Q(collaborations__in=request.user.groups.all())) \ .get(id=pk) markdown = get_markdown(asset) if markdown: b64pdf = get_pdf(markdown) return RestResponse({"pdf": b64pdf}) else: return RestResponse(status=status.HTTP_204_NO_CONTENT)
def markdown(self, request, pk=None): """ get: Retrieve asset report in markdown format. """ asset = AssetInstance.objects.filter(Q(owner=request.user) | Q(collaborations__in=request.user.groups.all())) \ .get(id=pk) markdown = get_markdown(asset) if markdown: b64_md = base64.b64encode(markdown.encode('utf-8')) return RestResponse({"markdown": b64_md.decode('utf-8')}) else: return RestResponse(status=status.HTTP_204_NO_CONTENT)
def post(self, request, *args, **kwargs): try: instance = Employee.objects.filter( pan_number=request.data.get('pan_number')) if len(instance) == 1: instance.delete() return RestResponse({'data': 'Success'}, status=HTTP_200_OK) else: return RestResponse({'data': 'Failure'}, status=HTTP_400_BAD_REQUEST) except Exception as e: print("Exception while deleting employee data " + str(e)) return RestResponse({'data': 'Failure'}, status=HTTP_400_BAD_REQUEST)
def put(self, request, *args, **kwargs): user_id = self.kwargs['user_id'] try: Patient.objects.get(user_id=user_id) request_user_id = User.objects.get(id=request.data['user_id']).id if user_id != request_user_id: raise ValidationError( "Inconsistent Request. Check User ID in URL against request JSON." ) except ObjectDoesNotExist as e: return RestResponse(e.__str__(), status=400) except ValidationError as e: return RestResponse(e.__str__(), status=400) else: return self.update(request, *args, **kwargs)
def destroy(self, request, pk=None): """ delete: Remove scan instance and all related database objects. """ try: instance = self.get_object() app.control.revoke(instance.last_task.id, terminate=True) try: current = instance.last_task.get_queue_progress( )['current'].lower() for heavy in scan_settings['heavy_processes']: if heavy in current: sandbox = Sandbox() sandbox.connect() sandbox.exec('rm /opt/scan_mutex') break except Exception: pass ScanTask.objects.filter(id=instance.last_task.id).delete() ScanPolicy.objects.filter(id=instance.policy.id).delete() self.perform_destroy(instance) except Http404: pass return RestResponse(status=status.HTTP_204_NO_CONTENT)
def active(self, request): """ get: List domain instances corresponding to last scan task. """ lasttasks = [] for asset in AssetInstance.objects.filter( Q(owner=request.user) | Q(collaborations__in=request.user.groups.all())): si = ScanInstance.objects.filter(asset=asset, status='SCANNED')\ .order_by('-scanned_date')\ .first() if si: try: id = si.last_task.id lasttasks.append(id) except Exception: pass domains = DomainInstance.objects.filter( last_task__id__in=lasttasks).order_by('-total_score') serializer = DomainInstanceSerializer(domains, many=True, context={'request': request}) return RestResponse(serializer.data)
def get(self, request, format=None): data = { 'authentication': { 'login': api_reverse('auth_login_api', request=request), 'password_reset': api_reverse('rest_password_reset', request=request), 'password_change': api_reverse('rest_password_change', request=request) }, 'accounts': { 'count': MyUser.objects.all().count(), 'url': api_reverse('user_account_list_api', request=request), 'create_url': api_reverse('account_create_api', request=request), 'profile_url': api_reverse( 'user_account_detail_api', request=request, kwargs={'id': request.user.id}), 'driver_url': api_reverse( 'user_driver_detail_api', request=request, kwargs={'id': request.user.id}) }, 'reservations': { 'count': Reservation.objects.pending().count(), 'url': api_reverse('reservation_list_api', request=request), 'create_url': api_reverse('reservation_create_api', request=request), # 'status_check': api_reverse('get_reservation_status_api', # request=request), }, } return RestResponse(data)
def get(self, request, *args, **kwargs): page = self.request.GET.get('active') if page: self.set_session_value( page, 'measurement_point', "Groundwater well: " + self.request.GET['name']) self.set_session_value(page, 'uuid', request.GET['uuid']) add_response = True else: add_response = False super().get(self, request, *args, **kwargs) datatypes = request.GET.get('datatypes', 'locations,timeseries_').split(',') try: response_dict = { "result": {x.strip('_'): getattr(self, x) for x in datatypes}, "error": "" } except LizardApiError: response_dict = { "result": {}, "error": "Too many groundwater locations to show on map. " "Please zoom in." } if add_response: response_dict.update(self.base_response) return RestResponse(response_dict)
def post(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) serializer.save() return RestResponse( {"success": "Password reset e-mail has been sent."}, status=status.HTTP_200_OK)
def block_user_api(request, user_pk): viewing_user = request.user user_to_block = get_object_or_404(MyUser, pk=user_pk) follower, created = Follower.objects.get_or_create(user=viewing_user) followed, created = Follower.objects.get_or_create(user=user_to_block) # Does the viewing_user follow the user_to_block? # If so, remove them try: user_to_block_followed = (Follower.objects.select_related('user').get( user=user_to_block, followers=follower)) except Follower.DoesNotExist: user_to_block_followed = None if user_to_block_followed: followed.followers.remove(follower) # Does the user_to_block follow the viewing_user? # If so, remove them try: viewer_followed = (Follower.objects.select_related('user').get( user=viewing_user, followers=followed)) except Follower.DoesNotExist: viewer_followed = None if viewer_followed: follower.followers.remove(followed) # Is the user_to_block already in blocked users? if user_to_block not in viewing_user.blocking.all(): viewing_user.blocking.add(user_to_block) serializer = FollowerSerializer(followed, context={'request': request}) return RestResponse(serializer.data, status=status.HTTP_201_CREATED)
def __generate_patient(self, request, user_id): request.data.update({'user_id': user_id}) serializer = PatientSerializer(data=request.data) serializer.is_valid(raise_exception=True) self.object = serializer.save() headers = self.get_success_headers(serializer.data) return RestResponse(request.data, status=201, headers=headers)
def requester_approve_api(request, party_pk, user_pk): user = get_object_or_404(MyUser, pk=user_pk) party = get_object_or_404(Party, pk=party_pk) party_creator = party.user party.attendees.add(user) party.requesters.remove(user) notify.send( party_creator, recipient=user, verb='has accepted your request to attend.', target=party, ) # Push notifications try: device = APNSDevice.objects.get(user=user) except APNSDevice.DoesNotExist: device = None if device: device.send_message( "{} has accepted your request to attend.".format(party_creator), sound='default') feed_item.send( user, verb='attending {}\'s event.'.format(party_creator.get_full_name), target=party, ) serializer = PartySerializer(party, context={'request': request}) return RestResponse(serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, *args, **kwargs): context = {} status = HTTP_200_OK try: form = EmployeeCreationForm(request.POST) if form.is_valid(): new_employee_inst = form.save() context['message'] = 'Saved record with id ' + str( new_employee_inst.id) else: context[ 'message'] = 'Server side validation error : ' + ' '.join( field + ' : ' + ' , '.join(err for err in error_list) for field, error_list in form.errors.items()) context['error'] = True except Exception as e: print("Exception occurred in HomeView GET API VIEW -> " + str(e)) status = HTTP_400_BAD_REQUEST context['message'] = 'Failure' context['error'] = True finally: context['form'] = EmployeeCreationForm() return RestResponse(context, status=status, template_name='index.html')
def get(self, request, *args, **kwargs): raster_wms = RasterLimits() response = raster_wms.get_limits(layername=request.GET.get('layers'), bbox=request.GET.get('bbox')) if response == [[None, None]]: response = [[-1000, 1000]] return RestResponse(response)
def reservation_cancel_api(request, reservation_id): reservation = Reservation.objects.get(id=reservation_id) reservation.reservation_status = Reservation.CANCELED reservation.save() serializer = ReservationSerializer(reservation, context={'request': request}) return RestResponse(serializer.data, status=status.HTTP_201_CREATED)