def get_manual_fields(self, path, method):
return [
coreapi.Field('client_id',
required=True,
location='path',
schema=coreschema.Integer(description='Client ID')),
coreapi.Field('product',
required=True,
location='form',
schema=coreschema.Integer(description='Product ID')),
coreapi.Field('procedure_datetime',
required=True,
location='form',
schema=coreschema.String(
description='Procedure datetime in format '
'YYYY-MM-DD hh:mm:ss')),
coreapi.Field(
'cost_type',
required=True,
location='form',
schema=coreschema.Integer(
description=f'Cost type: {UNIT_COST} for unit cost, '
f'{SYSTEM_COST} for system cost')),
coreapi.Field(
'discounts',
required=False,
location='form',
schema=coreschema.Array(
description=f'Selected discounts, eg. "CCO, Repless"')),
coreapi.Field('preference_questions',
required=True,
location='form',
schema=coreschema.Array(
description=f'Preference question IDs'))
]
def get_serializer_fields(self, path, method):
fields = []
if method == 'POST':
fields = [
coreapi.Field(name="group_id",
required=True,
location="form",
schema=coreschema.Integer(
title="group", description="Id группы"),
description='group_id'),
coreapi.Field(
name="title",
required=True,
location="form",
schema=coreschema.String(title="title",
description="Название задачи"),
description='Название задачи',
),
coreapi.Field(
name="user",
required=True,
location="form",
schema=coreschema.Array(title="user",
description="Юзеры в задаче"),
description='Юзеры в задаче',
),
]
if method == 'PUT':
fields = [
coreapi.Field(name="done",
required=True,
location="form",
schema=coreschema.Boolean(
title="done", description="Завершено"),
description='Завершено'),
coreapi.Field(
name="title",
required=True,
location="form",
schema=coreschema.String(title="title",
description="Название задачи"),
description='Название задачи',
),
coreapi.Field(
name="user",
required=True,
location="form",
schema=coreschema.Array(title="user",
description="Юзеры в задаче"),
description='Юзеры в задаче',
),
]
return fields
def simple2schema(stype, description):
if stype == "integer":
return coreschema.Integer(description=description)
if stype == "string":
return coreschema.String(description=description)
if stype == "array":
return coreschema.Array(description=description)
class WebsiteReportFailure(viewsets.ViewSet):
serializer_class = WebsiteReportingSerializer
schema = AutoSchema(manual_fields=[
coreapi.Field(
"errors",
location="body",
schema=coreschema.Array(
items=coreschema.Object(
properties={},
title="Error",
)
)
),
])
@decorators.action(detail=True, methods=['post'])
def report_failure(self, request, version, website_id=None):
website: Website = Website.objects.filter(id=website_id).first()
errors = request.data if isinstance(request.data, list) else []
message = render_to_string('reporting_email.html', {'errors': errors, 'website': website})
if not website.notification_sent_date \
or website.notification_sent_date < timezone.now() - timedelta(seconds=website.notification_cooldown):
website.notification_sent_date = datetime.now()
website.save()
send_mail(
f'SeoSnap Reporting - {website.name}',
message,
os.getenv('ADMIN_EMAIL', '*****@*****.**'),
[website.notification_email],
fail_silently=False,
html_message=message
)
return Response([])
class ActuatorAccess(APIView):
"""
API endpoint that allows users actuator access to be viewed or edited.
"""
permission_classes = (permissions.IsAdminUser, )
schema = utils.OrcSchema(manual_fields=[
coreapi.Field(
"username",
required=True,
location="path",
schema=coreschema.String(
description='Username to list the accessible actuators'))
],
put_fields=[
coreapi.Field("actuators",
required=True,
location="body",
schema=coreschema.Array(
items=coreschema.String(),
min_items=1,
unique_items=True))
])
def get(self, request, username, *args, **kwargs): # pylint: disable=unused-argument
"""
API endpoint that lists the actuators a users can access
"""
username = bleach.clean(username)
rtn = [
g.name for g in ActuatorGroup.objects.filter(
users__in=[User.objects.get(username=username)])
]
return Response(rtn)
def put(self, request, username, *args, **kwargs): # pylint: disable=unused-argument
"""
API endpoint that adds actuators to a users access
"""
username = bleach.clean(username)
user = User.objects.get(username=username)
if user is None:
return ParseError(detail='User cannot be found', code=404)
rtn = []
for actuator in request.data.get('actuators', []):
actuator = bleach.clean(actuator)
group = Group.objects.exclude(actuatorgroup__isnull=True).filter(
name=actuator).first()
if group:
rtn.append(group.name)
user.groups.add(group)
return Response(rtn)
def get_serializer_fields(self,
path,
method,
view,
version=None,
method_func=None):
"""
Return a list of `coreapi.Field` instances corresponding to any
request body input, as determined by the serializer class.
"""
if method in ('PUT', 'PATCH', 'POST'):
location = 'form'
else:
location = 'query'
serializer_class = self.get_serializer_class(view, method_func)
if not serializer_class:
return []
serializer = serializer_class()
if isinstance(serializer, serializers.ListSerializer):
return [
Field(name='data',
location=location,
required=True,
schema=coreschema.Array())
]
if not isinstance(serializer, serializers.Serializer):
return []
fields = []
for field in serializer.fields.values():
if field.read_only or isinstance(field, serializers.HiddenField):
continue
required = field.required and method != 'PATCH'
# if the attribute ('help_text') of this field is a lazy translation object, force it to generate a string
description = str(field.help_text) if isinstance(
field.help_text, Promise) else field.help_text
fallback_schema = self.fallback_schema_from_field(field)
field = Field(
name=field.field_name,
location=location,
required=required,
schema=fallback_schema
if fallback_schema else field_to_schema(field),
description=description,
)
fields.append(field)
return fields
def get_link(self, path, method, base_url):
link = super_get_link(self, path, method, base_url)
# link = super().get_link(path, method, base_url)
method = method.lower()
method_name = getattr(self.view, 'action', method.lower())
link._responses = OrderedDict()
# Add obvious responses based on common action names used in viewsets
try:
serializer_name = self.view.get_serializer().__class__.__name__
if method_name in ('retrieve', 'update', 'partial_update'):
response = coreschema.Response(
status=200,
schema=coreschema.Ref('%s_read' % serializer_name))
elif method_name == 'list':
response = coreschema.Response(
status=200,
schema=coreschema.Array(
items=coreschema.Ref('%s_read' % serializer_name)))
elif method_name == 'create':
response = coreschema.Response(
status=201,
schema=coreschema.Ref('%s_write' % serializer_name))
elif method_name == 'destroy':
response = coreschema.Response(status=204)
else:
response = None
if response:
link._responses[response.status] = response
except (AttributeError, AssertionError):
# not all views have get_serializer
pass
# User may want to add responses or overwrite existing
try:
# User defined responses come in a list
for r in self.view.Meta.responses[method_name]:
link._responses[r.status] = r
except (AttributeError, KeyError):
# The view doesn't have Meta, Meta doesn't have .responses or responses doesn't have this method
pass
# User may define what content types the view may produce:
try:
# User defined responses come in a list
link._produces = self.view.Meta.produces[method_name]
except (AttributeError, KeyError):
# The view doesn't have Meta or Meta doesn't have .produces
link._produces = []
return link
class PageWebsiteUpdate(viewsets.ViewSet):
schema = AutoSchema(manual_fields=[
coreapi.Field("items",
location="body",
schema=coreschema.Array(items=coreschema.Object(
properties={},
title="Page",
description="Page",
))),
])
@decorators.action(detail=True, methods=['put'])
def update_pages(self, request, version, website_id=None):
website = Website.objects.filter(id=website_id).first()
allowed = request.user.has_perm('seosnap.view_website', website)
if not allowed or not website: return Response([])
items = request.data if isinstance(request.data, list) else []
addresses = [item['address'] for item in items if 'address' in item]
existing = {
page.address: page
for page in Page.objects.filter(address__in=addresses,
website_id=website_id)
}
allowed_fields = set(PageSerializer.Meta.fields) - set(
PageSerializer.Meta.read_only_fields)
for item in items:
item = {k: item[k] for k in allowed_fields if k in item}
if item['address'] in existing:
page = existing[item['address']]
for k, v in item.items():
setattr(page, k, v)
else:
existing[item['address']] = Page(**item)
with transaction.atomic():
cache_updated_at = website.cache_updated_at
for page in existing.values():
page.website_id = website_id
cache_updated_at = page.cached_at
page.save()
website.cache_updated_at = cache_updated_at
website.save()
serializer = PageSerializer(list(existing.values()), many=True)
return Response(serializer.data)
def get_coreschema_field(self, field):
description = six.text_type(field.extra.get('help_text', ''))
if isinstance(field, filters.NumberFilter):
return coreschema.Number(description=description)
elif isinstance(field, filters.MultipleChoiceFilter):
return coreschema.Array(
items=coreschema.Enum(enum=[c[0]
for c in field.field.choices]),
description=description,
unique_items=True,
)
elif isinstance(field, filters.ChoiceFilter):
return coreschema.Enum(enum=[c[0] for c in field.field.choices],
description=description)
else:
return coreschema.String(description=description)
def get_schema(self):
if self.dtype == str:
return coreschema.String(description=self.description)
elif self.dtype == bool:
return coreschema.Boolean(description=self.description)
elif self.dtype == int:
return coreschema.Integer(description=self.description)
elif self.dtype == float:
return coreschema.Number(description=self.description)
elif self.dtype == list:
return coreschema.Array(description=self.description)
else:
raise TypeError("Parameter must have type.")
def field_to_schema(self, field):
import coreschema
import django.forms as django_forms
from django.utils.encoding import force_str
title = force_str(field.label) if field.label else ''
description = force_str(field.help_text) if field.help_text else ''
schema = None
if isinstance(field, django_forms.MultipleChoiceField):
schema = coreschema.Array(
items=coreschema.Enum(enum=list(field.choices)),
title=title,
description=description)
elif isinstance(field, django_forms.ChoiceField) and not isinstance(
field, django_forms.ModelChoiceField):
choices = list(
map(
lambda choice: choice[0]
if isinstance(choice, tuple) else choice, field.choices))
choices.remove('')
schema = coreschema.Enum(enum=choices,
title=title,
description=description)
elif isinstance(field, django_forms.BooleanField):
schema = coreschema.Boolean(title=title, description=description)
elif isinstance(field,
(django_forms.DecimalField, django_forms.FloatField)):
schema = coreschema.Number(title=title, description=description)
elif isinstance(field, django_forms.IntegerField):
schema = coreschema.Integer(title=title, description=description)
elif isinstance(field, django_forms.DateField):
schema = coreschema.String(title=title,
description=description,
format='date')
elif isinstance(field, django_forms.DateTimeField):
schema = coreschema.String(title=title,
description=description,
format='date-time')
elif isinstance(field, django_forms.JSONField):
schema = coreschema.Object(title=title, description=description)
return schema or coreschema.String(title=title,
description=description)
def get_serializer_fields(self, path, method, view, version=None):
"""
Return a list of `coreapi.Field` instances corresponding to any
request body input, as determined by the serializer class.
"""
if method not in ('PUT', 'PATCH', 'POST'):
return []
if not hasattr(view, 'serializer_class') and not hasattr(
view, 'get_serializer_class'):
return []
serializer_class = view.get_serializer_class() if hasattr(view, 'get_serializer_class') \
else view.serializer_class
serializer = serializer_class()
if isinstance(serializer, serializers.ListSerializer):
return [
Field(name='data',
location='body',
required=True,
schema=coreschema.Array())
]
if not isinstance(serializer, serializers.Serializer):
return []
fields = []
for field in serializer.fields.values():
if field.read_only or isinstance(field, serializers.HiddenField):
continue
required = field.required and method != 'PATCH'
field = Field(
name=field.field_name,
location='form',
required=required,
schema=field_to_schema(field),
description=field.help_text,
)
fields.append(field)
return fields
class DiceSequenceListByUUIDView(generics.ListAPIView):
queryset = DiceSequence.objects.all()
serializer_class = DiceSequenceListByUUIDSerializer
permission_classes = (permissions.IsAuthenticatedOrReadOnly, IsOwnerOrReadOnly)
schema = AutoSchema(manual_fields=[
coreapi.Field(
"uuid_list",
required=True,
location="form",
schema=coreschema.Array(
description=""
),
)
])
def get(self, request, *args, **kwargs):
try:
uuid_list = request.data['uuid_list']
except:
content = { 'message': 'Missing required parameters', 'missing parameters': ['uuid_list'] }
return Response(content, status=status.HTTP_400_BAD_REQUEST)
uuid_list = [mod_uuid.UUID(entry) for entry in uuid_list]
entries_found = self.get_queryset().filter(uuid__in=uuid_list)
uuids_found = [entry.uuid for entry in entries_found]
uuids_missing = [entry for entry in uuid_list if entry not in uuids_found]
data = (
DiceSequenceData(
entry.uuid, entry.seq_name, entry.owner, [dice.sides for dice in entry.sequence.all()]
)
for entry in entries_found
)
if (uuid_list != []) and (len(uuids_missing) == len(uuid_list)):
content = { 'message': 'Not Found', 'uuids_missing': uuids_missing }
return Response(content, status=status.HTTP_404_NOT_FOUND)
serializer = DiceSequenceSerializer(data, many=True, context={'request': request})
content = { 'message': 'UUID Search Results', 'uuids_found': serializer.data, 'uuids_missing': uuids_missing }
return Response(content)
def get_link(self, path, method, base_url):
link = super().get_link(path, method, base_url)
# 无法指定bill_ids数组中的元素类型，这里元素定义为int但实际为str，无法处理...
batch_del_fields = [
Field('bill_ids',
location='form',
required=True,
schema=coreschema.Array(items=coreschema.Integer(),
unique_items=True))
]
fields = link.fields
if link.url == '/api/v1/bills/batch/' and method.lower() == 'delete':
fields = tuple(batch_del_fields)
link = Link(url=link.url,
action=link.action,
encoding=link.encoding,
fields=fields,
description=link.description)
document.Link()
return link
def schema_view(request):
schema = coreapi.Document(
title='Occurrence Search API',
content={
'create':
coreapi.Link(
url='/api/occurrence/',
action='get',
fields=[
coreapi.Field(
name='urls',
required=True,
schema=coreschema.Array(),
description='Lista de sites iniciado com http ou https.'
),
coreapi.Field(name='word',
required=True,
description='Palavra buscada.'),
],
description='Count specific word occurrence on pages.')
})
# schema = generator.get_schema(request)
return response.Response(schema)
class ReportView(object):
"""
Updates and retrieves reports relations
"""
def register():
return [
url(r'^reportManager/myReports/$', ReportView.myReports),
url(r'^reportManager/sharedWithMe/$', ReportView.sharedWithMe),
url(r'^reportManager/mySharedReports/$', ReportView.mySharedReports),
url(r'^reportManager/$', ReportView.create),
url(r'^reportManager/(?P<pk>\d+)/$', ReportView.update),
url(r'^reportManager/getNavigator/$', ReportView.getNavigator),
url(r'^reportManager/bulkDelete/$', ReportView.bulkDelete),
url(r'^reportManager/changeOrder/$', ReportView.changeOrder),
url(r'^reportManager/search/$', ReportView.search),
url(r'^reportManager/duplicateItems/$', ReportView.duplicateItems),
url(r'^reportManager/copyToMyReports/$', ReportView.copyToMyReports),
url(r'^reportManager/setAsFav/$', ReportView.setAsFav),
url(r'^reportManager/dropOnReport/$', ReportView.dropOnReport),
url(r'^reportManager/exportItems/$', ReportView.exportItems),
url(r'^reportManager/exportItemsAndPublish/$',
ReportView.exportItemsAndPublish),
url(r'^reportManager/importItems/$', ReportView.importItems),
url(r'^reportManager/(?P<pk>\d+)/shares/$', ReportView.getShares),
url(r'^reportManager/(?P<pk>\d+)/setShares/$', ReportView.setShares),
]
@api_view(['GET'])
@permission_required('pyplan.get_my_reports', raise_exception=True)
@schema(AutoSchema(manual_fields=[
coreapi.Field("parent", required=False, location="query", description="Parent report"),
coreapi.Field("favs", required=False, location="query", description="bool"),
]))
def myReports(request, *args, **kargs):
parent = request.query_params.get("parent", None)
favs = bool(request.query_params.get("favs", None))
service = ReportManagerService(request)
result = service.myReports(parent, favs)
return Response(ReportSerializer(result, many=True, context={'request': request}).data)
@api_view(['GET'])
@permission_required('pyplan.get_my_reports', raise_exception=True)
@schema(AutoSchema(manual_fields=[
coreapi.Field("parent", required=False, location="query",
description="Parent report")
]))
def sharedWithMe(request, *args, **kargs):
parent = request.query_params.get("parent", None)
service = ReportManagerService(request)
response = service.sharedWithMe(parent)
return Response(ReportSerializer(response, many=True, context={'request': request}).data)
@api_view(['GET'])
@permission_required('pyplan.get_my_reports', raise_exception=True)
def mySharedReports(request, *args, **kargs):
service = ReportManagerService(request)
response = service.mySharedReports()
return Response(ReportSerializer(response, many=True, context={'request': request}).data)
@api_view(['POST'])
@permission_required('pyplan.add_report', raise_exception=True)
@schema(AutoSchema(manual_fields=[
coreapi.Field("parent", required=False, location="query",
description="Parent report")
]))
def create(request, *args, **kargs):
serializer = ReportCreateUpdateSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
service = ReportManagerService(request)
result = service.createReport(serializer.data)
return Response(ReportSerializer(result, context={'request': request}).data)
@api_view(['PUT', 'PATCH'])
@permission_required('pyplan.change_report', raise_exception=True)
@schema(AutoSchema(manual_fields=[
coreapi.Field("pk", required=False, location="query", description="ID")
]))
def update(request, *args, **kargs):
serializer = ReportCreateUpdateSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
service = ReportManagerService(request)
result = service.updateReport(int(kargs.get("pk")), serializer.data)
if result:
return Response(ReportSerializer(result, context={'request': request}).data)
return Response(status=status.HTTP_404_NOT_FOUND)
@api_view(['GET'])
@permission_classes((IsAuthenticated,))
@schema(AutoSchema(manual_fields=[
coreapi.Field("report_id", required=False, location="query",),
coreapi.Field("dashboard_id", required=False, location="query",)
]))
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)}")
@api_view(['DELETE'])
@permission_required('pyplan.delete_report', raise_exception=True)
@schema(AutoSchema(manual_fields=[
coreapi.Field("values", required=True, location="body",),
]))
def bulkDelete(request, *args, **kargs):
ids = request.data.get("values", None)
if ids is not None:
service = ReportManagerService(request)
result = service.bulkDelete(ids)
return Response(ids)
return Response(status=status.HTTP_400_BAD_REQUEST)
@api_view(['PUT'])
@permission_required('pyplan.organize_reports', raise_exception=True)
@schema(AutoSchema(manual_fields=[
coreapi.Field("values", required=True, location="body",),
]))
def changeOrder(request, *args, **kargs):
ids = request.data.get("values", None)
if ids is not None:
service = ReportManagerService(request)
result = service.changeOrder(ids)
return Response(ids)
return Response(status=status.HTTP_400_BAD_REQUEST)
@api_view(['GET'])
@permission_classes((IsAuthenticated,))
@schema(AutoSchema(manual_fields=[
coreapi.Field("text", required=True, description="Text to search"),
]))
def search(request, *args, **kargs):
text = str(request.query_params.get("text", ""))
try:
service = ReportManagerService(request)
result = service.search(text)
response = SearchResultSerializer(result)
return Response(response.data)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@api_view(['PUT'])
@permission_classes((IsAuthenticated,))
@schema(AutoSchema(manual_fields=[
coreapi.Field("report_ids", required=True,
location="body", schema=coreschema.Array()),
coreapi.Field("dashboard_ids", required=True,
location="body", schema=coreschema.Array()),
]))
def duplicateItems(request, *args, **kargs):
serializer = DuplicateItemsSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
service = ReportManagerService(request)
result = service.duplicateItems(serializer.data)
return Response(status=status.HTTP_200_OK)
@api_view(['PUT'])
@permission_classes((IsAuthenticated,))
@schema(AutoSchema(manual_fields=[
coreapi.Field("report_ids", required=True,
location="body", schema=coreschema.Array()),
coreapi.Field("dashboard_ids", required=True,
location="body", schema=coreschema.Array()),
]))
def copyToMyReports(request, *args, **kargs):
serializer = DuplicateItemsSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
service = ReportManagerService(request)
result = service.copyToMyReports(serializer.data)
return Response(status=status.HTTP_200_OK)
@api_view(['PUT'])
@permission_required('pyplan.change_report', raise_exception=True)
@schema(AutoSchema(manual_fields=[
coreapi.Field("report_ids", required=True,
location="body", schema=coreschema.Array()),
coreapi.Field("dashboard_ids", required=True,
location="body", schema=coreschema.Array()),
]))
def setAsFav(request, *args, **kargs):
serializer = SetAsFavSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
service = ReportManagerService(request)
result = service.setAsFav(serializer.data)
return Response(SearchResultSerializer(result, context={'request': request}).data)
@api_view(['PUT'])
@permission_classes((IsAuthenticated,))
@schema(AutoSchema(manual_fields=[
coreapi.Field("report_ids", required=True,
location="body", schema=coreschema.Array()),
coreapi.Field("dashboard_ids", required=True,
location="body", schema=coreschema.Array()),
coreapi.Field("report_id", required=False,
location="query", description="Parent report ID"),
]))
def dropOnReport(request, *args, **kargs):
report_id = request.data.get("report_id", [])
report_ids = request.data.get("report_ids", [])
dashboard_ids = request.data.get("dashboard_ids", None)
if report_ids or dashboard_ids:
service = ReportManagerService(request)
result = service.dropOnReport(report_ids, dashboard_ids, report_id)
return Response(SearchResultSerializer(result, context={'request': request}).data)
return Response(status=status.HTTP_400_BAD_REQUEST)
@api_view(['PUT'])
@permission_classes((IsAuthenticated,))
@schema(AutoSchema(manual_fields=[
coreapi.Field("report_ids", required=True,
location="body", schema=coreschema.Array()),
coreapi.Field("dashboard_ids", required=True,
location="body", schema=coreschema.Array()),
]))
def exportItems(request, *args, **kargs):
serializer = DuplicateItemsSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ReportManagerService(request)
# 1. get data and file name
data_to_export, file_name = service.exportItems(serializer.data)
# 2. serialize data and convert to string
json_string = dumps(ExportItemsSerializer(
data_to_export).data, indent=None)
# 3. make file stream from json string
file_stream = FileManagerService().makeJsonStream(json_string)
# 4. stream file as http response
response = FileResponse(
file_stream, as_attachment=True, filename=file_name)
response['Content-Disposition'] = f'attachment; filename={file_name}'
return response
except Exception as ex:
raise exceptions.NotAcceptable(detail=ex)
@api_view(['PUT'])
@permission_classes((IsAuthenticated,))
@schema(AutoSchema(manual_fields=[
coreapi.Field("username", required=True,
location="body", schema=coreschema.String),
coreapi.Field("uuid", required=True,
location="body", schema=coreschema.String),
coreapi.Field("model_folder", required=True,
location="body", schema=coreschema.String),
coreapi.Field("model_id", required=True,
location="body", schema=coreschema.String),
coreapi.Field("report_ids", required=True,
location="body", schema=coreschema.Array()),
coreapi.Field("dashboard_ids", required=True,
location="body", schema=coreschema.Array())
]))
def exportItemsAndPublish(request, *args, **kargs):
serializer = ExportItemsAndPublishSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ReportManagerService(request)
external_link = service.exportItemsAndPublish(serializer.data)
if external_link:
return Response(external_link, status=status.HTTP_200_OK)
return Response('There was an error publishing the item', status=status.HTTP_406_NOT_ACCEPTABLE)
except Exception as ex:
raise exceptions.NotAcceptable(detail=ex)
@api_view(['PUT'])
@permission_classes((IsAuthenticated,))
@schema(AutoSchema(manual_fields=[
coreapi.Field("reports", required=True, location="body",
schema=coreschema.Array()),
coreapi.Field("dashboards", required=True,
location="body", schema=coreschema.Array()),
coreapi.Field("styles", required=True, location="body",
schema=coreschema.Array()),
]))
def importItems(request, *args, **kargs):
serializer = ImportItemsSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
result = ReportManagerService(request).importItems(serializer.data)
return Response(ExportItemsSerializer(result).data)
except Exception as ex:
raise exceptions.NotAcceptable(detail=ex)
@api_view(['GET'])
@permission_classes((IsAuthenticated,))
@schema(AutoSchema(manual_fields=[
coreapi.Field("report_id", required=True, location="query",),
]))
def getShares(request, *args, **kargs):
report_id = int(kargs.get("pk"))
if report_id:
service = ReportManagerService(request)
# TODO: return accessList
try:
result = service.getShares(report_id)
return Response(ReportGetSharesSerializer(result).data)
except ObjectDoesNotExist as ex:
return Response({"message": str(ex)}, status=status.HTTP_404_NOT_FOUND)
except Exception as ex:
return Response({"message": str(ex)}, status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_400_BAD_REQUEST)
@api_view(['POST'])
@permission_required('pyplan.change_report', raise_exception=True)
@schema(AutoSchema(manual_fields=[
coreapi.Field("report_id", required=True, location="query",),
]))
def setShares(request, *args, **kargs):
report_id = int(kargs.get("pk"))
serializer = ReportSetSharesSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
if report_id:
service = ReportManagerService(request)
result = service.setShares(report_id, serializer.data)
return Response(ReportGetSharesSerializer(result).data)
return Response(status=status.HTTP_404_NOT_FOUND)
import coreschema
import re
jsonschema = coreschema.RefSpace({
'Schema': coreschema.Object(
properties={
# Meta
'id': coreschema.String(format='uri'),
'$schema': coreschema.String(format='uri'),
'title': coreschema.String(),
'description': coreschema.String(),
'default': coreschema.Anything(),
'definitions': coreschema.Ref('SchemaMap'),
# Type
'type': coreschema.Ref('SimpleTypes') | coreschema.Array(items=coreschema.Ref('SimpleTypes'), min_items=1, unique_items=True),
# Number validators
'minimum': coreschema.Number(),
'maximum': coreschema.Number(),
'exclusiveMinimum': coreschema.Boolean(default=False),
'exclusiveMaximum': coreschema.Boolean(default=False),
'multipleOf': coreschema.Number(minimum=0, exclusive_minimum=True),
# String validators
'minLength': coreschema.Integer(minimum=0, default=0),
'maxLength': coreschema.Integer(minimum=0),
'pattern': coreschema.String(format='regex'),
'format': coreschema.String(),
# Array validators
'items': coreschema.Ref('Schema') | coreschema.Ref('SchemaArray'), # TODO: default={}
'additionalItems': coreschema.Boolean() | coreschema.Ref('Schema'), # TODO: default={}
'minItems': coreschema.Integer(minimum=0, default=0),
def get_serializer_fields(self, path, method):
fields = []
if method == 'POST':
fields = [
coreapi.Field(name="group_id",
required=True,
location="form",
schema=coreschema.Integer(
title="group", description="Id группы"),
description='group_id'),
coreapi.Field(
name="title",
required=True,
location="form",
schema=coreschema.String(title="title",
description="Название покупки"),
description='Название покупки',
),
coreapi.Field(
name="price",
required=True,
location="form",
schema=coreschema.Number(title="price",
description="Цена"),
description='Цена',
),
coreapi.Field(
name="comment",
required=True,
location="form",
schema=coreschema.String(title="comment",
description="Комментарий"),
description='Комментарий',
),
coreapi.Field(
name="user",
required=True,
location="form",
schema=coreschema.Array(title="user",
description="Юзеры в покупке"),
description='Юзеры в покупке',
),
]
if method == 'PUT':
fields = [
coreapi.Field(name="done",
required=True,
location="form",
schema=coreschema.Boolean(
title="done", description="Завершено"),
description='Завершено'),
coreapi.Field(
name="title",
required=True,
location="form",
schema=coreschema.String(title="title",
description="Название покупки"),
description='Название покупки',
),
coreapi.Field(
name="price",
required=True,
location="form",
schema=coreschema.Number(title="price",
description="Цена"),
description='Цена',
),
coreapi.Field(
name="comment",
required=True,
location="form",
schema=coreschema.String(title="comment",
description="Комментарий"),
description='Комментарий',
),
coreapi.Field(
name="user",
required=True,
location="form",
schema=coreschema.Array(title="user",
description="Юзеры в покупке"),
description='Юзеры в покупке',
),
]
return fields
def get_manual_fields(self, path, method):
extra_fields = []
if self._view.action == 'create':
extra_fields = [
coreapi.Field("host",
required=True,
location="form",
schema=coreschema.String(
description='提交主机名，like: yum.ops.net')),
coreapi.Field(
"interface",
required=True,
location="form",
schema=coreschema.String(
description=
'主机接口，like: [{"type":"1", "main":"1", "useip":"1", "ip":"10.0.99.1", "dns":"" ,"port":"10050"}] ',
)),
coreapi.Field(
"templates",
required=True,
location="form",
schema=coreschema.String(
description='模板列表，like: ["10267", "10001"]', )),
]
elif self._view.action == 'update':
extra_fields = [
coreapi.Field("host",
required=False,
location="form",
schema=coreschema.String(
description='提交主机名，like: yum.ops.net', )),
coreapi.Field(
"interfaces",
required=False,
location="form",
schema=coreschema.Array(
description=
'主机接口，like: [{"type":"1", "main":"1", "useip":"1", "ip":"10.0.33.1", "dns":"" ,"port":"10050"}]',
)),
coreapi.Field("status",
required=False,
location="form",
schema=coreschema.String(
description='主机监控状态，like: 0 启用， 1 停用', )),
]
elif self._view.action == 'list':
extra_fields = [
coreapi.Field("hostid",
required=False,
location="query",
schema=coreschema.String(
description='根据主机id查询,like: 10330', )),
coreapi.Field("host",
required=False,
location="query",
schema=coreschema.String(
description='根据主机名模糊查询,like: yum', )),
coreapi.Field("available",
required=False,
location="query",
schema=coreschema.String(
description='根据可用性查询主机[1 可用，0不可用],'
'like: available=1', )),
coreapi.Field("status",
required=False,
location="query",
schema=coreschema.String(
description='根据启用状态查询主机[0 已启用，1 未启用],'
'like: status=1', )),
coreapi.Field("pageSize",
required=False,
location="query",
schema=coreschema.String(
description='分页列表数量，like: 10', )),
coreapi.Field("pageNo",
required=False,
location="query",
schema=coreschema.String(
description='页序，like: 1', )),
coreapi.Field("noPage",
required=False,
location="query",
schema=coreschema.String(
description='不分页，like: 1', )),
]
manual_fields = super().get_manual_fields(path, method)
return manual_fields + extra_fields
class EditMovieView(CustomView):
authentication_classes = (
SessionAuthentication,
TokenAuthentication,
)
permission_classes = (
IsAuthenticated,
IsAdminUser,
)
required_params = [
'id', 'name', 'imdb_score', '99popularity', 'ratings', 'delete_genre',
'add_genre', 'delete_movie_person', 'edit_person_role', 'add_person'
]
schema = AutoSchema(manual_fields=[
coreapi.Field(
"id", required=True, location="form", schema=coreschema.Integer()),
coreapi.Field(
"name", required=True, location="form",
schema=coreschema.String()),
coreapi.Field("imdb_score",
required=True,
location="form",
schema=coreschema.Number()),
coreapi.Field("99popularity",
required=True,
location="form",
schema=coreschema.Number()),
coreapi.Field(
"delete_movie_person",
required=False,
location="form",
schema=coreschema.Array(),
description="""[{'id':'abc','role':'actor'},...]""",
),
coreapi.Field(
"edit_person_role",
required=False,
location="form",
schema=coreschema.Array(),
description="""[{'name':'abc','prev_role':'actor'},...]""",
),
coreapi.Field(
"add_person",
required=False,
location="form",
schema=coreschema.Array(coreschema.Array()),
description="""[{'name':'abc','prev_role':'actor'},...]""",
),
coreapi.Field(
"delete_genre",
required=True,
location="form",
schema=coreschema.Array(),
description="['horror','Adventure']",
),
coreapi.Field(
"add_genre",
required=True,
location="form",
schema=coreschema.Array(),
description="['horror','Adventure']",
),
coreapi.Field(
"director",
required=False,
location="form",
schema=coreschema.String(),
),
])
def post(self, request, format=None):
try:
data = request.data
movie = Movie.objects.get(id=data['id'])
movie.name = data['name']
movie.imdb_score = data['imdb_score']
movie.popularity99 = data['99popularity']
for tag in data["delete_genre"]:
genre = Genre.objects.filter(name=tag)
if genre:
genre = genre.first()
if genre in movie.genre.all():
movie.genre.remove(genre)
for tag in data["add_genre"]:
genre = Genre.objects.get_or_create(name=tag)[0]
if genre not in movie.genre.all():
movie.genre.add(genre)
for movieperson in data["delete_movie_person"]:
if 'id' in movieperson.keys():
person = Person.objects.filter(id=int(movieperson["id"]))
if person:
person = person.first()
if 'role' in movieperson.keys():
role = MovieRole.objects.filter(
name=movieperson["role"])
if role:
role = role.first()
MoviePersonRoles.objects.filter(
person=person, role=role,
movie=movie).delete()
else:
MoviePersonRoles.objects.filter(
person=person, movie=movie).delete()
else:
if 'name' in movieperson.keys():
person = Person.objects.filter(
name=movieperson["name"])
if person:
person = person.first()
if 'role' in movieperson.keys():
role = MovieRole.objects.filter(
name=movieperson["role"])
if role:
role = role.first()
MoviePersonRoles.objects.filter(
person=person, role=role,
movie=movie).delete()
else:
MoviePersonRoles.objects.filter(
person=person, movie=movie).delete()
for movieperson in data['edit_person']:
person = None
if 'id' in movieperson.keys():
person = Person.objects.filter(id=int(movieperson['id']))
if person:
person.first()
else:
if 'name' in movieperson.keys():
person = Person.objects.filter(
name=movieperson['name'])
if person:
person.first()
if person:
if 'prev_role' in movieperson.keys():
prev_role = MovieRole.objects.filter(
name=movieperson["prev_role"])
if prev_role:
prev_role = prev_role.first()
if 'new_role' in movieperson.keys():
new_role = MovieRole.objects.get_or_create(
name=movieperson['new_role'])[0]
moviepersonrole = MoviePersonRoles.objects.filter(
movie=movie, person=person, role=prev_role)
if moviepersonrole and not MoviePersonRoles.objects.filter(
movie=movie, person=person,
role=new_role).exists():
moviepersonrole = moviepersonrole.first()
moviepersonrole.role = new_role
moviepersonrole.save()
for movieperson in data['add_person']:
person = None
if 'id' in movieperson.keys():
person = Person.objects.filter(id=int(movieperson['id']))
if person:
person.first()
else:
if 'name' in movieperson.keys():
person = Person.objects.filter(
name=movieperson['name'])
if person:
person.first()
if 'role' in movieperson.keys():
role = MovieRole.objects.get_or_create(
name=movieperson['role'])[0]
if not MoviePersonRoles.objects.filter(
movie=movie, person=person, role=role).exists():
MoviePersonRoles(movie=movie, person=person,
role=role).save()
movie.save()
return Response({'message': 'success'})
except Exception as e:
return Response({"error": str(e)},
status=status.HTTP_400_BAD_REQUEST)
schema=coreschema.String()),
coreapi.Field(name='product_name',
required=True,
location="form",
schema=coreschema.String()),
coreapi.Field('unit_price',
required=True,
location="form",
schema=coreschema.Integer()),
coreapi.Field(
'amount', required=False, location="form",
schema=coreschema.Integer()),
coreapi.Field('product_attr',
required=False,
location='form',
schema=coreschema.Array())
])
UpdateProductSchema = ManualSchema(fields=[
coreapi.Field(name='product_stock_name',
required=True,
location="form",
schema=coreschema.String()),
coreapi.Field(name='name',
required=True,
location="form",
schema=coreschema.String()),
coreapi.Field('unit_price',
required=True,
location="form",
schema=coreschema.Integer()),
coreapi.Field(name='booking_id',
required=True,
location='path',
schema=coreschema.Integer(
description='Identifier of the booking')),
coreapi.Field(
name='token',
required=True,
location='form',
schema=coreschema.String(
description=
'Temporary authorization token assigned during booking')),
coreapi.Field(name='tickets',
required=True,
location='form',
schema=coreschema.Array(
description='Array with ticket data\'s', ))
]))
@permission_classes(())
@authentication_classes(())
def replace_tickets(request, booking_id, format=None):
"""
Removes old and creates new tickets for specified booking
"""
try:
booking = Booking.objects.get(pk=booking_id)
check_booking_token(booking, request.data.get('token'))
tickets = request.data.get('tickets', [])
for ticket in tickets:
ticket['booking'] = booking_id
serializer = TicketSerializer(data=tickets, many=True)
with transaction.atomic():
coreschema.String(format="uri"),
"$schema":
coreschema.String(format="uri"),
"title":
coreschema.String(),
"description":
coreschema.String(),
"default":
coreschema.Anything(),
"definitions":
coreschema.Ref("SchemaMap"),
# Type
"type":
coreschema.Ref("SimpleTypes")
| coreschema.Array(items=coreschema.Ref("SimpleTypes"),
min_items=1,
unique_items=True),
# Number validators
"minimum":
coreschema.Number(),
"maximum":
coreschema.Number(),
"exclusiveMinimum":
coreschema.Boolean(default=False),
"exclusiveMaximum":
coreschema.Boolean(default=False),
"multipleOf":
coreschema.Number(minimum=0, exclusive_minimum=True),
# String validators
"minLength":
coreschema.Integer(minimum=0, default=0),
class FileManagerView(object):
"""
FileManager View.
* Requires token authentication.
* Only authenticated users are able to access this view.
"""
@staticmethod
def register():
return [
url(r'^fileManager/getMainFolders/$',
FileManagerView.getMainFolders),
url(r'^fileManager/getFiles/$',
FileManagerView.getFoldersAndFiles),
url(r'^fileManager/createFolder/$', FileManagerView.createFolder),
url(r'^fileManager/copyFileOrFolder/$',
FileManagerView.copyFileOrFolder),
url(r'^fileManager/renameFile/$', FileManagerView.renameFile),
url(r'^fileManager/duplicateFiles/$',
FileManagerView.duplicateFiles),
url(r'^fileManager/moveFiles/$', FileManagerView.moveFiles),
url(r'^fileManager/copyFiles/$', FileManagerView.copyFiles),
url(r'^fileManager/copyToMyWorkspace/$',
FileManagerView.copyToMyWorkspace),
url(r'^fileManager/deleteFiles/$', FileManagerView.deleteFiles),
url(r'^fileManager/upload/$', FileManagerView.upload),
url(r'^fileManager/download/$', FileManagerView.download),
url(r'^fileManager/unzipFile/$', FileManagerView.unzipFile),
url(r'^fileManager/zipFiles/$', FileManagerView.zipFiles),
url(r'^fileManager/getHome/', FileManagerView.getHome),
url(r'^fileManager/optimizeTemplates/$',
FileManagerView.optimizeTemplates),
]
@staticmethod
@api_view(['GET'])
@permission_required('pyplan.list_folders', raise_exception=True)
def getMainFolders(request, *args, **kargs):
"""
list:
Return a list of all folders.
"""
try:
service = FileManagerService(request)
folders = service.getMainFolders()
serializer = FileEntrySerializer(
folders,
many=True,
context={'client_session': service.client_session})
return Response(serializer.data)
except FileNotFoundError:
raise exceptions.NotFound('Folder Not Found')
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['GET'])
@schema(
AutoSchema(manual_fields=[
coreapi.Field('folder',
required=False,
location='query',
description='folder name'),
]))
@permission_required('pyplan.list_folders', raise_exception=True)
def getFoldersAndFiles(request, *args, **kargs):
"""
list:
Return a list of all folders and files.
"""
serializer = GetFoldersAndFilesSerializer(data=request.query_params)
serializer.is_valid(raise_exception=True)
folder = request.query_params.get('folder', '')
try:
service = FileManagerService(request)
files = service.getFoldersAndFiles(folder)
serializer = FileEntrySerializer(
files,
many=True,
context={'client_session': service.client_session})
return Response(serializer.data)
except FileNotFoundError:
raise exceptions.NotFound('Folder Not Found')
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['POST'])
@schema(
AutoSchema(manual_fields=[
coreapi.Field("data",
required=True,
location="body",
description='{"folder_path":str, "folder_name":str}',
schema=coreschema.Object()),
]))
@permission_required('pyplan.add_folder', raise_exception=True)
def createFolder(request, *args, **kargs):
"""
create:
Creates a folder inside provided path.
"""
serializer = CreateFolderSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
folder_path = serializer['folder_path'].value
folder_name = serializer['folder_name'].value
path = FileManagerService().createFolder(folder_path, folder_name)
return Response({'path': path})
except FileNotFoundError:
raise exceptions.NotFound('Folder Not Found')
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['POST'])
@schema(
AutoSchema(manual_fields=[
coreapi.Field("data",
required=True,
location="body",
description='{"folder_path":str, "folder_name":str}',
schema=coreschema.Object()),
]))
@permission_required('pyplan.copy_file_or_folder', raise_exception=True)
def copyFileOrFolder(request, *args, **kargs):
"""
create:
Duplicate file or Folder.
"""
serializer = CopyFileOrFolderSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
source = serializer['source'].value
destination = serializer['destination'].value
result = FileManagerService().copyFileOrFolder(source, destination)
return Response({'path': result})
except FileNotFoundError:
raise exceptions.NotFound('Folder Not Found')
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['GET'])
@schema(
AutoSchema(manual_fields=[
coreapi.Field("source", required=True, location="query"),
coreapi.Field("newName", required=True, location="query"),
]))
@permission_required('pyplan.copy_file_or_folder', raise_exception=True)
def renameFile(request, *args, **kargs):
"""
Rename File
"""
source = request.query_params.get('source', None)
new_name = request.query_params.get('newName', None)
try:
result = FileManagerService().renameFile(source, new_name)
return Response({'path': result})
except FileNotFoundError:
raise exceptions.NotFound('Folder or File Not Found')
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['GET'])
@schema(
AutoSchema(manual_fields=[
coreapi.Field("sources", required=True, location="query"),
]))
@permission_required('pyplan.copy_file_or_folder', raise_exception=True)
def duplicateFiles(request, *args, **kargs):
"""
Duplicate Files
"""
sources = request.query_params.getlist('sources', [])
try:
if len(sources) > 0:
result = FileManagerService().duplicateFiles(sources)
return Response({'path': result})
return Response(status=status.HTTP_204_NO_CONTENT)
except FileNotFoundError:
raise exceptions.NotFound('Folder or File Not Found')
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['GET'])
@schema(
AutoSchema(manual_fields=[
coreapi.Field("sources", required=True, location="query"),
coreapi.Field("target", required=True, location="query"),
]))
@permission_required('pyplan.copy_file_or_folder', raise_exception=True)
def moveFiles(request, *args, **kargs):
"""
Move Files
"""
sources = request.query_params.getlist('sources', [])
target = request.query_params.get('target', None)
try:
if len(sources) > 0 and target:
result = FileManagerService().moveFiles(sources, target)
return Response()
return Response(status=status.HTTP_204_NO_CONTENT)
except FileNotFoundError:
raise exceptions.NotFound('Folder or File Not Found')
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['GET'])
@schema(
AutoSchema(manual_fields=[
coreapi.Field("sources", required=True, location="query"),
coreapi.Field("target", required=True, location="query"),
]))
@permission_required('pyplan.copy_file_or_folder', raise_exception=True)
def copyFiles(request, *args, **kargs):
"""
Copy Files
"""
sources = request.query_params.getlist('sources', [])
target = request.query_params.get('target', None)
try:
if len(sources) > 0 and target:
result = FileManagerService().copyFiles(sources, target)
return Response()
return Response(status=status.HTTP_204_NO_CONTENT)
except FileNotFoundError:
raise exceptions.NotFound('Folder or File Not Found')
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['GET'])
@schema(
AutoSchema(manual_fields=[
coreapi.Field("source", required=True, location="query"),
]))
@permission_required('pyplan.copy_file_or_folder', raise_exception=True)
def copyToMyWorkspace(request, *args, **kargs):
"""
Copy to My Workspace
"""
source = request.query_params.get('source', None)
try:
if source:
result = FileManagerService(request).copyToMyWorkspace(source)
return Response(result)
return Response(status=status.HTTP_204_NO_CONTENT)
except FileNotFoundError:
raise exceptions.NotFound('Folder or File Not Found')
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['DELETE'])
@schema(
AutoSchema(manual_fields=[
coreapi.Field("sources", required=True, location="query"),
]))
@permission_required('pyplan.delete_files', raise_exception=True)
def deleteFiles(request, *args, **kargs):
"""
create:
Duplicate file or Folder.
"""
serializer = DeleteFilesSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
sources = serializer['sources'].value
result = FileManagerService().deleteFiles(sources)
return Response(status=status.HTTP_200_OK)
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@parser_classes((
parsers.MultiPartParser,
parsers.FormParser,
))
def upload(request, *args, **kargs):
"""
uploads multiple files
"""
serializer = UploadFilesSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = FileManagerService(request)
service.createFile(request.FILES["files"],
serializer.data.get("folder_path"),
serializer.data.get("name"),
serializer.data.get("chunk"))
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_200_OK)
@staticmethod
@api_view(['GET'])
@authentication_classes((QueryStringTokenAuthentication, ))
@permission_required('pyplan.download_files', raise_exception=True)
@schema(
AutoSchema(manual_fields=[
coreapi.Field("sources",
required=True,
location="query",
schema=coreschema.Array()),
coreapi.Field("auth_token",
required=True,
location="query",
schema=coreschema.String()),
]))
def download(request, *args, **kargs):
"""
download multiple files
"""
serializer = SourcesListSerializer(data=request.query_params)
serializer.is_valid(raise_exception=True)
try:
service = FileManagerService(request)
file_stream, file_name = service.download(
serializer.data.get('sources'), )
return FileResponse(file_stream,
as_attachment=True,
filename=file_name)
except Exception as ex:
raise exceptions.NotAcceptable(detail=ex)
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("source", required=True, location="query"),
coreapi.Field("targetFolder", required=True, location="query"),
]))
def unzipFile(request, *args, **kargs):
"""
unzip file
"""
serializer = UnzipFileSerializer(data=request.query_params)
serializer.is_valid(raise_exception=True)
try:
service = FileManagerService(request)
service.unzipFile(serializer.data.get("source"),
serializer.data.get("targetFolder"))
return Response(status=status.HTTP_200_OK)
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("sources",
required=True,
location="query",
schema=coreschema.Array()),
]))
def zipFiles(request, *args, **kargs):
"""
zip files
"""
serializer = SourcesListSerializer(data=request.query_params)
serializer.is_valid(raise_exception=True)
try:
service = FileManagerService(request)
response = service.zipFiles(serializer.data.get("sources"))
return Response(response, status=status.HTTP_200_OK)
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
def getHome(request, *args, **kargs):
"""
Return home json definition of the current company
"""
service = FileManagerService(request)
return Response(service.getHome())
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("sources",
required=True,
location="query",
schema=coreschema.Array()),
]))
def optimizeTemplates(request, *args, **kargs):
"""
Optimice templates for speed up future reads
"""
serializer = SourcesListSerializer(data=request.query_params)
serializer.is_valid(raise_exception=True)
try:
service = FileManagerService(request)
service.optimizeTemplates(serializer.data.get("sources"), )
except Exception as ex:
return Response(str(ex), status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_200_OK)
class AddMovieView(CustomView):
authentication_classes = (
SessionAuthentication,
TokenAuthentication,
)
permission_classes = (
IsAuthenticated,
IsAdminUser,
)
required_params = ['name', 'imdb_score', '99popularity', 'people', 'genre']
schema = AutoSchema(manual_fields=[
coreapi.Field(
"name", required=True, location="form",
schema=coreschema.String()),
coreapi.Field("imdb_score",
required=True,
location="form",
schema=coreschema.Number()),
coreapi.Field("99popularity",
required=True,
location="form",
schema=coreschema.Number()),
coreapi.Field(
"people",
required=False,
location="form",
schema=coreschema.Array(),
description="""[{'name':'abc','role':'actor'},...]""",
),
coreapi.Field(
"genre",
required=True,
location="form",
schema=coreschema.Array(),
description="['horror','Adventure']",
),
coreapi.Field(
"director",
required=False,
location="form",
schema=coreschema.String(),
),
])
def post(self, request, format=None):
data = request.data
try:
movie = Movie(name=data["name"],
imdb_score=data["imdb_score"],
popularity99=data['99popularity'])
movie.save()
if "director" in data:
role = MovieRole.objects.get_or_create(name="director")[0]
person_temp = Person.objects.get_or_create(
name=data["director"])[0]
mov_p_roles = MoviePersonRoles(person=person_temp,
movie=movie,
role=role)
mov_p_roles.save()
for person in data["people"]:
role = MovieRole.objects.get_or_create(name=person["role"])[0]
person_temp = Person.objects.get_or_create(
name=person["name"])[0]
mov_p_roles = MoviePersonRoles(person=person_temp,
movie=movie,
role=role)
mov_p_roles.save()
for tag in data["genre"]:
genre = Genre.objects.get_or_create(name=tag)[0]
movie.genre.add(genre)
movie.save()
return Response({'movie_id': movie.pk})
except Exception as e:
return Response({"error": str(e)},
status=status.HTTP_400_BAD_REQUEST)
class CustomJsonSchema(schemas.AutoSchema):
def get_manual_fields(self, path, method):
return self._manual_fields + get_fields(method, json_fields)
json_fields = {
'POST': [
coreapi.Field(
'type',
required=False,
location='form',
type='integer',
schema=coreschema.Array(
description='Type of log',
),
),
coreapi.Field(
'new',
required=False,
location='form',
type='boolean',
schema=coreschema.Array(
description='Force creation of new log'
)
),
coreapi.Field(
'json',
required=True,
location='form',
