def perform_create(self, serializer): cert_name = serializer.validated_data.get('name') user = self.request.user cert_email = user.email print('trying to create cert: ' + cert_name + ' for user: '******'There exists already a certificate with name: ' + cert_name) same_email_cert_exists = user.certificates.all().filter( email=cert_email).exists() if same_email_cert_exists: raise exceptions.NotAcceptable( detail= 'There exists already a certificate with the same email address: ' + cert_email + '. Only one certificate per email address is allowed.') cert = Certificate.objects.create(name=cert_name, user=user, email=user.email) serializer.instance = cert
def perform_create(self, serializer): try: user = self.request.user facility = self.request.user.facility # Cannot add employee to default facilit if facility == Facility.objects.default_facility(): raise exceptions.NotAcceptable({ "response_code": 1, "response_message": "Not on the default facility" }) # Admin not admissible here if user.is_staff: raise exceptions.NotAcceptable("Not for administrators") else: serializer.save( owner=user, facility=facility, ) except IntegrityError as e: raise exceptions.NotAcceptable({ "detail": [ "User must be to be unique. Similar user is already added!", ] })
def validate_file_extension_size(file, extension, supported_extension, max_size_mb, *args, **kwargs): if extension not in supported_extension: raise exceptions.NotAcceptable({"message": "invalid file extension. i.e. jpg, jpeg, png are only supported."}) file_size = file.size megabyte_limit = max_size_mb if file_size > megabyte_limit * 1024 * 1024: raise exceptions.NotAcceptable({"message": "file size cannot be greater than %sMB" % str(megabyte_limit)})
def saveModelAs(self, modelName): """Saves Model With New Name""" if self.checkModelOpen(): currentPath = self.client_session.modelInfo.uri folderPath = currentPath[:currentPath.rfind('/') + 1] file_path = f'{folderPath}{modelName}.ppl' storage = FileSystemStorage( os.path.join(settings.MEDIA_ROOT, 'models')) if not storage.exists(file_path): calcEngine = CalcEngine.factory(self.client_session) try: fullPath = f'{storage.base_location}/{file_path}' newModel = calcEngine.saveModel(fullPath) current_session = self.getSession() res = current_session.modelInfo res.uri = file_path self.saveSession() calcEngine = None return res except Exception as ex: raise exceptions.ErrorDetail( f'Error when saving the model: {str(ex)}') raise exceptions.NotAcceptable( "The file name you provide already exists") raise exceptions.NotAcceptable("There's no currentModel")
def importModuleFromFile(self, importModuleData): """Import module from file""" storage = FileSystemStorage(os.path.join(settings.MEDIA_ROOT, 'models')) currentPath = self.client_session.modelInfo.uri importModuleData.currentModelPath = f'{storage.base_location}/{currentPath}' fullFileName = join(settings.TMP_ROOT, importModuleData.moduleFile) if not importModuleData.fromTemp: fullFileName = f'{storage.base_location}/{importModuleData.moduleFile}' if (importModuleData.importType.name == eImportType(0).name) or (importModuleData.importType.name == eImportType(2).name): calcEngine = CalcEngine.factory(self.client_session) result = calcEngine.importModule(importModuleData.parentModelId, fullFileName, importModuleData.importType.value) if result == 1: importModuleData.importType = importModuleData.importType.value if importModuleData.fromTemp: os.remove(fullFileName) return importModuleData else: raise exceptions.NotAcceptable("Error importing module") else: # TODO: implement eImportType(1).name (APPEND) case raise exceptions.NotAcceptable( "Import Type 'APPEND' not implemented")
def create(self, validated_data): email = validated_data.pop('email') username = validated_data.pop('username') first_name = validated_data.pop('first_name') last_name = validated_data.pop('last_name') password = validated_data.pop('password') if User.objects.filter(username=username).exists(): raise exceptions.NotAcceptable("Username exists") if User.objects.filter(email=email).exists(): raise exceptions.NotAcceptable("Email address exists") user = User.objects.create_user(username=username, password=password, email=email, first_name=first_name, last_name=last_name) validated_data['user'] = user # Add the group club_group = Group.objects.get(name='Club') user.groups.add(club_group) # Create club club = Club.objects.create(**validated_data) return club
def _insupd_order( self, basket, user=None, shipping_address=None, billing_address=None, **kwargs ): existing_orders = basket.order_set.all() if existing_orders.exclude( status=settings.ORDER_STATUS_PAYMENT_DECLINED ).exists(): # Translators: User facing error message in checkout raise exceptions.NotAcceptable( _("An non-declined order already exists for this basket.") ) existing_count = existing_orders.count() if existing_count > 1: # Translators: User facing error message in checkout raise exceptions.NotAcceptable( _( "Multiple order exist for this basket! This should never happen and we don't know what to do." ) ) # Get request object from context request = self.context.get("request", None) # If no orders were pre-existing, make a new one. if existing_count == 0: return self.place_order( basket=basket, user=user, shipping_address=shipping_address, billing_address=billing_address, request=request, **kwargs, ) # Update this order instead of making a new one. order = existing_orders.first() kwargs["order_number"] = order.number status = self.get_initial_order_status(basket) shipping_address = self.create_shipping_address( user=user, shipping_address=shipping_address ) billing_address = self.create_billing_address( user=user, billing_address=billing_address, shipping_address=shipping_address, **kwargs, ) return utils.OrderUpdater().update_order( order=order, basket=basket, user=user, shipping_address=shipping_address, billing_address=billing_address, status=status, request=request, **kwargs, )
def validate_answer(self, request, **kwargs): submission = Submission.objects.get(pk=kwargs["pk"]) answer_pk = request.query_params.get("answer") if answer_pk is None: raise exceptions.NotAcceptable("No answer specified") try: answer = submission.answers.get(pk=answer_pk) except Answer.DoesNotExist: raise exceptions.NotFound("Answer not found") if answer.question.question_type != TEXT_FIELD: raise exceptions.NotAcceptable("Only text answers can be hidden") return submission, answer
def createNewModel(request, *args, **kargs): modelName = str(request.query_params.get("modelName", "")) if modelName: if len(modelName) > 0: service = ModelManagerService(request) new_model = service.createNewModel(modelName) serializer = ModelInfoSerializer(new_model) return Response(serializer.data) else: raise exceptions.NotAcceptable("Empty modelName was provided") else: raise exceptions.NotAcceptable("No modelName was provided")
def reset(self, request, *args, **kwargs): email = request.data.get('email', None) if not email: raise exceptions.NotAcceptable("Field 'email' required") try: user = self.queryset.get(email=email) except: raise exceptions.NotAcceptable("Email not found") from rest_framework.authtoken.models import Token token, created = Token.objects.get_or_create(user=user) self.perform_reset_password(user, token) return Response({}, status=204)
def setModelPreferences(request, *args, **kargs): serializer = ModelPreferenceSerializer(data=request.data) serializer.is_valid(raise_exception=True) try: service = ModelManagerService(request) result = service.setModelPreferences(serializer.validated_data) if result: return Response(ClientSessionSerializer(result).data) raise exceptions.NotAcceptable( 'There was an error changing model preferences.') except Exception as ex: raise exceptions.NotAcceptable( f'Error in setting model preferences:{str(ex)}')
def Verify(request): idd = request.GET.get('id') otp = request.data.get('otp') print(idd,otp) if not otp and not id: raise exceptions.NotAcceptable('error') try: user = models.beneficiaries.objects.get(id=int(idd),otp=str(otp)) except: raise exceptions.NotAcceptable('error') user.status="verified" user.save() return Response({'success':'otp verified'})
def set_password(self, request, *args, **kwargs): password = request.data.get('password', None) if not password: raise exceptions.NotAcceptable( "New password field 'password' required") tAuth = TokenAuthentication() try: user, token = tAuth.authenticate(request) except: raise exceptions.NotAcceptable(detail="Unknown user or auth token") self.perform_set_password(user, password) return Response({})
def upload_markdown(request): zipfile = request.FILES.get("file", None) if not zipfile: raise exceptions.NotAcceptable(_('markdown_only_zip')) file_name = zipfile.name if os.path.splitext(file_name)[1] != ".zip": raise exceptions.NotAcceptable(_('markdown_only_zip')) md = MarkdownZip(zipfile) content = md.handle_markdown_zip() return response.Response({'error': 0, 'md': content})
def getNavigator(request, *args, **kargs): report_id = request.query_params.get("report_id", None) dashboard_id = request.query_params.get("dashboard_id", None) try: if not report_id and not dashboard_id: raise exceptions.NotAcceptable( "Error in ReportView.getNavigator(): dashboard_id or report_id required, can't both be None") service = ReportManagerService(request) dashboard = service.getNavigator(report_id, dashboard_id) return Response(ReportGetNavigatorSerializer(dashboard).data) except Exception as ex: raise exceptions.NotAcceptable( f"Error in ReportView.getNavigator(): {str(ex)}")
def authenticate(self, request): """ Returns a two-tuple of `User` and token if a valid signature has been supplied using JWT-based authentication. Otherwise returns `None`. """ self.jwe_token = self.get_token_from_header(request) if self.jwe_token is None: return None try: payload = token_decode(self.jwe_token) user = self.verify_user(payload) return user, self.jwe_token except jwt.ExpiredSignature: if request.META.get('PATH_INFO', None) == '/refresh-token/': jwt_token = jwe_decode_handler(self.jwe_token) payload = jwt_decode_handler(jwt_token, { 'verify_exp': False, }) auth_user = self.verify_user(payload) jwt_payload = generate_jwt_payload(auth_user) ref_jwt_token = jwt_encode_handler(jwt_payload) ref_jwe_token = jwe_encode_handler(ref_jwt_token) return auth_user, ref_jwe_token logger.info({ 'token': self.jwe_token, 'message': 'Token has expired.', 'code': 401, }) msg = _('Signature has expired.') raise exceptions.AuthenticationFailed(msg) except jwt.DecodeError: logger.exception({ 'token': self.jwe_token, 'message': 'DecodeError on jwt token.', 'code': 406, }) msg = _('Error decoding signature.') raise exceptions.NotAcceptable(msg) except jwt.InvalidTokenError: logger.exception({ 'token': self.jwe_token, 'message': 'InvalidTokenError on jwt token.', 'code': 406, }) raise exceptions.NotAcceptable() except Exception as err: msg = ('Signature has expired.') raise exceptions.AuthenticationFailed(msg)
def setNodeIdFromTitle(request, *args, **kargs): if request.data is not None: if "value" in request.data: if len(request.data["value"]) > 0: node_id = request.data["value"] service = ModelManagerService(request) try: result = service.setNodeIdFromTitle(node_id) if result: return Response(result) else: raise exceptions.NotAcceptable( "Error on setting the node id from the title") except Exception as ex: raise exceptions.NotAcceptable(ex)
def perform_create(self, serializer): try: user = self.request.user facility = self.request.user.facility prescription_pk = self.kwargs.get("pk") if models.Prescription.objects.filter( id=prescription_pk).count() > 0: prescription = models.Prescription.objects.get( id=prescription_pk) # Add items only to prescriptions which are open and not signed if prescription: # Add items to own prescription if prescription.owner == self.request.user: if prescription.is_signed == False: serializer.save(owner=user, facility=facility, prescription_id=prescription_pk) # raise exceptions.NotAcceptable( # {"detail": ["Prescription is signed", ]}) else: raise exceptions.NotAcceptable({ "detail": [ "Prescription is already signed and closed", ] }) else: raise exceptions.NotAcceptable({ "detail": [ "You can only add items to your own prescription", ] }) else: raise exceptions.NotAcceptable( {"detail": [ "Prescription not retrieved", ]}) except IntegrityError as e: raise exceptions.NotAcceptable({ "detail": [ f"Prescription item must be to be unique. Similar item is already added!", ] })
def abandoned(self, request, *args, **kwargs): if settings.SHUUP_BASKET_STORAGE_CLASS_SPEC != "shuup.core.basket.storage:DatabaseBasketStorage": raise exceptions.NotAcceptable( "Invalid basket storage for this route.") serializer = BasketRequestAbandonedSerializer( data=request.query_params) serializer.is_valid(True) data = serializer.validated_data self.process_request(with_basket=False, shop=data["shop"]) days = data.get("days_ago", 14) days_ago = None if days: days_ago = now() - datetime.timedelta(days=days) not_updated_in_hours = data.get("not_updated_in_hours", 2) late_cutoff = now() - datetime.timedelta(hours=not_updated_in_hours) if days_ago: updated_on_q = Q(updated_on__range=(days_ago, late_cutoff)) else: updated_on_q = Q(updated_on__lte=late_cutoff) stored_baskets = Basket.objects.filter(shop=request.shop).filter( updated_on_q, product_count__gte=0).exclude(deleted=True, finished=True, persistent=True) return Response(self.get_serializer(stored_baskets, many=True).data)
def determine_version(self, request, *args, **kwargs): media_type = _MediaType(request.accepted_media_type) version = media_type.params.get(self.version_param, self.default_version) version = unicode_http_header(version) if not self.is_allowed_version(version): raise exceptions.NotAcceptable(self.invalid_version_message) return version
def create(self, validated_data): request = self.context['request'] validated_data['user'] = request.user try: return super(UserAddressSerializer, self).create(validated_data) except IntegrityError as e: raise exceptions.NotAcceptable(str(e))
def create(self, validated_data): try: basket = validated_data.get('basket') order_number = self.generate_order_number(basket) request = self.context['request'] if 'shipping_address' in validated_data: shipping_address = ShippingAddress( **validated_data['shipping_address']) else: shipping_address = None if 'billing_address' in validated_data: billing_address = BillingAddress( **validated_data['billing_address']) else: billing_address = None return self.place_order( order_number=order_number, user=request.user, basket=basket, shipping_address=shipping_address, shipping_method=validated_data.get('shipping_method'), shipping_charge=validated_data.get('shipping_charge'), billing_address=billing_address, order_total=validated_data.get('total'), guest_email=validated_data.get('guest_email') or '') except ValueError as e: raise exceptions.NotAcceptable(str(e))
def getHome(self): company_id = self.getSession().companyId model_path = eSpecialFolder.MODELS_PATH res = {} filepath = os.path.join(settings.MEDIA_ROOT, 'models', 'home.json') if os.path.isfile(filepath): with open(filepath, "r") as json_file: try: res = json.load(json_file) if "tabs" in res: for tab in res["tabs"]: if "folders" in tab: for folder in tab["folders"]: if "items" in folder: for item in folder["items"]: if "image" in item: image_path = os.path.join( settings.MEDIA_ROOT, 'models', item["image"]) if os.path.isfile(image_path): with open( image_path, "rb") as f_image: item["imagesrc"] = str( base64.b64encode( f_image.read( )), "utf-8") except Exception as ex: raise exceptions.NotAcceptable(ex) return res
def select_renderer(self, request, renderers, format_suffix=None): """ Given a request and a list of renderers, return a two-tuple of: (renderer, media type). """ # Allow URL style format override. eg. "?format=json format_query_param = self.settings.URL_FORMAT_OVERRIDE format = format_suffix or request.QUERY_PARAMS.get(format_query_param) if format: renderers = self.filter_renderers(renderers, format) accepts = self.get_accept_list(request) # Check the acceptable media types against each renderer, # attempting more specific media types first # NB. The inner loop here isn't as bad as it first looks :) # Worst case is we're looping over len(accept_list) * len(self.renderers) for media_type_set in order_by_precedence(accepts): for renderer in renderers: for media_type in media_type_set: if media_type_matches(renderer.media_type, media_type): # Return the most specific media type as accepted. if (_MediaType(renderer.media_type).precedence > _MediaType(media_type).precedence): # Eg client requests '*/*' # Accepted media type is 'application/json' return renderer, renderer.media_type else: # Eg client requests 'application/json; indent=8' # Accepted media type is 'application/json; indent=8' return renderer, media_type raise exceptions.NotAcceptable(available_renderers=renderers)
def select_renderer(self, request, renderers, format_suffix=None): data = request.GET or request.POST requested_format = data.get("f", "xml") try: return MAPPING[requested_format] except KeyError: raise exceptions.NotAcceptable(available_renderers=renderers)
def getModelPreferences(request, *args, **kargs): try: service = ModelManagerService(request) result = service.getModelPreferences() return Response(result) except Exception as ex: raise exceptions.NotAcceptable(ex)
def select_renderer(self, request, renderers, format_suffix=None): """ Given a request and a list of renderers, return a two-tuple of: (renderer, media type). """ accepts = self.get_accept_list(request) # Check the acceptable media types against each renderer, # attempting more specific media types first # NB. The inner loop here isn't as bad as it first looks :) # Worst case is we're looping over len(accept_list) * len(self.renderers) for media_type_set in order_by_precedence(accepts): for renderer in renderers: for media_type in media_type_set: if media_type_matches(renderer.media_type, media_type): # Return the most specific media type as accepted. media_type_wrapper = _MediaType(media_type) if (_MediaType(renderer.media_type).precedence > media_type_wrapper.precedence): # Eg client requests '*/*' # Accepted media type is 'application/json' full_media_type = ';'.join( (renderer.media_type, ) + tuple('{0}={1}'.format( key, value.decode(HTTP_HEADER_ENCODING)) for key, value in media_type_wrapper.params.items())) return renderer, full_media_type else: # Eg client requests 'application/json; indent=8' # Accepted media type is 'application/json; indent=8' return renderer, media_type raise exceptions.NotAcceptable(available_renderers=renderers)
def create(self, validated_data): basket = validated_data.get("basket") order_number = self.generate_order_number(basket) billing_address = None if "billing_address" in validated_data: billing_address = BillingAddress(**validated_data["billing_address"]) shipping_address = None if "shipping_address" in validated_data: shipping_address = ShippingAddress(**validated_data["shipping_address"]) # Place the order try: order = self._insupd_order( basket=basket, user=validated_data.get("user") or AnonymousUser(), order_number=order_number, billing_address=billing_address, shipping_address=shipping_address, order_total=validated_data.get("total"), shipping_method=validated_data.get("shipping_method"), shipping_charge=validated_data.get("shipping_charge"), guest_email=validated_data.get("guest_email") or "", ) except ValueError as e: raise exceptions.NotAcceptable(str(e)) # Return the order return order
def get(self, request): """ Provides the firmware if the update is required """ verify_secure(request) if not request.user.profile.is_device: raise rest_exceptions.NotAcceptable('Only for devices') assignment = None try: assignment = request.user.firmware except local_models.FirmwareAssignmentModel.DoesNotExist: raise rest_exceptions.NotFound({'firmware': 'Not available'}) if assignment.value.hardware == local_models.FirmwareModel.HW_ESP8266_4MB: return esp8266.update(request, assignment) else: raise rest_exceptions.NotAcceptable( 'The [{:s}] is not supported'.format( assignment.value.hardware))
def retrieve(self, request, *args, **kwargs): user = request.user recipe = self.get_object() if recipe.user != user: raise exceptions.NotAcceptable("this recipe not belong to you.") serializer = self.get_serializer(recipe) return Response(serializer.data)