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)