def get_user(request): if request.method == 'GET': return SuccessResponse( UserSerializer(request.user).data, status.HTTP_200_OK) elif request.method == 'PUT': user = request.user user_serializer = UserSerializer(user, data=request.data, partial=True) user_serializer.is_valid(raise_exception=True) user_serializer.save() return SuccessResponse(user_serializer.data, status.HTTP_200_OK)
def products_list(request): if request.method == 'POST': serializer = ProductSerializer(data=request.data) serializer.is_valid(raise_exception=True) serializer.save() return SuccessResponse(serializer.data, status.HTTP_201_CREATED) paginator = CountHeaderPagination() paginator.page_size_query_param = 'page_size' products_query = Product.objects.all() page = paginator.paginate_queryset(products_query, request) data = ProductSerializer(page, many=True).data return SuccessResponse(paginator.get_paginated_response(data).data, status.HTTP_200_OK)
def crud_account(request, account_id): try: account = Account.objects.get(pk=account_id) except ObjectDoesNotExist: return ErrorResponse('Нет такого филиала', status.HTTP_400_BAD_REQUEST) if request.method == 'GET': return SuccessResponse(AccountSerializer(account).data, status.HTTP_200_OK) elif request.method == 'DELETE': account.delete() return SuccessResponse(status=status.HTTP_204_NO_CONTENT) else: serializer = AccountSerializer(account, data=request.data, partial=True) serializer.is_valid(raise_exception=True) serializer.save() return SuccessResponse(serializer.data, status.HTTP_200_OK)
def crud_product(request, product_id): try: product = Product.objects.get(pk=product_id) except ObjectDoesNotExist: return ErrorResponse('Нет такого инструмента', status.HTTP_400_BAD_REQUEST) if request.method == 'GET': return SuccessResponse(ProductSerializer(product).data, status.HTTP_200_OK) elif request.method == 'DELETE': product.delete() return SuccessResponse(status=status.HTTP_204_NO_CONTENT) else: serializer = ProductSerializer(product, data=request.data, partial=True) serializer.is_valid(raise_exception=True) serializer.save() return SuccessResponse(serializer.data, status.HTTP_200_OK)
def crud_user(request, user_id): try: user = User.objects.get(pk=user_id) except ObjectDoesNotExist: return ErrorResponse('Нет такого пользователя', status.HTTP_400_BAD_REQUEST) if request.method == 'GET': return SuccessResponse(UserSerializer(user).data, status.HTTP_200_OK) elif request.method == 'DELETE': user.delete() return SuccessResponse(status=status.HTTP_204_NO_CONTENT) else: user_serializer = UserSerializer(user, data=request.data, partial=True) user_serializer.is_valid(raise_exception=True) user_serializer.save() return SuccessResponse(user_serializer.data, status.HTTP_200_OK)
def show_product(request, product_id): try: product = Product.objects.get(pk=product_id) except ObjectDoesNotExist: return ErrorResponse(NO_SUCH_PRODUCT, status.HTTP_404_NOT_FOUND) if request.method == 'GET': return SuccessResponse( ProductSerializer(product).data, status.HTTP_200_OK) elif request.method == 'PUT': product_serializer = ProductSerializer(product, data=request.data, partial=True) product_serializer.is_valid(raise_exception=True) product_serializer.save() return SuccessResponse(product_serializer.data, status.HTTP_200_OK)
def get_addresses(request, address_id): try: address = Address.objects.get(pk=address_id) except ObjectDoesNotExist: return ErrorResponse(INCORRECT_ID_PATTERN.format('Адрес', address_id), status.HTTP_404_NOT_FOUND) return SuccessResponse(AddressSerializer(address).data, status.HTTP_200_OK)
def show_products(request): """ Получение инструментов """ if request.method == 'GET': current_account = request.user.account responsible_filter_serializer = ResponsibleFilter( data=request.query_params) responsible_filter_serializer.is_valid(raise_exception=True) type_filter_serializer = TypeProductFilter(data=request.query_params) type_filter_serializer.is_valid(raise_exception=True) type_filter = type_filter_serializer.validated_data['type_filter'] show_own_products = responsible_filter_serializer.validated_data[ 'show_own'] paginator = CountHeaderPagination() paginator.page_size_query_param = 'page_size' products_query = [] if show_own_products is None: products_query = Product.objects.filter( type_filter=type_filter ) if type_filter != '' else Product.objects.all() elif show_own_products is False: products_query = Product.objects.exclude(responsible=current_account).filter(type_filter=type_filter) \ if type_filter != '' else Product.objects.exclude(responsible=current_account) elif show_own_products is True: products_query = Product.objects.filter(responsible=current_account, type_filter=type_filter) \ if type_filter != '' else Product.objects.filter(responsible=current_account) page = paginator.paginate_queryset(products_query, request) data = ProductSerializer(page, many=True).data return SuccessResponse( paginator.get_paginated_response(data).data, status.HTTP_200_OK)
def get_filters(request): """ Получение всех доступных типов инструментов """ arr = Product.objects.only('type_filter').distinct('type_filter') filtered_arr = map(lambda prod: prod.type_filter, arr) return SuccessResponse(filtered_arr, status.HTTP_200_OK)
def show_products_for_invoice(request): user = request.user current_account = user.account responsible_filter_serializer = ResponsibleFilter( data=request.query_params) responsible_filter_serializer.is_valid(raise_exception=True) type_filter_serializer = TypeProductFilter(data=request.query_params) type_filter_serializer.is_valid(raise_exception=True) type_filter = type_filter_serializer.validated_data['type_filter'] show_own_products = responsible_filter_serializer.validated_data[ 'show_own'] paginator = CountHeaderPagination() paginator.page_size_query_param = 'page_size' products_query = [] if show_own_products is None: products_query = Product.objects.filter(on_transition=False, type_filter=type_filter) if type_filter != '' \ else Product.objects.filter(on_transition=False) elif show_own_products is False: products_query = Product.objects.exclude(responsible=current_account)\ .filter(on_transition=False, type_filter=type_filter) if type_filter != '' \ else Product.objects.exclude(responsible=current_account)\ .filter(on_transition=False) elif show_own_products is True: products_query = Product.objects.filter(responsible=current_account, on_transition=False, type_filter=type_filter) if type_filter != ''\ else Product.objects.filter(on_transition=False, responsible=current_account) page = paginator.paginate_queryset(products_query, request) data = ProductSerializer(page, many=True).data return SuccessResponse( paginator.get_paginated_response(data).data, status.HTTP_200_OK)
def all_accounts(request): user = request.user current_account = user.account if current_account: accounts = Account.objects.all().exclude(pk=current_account.id) else: accounts = Account.objects.all() return SuccessResponse( AccountSerializer(accounts, many=True).data, status.HTTP_200_OK)
def add_to_account(request): user = request.user current_account = user.account if not user.is_admin: return ErrorResponse(NO_PERMISSION, status.HTTP_403_FORBIDDEN) import_serializer = ImportUserSerializer(data=request.data) import_serializer.is_valid(raise_exception=True) added = current_account.add_user(import_serializer.validated_data['email']) return SuccessResponse({'status': added}, status.HTTP_200_OK)
def single_account(request, pk): if request.method == 'GET': try: pk_account = Account.objects.get(pk=pk) except ObjectDoesNotExist: return ErrorResponse(INCORRECT_ID_PATTERN.format('Филиал', pk), status.HTTP_404_NOT_FOUND) return SuccessResponse( AccountSerializer(pk_account).data, status.HTTP_200_OK)
def update_invoice(request, invoice_id): user = request.user try: invoice = Invoice.objects.get(pk=invoice_id) except ObjectDoesNotExist: return ErrorResponse(INCORRECT_ID_PATTERN.format('Заявка', invoice_id), status.HTTP_404_NOT_FOUND) if request.method == 'GET': return SuccessResponse( InvoiceSerializer(invoice).data, status.HTTP_200_OK) invoice_serializer = InvoiceSerializer(invoice, data=request.data, partial=True) invoice_serializer.is_valid(raise_exception=True) new_status = invoice_serializer.validated_data['status'] track_id = invoice_serializer.validated_data.get('track_id', invoice.track_id) if track_id is None and new_status == 1 and new_status != 3: return ErrorResponse("Нужно указать номер трэкинга", status.HTTP_400_BAD_REQUEST) if new_status - invoice.status != 1 and new_status != 3: return ErrorResponse(INVOICE_UPDATE_ERROR, status.HTTP_400_BAD_REQUEST) if new_status == 2: to_update = [] for product in invoice.invoice_lines.all(): product.responsible = invoice.to_account product.responsible_text = invoice.to_account.get_admin_name() product.location_update = timezone.now() product.on_transition = False to_update.append(product) bulk_update(to_update, update_fields=[ 'responsible', 'responsible_text', 'location_update', 'on_transition' ]) elif new_status == 3: to_update = [] for product in invoice.invoice_lines.all(): product.on_transition = False to_update.append(product) bulk_update(to_update, update_fields=['on_transition']) invoice_serializer.save() InvoiceChanges.objects.create(invoice=invoice, status=new_status) return SuccessResponse(invoice_serializer.data, status.HTTP_200_OK)
def get_inner_filters(request): """ Получение всех доступных типов инструментов """ serializer = TypeProductFilter(data=request.query_params) serializer.is_valid(raise_exception=True) type_filter = serializer.validated_data['type_filter'] arr = Product.objects.only('type_filter', 'inner_type_filter').filter( type_filter=type_filter).distinct('inner_type_filter') filtered_arr = map(lambda prod: prod.inner_type_filter, arr) return SuccessResponse(filtered_arr, status.HTTP_200_OK)
def change_password(request): user = request.user password_serializer = PasswordSerializer(data=request.data) if not password_serializer.is_valid(): return ErrorResponse(password_serializer.errors_to_text, status.HTTP_400_BAD_REQUEST) password = password_serializer.validated_data['password'] user.password = make_password(password) user.token = to_base64(user.email, password) user.save() return SuccessResponse(UserSerializer(user).data, status.HTTP_200_OK)
def check_invoice(request): user = request.user invoice_serializer = CheckInvoiceSerializer(data=request.data) invoice_serializer.is_valid(raise_exception=True) if not invoice_serializer.validated_data['invoice_type'] in TYPES: ErrorResponse(INCORRECT_INVOICE_TYPE, status.HTTP_400_BAD_REQUEST) filtered_products = list( filter(lambda prod: not prod.responsible == user.account, invoice_serializer.validated_data['products'])) invoice_type = invoice_serializer.validated_data['invoice_type'] if len(filtered_products) == len( invoice_serializer.validated_data['products']): account_ids = list( set( map(lambda prod: prod.responsible.id, invoice_serializer.validated_data['products']))) if invoice_type == 0: return SuccessResponse( { 'status': 'ok', 'invoice_type': 0, 'from_account': account_ids, 'to_account': request.user.account.id }, status.HTTP_200_OK) else: return ErrorResponse(INCORRECT_INVOICE_TYPE, status.HTTP_400_BAD_REQUEST) elif len(filtered_products) == 0: if invoice_type in [1, 2]: return SuccessResponse( { 'status': 'ok', 'invoice_type': invoice_type, "from_account": [request.user.account.id] }, status.HTTP_200_OK) else: return ErrorResponse(INCORRECT_INVOICE_TYPE, status.HTTP_400_BAD_REQUEST) else: return ErrorResponse(INCORRECT_INVOICE_PRODUCTS, status.HTTP_404_NOT_FOUND)
def login_user(request): serializer = LoginUserSerializer(data=request.data) serializer.is_valid(raise_exception=True) email = serializer.validated_data['email'] password = serializer.validated_data['password'] existed_user = User.objects.filter(email=email).first() if existed_user: if check_password(password, existed_user.password): return SuccessResponse( UserSerializer(existed_user).data, status.HTTP_201_CREATED) else: return ErrorResponse(INVALID_AUTH, status.HTTP_400_BAD_REQUEST) else: return ErrorResponse(INVALID_AUTH, status.HTTP_400_BAD_REQUEST)
def account(request): user = request.user current_account = user.account if request.method == 'GET': return SuccessResponse( AccountSerializer(current_account).data, status.HTTP_200_OK) if request.method == 'PUT': if not user.is_admin: return ErrorResponse(NO_PERMISSION, status.HTTP_403_FORBIDDEN) if current_account.address is not None: address_serializer = AddressSerializer(current_account.address, data=request.data, partial=True) else: address_serializer = AddressSerializer(data=request.data) address_serializer.is_valid(raise_exception=True) address = address_serializer.save() current_account.address = address account_serializer = AccountSerializer(current_account, data=request.data, partial=True) account_serializer.is_valid(raise_exception=True) account_serializer.save() return SuccessResponse(account_serializer.data, status.HTTP_200_OK)
def get_invoices(request): user = request.user current_account = user.account status_serializer = StatusFilterSerializer(data=request.query_params) status_serializer.is_valid(raise_exception=True) status_filter = status_serializer.validated_data['status'] or [0, 1] paginator = CountHeaderPagination() paginator.page_size_query_param = 'page_size' if current_account.is_admin: invoices = Invoice.objects.filter( status__in=status_filter).order_by('-id') else: invoices = Invoice.objects.filter( Q(status__in=status_filter, to_account=current_account) | Q(from_account=current_account, status__in=status_filter) ).order_by('-id') page = paginator.paginate_queryset(invoices, request) data = InvoiceSerializer(page, many=True).data return SuccessResponse( paginator.get_paginated_response(data).data, status.HTTP_200_OK)
def create_user(request): serializer = CreateUserSerializer(data=request.data) if not serializer.is_valid(): return ErrorResponse(serializer.errors_to_text, status.HTTP_400_BAD_REQUEST) email = serializer.validated_data['email'] password = serializer.validated_data['password'] name = serializer.validated_data['name'] token = to_base64(email, password) cash_account = AccountEmailCash.objects.filter(email=email).first() account = cash_account.account if cash_account is not None else None if User.objects.filter(email=email).first(): return ErrorResponse(ALREADY_EXIST_USER, status.HTTP_400_BAD_REQUEST) else: user = User.objects.create(email=email, name=name, password=make_password(password), token=token, account=account) return SuccessResponse( UserSerializer(user).data, status.HTTP_201_CREATED)
def import_document(request): serializer = XLSXImport(data=request.data) serializer.is_valid(raise_exception=True) doc = serializer.validated_data['document'] excel_document = openpyxl.load_workbook(doc) admin_account = Account.objects.filter(is_admin=True).first() to_create = [] for type_filter in excel_document.get_sheet_names(): current_sheet = excel_document.get_sheet_by_name(type_filter) inner_type_filter = '' rows_tuple = tuple(current_sheet.rows) if not valid_sheet(rows_tuple[0]): continue for row in rows_tuple[1:]: res = build_product_or_type_filter(row, type_filter, inner_type_filter, admin_account) if res[0] == INPUT_TYPE: inner_type_filter = res[1] elif res[0] == PRODUCT: to_create.append(res[1]) Product.objects.bulk_create(to_create) return SuccessResponse(status=status.HTTP_204_NO_CONTENT)
def account_list(request): return SuccessResponse(AccountSerializer(Account.objects.all(), many=True).data, status.HTTP_200_OK)
def user_list(request): users = User.objects.all().exclude(pk=request.user.id) return SuccessResponse(UserSerializer(users, many=True).data, status.HTTP_200_OK)
def create_invoice(request): user = request.user current_account = user.account invoice_serializer = CreateInvoiceSerializer(data=request.data) invoice_serializer.is_valid(raise_exception=True) if not invoice_serializer.validated_data['invoice_type'] in [0, 1, 2]: return ErrorResponse(INCORRECT_INVOICE_TYPE, status.HTTP_400_BAD_REQUEST) address = invoice_serializer.get_address() invoice_type = invoice_serializer.validated_data['invoice_type'] products = invoice_serializer.validated_data['products'] comment = invoice_serializer.validated_data['comment'] target = invoice_serializer.validated_data['target'] if len(list(filter(lambda prod: prod.on_transition, products))) != 0: return ErrorResponse(SOME_PRODUCTS_ARE_IN_TRANSITION, status.HTTP_400_BAD_REQUEST) filtered_products = list( filter(lambda prod: not prod.responsible == user.account, products)) if len(filtered_products) == len(products): if invoice_type == 0: accounts = list(set(map(lambda pr: pr.responsible, products))) created_invoices = [] for account in accounts: account_products = list( filter(lambda pr: pr.responsible.id == account.id, products)) invoice = Invoice.objects.create(invoice_type=invoice_type, comment=comment, address=address, from_account=account, to_account=current_account, target=target) invoice.invoice_lines.add(*account_products) invoice.save() InvoiceChanges.objects.create(invoice=invoice, status=0) created_invoices.append(invoice) return SuccessResponse( InvoiceSerializer(created_invoices, many=True).data, status.HTTP_200_OK) else: return ErrorResponse(INCORRECT_INVOICE_TYPE, status.HTTP_400_BAD_REQUEST) elif len(filtered_products) == 0: if invoice_type == 1: to_account = current_account if invoice_serializer.validated_data['to_account'] is None\ else invoice_serializer.validated_data['to_account'] invoice = Invoice.objects.create(invoice_type=invoice_type, comment=comment, address=address, from_account=current_account, to_account=to_account, target=target) invoice.invoice_lines.add(*products) invoice.save() InvoiceChanges.objects.create(invoice=invoice, status=0) return SuccessResponse( InvoiceSerializer(invoice).data, status.HTTP_200_OK) elif invoice_type == 2: to_account = current_account if invoice_serializer.validated_data['to_account'] is None \ else invoice_serializer.validated_data['to_account'] invoice = Invoice.objects.create(invoice_type=invoice_type, comment=comment, address=address, from_account=current_account, to_account=to_account, target=target) invoice.invoice_lines.add(*products) invoice.save() InvoiceChanges.objects.create(invoice=invoice, status=0) return SuccessResponse( InvoiceSerializer(invoice).data, status.HTTP_200_OK) else: return ErrorResponse(INCORRECT_INVOICE_TYPE, status.HTTP_400_BAD_REQUEST) else: return ErrorResponse(INCORRECT_INVOICE_PRODUCTS, status.HTTP_404_NOT_FOUND)