1181 lines
44 KiB
Python
1181 lines
44 KiB
Python
from BaseModels.api.base_api_views import *
|
||
from .user_api_serializars import *
|
||
from ...api_permissions import Auth_API_perms
|
||
from datetime import datetime
|
||
from rest_framework.decorators import action
|
||
from django.db.models import Sum, FloatField, F, Value as V, Q, Count
|
||
from django.db.models.functions import Concat
|
||
import json
|
||
from BaseModels.mailSender import techSendMail
|
||
from operator import itemgetter
|
||
from rest_framework import status
|
||
from CompaniesApp.models import Company, DeliveryData
|
||
from BaseModels.api.api_inter import check_and_get_specific_output_format
|
||
from django.contrib.contenttypes.models import ContentType
|
||
from ..permissions.personal_api_permissions import Personal_API_perms
|
||
|
||
from B2BApp.funcs import pay_terms_for_report_list
|
||
|
||
|
||
def get_kwargs_by_get_query_params(request):
|
||
kwargs = {}
|
||
stat_kwargs = {}
|
||
|
||
if not request.user.has_perm('AuthApp.UI_managers_all_stat'):
|
||
kwargs.update({'id': request.user.id})
|
||
|
||
if not request.query_params:
|
||
return kwargs, stat_kwargs
|
||
else:
|
||
|
||
try:
|
||
|
||
params = request.query_params
|
||
|
||
for param_key, param_val in params.items():
|
||
|
||
if 'for_managers_stat_DT_from' == param_key:
|
||
# param_key = 'orders_for_manager__delivery_DT__gte'
|
||
param_key = 'delivery_DT__gte'
|
||
kwargs.update({
|
||
param_key: datetime.strptime(param_val, '%Y-%m-%d %H:%M')
|
||
})
|
||
elif 'for_managers_stat_DT_to' == param_key:
|
||
# param_key = 'orders_for_manager__delivery_DT__lte'
|
||
param_key = 'delivery_DT__lte'
|
||
kwargs.update({
|
||
param_key: datetime.strptime(param_val, '%Y-%m-%d %H:%M')
|
||
})
|
||
|
||
elif '_D_from' in param_key:
|
||
param_key = param_key.replace('_from', '__gte')
|
||
kwargs.update({
|
||
param_key: datetime.strptime(param_val, '%Y-%m-%d')
|
||
})
|
||
elif '_D_to' in param_key:
|
||
param_key = param_key.replace('_to', '__lte')
|
||
kwargs.update({
|
||
param_key: datetime.strptime(param_val, '%Y-%m-%d')
|
||
})
|
||
|
||
elif param_key == 'regions':
|
||
param_val = json.loads(param_val)
|
||
kwargs.update({
|
||
'company__region__in'.format(param_key): param_val
|
||
})
|
||
|
||
|
||
elif 'rel_products_in_order_for_product__order__delivery_DT_from' in param_key:
|
||
|
||
# param_key = 'orders_for_manager__delivery_DT__gte'
|
||
param_key = 'delivery_DT__gte'
|
||
|
||
kwargs.update({
|
||
|
||
param_key: datetime.strptime(param_val, '%Y-%m-%d %H:%M')
|
||
|
||
})
|
||
|
||
elif 'rel_products_in_order_for_product__order__delivery_DT_to' in param_key:
|
||
|
||
param_key = 'orders_for_manager__delivery_DT__lte'
|
||
# param_key = 'delivery_DT__lte'
|
||
|
||
kwargs.update({
|
||
|
||
param_key: datetime.strptime(param_val, '%Y-%m-%d %H:%M')
|
||
|
||
})
|
||
|
||
# only_stat_kwargs
|
||
elif '_from' in param_key:
|
||
param_key = param_key.replace('_from', '__gte')
|
||
stat_kwargs.update({
|
||
param_key: param_val
|
||
})
|
||
elif '_to' in param_key:
|
||
param_key = param_key.replace('_to', '__lte')
|
||
stat_kwargs.update({
|
||
param_key: param_val
|
||
})
|
||
# ---------------------
|
||
|
||
elif param_key in ('pay_terms', 'status'):
|
||
param_val = json.loads(param_val)
|
||
kwargs.update({
|
||
'{0}__in'.format(param_key): param_val
|
||
})
|
||
|
||
elif param_key in ['manager_obj', '']:
|
||
kwargs.update({
|
||
'{0}__id'.format(param_key): param_val
|
||
})
|
||
|
||
elif param_key in ['series_name']:
|
||
param_val = json.loads(param_val)
|
||
kwargs.update({
|
||
# 'orders_for_manager__rel_products_in_order_for_order__product__product_series__id__in': param_val
|
||
'rel_products_in_order_for_order__product__product_series__id__in': param_val
|
||
})
|
||
|
||
elif param_key in ['brand_name']:
|
||
param_val = json.loads(param_val)
|
||
kwargs.update({
|
||
# 'orders_for_manager__rel_products_in_order_for_order__product__brand__id__in': param_val
|
||
'rel_products_in_order_for_order__product__brand__id__in': param_val
|
||
})
|
||
elif param_key == 'enable':
|
||
param_val = json.loads(param_val)
|
||
kwargs.update({
|
||
# 'orders_for_manager__rel_products_in_order_for_order__product__enable': param_val
|
||
'rel_products_in_order_for_order__product__enable': param_val
|
||
})
|
||
|
||
except Exception as e:
|
||
msg = 'Ошибка разбора параметров фильтра<br>{0}({1})<br>{2}'.format(
|
||
str(e),
|
||
str(e.args),
|
||
str(request.query_params)
|
||
)
|
||
print(msg)
|
||
title = 'ОШИБКА tE AuthApp get_kwargs_by_get_query_params'
|
||
techSendMail(msg, title)
|
||
|
||
return kwargs, stat_kwargs
|
||
|
||
|
||
def get_sales_for_managers_by_goods(user, objs, ord_kwargs, receipts_kwargs, stat_kwargs=None):
|
||
objs_ids = objs.values_list('id', flat=True)
|
||
objs_ids = list(objs_ids)
|
||
|
||
from B2BApp.models import ProductInReceipt, ProductInOrder
|
||
from django.db.models import Sum, FloatField, F
|
||
|
||
prod_in_orders = ProductInOrder.objects.filter(
|
||
order__status_shipment='shipped',
|
||
order__defective_goods=False,
|
||
order__manager_obj__id__in=objs_ids,
|
||
**ord_kwargs
|
||
# ).exclude(
|
||
# order__pay_terms='no_pay'
|
||
)
|
||
|
||
allow_values_in_orders = [
|
||
'id', 'sales_count',
|
||
# 'paid_sum',
|
||
'order__manager_obj__id'
|
||
]
|
||
|
||
allow_values_in_receipts = [
|
||
'id', 'receipts_count',
|
||
'receipt__company__manager_obj__id'
|
||
]
|
||
|
||
if user.has_perm('B2BApp.UI_show_summ_for_sales'):
|
||
allow_values_in_orders.append('sales_sum')
|
||
allow_values_in_receipts.append('receipts_sum')
|
||
|
||
prod_in_orders = prod_in_orders.annotate(
|
||
sales_count=F('count'),
|
||
sales_sum=F('product_sum_byn'),
|
||
# paid_sum=F('order__paid_sum_byn')
|
||
).values(
|
||
*allow_values_in_orders
|
||
).order_by('order__manager_obj__id')
|
||
|
||
prod_in_orders = list(prod_in_orders)
|
||
|
||
prod_in_receipts = ProductInReceipt.objects.filter(
|
||
receipt__receipt_type='return',
|
||
receipt__company__manager_obj__id__in=objs_ids,
|
||
**receipts_kwargs
|
||
)
|
||
|
||
prod_in_receipts = prod_in_receipts.annotate(
|
||
receipts_count=Sum('count',
|
||
output_field=FloatField()),
|
||
receipts_sum=Sum('product_sum_byn'),
|
||
).values(
|
||
*allow_values_in_receipts
|
||
).order_by('receipt__company__manager_obj__id')
|
||
|
||
prod_in_receipts = list(prod_in_receipts)
|
||
|
||
objs = list(objs)
|
||
objs.sort(key=itemgetter('full_name'), reverse=False)
|
||
|
||
objs_i = 0
|
||
while objs_i < len(objs):
|
||
obj = objs[objs_i]
|
||
obj['sales_count'] = 0
|
||
obj['sales_sum'] = 0
|
||
# obj['paid_sum'] = 0
|
||
i = 0
|
||
while i < len(prod_in_orders):
|
||
if obj['id'] == prod_in_orders[i]['order__manager_obj__id']:
|
||
obj['sales_count'] += prod_in_orders[i]['sales_count']
|
||
if 'sales_sum' in prod_in_orders[i]:
|
||
obj['sales_sum'] += prod_in_orders[i]['sales_sum']
|
||
# obj['paid_sum'] += prod_in_orders[i]['paid_sum']
|
||
del prod_in_orders[i]
|
||
# break
|
||
else:
|
||
i += 1
|
||
|
||
i = 0
|
||
while i < len(prod_in_receipts):
|
||
if obj['id'] == prod_in_receipts[i]['receipt__company__manager_obj__id']:
|
||
obj['sales_count'] -= prod_in_receipts[i]['receipts_count']
|
||
if 'receipts_sum' in prod_in_receipts[i]:
|
||
obj['sales_sum'] -= prod_in_receipts[i]['receipts_sum']
|
||
|
||
del prod_in_receipts[i]
|
||
# break
|
||
else:
|
||
i += 1
|
||
|
||
if stat_kwargs:
|
||
if stat_kwargs and 'sales_count__gte' in stat_kwargs and stat_kwargs['sales_count__gte'] and objs[objs_i][
|
||
'sales_count'] < float(stat_kwargs['sales_count__gte']):
|
||
del objs[objs_i]
|
||
elif stat_kwargs and 'sales_count__lte' in stat_kwargs and stat_kwargs['sales_count__lte'] and objs[objs_i][
|
||
'sales_count'] > float(stat_kwargs['sales_count__lte']):
|
||
del objs[objs_i]
|
||
elif stat_kwargs and 'sales_sum__gte' in stat_kwargs and stat_kwargs['sales_sum__gte'] and objs[objs_i][
|
||
'sales_sum'] < float(stat_kwargs['sales_sum__gte']):
|
||
del objs[objs_i]
|
||
elif stat_kwargs and 'sales_sum__lte' in stat_kwargs and stat_kwargs['sales_sum__lte'] and objs[objs_i][
|
||
'sales_sum'] > float(stat_kwargs['sales_sum__lte']):
|
||
del objs[objs_i]
|
||
|
||
else:
|
||
objs[objs_i]['sales_count'] = round(objs[objs_i]['sales_count'], 2)
|
||
objs[objs_i]['sales_sum'] = round(objs[objs_i]['sales_sum'], 2)
|
||
|
||
objs_i += 1
|
||
else:
|
||
objs_i += 1
|
||
|
||
return objs
|
||
|
||
|
||
def get_sales_for_managers_by_orders(objs, ord_kwargs, receipts_kwargs, pay_kwargs, stat_kwargs=None):
|
||
from datetime import date, timedelta
|
||
from collections import OrderedDict
|
||
|
||
chart_data_Dict = {}
|
||
|
||
try:
|
||
|
||
from_date = None
|
||
to_date = None
|
||
|
||
objs_ids = objs.values_list('id', flat=True)
|
||
objs_ids = list(objs_ids)
|
||
|
||
from B2BApp.models import Order, ReceiptDocument, Pay
|
||
orders = Order.objects.filter(
|
||
status_shipment='shipped',
|
||
defective_goods=False,
|
||
manager_obj__id__in=objs_ids,
|
||
**ord_kwargs
|
||
)
|
||
|
||
if orders:
|
||
from_date = orders.order_by('delivery_DT')[0].delivery_DT.date()
|
||
to_date = orders.order_by('-delivery_DT')[0].delivery_DT.date()
|
||
|
||
orders = orders.annotate(
|
||
sales_count=Sum('rel_products_in_order_for_order__count',
|
||
output_field=FloatField()),
|
||
sales_sum=F('order_sum_byn'),
|
||
paid_sum=F('paid_sum_byn')
|
||
).values(
|
||
'id', 'sales_count', 'sales_sum', 'delivery_DT',
|
||
'paid_sum', 'pay_type',
|
||
'manager_obj__id', 'company__name'
|
||
).order_by('manager_obj__id')
|
||
|
||
orders = list(orders)
|
||
|
||
receipts = ReceiptDocument.objects.filter(
|
||
receipt_type='return',
|
||
manager_obj__id__in=objs_ids,
|
||
**receipts_kwargs
|
||
)
|
||
|
||
if receipts:
|
||
from_date_tmp = receipts.order_by('receipt_D')[0].receipt_D
|
||
if not from_date or from_date_tmp < from_date:
|
||
from_date = from_date_tmp
|
||
to_date_tmp = receipts.order_by('-receipt_D')[0].receipt_D
|
||
if not to_date or to_date_tmp > to_date:
|
||
to_date = to_date_tmp
|
||
|
||
receipts = receipts.annotate(
|
||
receipts_count=Sum('rel_products_in_receipt_for_receipt__count',
|
||
output_field=FloatField()),
|
||
receipts_sum=Sum('rel_products_in_receipt_for_receipt__product_sum_byn'),
|
||
).values(
|
||
'id', 'receipts_count', 'receipts_sum', 'manager_obj__id', 'pay_type', 'receipt_D' # , 'company__name'
|
||
).order_by('manager_obj__id')
|
||
|
||
receipts = list(receipts)
|
||
|
||
pays = Pay.objects.filter(
|
||
manager__id__in=objs_ids,
|
||
**pay_kwargs
|
||
)
|
||
|
||
if pays:
|
||
from_date_tmp = pays.order_by('oper_D')[0].oper_D
|
||
if not from_date or from_date_tmp < from_date:
|
||
from_date = from_date_tmp
|
||
to_date_tmp = pays.order_by('-oper_D')[0].oper_D
|
||
if not to_date or to_date_tmp > to_date:
|
||
to_date = to_date_tmp
|
||
|
||
pay_objs = pays.values(
|
||
'id', 'oper_D', 'sum_pay_byn', 'manager__id',
|
||
'shipment_doc__id', 'shipment_doc__rel_orders_for_documents',
|
||
'shipment_doc__rel_orders_for_documents__manager_obj__id',
|
||
'company__id', 'bank_doc_D'
|
||
).order_by('oper_D', 'company__name')
|
||
# ).order_by('company__manager_obj__id', 'oper_D')
|
||
|
||
pays = list(pay_objs)
|
||
|
||
# from CompaniesApp.models import Document
|
||
# its = Pay.objects.filter(documents__id=30069)
|
||
|
||
objs = list(objs)
|
||
objs.sort(key=itemgetter('full_name'), reverse=False)
|
||
|
||
if from_date:
|
||
from_DT = from_date
|
||
else:
|
||
from_DT = date(year=2000, month=1, day=1)
|
||
|
||
if to_date:
|
||
to_DT = to_date + timedelta(days=1)
|
||
else:
|
||
to_DT = datetime.now().date() + timedelta(days=1)
|
||
|
||
chart_data_Dict = OrderedDict({
|
||
str(from_DT + timedelta(n)): {
|
||
'sales_count': 0,
|
||
'sales_sum': 0,
|
||
'paid_sum': 0,
|
||
'paid_cash': 0,
|
||
'paid_invoice': 0
|
||
} for n in range(int((to_DT - from_DT).days) + 1)
|
||
})
|
||
|
||
total_pays_cash = 0
|
||
total_pays_invoice = 0
|
||
|
||
objs_i = 0
|
||
while objs_i < len(objs):
|
||
obj = objs[objs_i]
|
||
# if obj['id'] == 31:
|
||
# print('!')
|
||
|
||
orders_items = []
|
||
receipts_items = []
|
||
pays_items = []
|
||
obj['sales_count'] = 0
|
||
obj['sales_sum'] = 0
|
||
obj['paid_sum'] = 0
|
||
obj['paid_cash'] = 0
|
||
i = 0
|
||
while i < len(orders):
|
||
if obj['id'] == orders[i]['manager_obj__id']:
|
||
if orders[i]['sales_count']:
|
||
obj['sales_count'] += orders[i]['sales_count']
|
||
if orders[i]['sales_sum']:
|
||
obj['sales_sum'] += orders[i]['sales_sum']
|
||
chart_data_Dict[str(orders[i]['delivery_DT'].date())]['sales_sum'] += round(
|
||
orders[i]['sales_sum'], 2)
|
||
if orders[i]['pay_type'] == 'cash' and orders[i]['paid_sum']:
|
||
obj['paid_cash'] += orders[i]['paid_sum']
|
||
chart_data_Dict[str(orders[i]['delivery_DT'].date())]['paid_cash'] += round(
|
||
orders[i]['paid_sum'], 2)
|
||
chart_data_Dict[str(orders[i]['delivery_DT'].date())]['paid_sum'] += round(
|
||
orders[i]['paid_sum'], 2)
|
||
|
||
orders_items.append(orders[i])
|
||
|
||
del orders[i]
|
||
|
||
# break
|
||
else:
|
||
i += 1
|
||
|
||
i = 0
|
||
while i < len(receipts):
|
||
if obj['id'] == receipts[i]['manager_obj__id']:
|
||
if receipts[i]['receipts_count']:
|
||
obj['sales_count'] -= receipts[i]['receipts_count']
|
||
if receipts[i]['receipts_sum']:
|
||
obj['sales_sum'] -= receipts[i]['receipts_sum']
|
||
chart_data_Dict[str(receipts[i]['receipt_D'])]['sales_sum'] -= round(
|
||
receipts[i]['receipts_sum'], 2)
|
||
receipts_items.append(receipts[i])
|
||
|
||
if receipts[i]['pay_type'] == 'cash':
|
||
if receipts[i]['receipts_sum']:
|
||
obj['paid_cash'] -= receipts[i]['receipts_sum']
|
||
chart_data_Dict[str(receipts[i]['receipt_D'])]['paid_cash'] -= round(
|
||
receipts[i]['receipts_sum'], 2)
|
||
|
||
chart_data_Dict[str(receipts[i]['receipt_D'])]['paid_sum'] -= round(
|
||
receipts[i]['receipts_sum'], 2)
|
||
|
||
del receipts[i]
|
||
|
||
# break
|
||
else:
|
||
i += 1
|
||
|
||
i = 0
|
||
obj['paid_invoice'] = 0
|
||
while i < len(pays):
|
||
|
||
if obj['id'] == pays[i]['manager__id'] and pays[i]['sum_pay_byn']:
|
||
|
||
# if pays[i]['id'] == 2879:
|
||
# print('!')
|
||
|
||
obj['paid_invoice'] += pays[i]['sum_pay_byn']
|
||
pays_items.append(pays[i])
|
||
|
||
chart_data_Dict[str(pays[i]['oper_D'])]['paid_invoice'] += round(pays[i]['sum_pay_byn'], 2)
|
||
chart_data_Dict[str(pays[i]['oper_D'])]['paid_sum'] += round(pays[i]['sum_pay_byn'], 2)
|
||
|
||
del pays[i]
|
||
# elif obj['id'] == pays[i]['shipment_doc__rel_orders_for_documents__manager_obj__id']:
|
||
# obj['paid_sum'] += pays[i]['sum_pay_byn']
|
||
# pays_items.append(pays[i])
|
||
# del pays[i]
|
||
# break
|
||
else:
|
||
i += 1
|
||
|
||
if stat_kwargs:
|
||
if stat_kwargs and 'sales_count__gte' in stat_kwargs and stat_kwargs['sales_count__gte'] and \
|
||
objs[objs_i][
|
||
'sales_count'] < float(stat_kwargs['sales_count__gte']):
|
||
del objs[objs_i]
|
||
elif stat_kwargs and 'sales_count__lte' in stat_kwargs and stat_kwargs['sales_count__lte'] and \
|
||
objs[objs_i][
|
||
'sales_count'] > float(stat_kwargs['sales_count__lte']):
|
||
del objs[objs_i]
|
||
elif stat_kwargs and 'sales_sum__gte' in stat_kwargs and stat_kwargs['sales_sum__gte'] and objs[objs_i][
|
||
'sales_sum'] < float(stat_kwargs['sales_sum__gte']):
|
||
del objs[objs_i]
|
||
elif stat_kwargs and 'sales_sum__lte' in stat_kwargs and stat_kwargs['sales_sum__lte'] and objs[objs_i][
|
||
'sales_sum'] > float(stat_kwargs['sales_sum__lte']):
|
||
del objs[objs_i]
|
||
|
||
else:
|
||
objs[objs_i]['sales_count'] = round(objs[objs_i]['sales_count'], 2)
|
||
objs[objs_i]['sales_sum'] = round(objs[objs_i]['sales_sum'], 2)
|
||
|
||
objs_i += 1
|
||
else:
|
||
objs_i += 1
|
||
|
||
obj['paid_sum'] = obj['paid_cash'] + obj['paid_invoice']
|
||
|
||
# obj['sales_count'] = round(obj['sales_count'], 2)
|
||
# obj['sales_sum'] = round(obj['sales_sum'], 2)
|
||
obj['paid_sum'] = round(obj['paid_sum'], 2)
|
||
|
||
total_pays_cash += obj['paid_cash']
|
||
total_pays_invoice += obj['paid_invoice']
|
||
|
||
# print('{0}. ord_count={1}, recepts_count={2}'.format(obj['full_name'], len(orders_items), len(receipts_items)))
|
||
|
||
except Exception as e:
|
||
msg = 'Ошибка сбора статистики<br>{0}({1})'.format(
|
||
str(e),
|
||
str(e.args),
|
||
)
|
||
print(msg)
|
||
title = 'ОШИБКА tE AuthApp get_sales_for_managers_by_orders'
|
||
techSendMail(msg, title)
|
||
|
||
return objs, chart_data_Dict
|
||
|
||
|
||
class v1_Personal_ViewSet(APIViewSet_ModelClass):
|
||
queryset = User.objects.filter().order_by('last_name', 'first_name')
|
||
serializer_class = Personal_list_Serializer
|
||
permission_classes = (Personal_API_perms,)
|
||
|
||
def get_serializer_class(self):
|
||
|
||
try:
|
||
if self.action == 'list':
|
||
return Personal_list_Serializer
|
||
if self.action == 'add_communication_item':
|
||
from GeneralApp.api.v1.communications.communications_api_serializers import \
|
||
Communications_create_Serializer
|
||
return Communications_create_Serializer
|
||
if self.action == 'retrieve':
|
||
return Personal_list_Serializer
|
||
if self.action == 'change_mailing_status':
|
||
return Personal_change_mailing_status_Serializer
|
||
|
||
except (KeyError, AttributeError):
|
||
pass
|
||
|
||
return super(v1_Personal_ViewSet, self).get_serializer_class()
|
||
|
||
def get_queryset(self, *args, **kwargs):
|
||
|
||
user = self.request.user
|
||
if not user or user.is_anonymous or not user.is_active:
|
||
return []
|
||
|
||
persons = super(v1_Personal_ViewSet, self).get_queryset()
|
||
persons = persons.exclude(is_superuser=True)
|
||
|
||
if user.has_perm('AuthApp.UI_company_staff_modify_any') or user.has_perm(
|
||
'AuthApp.UI_company_staff_retrieve_any_no_staff'):
|
||
return persons.filter(user_profile__enable=True)
|
||
elif user.has_perm('AuthApp.UI_company_staff_modify_if_manager'):
|
||
persons = persons.filter(
|
||
# user_profile__company_obj__manager_obj=user,
|
||
user_profile__enable=True
|
||
)
|
||
return persons
|
||
elif user.has_perm('AuthApp.UI_company_staff_modify_if_staff_company'):
|
||
persons = persons.filter(
|
||
user_profile__company_obj=user.user_profile.company_obj,
|
||
user_profile__enable=True
|
||
)
|
||
return persons
|
||
|
||
return []
|
||
|
||
@action(methods=['GET'], detail=False)
|
||
def possible_departaments_list(self, request, *args, **kwargs):
|
||
|
||
data_list = UserProfile.objects.exclude(
|
||
departament=None
|
||
).exclude(
|
||
company_position=''
|
||
).values_list('departament', flat=True).order_by('departament').distinct()
|
||
return Response(data_list)
|
||
|
||
@action(methods=['PATCH'], detail=True)
|
||
def change_mailing_status(self, request, *args, **kwargs):
|
||
from MailingApp.models import Mailing
|
||
|
||
obj = self.get_object()
|
||
|
||
data = request.data
|
||
|
||
res = obj.user_profile.change_mailing_status(data['mailing_ID'], data['mailing_status'])
|
||
|
||
return Response(res)
|
||
|
||
@action(methods=['GET'], detail=True)
|
||
def possible_mailings(self, request, *args, **kwargs):
|
||
from MailingApp.models import Mailing
|
||
|
||
person = self.get_object()
|
||
|
||
if not person or not person.user_profile or not person.user_profile.company_obj or \
|
||
not person.user_profile.company_obj.manager_obj:
|
||
raise serializers.ValidationError(
|
||
u'user is not connected w company'
|
||
)
|
||
|
||
manager_of_person = person.user_profile.company_obj.manager_obj
|
||
|
||
if manager_of_person != request.user:
|
||
from AuthApp.funcs import get_subordinate_staff
|
||
subordinate_users_for_cur_user = get_subordinate_staff(request.user)
|
||
if not manager_of_person in subordinate_users_for_cur_user:
|
||
raise serializers.ValidationError(
|
||
u'нет прав для доступа к управлению рассылкой'
|
||
)
|
||
|
||
mailings = request.user.user_profile.get_allow_mailings(for_user=person)
|
||
if mailings:
|
||
mailings = list(
|
||
mailings.values('id', 'name', 'enable', 'pass_weekends', 'last_send_DT', 'next_send_DT', 'creator__id',
|
||
'creator_name'))
|
||
|
||
connected_mailings_ids = person.user_profile.connected_mailings.all().values_list('id', flat=True)
|
||
|
||
for mailing in mailings:
|
||
if mailing['id'] in connected_mailings_ids:
|
||
mailing['connected'] = True
|
||
else:
|
||
mailing['connected'] = False
|
||
|
||
if mailing['next_send_DT']:
|
||
mailing['next_send_DT'] = str(mailing['next_send_DT'])
|
||
if mailing['last_send_DT']:
|
||
mailing['last_send_DT'] = str(mailing['last_send_DT'])
|
||
|
||
return Response(mailings)
|
||
|
||
@action(methods=['GET'], detail=False)
|
||
def possible_company_positions_list(self, request, *args, **kwargs):
|
||
|
||
data_list = UserProfile.objects.exclude(
|
||
company_position=None
|
||
).exclude(
|
||
company_position=''
|
||
).values_list('company_position', flat=True).order_by('company_position').distinct()
|
||
return Response(data_list)
|
||
|
||
@action(methods=['GET'], detail=True)
|
||
def get_connected_mailings(self, request, *args, **kwargs):
|
||
|
||
obj = self.get_object()
|
||
data_list = obj.user_profile.get_connected_mailings().values('id', 'name', 'enable')
|
||
return Response(data_list)
|
||
|
||
@action(methods=['POST'], detail=True)
|
||
def add_communication_item(self, request, *args, **kwargs):
|
||
|
||
data = request.data
|
||
if not 'connection_name' in data or not 'connection_value' in data:
|
||
raise serializers.ValidationError(
|
||
u'Ошибка, недостаточно данных'
|
||
)
|
||
|
||
obj = self.get_object()
|
||
|
||
from GeneralApp.views import create_communication_item
|
||
|
||
ct = ContentType.objects.get_for_model(obj.user_profile)
|
||
res = create_communication_item(ct, obj.user_profile.id, data)
|
||
if 'error' in res:
|
||
raise serializers.ValidationError(res['error'])
|
||
|
||
serializer = Personal_list_Serializer(obj)
|
||
|
||
return Response(serializer.data)
|
||
|
||
def list(self, request, *args, **kwargs):
|
||
|
||
filter_kwargs, stat_kwargs = get_kwargs_by_get_query_params(request)
|
||
|
||
res = check_and_get_specific_output_format(self, data=None, filename='personal_list.xlsx')
|
||
if res:
|
||
return res
|
||
|
||
return super(v1_Personal_ViewSet, self).list(request, *args, **kwargs)
|
||
|
||
@action(methods=['GET'], detail=True)
|
||
def list_by_company_id(self, request, *args, **kwargs):
|
||
if not kwargs or not 'pk' in kwargs:
|
||
raise serializers.ValidationError(
|
||
u'Ошибка, не указан id компании'
|
||
)
|
||
|
||
try:
|
||
company = Company.objects.get(id=kwargs['pk'])
|
||
except Company.DoesNotExist:
|
||
raise serializers.ValidationError(
|
||
u'Ошибка, неверный id компании'
|
||
)
|
||
|
||
personal_objs = self.get_queryset().filter(user_profile__company_obj=company)
|
||
serializer = Personal_list_Serializer(personal_objs, many=True)
|
||
|
||
res = check_and_get_specific_output_format(self, serializer.data, '{0}_personal.xlsx'.format(str(company.name)))
|
||
if res:
|
||
return res
|
||
|
||
data = serializer.data
|
||
|
||
return Response(data)
|
||
|
||
@action(methods=['GET'], detail=True)
|
||
def list_by_office_id(self, request, *args, **kwargs):
|
||
if not kwargs or not 'pk' in kwargs:
|
||
raise serializers.ValidationError(
|
||
u'Ошибка, не указан id подразделения'
|
||
)
|
||
|
||
try:
|
||
office = DeliveryData.objects.get(id=kwargs['pk'])
|
||
except DeliveryData.DoesNotExist:
|
||
raise serializers.ValidationError(
|
||
u'Ошибка, неверный id компании'
|
||
)
|
||
|
||
personal_objs = self.queryset.filter(user_profile__office=office)
|
||
serializer = Personal_list_Serializer(personal_objs, many=True)
|
||
|
||
res = check_and_get_specific_output_format(self, data=serializer.data,
|
||
filename='{0}_personal.xlsx'.format(str(office.name)))
|
||
if res:
|
||
return res
|
||
|
||
return Response(serializer.data)
|
||
|
||
def partial_update(self, request, *args, **kwargs):
|
||
user = self.get_object()
|
||
|
||
data = request.data
|
||
|
||
if 'id' in data and not data['id']:
|
||
return Response({'error': 'Изменение невозможно. Нет идентификатора пользователя'},
|
||
status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
if 'email' in data and not data['email']:
|
||
return Response({'error': 'Изменение невозможно. Нет email идентификатора пользователя'},
|
||
status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
users = User.objects.filter(
|
||
id=user.id
|
||
)
|
||
|
||
if not users:
|
||
return Response({'error': 'Изменение невозможно. Пользователь не найден'},
|
||
status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
company = None
|
||
profile_data = None
|
||
if 'user_profile' in data:
|
||
profile_data = data['user_profile']
|
||
if 'company_obj' in profile_data and profile_data['company_obj']:
|
||
try:
|
||
company = Company.objects.get(id=profile_data['company_obj'])
|
||
profile_data['company_obj'] = company
|
||
|
||
except Company.DoesNotExist:
|
||
return Response({'error': u'Компания не существует'},
|
||
status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
office = None
|
||
if 'office' in profile_data and profile_data['office']:
|
||
try:
|
||
office = DeliveryData.objects.get(id=profile_data['office'])
|
||
profile_data['office'] = office
|
||
except Company.DoesNotExist:
|
||
return Response({'error': u'Подразделение не существует'},
|
||
status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
if 'id' in profile_data:
|
||
del profile_data['id']
|
||
if 'office__name' in profile_data:
|
||
del profile_data['office__name']
|
||
|
||
user_data = data
|
||
|
||
if profile_data:
|
||
del user_data['user_profile']
|
||
if 'id' in user_data:
|
||
del user_data['id']
|
||
if 'full_name' in user_data:
|
||
del user_data['full_name']
|
||
if 'email' in user_data:
|
||
user_data['username'] = user_data['email']
|
||
|
||
if users.count() > 1:
|
||
return Response({'error': u'Ошибка, найдено более одного пользователя, соответствующего id'},
|
||
status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
users.update(**user_data)
|
||
user = users.first()
|
||
|
||
if profile_data:
|
||
UserProfile.objects.filter(user=user).update(**profile_data)
|
||
|
||
if 'mailing_sets' in profile_data:
|
||
if not company and user.user_profile:
|
||
company = user.user_profile.company_obj
|
||
if company:
|
||
company.update_mailing_on()
|
||
|
||
serializer = Personal_list_Serializer(user)
|
||
data = serializer.data
|
||
|
||
# data.update(get_editable_fields_list_Dict(request.user, self.action, serializer.Meta.fields))
|
||
|
||
return Response(data)
|
||
|
||
def create(self, request, *args, **kwargs):
|
||
|
||
data = request.data
|
||
|
||
serializer = self.get_serializer_class()(data=data)
|
||
if not serializer.is_valid():
|
||
raise serializers.ValidationError(serializer.errors)
|
||
|
||
errors_Dict = {}
|
||
|
||
if not 'email' in data or not data['email']:
|
||
errors_Dict.update({'email': 'обязательное поле'})
|
||
# return Response(
|
||
# {
|
||
# 'errors': {
|
||
# 'Создание невозможно. Не не введен email'
|
||
# }
|
||
# },
|
||
# status=status.HTTP_400_BAD_REQUEST
|
||
# )
|
||
else:
|
||
|
||
try:
|
||
user = User.objects.get(
|
||
email=data['email']
|
||
)
|
||
|
||
errors_Dict.update({'email': 'Создание невозможно. Пользователь с указанным email уже существует'})
|
||
|
||
# return Response({'error': u'Создание невозможно. Пользователь с указанным email уже существует'},
|
||
# status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
except User.DoesNotExist:
|
||
pass
|
||
|
||
company = None
|
||
office = None
|
||
if 'office' in data['user_profile'] and data['user_profile']['office']:
|
||
try:
|
||
office = DeliveryData.objects.get(id=data['user_profile']['office'])
|
||
data['user_profile']['office'] = office
|
||
company = office.company
|
||
except Company.DoesNotExist:
|
||
return Response({'error': u'Подразделение не существует'},
|
||
status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
if not company and ('company_obj' in data['user_profile'] and data['user_profile']['company_obj']):
|
||
try:
|
||
company = Company.objects.get(id=data['user_profile']['company_obj'])
|
||
data['user_profile']['company_obj'] = company
|
||
except Company.DoesNotExist:
|
||
return Response({'error': u'Компания не существует'},
|
||
status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
if 'creator' in data['user_profile'] and data['user_profile']['creator']:
|
||
try:
|
||
creator = User.objects.get(id=data['user_profile']['creator'])
|
||
data['user_profile']['creator'] = company
|
||
except Company.DoesNotExist:
|
||
pass
|
||
# return Response({'error': u'Пользователь не существует'},
|
||
# status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
if errors_Dict:
|
||
raise serializers.ValidationError(errors_Dict)
|
||
# return Response({
|
||
# 'errors': errors_Dict
|
||
# })
|
||
|
||
from ....views import create_personal_user
|
||
res = create_personal_user(data, request.user)
|
||
if 'error' in res:
|
||
raise serializers.ValidationError(res['error'])
|
||
# return Response({'error': res['error']},
|
||
# status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
serializer = Personal_list_Serializer(res['user'])
|
||
data = serializer.data
|
||
|
||
# data.update(get_editable_fields_list_Dict(request.user, self.action, serializer.Meta.fields))
|
||
|
||
return Response(data)
|
||
|
||
|
||
class v1_Managers_ViewSet(APIViewSet_ModelClass):
|
||
queryset = User.objects.filter(is_staff=True).order_by('last_name', 'first_name')
|
||
serializer_class = User_list_Serializer
|
||
permission_classes = (Auth_API_perms,)
|
||
|
||
def get_serializer_class(self):
|
||
|
||
try:
|
||
if self.action == 'list':
|
||
return User_list_Serializer
|
||
if self.action == 'retrieve':
|
||
return User_list_Serializer
|
||
|
||
except (KeyError, AttributeError):
|
||
pass
|
||
|
||
return super(v1_Managers_ViewSet, self).get_serializer_class()
|
||
|
||
def get_queryset(self, *args, **kwargs):
|
||
|
||
user = self.request.user
|
||
if user.has_perm('AuthApp.UI_managers_all_stat'):
|
||
managers = User.objects.filter(
|
||
is_staff=True,
|
||
)
|
||
else:
|
||
managers = User.objects.filter(
|
||
id=user.id,
|
||
is_staff=True,
|
||
)
|
||
|
||
managers = managers.order_by('-is_active', 'last_name', 'first_name')
|
||
|
||
# if self.action in ('stat_list', ):
|
||
#
|
||
# filter_kwargs, stat_kwargs = get_kwargs_by_get_query_params(self.request)
|
||
# if kwargs:
|
||
# filter_kwargs.update(kwargs)
|
||
#
|
||
# managers = managers.filter(
|
||
#
|
||
# orders_for_manager__status_shipment='shipped',
|
||
# orders_for_manager__defective_goods=False,
|
||
# **filter_kwargs
|
||
# ).annotate(
|
||
# # sales_count=Sum('orders_for_manager__rel_products_in_order_for_order__count',
|
||
# # output_field=FloatField()),
|
||
# # sales_sum=Sum('orders_for_manager__rel_products_in_order_for_order__product_sum_byn',
|
||
# # output_field=FloatField()),
|
||
# # paid_sum=Sum('orders_for_manager__paid_sum_byn',
|
||
# # output_field=FloatField()),
|
||
# full_name=Concat(F('last_name'), V(' '), F('first_name'))
|
||
# ).filter(
|
||
# **stat_kwargs
|
||
# ).order_by(
|
||
# 'full_name'
|
||
# ).distinct()
|
||
# # return managers
|
||
#
|
||
#
|
||
# if self.action in ('get_sales_stat_by_productid', ):
|
||
#
|
||
# filter_kwargs, stat_kwargs = get_kwargs_by_get_query_params(self.request)
|
||
# if kwargs:
|
||
# filter_kwargs.update(kwargs)
|
||
#
|
||
# managers = managers.filter(
|
||
# is_staff=True,
|
||
# orders_for_manager__status_shipment='shipped',
|
||
# orders_for_manager__defective_goods=False,
|
||
# **filter_kwargs
|
||
# ).annotate(
|
||
# # sales_count=Sum('orders_for_manager__rel_products_in_order_for_order__count',
|
||
# # output_field=FloatField()),
|
||
# # sales_sum=Sum('orders_for_manager__rel_products_in_order_for_order__product_sum_byn',
|
||
# # output_field=FloatField()),
|
||
# # paid_sum=Sum('orders_for_manager__paid_sum_byn',
|
||
# # output_field=FloatField()),
|
||
# full_name=Concat(F('last_name'), V(' '), F('first_name'))
|
||
# ).filter(
|
||
# **stat_kwargs
|
||
# ).order_by(
|
||
# 'full_name'
|
||
# ).distinct()
|
||
# return managers
|
||
# else:
|
||
# if self.request.user:
|
||
# user = self.request.user
|
||
# if user.active and not self.request.user.is_anonymus:
|
||
# managers = User.objects.filter(id=user.id)
|
||
# return managers
|
||
|
||
# return super(v1_Managers_ViewSet, self).get_queryset()
|
||
return managers
|
||
|
||
def list(self, request, *args, **kwargs):
|
||
res = check_and_get_specific_output_format(self, data=None, filename='managers_list.xlsx')
|
||
if res:
|
||
return res
|
||
|
||
res = super(v1_Managers_ViewSet, self).list(request, *args, **kwargs)
|
||
return res
|
||
|
||
@action(methods=['GET'], detail=False)
|
||
def get_all_staff(self, request, *args, **kwargs):
|
||
|
||
from ....funcs import get_all_staff
|
||
objs = get_all_staff()
|
||
serializer = self.get_serializer_class()(objs, many=True)
|
||
return Response(serializer.data)
|
||
|
||
@action(methods=['GET'], detail=False)
|
||
def get_sales_managers_only(self, request, *args, **kwargs):
|
||
|
||
from ....funcs import get_sales_managers
|
||
objs = get_sales_managers()
|
||
serializer = self.get_serializer_class()(objs, many=True)
|
||
return Response(serializer.data)
|
||
|
||
@action(methods=['GET'], detail=False)
|
||
def get_sales_department_staff(self, request, *args, **kwargs):
|
||
|
||
from ....funcs import get_sales_department_staff
|
||
objs = get_sales_department_staff()
|
||
serializer = self.get_serializer_class()(objs, many=True)
|
||
return Response(serializer.data)
|
||
|
||
@action(methods=['GET'], detail=False)
|
||
def get_sales_department_staff(self, request, *args, **kwargs):
|
||
|
||
from ....funcs import get_sales_department_staff
|
||
objs = get_sales_department_staff()
|
||
serializer = self.get_serializer_class()(objs, many=True)
|
||
return Response(serializer.data)
|
||
|
||
@action(methods=['GET'], detail=False)
|
||
def get_subordinate_staff(self, request, *args, **kwargs):
|
||
objs = None
|
||
|
||
if request.user.is_superuser:
|
||
objs = self.get_queryset()
|
||
else:
|
||
from ....funcs import get_subordinate_staff
|
||
objs = get_subordinate_staff(request.user, include_cur_user=True)
|
||
|
||
if not objs:
|
||
objs = self.get_queryset().filter(id=request.user.id)
|
||
|
||
serializer = self.get_serializer_class()(objs, many=True)
|
||
return Response(serializer.data)
|
||
|
||
@action(methods=['GET'], detail=False)
|
||
def stat_list(self, request, *args, **kwargs):
|
||
|
||
filter_kwargs, stat_kwargs = get_kwargs_by_get_query_params(request)
|
||
|
||
period_from = None
|
||
period_to = None
|
||
region_ids = None
|
||
if 'delivery_DT__gte' in filter_kwargs:
|
||
period_from = filter_kwargs['delivery_DT__gte']
|
||
if 'delivery_DT__lte' in filter_kwargs:
|
||
period_to = filter_kwargs['delivery_DT__lte']
|
||
if 'company__region__in' in filter_kwargs:
|
||
region_ids = filter_kwargs['company__region__in']
|
||
|
||
from ....stat_funcs import managers_sales_by_period_n_regions
|
||
managers, chart_Data = managers_sales_by_period_n_regions(
|
||
period_from=period_from, period_to=period_to,
|
||
region_ids=region_ids
|
||
)
|
||
|
||
if request.query_params and 'chart' in request.query_params and request.query_params[
|
||
'chart'] == 'line':
|
||
return Response(chart_Data)
|
||
else:
|
||
return Response(managers)
|
||
|
||
res = check_and_get_specific_output_format(self, data=managers, filename='managers_stat.xlsx')
|
||
if res:
|
||
return res
|
||
|
||
return Response(managers)
|
||
|
||
@action(methods=['GET'], detail=True)
|
||
def get_sales_stat_by_productid(self, request, *args, **kwargs):
|
||
from django.db.models import Sum, FloatField, F, Value as V
|
||
|
||
filter_kwargs, stat_kwargs = get_kwargs_by_get_query_params(request)
|
||
|
||
ords_kwargs = {}
|
||
|
||
ords_kwargs.update({
|
||
'enable': True,
|
||
'status_shipment': 'shipped',
|
||
'defective_goods': False,
|
||
'rel_products_in_order_for_order__product__id': kwargs['pk']
|
||
})
|
||
|
||
rec_kwargs = {
|
||
'receipt_type': 'return',
|
||
'enable': True,
|
||
}
|
||
|
||
for key, val in filter_kwargs.items():
|
||
if 'delivery_DT__gte' in key:
|
||
ords_kwargs.update({'delivery_DT__gte': val})
|
||
rec_kwargs.update({'receipt_D__gte': val})
|
||
|
||
elif 'delivery_DT__lte' in key:
|
||
ords_kwargs.update({'delivery_DT__lte': val})
|
||
rec_kwargs.update({'receipt_D__lte': val})
|
||
elif 'company__region__in' in key:
|
||
ords_kwargs.update({key: val})
|
||
rec_kwargs.update({'company__region__in': val})
|
||
else:
|
||
ords_kwargs.update({key: val})
|
||
|
||
if kwargs and 'pk' in kwargs:
|
||
rec_kwargs.update({
|
||
'rel_products_in_receipt_for_receipt__product__id': kwargs['pk']
|
||
})
|
||
|
||
# print(str(ords_kwargs))
|
||
from B2BApp.models import Order, ReceiptDocument
|
||
ords_ids = Order.objects.filter(
|
||
**ords_kwargs
|
||
).exclude(
|
||
pay_terms='no_pay'
|
||
).values_list('id', flat=True)
|
||
|
||
receipts_ids = ReceiptDocument.objects.filter(
|
||
**rec_kwargs
|
||
).values_list('id', flat=True)
|
||
|
||
managers = self.get_queryset().annotate(
|
||
full_name=Concat(F('last_name'), V(' '), F('first_name'))
|
||
# ).filter(
|
||
# **stat_kwargs
|
||
).order_by(
|
||
'full_name'
|
||
).distinct(
|
||
).values(
|
||
'id', 'full_name',
|
||
)
|
||
|
||
ord_managers = managers.filter(orders_for_manager__in=ords_ids)
|
||
|
||
recipt_managers = managers.filter(receipts_for_manager__in=receipts_ids)
|
||
|
||
managers = ord_managers.union(recipt_managers)
|
||
|
||
receipt_kwargs = {
|
||
'enable': True,
|
||
}
|
||
ord_kwargs = {
|
||
'order__enable': True,
|
||
'order__pay_terms__in': pay_terms_for_report_list,
|
||
}
|
||
for key, val in filter_kwargs.items():
|
||
if 'delivery_DT__gte' in key:
|
||
ord_kwargs.update({'order__delivery_DT__gte': val})
|
||
receipt_kwargs.update({'receipt__receipt_D__gte': val})
|
||
|
||
elif 'delivery_DT__lte' in key:
|
||
ord_kwargs.update({'order__delivery_DT__lte': val})
|
||
receipt_kwargs.update({'receipt__receipt_D__lte': val})
|
||
|
||
elif 'company__region__in' in key:
|
||
ord_kwargs.update({'order__company__region__in': val})
|
||
receipt_kwargs.update({'receipt__company__region__in': val})
|
||
|
||
ord_kwargs.update({
|
||
'product__id': kwargs['pk'],
|
||
})
|
||
|
||
receipt_kwargs.update({
|
||
'product__id': kwargs['pk'],
|
||
# 'receipt__receipt_type': 'return'
|
||
})
|
||
|
||
if managers:
|
||
managers = get_sales_for_managers_by_goods(request.user, managers, ord_kwargs, receipt_kwargs)
|
||
|
||
filename = 'managers_sales_by_product_{0}.xlsx'.format(str(kwargs['pk']))
|
||
res = check_and_get_specific_output_format(self, data=managers, filename=filename)
|
||
if res:
|
||
return res
|
||
|
||
return Response(managers)
|