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)
