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)
get, post, delete, put, patch
location:
form, path, query, body*
type:
integer, string, float, date
"""
TRAVEL = {
'travel': {
'list':
coreapi.Link(url='/travel/',
action='get',
fields=[
coreapi.Field(name='st',
required=False,
location='query',
description='Estado del viaje',
type='string'),
coreapi.Field(
name='str',
required=True,
location='form',
description='City name or airport code.')
],
description='Return flight availability and prices.'),
'create':
coreapi.Link(url='/travel/{pk}/',
action='post',
fields=[
coreapi.Field(
name='pk',
import coreapi
import coreschema
from rest_framework.schemas import AutoSchema
token_field = coreapi.Field(
name="Authorization",
required=False,
location="head",
schema=coreschema.String(),
description="格式：JWT 值",
)
TokenSchema = AutoSchema([token_field])
AlarmSchema = AutoSchema([
coreapi.Field(
"type_id",
required=False,
location="query",
schema=coreschema.Integer(),
description="告警类型id",
),
coreapi.Field(
"level_id",
required=False,
location="query",
schema=coreschema.Integer(),
description="告警级别id",
),
coreapi.Field(
"scene_id",
class WorkFlowNetConfWcnn(APIView):
# TODO:add document sample for swagger (need to update)
coreapi_fields = (
coreapi.Field(
name='parm1',
required=True,
type='string',
),
coreapi.Field(
name='parm2',
required=True,
type='string',
),
)
def post(self, request, nnid, ver, node):
"""
- desc : insert data
"""
try:
input_data = request.data
input_data['model_path'] = get_model_path(nnid, ver, node)
return_data = WcnnConf(nnid + "_" + ver + "_" + node).set_view_obj(
nnid, ver, node, input_data)
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def get(self, request, nnid, ver, node):
"""
- desc : get data
"""
try:
return_data = ""
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def put(self, request, nnid, ver, node):
"""
- desc ; update data
"""
try:
input_data = request.data
input_data['model_path'] = get_model_path(nnid, ver, node)
nodeid = ''.join([nnid, '_', ver, '_', node])
return_data = WcnnConf().set_view_obj(nodeid, input_data)
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def delete(self, request, nnid, ver, node):
"""
- desc : delete data
"""
try:
return_data = ""
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
import coreschema
from django.db import transaction
from rest_framework.decorators import api_view, schema
from rest_framework.response import Response
from rest_framework.schemas import AutoSchema
from frontend import common
from frontend.common import check_required, Result, encode_passwd, gen_user_id
from frontend.models import SmsCode, User
@api_view(['GET', 'POST'])
@schema(
AutoSchema(manual_fields=[
coreapi.Field('uid',
location='query',
schema=coreschema.String(description='search value')),
coreapi.Field('page',
location='query',
schema=coreschema.Integer(description='page', )),
]))
def user_detail(request):
"""
User detail
"""
uid = request.query_params['uid']
page = request.query_params['page']
print(page)
user = User.objects.filter(user_id=uid).first()
return Response(user)
def get_custom_links():
"""
Return a dictionary containing all the links that should be
included in the API schema.
"""
links = OrderedDict()
# Somehow query filters dont work correctly in the documentation window, probably better to leave them out
filterfields = [
coreapi.Field(
name="chr",
schema=coreschema.Integer(
title="Chromosome",
description=
"The chromosome of interest. Multiple choices can be chained when accessing programmatically."
),
location="query"),
coreapi.Field(
name="maf",
schema=coreschema.String(
title="MAF",
description=
"The MAF filter, options are 1 (for <1%), 1-5 (for 1-5%), 5-10 (for 5-10%) and 10 (for >10%). Multiple choices can be chained when accessing programmatically."
),
location="query"),
coreapi.Field(
name="mac",
schema=coreschema.String(
title="MAC",
description=
"The MAC filter, options are 0 (for MAC≤5) and 5 (for MAC>5), default is 5. Multiple choices can be chained when accessing programmatically."
),
location="query"),
coreapi.Field(
name="annotation",
schema=coreschema.String(
title="Annotation",
description=
"The SNP annotation filter, options are ns (for non-synonymous coding), s (for synonymous coding), in (for introns) and i (for intergenic). Multiple choices can be chained when accessing programmatically."
),
location="query"),
coreapi.Field(
name="type",
schema=coreschema.String(
title="Type",
description=
"The SNP type filter, options are genic and non-genic."),
location="query"),
coreapi.Field(
name="significant",
schema=coreschema.String(
title="Significant",
description=
"The significance filter, options are 0 for no filtering, p for permutation-threshold filtering and b for Bonferroni-threshold filtering. Default is p."
),
location="query"),
]
associations = {
"list":
coreapi.Link(
url="/api/associations/",
action="get",
description=
"List all associations meeting the filtering criteria sorted by score.",
fields=filterfields),
"aggregated_statistics":
coreapi.Link(
url="/api/associations/aggregated_statistics/",
action="get",
description=
"Retrieve the aggregation percentage for associations meeting filters criteria.",
fields=filterfields),
"count":
coreapi.Link(
url="/api/associations/count/",
action="get",
description=
"Retrieve the number of significant associations in the database.",
),
}
genes = {
"list":
coreapi.Link(
url="/api/genes/",
action="get",
description=
"List all genes in the database. Can add 'chrom', 'start' and 'end' as params in the url request.",
fields=[
coreapi.Field(
name="chr",
location="query",
schema=coreschema.Integer(
title="Chromosome",
description=
"The chromosome of interest of the search region")),
coreapi.Field(
name="start",
location="query",
schema=coreschema.Integer(
title="Start position",
description="The begininning of the search region")),
coreapi.Field(name="end",
location="query",
schema=coreschema.Integer(
title="End position",
description="The end of the search region"))
]),
"read":
coreapi.Link(url="/api/genes/{id}/",
action="get",
description="Retrieve information about a specific gene.",
fields=[
coreapi.Field(name="id",
required=True,
location="path",
schema=coreschema.String(
title="Gene ID",
description="The name of the gene"))
]),
"top_list":
coreapi.Link(
url="/api/genes/top_list/",
action="get",
description=
"Retrieve the top genes based on the number of significant associations and provide full gene information.",
fields=[]),
"associations":
coreapi.Link(
url="/api/genes/{id}/associations/",
action="get",
description=
"Return associations meeting the filtering criteria for the selected gene.",
fields=filterfields[1:] + [
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.String(
title="Gene ID",
description=
"The name of the gene for which associations should be loaded."
))
]),
"aggregated_statistics":
coreapi.Link(
url="/api/genes/{id}/aggregated_statistics/",
action="get",
description=
"Retrieve the aggregation percentage for associations meeting the filtering criteria for this gene.",
fields=filterfields[1:] + [
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.String(
title="Gene ID",
description=
"The name of the gene for which statistics should be computed."
))
]),
}
genotypes = {
"list":
coreapi.Link(url="/api/genotypes/",
action="get",
description="List available genotypes.",
fields=[]),
"read":
coreapi.Link(
url="/api/genotypes/{id}/",
action="get",
description="Retrieve information about a specific genotype.",
fields=[
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.Integer(
title="Genotype ID",
description=
"A unique integer value identifying this genotype."))
]),
}
phenotypes = {
"list":
coreapi.Link(
url="/api/phenotypes/",
action="get",
description="List available phenotypes.",
fields=[
coreapi.Field(
name="page",
location="query",
schema=coreschema.Integer(
title="Page number",
description=
"A page number within the paginated result set."))
]),
"read":
coreapi.Link(
url="/api/genotypes/{id}/",
action="get",
description="Retrieve information about a specific genotype.",
fields=[
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.Integer(
title="Phenotype ID",
description=
"A unique integer value identifying this phenotype."))
]),
"studies":
coreapi.Link(
url="/api/genotypes/{id}/studies",
action="get",
description="Get a list of studies for a specific phenotype.",
fields=[
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.Integer(
title="Phenotype ID",
description=
"A unique integer value identifying this phenotype."))
]),
}
search = {
"search_results":
coreapi.Link(url="/api/search/search_results/{query_term}/",
action="get",
description="Display results based on search term.",
fields=[
coreapi.Field(name="query_term",
required=True,
location="path",
schema=coreschema.String(
title="Query term",
description="Search term"))
]),
}
studies = {
"list":
coreapi.Link(
url="/api/studies/",
action="get",
description="List all available GWA studies.",
fields=[
coreapi.Field(
name="page",
location="query",
schema=coreschema.Integer(
title="Page",
description=
"A page number within the paginated result set."))
]),
"read":
coreapi.Link(
url="/api/studies/{id}/",
action="get",
description="Retrieve information about a specific GWA study.",
fields=[
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.Integer(
title="Study ID",
description=
"A unique integer value identifying this study."))
]),
"aggregated_statistics":
coreapi.Link(
url="/api/studies/{id}/aggregated_statistics/",
action="get",
description=
"Retrieve the aggregation statistics of the top assocations meeting the filtering criteria for a study and a specific set of filters.",
fields=filterfields + [
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.Integer(
title="Study ID",
description=
"A unique integer value identifying this study."))
]),
"top_associations":
coreapi.Link(
url="/api/studies/{id}/associations/",
action="get",
description=
"Retrieve top associations meeting the filtering criteria for the selected study.",
fields=filterfields + [
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.Integer(
title="Study ID",
description=
"A unique integer value identifying this study."))
]),
"top_genes_and_snp_type":
coreapi.Link(
url="/api/studies/{id}/top/",
action="get",
description=
"Get genes and SNP type that got the most significant associations for a specific study. The returned fields will be empty if there are no significant associations for the selected study.",
fields=[
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.Integer(
title="Study ID",
description=
"A unique integer value identifying this study."))
]),
}
links['associations'] = associations
links['genes'] = genes
links['genotypes'] = genotypes
links['phenotypes'] = phenotypes
links['search'] = search
links['studies'] = studies
return links
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 MappingStatusView(APIView):
"""
Change the status of a mapping
"""
permission_classes = (IsAuthenticated, )
schema = ManualSchema(
description="Change the status of a mapping",
fields=[
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.Integer(),
description="A unique integer value identifying the mapping"),
])
def put(self, request, pk):
mapping = get_mapping(pk)
# retrieve the status object associated to the given description
try:
s = CvUeStatus.objects.get(description=request.data['status'])
except KeyError:
raise Http404("Payload should have 'status'")
except CvUeStatus.DoesNotExist:
raise Http404("Couldn't get status object for {}".format(
request.data['status']))
except MultipleObjectsReturned:
raise Http404("Couldn't get unique status for {}".format(
request.data['status']))
"""
If the mapping has already been assigned that status, update the timestamp,
otherwise create one from scratch
"""
try:
mapping_status = UeMappingStatus.objects.filter(
mapping=mapping).latest('time_stamp')
except UeMappingStatus.DoesNotExist:
# It's alright, for the first status change of a mapping a
# historic record won't exist.
pass
else:
if mapping_status.status.id == s.id:
# The user is trying to change it to what the status
# already is, nothing to do.
return Response(status=status.HTTP_204_NO_CONTENT)
# create new mapping status
serializer = MappingStatusSerializer(
data={
'time_stamp': timezone.now(),
'user_stamp': request.user,
'status': s.id,
'mapping': mapping.mapping_id
})
if serializer.is_valid():
serializer.save()
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
# Update the status in the mapping record
mapping.status = s
mapping.save()
# update status on mapping_view corresponding entry,
# otherwise search won't reflect the status change
try:
mv = MappingView.objects.get(mapping_id=pk)
except MappingView.DoesNotExist:
return Response(
{
"error":
"Could not find mapping {} in search table.".format(pk)
},
status=status.HTTP_400_BAD_REQUEST)
else:
prev_status = CvUeStatus.objects.get(id=mv.status)
mv.status = s.id
mv.save()
email = GiftsEmail(request)
build_status_change_email = email.build_status_change_email(
mapping, prev_status.description, s.description)
if build_status_change_email:
email.send()
return Response(serializer.data, status=status.HTTP_201_CREATED)
import requests
from django.core.exceptions import ObjectDoesNotExist
from rest_framework import status
from rest_framework.decorators import api_view, schema, permission_classes, authentication_classes
from rest_framework.response import Response
from rest_framework.schemas import AutoSchema
from cinema.models import Booking
from cinema.serializers.booking import BookingSerializer
@api_view(['POST'])
@schema(
AutoSchema(manual_fields=[
coreapi.Field(name='client_id',
required=True,
location='form',
schema=coreschema.String(description='POS client id')),
coreapi.Field(name='client_secret',
required=True,
location='form',
schema=coreschema.String(
description='POS client secret'))
]))
@permission_classes(())
@authentication_classes(())
def get_payu_oauth_token(request, format=None):
"""
Proxy for PayU OAuth token retrieval.
Returns OAuth token
"""
data = requests.post(
class EditDeleteCommentView(APIView):
"""
Edit (PUT) and delete (DELETE) a comment for a given mapping.
"""
permission_class = (IsAuthenticated, )
schema = ManualSchema(
description="Edit or delete a comment for a given mapping.",
fields=[
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.Integer(),
description="A unique integer value identifying the mapping"),
coreapi.Field(
name="comment_id",
required=True,
location="path",
schema=coreschema.Integer(),
description="A unique integer value identifying the comment"),
])
def put(self, request, pk, comment_id):
mapping = get_mapping(pk)
if 'text' not in request.data:
return Response({"error": "Text not specified"},
status=status.HTTP_400_BAD_REQUEST)
try:
comment = mapping.comments.get(id=comment_id)
except UeMappingComment.DoesNotExist:
return Response(
{"error": "Invalid comment ID: {}".format(comment_id)},
status=status.HTTP_400_BAD_REQUEST)
else:
if comment.deleted:
return Response({"error": "Cannot edit deleted comment"},
status=status.HTTP_400_BAD_REQUEST)
comment.comment = request.data['text']
comment.time_stamp = timezone.now()
comment.save()
editable = False
if request.user and request.user == comment.user_stamp:
editable = True
serializer = CommentLabelSerializer({
'commentId': comment.id,
'text': comment.comment,
'timeAdded': comment.time_stamp,
'user': comment.user_stamp.full_name,
'editable': editable
})
return Response(serializer.data)
def delete(self, request, pk, comment_id):
mapping = get_mapping(pk)
try:
comment = mapping.comments.get(id=comment_id)
except:
return Response(
{"error": "Invalid comment ID: {}".format(comment_id)},
status=status.HTTP_400_BAD_REQUEST)
else:
comment.deleted = True
comment.save()
return Response(status=status.HTTP_204_NO_CONTENT)
class MappingCommentsView(APIView):
"""
Add a comment/Retrieve all comments relative to a given mapping, includes
mapping labels.
"""
permission_classes = (IsAuthenticated, )
schema = ManualSchema(
description=(
"Add a comment/Retrieve all comments relative to a given mapping, "
"includes mapping labels."),
fields=[
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.Integer(),
description="A unique integer value identifying the mapping"),
])
def get(self, request, pk):
mapping = get_mapping(pk)
# fetch mapping comment history, exclude deleted comments
mapping_comments = mapping.comments.filter(
deleted=False).order_by('-time_stamp')
# comments are editable if they belong to the requesting user
comments = []
for comment in mapping_comments:
comments.append({
'commentId':
comment.id,
'text':
comment.comment,
'timeAdded':
comment.time_stamp,
'user':
comment.user_stamp.full_name,
'editable':
request.user and request.user == comment.user_stamp
})
data = {'mappingId': pk, 'comments': comments}
serializer = MappingCommentsSerializer(data)
return Response(serializer.data)
def post(self, request, pk):
mapping = get_mapping(pk)
try:
serializer = MappingCommentSerializer(
data={
'time_stamp': timezone.now(),
'user_stamp': request.user,
'comment': request.data['text'],
'mapping': mapping.mapping_id,
'deleted': False
})
except KeyError:
raise Http404("Must provide comment")
if serializer.is_valid():
serializer.save()
email = GiftsEmail(request)
build_comments_email = email.build_comments_email(mapping)
if build_comments_email:
email.send()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class MappingLabelView(APIView):
"""
Add or delete label a associated to the given mapping
"""
permission_classes = (IsAuthenticated, )
schema = ManualSchema(
description="Add or delete label a associated to the given mapping",
fields=[
coreapi.Field(
name="id",
required=True,
location="path",
schema=coreschema.Integer(),
description="A unique integer value identifying the mapping"),
coreapi.Field(
name="label_id",
required=True,
location="path",
schema=coreschema.Integer(),
description="A unique integer value identifying the label"),
])
def post(self, request, pk, label_id):
mapping = get_mapping(pk)
mapping_labels = UeMappingLabel.objects.filter(mapping=mapping,
label=label_id)
if mapping_labels:
# mapping already has a label, ignore
return Response(status=status.HTTP_204_NO_CONTENT)
try:
serializer = MappingLabelSerializer(
data={
'time_stamp': timezone.now(),
'user_stamp': request.user,
'label': label_id,
'mapping': pk
})
except KeyError:
raise Http404("Must provide valid label")
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, pk, label_id):
mapping = get_mapping(pk)
# delete all labels with the given description attached to the mapping
# TODO: only those associated to the given user
mapping_labels = UeMappingLabel.objects.filter(mapping=mapping,
label=label_id)
if mapping_labels:
mapping_labels.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
raise Http404
class SDKTraitsDeprecated(SDKAPIView):
# API to handle /api/v1/identities/<identifier>/traits/<trait_key> endpoints
# if Identity or Trait does not exist it will create one, otherwise will fetch existing
serializer_class = TraitSerializerBasic
schema = AutoSchema(manual_fields=[
coreapi.Field("X-Environment-Key",
location="header",
description="API Key for an Environment"),
coreapi.Field("identifier",
location="path",
required=True,
description="Identity user identifier"),
coreapi.Field("trait_key",
location="path",
required=True,
description="User trait unique key")
])
def post(self, request, identifier, trait_key, *args, **kwargs):
"""
THIS ENDPOINT IS DEPRECATED. Please use `/traits/` instead.
"""
trait_data = request.data
if 'trait_value' not in trait_data:
error = {"detail": "Trait value not provided"}
return Response(error, status=status.HTTP_400_BAD_REQUEST)
# if we have identifier fetch, or create if does not exist
if identifier:
identity, _ = Identity.objects.get_or_create(
identifier=identifier,
environment=request.environment,
)
else:
return Response({"detail": "Missing identifier"},
status=status.HTTP_400_BAD_REQUEST)
# if we have identity trait fetch, or create if does not exist
if trait_key:
# need to create one if does not exist
trait, _ = Trait.objects.get_or_create(
identity=identity,
trait_key=trait_key,
)
else:
return Response({"detail": "Missing trait key"},
status=status.HTTP_400_BAD_REQUEST)
if trait and 'trait_value' in trait_data:
# Check if trait value was provided with request data. If so, we need to figure out value_type from
# the given value and also use correct value field e.g. boolean_value, integer_value or
# string_value, and override request data
trait_data = trait.generate_trait_value_data(
trait_data['trait_value'])
trait_full_serializer = TraitSerializerFull(trait,
data=trait_data,
partial=True)
if trait_full_serializer.is_valid():
trait_full_serializer.save()
return Response(self.get_serializer(trait).data,
status=status.HTTP_200_OK)
else:
return Response(trait_full_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({"detail": "Failed to update user trait"},
status=status.HTTP_400_BAD_REQUEST)
from rest_framework import filters
from rest_framework import exceptions
from PoleLuxe.constants import CategoryType
from PoleLuxe.models import (
Feed,
Media,
UserGroup,
)
from api.v1.views.base import (LEGACY_SCHEMA_AUTH_FIELD, INCLUDE_SCHEMA_FIELD)
LEGACY_SCHEMA_FIELDS = [
LEGACY_SCHEMA_AUTH_FIELD,
coreapi.Field(name='feed_id',
location='query',
required=False,
schema=coreschema.Integer(),
description='Feed ID.'),
coreapi.Field(name='user_group_id',
location='query',
required=True,
type='string',
schema=coreschema.Integer(),
description='User group ID.'),
coreapi.Field(name='oldest_feed_id',
location='query',
required=False,
schema=coreschema.Integer(),
description='''Oldest feed ID.
For pagination use. The parameter should be the last object id
returned in the last of this API (last page). If it is the
def get_schema_fields(self, view):
return [
coreapi.Field('organization_id', location='query', required=True, type='integer'),
]
import coreapi
import coreschema
from rest_framework.schemas import AutoSchema, ManualSchema
token_field = coreapi.Field(
name="Authorization",
required=False,
location="header",
schema=coreschema.String(),
description="格式：JWT 值",
)
TokenSchema = AutoSchema([token_field])
#商品列表
GoodsListSchema = AutoSchema([
# token_field,
coreapi.Field(
"good_id",
required=False,
location="query", #form
schema=coreschema.Integer(),
# schema=coreschema.String(),
description="商品ID",
),
])
#商品分类列表
TypeListSchema = AutoSchema([
# token_field,
coreapi.Field(
"type_id",
class ServiceManagerPredict(APIView):
# TODO:add document sample for swagger (need to update)
coreapi_fields = (
coreapi.Field(
name='parm1',
required=True,
type='string',
),
coreapi.Field(
name='parm2',
required=True,
type='string',
),
)
def post(self, request, type, nnid, ver):
"""
- desc : insert cnn configuration data
"""
try:
if (ver == 'active'):
if (type == 'w2v'):
return_data = PredictNetW2V().run(nnid, request.data)
elif (type == "d2v"):
return_data = PredictNetD2V().run(nnid, request.data)
elif (type == "cnn"):
# TO-DO : need predict function for active taged version
raise Exception("on developing now !")
elif (type == "wdnn"):
return_data = PredictNetWdnn().run(nnid, ver,
request.FILES)
elif (type == "seq2seq"):
return_data = PredictNetSeq2Seq().run(nnid, request.data)
elif (type == "autoencoder"):
return_data = PredictNetAutoEncoder().run(
nnid, request.data)
elif (type == "renet"):
#return_data = PredictNetRenet().run(nnid, ver, request.FILES)
# TO-DO : need to create PredictNetRenet class first
raise Exception("on developing now !")
elif (type == "anomaly"):
return_data = PredictNetAnomaly().run(nnid, request.data)
elif (type == "wcnn"):
return_data = PredictNetWcnn().run(nnid, request.data)
elif (type == "bilstmcrf"):
return_data = PredictNetBiLstmCrf().run(nnid, request.data)
else:
raise Exception("Not defined type error")
else:
if (type == 'w2v'):
# TO-DO : need predict function for specific version
raise Exception("on developing now !")
elif (type == "d2v"):
# TO-DO : need predict function for specific version
raise Exception("on developing now !")
elif (type == "cnn"):
return_data = PredictNetCnn().run(nnid, ver, request.FILES)
elif (type == "wdnn"):
return_data = PredictNetWdnn().run(nnid, ver,
request.FILES)
elif (type == "seq2seq"):
# TO-DO : need predict function for specific version
raise Exception("on developing now !")
elif (type == "renet"):
return_data = PredictNetRenet().run(
nnid, ver, request.FILES)
else:
raise Exception("Not defined type error")
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def get(self, request, type, nnid, ver):
"""
- desc : get cnn configuration data
"""
try:
return_data = ""
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def put(self, request, type, nnid, ver):
"""
- desc ; update cnn configuration data
"""
try:
return_data = ""
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def delete(self, request, type, nnid, ver):
"""
- desc : delete cnn configuration data
"""
try:
return_data = ""
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
class TimeSlotIntersectionView(APIView):
"""
get:
Returns one hour time slots common to two or more users.
**You must supply the required url query parameter `users` when sending
requests to this endpoint. The value of the query parameter should be
a comma separated string of at least two usernames. For example,
`?users=philipp,carl` will return the time slots common to both philipp
and carl, while `?users=philipp,sarah,carl` will compute the time slots
common to all three users.**
###Response schema
[
{
"users" : List of users for whom time slot intersections is
being computed,
"intersecting one hour time slots" : [
{
"start" : Start of a common one hour time slot
(YYYY-MM-DDThh:mm:ss),
"end" : End of the common one hour time slot
(YYYY-MM-DDThh:mm:ss),
},...
],
}
]
"""
schema = AutoSchema(manual_fields=[
coreapi.Field(
name="users",
required=True,
location="query",
description="Comma separated list of usernames.",
)
])
def get(self, request, format=None):
usernames_string = request.GET.get("users", None)
# This endpoint requires a value for the url query parameter "users"
if usernames_string is None:
return Response(
{
"error":
("No users specified. Please specify users using the "
"url parameter 'users' e.g. ?users=<user1>,<user2>."),
},
status=status.HTTP_400_BAD_REQUEST)
usernames_list = usernames_string.split(",")
# The url query parameter "user" must be a comma separated list of
# at least 2 usernames.
if len(usernames_list) == 1:
return Response(
{
"error":
("Only one user specified. Please specify at least two "
"users e.g. ?users=<user1>,<user2>."),
},
status=status.HTTP_400_BAD_REQUEST)
calendar_users = []
for username in usernames_list:
try:
calendar_user = CalendarUser.objects.get(username=username)
calendar_users.append(calendar_user)
except CalendarUser.DoesNotExist:
return Response(
{
"error": ("User {0} does not exist".format(username)),
},
status=status.HTTP_400_BAD_REQUEST)
# Collect sets of all one hour time slots for each user in a list
one_hour_time_slot_sets = []
for calendar_user in calendar_users:
one_hour_time_slot_set_for_this_calendar_user = set()
calendar_time_slots = CalendarTimeSlot.objects.filter(
creator=calendar_user)
for calendar_time_slot in calendar_time_slots:
set_of_all_one_hour_time_slots = set(
calendar_time_slot.get_all_one_hour_time_slots())
one_hour_time_slot_set_for_this_calendar_user = (
one_hour_time_slot_set_for_this_calendar_user.union(
set_of_all_one_hour_time_slots))
one_hour_time_slot_sets.append(
one_hour_time_slot_set_for_this_calendar_user)
# Compute the common one hour time slots
intersecting_one_hour_time_slots = set.intersection(
*one_hour_time_slot_sets)
response = {
"users":
usernames_list,
"intersecting one hour time slots": [{
"start":
dt.ctime(),
"end": (dt + timedelta(hours=1)).ctime()
} for dt in intersecting_one_hour_time_slots]
}
return Response(response)
class ConfServerData(APIView):
"""
"""
# TODO:add document sample for swagger (need to update)
coreapi_fields = (
coreapi.Field(
name='parm1',
required=True,
type='string',
),
coreapi.Field(
name='parm2',
required=True,
type='string',
),
)
def post(self, request, nnid):
"""
Your docs
---
# Class Name (must be separated by `---`)
# Description:
- name: name
description: Foobar long description goes here
"""
try:
return_data = ""
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def get(self, request, nnid):
"""
Your docs
---
# Class Name (must be separated by `---`)
# Description:
- name: name
description: Foobar long description goes here
"""
try:
return_data = ""
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def put(self, request, nnid):
"""
Your docs
---
# Class Name (must be separated by `---`)
# Description:
- name: name
description: Foobar long description goes here
"""
try:
return_data = ""
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def delete(self, request, nnid):
"""
Your docs
---
# Class Name (must be separated by `---`)
# Description:
- name: name
description: Foobar long description goes here
"""
try:
return_data = ""
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def get_schema_fields(self, view):
return coreapi.Field(name='word', required=False, location='query')
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)
def get_manual_fields(self, path, method):
extra_fields = []
if method.lower() in ('post', 'get'):
extra_fields = [coreapi.Field('nombre')]
manual_fields = super().get_manual_fields(path, method)
return manual_fields + extra_fields
class SDKFeatureStates(GenericAPIView):
serializer_class = FeatureStateSerializerFull
permission_classes = (EnvironmentKeyPermissions, )
authentication_classes = (EnvironmentKeyAuthentication, )
schema = AutoSchema(manual_fields=[
coreapi.Field(
"X-Environment-Key",
location="header",
description="API Key for an Environment",
),
coreapi.Field(
"feature",
location="query",
description="Name of the feature to get the state of",
),
])
def get(self, request, identifier=None, *args, **kwargs):
"""
USING THIS ENDPOINT WITH AN IDENTIFIER IS DEPRECATED.
Please use `/identities/?identifier=<identifier>` instead.
"""
if identifier:
return self._get_flags_response_with_identifier(
request, identifier)
filter_args = {
"identity": None,
"environment": request.environment,
"feature_segment": None,
}
if "feature" in request.GET:
filter_args["feature__name__iexact"] = request.GET["feature"]
try:
feature_state = FeatureState.objects.get(**filter_args)
except FeatureState.DoesNotExist:
return Response(
{"detail": "Given feature not found"},
status=status.HTTP_404_NOT_FOUND,
)
return Response(self.get_serializer(feature_state).data)
if settings.CACHE_FLAGS_SECONDS > 0:
data = self._get_flags_from_cache(filter_args, request.environment)
else:
data = self.get_serializer(
# ignore disabled Flags when project hide_disabled_flags is enabled
FeatureState.objects.filter(**filter_args).exclude(
feature__project__hide_disabled_flags=True,
enabled=False,
).select_related("feature", "feature_state_value"),
many=True,
).data
return Response(data)
def _get_flags_from_cache(self, filter_args, environment):
data = flags_cache.get(environment.api_key)
if not data:
data = self.get_serializer(
# ignore disabled Flags when project hide_disabled_flags is enabled
FeatureState.objects.filter(**filter_args).exclude(
feature__project__hide_disabled_flags=True,
enabled=False,
).select_related("feature", "feature_state_value"),
many=True,
).data
flags_cache.set(environment.api_key, data,
settings.CACHE_FLAGS_SECONDS)
return data
def _get_flags_response_with_identifier(self, request, identifier):
identity, _ = Identity.objects.get_or_create(
identifier=identifier, environment=request.environment)
kwargs = {
"identity": identity,
"environment": request.environment,
"feature_segment": None,
}
if "feature" in request.GET:
kwargs["feature__name__iexact"] = request.GET["feature"]
try:
feature_state = identity.get_all_feature_states().get(
feature__name__iexact=kwargs["feature__name__iexact"], )
except FeatureState.DoesNotExist:
return Response(
{"detail": "Given feature not found"},
status=status.HTTP_404_NOT_FOUND,
)
return Response(self.get_serializer(feature_state).data,
status=status.HTTP_200_OK)
flags = self.get_serializer(identity.get_all_feature_states(),
many=True)
return Response(flags.data, status=status.HTTP_200_OK)
def get_manual_fields(self, path, method):
extra_fields = []
if method.lower() in ['post', 'put']:
extra_fields = [
coreapi.Field('name'),
coreapi.Field('content'),
coreapi.Field('creation_date'),
coreapi.Field('completion_date'),
coreapi.Field('priority'),
coreapi.Field('is_done'),
coreapi.Field('repetition'),
coreapi.Field('category'),
coreapi.Field('owning_table_id')
]
if method.lower() == 'get':
extra_fields = [
coreapi.Field('date'),
coreapi.Field('table_id')
]
return super().get_manual_fields(path, method) + extra_fields
import coreapi
from rest_framework.schemas import ManualSchema
from rest_framework.compat import coreschema
MVT_SCHEMA = ManualSchema(fields=[
coreapi.Field(
"tile",
required=True,
location="query",
schema=coreschema.String(
description=
"TMS coordinates of the requested tile. The format should be tile=z/x/y"
),
),
coreapi.Field(
"limit",
required=False,
location="query",
schema=coreschema.String(
description="Number of results to return per page."),
),
coreapi.Field(
"offset",
required=False,
location="query",
schema=coreschema.String(
description="The initial index from which to return the results."),
),
])
class RunManagerAutoRule(APIView):
# TODO:add document sample for swagger (need to update)
coreapi_fields = (
coreapi.Field(
name='parm1',
required=True,
type='string',
),
coreapi.Field(
name='parm2',
required=True,
type='string',
),
)
def post(self, request, graph_id):
"""
Your docs
---
# Class Name (must be separated by `---`)
# Description:
- name: name
description: Foobar long description goes here
"""
try:
return_data = AutoMlRule().set_graph_type_list(
graph_id, request.data)
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def get(self, request, graph_id):
"""
Your docs
---
# Class Name (must be separated by `---`)
# Description:
- name: name
description: Foobar long description goes here
"""
try:
if (graph_id == 'all'):
return_data = AutoMlRule().get_graph_type_list()
elif (graph_id is not None):
return_data = AutoMlRule().get_graph_info(graph_id)
else:
raise Exception("no vailed graph_id")
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def put(self, request, graph_id):
"""
Your docs
---
# Class Name (must be separated by `---`)
# Description:
- name: name
description: Foobar long description goes here
"""
try:
return_data = AutoMlRule().update_graph_type_list(
graph_id, request.data)
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
def delete(self, request, graph_id):
"""
Your docs
---
# Class Name (must be separated by `---`)
# Description:
- name: name
description: Foobar long description goes here
"""
try:
return_data = ""
return Response(json.dumps(return_data))
except Exception as e:
return_data = {"status": "404", "result": str(e)}
return Response(json.dumps(return_data))
class ModelManagerView(object):
"""
Class to dialog with pyplan model
"""
@staticmethod
def register():
return [
# model related urls
path('modelManager/openModel/', ModelManagerView.openModel),
path('modelManager/getModelInfo/', ModelManagerView.getModelInfo),
path('modelManager/saveModel/', ModelManagerView.saveModel),
path('modelManager/saveModelAs/', ModelManagerView.saveModelAs),
path('modelManager/navigateDiagram/',
ModelManagerView.navigateDiagram),
path('modelManager/getArrows/', ModelManagerView.getArrows),
path('modelManager/getToolbars/', ModelManagerView.getToolbars),
path('modelManager/createNewModel/',
ModelManagerView.createNewModel),
path('modelManager/getModelPreferences/',
ModelManagerView.getModelPreferences),
path('modelManager/lastOpenModels/',
ModelManagerView.lastOpenModels),
path('modelManager/changeToOtherModelSession/',
ModelManagerView.changeToOtherModelSession),
path('modelManager/setModelPreferences/',
ModelManagerView.setModelPreferences),
path('modelManager/closeModel/', ModelManagerView.closeModel),
# node related urls
path('modelManager/getNodeProperties/',
ModelManagerView.getNodeProperties),
path('modelManager/setNodeProperties/',
ModelManagerView.setNodeProperties),
path('modelManager/setNodesProperties/',
ModelManagerView.setNodesProperties),
path('modelManager/getNodeInputs/',
ModelManagerView.getNodeInputs),
path('modelManager/getNodeOutputs/',
ModelManagerView.getNodeOutputs),
path('modelManager/searchNodes/', ModelManagerView.searchNodes),
path('modelManager/searchForAutocomplete/',
ModelManagerView.searchForAutocomplete),
path('modelManager/previewNode/', ModelManagerView.previewNode),
path('modelManager/getSelector/', ModelManagerView.getSelector),
path('modelManager/setNodesSize/', ModelManagerView.setNodesSize),
path('modelManager/setNodesPosition/',
ModelManagerView.setNodesPosition),
path('modelManager/getNodeProfile/',
ModelManagerView.getNodeProfile),
path('modelManager/createNode/', ModelManagerView.createNode),
path('modelManager/deleteNodes/', ModelManagerView.deleteNodes),
path('modelManager/createAlias/', ModelManagerView.createAlias),
path('modelManager/createInputNode/',
ModelManagerView.createInputNode),
path('modelManager/copyNodes/', ModelManagerView.copyNodes),
path('modelManager/copyAsValues/', ModelManagerView.copyAsValues),
path('modelManager/moveNodes/', ModelManagerView.moveNodes),
path('modelManager/stop/', ModelManagerView.stop),
path('modelManager/setNodeZ/', ModelManagerView.setNodeZ),
path('modelManager/setNodeIdFromTitle/',
ModelManagerView.setNodeIdFromTitle),
path('modelManager/executeForRefresh/',
ModelManagerView.executeForRefresh),
path('modelManager/exportFlatNode/',
ModelManagerView.exportFlatNode),
path('modelManager/exportCurrentNode/',
ModelManagerView.exportCurrentNode),
path('modelManager/exportModuleToFile/',
ModelManagerView.exportModuleToFile),
path('modelManager/importModuleFromFile/',
ModelManagerView.importModuleFromFile),
path('modelManager/getFilesForImportWizard/',
ModelManagerView.getFilesForImportWizard),
path('modelManager/callWizard/', ModelManagerView.callWizard),
path('modelManager/executeButton/',
ModelManagerView.executeButton),
path('modelManager/isInBackground/',
ModelManagerView.isInBackground),
# helper functions
path('modelManager/uploadFileToTemp/',
ModelManagerView.uploadFileToTemp),
path('modelManager/installLibrary/',
ModelManagerView.installLibrary),
path('modelManager/getInstallProgress/',
ModelManagerView.getInstallProgress),
]
# model related methods
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field(
"file", required=True, description="Model file to open")
]))
def openModel(request, *args, **kargs):
file = str(request.query_params.get("file", ""))
if file:
activity_service = ActivityService(request)
activity_service.registerOpenModel(file)
service = ModelManagerService(request)
model_info = service.openModel(file)
serializer = ModelInfoSerializer(model_info)
return Response(serializer.data)
raise exceptions.NotAcceptable("Model file not found")
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
def getModelInfo(request, *args, **kargs):
service = ModelManagerService(request)
model_info = service.getModelInfo()
return Response(model_info)
@staticmethod
@api_view(['GET'])
@permission_required('pyplan.change_model', raise_exception=True)
def saveModel(request, *args, **kargs):
try:
service = ModelManagerService(request)
result = service.saveModel()
if result:
return Response(status=status.HTTP_200_OK)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['GET'])
@permission_required('pyplan.change_model', raise_exception=True)
@schema(
AutoSchema(manual_fields=[
coreapi.Field(
"name", required=True, description="Name of the model")
]))
def saveModelAs(request, *args, **kargs):
modelName = str(request.query_params.get("name", ""))
if modelName:
if len(modelName) > 0:
service = ModelManagerService(request)
new_model = service.saveModelAs(modelName)
serializer = ModelInfoSerializer(new_model)
return Response(serializer.data)
else:
raise exceptions.NotAcceptable("Empty modelName was provided")
else:
raise exceptions.NotAcceptable("No modelName was provided")
@staticmethod
@api_view(['GET'])
@permission_required('pyplan.view_influence_diagram', raise_exception=True)
@schema(
AutoSchema(manual_fields=[
coreapi.Field("moduleId", required=False, description="Module ID"),
coreapi.Field(
"includeArrows", required=False, description="Include Arrows")
]))
def navigateDiagram(request, *args, **kargs):
module_id = str(request.query_params.get("moduleId", ""))
include_arrows = bool(request.query_params.get("includeArrows", False))
try:
service = ModelManagerService(request)
diagram = service.navigateDiagram(module_id, include_arrows)
serializer = NavigateDiagramSerializer(diagram)
return Response(serializer.data)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("moduleId", required=False, description="Module ID")
]))
def getArrows(request, *args, **kargs):
module_id = str(request.query_params.get("moduleId", ""))
try:
service = ModelManagerService(request)
result = service.getArrows(module_id)
serializer = NavigateDiagramSerializer({
"arrows":
result["arrows"],
"nodes": [],
"breadcrumb": [],
"moduleId":
result["module_id"]
})
return Response(serializer.data)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
def getToolbars(request, *args, **kargs):
try:
service = ModelManagerService(request)
result = service.getToolbars()
if result:
return Response(result)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['GET'])
@permission_required('pyplan.change_model', raise_exception=True)
@schema(
AutoSchema(manual_fields=[
coreapi.Field(
"modelName", required=True, description="Name of the model")
]))
def createNewModel(request, *args, **kargs):
modelName = str(request.query_params.get("modelName", ""))
if modelName:
if len(modelName) > 0:
service = ModelManagerService(request)
new_model = service.createNewModel(modelName)
serializer = ModelInfoSerializer(new_model)
return Response(serializer.data)
else:
raise exceptions.NotAcceptable("Empty modelName was provided")
else:
raise exceptions.NotAcceptable("No modelName was provided")
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
def getModelPreferences(request, *args, **kargs):
try:
service = ModelManagerService(request)
result = service.getModelPreferences()
return Response(result)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['GET'])
@permission_required('pyplan.list_last_models', raise_exception=True)
def lastOpenModels(request, *args, **kargs):
service = ActivityService(request)
serializer = ActivitySerializer(service.lastModels(), many=True)
return Response(serializer.data)
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
def changeToOtherModelSession(request, *args, **kargs):
new_session_key = request.query_params.get("new_session_key", "")
model_info = ModelManagerService(request).changeToOtherModelSession(
new_session_key)
serializer = ModelInfoSerializer(model_info)
return Response(serializer.data)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("modelPreferences",
required=False,
description="Model Preferences Object")
]))
def setModelPreferences(request, *args, **kargs):
serializer = ModelPreferenceSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
return Response(
service.setModelPreferences(serializer.validated_data))
except Exception as ex:
raise exceptions.NotAcceptable(
f"Error in setting model preferences:{str(ex)}")
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(AutoSchema(manual_fields=[]))
def closeModel(request, *args, **kargs):
service = ModelManagerService(request)
result = service.closeModel()
return Response(result)
# node related methods
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("node", required=True, description="Node ID"),
coreapi.Field("properties",
required=False,
description="Required node properties")
]))
def getNodeProperties(request, *args, **kargs):
serializer = NodePropertiesSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
result = service.getNodeProperties(
serializer.validated_data["node"],
serializer.validated_data["properties"])
response = NodePropertiesSerializer(result)
return Response(response.data)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("node", required=True, description="Node ID"),
coreapi.Field(
"properties", required=False, description="Node properties")
]))
def setNodeProperties(request, *args, **kargs):
serializer = NodePropertiesSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
result = service.setNodeProperties(
serializer.validated_data["node"],
serializer.validated_data["properties"])
if result:
return Response(status=status.HTTP_200_OK)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("node", required=True, description="Node ID"),
coreapi.Field(
"properties", required=False, description="Node properties")
]))
def setNodesProperties(request, *args, **kargs):
result = True
try:
if request.data:
if len(request.data) > 0:
serializer = NodePropertiesSerializer(data=request.data,
many=True)
serializer.is_valid(raise_exception=True)
service = ModelManagerService(request)
for data in serializer.validated_data:
result = service.setNodeProperties(
data["node"], data["properties"]) and result
if result:
return Response(status=status.HTTP_200_OK)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("node", required=True, description="Node ID")
]))
def getNodeInputs(request, *args, **kargs):
node_id = str(request.query_params.get("node", ""))
try:
service = ModelManagerService(request)
result = service.getNodeInputs(node_id)
return Response(result)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("node", required=True, description="Node ID")
]))
def getNodeOutputs(request, *args, **kargs):
node_id = str(request.query_params.get("node", ""))
try:
service = ModelManagerService(request)
result = service.getNodeOutputs(node_id)
return Response(result)
except Exception as ex:
raise exceptions.NotFound(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("text",
required=True,
location="query",
description="Text to search"),
coreapi.Field("nodeClass",
required=True,
location="query",
description="Node Class"),
coreapi.Field("moduleId",
required=True,
location="query",
description="Module ID"),
coreapi.Field("fillDetail",
required=True,
location="query",
description="Fill Detail"),
coreapi.Field("extraClasses",
required=True,
location="body",
description="Extra Classes"),
]))
def searchNodes(request, *args, **kargs):
text = str(request.query_params.get("text", ""))
module_id = request.query_params.get("moduleId", None)
node_class = request.query_params.get("nodeClass", None)
fill_detail = request.query_params.get("fillDetail", None)
extra_classes = request.data.get("extraClasses", [])
try:
service = ModelManagerService(request)
result = service.searchNodes(text, module_id, node_class,
extra_classes, fill_detail)
response = NodeSearchResultSerializer(result, many=True)
return Response(response.data)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("text", required=True, description="Text to search")
]))
def searchForAutocomplete(request, *args, **kargs):
text = str(request.query_params.get("text", ""))
try:
service = ModelManagerService(request)
result = service.searchForAutocomplete(text)
response = NodeSearchResultSerializer(result, many=True)
return Response(response.data)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("node",
required=True,
description="Node to evaluate and get preview")
]))
def previewNode(request, *args, **kargs):
node = str(request.data.get("node", ""))
if node:
service = ModelManagerService(request)
result = service.previewNode(node)
return Response(result)
raise exceptions.NotAcceptable("Node not found")
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field(
"values", required=True, description="Node properties")
]))
def setNodesSize(request, *args, **kargs):
serializer = NodesSizeAndPositionSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
result = service.setNodesSize(serializer.validated_data["values"])
if result:
return Response(status=status.HTTP_200_OK)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field(
"values", required=True, description="Node properties")
]))
def setNodesPosition(request, *args, **kargs):
serializer = NodesSizeAndPositionSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
result = service.setNodesPosition(
serializer.validated_data["values"])
if result:
return Response(status=status.HTTP_200_OK)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("nodeId",
required=False,
location="query",
description="Node ID")
]))
def getNodeProfile(request, *args, **kargs):
node_id = request.query_params.get("nodeId", None)
service = ModelManagerService(request)
result = service.getNodeProfile(node_id)
if result:
return Response(result)
return Response(status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("node",
required=True,
location="query",
description="Node Object")
]))
def createNode(request, *args, **kargs):
serializer = NodeSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
service = ModelManagerService(request)
result = service.createNode(serializer.create(serializer.data))
if result:
return Response(result)
return Response(status=status.HTTP_400_BAD_REQUEST)
@staticmethod
@api_view(['DELETE'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field(
"values", required=True, description="Array of nodes ids")
]))
def deleteNodes(request, *args, **kargs):
serializer = NodeIdentifierSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
service = ModelManagerService(request)
try:
result = service.deleteNodes(serializer.data["values"])
if result:
return Response(result)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field(
"values", required=True, description="Array of nodes ids")
]))
def createAlias(request, *args, **kargs):
serializer = NodeIdentifierSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
service = ModelManagerService(request)
try:
result = service.createAlias(serializer.data["values"])
if result:
res = []
if len(result) > 0:
for nodeId in result:
res.append({"id": nodeId})
# TODO: fillNodeProperties ? is comented in .net
return Response(res)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field(
"values", required=True, description="Array of nodes ids")
]))
def createInputNode(request, *args, **kargs):
serializer = NodeIdentifierSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
service = ModelManagerService(request)
try:
result = service.createInputNode(serializer.data["values"])
if result:
res = []
if len(result) > 0:
for nodeId in result:
res.append({"id": nodeId})
return Response(res)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
# TODO: Implement createOutputNode
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("values",
required=True,
location="query",
description="Array of Node Objects")
]))
def copyNodes(request, *args, **kargs):
if request.data is not None:
if "values" in request.data:
if len(request.data["values"]) > 0:
nodes = []
for node in request.data["values"]:
nodes.append(Node(**node))
service = ModelManagerService(request)
try:
result = service.copyNodes(nodes)
if result:
return Response(result)
else:
raise exceptions.NotAcceptable(
"Error on copy nodes")
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("nodeId",
required=True,
location="query",
description="Id of the node to be copied"),
coreapi.Field(
"asNewNode",
required=True,
location="query",
description="(True/False) if the node is copied as a new node")
]))
def copyAsValues(request, *args, **kargs):
serializer = CopyAsValuesParamSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
result = service.copyAsValues(
serializer.create(serializer.validated_data))
if result:
return Response(status=status.HTTP_200_OK)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("values",
required=True,
location="query",
description="Array of Node Objects")
]))
def moveNodes(request, *args, **kargs):
if request.data is not None:
if "values" in request.data:
if len(request.data["values"]) > 0:
nodes = []
for node in request.data["values"]:
nodes.append(Node(**node))
service = ModelManagerService(request)
try:
result = service.moveNodes(nodes)
if result:
return Response(result)
else:
raise exceptions.NotAcceptable(
"Error on move nodes")
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
def stop(request, *args, **kargs):
try:
service = ModelManagerService(request)
result = service.stop()
if result:
return Response(status=status.HTTP_200_OK)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("values",
required=True,
location="query",
description="Array of Node Objects")
]))
def setNodeZ(request, *args, **kargs):
if request.data is not None:
if "values" in request.data:
if len(request.data["values"]) > 0:
nodes = []
for node in request.data["values"]:
nodes.append(Node(**node))
service = ModelManagerService(request)
try:
result = service.setNodeZ(nodes)
if result:
return Response(status=status.HTTP_200_OK)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("value",
required=True,
location="query",
description="Node Id")
]))
def setNodeIdFromTitle(request, *args, **kargs):
if request.data is not None:
if "value" in request.data:
if len(request.data["value"]) > 0:
node_id = request.data["value"]
service = ModelManagerService(request)
try:
result = service.setNodeIdFromTitle(node_id)
if result:
return Response(result)
else:
raise exceptions.NotAcceptable(
"Error on setting the node id from the title")
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
def executeForRefresh(request, *args, **kargs):
try:
service = ModelManagerService(request)
if service.executeForRefresh():
return Response(status=status.HTTP_200_OK)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("nodeId",
required=True,
location="query",
description="Node Id"),
coreapi.Field("fileFormat",
required=True,
location="query",
description="(csv or xls)"),
coreapi.Field(
"numberFormat",
required=True,
location="query",
description="The format of the decimal point, etc ..."),
coreapi.Field(
"columnFormat",
required=True,
location="query",
description="(tab,;,...) The format of the columns separator"),
coreapi.Field(
"compressed",
required=True,
location="query",
description=
"(1/0) If the file needs to be compressed, if true then returns a file with the fileformat compressed on a .zip file"
),
coreapi.Field("nodeQuery",
required=True,
location="query",
description="The query for the node")
]))
def exportFlatNode(request, *args, **kargs):
serializer = ExportNodeSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
file_stream, file_name = service.exportFlatNode(
serializer.create(serializer.validated_data))
response = FileResponse(file_stream,
as_attachment=True,
filename=file_name)
# content disposition to retrieve filename in the ui
response['Access-Control-Allow-Headers'] = 'Content-Disposition'
response['Access-Control-Expose-Headers'] = 'Content-Disposition'
return response
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("nodeId",
required=True,
location="query",
description="Node Id"),
coreapi.Field("fileFormat",
required=True,
location="query",
description="(csv or xls)"),
coreapi.Field(
"numberFormat",
required=True,
location="query",
description="The format of the decimal point, etc ..."),
coreapi.Field(
"columnFormat",
required=True,
location="query",
description="(tab,;,...) The format of the columns separator"),
coreapi.Field(
"compressed",
required=True,
location="query",
description=
"(1/0) If the file needs to be compressed, if true then returns a file with the fileformat compressed on a .zip file"
),
coreapi.Field("nodeQuery",
required=True,
location="query",
description="The query for the node")
]))
def exportCurrentNode(request, *args, **kargs):
"""
Reminder: Pyplan Excel Addin uses this endpoint.
"""
serializer = ExportNodeSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
dashboardManagerService = DashboardManagerService(request)
objectExport = serializer.create(serializer.validated_data)
file_stream, file_name = service.exportCurrentNode(
objectExport, dashboardManagerService)
response = FileResponse(file_stream,
as_attachment=True,
filename=file_name)
# content disposition to retrieve filename in the ui
response['Access-Control-Allow-Headers'] = 'Content-Disposition'
response['Access-Control-Expose-Headers'] = 'Content-Disposition'
return response
except Exception as ex:
raise exceptions.NotAcceptable(ex)
# TODO: Método exportEntireNode en visual no esta siendo usado por la UI.
# tiene un comentario en visual que dice implementar tal cual ADE
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("moduleId",
required=True,
location="query",
description="Module Id"),
coreapi.Field(
"exportType",
required=True,
location="query",
description=
"(1/2) If 1 exports to the tmp folder, 2 exports to the current module folder"
)
]))
def exportModuleToFile(request, *args, **kargs):
serializer = ExportModuleToFileSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
file_stream, file_name = service.exportModuleToFile(
serializer.create(serializer.validated_data))
response = FileResponse(file_stream,
as_attachment=True,
filename=file_name)
# content disposition to retrieve filename in the ui
response['Access-Control-Allow-Headers'] = 'Content-Disposition'
response['Access-Control-Expose-Headers'] = 'Content-Disposition'
return response
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("ImportModuleData",
required=True,
location="query",
description="Object")
]))
def importModuleFromFile(request, *args, **kargs):
"""
Imports a module from a file
"""
serializer = ImportModuleDataSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
res = ImportModuleDataSerializer(
service.importModuleFromFile(
serializer.create(serializer.validated_data)))
return Response(res.data)
except Exception as ex:
raise exceptions.NotAcceptable(ex)
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("extension",
required=False,
description="extension of the looked files")
]))
@schema(AutoSchema(manual_fields=[]))
def getFilesForImportWizard(request, *args, **kargs):
"""
Get files for use in import wizard
"""
extension = str(request.query_params.get("extension", None))
if extension:
try:
service = ModelManagerService(request)
res = FileEntrySerializer(
service.getFilesForImportWizard(extension),
many=True,
context={'client_session': service.client_session})
return Response(res.data)
except Exception as ex:
raise exceptions.NotAcceptable(
f"There was an error trying to getFilesForImportWizard: {str(ex)}"
)
else:
raise exceptions.NotAcceptable(
"There was no file extension provided")
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field(
"params", required=False, description="Wizard Request Object")
]))
def callWizard(request, *args, **kargs):
serializer = WizardRequestSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
return Response(service.callWizard(request.data))
except Exception as ex:
raise exceptions.NotAcceptable(
f"Error when trying to callWizard: {str(ex)}")
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("nodeId",
required=False,
description="Id of the node to be excecuted")
]))
def executeButton(request, *args, **kargs):
serializer = NodeIdSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
if service.executeButton(serializer.validated_data['nodeId']):
return Response(status=status.HTTP_200_OK)
return Response(status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
raise exceptions.NotAcceptable(
f"Error in executeButton: {str(ex)}")
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("nodeId",
required=False,
description="Id of the node to be evaluated")
]))
def isInBackground(request, *args, **kargs):
try:
node_id = request.query_params.get("nodeId", None)
service = ModelManagerService(request)
return Response(service.isInBackground(node_id))
except Exception as ex:
raise exceptions.NotAcceptable(
f"Error in isInBackground: {str(ex)}")
# helper functions
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field("file", required=False, description="File Object")
]))
@parser_classes((
parsers.MultiPartParser,
parsers.FormParser,
))
def uploadFileToTemp(request, *args, **kargs):
"""
uploads single file to temp
"""
serializer = UploadFilesSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
try:
service = ModelManagerService(request)
res = service.uploadFile(serializer.data.get("action"),
request.FILES["files"],
serializer.data.get("folder_path"),
serializer.data.get("name"),
serializer.data.get("chunk"))
return Response(res)
except Exception as ex:
raise exceptions.NotFound(
f"There was an error when trying to upload the file: {str(ex)}"
)
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field(
"node",
required=True,
description="Node to evaluate and get selector definition")
]))
def getSelector(request, *args, **kargs):
node = str(request.data.get("node", ""))
if node:
service = ModelManagerService(request)
result = service.getSelector(node)
return Response(result)
raise exceptions.NotAcceptable("Node not found")
@staticmethod
@api_view(['POST'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field('lib',
required=True,
location='form',
type='string',
description='Library to install'),
]))
def installLibrary(request, *args, **kargs):
"""Install python library"""
try:
_lib = request.data.get('lib')
service = ModelManagerService(request)
return Response(service.installLibrary(_lib))
except Exception as ex:
raise exceptions.NotAcceptable(
f"Error in installLibrary: {str(ex)}")
@staticmethod
@api_view(['GET'])
@permission_classes((permissions.IsAuthenticated, ))
@schema(
AutoSchema(manual_fields=[
coreapi.Field('from_line',
required=True,
location='form',
type='string',
description='Get install progress from this line')
]))
def getInstallProgress(request, *args, **kargs):
"""Get current install progress"""
try:
from_line = request.query_params.get("from_line", None)
service = ModelManagerService(request)
return Response(service.getInstallProgress(from_line))
except Exception as ex:
raise exceptions.NotAcceptable(
f"Error in getInstallProgress: {str(ex)}")
class GovernmentIndicatorView(APIView):
"""
Return indicator scores for a particular government
"""
schema = AutoSchema(manual_fields=[
coreapi.Field(
'govid',
required=True,
location='path',
schema=coreschema.String(
description='Unique identifier for gorvernment'
)
),
coreapi.Field(
'subgroup',
required=False,
location='query',
schema=coreschema.String(
description='Indicators are placed in certain '\
'grouings, the ids of these groups can be found in '\
'/api/v1/groupings'
)
),
coreapi.Field(
'indicator',
required=False,
location='query',
schema=coreschema.String(
description='List of unique indicator ids'
)
),
coreapi.Field(
'year',
required=False,
location='query',
schema=coreschema.String(
description='full year eg: 2015'
)
)
])
def get(self, request, govid, format=None):
subgroup = request.query_params.get('subgroup', None)
indicators = request.query_params.get('indicator', None)
year = request.query_params.get('year', None)
if not year:
year_latest = Govindicator\
.objects\
.aggregate(latest_year=Max('yearid'))
year = Yearref.objects.get(yearid=year_latest['latest_year']).yr
if indicators:
indi = indicators.split(',')
query = Govindicator.objects.filter(
govid=govid, yearid__yr=year,
iid__parentgid__in=indi).select_related(
'iid', 'iid__parentgid')
elif subgroup:
query = Govindicator\
.objects\
.only('value', 'iid__name', 'iid__parentgid__name',
'iid__short_name')\
.filter(
govid=govid,
yearid__yr=year,
iid__parentgid__parentgid=subgroup,
)\
.select_related('iid', 'iid__parentgid')
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
serialize = serializers.IndicatorValueSerializer(
query, context={'request': request}, many=True)
return Response({'results': serialize.data, 'year': year})
def schema_view(request):
print("---inside schema view-----")
schema = coreapi.Document(
title='Price aggregator',
url='34.92.149.102',
description=
'User can get the latest second hand product information in this website, the search engine is a meta search engine. user can also record down the product data. the search api and recent product is opened for public.',
content={
#search the second product
"SearchingAPI": {
'search':
coreapi.Link(
url='/find_my_product/Search/',
action='get',
fields=[
coreapi.Field(
name='Keyword',
required=True,
location='query',
description=
'Input the keyword to search the second-hand product',
),
coreapi.Field(
name='seach_type',
location='query',
description=
'Input the Product type of what second-hand product you want to search'
),
coreapi.Field(
name='minarea',
location='query',
description=
'Input the minimum of Product price of what second-hand product you want to search'
),
coreapi.Field(
name='maxarea',
location='query',
description=
'Input the maximum of Product price of what second-hand product you want to search'
),
],
description=
'Return the searching resuit of second-hand from different selling website API'
)
},
#operation about user
"UserAPI": {
'login':
coreapi.Link(
url='/user/login/',
action='post',
fields=[
coreapi.Field(name='email',
required=True,
location='form',
description='login with email'),
coreapi.Field(
name='password',
required=True,
location='form',
description=
"The Password which match the user's email"),
],
encoding="multipart/form-data",
description=
'Return Login success if the email and password is match.'
),
'logout':
coreapi.Link(
url='/user/logout/',
action='post',
description=
'Logout the existance account without any Parameters'),
'DeleteAccount':
coreapi.Link(
url='/api/user/',
action='delete',
description=
'Delete your account of existance login with using delete request without any Parameters'
),
'GetUserInfo':
coreapi.Link(
url='/api/user/',
action='get',
description=
'Get your account infomation of existance login without any Parameters '
),
'SignUP':
coreapi.Link(
url='/api/user/',
action='post',
fields=[
coreapi.Field(name='first_name',
location='form',
description='Input first name'),
coreapi.Field(name='last_name',
location='form',
description="Input last name"),
coreapi.Field(name='email',
required=True,
location='form',
description="Input the email"),
coreapi.Field(
name='password1',
required=True,
location='form',
description=
"Input the first password , it may match the second password"
),
coreapi.Field(
name='password2',
required=True,
location='form',
description=
"Input the second password , it may match the first password"
),
],
encoding="multipart/form-data",
description=
'Return signup success if the signup information no any mistake.'
),
'UserUpdate':
coreapi.Link(
url='/api/user/',
action='PUT',
fields=[
coreapi.Field(
name='first_name',
location='form',
description='Input the updated first name'),
coreapi.Field(
name='last_name',
location='form',
description="Input the updated last name"),
coreapi.Field(
name='existing_pw',
required=True,
location='form',
description=
"Input the existance password for validation"),
coreapi.Field(name='password1',
required=True,
location='form',
description="Input the new password "),
coreapi.Field(
name='password2',
required=True,
location='form',
description=
"Input the new password again, two new password must be matched"
),
],
encoding="multipart/form-data",
description=
'Return user information update success if the all information no any mistake.'
),
},
#operation about user
"RecentProductAPI": {
'InsertRecentProduct':
coreapi.Link(
url='/api/product/',
action='post',
description=
'no any parameters. The Api will create a table for insert recent product list from selling website, user can use get request to get a list of recent product, and use put request to update the recent product '
),
'GetRecentProduct':
coreapi.Link(
url='/api/product/',
action='get',
description=
'no any parameters. it return all latest recent product data from database, moreover, it will return the recent product table is null if you are not create the recent product table with using post request'
),
'UpdateRecentProduct':
coreapi.Link(
url='/api/product/',
action='put',
description=
'no any parameters. it return recent product table update success, when user want to get the latest recent product data, you should using the put request first for update the data'
)
},
#operation about user's Favourite product
"UserFavouriteProductAPI": {
'InsertUserFavouriteProduct':
coreapi.Link(
url='/api/Favourite/',
action='post',
fields=[
coreapi.Field(
name='price',
required=True,
location='form',
description=
"insert the price of favourtite product to the database."
),
coreapi.Field(
name='name',
required=True,
location='form',
description=
"insert the name of favourtite product to the database."
),
coreapi.Field(
name='link',
required=True,
location='form',
description=
"insert the selling link of favourtite product to the database."
)
],
encoding="multipart/form-data",
description='User can record down his favourtite product '
),
'DeleteUserFavouriteProduct':
coreapi.Link(
url='/api/Favourite/',
action='delete',
fields=[
coreapi.Field(
name='ProductID',
required=True,
location='form',
description=
"according the ID of the User Favourite Product in the databas to delete the record"
),
],
encoding="multipart/form-data",
description='User can record down his favourtite product '
),
'GetAllUserFavouriteProduct':
coreapi.Link(
url='/api/Favourite/',
action='get',
description=
"Get the existance login user's favourtite product ")
}
})
print(dir(schema))
# schema = generator.get_schema(request)
return response.Response(schema)
def schema_view(request):
schema = coreapi.Document(
title='Zementis Modeler',
url='http://localhost:8000',
content={
'Model': {
'listOfModels':
coreapi.Link(url='/api/v1/models',
action='get',
description='Get the list of loaded models.'),
'loadModel':
coreapi.Link(
url='/api/v1/models',
action='post',
fields=[
coreapi.Field(
name='filePath',
required=True,
location='formData',
description='Path of the model (PMML) to be loaded.'
)
],
description='Loads a model into memory for scoring data.'),
'unloadModel':
coreapi.Link(
url='/api/v1/models/{modelName}',
action='delete',
fields=[
coreapi.Field(
name='modelName',
required=True,
location='path',
description='Name of the model to be unloaded.')
],
description='Unloads a model from memory.'),
'scoreMultipleData':
coreapi.Link(
url='/api/v1/models/{modelName}/score',
action='post',
fields=[
coreapi.Field(
name='modelName',
required=True,
location='path',
description=
'Name of the loaded model to be used for scoring.'
),
coreapi.Field(
name='filePath',
required=False,
location='formData',
description='Path of the data file to be predicted.'
)
],
description='Prediction of multiple record data.'),
'scoreSingleData':
coreapi.Link(
url='/api/v1/models/{modelName}/score',
action='get',
fields=[
coreapi.Field(
name='modelName',
required=True,
location='path',
description=
'Name of the loaded model to be used for scoring.'
),
coreapi.Field(
name='jsonRecord',
required=False,
location='query',
description=
'The record in json format.\nExample: {"sepal_length":5,"sepal_width":4,"petal_length":4,"petal_width":5}'
)
],
description='Prediction of single record data.')
},
'PMML': {
'getDetailsOfPMML':
coreapi.Link(url='/api/v1/pmml',
action='get',
fields=[
coreapi.Field(
name='filePath',
required=True,
location='query',
description='The path of the PMML')
],
description='Returns the details of a PMML'),
'getGlobal':
coreapi.Link(
url='/api/v1/pmml/getGlobal/memory',
action='get',
description=
'Returns all available models (PMMLs) in JSON format.'),
'addArchitechToGlobalMemory':
coreapi.Link(
url='/api/v1/pmml/{projectID}',
action='post',
fields=[
coreapi.Field(
name='projectID',
required=True,
location='path',
description=
'Create an unique project Id for that PMML.'),
coreapi.Field(name='filePath',
required=True,
location='formData',
description='Path of the PMML file.')
],
description='Adds the PMML to the global memory as JSON.'),
'addOrUpdateLayer':
coreapi.Link(
url='/api/v1/pmml/{projectID}/layer',
action='put',
fields=[
coreapi.Field(
name='projectID',
required=True,
location='path',
description='Project id for the PMML model.'),
coreapi.Field(
name='layerToUpdate',
required=True,
location='body',
description=
'The JSON payload of the layer/section/template to be added/update.'
)
],
description=
'For Modifying a DeepNetwork PMML. Adds or updates a layer/section/template.'
),
'deleteLayer':
coreapi.Link(
url='/api/v1/pmml/{projectID}/layer',
action='delete',
fields=[
coreapi.Field(
name='projectID',
required=True,
location='path',
description='Project id for the PMML model.'),
coreapi.Field(
name='layerDelete',
required=True,
location='body',
description=
'The JSON payload of the layer/section to be deleted.'
)
],
description='Deletes a layer/section from the PMML model.')
},
'Running Tasks': {
'runningTasksList':
coreapi.Link(url='/api/v1/runningTasks',
action='get',
description='Get a list of running tasks.'),
'statusOfModel':
coreapi.Link(url='/api/v1/runningTasks/{id_for_task}',
action='get',
fields=[
coreapi.Field(name='id_for_task',
required=True,
location='path',
description='Id for the task.')
],
description='Get the status of a running task.'),
'deleteTask':
coreapi.Link(
url='/api/v1/runningTasks/{id_for_task}',
action='delete',
fields=[
coreapi.Field(name='id_for_task',
required=True,
location='path',
description='Id for the task')
],
description='Removes a task from the running tasks list.')
},
'Train Model': {
'autoMLsendData':
coreapi.Link(
url='/api/v1/trainAutoMLModel',
action='get',
fields=[
coreapi.Field(
name='filePath',
required=True,
location='query',
description='Path of the data file to be uploaded')
],
description='Uploads data for AutoML.'),
'trainAutoML':
coreapi.Link(
url='/api/v1/trainAutoMLModel',
action='post',
fields=[
coreapi.Field(
name='payload',
required=True,
location='body',
description=
'Payload for training of AutoML. (Pass the JSON payload)'
)
],
description=
'For a given dataset, generates a model using AutoML.'),
'trainNNModel':
coreapi.Link(
url='/api/v1/trainNNModel',
action='post',
fields=[
coreapi.Field(
name='payload',
required=True,
location='body',
description=
'Payload for training of DeepNetwork Model. (Pass the JSON payload)'
)
],
description='Trains a DeepNetwork model.')
},
'Utility': {
'downloadFile':
coreapi.Link(
url='/api/v1/downloadFile',
action='get',
fields=[
coreapi.Field(
name='filePath',
required=True,
location='query',
description='Path of the file to be downloaded.')
],
description='Downloads a file.'),
'listOfLayers':
coreapi.Link(
url='/api/v1/listOfLayers',
action='get',
description=
'Returns a list of layers and architectures supported by Zementis Modeler.'
)
}
})
# schema = generator.get_schema(request)
return response.Response(schema)
