def add(self, request):
data = Tools.clean_and_upper_key(request.data, 'uid')
data = Tools.clean_key(request.data, 'purchase_code')
serializer = BolBaseSr(data=data)
if serializer.is_valid(raise_exception=True):
serializer.save()
return res(serializer.data)
def change(self, request, pk=None):
obj = self.get_object(pk)
data = Tools.clean_and_upper_key(request.data, 'uid')
data = Tools.clean_key(request.data, 'purchase_code')
serializer = BolBaseSr(obj, data=data, partial=True)
if serializer.is_valid(raise_exception=True):
serializer.save()
return res(serializer.data)
def test_date_to_str(self):
input = timezone.now()
output = Tools.date_to_str(input).split('/')
self.assertEqual(Tools.date_to_str(''), '')
self.assertEqual(Tools.date_to_str(None), '')
self.assertEqual(len(output[0]), 2)
self.assertEqual(len(output[1]), 2)
self.assertEqual(len(output[2]), 4)
def match_vn(self, request):
uid = request.data.get('bol_uid', '')
bag_uid = request.data.get('bag_uid', '')
uid = Tools.remove_special_chars(uid, True)
bag_uid = Tools.remove_special_chars(bag_uid, True)
obj = get_object_or_404(Bol, uid=uid, bag__uid=bag_uid)
if not obj.vn_date:
obj.vn_date = timezone.now()
obj.save()
return res(BolBaseSr(obj).data)
def save(self, *args, **kwargs):
from .utils import CustomerUtils
if not self._state.adding:
item = Customer.objects.get(pk=self.pk)
if item.avatar and item.avatar and hasattr(item.avatar, 'url'):
if self.avatar and item.avatar != self.avatar:
Tools.remove_file(item.avatar.path, True)
super(Customer, self).save(*args, **kwargs)
CustomerUtils.ensure_roles(self)
if self.avatar and hasattr(self.avatar, 'url'):
Tools.scale_image(1, self.avatar.path)
def list(self, request):
from apps.staff.models import Staff
from apps.staff.serializers import StaffSelectSr
from apps.customer.models import Customer
from apps.customer.serializers import CustomerSelectSr
balance = 0
queryset = Transaction.objects.all()
if hasattr(request.user, 'customer'):
queryset = queryset.filter(customer=request.user.customer)
balance = TransactionUtils.get_customer_balance(request.user.customer)
queryset = self.filter_queryset(queryset)
queryset = self.paginate_queryset(queryset)
serializer = TransactionBaseSr(queryset, many=True)
result = {
'items': serializer.data,
'extra': {
'list_bank': BankBaseSr(Bank.objects.all(), many=True).data,
'list_customer': [],
'balance': balance,
'options': {
'staff': StaffSelectSr(Staff.objects.all(), many=True).data,
'customer': CustomerSelectSr(Customer.objects.all(), many=True).data
}
}
}
is_fetch_customers = Tools.string_to_bool(request.query_params.get('customers', 'False'))
if is_fetch_customers:
result['extra']['list_customer'] = CustomerUtils.get_list_for_select()
return self.get_paginated_response(result)
def get_title(self, obj):
lang = Tools.langFromContext(self.context)
if lang not in settings.LANGUAGES or lang == settings.LANGUAGES[0]:
return obj.title
translation = BannerTranslation.objects.filter(banner=obj.pk,
lang=lang).first()
return translation.title if translation.title else obj.title
def get_description(self, obj):
lang = Tools.langFromContext(self.context)
if lang not in settings.LANGUAGES:
return obj.description
translation = BannerTranslation.objects.filter(banner=obj.pk,
lang=lang).first()
return translation.description
def save(self, *args, **kwargs):
from .utils import OrderUtils
from apps.bol.utils import BolUtils
if not self._state.adding:
self = OrderUtils.check_order_for_frozen(self)
BolUtils.update_order_service(self)
if self._state.adding and self.address and not self.uid:
self.uid = OrderUtils.get_next_uid(self.address)
self.customer = self.address.customer
deposit_factor = self.customer.deposit_factor
if not deposit_factor or deposit_factor < 0 or deposit_factor > 90:
self.deposit_factor = settings.DEPOSIT_FACTOR
else:
self.deposit_factor = self.customer.deposit_factor
if self._state.adding and self.address:
customer = self.address.customer
if not self.sale:
self.sale = customer.sale
if not self.cust_care:
self.cust_care = customer.cust_care
if self.purchase_code:
self.purchase_code = self.purchase_code.strip()
self.customer = self.address.customer
if not Tools.is_testing():
self.__dict__.update(OrderUtils.cal_all(self))
super(Order, self).save(*args, **kwargs)
def create(self, validated_data):
validated_data['filetype'] = Tools.checkMime(validated_data['attachment'])
if validated_data['filetype'] == '':
raise ValidationError({'detail': 'File type not supported'})
attach = Attach(**validated_data)
attach.save()
return attach
def get_content(self, obj):
lang = Tools.langFromContext(self.context)
if lang not in settings.LANGUAGES:
return obj.content
translation = ArticleTranslation.objects.filter(article=obj.pk,
lang=lang).first()
return translation.content if translation.content else obj.content
def get_title(self, obj):
lang = self.context.get('lang', None)
if lang is None:
lang = Tools.langFromContext(self.context)
if lang not in settings.LANGUAGES or lang == settings.LANGUAGES[0]:
return obj.title
translation = CategoryTranslation.objects.filter(category=obj.pk, lang=lang).first()
return translation.title if translation.title else obj.title
def update(self, instance, validated_data):
if 'attachment' in validated_data:
validated_data['filetype'] = Tools.checkMime(validated_data['attachment'])
if validated_data['filetype'] == '':
raise ValidationError({'detail': 'File type not supported'})
instance.__dict__.update(validated_data)
instance.save()
return instance
def list(self, request):
query = self.request.GET.dict()
if 'richtext_image' in query:
query['richtext_image'] = Tools.stringToBool(
query['richtext_image'])
queryset = Attach.objects.filter(**query)
queryset = self.filter_queryset(queryset)
serializer = AttachBaseSerializer(queryset, many=True)
return Response(serializer.data)
def post(self, request, format=None):
params = self.request.data
item = self.get_object(params["username"])
user = item.user
token = Tools.getUuid()
item.reset_password_token = token
item.reset_password_tmp = make_password(params["password"])
item.reset_password_created = timezone.now()
item.save()
url = settings.BASE_URL + "admin/reset-password/" + str(token)
subject = "Rest set password for %s %s" % (user.first_name, user.last_name)
body = "Reset password confirm link: %s" % (url)
to = user.email
Tools.sendEmailAsync(subject, body, to)
return Response({})
def change_address(self, request, pk=None):
obj = get_object_or_404(Order, pk=pk)
blank, address = Tools.obj_from_pk(Address,
request.data.get('value', None))
if not blank and not address:
# Address not exist -> do nothing
serializer = OrderBaseSr(obj)
else:
serializer = OrderUtils.partial_update(obj, 'address', address.pk)
return res(serializer.data)
def change_cust_care(self, request, pk=None):
obj = get_object_or_404(Order, pk=pk)
blank, staff = Tools.obj_from_pk(Staff,
request.data.get('value', None))
if not blank and not staff:
# Staff not exist -> do nothing
serializer = OrderBaseSr(obj)
else:
serializer = OrderUtils.partial_update(obj, 'cust_care', staff.pk)
return res(serializer.data)
def save(self, *args, **kwargs):
if not self.uid:
self.uid = Tools.get_uuid()
if self.customer:
self.customer_username = self.customer.user.username
if self.staff:
self.staff_username = self.staff.user.username
if self.address:
self.address_code = self.address.uid
super(Receipt, self).save(*args, **kwargs)
def retrieve_to_print_common(receipt: models.QuerySet) -> dict:
from apps.variable.utils import VariableUtils
from apps.address.serializers import AddressBaseSr
return {
'company_info': VariableUtils.get_company_info(),
'customer': {
'fullname': Tools.get_fullname(receipt.customer),
},
'staff': {
'fullname': Tools.get_fullname(receipt.staff),
},
'address': AddressBaseSr(receipt.address).data,
'uid': receipt.uid,
'created_at': receipt.created_at,
'vnd_delivery_fee': receipt.vnd_delivery_fee,
'vnd_total': receipt.vnd_total,
'note': receipt.note
}
def mark_cn(self, request, pk=None):
obj = self.get_object(pk)
if obj.cn_date is not None:
raise ValidationError(
{"uid": "Vận đơn này đã ghi nhận về kho TQ."})
data = Tools.clean_and_upper_key(request.data, 'uid')
serializer = BolBaseSr(obj, data=data, partial=True)
if serializer.is_valid(raise_exception=True):
serializer.save()
return res(serializer.data)
def save(self, *args, **kwargs):
from .utils import TransactionUtils
self.is_assets = TransactionUtils.is_assets(self.type)
if not self.uid:
self.uid = Tools.get_uuid()
if self.customer:
self.customer_username = Tools.get_fullname(self.customer.user, True)
if self.staff:
self.staff_username = Tools.get_fullname(self.staff.user, True)
if self.order:
self.order_uid = self.order.uid
if self.bol:
self.bol_uid = self.bol.uid
self.balance = TransactionUtils.get_transaction_balance(self)
super(Transaction, self).save(*args, **kwargs)
def export_no_incomplete_order_bols(bols: models.QuerySet, ids: list) -> str:
orders_have_multiple_bols = {}
for bol in bols:
if bol.order and bol.order.order_bols.count() > 1:
orders_have_multiple_bols[str(bol.order.pk)] = bol.order
orders = orders_have_multiple_bols.values()
for order in orders:
sub_bols = [bol.pk for bol in order.order_bols.all()]
if Tools.is_semi_contain(ids, sub_bols):
return error_messages['EXPORT_INCOMPLETE_ORDER_BOLS']
return ""
def save(self, *args, **kwargs):
if not self.title:
self.title = self.attachment.path.split("/")[-1]
if not self._state.adding and self.attachment:
item = Attach.objects.get(pk=self.pk)
if not self.richtext_image:
self.richtext_image = item.richtext_image
if item.attachment != self.attachment:
# Update: remove exist attachment
removeThumbnail = False
if item.filetype == 'image':
removeThumbnail = True
Tools.removeFile(item.attachment.path, removeThumbnail)
if self.order == 0:
if Attach.objects.count() > 0:
self.order = Attach.objects.order_by(
'-order').first().order + 1
else:
self.order = 1
super(Attach, self).save(*args, **kwargs)
if self.filetype == 'image':
imageRatio = settings.IMAGE_RATIO
if self.richtext_image:
imageRatio = 0
Tools.scaleImage(settings.IMAGE_RATIO, self.attachment.path)
Tools.createThumbnail(settings.IMAGE_THUMBNAIL_WIDTH,
self.attachment.path)
def save(self, *args, **kwargs):
if not self._state.adding:
item = Article.objects.get(pk=self.pk)
if self.content == "":
self.content = item.content
if self.description == "":
self.description = item.description
if self.image and item.image and hasattr(item.image, 'url'):
print(self.image)
if item.image != self.image:
# Update: remove exist image
Tools.removeFile(item.image.path, True)
if self.order == 0:
if Article.objects.count() > 0:
self.order = Article.objects.order_by(
'-order').first().order + 1
else:
self.order = 1
super(Article, self).save(*args, **kwargs)
if self.category:
image_ratio = self.category.image_ratio
else:
image_ratio = self.article.category.image_ratio
if self.image and hasattr(self.image, 'url'):
Tools.scaleImage(image_ratio, self.image.path)
Tools.createThumbnail(settings.IMAGE_THUMBNAIL_WIDTH,
self.image.path)
def change(self, request, pk=None):
obj = get_object_or_404(Staff, pk=pk)
data = Tools.parse_user_related_data(request.data)
userSr = UserSr(obj.user, data=data['user'])
if userSr.is_valid(raise_exception=True):
userSr.save()
remain = data['remain']
remain.update({'user': obj.user_id})
serializer = StaffBaseSr(obj, data=remain)
if serializer.is_valid(raise_exception=True):
serializer.save()
return res(serializer.data)
def add(self, request):
data = Tools.parse_user_related_data(request.data)
userSr = UserSr(data=data['user'])
if userSr.is_valid(raise_exception=True):
userSr.save()
remain = data['remain']
remain.update({'user': userSr.data['id']})
serializer = StaffBaseSr(data=remain)
if serializer.is_valid(raise_exception=True):
serializer.save()
serializer.data.update({'user': userSr.data})
return res(serializer.data)
def post(self, request, format=None):
params = self.request.data
try:
item = self.get_object(params["username"])
except Staff.DoesNotExist:
return res({"url": ""})
user = item.user
token = Tools.get_uuid()
item.reset_password_token = token
item.reset_password_tmp = make_password(params["password"])
item.reset_password_created = timezone.now()
item.save()
url = settings.BASE_URL + "admin/reset-password/" + str(token)
subject = "Rest set password for %s %s" % (user.first_name,
user.last_name)
body = "Reset password confirm link: %s" % (url)
to = user.email
Tools.send_email_async(subject, body, to)
return res({"url": url})
def retrieve_to_print(self, request, pk=None):
transaction = get_object_or_404(Transaction, pk=pk)
return res({
'company_info': VariableUtils.get_company_info(),
'customer': {
'fullname': Tools.get_fullname(transaction.customer),
'address': transaction.customer.address,
},
'uid': transaction.uid,
'created_at': transaction.created_at,
'amount': transaction.amount,
'note': transaction.note
})
def test_normal_case(self):
# Recharge
recharge_amount = 500000
money_type = MoneyType.CASH
TransactionUtils.recharge(recharge_amount, money_type, self.customer, self.staff)
# Approve
OrderUtils.approve(self.order, self.staff, self.staff)
# Set status
self.order.status = Status.VN_STORE
self.order.cn_date = Tools.now()
self.order.vn_date = Tools.now()
self.order.save()
# Export
receipt = ReceiptUtils.seeding(1, True)
BolUtils.export_order_bols(self.order.order_bols.all(), receipt, self.customer, self.staff)
deposit = Transaction.objects.get(order=self.order, type=Type.DEPOSIT)
pay = Transaction.objects.get(order=self.order, type=Type.PAY)
vnd_total = OrderUtils.get_vnd_total_obj(self.order)
self.assertEqual(deposit.amount + pay.amount, vnd_total)
def change_purchase_code(self, request, pk=None):
from apps.bol.models import Bol
from apps.order.models import Status
obj = get_object_or_404(Order, pk=pk)
value = request.data.get('value', obj.purchase_code)
if value and obj.status == Status.DEBT:
obj = MoveStatusUtils.move(obj, Status.PAID)
if not value and obj.status == Status.PAID:
obj = MoveStatusUtils.move(obj, Status.DEBT)
value = Tools.remove_special_chars(value)
serializer = OrderUtils.partial_update(obj, 'purchase_code', value)
data = serializer.data
Bol.objects.filter(purchase_code=data.get('purchase_code')).update(
order=obj)
return res(data)
