예제 #1
0
    def get(self, request, *args, **kwargs):

        try:
            UUID(str(kwargs.get("uuid")), version=3)
        except Exception as error:
            print(error)
            return Response(ReturnResponse.Response(0, __name__, "Bad UUID",
                                                    "Failed").return_json(),
                            status=status.HTTP_400_BAD_REQUEST)
        try:
            custom_user = CustomUser.objects.get(uuid=str(kwargs.get("uuid")),
                                                 user_profile__disabled=False)
            custom_user.status = UserStatus.objects.get(
                pk=USER_STATUS['ACTIVE'])
            custom_user.save()
            email_handler = EmailHandler(
                api="http://api.incamedical.com",
                website="http://audits.incamedical.com")
            email_handler.send_template(EMAIL_TEMPLATE['WELCOME'], custom_user)
            return redirect("http://audits.incamedical.com/static/login.html")

        except Exception as error:
            print(error)
            return Response(ReturnResponse.Response(0, __name__, "Bad User",
                                                    "Failed").return_json(),
                            status=status.HTTP_400_BAD_REQUEST)
예제 #2
0
    def create(self, request, *args, **kwargs):

        data = request.data
        serializer = CustomUserListRegisterSerializer(
            data=data,
            context={"confirm_password": data.get("confirm_password")})
        if serializer.is_valid():
            try:
                with transaction.atomic():
                    new_user = get_user_model().objects.create_user(
                        email=serializer.validated_data.get('email'),
                        password=serializer.validated_data.get('password'),
                        status=USER_STATUS['REGISTERED'],
                        firstname=data.get("firstname"),
                        lastname=data.get("lastname"))
                    email_handler = EmailHandler(
                        api="http://api.incamedical.com",
                        website="http://audits.incamedical.com")
                    email_handler.send_template(EMAIL_TEMPLATE['CONFIRM'],
                                                new_user)
                return Response(ReturnResponse.Response(
                    0, __name__, new_user.pk, "success").return_json(),
                                status=status.HTTP_201_CREATED)
            except Exception as e:
                return Response(ReturnResponse.Response(
                    1, __name__, e, "error2").return_json(),
                                status=status.HTTP_400_BAD_REQUEST)
        return Response(ReturnResponse.Response(1, __name__, serializer.errors,
                                                "error3").return_json(),
                        status=status.HTTP_400_BAD_REQUEST)
예제 #3
0
    def put(self, request):

        audit_area = AuditAreaListSerializer(data=request.data,
                                             context={
                                                 "manager":
                                                 request.data.pop("manager"),
                                                 "director":
                                                 request.data.pop("director"),
                                                 "phone":
                                                 request.data.pop("phone")
                                             })

        try:
            audit_area.is_valid(raise_exception=True)
            audit_area = audit_area.save()
        except (RuntimeError, TypeError, NameError) as e:
            result = '{0}:'.format(e)
            print(result)

            logger.error("SerializeR Error: {0}: error:{1}".format(
                audit_area.errors, result))
            return Response(ReturnResponse.Response(1, __name__,
                                                    'Company Already Exists',
                                                    result).return_json(),
                            status=status.HTTP_400_BAD_REQUEST)

        return Response(ReturnResponse.Response(0, __name__, audit_area.pk,
                                                "success").return_json(),
                        status=status.HTTP_201_CREATED)
예제 #4
0
 def get(self, request, *args, **kwargs):
     if self.get_queryset():
         user = self.get_queryset()
         email_handler = EmailHandler(
             api="http://api.incamedical.com",
             website="http://audits.incamedical.com")
         email_handler.send_template(EMAIL_TEMPLATE['FORGOT'], user)
         return Response(ReturnResponse.Response(0, __name__, user.pk,
                                                 "success").return_json(),
                         status=status.HTTP_200_OK)
     return Response(ReturnResponse.Response(0, __name__, 0,
                                             "Not Found").return_json(),
                     status=status.HTTP_400_BAD_REQUEST)
예제 #5
0
    def update(self, request, *args, **kwargs):
        serializer = CompanySerializer(self.get_object(), data=request.data)
        try:
            serializer.is_valid(raise_exception=True)
            company = serializer.save()
        except ValidationError as error:
            result = '{0}:'.format(error)
            logger.error("SerializeR Error: {0}: error:{1}".format(
                serializer.errors, result))
            return Response(ReturnResponse.Response(1, __name__,
                                                    'Company Already Exists',
                                                    result).return_json(),
                            status=status.HTTP_400_BAD_REQUEST)

        return Response(ReturnResponse.Response(0, __name__, company.id,
                                                "success").return_json(),
                        status=status.HTTP_201_CREATED)
예제 #6
0
    def put(self, request):
        category = CategorySerializer(data=request.data)
        try:
            category.is_valid(raise_exception=True)
            category = category.save()
        except ValidationError as error:
            result = '{0}:'.format(error)
            logger.error("SerializeR Error: {0}: error:{1}".format(
                category.errors, result))
            return Response(ReturnResponse.Response(1, __name__,
                                                    'Category Already Exists',
                                                    result).return_json(),
                            status=status.HTTP_400_BAD_REQUEST)

        return Response(ReturnResponse.Response(0, __name__, category.pk,
                                                "success").return_json(),
                        status=status.HTTP_201_CREATED)
예제 #7
0
    def post(self, request, pk, audit):
        file_upload_obj = request.data['fileToUpload']
        file_upload_type = ""
        upload = ""

        for upload_type in UploadType.objects.all():
            file_upload_type = upload_type
            if upload_type.type == file_upload_obj.name.split(".")[-1].lower():
                file_upload_type = upload_type
                break
        fs = FileSystemStorage()

        try:
            filename = fs.save(join(str(audit), str(pk), file_upload_obj.name),
                               file_upload_obj)
            upload = Upload.objects.create(name=filename,
                                           uploaded_name=file_upload_obj.name,
                                           size=file_upload_obj.size,
                                           type=file_upload_type)
            upload_serializer = self.get_serializer(upload)
        except (RuntimeError, TypeError, NameError) as e:
            result = '{0}:'.format(e)
            print(result)
            return Response(ReturnResponse.Response(1, __name__,
                                                    'Indicator Option Exists',
                                                    result).return_json(),
                            status=status.HTTP_400_BAD_REQUEST)

        try:
            AuditIndicatorUpload.objects.create(
                audit=Audit.objects.get(pk=audit),
                upload=upload,
                indicator=self.get_object())

        except (RuntimeError, TypeError, NameError) as e:
            result = '{0}:'.format(e)
            print(result)
            return Response(ReturnResponse.Response(1, __name__,
                                                    'Indicator Option Exists',
                                                    result).return_json(),
                            status=status.HTTP_400_BAD_REQUEST)
        return Response(ReturnResponse.Response(
            0, __name__, json.dumps(upload_serializer.data),
            "success").return_json(),
                        status=status.HTTP_201_CREATED)
예제 #8
0
    def put(self, request):
        indicator = IndicatorSerializer(data=request.data, partial=True)

        try:
            indicator.is_valid(raise_exception=True)
            indicator = indicator.save()

        except ValidationError as error:
            result = '{0}:'.format(error)
            logger.error("SerializeR Error: {0}: error:{1}".format(
                indicator.errors, result))
            return Response(ReturnResponse.Response(
                1, __name__, 'Indicator Already Exists', result).return_json(),
                            status=status.HTTP_400_BAD_REQUEST)

        return Response(ReturnResponse.Response(0, __name__, indicator.pk,
                                                "success").return_json(),
                        status=status.HTTP_201_CREATED)
예제 #9
0
 def update(self, request, *args, **kwargs):
     audit_area = self.get_serializer(self.get_object(),
                                      data=request.data,
                                      partial=True)
     try:
         audit_area.is_valid(raise_exception=True)
         audit_area = audit_area.save()
     except ValidationError as error:
         result = '{0}:'.format(error)
         logger.error("SerializeR Error: {0}: error:{1}".format(
             audit_area.errors, result))
         return Response(ReturnResponse.Response(
             1, __name__, 'Audit Area Already Exists',
             result).return_json(),
                         status=status.HTTP_400_BAD_REQUEST)
     return Response(ReturnResponse.Response(0, __name__, audit_area.id,
                                             "success").return_json(),
                     status=status.HTTP_201_CREATED)
예제 #10
0
    def put(self, request):
        data = request.data
        company = data.pop("company")
        note = NoteSerializer(data=request.data, context=company)

        try:
            note.is_valid(raise_exception=True)
            note = note.save()
        except ValidationError as error:
            result = '{0}:'.format(error)
            logger.error("SerializeR Error: {0}: error:{1}".format(
                note.errors, result))
            return Response(ReturnResponse.Response(1, __name__, 'Note Failed',
                                                    result).return_json(),
                            status=status.HTTP_400_BAD_REQUEST)

        return Response(ReturnResponse.Response(0, __name__, note.pk,
                                                "success").return_json(),
                        status=status.HTTP_201_CREATED)
예제 #11
0
    def update(self, request, *args, **kwargs):
        serializer = CustomUserDetailSerializer(self.get_object(),
                                                data=request.data,
                                                partial=True)
        try:
            serializer.is_valid(raise_exception=True)
            serializer = serializer.save()
        except ValidationError as error:
            result = '{0}:'.format(error)
            logger.error("SerializeR Error: {0}: error:{1}".format(
                serializer.errors, result))
            return Response(ReturnResponse.Response(1, __name__,
                                                    'Custom USer Error',
                                                    result).return_json(),
                            status=status.HTTP_400_BAD_REQUEST)

        return Response(ReturnResponse.Response(0, __name__, serializer.id,
                                                "success").return_json(),
                        status=status.HTTP_200_OK)
예제 #12
0
    def patch(self, request, *args, **kwargs):

        template = TemplateDetailSerializer(self.get_object(),
                                            data=request.data,
                                            partial=True)

        try:
            template.is_valid(raise_exception=True)
            template = template.save()
        except ValidationError as error:
            result = '{0}:'.format(error)
            logger.error("SerializeR Error: {0}: error:{1}".format(
                template.errors, result))
            return Response(ReturnResponse.Response(1, __name__,
                                                    'Template Already Exists',
                                                    result).return_json(),
                            status=status.HTTP_400_BAD_REQUEST)

        return Response(ReturnResponse.Response(0, __name__, template.pk,
                                                "success").return_json(),
                        status=status.HTTP_201_CREATED)
예제 #13
0
    def put(self, request):
        data = request.data
        company = data.pop("company")
        template = TemplateListSerializer(data=request.data,
                                          context={"company": company})

        try:
            template.is_valid(raise_exception=True)
            template = template.save()
        except ValidationError as error:
            result = '{0}:'.format(error)
            logger.error("SerializeR Error: {0}: error:{1}".format(
                template.errors, result))
            return Response(ReturnResponse.Response(1, __name__,
                                                    'Template Already Exists',
                                                    result).return_json(),
                            status=status.HTTP_400_BAD_REQUEST)

        return Response(ReturnResponse.Response(0, __name__, template.pk,
                                                "success").return_json(),
                        status=status.HTTP_201_CREATED)
예제 #14
0
    def create(self, request, *args, **kwargs):

        audit = AuditCreateSerializer(data=request.data)
        try:
            audit.is_valid(raise_exception=True)
            audit = audit.save()
        except (RuntimeError, TypeError, NameError) as e:
            result = '{0}:'.format(e)
            print(result)
            result = '{0}:'.format(e)
            print(result)
            result = '{0}:'.format(e)
            print("SerializeR Error: {0}: error:{1}".format(
                audit.errors, result))
            return Response(ReturnResponse.Response(1, __name__,
                                                    'Audit Already Exists',
                                                    result).return_json(),
                            status=status.HTTP_400_BAD_REQUEST)

        return Response(ReturnResponse.Response(0, __name__, audit.pk,
                                                "success").return_json(),
                        status=status.HTTP_201_CREATED)
예제 #15
0
    def post(self, request, pk):
        image = ImageSerializer(data=request.data)

        try:
            image.is_valid(raise_exception=ValueError)
            image.save()
        except (RuntimeError, TypeError, NameError) as e:
            result = '{0}:'.format(e)
            print(result)
            return Response(ReturnResponse.Response(1, __name__,
                                                    'Image failed to create',
                                                    "failed").return_json(),
                            status=status.HTTP_400_BAD_REQUEST)
        indicator = self.get_object()
        indicator.images.add(image.instance)
        indicator.save()

        res = image.data
        res['indicator'] = indicator.id
        return Response(ReturnResponse.Response(0, __name__, json.dumps(res),
                                                "success").return_json(),
                        status=status.HTTP_201_CREATED)
예제 #16
0
    def update(self, request, *args, **kwargs):
        data = request.data.dict()

        print(data)
        if not data.get("confirm_password"):
            raise ValidationError("Empty Confirm Password")

        if not data.get('password'):
            raise ValidationError("Empty Password")

        if data.get('password') != data.get("confirm_password"):
            raise ValidationError("Mismatch")

        user = self.get_object()
        if data.get('password'):
            user.set_password(data.get('password'))
            user.save()
            return Response(ReturnResponse.Response(0, __name__, user.pk,
                                                    "success").return_json(),
                            status=status.HTTP_200_OK)

        return Response(ReturnResponse.Response(0, __name__, "failed",
                                                "success").return_json(),
                        status=status.HTTP_400_BAD_REQUEST)
예제 #17
0
    def update(self, request, *args, **kwargs):
        serializer = IndicatorSerializer(instance=self.get_object(),
                                         data=request.data,
                                         partial=True,
                                         read_only=False)
        try:
            serializer.is_valid(raise_exception=True)
            serializer.save()
        except (RuntimeError, TypeError, NameError) as e:
            result = '{0}:'.format(e)
            print(result)
            result = '{0}:'.format(e)
            print(result)
            result = '{0}:'.format(e)
            logger.error("SerializeR Error: {0}: error: {1}".format(
                serializer.errors, result))
            return Response(ReturnResponse.Response(
                1, __name__, 'Indicator Already Exists', result).return_json(),
                            status=status.HTTP_400_BAD_REQUEST)

        return Response(ReturnResponse.Response(0, __name__,
                                                serializer.validated_data,
                                                "success").return_json(),
                        status=status.HTTP_201_CREATED)
예제 #18
0
    def update(self, request, *args, **kwargs):

        notes = request.data.pop("notes")
        note = Note.objects.create(note=notes['note'],
                                   type=NoteType.objects.get(pk=notes['type']),
                                   creator=DEFAULT_USER)

        audit_indicator_note = AuditIndicatorNote.objects.create(
            audit=Audit.objects.get(pk=request.data['audit']),
            note=note,
            indicator=self.get_object())

        return Response(ReturnResponse.Response(0, __name__,
                                                audit_indicator_note.pk,
                                                "success").return_json(),
                        status=status.HTTP_201_CREATED)
예제 #19
0
    def post(self, request):

        if request.auth is None:
            custom_user = None
            try:
                custom_user = CustomUser.objects.get(
                    email=request.data.get('username'))
            except CustomUser.DoesNotExist:
                return Response(ReturnResponse.Response(
                    1, __name__, "no user", "error").return_json(),
                                status=status.HTTP_400_BAD_REQUEST)
            try:
                with transaction.atomic():
                    custom_user = authenticate(
                        request,
                        username=custom_user.username,
                        password=request.data.get('password'))
                    if custom_user is None:
                        return Response(ReturnResponse.Response(
                            1, __name__, "Failed AuthenticaTion",
                            "error").return_json(),
                                        status=status.HTTP_401_UNAUTHORIZED)
                    login(request, custom_user)
                    uri, http_method, body, headers = self._extract_params(
                        request)
                    data = body
                    params = dict(parse.parse_qsl(data))
                    uri = OAuthLibCore().create_authorization_response(
                        request=request,
                        scopes={
                            "read": "Read Scope",
                            "write": "Write Scope"
                        },
                        credentials={
                            "redirect_uri": params['redirect_uri'],
                            "response_type": params['response_type'],
                            "client_id": params['client_id']
                        },
                        allow=True)

                    params = parse.urlparse(uri[0])
                    params = dict(parse.parse_qsl(params.fragment))
                    return Response(params, status=200)
                    if status_code != 200:
                        raise Exception(
                            json.loads(body).get("error_description", ""))
                    return Response(json.loads(body), status=status_code)
            except Exception as error:
                print("error")
                print(error)
                return Response(ReturnResponse.Response(
                    1, __name__, error, "error").return_json(),
                                status=status.HTTP_400_BAD_REQUEST)

            print("error2")
            return Response(ReturnResponse.Response(1, __name__, "error",
                                                    "error").return_json(),
                            status=status.HTTP_400_BAD_REQUEST)

        print("error3")
        return Response(ReturnResponse.Response(1, __name__, "error",
                                                "error").return_json(),
                        status=status.HTTP_403_FORBIDDEN)
예제 #20
0
 def post(self, request, *args, **kwargs):
     print(request)
     return Response(ReturnResponse.Response(0, __name__, request.data,
                                             "success").return_json(),
                     status=status.HTTP_201_CREATED)