예제 #1
0
class UnmappedDetailed(APIView):
    """
    Retrieve a single "unmapped" entry, includes related entries.
    """

    schema = ManualSchema(
        description=
        "Retrieve a single unmapped entry, includes related entries.",
        fields=[
            coreapi.Field(
                name="id",
                required=True,
                location="path",
                schema=coreschema.Integer(),
                description=
                "A unique integer value identifying the mapping view id"),
        ])

    def get(self, request, mapping_view_id):
        try:
            mapping_view = MappingView.objects.get(pk=mapping_view_id)
        except MappingView.DoesNotExist:
            raise Http404

        # this is supposed to be called for an unmapped entry
        if (mapping_view.uniprot_mapping_status == 'mapped'
                and mapping_view.mapping_id is not None):
            return Response(
                {
                    "error":
                    "Entry is mapped with id {}".format(
                        mapping_view.mapping_id)
                },
                status=status.HTTP_400_BAD_REQUEST)

        email_recipients_list = {
            recipient_id: recipient_details.get('name')
            for (recipient_id,
                 recipient_details) in settings.EMAIL_RECIPIENT_LIST.items()
        }

        data = {
            'entry':
            mapping_view,
            'relatedEntries':
            list(
                MappingView.objects.filter(
                    grouping_id=mapping_view.grouping_id).exclude(
                        pk=mapping_view_id)),
            'emailRecipientsList':
            email_recipients_list
        }

        serializer = UnmappedEntrySerializer(data)

        serializer.data['entry']['status'] = MappingView.status_description(
            serializer.data['entry']['status'])

        return Response(serializer.data)
예제 #2
0
class RoomView(APIView):
    CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    schema = AutoSchema(manual_fields=[
        coreapi.Field(name='room_id',
                      required=True,
                      location='path',
                      schema=coreschema.Integer(
                          description='Identifier of the room')),
    ])

    @staticmethod
    def _map_number_to_char(number):
        if number - 1 >= len(RoomView.CHARS):
            return None
        else:
            return RoomView.CHARS[number - 1]

    @staticmethod
    def _transform_row(row):
        previous_seat = [0, 0]
        result = []
        for seat, column in zip(row, range(1, len(row) + 1)):
            result += [None for _ in range(seat[1] - previous_seat[1] - 1)]
            result.append({'col': column, 'seat': seat})
            previous_seat = seat
        return result

    @staticmethod
    def _transform_layout(rows, raw_layout):
        layout = []
        empty = 0
        for current_row in range(1, rows + 1):
            row = [i for i in raw_layout if i[0] == current_row]
            if len(row):
                layout.append({
                    'row':
                    RoomView._map_number_to_char(current_row - empty),
                    'seats':
                    RoomView._transform_row(row)
                })
            else:
                layout.append(None)
                empty += 1
        return layout

    def get(self, request, room_id, format=None):
        """
            Returns details of the room for given showing
        """
        try:
            room = Room.objects.get(pk=room_id)
            serializer = RoomSerializer(room)
            layout = self._transform_layout(serializer.data['rows'],
                                            serializer.data['layout'])
            data = serializer.data
            data['layout'] = layout
            return Response(data)
        except ObjectDoesNotExist:
            raise Http404
예제 #3
0
 def setUp(self):
     self.field = coreapi.Field(
         name='page',
         required=True,
         location='query',
         schema=coreschema.Integer(description='A page number.'))
     self.swagger = _get_parameters(coreapi.Link(fields=[self.field]),
                                    encoding='')
예제 #4
0
class ShowingListView(APIView):
    schema = AutoSchema(manual_fields=[
        coreapi.Field(name='date',
                      required=True,
                      location='path',
                      schema=coreschema.String(
                          description='Date in format YYYY-MM-DD')),
        coreapi.Field(name='cinema_id',
                      required=True,
                      location='path',
                      schema=coreschema.Integer(
                          description='Identifier of the cinema')),
        coreapi.Field(name='movie_id',
                      required=True,
                      location='path',
                      schema=coreschema.Integer(
                          description='Identifier of the movie')),
    ])

    def get(self, request, movie_id, date, cinema_id, format=None):
        """
            Returns list of all showings for given movie id and given day
        """
        datetime_date = datetime.strptime(date, '%Y-%m-%d').date()
        if datetime_date < datetime.now().date():
            return Response([])
        elif datetime_date == datetime.now().date():
            showing = Showing.objects \
                .prefetch_related() \
                .filter(room__cinema__id=cinema_id,
                        movie__id=movie_id,
                        date=date,
                        hour__gt=datetime.now() + timedelta(minutes=15)) \
                .all() \
                .order_by('hour')
        else:
            showing = Showing.objects \
                .prefetch_related() \
                .filter(room__cinema__id=cinema_id,
                        movie__id=movie_id,
                        date=date) \
                .all() \
                .order_by('hour')
        serializer = ShowingSerializer(showing, many=True)
        return Response(serializer.data)
예제 #5
0
    def get_schema_fields(self, view):
        fields = [
            coreapi.Field(
                name="place",
                description="show meals in specified place",
                required=False,
                location='query',
                schema=coreschema.Integer()
            ),
            coreapi.Field(
                name="ingredients",
                description="show meals with specified ingredients",
                required=False,
                location='query',
                schema=coreschema.Integer()
            )]

        return fields
예제 #6
0
    def get_schema_fields(self, view):
        fields = [
            coreapi.Field(
                name="meal",
                description="show ingredients in specified meal",
                required=False,
                location='query',
                schema=coreschema.Integer()
            ),
            coreapi.Field(
                name="calories",
                description="show ingredients with specified number of calories",
                required=False,
                location='query',
                schema=coreschema.Integer()
            )]

        return fields
예제 #7
0
    def get_link(self, path, method, base_url):
        link = super().get_link(path, method, base_url)

        if method == 'POST':
            fields = [
                coreapi.Field(
                    "file[]",
                    required=False,
                    location="form",
                    schema=coreschema.String(title='file[]',
                                             description='A multipart list of files to upload.')
                ),
                coreapi.Field(
                    "course",
                    required=False,
                    location="form",
                    schema=coreschema.Integer(title='course',
                                              description=Attachment._meta.get_field('course').help_text)
                ),
                coreapi.Field(
                    "event",
                    required=False,
                    location="form",
                    schema=coreschema.Integer(title='event',
                                              description=Attachment._meta.get_field('event').help_text)
                ),
                coreapi.Field(
                    "homework",
                    required=False,
                    location="form",
                    schema=coreschema.Integer(title='homework',
                                              description=Attachment._meta.get_field('homework').help_text)
                )
            ]

            return coreapi.Link(
                url=link.url,
                action=link.action,
                encoding=link.encoding,
                fields=fields,
                description=link.description
            )

        return link
예제 #8
0
 def get_schema_fields(self, view):
     return (Field(
         name='near_trek',
         required=False,
         location='query',
         schema=coreschema.Integer(
             title=_("Near trek"),
             description=
             _("Id of a trek. It will show only the touristics contents related to this trek"
               ))), )
예제 #9
0
 def get_schema_fields(self, view):
     return (
         Field(name='type',
               required=False,
               location='query',
               schema=coreschema.Integer(
                   title=_("Type"),
                   description=_(
                       "Limit to POIs that contains a specific POI Type"))),
         Field(
             name='trek',
             required=False,
             location='query',
             schema=coreschema.Integer(
                 title=_("Trek"),
                 description=
                 _("Id of a trek. It will show only the POIs related to this trek"
                   ))),
     )
예제 #10
0
 def get_schema_fields(self, view):
     return [
         coreapi.Field(
             name='month',
             required=False,
             schema=coreschema.Integer(
                 description='The reference month number [1-12]'),
             location='query',
             type=int,
         ),
         coreapi.Field(
             name='year',
             required=False,
             schema=coreschema.Integer(
                 description='The reference year number (eg 2018)'),
             location='query',
             type=int,
         ),
     ]
예제 #11
0
def _annotated_type_to_coreschema(
        annotated_type: type) -> coreschema.schemas.Schema:
    if annotated_type is bool or issubclass(annotated_type, schema.Boolean):
        return coreschema.Boolean()
    elif annotated_type is int or issubclass(annotated_type, schema.Integer):
        return coreschema.Integer()
    elif annotated_type is float or issubclass(annotated_type, schema.Number):
        return coreschema.Number()

    return coreschema.String()
예제 #12
0
    def get_serializer_fields(self, path, method):
        fields = []
        if method == 'POST':
            fields = [
                coreapi.Field(
                    name="user_id",
                    required=True,
                    location="form",
                    schema=coreschema.Integer(title="user_id",
                                              description="Id пользователя"),
                    description='user_id'
                ),
                coreapi.Field(
                    name="group_id",
                    required=True,
                    location="form",
                    schema=coreschema.Integer(title="group_id",
                                              description="Id группы"),
                    description='group_id'
                ),
                coreapi.Field(
                    name="role",
                    required=True,
                    location="form",
                    schema=coreschema.String(title="role",
                                             description="Роль"),
                    description='Значение ADM или USR',
                ),
            ]
        if method == 'PUT':
            fields = [
                coreapi.Field(
                    name="role",
                    required=True,
                    location="form",
                    schema=coreschema.String(title="role",
                                             description="Роль"),
                    description='Значение ADM или USR',
                ),
            ]

        return fields
예제 #13
0
 def get_manual_fields(self, path, method):
     if method == 'PUT':
         return [
             coreapi.Field('default_client_id',
                           required=True,
                           location='form',
                           schema=coreschema.Integer(
                               description='Default client ID')),
         ]
     elif method == 'GET':
         return []
예제 #14
0
    def get_serializer_fields(self, path, method):
        fields = []
        if method == 'POST':
            fields = [
                coreapi.Field(name="group_id",
                              required=True,
                              location="form",
                              schema=coreschema.Integer(
                                  title="group", description="Id группы"),
                              description='group_id'),
                coreapi.Field(
                    name="title",
                    required=True,
                    location="form",
                    schema=coreschema.String(title="title",
                                             description="Название задачи"),
                    description='Название задачи',
                ),
                coreapi.Field(
                    name="user",
                    required=True,
                    location="form",
                    schema=coreschema.Array(title="user",
                                            description="Юзеры в задаче"),
                    description='Юзеры в задаче',
                ),
            ]
        if method == 'PUT':
            fields = [
                coreapi.Field(name="done",
                              required=True,
                              location="form",
                              schema=coreschema.Boolean(
                                  title="done", description="Завершено"),
                              description='Завершено'),
                coreapi.Field(
                    name="title",
                    required=True,
                    location="form",
                    schema=coreschema.String(title="title",
                                             description="Название задачи"),
                    description='Название задачи',
                ),
                coreapi.Field(
                    name="user",
                    required=True,
                    location="form",
                    schema=coreschema.Array(title="user",
                                            description="Юзеры в задаче"),
                    description='Юзеры в задаче',
                ),
            ]

        return fields
예제 #15
0
 def get_manual_fields(self, path, method):
     if method == 'GET':
         return [
             coreapi.Field(
                 'client_id',
                 required=True,
                 location='path',
                 schema=coreschema.Integer(description='Client ID')),
         ]
     else:
         return []
예제 #16
0
def get_param_schema(annotated_type: typing.Type) -> coreschema.schemas.Schema:
    if issubclass(annotated_type, (bool, typesystem.Boolean)):
        return coreschema.Boolean()
    elif issubclass(annotated_type, int):
        return coreschema.Integer()
    elif issubclass(annotated_type, float):
        return coreschema.Number()
    elif issubclass(annotated_type, typesystem.Enum):
        enum = typing.cast(typing.Type[typesystem.Enum], annotated_type)
        return coreschema.Enum(enum=enum.enum)
    return coreschema.String()
예제 #17
0
def test_ref_space():
    schema = coreschema.RefSpace(refs={
        'PositiveInteger':
        coreschema.Integer(minimum=1),
        'Root':
        coreschema.Ref('PositiveInteger') | coreschema.String()
    },
                                 root='Root')

    assert schema.validate(1) == []
    assert schema.validate('abc') == []
    assert schema.validate(0) == [('Must match one of the options.', [])]
예제 #18
0
class TriggerCasePlan(APIView):
    """
    【触发case测试计划】
    """
    Schema = AutoSchema(manual_fields=[
        coreapi.Field(name="projectId",
                      required=True,
                      location="form",
                      schema=coreschema.Integer(description='项目id')),
        coreapi.Field(name="testPlanId",
                      required=True,
                      location="form",
                      schema=coreschema.String(description='接口测试计划uid')),
    ])
    schema = Schema
    authentication_classes = (JSONWebTokenAuthentication, )
    permission_classes = (permissions.IsAuthenticated, )

    def post(self, request):
        receive_data = request.data
        testplan_id = receive_data.get('testPlanId', None)
        project_id = receive_data.get('projectId', None)
        if not all([testplan_id, project_id]):
            return Response({"error": "缺少必要的参数"},
                            status=status.HTTP_400_BAD_REQUEST)
        case_test_plan = CaseTestPlanModel.objects.filter(
            project_id=project_id, plan_id=testplan_id).first()
        if not case_test_plan:
            return Response(
                {"error": "testplan {} not found".format(testplan_id)},
                status=status.HTTP_404_NOT_FOUND)
        case_paths = case_test_plan.case_paths
        case_test_plan_task = CaseTestPlanTaskModel.objects.create(
            test_plan_uid=testplan_id,
            state=CaseTestPlanTaskState.WAITING,
            case_job_number=len(case_paths),
            finish_num=0)
        CaseRunner.distributor(case_test_plan_task)

        # 根据是否并行执行case选择不用的触发器
        if case_test_plan.parallel:
            '''并行执行'''
            case_jobs_id = CaseJobModel.objects.filter(
                case_task_id=case_test_plan_task.id).values_list('id',
                                                                 flat=True)
            for case_job_id in case_jobs_id:
                case_test_job_executor.delay(case_job_id, project_id,
                                             case_test_plan.plan_id,
                                             case_test_plan_task.id)
        else:
            '''串行执行'''
            case_test_task_executor.delay(case_test_plan_task.id)
        return Response({"success": True, "data": "测试用例计划已经成功触发"})
예제 #19
0
    def get_serializer_fields(self, path, method):

        extra_fields = []

        if method == 'PUT':
            extra_fields = [
                coreapi.Field(name='password',
                              required=False,
                              location='form',
                              schema=coreschema.String(
                                  description="New password",
                                  title='password',
                              )),
                coreapi.Field(
                    name='position',
                    required=False,
                    location='form',
                    type=coreschema.Integer,
                    schema=coreschema.Integer(
                        description=
                        "Device outlet position. Mandatory for changing outlet name, remove user or outlet status. Must be an integer. Only admins can remove user from outlet",
                        title="position")),
                coreapi.Field(
                    name='name',
                    required=False,
                    location='form',
                    schema=coreschema.String(
                        description=
                        "Change the outlet name in the position provided",
                        title='name')),
                coreapi.Field(
                    name='status',
                    required=False,
                    location='form',
                    type=coreschema.String,
                    schema=coreschema.String(
                        description=
                        "Turn on or off the remote server connected to the outlet position provided. Values accepted: \'on\' or \'off\'",
                        title='status')),
                coreapi.Field(
                    name='rempos',
                    required=False,
                    location='form',
                    schema=coreschema.Boolean(
                        description=
                        "Remove user from position. Only for admins. Values accepted: True or False (False by default)",
                        title='rempos',
                    )),
            ]

        manual_fields = super(CustomUserRestSchema,
                              self).get_serializer_fields(path, method)
        return manual_fields + extra_fields
예제 #20
0
class SpeciesHistoryAlignmentStatus(APIView):
    """
    Update a species history's alignment status
    """

    permission_classes = (IsAuthenticated,)
    schema = ManualSchema(
        description="Update a species history's alignment status",
        fields=[
            coreapi.Field(
                name="id",
                required=True,
                location="path",
                schema=coreschema.Integer(),
                description="A unique integer value identifying the species history"
            ),
            coreapi.Field(
                name="status",
                required=True,
                location="path",
                schema=coreschema.Integer(),
                description="String representing the updated alignment status"
            ),
        ])

    def post(self, request, pk, status):
        try:
            history = EnsemblSpeciesHistory.objects.get(pk=pk)
        except EnsemblSpeciesHistory.DoesNotExist:
            return Response(
                {"error": "Could not find species history {}".format(pk)},
                status=status.HTTP_400_BAD_REQUEST
            )
        else:
            history.alignment_status = status
            history.save()

        serializer = SpeciesHistorySerializer(history)

        return Response(serializer.data)
예제 #21
0
 def get_serializer_fields(self, path, method):
     fields = []
     if method == 'POST':
         fields = [
             coreapi.Field(name='target',
                           required=False,
                           location="form",
                           schema=coreschema.Integer(title='target',
                                                     default=None,
                                                     description='target'),
                           description='target'),
         ]
     return fields
예제 #22
0
class ApiJobViewSet(viewsets.ModelViewSet):
    Schema = AutoSchema(manual_fields=[
        coreapi.Field(name="task_id", required=False, location="query",
                      schema=coreschema.Integer(description='api task id'), ),
    ])
    schema = Schema
    authentication_classes = (JSONWebTokenAuthentication,)
    pagination_class = pagination.LimitOffsetPagination
    serializer_class = InterfaceJobSerializer
    permission_classes = (permissions.IsAuthenticated,)

    def get_queryset(self):
        return InterfaceJobModel.objects.filter(api_test_plan_task_id=self.request.GET.get('task_id'))
예제 #23
0
def test_ref():
    child = coreschema.Object(properties={
        'a': coreschema.String(),
        'b': coreschema.Integer()
    })
    schema = coreschema.Ref('Child')
    context = {'refs': {'Child': child}}

    assert schema.validate({'a': 'abc', 'b': 123}, context) == []
    assert schema.validate({
        'a': 'abc',
        'b': 'abc'
    }, context) == [('Must be an integer.', ['b'])]
예제 #24
0
파일: apischema.py 프로젝트: webee/apistar
def _annotated_type_to_coreschema(
        annotated_type: type) -> coreschema.schemas.Schema:
    if annotated_type is bool or issubclass(annotated_type, schema.Boolean):
        return coreschema.Boolean()
    elif annotated_type is int or issubclass(annotated_type, schema.Integer):
        return coreschema.Integer()
    elif annotated_type is float or issubclass(annotated_type, schema.Number):
        return coreschema.Number()
    elif issubclass(annotated_type, schema.Enum):
        enum = cast(Type[schema.Enum], annotated_type)
        return coreschema.Enum(enum=enum.enum)

    return coreschema.String()
예제 #25
0
def get_param_schema(annotated_type: typing.Type) -> coreschema.schemas.Schema:
    schema_kwargs = {'description': getattr(annotated_type, 'description', '')}

    if issubclass(annotated_type, (bool, typesystem.Boolean)):
        return coreschema.Boolean(**schema_kwargs)
    elif issubclass(annotated_type, int):
        return coreschema.Integer(**schema_kwargs)
    elif issubclass(annotated_type, float):
        return coreschema.Number(**schema_kwargs)
    elif issubclass(annotated_type, typesystem.Enum):
        enum = typing.cast(typing.Type[typesystem.Enum], annotated_type)
        return coreschema.Enum(enum=enum.enum, **schema_kwargs)
    return coreschema.String(**schema_kwargs)
예제 #26
0
class InvestorNetworkView(APIView):
    """
    Get investor network.
    Used within charts section.
    """
    schema = ManualSchema(fields=[
        coreapi.Field(
            "operational_stakeholder",
            required=True,
            location="query",
            description="Operating company ID",
            schema=coreschema.Integer(),
        ),
    ])

    def get_object(self):
        '''
        Returns an investor object.
        '''
        try:
            investor_id = int(
                self.request.query_params['operational_stakeholder'])
        except KeyError:
            raise serializers.ValidationError(
                {'operational_stakeholder': _("This field is required.")})
        except ValueError:
            raise serializers.ValidationError(
                {'operational_stakeholder': _("An integer is required.")})

        investor = get_object_or_404(HistoricalInvestor, pk=investor_id)
        if not self.request.user.is_authenticated:
            if investor.fk_status_id not in (InvestorBase.STATUS_ACTIVE,
                                             InvestorBase.STATUS_OVERWRITTEN):
                raise Http404("Investor is not public")
        self.check_object_permissions(self.request, investor)

        return investor

    def get(self, request, format=None):
        # TODO: determine what operational_stakeholder_diagram does here -
        # it seems to just be passed back in the response.
        operational_stakeholder = self.get_object()
        serialized_response = HistoricalInvestorNetworkSerializer(
            operational_stakeholder, user=request.user)
        #parent_type=request.query_params.get('parent_type', 'parent_stakeholders'))

        response_data = serialized_response.data.copy()
        #response_data['index'] = investor_diagram

        return Response(response_data)
예제 #27
0
class InterfaceViewSet(viewsets.ModelViewSet):
    Schema = AutoSchema(manual_fields=[
        coreapi.Field(
            name="projectId",
            required=False,
            location="query",
            schema=coreschema.Integer(description='项目id'),
        )
    ])
    schema = Schema
    authentication_classes = (JSONWebTokenAuthentication, )
    permission_classes = (permissions.IsAuthenticated, )
    serializer_class = InterfaceSerializer
    pagination_class = pagination.LimitOffsetPagination

    def get_queryset(self):
        if self.request.GET.get('projectId'):
            return InterfaceModel.objects.filter(
                project=self.request.GET.get('projectId')).order_by("-id")
        else:
            return InterfaceModel.objects.all().order_by("-id")

    def list(self, request, *args, **kwargs):
        """
        【获取接口列表】
        """
        interfaces = self.get_queryset()
        if not all([request.GET.get('limit'), request.GET.get('offset')]):
            serializer = self.get_serializer(interfaces, many=True)
            return Response({
                "count": len(interfaces),
                "results": serializer.data
            })
        page = self.paginate_queryset(interfaces)
        serializer = self.get_serializer(page, many=True)
        return self.get_paginated_response(serializer.data)

    def create(self, request, *args, **kwargs):
        """
        【创建接口】
        """
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data)

    def destroy(self, request, *args, **kwargs):
        instance = InterfaceModel.objects.get(id=kwargs.get('pk'))
        self.perform_destroy(instance)
        return Response(status=status.HTTP_204_NO_CONTENT)
예제 #28
0
    def get_serializer_fields(self, path, method):
        fields = []
        if method == 'POST':
            fields = [
                coreapi.Field(name='contact_user_id',
                              required=True,
                              location="form",
                              schema=coreschema.Integer(
                                  title='contact_user_id',
                                  description='contact_user_id'),
                              description='ID контакта'),
            ]

        return fields
예제 #29
0
class MappingDetailed(APIView):
    """
    Retrieve a single mapping, includes related mappings/unmapped entries and taxonomy information.
    """

    schema = ManualSchema(
        description=(
            "Retrieve a single mapping, includes related mappings/unmapped "
            "entries and taxonomy information."),
        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)

        authenticated = False
        if request.user and request.user.is_authenticated:
            authenticated = True

        email_recipients_list = {
            recipient_id: recipient_details.get('name')
            for (recipient_id,
                 recipient_details) in settings.EMAIL_RECIPIENT_LIST.items()
        }

        data = {
            'taxonomy':
            build_taxonomy_data(mapping),
            'mapping':
            MappingsSerializer.build_mapping(mapping,
                                             fetch_sequence=True,
                                             authenticated=authenticated),
            'relatedEntries': {
                'mapped': build_related_mappings_data(mapping),
                'unmapped': build_related_unmapped_entries_data(mapping)
            },
            'emailRecipientsList':
            email_recipients_list
        }

        serializer = MappingSerializer(data)

        return Response(serializer.data)
예제 #30
0
    def __init__(self, manual_fields=None):
        if manual_fields is None:
            manual_fields = []

        manual_fields += [
            coreapi.Field("course_group",
                          required=True,
                          location="path",
                          schema=coreschema.Integer(
                              title='id',
                              description=Course._meta.get_field(
                                  'course_group').help_text)),
        ]

        super().__init__(manual_fields=manual_fields)