583 lines
28 KiB
Python
583 lines
28 KiB
Python
from django.db import models
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django.utils import timezone
|
|
from django.contrib.auth.models import User
|
|
from django.db.models.signals import post_save
|
|
from django.dispatch import receiver
|
|
import base64
|
|
import os
|
|
from django.conf import settings as django_settings
|
|
from django.utils.translation import gettext as _
|
|
from .utils import number_to_words_en, send_whatsapp_document
|
|
from django.core.paginator import Paginator
|
|
import decimal
|
|
from django.contrib.auth.models import User, Group, Permission
|
|
from django.urls import reverse
|
|
import random
|
|
import string
|
|
from django.shortcuts import render, get_object_or_404, redirect
|
|
from django.db.models import Sum, Count, F, Q
|
|
from django.db.models.functions import TruncDate, TruncMonth
|
|
from django.http import JsonResponse, HttpResponse
|
|
from django.views.decorators.csrf import csrf_exempt
|
|
from django.contrib.auth.decorators import login_required
|
|
from .models import (
|
|
Expense, ExpenseCategory,
|
|
Product, Sale, Category, Unit, Customer, Supplier,
|
|
Purchase, PurchaseItem, PurchasePayment,
|
|
SaleItem, SalePayment, SystemSetting,
|
|
Quotation, QuotationItem,
|
|
SaleReturn, SaleReturnItem, PurchaseReturn, PurchaseReturnItem, PurchaseOrder, PurchaseOrderItem,
|
|
PaymentMethod, HeldSale, LoyaltyTier, LoyaltyTransaction,
|
|
Device, CashierCounterRegistry, CashierSession
|
|
)
|
|
import json
|
|
from datetime import timedelta
|
|
from django.utils import timezone
|
|
from django.contrib import messages
|
|
from django.utils.text import slugify
|
|
import openpyxl
|
|
import csv
|
|
from . import views_import
|
|
|
|
@login_required
|
|
def index(request):
|
|
"""
|
|
Enhanced Meezan Dashboard View
|
|
"""
|
|
total_products = Product.objects.count()
|
|
total_sales_count = Sale.objects.count()
|
|
total_sales_amount = Sale.objects.aggregate(total=Sum('total_amount'))['total'] or 0
|
|
total_customers = Customer.objects.count()
|
|
|
|
today = timezone.now().date()
|
|
expired_count = Product.objects.filter(has_expiry=True, expiry_date__lt=today, stock_quantity__gt=0).count()
|
|
|
|
low_stock_qs = Product.objects.filter(stock_quantity__lt=5)
|
|
low_stock_count = low_stock_qs.count()
|
|
low_stock_products = low_stock_qs[:5]
|
|
|
|
recent_sales = Sale.objects.order_by('-created_at').select_related('created_by')[:5]
|
|
|
|
seven_days_ago = timezone.now().date() - timedelta(days=6)
|
|
sales_over_time = Sale.objects.filter(created_at__date__gte=seven_days_ago) \
|
|
.annotate(date=TruncDate('created_at')) \
|
|
.values('date') \
|
|
.annotate(total=Sum('total_amount')) \
|
|
.order_by('date')
|
|
|
|
chart_labels = []
|
|
chart_data = []
|
|
date_dict = {s['date']: float(s['total']) for s in sales_over_time}
|
|
for i in range(7):
|
|
date = seven_days_ago + timedelta(days=i)
|
|
chart_labels.append(date.strftime('%b %d'))
|
|
chart_data.append(date_dict.get(date, 0))
|
|
|
|
six_months_ago = timezone.now().date() - timedelta(days=180)
|
|
monthly_sales_qs = Sale.objects.filter(created_at__date__gte=six_months_ago) \
|
|
.annotate(month=TruncMonth('created_at')) \
|
|
.values('month') \
|
|
.annotate(total=Sum('total_amount')) \
|
|
.order_by('month')
|
|
|
|
monthly_labels = []
|
|
monthly_data = []
|
|
for entry in monthly_sales_qs:
|
|
if entry['month']:
|
|
monthly_labels.append(entry['month'].strftime('%b %Y'))
|
|
monthly_data.append(float(entry['total']))
|
|
|
|
top_products_qs = SaleItem.objects.values('product__name_en', 'product__name_ar') \
|
|
.annotate(total_qty=Sum('quantity'), total_rev=Sum('line_total')) \
|
|
.order_by('-total_qty')[:5]
|
|
|
|
category_sales_qs = SaleItem.objects.values('product__category__name_en', 'product__category__name_ar') \
|
|
.annotate(total=Sum('line_total')) \
|
|
.order_by('-total')
|
|
|
|
category_labels = []
|
|
category_data = []
|
|
for entry in category_sales_qs:
|
|
name = entry['product__category__name_en'] or entry['product__category__name_ar'] or "Uncategorized"
|
|
category_labels.append(name)
|
|
category_data.append(float(entry['total']))
|
|
|
|
payment_stats_qs = SalePayment.objects.values('payment_method_name') \
|
|
.annotate(total=Sum('amount')) \
|
|
.order_by('-total')
|
|
|
|
payment_labels = []
|
|
payment_data = []
|
|
for entry in payment_stats_qs:
|
|
payment_labels.append(entry['payment_method_name'] or "Unknown")
|
|
payment_data.append(float(entry['total']))
|
|
|
|
context = {
|
|
'total_products': total_products,
|
|
'total_sales_count': total_sales_count,
|
|
'total_sales_amount': total_sales_amount,
|
|
'total_customers': total_customers,
|
|
'low_stock_products': low_stock_products,
|
|
'low_stock_count': low_stock_count,
|
|
'expired_count': expired_count,
|
|
'recent_sales': recent_sales,
|
|
'chart_labels': json.dumps(chart_labels),
|
|
'chart_data': json.dumps(chart_data),
|
|
'monthly_labels': json.dumps(monthly_labels),
|
|
'monthly_data': json.dumps(monthly_data),
|
|
'top_products': top_products_qs,
|
|
'category_labels': json.dumps(category_labels),
|
|
'category_data': json.dumps(category_data),
|
|
'payment_labels': json.dumps(payment_labels),
|
|
'payment_data': json.dumps(payment_data),
|
|
}
|
|
return render(request, 'core/index.html', context)
|
|
|
|
@login_required
|
|
def inventory(request):
|
|
products_list = Product.objects.all().select_related('category', 'unit', 'supplier').order_by('-created_at')
|
|
category_id = request.GET.get('category')
|
|
if category_id: products_list = products_list.filter(category_id=category_id)
|
|
search = request.GET.get('search')
|
|
if search:
|
|
products_list = products_list.filter(Q(name_en__icontains=search) | Q(name_ar__icontains=search) | Q(sku__icontains=search))
|
|
today = timezone.now().date()
|
|
expired_products = Product.objects.filter(has_expiry=True, expiry_date__lt=today, stock_quantity__gt=0)
|
|
expiring_soon_products = Product.objects.filter(has_expiry=True, expiry_date__gte=today, expiry_date__lte=today + timedelta(days=30), stock_quantity__gt=0)
|
|
paginator = Paginator(products_list, 25)
|
|
products = paginator.get_page(request.GET.get('page'))
|
|
context = {'products': products, 'categories': Category.objects.all(), 'suppliers': Supplier.objects.all(), 'units': Unit.objects.all(), 'expired_products': expired_products, 'expiring_soon_products': expiring_soon_products, 'today': today}
|
|
return render(request, 'core/inventory.html', context)
|
|
|
|
@login_required
|
|
def pos(request):
|
|
from .models import CashierSession
|
|
active_session = CashierSession.objects.filter(user=request.user, status='active').first()
|
|
if not active_session:
|
|
if hasattr(request.user, 'counter_assignment'):
|
|
messages.warning(request, _("Please open a session to start selling."))
|
|
return redirect('start_session')
|
|
settings = SystemSetting.objects.first()
|
|
products = Product.objects.filter(is_active=True)
|
|
if not settings or not settings.allow_zero_stock_sales:
|
|
products = products.filter(stock_quantity__gt=0)
|
|
customers = Customer.objects.all()
|
|
categories = Category.objects.all()
|
|
payment_methods = PaymentMethod.objects.filter(is_active=True)
|
|
if not payment_methods.exists():
|
|
PaymentMethod.objects.create(name_en="Cash", name_ar="نقدي", is_active=True)
|
|
payment_methods = PaymentMethod.objects.filter(is_active=True)
|
|
context = {'products': products, 'customers': customers, 'categories': categories, 'payment_methods': payment_methods, 'settings': settings, 'active_session': active_session}
|
|
return render(request, 'core/pos.html', context)
|
|
|
|
@csrf_exempt
|
|
@login_required
|
|
def create_sale_api(request):
|
|
if request.method == 'POST':
|
|
try:
|
|
data = json.loads(request.body)
|
|
customer_id = data.get('customer_id')
|
|
items = data.get('items', [])
|
|
total_amount = data.get('total_amount', 0)
|
|
paid_amount = data.get('paid_amount', 0)
|
|
payment_type = data.get('payment_type', 'cash')
|
|
payment_method_id = data.get('payment_method_id')
|
|
discount = data.get('discount', 0)
|
|
settings = SystemSetting.objects.first()
|
|
allow_zero_stock = settings.allow_zero_stock_sales if settings else False
|
|
customer = Customer.objects.get(id=customer_id) if customer_id else None
|
|
sale = Sale.objects.create(
|
|
customer=customer, total_amount=total_amount, paid_amount=paid_amount,
|
|
balance_due=float(total_amount) - float(paid_amount), payment_type=payment_type,
|
|
discount=discount, created_by=request.user,
|
|
status='paid' if float(paid_amount) >= float(total_amount) else ('partial' if float(paid_amount) > 0 else 'unpaid')
|
|
)
|
|
if float(paid_amount) > 0:
|
|
pm = PaymentMethod.objects.filter(id=payment_method_id).first() if payment_method_id else None
|
|
SalePayment.objects.create(sale=sale, amount=paid_amount, payment_method=pm, payment_method_name=pm.name_en if pm else "Cash", created_by=request.user)
|
|
for item in items:
|
|
product = Product.objects.get(id=item['id'])
|
|
qty = float(item['quantity'])
|
|
if not allow_zero_stock and product.stock_quantity < qty:
|
|
return JsonResponse({'success': False, 'error': f"Insufficient stock for {product.name_en}"}, status=400)
|
|
SaleItem.objects.create(sale=sale, product=product, quantity=qty, unit_price=item['price'], line_total=item['total'])
|
|
product.stock_quantity -= decimal.Decimal(qty)
|
|
product.save()
|
|
return JsonResponse({'success': True, 'sale_id': sale.id})
|
|
except Exception as e:
|
|
return JsonResponse({'success': False, 'error': str(e)}, status=400)
|
|
return JsonResponse({'success': False, 'error': 'Invalid request'}, status=405)
|
|
|
|
@login_required
|
|
def customers(request):
|
|
customers_qs = Customer.objects.all().annotate(total_sales=Sum('sales__total_amount')).order_by('name')
|
|
paginator = Paginator(customers_qs, 25)
|
|
context = {'customers': paginator.get_page(request.GET.get('page'))}
|
|
return render(request, 'core/customers.html', context)
|
|
|
|
@login_required
|
|
def suppliers(request):
|
|
suppliers_qs = Supplier.objects.all().order_by('name')
|
|
paginator = Paginator(suppliers_qs, 25)
|
|
context = {'suppliers': paginator.get_page(request.GET.get('page'))}
|
|
return render(request, 'core/suppliers.html', context)
|
|
|
|
@login_required
|
|
def purchases(request):
|
|
purchases_qs = Purchase.objects.all().select_related('supplier', 'created_by').order_by('-created_at')
|
|
paginator = Paginator(purchases_qs, 25)
|
|
return render(request, 'core/purchases.html', {'purchases': paginator.get_page(request.GET.get('page'))})
|
|
|
|
@login_required
|
|
def purchase_create(request):
|
|
return render(request, 'core/purchase_create.html', {'products': Product.objects.filter(is_active=True), 'suppliers': Supplier.objects.all(), 'payment_methods': PaymentMethod.objects.filter(is_active=True)})
|
|
|
|
@login_required
|
|
def purchase_detail(request, pk):
|
|
purchase = get_object_or_404(Purchase, pk=pk)
|
|
return render(request, 'core/purchase_detail.html', {'purchase': purchase, 'settings': SystemSetting.objects.first(), 'amount_in_words': number_to_words_en(purchase.total_amount)})
|
|
|
|
@csrf_exempt
|
|
@login_required
|
|
def create_purchase_api(request):
|
|
if request.method == 'POST':
|
|
try:
|
|
data = json.loads(request.body)
|
|
supplier_id = data.get('supplier_id')
|
|
items = data.get('items', [])
|
|
total_amount = data.get('total_amount', 0)
|
|
paid_amount = data.get('paid_amount', 0)
|
|
supplier = Supplier.objects.get(id=supplier_id) if supplier_id else None
|
|
purchase = Purchase.objects.create(
|
|
supplier=supplier, invoice_number=data.get('invoice_number', ''),
|
|
total_amount=total_amount, paid_amount=paid_amount,
|
|
balance_due=float(total_amount) - float(paid_amount), created_by=request.user,
|
|
status='paid' if float(paid_amount) >= float(total_amount) else 'partial'
|
|
)
|
|
if float(paid_amount) > 0:
|
|
PurchasePayment.objects.create(purchase=purchase, amount=paid_amount, created_by=request.user)
|
|
for item in items:
|
|
product = Product.objects.get(id=item['id'])
|
|
qty = float(item.get('quantity', 0))
|
|
cost = float(item.get('cost_price', 0))
|
|
PurchaseItem.objects.create(purchase=purchase, product=product, quantity=qty, cost_price=cost, line_total=qty * cost)
|
|
product.stock_quantity += decimal.Decimal(qty)
|
|
product.cost_price = cost
|
|
product.save()
|
|
return JsonResponse({'success': True, 'purchase_id': purchase.id})
|
|
except Exception as e:
|
|
return JsonResponse({'success': False, 'error': str(e)}, status=400)
|
|
return JsonResponse({'success': False, 'error': 'Invalid request'}, status=405)
|
|
|
|
@login_required
|
|
def reports(request):
|
|
monthly_sales = Sale.objects.annotate(month=TruncMonth('created_at')).values('month').annotate(total=Sum('total_amount')).order_by('-month')[:12]
|
|
top_products = SaleItem.objects.values('product__name_en', 'product__name_ar').annotate(total_qty=Sum('quantity'), revenue=Sum('line_total')).order_by('-total_qty')[:5]
|
|
return render(request, 'core/reports.html', {'monthly_sales': monthly_sales, 'top_products': top_products})
|
|
|
|
@login_required
|
|
def settings_view(request):
|
|
settings = SystemSetting.objects.first() or SystemSetting.objects.create()
|
|
if request.method == "POST":
|
|
if "business_name" in request.POST:
|
|
settings.business_name = request.POST.get("business_name")
|
|
settings.currency_symbol = request.POST.get("currency_symbol", "OMR")
|
|
settings.allow_zero_stock_sales = request.POST.get("allow_zero_stock_sales") == "on"
|
|
if "logo" in request.FILES: settings.logo = request.FILES["logo"]
|
|
settings.save()
|
|
messages.success(request, _("Settings updated successfully!"))
|
|
return redirect('settings')
|
|
return render(request, "core/settings.html", {"settings": settings, "payment_methods": PaymentMethod.objects.all().order_by("name_en"), "loyalty_tiers": LoyaltyTier.objects.all().order_by("min_points"), "devices": Device.objects.all().order_by("name")})
|
|
|
|
@login_required
|
|
def customer_statement(request):
|
|
customers = Customer.objects.all().order_by('name')
|
|
selected_customer = None
|
|
sales = []
|
|
customer_id = request.GET.get('customer')
|
|
if customer_id:
|
|
selected_customer = get_object_or_404(Customer, id=customer_id)
|
|
sales = Sale.objects.filter(customer=selected_customer).order_by('-created_at')
|
|
if request.GET.get('start_date'): sales = sales.filter(created_at__date__gte=request.GET.get('start_date'))
|
|
if request.GET.get('end_date'): sales = sales.filter(created_at__date__lte=request.GET.get('end_date'))
|
|
return render(request, 'core/customer_statement.html', {'customers': customers, 'selected_customer': selected_customer, 'sales': sales})
|
|
|
|
@login_required
|
|
def supplier_statement(request):
|
|
suppliers = Supplier.objects.all().order_by('name')
|
|
selected_supplier = None
|
|
purchases = []
|
|
supplier_id = request.GET.get('supplier')
|
|
if supplier_id:
|
|
selected_supplier = get_object_or_404(Supplier, id=supplier_id)
|
|
purchases = Purchase.objects.filter(supplier=selected_supplier).order_by('-created_at')
|
|
if request.GET.get('start_date'): purchases = purchases.filter(created_at__date__gte=request.GET.get('start_date'))
|
|
if request.GET.get('end_date'): purchases = purchases.filter(created_at__date__lte=request.GET.get('end_date'))
|
|
return render(request, 'core/supplier_statement.html', {'suppliers': suppliers, 'selected_supplier': selected_supplier, 'purchases': purchases})
|
|
|
|
@login_required
|
|
def cashflow_report(request):
|
|
sales = Sale.objects.all()
|
|
expenses = Expense.objects.all()
|
|
purchases = Purchase.objects.all()
|
|
if request.GET.get('start_date'):
|
|
sales = sales.filter(created_at__date__gte=request.GET.get('start_date'))
|
|
expenses = expenses.filter(date__gte=request.GET.get('start_date'))
|
|
purchases = purchases.filter(created_at__date__gte=request.GET.get('start_date'))
|
|
if request.GET.get('end_date'):
|
|
sales = sales.filter(created_at__date__lte=request.GET.get('end_date'))
|
|
expenses = expenses.filter(date__lte=request.GET.get('end_date'))
|
|
purchases = purchases.filter(created_at__date__lte=request.GET.get('end_date'))
|
|
total_sales = sales.aggregate(total=Sum('total_amount'))['total'] or 0
|
|
total_expenses = expenses.aggregate(total=Sum('amount'))['total'] or 0
|
|
total_purchases = purchases.aggregate(total=Sum('total_amount'))['total'] or 0
|
|
return render(request, 'core/cashflow_report.html', {'total_sales': total_sales, 'total_expenses': total_expenses, 'total_purchases': total_purchases, 'net_profit': total_sales - total_expenses - total_purchases})
|
|
|
|
@login_required
|
|
def invoice_list(request):
|
|
sales = Sale.objects.all().order_by('-created_at')
|
|
paginator = Paginator(sales, 25)
|
|
return render(request, 'core/invoices.html', {'sales': paginator.get_page(request.GET.get('page'))})
|
|
|
|
@login_required
|
|
def invoice_detail(request, pk):
|
|
return render(request, 'core/invoice_detail.html', {'sale': get_object_or_404(Sale, pk=pk), 'settings': SystemSetting.objects.first()})
|
|
|
|
@login_required
|
|
def invoice_create(request): return redirect('pos')
|
|
|
|
# --- STUBS & MISSING VIEWS ---
|
|
@login_required
|
|
def quotations(request): return render(request, 'core/quotations.html')
|
|
@login_required
|
|
def quotation_create(request): return redirect('quotations')
|
|
@login_required
|
|
def quotation_detail(request, pk): return redirect('quotations')
|
|
@login_required
|
|
def convert_quotation_to_invoice(request, pk): return redirect('quotations')
|
|
@login_required
|
|
def delete_quotation(request, pk): return redirect('quotations')
|
|
@csrf_exempt
|
|
def create_quotation_api(request): return JsonResponse({'success': False})
|
|
@login_required
|
|
def sales_returns(request): return render(request, 'core/sales_returns.html')
|
|
@login_required
|
|
def sale_return_create(request): return redirect('sales_returns')
|
|
@login_required
|
|
def sale_return_detail(request, pk): return redirect('sales_returns')
|
|
@login_required
|
|
def delete_sale_return(request, pk): return redirect('sales_returns')
|
|
@csrf_exempt
|
|
def create_sale_return_api(request): return JsonResponse({'success': False})
|
|
@login_required
|
|
def add_purchase_payment(request, pk): return redirect('purchases')
|
|
@login_required
|
|
def delete_purchase(request, pk): return redirect('purchases')
|
|
@login_required
|
|
def purchase_returns(request): return render(request, 'core/purchase_returns.html')
|
|
@login_required
|
|
def purchase_return_create(request): return redirect('purchase_returns')
|
|
@login_required
|
|
def purchase_return_detail(request, pk): return redirect('purchase_returns')
|
|
@login_required
|
|
def delete_purchase_return(request, pk): return redirect('purchase_returns')
|
|
@csrf_exempt
|
|
def create_purchase_return_api(request): return JsonResponse({'success': False})
|
|
@login_required
|
|
def export_expenses_excel(request): return redirect('expenses')
|
|
@csrf_exempt
|
|
def update_sale_api(request, pk): return JsonResponse({'success': False})
|
|
@csrf_exempt
|
|
def hold_sale_api(request): return JsonResponse({'success': False})
|
|
@csrf_exempt
|
|
def get_held_sales_api(request): return JsonResponse({'sales': []})
|
|
@csrf_exempt
|
|
def recall_held_sale_api(request, pk): return JsonResponse({'success': False})
|
|
@csrf_exempt
|
|
def delete_held_sale_api(request, pk): return JsonResponse({'success': False})
|
|
@login_required
|
|
def add_customer(request): return redirect('customers')
|
|
@login_required
|
|
def edit_customer(request, pk): return redirect('customers')
|
|
@login_required
|
|
def delete_customer(request, pk): return redirect('customers')
|
|
@csrf_exempt
|
|
def add_customer_ajax(request): return JsonResponse({'success': False})
|
|
@login_required
|
|
def add_supplier(request): return redirect('suppliers')
|
|
@login_required
|
|
def edit_supplier(request, pk): return redirect('suppliers')
|
|
@login_required
|
|
def delete_supplier(request, pk): return redirect('suppliers')
|
|
@csrf_exempt
|
|
def add_supplier_ajax(request): return JsonResponse({'success': False})
|
|
@login_required
|
|
def suggest_sku(request): return JsonResponse({'sku': '12345'})
|
|
@login_required
|
|
def add_category(request): return redirect('inventory')
|
|
@login_required
|
|
def edit_category(request, pk): return redirect('inventory')
|
|
@login_required
|
|
def delete_category(request, pk): return redirect('inventory')
|
|
@csrf_exempt
|
|
def add_category_ajax(request): return JsonResponse({'success': False})
|
|
@login_required
|
|
def add_unit(request): return redirect('inventory')
|
|
@login_required
|
|
def edit_unit(request, pk): return redirect('inventory')
|
|
@login_required
|
|
def delete_unit(request, pk): return redirect('inventory')
|
|
@csrf_exempt
|
|
def add_unit_ajax(request): return JsonResponse({'success': False})
|
|
@login_required
|
|
def add_payment_method(request): return redirect('settings')
|
|
@login_required
|
|
def edit_payment_method(request, pk): return redirect('settings')
|
|
@login_required
|
|
def delete_payment_method(request, pk): return redirect('settings')
|
|
@csrf_exempt
|
|
def add_payment_method_ajax(request): return JsonResponse({'success': False})
|
|
@login_required
|
|
def add_loyalty_tier(request): return redirect('settings')
|
|
@login_required
|
|
def edit_loyalty_tier(request, pk): return redirect('settings')
|
|
@login_required
|
|
def delete_loyalty_tier(request, pk): return redirect('settings')
|
|
@csrf_exempt
|
|
def get_customer_loyalty_api(request, pk): return JsonResponse({'points': 0})
|
|
@csrf_exempt
|
|
def send_invoice_whatsapp(request): return JsonResponse({'success': False})
|
|
@csrf_exempt
|
|
def group_details_api(request, pk): return JsonResponse({'users': []})
|
|
@login_required
|
|
def search_customers_api(request):
|
|
query = request.GET.get('q', '')
|
|
customers = Customer.objects.filter(Q(name__icontains=query) | Q(phone__icontains=query)).values('id', 'name', 'phone')[:10]
|
|
return JsonResponse({'results': list(customers)})
|
|
@login_required
|
|
def customer_payments(request):
|
|
payments = SalePayment.objects.select_related('sale', 'sale__customer').order_by('-payment_date', '-created_at')
|
|
paginator = Paginator(payments, 25)
|
|
return render(request, 'core/customer_payments.html', {'payments': paginator.get_page(request.GET.get('page'))})
|
|
@login_required
|
|
def customer_payment_receipt(request, pk):
|
|
payment = get_object_or_404(SalePayment, pk=pk)
|
|
return render(request, 'core/payment_receipt.html', {'payment': payment, 'settings': SystemSetting.objects.first(), 'amount_in_words': number_to_words_en(payment.amount)})
|
|
@login_required
|
|
def sale_receipt(request, pk):
|
|
return render(request, 'core/sale_receipt.html', {'sale': get_object_or_404(Sale, pk=pk), 'settings': SystemSetting.objects.first()})
|
|
@csrf_exempt
|
|
def pos_sync_update(request): return JsonResponse({'status': 'ok'})
|
|
@csrf_exempt
|
|
def pos_sync_state(request): return JsonResponse({'state': {}})
|
|
@login_required
|
|
def test_whatsapp_connection(request): return JsonResponse({'success': True, 'message': 'Connection simulation successful'})
|
|
@login_required
|
|
def add_device(request):
|
|
if request.method == 'POST':
|
|
Device.objects.create(name=request.POST.get('name'), device_type=request.POST.get('device_type'), connection_type=request.POST.get('connection_type'), ip_address=request.POST.get('ip_address'), port=request.POST.get('port'), is_active=request.POST.get('is_active') == 'on')
|
|
messages.success(request, _("Device added successfully!"))
|
|
return redirect(reverse('settings') + '#devices')
|
|
@login_required
|
|
def edit_device(request, pk):
|
|
device = get_object_or_404(Device, pk=pk)
|
|
if request.method == 'POST':
|
|
device.name = request.POST.get('name')
|
|
device.device_type = request.POST.get('device_type')
|
|
device.connection_type = request.POST.get('connection_type')
|
|
device.ip_address = request.POST.get('ip_address')
|
|
device.port = request.POST.get('port')
|
|
device.is_active = request.POST.get('is_active') == 'on'
|
|
device.save()
|
|
messages.success(request, _("Device updated successfully!"))
|
|
return redirect(reverse('settings') + '#devices')
|
|
@login_required
|
|
def delete_device(request, pk):
|
|
get_object_or_404(Device, pk=pk).delete()
|
|
messages.success(request, _("Device deleted successfully!"))
|
|
return redirect(reverse('settings') + '#devices')
|
|
@login_required
|
|
def lpo_list(request): return render(request, 'core/lpo_list.html', {'lpos': PurchaseOrder.objects.all().order_by('-created_at')})
|
|
@login_required
|
|
def lpo_create(request): return render(request, 'core/lpo_create.html', {'suppliers': Supplier.objects.all(), 'products': Product.objects.filter(is_active=True)})
|
|
@login_required
|
|
def lpo_detail(request, pk): return render(request, 'core/lpo_detail.html', {'lpo': get_object_or_404(PurchaseOrder, pk=pk), 'settings': SystemSetting.objects.first()})
|
|
@login_required
|
|
def convert_lpo_to_purchase(request, pk): return redirect('purchases')
|
|
@login_required
|
|
def lpo_delete(request, pk):
|
|
get_object_or_404(PurchaseOrder, pk=pk).delete()
|
|
return redirect('lpo_list')
|
|
@csrf_exempt
|
|
@login_required
|
|
def create_lpo_api(request): return JsonResponse({'success': True, 'lpo_id': 1})
|
|
@login_required
|
|
def cashier_registry(request): return render(request, 'core/cashier_registry.html', {'registries': CashierCounterRegistry.objects.all()})
|
|
@login_required
|
|
def cashier_session_list(request): return render(request, 'core/session_list.html', {'sessions': CashierSession.objects.all().order_by('-start_time')})
|
|
@login_required
|
|
def start_session(request):
|
|
if request.method == 'POST':
|
|
registry = CashierCounterRegistry.objects.filter(cashier=request.user).first()
|
|
CashierSession.objects.create(user=request.user, counter=registry.counter if registry else None, opening_balance=request.POST.get('opening_balance', 0), status='active')
|
|
return redirect('pos')
|
|
return render(request, 'core/start_session.html')
|
|
@login_required
|
|
def close_session(request):
|
|
session = CashierSession.objects.filter(user=request.user, status='active').first()
|
|
if request.method == 'POST' and session:
|
|
session.closing_balance = request.POST.get('closing_balance', 0)
|
|
session.notes = request.POST.get('notes', '')
|
|
session.end_time = timezone.now()
|
|
session.status = 'closed'
|
|
session.save()
|
|
return redirect('index')
|
|
return render(request, 'core/close_session.html', {'session': session})
|
|
@login_required
|
|
def session_detail(request, pk): return render(request, 'core/session_detail.html', {'session': get_object_or_404(CashierSession, pk=pk)})
|
|
@login_required
|
|
def customer_display(request): return render(request, 'core/customer_display.html')
|
|
@login_required
|
|
def add_product(request): return redirect('inventory')
|
|
@login_required
|
|
def edit_product(request, pk): return redirect('inventory')
|
|
@login_required
|
|
def delete_product(request, pk):
|
|
Product.objects.filter(pk=pk).delete()
|
|
return redirect('inventory')
|
|
@login_required
|
|
def import_products(request): return redirect('inventory')
|
|
@login_required
|
|
def barcode_labels(request): return render(request, 'core/barcode_labels.html')
|
|
@login_required
|
|
def supplier_payments(request):
|
|
payments_qs = PurchasePayment.objects.all().select_related("purchase", "purchase__supplier", "payment_method", "created_by").order_by("-payment_date", "-id")
|
|
paginator = Paginator(payments_qs, 25)
|
|
return render(request, "core/supplier_payments.html", {"payments": paginator.get_page(request.GET.get("page"))})
|
|
@login_required
|
|
def expense_report(request): return redirect('reports')
|
|
@login_required
|
|
def expense_category_delete_view(request, pk):
|
|
ExpenseCategory.objects.filter(pk=pk).delete()
|
|
return redirect('expense_categories')
|
|
@login_required
|
|
def expense_delete_view(request, pk):
|
|
Expense.objects.filter(pk=pk).delete()
|
|
return redirect('expenses')
|
|
@login_required
|
|
def expenses_view(request): return render(request, 'core/expenses.html', {'expenses': Expense.objects.all().order_by('-date')})
|
|
@login_required
|
|
def expense_create_view(request): return redirect('expenses')
|
|
@login_required
|
|
def expense_categories_view(request): return render(request, 'core/expense_categories.html')
|
|
@login_required
|
|
def user_management(request): return render(request, 'core/users.html', {'users': User.objects.all()})
|
|
@login_required
|
|
def profile_view(request): return render(request, 'core/profile.html')
|
|
@login_required
|
|
def add_sale_payment(request, pk): return redirect('invoices')
|
|
@login_required
|
|
def delete_sale(request, pk): return redirect('invoices')
|
|
@login_required
|
|
def edit_invoice(request, pk): return redirect('invoices') |