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)
