예제 #1
0
 def put(self, request, pk, format=None):
     client = self.get_object(pk)
     serializer = ClientSerializer(client, data=request.data)
     if serializer.is_valid():
         serializer.save()
         return Response(serializer.data)
     return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
예제 #2
0
 def put(self, request, pk, format=None):
     client = self.get_object(pk)
     serializer = ClientSerializer(client, data=request.data)
     if serializer.is_valid():
         serializer.save()
         return Response(serializer.data)
     return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
예제 #3
0
def add_client(request):
    if request.method == 'POST':
        client_data = JSONParser().parse(request)
        client_serializer = ClientSerializer(data=client_data)
        if client_serializer.is_valid():
            # Generate query
            cursor = connection.cursor()
            query = 'INSERT INTO clients_client('
            data_spc_query = ''
            data_query = []
            attrbs_table = list(client_data.keys())
            for a in attrbs_table:
                if a != attrbs_table[-1]:
                    query += a + ', '
                    data_spc_query += '%s, '
                else:
                    query += a + ') VALUES('
                    data_spc_query += '%s);'
                if a != 'password':
                    data_query.append(client_data.get(a))
                else:
                    pwd = make_password(client_data.get(a))
                    data_query.append(pwd)
            query += data_spc_query
            print(query)
            cursor.execute(query, tuple(data_query))
            connection.commit()
            return JsonResponse({
                "code": 201,
                "message": "Client Added"
            },
                                status=status.HTTP_201_CREATED)
        return JsonResponse(client_serializer.errors,
                            status=status.HTTP_400_BAD_REQUEST)
def client_detail(request, facebook_id):
    """
    Retrieve, update or delete a code client.
    """
    try:
        client = Client.objects.get(facebook_id=facebook_id)
    except Client.DoesNotExist:
        return HttpResponse(status=404)

    if request.method == 'GET':
        serializer = ClientSerializer(client)
        log('client_detail', 'detail', 'detail user %s' % facebook_id)
        return JSONResponse(serializer.data)

    elif request.method == 'PUT':
        data = JSONParser().parse(request)
        serializer = ClientSerializer(client, data=data)
        if serializer.is_valid():
            serializer.save()
            return JSONResponse(serializer.data)
        return JSONResponse(serializer.errors, status=400)

    elif request.method == 'DELETE':
        client.delete()
        log('client', 'delete', 'delete client %s' % facebook_id)
        return HttpResponse(status=204)
예제 #5
0
파일: views.py 프로젝트: luxu/codenation
 def post(self, request, format=None):
     client = ClientSerializer(data=request.data)
     if client.is_valid():
         client = client.save()
         return Response(data={
             'client_id': client.client_id,
         },
                         status=status.HTTP_201_CREATED)
     return Response(client.errors, status=status.HTTP_400_BAD_REQUEST)
예제 #6
0
    def get(self, request, pk):

        response = {}

        policy = (
            Policy.objects.filter(pk=pk)
            .prefetch_related(
                "workstation_clients",
                "workstation_sites",
                "server_clients",
                "server_sites",
            )
            .first()
        )

        response["default_server_policy"] = policy.is_default_server_policy
        response["default_workstation_policy"] = policy.is_default_workstation_policy

        response["server_clients"] = ClientSerializer(
            policy.server_clients.all(), many=True
        ).data
        response["workstation_clients"] = ClientSerializer(
            policy.workstation_clients.all(), many=True
        ).data

        filtered_server_sites = list()
        filtered_workstation_sites = list()

        for client in policy.server_clients.all():
            for site in client.sites.all():
                if site not in policy.server_sites.all():
                    filtered_server_sites.append(site)

        response["server_sites"] = SiteSerializer(
            filtered_server_sites + list(policy.server_sites.all()), many=True
        ).data

        for client in policy.workstation_clients.all():
            for site in client.sites.all():
                if site not in policy.workstation_sites.all():
                    filtered_workstation_sites.append(site)

        response["workstation_sites"] = SiteSerializer(
            filtered_workstation_sites + list(policy.workstation_sites.all()), many=True
        ).data

        response["agents"] = AgentHostnameSerializer(
            policy.related_agents().only("pk", "hostname"),
            many=True,
        ).data

        return Response(response)
예제 #7
0
파일: views.py 프로젝트: AsMaNick/Animals
def client_detail(request, pk):
    """
    Retrieve, update or delete a client.
    """
    try:
        client = Client.objects.get(pk=pk)
    except Client.DoesNotExist:
        return HttpResponse(status=404)

    if request.method == 'GET':
        serializer = ClientSerializerWithoutPassword(client)
        return JsonResponse(serializer.data)

    elif request.method == 'PATCH':
        data = request.data.copy()
        if 'lat' not in data:
            data['lat'] = None
        if 'lng' not in data:
            data['lng'] = None
        serializer = ClientSerializer(client, data=data, partial=True)
        if serializer.is_valid():
            serializer.save()
            return JsonResponse(serializer.data, status=201)
        return JsonResponse(serializer.errors, status=200)

    elif request.method == 'DELETE':
        client.delete()
        return HttpResponse(status=204)
예제 #8
0
class DocumentDetailSerializer(DocumentSerializer):
    from clients.serializers import ClientSerializer
    from projects.serializers import ProjectSerializer
    author = CRMUserTinySerializer(read_only=True)
    client = ClientSerializer()
    project = ProjectSerializer()
    task = ProjectTaskSerializer()
예제 #9
0
class AgentEditSerializer(serializers.ModelSerializer):
    winupdatepolicy = WinUpdatePolicySerializer(many=True, read_only=True)
    all_timezones = serializers.SerializerMethodField()
    client = ClientSerializer(read_only=True)
    custom_fields = AgentCustomFieldSerializer(many=True, read_only=True)

    def get_all_timezones(self, obj):
        return pytz.all_timezones

    class Meta:
        model = Agent
        fields = [
            "id",
            "hostname",
            "client",
            "site",
            "monitoring_type",
            "description",
            "time_zone",
            "timezone",
            "check_interval",
            "overdue_time",
            "offline_time",
            "overdue_text_alert",
            "overdue_email_alert",
            "all_timezones",
            "winupdatepolicy",
            "policy",
            "custom_fields",
        ]
예제 #10
0
    def get(self, request, pk):

        response = {}

        policy = (Policy.objects.filter(pk=pk).prefetch_related(
            "clients", "sites").first())

        response["clients"] = ClientSerializer(policy.clients.all(),
                                               many=True).data

        filtered_sites = list()

        for client in policy.clients.all():
            for site in client.sites.all():
                if site not in policy.sites.all():
                    filtered_sites.append(site)

        response["sites"] = TreeSerializer(filtered_sites +
                                           list(policy.sites.all()),
                                           many=True).data

        response["agents"] = AgentHostnameSerializer(policy.related_agents(),
                                                     many=True).data

        return Response(response)
예제 #11
0
class ContractSerializer(serializers.ModelSerializer):
    employee = EmployeeSerializer(read_only=True)
    client = ClientSerializer(read_only=True)
    car = CarSerializer(read_only=True)
    payment_type_name = serializers.CharField(source='payment_type.name',
                                              read_only=True)

    class Meta:
        model = Contract
        fields = [
            'id', 'employee', 'client', 'car', 'date', 'payment_type',
            'payment_type_name', 'price'
        ]

    def create(self, validated_data):
        employee = get_object_or_404(Employee.objects.all(),
                                     pk=self.context.get('employee_id'))
        car = get_object_or_404(Car.objects.all(),
                                pk=self.context.get('car_id'))
        payment_type = get_object_or_404(
            PaymentType.objects.all(), pk=self.context.get('payment_type_id'))
        client = get_object_or_404(Client.objects.all(),
                                   pk=self.context.get('client_id'))

        contract = Contract.objects.create(price=validated_data.get('price'),
                                           car=car,
                                           employee=employee,
                                           payment_type=payment_type,
                                           client=client)

        return contract
예제 #12
0
 def list(self, request, *args, **kwargs):
     queryset = Client.objects.filter(specialists=request.user)
     serializer = ClientSerializer(queryset,
                                   many=True,
                                   context={'request': request})
     if request.user in User.objects.filter(groups__name='Specialists'):
         return Response(serializer.data)
     return super().list(request, *args, **kwargs)
예제 #13
0
class AlertTemplateRelationSerializer(ModelSerializer):
    policies = PolicySerializer(read_only=True, many=True)
    clients = ClientSerializer(read_only=True, many=True)
    sites = SiteSerializer(read_only=True, many=True)

    class Meta:
        model = AlertTemplate
        fields = "__all__"
예제 #14
0
파일: serializers.py 프로젝트: justBboy/crm
class ProjectSerializer(ModelSerializer):
    """
    serializes and deserializes projects to be sent over the network or saved in the database 
    """
    client = ClientSerializer()

    class Meta:
        model = Project
        fields = ['title', 'client', 'start_date', 'end_date', 'status']
    def _handle_put(self, request, *args, **kwargs):
        """
        PUT/PATCH handler for Client Detail

        Sample Post Data:
        {
            "name": "Detroit City Apartments"
        }
        """
        client = self.get_object(kwargs.get('pk'))

        serializer = ClientSerializer(client, data=request.DATA)

        if serializer.is_valid():
            serializer.save()

            return serializer.data

        return self.raise_bad_request(serializer.errors)
예제 #16
0
class PolicyTableSerializer(ModelSerializer):

    server_clients = ClientSerializer(many=True, read_only=True)
    server_sites = SiteSerializer(many=True, read_only=True)
    workstation_clients = ClientSerializer(many=True, read_only=True)
    workstation_sites = SiteSerializer(many=True, read_only=True)
    agents = AgentHostnameSerializer(many=True, read_only=True)
    default_server_policy = ReadOnlyField(source="is_default_server_policy")
    default_workstation_policy = ReadOnlyField(source="is_default_workstation_policy")
    agents_count = SerializerMethodField(read_only=True)
    winupdatepolicy = WinUpdatePolicySerializer(many=True, read_only=True)

    class Meta:
        model = Policy
        fields = "__all__"
        depth = 1

    def get_agents_count(self, policy):
        return policy.related_agents().count()
예제 #17
0
class ProjectTeamClientSerializer(ProjectSerializer):
    team = TeamUserSerializer()
    client = ClientSerializer()
    has_tasks = serializers.SerializerMethodField()
    is_finished = serializers.SerializerMethodField()
    tasks_budget = serializers.SerializerMethodField()

    def get_has_tasks(self, obj):
        return obj.has_tasks()

    def get_is_finished(self, obj):
        return obj.is_finished()

    def get_tasks_budget(self, obj):
        return obj.tasks_budget()
예제 #18
0
파일: views.py 프로젝트: AsMaNick/Animals
def client_list(request):
    """
    List all clients, or create a new client.
    """
    if request.method == 'GET':
        clients = Client.objects.all()
        serializer = ClientSerializerWithoutPassword(clients, many=True)
        return JsonResponse(serializer.data, safe=False)

    elif request.method == 'POST':
        data = JSONParser().parse(request)
        if 'password_hash' in data:
            data['password_hash'] = calc_hash(data['password_hash'])
        serializer = ClientSerializer(data=data)
        if serializer.is_valid():
            serializer.save()
            return JsonResponse(serializer.data, status=201)
        return JsonResponse(serializer.errors, status=200)
    def post(request):
        # Comprovem que l'usuari no sigui manager
        if request.data["is_manager"]:
            return Response("A client can not be manager",
                            status=status.HTTP_400_BAD_REQUEST)

        # Creem l'usuari
        user = RegisterSerializer(data=request.data)
        user.is_valid(raise_exception=True)
        user.save()

        # Creem el client amb l'id i l'username de l'usuari
        client = {
            "_id": user.data["id"],
            "username": user.data["username"],
            "age": request.data.get('age', None),
            "country": request.data.get('country', None)
        }

        serializer = ClientSerializer(data=client)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(data=serializer.data, status=status.HTTP_201_CREATED)
예제 #20
0
파일: views.py 프로젝트: luxu/codenation
class ClientApi(APIView):
    @swagger_auto_schema(
        security=[],
        operation_description='Retrive all existing clients',
        operation_id='GET /clients',
        manual_parameters=[
            openapi.Parameter(name='page',
                              in_=openapi.IN_QUERY,
                              default=1,
                              type=openapi.TYPE_INTEGER,
                              description='Page number'),
            openapi.Parameter(name='page_size',
                              in_=openapi.IN_QUERY,
                              default=50,
                              type=openapi.TYPE_INTEGER,
                              description='Number of page elements'),
        ],
        responses={
            status.HTTP_200_OK:
            openapi.Response(description='Clients list',
                             examples={
                                 'application/json': {
                                     'count':
                                     openapi.TYPE_INTEGER,
                                     'next':
                                     openapi.TYPE_STRING,
                                     'previous':
                                     openapi.TYPE_STRING,
                                     'results': [{
                                         'client_id': openapi.FORMAT_UUID,
                                         'name': openapi.TYPE_STRING,
                                         'cpf': openapi.TYPE_STRING,
                                     }]
                                 }
                             })
        },
    )
    def get(self, request, format=None):
        paginator = api_settings.DEFAULT_PAGINATION_CLASS()
        return paginator.get_paginated_response(
            queryset=Client.objects.all(),
            request=request,
            serializer=ClientDetailSerializer,
            serializer_kwargs={'fields': (
                'client_id',
                'name',
                'cpf',
            )})

    @swagger_auto_schema(
        request_body=ClientSerializer(),
        security=[],
        operation_description='Create a client',
        operation_id='POST /clients',
        responses={
            status.HTTP_201_CREATED:
            openapi.Response(description='Client has been created',
                             examples={
                                 'application/json': {
                                     'client_id': openapi.FORMAT_UUID
                                 }
                             }),
            status.HTTP_400_BAD_REQUEST:
            openapi.Response(description='Fields are invalid',
                             examples={
                                 'application/json_required': [{
                                     'field':
                                     'This field is required'
                                 }],
                                 'application/json_wrong': [{
                                     'field':
                                     'Reason of the error'
                                 }]
                             })
        })
    def post(self, request, format=None):
        client = ClientSerializer(data=request.data)
        if client.is_valid():
            client = client.save()
            return Response(data={
                'client_id': client.client_id,
            },
                            status=status.HTTP_201_CREATED)
        return Response(client.errors, status=status.HTTP_400_BAD_REQUEST)
    def get(self, request, *args, **kwargs):
        username = self.kwargs['username']
        serializer = ClientSerializer(
            Clients.objects.filter(username=username), many=True)

        return Response(data=serializer.data, status=status.HTTP_200_OK)
예제 #22
0
 def get(self, request, pk, format=None):
     client = self.get_object(pk)
     serializer = ClientSerializer(client)
     return Response(serializer.data)
예제 #23
0
 def post(self, request, format=None):
     serializer = ClientSerializer(data=request.data)
     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)
예제 #24
0
 def post(self, request, format=None):
     serializer = ClientSerializer(data=request.data)
     if serializer.is_valid():
         serializer.save()
         return Response(serializer.data, status=201)
     return Response(serializer.errors, status=400)
 def get(request):
     serializer = ClientSerializer(Clients.objects.all(), many=True)
     return Response(data=serializer.data, status=status.HTTP_200_OK)
예제 #26
0
 def list(self):
     queryset = Client.objects.all()
     serializer = ClientSerializer(queryset, many=True)
     return Response(serializer.data)
예제 #27
0
 def get(self, request, format=None):
     clients = Client.objects.all()
     serializer = ClientSerializer(clients, many=True)
     return Response(serializer.data)