class TasksFilter(filters.BaseFilterBackend):
"""Return tasks that satisfy given constraints"""
template = os.path.join('celery_pantry', 'tasks_filter.html')
schema = [
coreapi.Field(
name='with_data',
required=False,
location='query',
schema=coreschema.Object(description='Data users must have',
min_properties=1)),
coreapi.Field(name='without_data',
required=False,
location='query',
schema=coreschema.Object(
description='Data users must not have',
min_properties=1)),
]
@staticmethod
def _filter__with_data(queryset, value):
return queryset.filter(data__contains=json.loads(value))
@staticmethod
def _filter__without_data(queryset, value):
return queryset.exclude(data__contains=json.loads(value))
def filter_queryset(self, request, queryset, view):
if view.action == 'list':
for key, value in request.query_params.items():
if value:
try:
filter_func = getattr(self, f'_filter__{key}')
queryset = filter_func(queryset, value)
except AttributeError:
continue
return queryset
def to_html(self, request, queryset, view) -> str:
template = loader.get_template(self.template)
context = self.get_template_context(request)
return template.render(context)
def get_template_context(self, request):
return dict(
conditions={
field.name: request.query_params.get(field.name, '')
for field in self.schema
})
def coreapi_schema(self):
if self.request.method == 'GET':
fields = [
coreapi.Field("name",
required=False,
location="query",
schema=coreschema.String(max_length=30)),
coreapi.Field("name_contains",
required=False,
location="query",
schema=coreschema.String(max_length=30))
]
elif self.request.method == 'POST':
fields = [
coreapi.Field("params",
required=True,
location="body",
schema=coreschema.Object())
]
else:
fields = [
coreapi.Field("name",
required=True,
location="body",
schema=coreschema.String(max_length=30))
]
return schemas.ManualSchema(fields=fields)
class DumpFixtureAPIView(generics.CreateAPIView):
permission_classes = (SuperuserRequiredPermission, )
schema = schemas.ManualSchema(fields=[
coreapi.Field("app_name",
required=True,
location="form",
schema=coreschema.String(max_length=10)),
coreapi.Field("model_name",
required=True,
location="form",
schema=coreschema.String(max_length=50)),
coreapi.Field("filter_options",
required=False,
location="form",
schema=coreschema.Object()),
coreapi.Field("file_name",
required=True,
location="form",
schema=coreschema.String(max_length=50)),
])
def post(self, request, *args, **kwargs):
"""
Download model fixture
"""
serializer = DumpFixtureSerializer(data=request.data)
if not serializer.is_valid():
return Response('Data is not valid')
form_data = serializer.data
file_name = form_data.pop('file_name')
json_data = get_model_fixture_dump(**form_data)
return download(json_data, file_name)
def form_for_link(link):
import coreschema
properties = OrderedDict([(field.name, field.schema or coreschema.String())
for field in link.fields])
required = [field.name for field in link.fields if field.required]
schema = coreschema.Object(properties=properties, required=required)
return mark_safe(coreschema.render_to_form(schema))
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([])
def render_form(link: coreapi.Link) -> str:
properties = dict([
(field.name, field.schema or coreschema.String())
for field in link.fields
])
required = [] # type: typing.List[str]
schema = coreschema.Object(properties=properties, required=required)
return coreschema.render_to_form(schema)
def get_manual_fields(self, path, method):
if method not in ['POST', 'PUT', 'PATCH']:
return []
return [
coreapi.Field("data",
required=False,
location="form",
schema=coreschema.Object())
]
def get_schema_fields(self, view):
fields = super(PaymentFilterBackend, self).get_schema_fields(view)
extra_fields = [
coreapi.Field(
name="created_before",
location="query",
required=False,
schema=coreschema.Object(),
),
coreapi.Field(
name="created_after",
location="query",
required=False,
schema=coreschema.Object(),
),
]
fields.extend(extra_fields)
return fields
def test_ref():
child = coreschema.Object(properties={
'a': coreschema.String(),
'b': coreschema.Integer()
})
schema = coreschema.Ref('Child')
context = {'refs': {'Child': child}}
assert schema.validate({'a': 'abc', 'b': 123}, context) == []
assert schema.validate({
'a': 'abc',
'b': 'abc'
}, context) == [('Must be an integer.', ['b'])]
def fallback_schema_from_field(self, field):
""" Fallback schema for field that isn't inspected properly by DRF
and probably won't land in upstream canon due to its hacky nature only for doc purposes
"""
title = force_text(field.label) if field.label else ''
description = force_text(field.help_text) if field.help_text else ''
# since we can't really inspect dictfield and jsonfield, at least display object as type
# instead of string
if isinstance(field, (serializers.DictField, serializers.JSONField)):
return coreschema.Object(properties={},
title=title,
description=description)
class ServiceAreaViewSet(viewsets.ModelViewSet):
permission_classes = (ServiceAreaPermissions, )
queryset = ServiceArea.objects
instance_class = ServiceArea
lookup_field = '_id'
schema = MongoSchema(manual_fields=[
MethodField(
"body",
required=True,
location="body",
schema=coreschema.Object(),
methods=['POST', 'PUT', 'PATCH'],
),
MethodField(
"lat",
required=False,
location="query",
schema=coreschema.Number(),
methods=['GET'],
),
MethodField(
"lng",
required=False,
location="query",
schema=coreschema.Number(),
methods=['GET'],
),
])
def filter_queryset(self, queryset):
if 'lat' in self.request.query_params and 'lng' in self.request.query_params:
lat = float(self.request.query_params['lat'])
lng = float(self.request.query_params['lng'])
return queryset.raw({
'geometry': {
'$geoIntersects': {
'$geometry': {
'type': 'Point',
'coordinates': [lat, lng]
}
}
}
})
else:
return queryset
def perform_create(self, instance):
instance.user_id = self.request.user.pk
super(ServiceAreaViewSet, self).perform_create(instance)
def fallback_schema_from_field(self, field):
import coreschema
# Using django default `force_text` instead of inconsistent drf_openapi
from django.utils.encoding import force_text
title = force_text(field.label) if field.label else ''
description = force_text(field.help_text) if field.help_text else ''
if isinstance(field, (serializers.DictField, serializers.JSONField)):
return coreschema.Object(properties={},
title=title,
description=description)
return None
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 schema(self):
field_name = "params"
location = "body"
required = True
schema = coreschema.String(max_length=30)
if self.request.method == 'GET':
field_name = "name"
location = "query"
required = False
elif self.request.method == 'POST':
schema = coreschema.Object()
return schemas.ManualSchema(fields=[
coreapi.Field(field_name,
required=required,
location=location,
schema=schema)
])
def add_object_definitions(self, method, view):
"""Create an Object definition from serializer
It will create a different definitions depending on the method, definition name is
{serializer class name}_{read|write}
POST, PUT, PATCH is write
GET, DELETE, HEAD is read
write methods will not include read only fields
read methods will not include write only fields
Note that for write methods it will also return a read definition because by default this is the definition
object returned by write methods
:param str method: GET, POST etc
:param rest_framework.generics.GenericAPIView view:
"""
if not hasattr(view, 'get_serializer'):
return None
try:
serializer = view.get_serializer()
except AssertionError: # Default behaviour of GenericAPIView is to raise AssertionError
return None
if method in ('POST', 'PUT', 'PATCH'):
write = True
# also generate a read definition, because it is commonly used as response for write actions
self.add_object_definitions('GET', view)
name = '%s_write' % serializer.__class__.__name__
elif method in ('GET', 'DELETE', 'HEAD'):
write = False
name = '%s_read' % serializer.__class__.__name__
else:
assert False, 'Can not recognize method %s' % method
if name in self.definitions:
return
fields = []
for field in serializer.fields.values():
if isinstance(field, serializers.HiddenField) or write and field.read_only or \
not write and field.write_only:
continue
# required = bool(field.required) # field.required is a list
field = field_to_schema(field)
fields.append(field)
self.definitions[name] = coreschema.Object(title=name,
properties=fields)
return self.definitions[name]
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 render_form(link):
properties = dict([(field.name, field.schema or coreschema.String())
for field in link.fields])
required = []
schema = coreschema.Object(properties=properties, required=required)
return coreschema.render_to_form(schema)
from frontend import common
from frontend.common import Result
from frontend.settings import DEBUG
from msg.models import SmsCode
from user.models import User
@api_view(['POST'])
@schema(
AutoSchema(manual_fields=[
coreapi.Field(
'data',
location='body',
schema=coreschema.Object(
description=
'{"mobile": "176666622222","verify_code(optional)":"5462"}'),
required=True),
# coreapi.Field('verifyCode', location='form', schema=coreschema.String(description='verifyCode(optional)'))
]))
def sms_reg(request):
data = request.data
code = random.randint(100000, 999999)
send_code(data["mobile"], code)
if DEBUG:
result = Result(data=code)
else:
result = Result()
return Response(json.dumps(result))
"user_name",
required=False,
location="form", #form
schema=coreschema.String(),
# schema=coreschema.String(),
description="用户名称",
),
])
PermissionUpdateSchema = AutoSchema([
# token_field,
coreapi.Field(
"permission",
required=True,
location="form", # from,query,url
schema=coreschema.Object(),
# schema=coreschema.String(),
description="权限",
),
])
UserUpdateSchema = AutoSchema([
# token_field,
coreapi.Field(
"user",
required=True,
location="form", # from,query,url
schema=coreschema.Object(),
# schema=coreschema.String(),
description="用户",
),
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),
"maxItems":
coreschema.Integer(minimum=0),
"uniqueItems":
coreschema.Boolean(default=False),
# Object validators
"properties":
coreschema.Ref("SchemaMap"),
"patternProperties":
coreschema.Ref("SchemaMap"),
"additionalProperties":
coreschema.Boolean() | coreschema.Ref("Schema"),
"minProperties":
coreschema.Integer(minimum=0, default=0),
"maxProperties":
coreschema.Integer(minimum=0),
"required":
coreschema.Ref("StringArray"),
"dependancies":
coreschema.Object(
additional_properties=coreschema.Ref("Schema")
| coreschema.Ref("StringArray")),
# Enum validators
"enum":
coreschema.Array(min_items=1, unique_items=True),
# Composites
"allOf":
coreschema.Ref("SchemaArray"),
"anyOf":
coreschema.Ref("SchemaArray"),
"oneOf":
coreschema.Ref("SchemaArray"),
"not":
coreschema.Ref("Schema"),
},
# dependancies=..., TODO
default={},
),
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='client_data',
required=True,
location='form',
schema=coreschema.Object(
description=
'Client data like first name, last name, email and phone number',
))
]))
@permission_classes(())
@authentication_classes(())
def replace_client_data(request, booking_id, format=None):
"""
Removes old and creates new client information instance
"""
try:
booking = Booking.objects.get(pk=booking_id)
check_booking_token(booking, request.data.get('token'))
client_data = request.data.get('client_data', {})
client_data['username'] = secrets.token_urlsafe(10)
serializer = ClientSerializer(data=client_data)
with transaction.atomic():
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 UpdateProfilePic(APIView):
"""
post:
API for update user profile picture. Auth token required.
"""
# Parameter description for API documentation starts here
schema = schemas.ManualSchema(fields=[
coreapi.Field(
"profile_pic",
required=False,
location="form",
schema=coreschema.Object(
description="Test this API with Postmen"
)
)
])
# Parameter description for API documentation ends here
permission_classes = (permissions.IsAuthenticated,)
def post(self, request):
try:
user = User.objects.get(id=request.user.id)
except ValidationError as v:
return Response(
{
'status': status.HTTP_401_UNAUTHORIZED,
'message': 'invalid token',
'data': ''
}
)
if 'profile_pic' not in self.request.data:
return Response(
{
'status': status.HTTP_400_BAD_REQUEST,
'message': 'Invalid file given',
'data': ''
},
status=status.HTTP_400_BAD_REQUEST
)
file_name = self.request.data['profile_pic']
if not file_name.name.lower().endswith(('.jpg', '.jpeg')):
return Response(
{
'status': status.HTTP_400_BAD_REQUEST,
'message': 'Invalid image format is given',
'data': ''
},
status=status.HTTP_400_BAD_REQUEST
)
rndm = random.randint(100000, 9999999)
upload_dir = make_dir(
settings.MEDIA_ROOT + settings.CUSTOM_DIRS.get('USER_IMAGE') + '/' + str(rndm) + '/'
)
file_name = file_upload_handler(file_name, upload_dir)
profile_pic = settings.MEDIA_URL + settings.CUSTOM_DIRS.get('USER_IMAGE') + '/' + str(
rndm) + '/' + file_name
user.profile_pic = profile_pic
user.save()
return Response(
{
'status': status.HTTP_201_CREATED,
'message': 'Profile picture updated.',
'data': {
'profile_pic': profile_pic,
'user_name': user.username
}
},
status=status.HTTP_201_CREATED
)
'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),
'maxItems': coreschema.Integer(minimum=0),
'uniqueItems': coreschema.Boolean(default=False),
# Object validators
'properties': coreschema.Ref('SchemaMap'),
'patternProperties': coreschema.Ref('SchemaMap'),
'additionalProperties': coreschema.Boolean() | coreschema.Ref('Schema'),
'minProperties': coreschema.Integer(minimum=0, default=0),
'maxProperties': coreschema.Integer(minimum=0),
'required': coreschema.Ref('StringArray'),
'dependancies': coreschema.Object(additional_properties=coreschema.Ref('Schema') | coreschema.Ref('StringArray')),
# Enum validators
'enum': coreschema.Array(min_items=1, unique_items=True),
# Composites
'allOf': coreschema.Ref('SchemaArray'),
'anyOf': coreschema.Ref('SchemaArray'),
'oneOf': coreschema.Ref('SchemaArray'),
'not': coreschema.Ref('Schema')
},
# dependancies=..., TODO
default={},
),
class HistoryViewSet(viewsets.ModelViewSet):
"""
API endpoint that allows Command History to be viewed or edited.
"""
permission_classes = (IsAuthenticated, )
serializer_class = HistorySerializer
lookup_field = 'command_id'
permissions = {
'create': (IsAuthenticated, ),
'destroy': (IsAdminUser, ),
'partial_update': (IsAdminUser, ),
'retrieve': (IsAuthenticated, ),
'update': (IsAdminUser, ),
# Custom Views
'send': (IsAuthenticated, ),
}
queryset = SentHistory.objects.order_by('-received_on')
filter_backends = (filters.OrderingFilter, )
ordering_fields = ('command_id', 'user', 'received_on', 'actuators',
'status', 'details')
schema = utils.OrcSchema(send_fields=[
coreapi.Field(
"actuator",
required=False,
location="json",
schema=coreschema.String(
description='Actuator/Type that is to receive the command.')),
coreapi.Field(
"command",
required=True,
location="json",
schema=coreschema.Object(
description='Command that is to be sent to the actuator(s).'))
])
def get_permissions(self):
"""
Instantiates and returns the list of permissions that this view requires.
"""
return [
permission() for permission in self.permissions.get(
self.action, self.permission_classes)
]
def list(self, request, *args, **kwargs):
"""
Return a list of all commands that the user has executed, all commands if admin
"""
self.pagination_class.page_size_query_param = 'length'
self.pagination_class.max_page_size = 100
queryset = self.filter_queryset(self.get_queryset())
if not request.user.is_staff: # Standard User
queryset = queryset.filter(user=request.user)
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
def retrieve(self, request, *args, **kwargs):
"""
Return a specific command that the user has executed, command if admin
"""
command = self.get_object()
if not request.user.is_staff: # Standard User
if command.user is not request.user:
raise PermissionDenied(
detail='User not authorised to access command', code=401)
serializer = self.get_serializer(command)
return Response(serializer.data)
@action(methods=['PUT'], detail=False)
def send(self, request, *args, **kwargs):
"""
Sends the specified command to the specified orchestrator in the command or in the request
"""
rslt = action_send(
usr=request.user,
cmd=request.data.get('command', {}),
actuator=request.data.get('actuator', None),
channel=request.data.get('channel', {}),
)
return Response(*rslt)
uid = request.query_params['uid']
page = request.query_params['page']
print(page)
user = User.objects.filter(user_id=uid).first()
return Response(user)
@api_view(['POST'])
@transaction.atomic
@schema(
AutoSchema(manual_fields=[
coreapi.Field(
'data',
location='body',
schema=coreschema.Object(
description=
'{"mobile":"18665411234", "password":"******", "verify_code":"123456"}'
),
required=True),
]))
@check_required(["mobile", "password", "verify_code"])
def register(request):
"""
user register api
:param request:
:return:
"""
data = request.data
mobile = data["mobile"]
code = data["verify_code"]
password = data["password"]
#
