def create(self, request, *args, **kwargs):
user_id = request.user.id
property_id = request.data['property_id']
message = request.data['message'] if 'message' in request.data else None
# Check if the chat is not created
existing_chat = Chat.objects.filter(
(Q(from_user_id=user_id) & Q(property_id=property_id)))
if existing_chat.count() > 0:
raise NotAcceptable('Chat already exists. Please, go to Chats')
_property = Property.objects.get(id=property_id)
if not _property:
raise NotAcceptable('Property does not exist')
chat = Chat(property=_property,
from_user_id=user_id,
to_user_id=_property.owner_id)
chat.save()
if message:
create_message(chat.id, user_id, request.data['message'])
serializer = ChatSerializer(chat)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def perform_crs_negotation(self, request):
# don't cripple the browsable API...
if isinstance(request.accepted_renderer, BrowsableAPIRenderer):
return
# methods with request bodies need to have the CRS specified
if request.method.lower() in ("post", "put", "patch"):
content_crs = extract_header(request, HEADER_CONTENT)
if content_crs is None:
raise PreconditionFailed(
detail=f"'{HEADER_CONTENT}' header ontbreekt")
if content_crs != DEFAULT_CRS:
raise NotAcceptable(
detail=f"CRS '{content_crs}' is niet ondersteund")
if request.method.lower() == "delete":
return
# client must indicate which CRS they want in the response
requested_crs = extract_header(request, HEADER_ACCEPT)
if requested_crs is None:
raise PreconditionFailed(
detail=f"'{HEADER_ACCEPT}' header ontbreekt")
if requested_crs != DEFAULT_CRS:
raise NotAcceptable(
detail=f"CRS '{requested_crs}' is niet ondersteund")
def create(self, request, *args, **kwargs):
data = self.request.data.get(
"items") if 'items' in self.request.data else self.request.data
userDetail = UserDetails.objects.filter(user=request.user).first()
shop = request.data.get('shop')
if not userDetail.is_customer:
shopDetail = Shop.objects.filter(
id=self.request.data.get('shop')).first()
if shopDetail is not None and shopDetail.user == userDetail.user:
many = isinstance(data, list)
if many:
for x in data:
x['shop'] = shop
serializer = self.get_serializer(data=data, many=many)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
else:
raise NotAcceptable(
"You are not allowed to create items for other users.")
else:
raise NotAcceptable("Customers are not allowed to create shops.")
def idea_register(request, idea_id):
"""
Endpoint to register user into an idea
---
POST:
serializer: ideas.serializers.IdeaRegistrationSerializer
"""
serializer = IdeaRegistrationSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
idea = get_object_or_404(Idea, pk=idea_id)
user = get_object_or_404(User, pk=serializer.validated_data['user_id'])
previous_records = IdeaParticipant.objects.filter(user=user)
if len(previous_records) > 0:
for record in previous_records:
if record.idea.event == idea.event:
raise NotAcceptable(config.PARTICIPANT_IDEA_RESTRICTION)
number_participants = IdeaParticipant.objects.filter(idea=idea).count()
if config.TEAM_MAX_SIZE > number_participants and idea.is_completed is False:
try:
IdeaParticipant.objects.create(idea=idea, user=user)
if IdeaParticipant.objects.filter(idea=idea).count() == config.TEAM_MAX_SIZE:
idea.is_completed = True
idea.save()
except Exception as e:
print(e)
raise NotAcceptable(config.PARTICIPANT_REGISTERED)
else:
raise ValidationError(
{'detail': config.TEAM_MAX_SIZE_MESSAGE})
participants = IdeaParticipant.objects.filter(idea=idea)
serializer = IdeaParticipantsSerializer(participants, many=True)
return Response({"is_registered": True,
"team_members": serializer.data}, status=status.HTTP_201_CREATED)
def post(self, request, pk, user_id, action):
community = get_object_or_404(Community, pk=pk, valid=True)
self.check_object_permissions(request, community)
if community.members.filter(id=user_id, membership__valid=True):
raise NotAcceptable('此成员已经通过审核。')
elif not community.members.filter(id=user_id):
raise NotAcceptable('此成员不在审核列表上。')
member = community.membership_set.get(user_id=user_id)
related_user = community.members.get(id=user_id)
subtype_ca = 1
subtype_c_ap = 2
with transaction.atomic():
if action == 'allow':
description = '加入社团请求被通过。'
NoticeManager.create_notice_CA(related_user, community,
subtype_ca, description)
NoticeManager.create_notice_C_AP(related_user, community,
subtype_c_ap)
member.valid = True
member.save()
elif action == 'deny':
description = '加入社团请求被拒绝。'
NoticeManager.create_notice_CA(related_user, community,
subtype_ca, description)
member.delete()
else:
raise NotAcceptable('错误的操作。')
return Response(status=status.HTTP_200_OK)
def post(self, request, pk):
community = get_object_or_404(Community, pk=pk, valid=True)
serializer = CommunityJoinSerializer(data=request.data)
user_status = community.get_member_status(request.user)
if serializer.is_valid():
# fixme: put following validation logic into serializer
# maybe serializers.SerializerMethodField() is useful here?
with transaction.atomic():
admin = community.admins.filter(id=request.user.pk)
if not admin:
if serializer.validated_data['join']:
if user_status['member']:
raise NotAcceptable(
f'你目前已经为社团成员 ({"正式" if user_status["valid"] else "待审核"})'
)
NoticeManager.create_notice_C_AA(
request.user, community)
community.members.add(request.user)
else:
if user_status['member']:
if request.user != community.owner:
community.members.remove(request.user)
else:
raise NotAcceptable('社团所有者无法直接退出社团。')
else:
raise NotAcceptable('你不是此社团成员！')
return Response(community.get_member_status(request.user))
else:
raise NotAcceptable('社团的管理员用户无法直接修改自己的加入状态。')
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
params = request.GET
if not request.user.is_authenticated:
raise NotAuthenticated(detail='Not Authenticated')
if not params:
response = totals_utils.get_all_friends_total(request.user)
elif params.get('filter') == 'current_user':
response = totals_utils.get_current_user_total(request.user)
elif params.get('friend_id'):
friend_id = params.get('friend_id')
try:
friend = User.objects.get(pk=uuid.UUID(friend_id))
except:
raise NotFound(detail='Friend ID given is incorrect')
if request.user == friend:
raise NotAcceptable(
detail='Friend ID given is equal to Current User ID')
response = totals_utils.get_friend_total(request.user, friend)
else:
raise NotAcceptable(detail='Invalid query')
return Response(response)
def get(self, _, templates):
templates = templates.split(",")
response = {}
for template in templates:
try:
view_name, view_method = template.split(".")
except ValueError:
if not template in self.allowed_templates:
raise NotAcceptable("Template: {}".format(template))
loader = Loader()
name = "{}.html".format(template)
template_body = loader.load_template_source(name)[0]
response[template] = self.reformat_template(template_body)
else:
if view_name not in self.allowed_views.keys():
raise NotAcceptable("View: {}".format(view_name))
view = self.allowed_views[view_name]
if view_name in self.allowed_methods.keys() and \
view_method not in self.allowed_methods[view_name]:
raise NotAcceptable("Method: {}.{}".format(
view_name, view_method))
views = getattr(view, view_method)()
response[view_name] = views
# response.update({"{}.{}".format(view_name, name): template_body\
# for name, template_body in views.items()})
return Response(response)
def validate(self, attrs):
amount_to_be_transferred = attrs.get('amount_to_be_transferred', '')
destination_account_number = attrs.get('destination_account_number', '')
user_name = attrs.get('user_name', '')
# TODO check if my limit is ok, not implemented yet
current_balance = self.context['current_balance']
current_username = self.context['current_username']
balance_after_transaction = self.context['balance_after_transaction']
current_id = self.context['current_id']
current_account_number = self.context['current_account_number']
if user_name != current_username:
raise NotAcceptable(f"Please check your user name")
if current_account_number == destination_account_number:
raise NotAcceptable(f"Please check destination account number: {destination_account_number}")
if amount_to_be_transferred > current_balance:
raise NotAcceptable(
f"You don't have enough money, your current balance is R$ {current_balance}")
qs = UserBankAccount.objects.filter(account_no=destination_account_number)
if not qs.exists():
raise NotAcceptable(f"Wrong destination account number: {destination_account_number}")
return {
'amount_to_be_transferred': amount_to_be_transferred,
'destination_account_number': destination_account_number,
'user_name': user_name,
'balance_after_transaction': balance_after_transaction,
'current_id': current_id,
'transaction_type': TRANSFER_MONEY
}
def validate(self, attrs):
amount = attrs.get('amount', '')
min_withdrawal_amount = settings.MINIMUM_WITHDRAWAL_AMOUNT
# Grabbing the custom context data
maximum_withdrawal = self.context['maximum_withdrawal']
balance_after_transaction = self.context['balance_after_transaction']
user_account_id = self.context['user_account_id']
current_balance = self.context['current_balance']
if amount < min_withdrawal_amount:
raise NotAcceptable(f'You need to withdrawal at least R$ {min_withdrawal_amount}')
if amount > maximum_withdrawal:
raise NotAcceptable(f'You only can withdrawal a maximum of R$ {maximum_withdrawal}')
if amount > current_balance:
raise NotAcceptable(
f"You don't have enough money, your current balance is R$ {current_balance}")
return {
'account': user_account_id,
'amount': amount,
'balance_after_transaction': balance_after_transaction,
'transaction_type': WITHDRAWAL,
}
def create_multiple_from_template(self, vmachine, pmachineguids, amount,
start, name, description):
"""
Creates a certain amount of vMachines based on a vTemplate
"""
if len(pmachineguids) == 0:
raise NotAcceptable
try:
for pmachienguid in pmachineguids:
_ = PMachine(pmachienguid)
except ObjectNotFoundException:
raise Http404('pMachine could not be found')
if vmachine.is_vtemplate is False:
raise NotAcceptable('vMachine is not a vTemplate')
if not isinstance(amount, int) or not isinstance(start, int):
raise NotAcceptable('Fields amount and start should be numeric')
amount = max(1, amount)
start = max(0, start)
return VMachineController.create_multiple_from_template.delay(
machineguid=vmachine.guid,
pmachineguids=pmachineguids,
amount=amount,
start=start,
name=str(name),
description=str(description))
def create_ticket_envelope_pre_save(sender, instance, *args, **kwargs):
driver_has_active_trip = Trip.objects.has_active_trip(instance.driver)
if not driver_has_active_trip:
raise NotAcceptable('Driver trip\'s is not active')
# check driver is not a passenger
if instance.driver == instance.passenger:
raise NotAcceptable('Conversation can not between one person!')
# check each passenger has just one ticket.
tickets = TicketEnvelope.objects.filter(trip=instance.trip)
if not instance.pk:
for ticket in tickets:
if ticket.passenger == instance.passenger:
raise NotAcceptable('Active conversation is now available')
# check tickets reach to 4
if len(tickets) == 4:
raise NotAcceptable(
'Now, 4 tickets are available, you can\'t create more envelope.'
)
today = khayyam.JalaliDatetime.now().strftime('%y%m%d')
security_code = secrets.token_hex(3)
instance.sku = '{}{}'.format(today, security_code)
END = 2
if instance.trip.status == END:
raise Exception('Trip is Ended. We can\'t send your message')
def update(self, instance, validated_data):
updated = super().update(instance, validated_data)
default_facility = Facility.objects.default_facility()
user_pk = self.context.get("user_pk")
user = User.objects.get(id=user_pk)
# Administrator cannot change away fro a facility he/she created
if user.is_administrator:
raise NotAcceptable({
"response_code":
1,
"response_message":
f"You cannot change your facility from {user.facility.title} because you created it"
})
# Take the professional back to default facility and make use visible to facilities for recruitment
if 'is_available' in validated_data:
availability_status = validated_data['is_available']
if availability_status == True:
user.facility = default_facility
user.save()
updated.is_available = availability_status
updated.facility = default_facility
updated.save()
else:
raise NotAcceptable({"response_message": f"Not acceptable"})
return updated
def idea_vote(request, event_id):
"""
Endpoint to vote for an idea
---
POST:
serializer: ideas.serializers.IdeaVoteSerializer
"""
if request.method == "POST":
serializer = IdeaVoteSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
idea = get_object_or_404(Idea, pk=serializer.validated_data['idea_id'])
user = request.user
event = get_object_or_404(Event, pk=event_id)
own_idea = IdeaParticipant.objects.filter(idea=idea, user=user).count()
if own_idea > 0:
raise NotAcceptable("No puedes votar por tu propia idea.")
try:
IdeaVotes.objects.create(event=event, idea=idea, participant=user)
except Exception as e:
print(e)
raise NotAcceptable(config.USER_VOTED)
event_ideas = []
ideas = get_list_or_404(Idea, event=event_id, is_valid=True, is_completed=True)
for idea in ideas:
votes = IdeaVotes.objects.filter(idea=idea).count()
idea_response = {'id': idea.id,
'title': idea.title,
'votes': votes}
event_ideas.append(idea_response)
serializer = IdeaSerializerWithVotes(event_ideas, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def partial_update(self, storagerouter, request, contents=None):
"""
Update a StorageRouter
"""
contents = None if contents is None else contents.split(',')
previous_primary = storagerouter.primary_failure_domain
previous_secondary = storagerouter.secondary_failure_domain
serializer = FullSerializer(StorageRouter,
contents=contents,
instance=storagerouter,
data=request.DATA)
if serializer.is_valid():
primary = storagerouter.primary_failure_domain
secondary = storagerouter.secondary_failure_domain
if primary is None:
raise NotAcceptable(
'A StorageRouter must have a primary FD configured')
if secondary is not None:
if primary.guid == secondary.guid:
raise NotAcceptable(
'A StorageRouter cannot have the same FD for both primary and secondary'
)
if len(secondary.primary_storagerouters) == 0:
raise NotAcceptable(
'The secondary FD should be set as primary FD by at least one StorageRouter'
)
if len(previous_primary.secondary_storagerouters) > 0 and len(previous_primary.primary_storagerouters) == 1 and \
previous_primary.primary_storagerouters[0].guid == storagerouter.guid and previous_primary.guid != primary.guid:
raise NotAcceptable(
'Cannot change the primary FD as this StorageRouter is the only one serving it while it is used as secondary FD'
)
serializer.save()
if previous_primary != primary or previous_secondary != secondary:
cache = VolatileFactory.get_client()
key_mds = 'ovs_dedupe_fdchange_mds_{0}'.format(
storagerouter.guid)
key_dtl = 'ovs_dedupe_fdchange_dtl_{0}'.format(
storagerouter.guid)
task_mds_id = cache.get(key_mds)
task_dtl_id = cache.get(key_dtl)
if task_mds_id:
# Key exists, task was already scheduled. If task is already running, the revoke message will be ignored
revoke(task_mds_id)
if task_dtl_id:
revoke(task_dtl_id)
async_mds_result = MDSServiceController.mds_checkup.s(
).apply_async(countdown=60)
async_dtl_result = VDiskController.dtl_checkup.s().apply_async(
countdown=60)
cache.set(key_mds, async_mds_result.id,
600) # Store the task id
cache.set(key_mds, async_dtl_result.id,
600) # Store the task id
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def check_tasks_csv(csv_file, organizer):
oid = organizer.org.oid
task_list = []
input_fields = [
'title', 'duration', 'address', 'manager_id', 'image_required',
'collect_demand', 'other_fields'
]
flag, csv_dict = check_csv_fields(csv_file, input_fields, ';')
for row in csv_dict:
if row is None:
break
try:
title = row['title']
duration = int(row['duration'])
address = row['address']
manager = clean_whs(row['manager_id'])
if len(manager) < 1:
err_msg = 'Manager not provided!'
raise NotAcceptable(detail=err_msg)
manager_qs = User.objects.filter(
Q(username=create_username(oid, manager)))
if not manager_qs.exists():
err_msg = 'Manager: ' + manager + ' not found!'
raise NotAcceptable(detail=err_msg)
manager = manager_qs[0]
image_req = bool(int(row['image_required']))
demand = bool(int(row['collect_demand']))
other_fields = str(row['other_fields']).split(',')
except Exception as e:
err_msg = str(e)
raise NotAcceptable(detail=err_msg)
task_list.append({
'title': title,
'duration': duration,
'address': address,
'manager': manager,
'agents': [],
'image_req': image_req,
'demand': demand,
'other_fields': other_fields,
})
# print(task_list)
new_task = len(task_list)
task_limit = organizer.org.subscription.task_limit
consumed_tasks = organizer.org.subscription.current_usage.consumed_tasks
if new_task + consumed_tasks > task_limit:
diff = (new_task + consumed_tasks) - task_limit
err_msg = 'Task limit exceeded! Please upgrade for another ' + str(
diff) + ' tasks!'
raise NotAcceptable(detail=err_msg)
return task_list
def upload_location(self, validated_data, request):
agent = request.user
agent_qs = User.objects.filter(id=agent.id)
presence = agent.is_present
remaining_task = Task.objects.filter(
Q(agent_list=agent) & Q(status=TSD['In progress'])).exists()
loc_reply = None
with transaction.atomic():
loc = self.create(validated_data)
loc.agent = agent
loc.org = agent.org
if presence:
loc.on_task_id = agent.userstate.active_task_id
address = get_address(loc.point['lat'], loc.point['lng'])
loc.address = address
loc.save()
event_timestamp = loc.timestamp
UserState.objects.filter(Q(user=agent)).update(last_location=loc)
# invalid_upload = not presence and loc.event != EVENT_DICT['To Online']
# cur_device = agent.userstate.current_device
# invalid_device = cur_device and loc.mac != cur_device.mac
if not presence and loc.event != EVENT_DICT['To Online']:
msg = 'invalid_upload'
raise NotAcceptable(detail=msg)
if loc.event == EVENT_DICT['To Online']:
if presence:
msg = 'Already present!'
raise NotAcceptable(detail=msg)
exec_online_event(user=agent, entry_timestamp=event_timestamp)
presence = True
attendance_notification(agent, presence)
if loc.event == EVENT_DICT['To Offline']:
# if remaining_task:
# msg = 'Task is in progress!'
# raise NotAcceptable(detail=msg)
exec_offline_event(user=agent, exit_timestamp=event_timestamp)
presence = False
attendance_notification(agent, presence)
agent_qs.update(is_working=remaining_task,
is_awol=False,
is_present=presence,
ping_count=0)
loc_reply = {
'presence': presence,
'location_interval': agent.org.location_interval,
}
return loc_reply
def clust_boxplot(self, request, pk=None):
k = try_int(self.request.GET.get('k'), -1)
col_index = try_int(self.request.GET.get('index'), -1)
if k == -1:
raise NotAcceptable("k parameter required")
if col_index == -1:
raise NotAcceptable("col_index parameter required")
object = self.get_object()
return Response(object.get_clust_boxplot_values(k, col_index))
def ks(self, request, pk=None):
vector_id = try_int(self.request.GET.get('vector_id'), -1)
matrix_id = try_int(self.request.GET.get('matrix_id'), -1)
if vector_id == -1:
raise NotAcceptable("Vector `id` parameter required")
if matrix_id == -1:
raise NotAcceptable("Matrix `id` parameter required")
object = self.get_object()
return Response(object.get_ks(vector_id, matrix_id))
def create(self, request, *args, **kwargs):
data = self.request.data
if "basket" not in data:
raise NotAcceptable(detail="Target basket needs to be specified.")
basket = Basket.objects.get(id=data.get("basket"))
basket_variables = []
basket_size = BasketVariable.objects.filter(basket=basket.id).count()
self._test_exclusivity(
["variables" in data, "concept" in data, "topic" in data])
variable_filter = {}
if "variables" in data:
variable_filter = {"id__in": data["variables"]}
if "topic" in data:
topic_object: Topic = Topic.objects.get(name=data["topic"],
study=basket.study)
variable_filter = {
"concept__topics__in": topic_object.get_topic_tree_leaves()
}
if "concept" in data:
concept = Concept.objects.get(name=data["concept"])
variable_filter = {"concept": concept}
if "study" in data:
variable_filter["dataset__study__name"] = data["study"]
variables = Variable.objects.filter(
~Q(baskets_variables__basket=basket), **variable_filter)
if len(variables) + basket_size > self.basket_limit:
raise NotAcceptable(detail=self._basket_limit_error_message(
basket_size, len(variables)))
for variable in variables:
basket_variables.append(
BasketVariable(variable=variable, basket=basket))
BasketVariable.objects.bulk_create(basket_variables)
if len(variables) == 0:
return Response(
{"detail": "No new variables to add to this Basket."},
status=status.HTTP_200_OK,
)
return Response(
{
"detail":
"Successfully added " + str(len(variables)) +
" variables to this Basket."
},
status=status.HTTP_201_CREATED,
)
def validate_product_cost(self, data):
try:
product_cost = int(data)
if float(product_cost) <= 0:
raise NotAcceptable('cost cannot be 0 or negative')
except NotAcceptable:
raise NotAcceptable('cost must be a number')
return data
def cluster_details(self, request, pk=None):
k = try_int(self.request.GET.get('k'), -1)
cluster_id = try_int(self.request.GET.get('cluster_id'), -1)
if k == -1:
raise NotAcceptable('`k` parameter required')
if cluster_id == -1:
raise NotAcceptable('`cluster_id` parameter required')
object = self.get_object()
return Response(object.get_cluster_members(k, cluster_id))
def has_permission(self, request, view):
if request.user.is_authenticated:
if request.user.cadre:
if request.user.cadre.cluster == "PHARMACY":
return True
else:
raise NotAcceptable(
"Pharmacists or Pharmaceutical Technologists only")
else:
raise NotAcceptable("Pharmacists only")
def get_queryset(self) -> QuerySet:
n = self.request.GET.get('n', 12)
try:
n = int(n)
except ValueError:
raise NotAcceptable('Invalid value for n provided.')
if n >= 20:
raise NotAcceptable("Can't retrieve more than 20 articles.")
articles = Article.objects.filter(draft=False)[:n]
return articles
def _test_exclusivity(self, values: List[bool]) -> bool:
"""Check if only one boolean in list of booleans is True."""
mutually_exclusive_violation = 0
for value in values:
mutually_exclusive_violation += value
if mutually_exclusive_violation > 1:
raise NotAcceptable(
detail=
"Keys topic, concept and variables are mutually exclusive.")
if mutually_exclusive_violation == 0:
raise NotAcceptable(detail=self.DATA_MISSING_ERROR_MESSAGE)
def perform_create(self, serializer):
user = get_object_or_404(Passageiro, user=self.request.user)
driver = util.get_available_driver()
if user.has_active_race():
raise NotAcceptable({"message": "Usuário já está em uma corrida."})
if driver:
serializer.save(passageiro=user, motorista=driver)
else:
raise NotAcceptable({"message": "Nenhum motorista disponível."})
def validate_value(self, property, value):
if value is not None:
if not isinstance(value, int):
raise NotAcceptable(self.error_msgs['invalid_type'].format(
property=property, type=type(value)))
if value < 0:
raise NotAcceptable(self.error_msgs['less_than_zero'].format(
property=property))
if property == 'limit' and value == 0:
raise NotAcceptable(self.error_msgs['limit_is_zero'])
def create_obj(self, validated_data):
username = validated_data.get('username', None)
username_qs = User.objects.filter(username=username)
if username_qs.exists():
raise NotAcceptable(detail='username exists!')
validate_username(username)
try:
user = self.create(validated_data)
except Exception as e:
print(str(e))
raise NotAcceptable(detail='Something went wrong!')
return user
def delete(self, request, *args, **kwargs):
if self.request.user == self.get_object():
raise NotAcceptable(u'No se permite borrar su propio usuario.')
group = self.get_object().groups.first().name
current_user_group = self.request.user.groups.first().name
if not can_delete(
get_profile_from_name(current_user_group)['id'],
get_profile_from_name(group)['id']):
raise NotAcceptable(
u'No posee autorización para borrar un usuario con perfil \"%s\".'
% self.get_object().groups.first().name)
return self.destroy(request, *args, **kwargs)
def validate_csv(csv_file):
if not csv_file:
msg = 'File is not attached'
raise NotAcceptable(detail=msg)
if not csv_file.name.endswith('.csv'):
msg = 'File is not csv type'
raise NotAcceptable(detail=msg)
if csv_file.multiple_chunks():
msg = "Uploaded file is too big (%.2f MB)." % (csv_file.size /
(1000 * 1000), )
raise NotAcceptable(detail=msg)
