4589 lines
165 KiB
Python
4589 lines
165 KiB
Python
from django.db.models import Func
|
|
from django.contrib.auth.models import Permission
|
|
from appointment.models import Appointment,AppointmentRequest,Service,StaffMember
|
|
from datetime import timedelta
|
|
from calendar import month_name
|
|
from random import randint
|
|
from django_tables2 import SingleTableView
|
|
from django_tables2.export.views import ExportMixin
|
|
from django_pdf_actions.actions import export_to_pdf_landscape
|
|
from plans.quota import get_user_quota
|
|
from reportlab.lib.pagesizes import landscape, A4
|
|
from rich import print
|
|
from decimal import Decimal
|
|
from django.core.paginator import Paginator
|
|
from django.forms import DateField, DateInput, HiddenInput, TextInput
|
|
from django_ledger.forms.bill import (
|
|
ApprovedBillModelUpdateForm,
|
|
InReviewBillModelUpdateForm,
|
|
)
|
|
from django.utils.decorators import method_decorator
|
|
from django.views.decorators.csrf import csrf_exempt
|
|
from django_ledger.models import (
|
|
ItemTransactionModel,
|
|
EntityModel,
|
|
InvoiceModel,
|
|
BankAccountModel,
|
|
AccountModel,
|
|
JournalEntryModel,
|
|
TransactionModel,
|
|
EstimateModel,
|
|
CustomerModel,
|
|
LedgerModel,
|
|
ItemModel,
|
|
BillModel,
|
|
VendorModel,
|
|
)
|
|
from django_ledger.forms.bank_account import (
|
|
BankAccountCreateForm,
|
|
BankAccountUpdateForm,
|
|
)
|
|
|
|
from django_ledger.forms.customer import CustomerModelForm
|
|
from django_ledger.forms.bill import BillModelCreateForm
|
|
from django_ledger.forms.invoice import (
|
|
DraftInvoiceModelUpdateForm,
|
|
ApprovedInvoiceModelUpdateForm,
|
|
PaidInvoiceModelUpdateForm,
|
|
)
|
|
from django_ledger.forms.account import AccountModelCreateForm, AccountModelUpdateForm
|
|
# from django_ledger.forms.estimate import EstimateModelCreateForm
|
|
|
|
from django_ledger.forms.invoice import InvoiceModelCreateForm
|
|
from django_ledger.forms.item import (
|
|
ServiceCreateForm,
|
|
ExpenseItemCreateForm,
|
|
ExpenseItemUpdateForm,
|
|
)
|
|
from django_ledger.forms.journal_entry import JournalEntryModelCreateForm
|
|
from django_ledger.io import roles
|
|
from django.contrib.admin.models import LogEntry
|
|
import logging
|
|
import json
|
|
import datetime
|
|
from django.db.models.functions import Coalesce
|
|
from django.shortcuts import HttpResponse
|
|
from django.contrib.auth.mixins import LoginRequiredMixin
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.http import JsonResponse
|
|
from django.shortcuts import render, get_object_or_404, redirect
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django.db.models import Q
|
|
from django.views.generic import (
|
|
View,
|
|
ListView,
|
|
DetailView,
|
|
CreateView,
|
|
UpdateView,
|
|
DeleteView,
|
|
TemplateView,
|
|
)
|
|
from django.utils import timezone, translation
|
|
from django.conf import settings
|
|
from urllib.parse import urlparse, urlunparse
|
|
from django.urls import reverse, reverse_lazy
|
|
from django.contrib import messages
|
|
from django.db.models import Sum, F, Count
|
|
from django.db import transaction
|
|
from twilio.rest.verify.v2 import form
|
|
|
|
from .forms import VendorForm
|
|
from .services import (
|
|
decodevin,
|
|
get_make,
|
|
get_model,
|
|
)
|
|
from . import models, forms, tables
|
|
from django.contrib.auth.mixins import PermissionRequiredMixin
|
|
from django.contrib.messages.views import SuccessMessageMixin
|
|
from django.contrib.auth.models import Group
|
|
from .utils import (
|
|
CarFinanceCalculator,
|
|
calculate_vat_amount,
|
|
get_calculations,
|
|
get_car_finance_data,
|
|
get_financial_values,
|
|
get_item_transactions,
|
|
reserve_car,
|
|
send_email,
|
|
get_user_type,
|
|
set_bill_payment,
|
|
set_invoice_payment,
|
|
to_dict,
|
|
CarTransfer,
|
|
)
|
|
from django.contrib.auth.models import User
|
|
from allauth.account import views as allauth_views
|
|
from django.db.models import Count, F, Value
|
|
from django.contrib.auth import authenticate
|
|
import cv2
|
|
import numpy as np
|
|
from pyzbar.pyzbar import decode
|
|
from django.core.files.storage import default_storage
|
|
from plans.models import Plan,PlanPricing
|
|
from django_ledger.utils import accruable_net_summary
|
|
from appointment.views_admin import fetch_user_appointments
|
|
from django_ledger.views.financial_statement import (
|
|
FiscalYearBalanceSheetView,
|
|
BaseIncomeStatementRedirectView,
|
|
FiscalYearIncomeStatementView,
|
|
BaseCashFlowStatementRedirectView,
|
|
FiscalYearCashFlowStatementView,
|
|
)
|
|
from django_ledger.views.entity import EntityModelDetailBaseView,EntityModelDetailHandlerView
|
|
from django.views.generic import DetailView, RedirectView
|
|
|
|
from django_ledger.io.io_core import get_localdate
|
|
from django_ledger.models import EntityModel, EntityUnitModel
|
|
from django_ledger.views.mixins import (
|
|
QuarterlyReportMixIn,
|
|
YearlyReportMixIn,
|
|
MonthlyReportMixIn,
|
|
DateReportMixIn,
|
|
DjangoLedgerSecurityMixIn,
|
|
EntityUnitMixIn,
|
|
BaseDateNavigationUrlMixIn,
|
|
PDFReportMixIn,
|
|
)
|
|
from django_pdf_actions import actions
|
|
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
logging.basicConfig(level=logging.INFO)
|
|
|
|
|
|
|
|
class Hash(Func):
|
|
function = 'get_hash'
|
|
|
|
|
|
def switch_language(request):
|
|
language = request.GET.get("language", "en")
|
|
referer = request.META.get("HTTP_REFERER", "/")
|
|
parsed_url = urlparse(referer)
|
|
path_parts = parsed_url.path.split("/")
|
|
|
|
if path_parts[1] in dict(settings.LANGUAGES):
|
|
path_parts.pop(1)
|
|
|
|
new_path = "/".join(path_parts)
|
|
new_url = urlunparse(
|
|
(
|
|
parsed_url.scheme,
|
|
parsed_url.netloc,
|
|
new_path,
|
|
parsed_url.params,
|
|
parsed_url.query,
|
|
parsed_url.fragment,
|
|
)
|
|
)
|
|
|
|
if language in dict(settings.LANGUAGES):
|
|
logger.debug(f"Switching language to: {language}")
|
|
response = redirect(new_url)
|
|
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, language)
|
|
translation.activate(language)
|
|
request.session[settings.LANGUAGE_COOKIE_NAME] = language
|
|
logger.debug(
|
|
f"Language switched to: {language}, Session: {request.session[settings.LANGUAGE_COOKIE_NAME]}"
|
|
)
|
|
return response
|
|
else:
|
|
logger.warning(f"Invalid language code: {language}")
|
|
return redirect("/")
|
|
|
|
|
|
def dealer_signup(request, *args, **kwargs):
|
|
form1 = forms.WizardForm1()
|
|
form2 = forms.WizardForm2()
|
|
form3 = forms.WizardForm3()
|
|
|
|
if request.method == "POST":
|
|
if "Hx-Request" in request.headers:
|
|
form1 = forms.WizardForm1(request.POST)
|
|
return render(request,"account/signup-wizard.html",{"form1": form1, "form2": form2, "form3": form3})
|
|
|
|
data = json.loads(request.body)
|
|
wf1 = data.get("wizardValidationForm1")
|
|
wf2 = data.get("wizardValidationForm2")
|
|
wf3 = data.get("wizardValidationForm3")
|
|
email = wf1.get("email")
|
|
password = wf1.get("password")
|
|
password_confirm = wf1.get("confirm_password")
|
|
name = wf2.get("name")
|
|
arabic_name = wf2.get("arabic_name")
|
|
phone = wf2.get("phone_number")
|
|
crn = wf3.get("crn")
|
|
vrn = wf3.get("vrn")
|
|
address = wf3.get("address")
|
|
|
|
if password != password_confirm:
|
|
return JsonResponse({"error": "Passwords do not match."}, status=400)
|
|
|
|
try:
|
|
with transaction.atomic():
|
|
user = User.objects.create(username=email, email=email)
|
|
user.set_password(password)
|
|
user.save()
|
|
|
|
models.Dealer.objects.create(
|
|
user=user,
|
|
name=name,
|
|
arabic_name=arabic_name,
|
|
crn=crn,
|
|
vrn=vrn,
|
|
phone_number=phone,
|
|
address=address,
|
|
)
|
|
return JsonResponse(
|
|
{"message": "User created successfully."}, status=200
|
|
)
|
|
except Exception as e:
|
|
return JsonResponse({"error": str(e)}, status=400)
|
|
return render(request,"account/signup-wizard.html",{"form1": form1, "form2": form2, "form3": form3})
|
|
|
|
|
|
# class OTPView(View, LoginRequiredMixin):
|
|
# template_name = "account/otp_verification.html"
|
|
#
|
|
# def get(self, request, *args, **kwargs):
|
|
# # device = default_device(request.user)
|
|
# # device.generate_challenge()
|
|
# return render(request, self.template_name)
|
|
#
|
|
# def post(self, request, *args, **kwargs):
|
|
# otp_code = request.POST.get("otp_code")
|
|
#
|
|
# if self.verify_otp(otp_code, request.user):
|
|
# messages.success(request, _("OTP verified successfully!"))
|
|
# return redirect("home")
|
|
#
|
|
# messages.error(request, _("Invalid OTP. Please try again."))
|
|
# return render(request, self.template_name)
|
|
|
|
# def verify_otp(self, otp_code, user):
|
|
# device = default_device(user)
|
|
# if device and device.verify_token(otp_code):
|
|
# return True
|
|
# return False
|
|
|
|
|
|
class HomeView(TemplateView):
|
|
template_name = "index.html"
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
# Redirect unauthenticated users to the welcome page
|
|
if not request.user.is_authenticated:
|
|
return redirect("welcome")
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
dealer = get_user_type(self.request)
|
|
|
|
try:
|
|
# Fetch car-related statistics
|
|
total_cars = models.Car.objects.filter(dealer=dealer).count()
|
|
total_reservations = models.CarReservation.objects.filter(
|
|
reserved_until__gte=timezone.now()
|
|
).count()
|
|
cars_in_house = models.CarLocation.objects.filter(
|
|
owner=dealer,
|
|
).count()
|
|
cars_outside = total_cars - cars_in_house
|
|
|
|
# Fetch financial statistics
|
|
stats = models.CarFinance.objects.aggregate(
|
|
total_cost_price=Sum("cost_price"),
|
|
total_selling_price=Sum("selling_price"),
|
|
)
|
|
total_cost_price = stats.get("total_cost_price", 0) or 0
|
|
total_selling_price = stats.get("total_selling_price", 0) or 0
|
|
total_profit = total_selling_price - total_cost_price
|
|
|
|
# Prepare context data
|
|
context.update({
|
|
"dealer": dealer,
|
|
"total_cars": total_cars,
|
|
"cars_in_house": cars_in_house,
|
|
"cars_outside": cars_outside,
|
|
"total_reservations": total_reservations,
|
|
"total_cost_price": total_cost_price,
|
|
"total_selling_price": total_selling_price,
|
|
"total_profit": total_profit,
|
|
})
|
|
|
|
except Exception as e:
|
|
# Log the error (you can use Django's logging framework)
|
|
print(f"Error fetching data: {e}")
|
|
# Provide default values in case of an error
|
|
context.update({
|
|
"dealer": dealer,
|
|
"total_cars": 0,
|
|
"cars_in_house": 0,
|
|
"cars_outside": 0,
|
|
"total_reservations": 0,
|
|
"total_cost_price": 0,
|
|
"total_selling_price": 0,
|
|
"total_profit": 0,
|
|
})
|
|
|
|
return context
|
|
|
|
class TestView(TemplateView):
|
|
template_name = "inventory/cars_list_api.html"
|
|
|
|
|
|
class ManagerDashboard(LoginRequiredMixin, TemplateView):
|
|
template_name = "dashboards/manager.html"
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
if (
|
|
# not any(hasattr(request.user, attr) for attr in ["dealer", "subdealer"])
|
|
not request.user.is_authenticated
|
|
):
|
|
# messages.error(request, _("You are not associated with any dealer."))
|
|
return redirect("welcome")
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
dealer = get_user_type(self.request)
|
|
total_cars = models.Car.objects.filter(dealer=dealer).count()
|
|
total_reservations = models.CarReservation.objects.filter(
|
|
reserved_until__gte=timezone.now()
|
|
).count()
|
|
stats = models.CarFinance.objects.aggregate(
|
|
total_cost_price=Sum("cost_price"),
|
|
total_selling_price=Sum("selling_price"),
|
|
)
|
|
total_cost_price = stats["total_cost_price"] or 0
|
|
total_selling_price = stats["total_selling_price"] or 0
|
|
total_profit = total_selling_price - total_cost_price
|
|
|
|
context["dealer"] = dealer
|
|
context["total_cars"] = total_cars
|
|
context["total_reservations"] = total_reservations
|
|
context["total_cost_price"] = total_cost_price
|
|
context["total_selling_price"] = total_selling_price
|
|
context["total_profit"] = total_profit
|
|
return context
|
|
|
|
|
|
class WelcomeView(TemplateView):
|
|
template_name = "welcome.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
dealer = get_user_type(self.request)
|
|
plan_list = Plan.objects.all()
|
|
# pricing = PlanPricing.objects.filter(plan=plan).
|
|
context["plan_list"] = plan_list
|
|
return context
|
|
|
|
|
|
class CarCreateView(LoginRequiredMixin, CreateView):
|
|
model = models.Car
|
|
form_class = forms.CarForm
|
|
template_name = "inventory/car_form.html"
|
|
|
|
# success_url = reverse_lazy('inventory_stats')
|
|
|
|
def get_form(self, form_class=None):
|
|
form = super().get_form(form_class)
|
|
dealer = get_user_type(self.request)
|
|
form.fields["vendor"].queryset = dealer.entity.get_vendors().filter(active=True)
|
|
return form
|
|
|
|
def get_success_url(self):
|
|
"""Determine the redirect URL based on user choice."""
|
|
if self.request.POST.get("add_another"):
|
|
return reverse("car_add")
|
|
return reverse("inventory_stats")
|
|
|
|
def form_valid(self, form):
|
|
dealer = get_user_type(self.request)
|
|
form.instance.dealer = dealer
|
|
form.save()
|
|
messages.success(self.request, "Car saved successfully.")
|
|
return super().form_valid(form)
|
|
|
|
def car_history(request,pk):
|
|
car = get_object_or_404(models.Car, pk=pk)
|
|
activities = models.Activity.objects.filter(content_type__model="car", object_id=car.id)
|
|
return render(request,'inventory/car_history.html',{"car":car,"activities":activities})
|
|
|
|
class AjaxHandlerView(LoginRequiredMixin, View):
|
|
def get(self, request, *args, **kwargs):
|
|
action = request.GET.get("action")
|
|
handlers = {
|
|
"decode_vin": self.decode_vin,
|
|
"get_models": self.get_models,
|
|
"get_series": self.get_series,
|
|
"get_trims": self.get_trims,
|
|
"get_specifications": self.get_specifications,
|
|
"get_equipments": self.get_equipments,
|
|
"get_options": self.get_options,
|
|
}
|
|
handler = handlers.get(action)
|
|
if handler:
|
|
return handler(request)
|
|
else:
|
|
return JsonResponse({"error": "Invalid action"}, status=400)
|
|
|
|
def decode_vin(self, request):
|
|
vin_no = request.GET.get("vin_no")
|
|
car_existed = models.Car.objects.filter(vin=vin_no).exists()
|
|
|
|
if car_existed:
|
|
return JsonResponse({"error": _("VIN number exists")}, status=400)
|
|
|
|
if not vin_no or len(vin_no.strip()) != 17:
|
|
return JsonResponse(
|
|
{"success": False, "error": "Invalid VIN number provided."}, status=400
|
|
)
|
|
|
|
vin_no = vin_no.strip()
|
|
vin_data = {}
|
|
decoding_method = ""
|
|
|
|
# manufacturer_name = model_name = year_model = None
|
|
if not (result := decodevin(vin_no)):
|
|
return JsonResponse(
|
|
{"success": False, "error": "VIN not found in all sources."}, status=404
|
|
)
|
|
|
|
manufacturer_name, model_name, year_model = result.values()
|
|
make = get_make(manufacturer_name)
|
|
model = get_model(model_name, make)
|
|
|
|
logger.info(
|
|
f"VIN decoded using {decoding_method}: Make={manufacturer_name}, Model={model_name}, Year={year_model}"
|
|
)
|
|
car_model = model
|
|
car_make = make
|
|
|
|
if not car_make:
|
|
return JsonResponse(
|
|
{"success": False, "error": "Manufacturer not found in the database."},
|
|
status=404,
|
|
)
|
|
vin_data["make_id"] = car_make.id_car_make
|
|
vin_data["name"] = car_make.name
|
|
vin_data["arabic_name"] = car_make.arabic_name
|
|
|
|
if not car_model:
|
|
vin_data["model_id"] = ""
|
|
else:
|
|
vin_data["model_id"] = car_model.id_car_model
|
|
vin_data["year"] = year_model
|
|
return JsonResponse({"success": True, "data": vin_data})
|
|
|
|
def get_models(self, request):
|
|
make_id = request.GET.get("make_id")
|
|
car_models = (
|
|
models.CarModel.objects.filter(id_car_make=make_id)
|
|
.values("id_car_model", "name", "arabic_name")
|
|
.order_by("name")
|
|
)
|
|
return JsonResponse(list(car_models), safe=False)
|
|
|
|
def get_series(self, request):
|
|
model_id = request.GET.get("model_id")
|
|
year = request.GET.get("year")
|
|
|
|
model_id = int(model_id)
|
|
year = int(year)
|
|
|
|
query = Q(id_car_model=model_id) & (
|
|
Q(year_begin__lte=year, year_end__gte=year) |
|
|
Q(year_end__isnull=True) |
|
|
Q(year_begin__isnull=True)
|
|
)
|
|
try:
|
|
series = models.CarSerie.objects.filter(query).values(
|
|
"id_car_serie",
|
|
"name",
|
|
"arabic_name",
|
|
"generation_name"
|
|
)
|
|
except Exception as e:
|
|
return JsonResponse({"error": "Server error occurred"}, status=500)
|
|
return JsonResponse(list(series), safe=False)
|
|
|
|
def get_trims(self, request):
|
|
serie_id = request.GET.get("serie_id")
|
|
# model_id = request.GET.get('model_id')
|
|
trims = models.CarTrim.objects.filter(id_car_serie=serie_id).values(
|
|
"id_car_trim", "name", "arabic_name"
|
|
)
|
|
return JsonResponse(list(trims), safe=False)
|
|
|
|
def get_specifications(self, request):
|
|
trim_id = request.GET.get("trim_id")
|
|
car_spec_values = models.CarSpecificationValue.objects.filter(
|
|
id_car_trim=trim_id
|
|
)
|
|
lang = translation.get_language()
|
|
specs_by_parent = {}
|
|
for value in car_spec_values:
|
|
specification = value.id_car_specification
|
|
parent = specification.id_parent
|
|
parent_id = parent.id_car_specification if parent else 0
|
|
if lang == "ar":
|
|
parent_name = parent.arabic_name if parent else "Root"
|
|
else:
|
|
parent_name = parent.name if parent else "Root"
|
|
if parent_id not in specs_by_parent:
|
|
specs_by_parent[parent_id] = {
|
|
"parent_name": parent_name,
|
|
"specifications": [],
|
|
}
|
|
spec_data = {
|
|
"specification_id": specification.id_car_specification,
|
|
"s_name": specification.arabic_name
|
|
if lang == "ar"
|
|
else specification.name,
|
|
"s_value": value.value,
|
|
"s_unit": value.unit if value.unit else "",
|
|
"trim_name": value.id_car_trim.name,
|
|
}
|
|
specs_by_parent[parent_id]["specifications"].append(spec_data)
|
|
serialized_specs = [
|
|
{"parent_name": v["parent_name"], "specifications": v["specifications"]}
|
|
for v in specs_by_parent.values()
|
|
]
|
|
return JsonResponse(serialized_specs, safe=False)
|
|
|
|
def get_equipments(self, request):
|
|
trim_id = request.GET.get("trim_id")
|
|
equipments = (
|
|
models.CarEquipment.objects.filter(id_car_trim=trim_id)
|
|
.values("id_car_equipment", "name")
|
|
.order_by("name")
|
|
)
|
|
return JsonResponse(list(equipments), safe=False)
|
|
|
|
def get_options(self, request):
|
|
equipment_id = request.GET.get("equipment_id")
|
|
car_option_values = models.CarOptionValue.objects.filter(
|
|
id_car_equipment=equipment_id
|
|
)
|
|
|
|
options_by_parent = {}
|
|
for value in car_option_values:
|
|
option = value.id_car_option
|
|
parent = option.id_parent
|
|
parent_id = parent.id_car_option if parent else 0
|
|
parent_name = parent.name if parent else "Root"
|
|
if parent_id not in options_by_parent:
|
|
options_by_parent[parent_id] = {
|
|
"parent_name": parent_name,
|
|
"options": [],
|
|
}
|
|
option_data = {
|
|
"option_id": option.id_car_option,
|
|
"option_name": option.name,
|
|
"is_base": value.is_base,
|
|
"equipment_name": value.id_car_equipment.name,
|
|
}
|
|
options_by_parent[parent_id]["options"].append(option_data)
|
|
serialized_options = [
|
|
{"parent_name": v["parent_name"], "options": v["options"]}
|
|
for v in options_by_parent.values()
|
|
]
|
|
return JsonResponse(serialized_options, safe=False)
|
|
|
|
|
|
@method_decorator(csrf_exempt, name="dispatch")
|
|
class SearchCodeView(View):
|
|
template_name = "inventory/scan_vin.html"
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
"""Render the form page."""
|
|
return render(request, self.template_name)
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
image_file = request.FILES.get("image")
|
|
|
|
if image_file:
|
|
print("image received!")
|
|
image = cv2.imdecode(
|
|
np.frombuffer(image_file.read(), np.uint8), cv2.IMREAD_COLOR
|
|
)
|
|
decoded_objects = decode(image)
|
|
if decoded_objects:
|
|
print("image decoded!")
|
|
print(decoded_objects[0])
|
|
code = decoded_objects[0].data.decode("utf-8")
|
|
print("code received!")
|
|
print(code)
|
|
car = get_object_or_404(models.Car, vin=code)
|
|
name = car.id_car_make.get_local_name
|
|
print(name)
|
|
return redirect("car_detail", pk=car.pk)
|
|
else:
|
|
print("back to else statement")
|
|
return JsonResponse({"success": False, "error": "No code detected"})
|
|
else:
|
|
return JsonResponse({"success": False, "error": "No image provided"})
|
|
|
|
|
|
class CarInventory(LoginRequiredMixin, ListView):
|
|
model = models.Car
|
|
home_label = _("inventory")
|
|
template_name = "inventory/car_inventory.html"
|
|
context_object_name = "cars"
|
|
paginate_by = 10
|
|
ordering = ["receiving_date"]
|
|
|
|
def get_queryset(self, *args, **kwargs):
|
|
query = self.request.GET.get("q")
|
|
make_id = self.kwargs["make_id"]
|
|
model_id = self.kwargs["model_id"]
|
|
trim_id = self.kwargs["trim_id"]
|
|
|
|
dealer = get_user_type(self.request)
|
|
cars = models.Car.objects.filter(
|
|
dealer=dealer,
|
|
id_car_make=make_id,
|
|
id_car_model=model_id,
|
|
id_car_trim=trim_id,
|
|
).order_by("receiving_date")
|
|
|
|
return apply_search_filters(cars, query)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["query"] = self.request.GET.get("q", "")
|
|
context["make_id"] = self.kwargs["make_id"]
|
|
context["model_id"] = self.kwargs["model_id"]
|
|
context["trim_id"] = self.kwargs["trim_id"]
|
|
return context
|
|
|
|
|
|
class CarColorCreate(LoginRequiredMixin, CreateView):
|
|
model = models.CarColors
|
|
form_class = forms.CarColorsForm
|
|
template_name = "inventory/add_colors.html"
|
|
|
|
def form_valid(self, form):
|
|
car = get_object_or_404(models.Car, pk=self.kwargs["car_pk"])
|
|
form.instance.car = car
|
|
return super().form_valid(form)
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("car_detail", kwargs={"pk": self.kwargs["car_pk"]})
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["car"] = get_object_or_404(models.Car, pk=self.kwargs["car_pk"])
|
|
return context
|
|
|
|
class CarListView(LoginRequiredMixin, ListView):
|
|
model = models.Car
|
|
template_name = "inventory/car_list_view.html"
|
|
context_object_name = "cars"
|
|
paginate_by = 20
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
dealer = get_user_type(self.request)
|
|
cars = models.Car.objects.filter(dealer=dealer).order_by("receiving_date")
|
|
|
|
context["stats"] = {
|
|
'all': cars.count(),
|
|
'available':cars.filter(status='available').count(),
|
|
'reserved':cars.filter(status='reserved').count(),
|
|
'sold':cars.filter(status='sold').count(),
|
|
'transfer':cars.filter(status='transfer').count()
|
|
}
|
|
context['make'] = models.CarMake.objects.filter(car__in=cars).distinct()
|
|
context['model'] = models.CarModel.objects.none()
|
|
context['year'] = models.Car.objects.none()
|
|
make = self.request.GET.get('make')
|
|
model = self.request.GET.get('model')
|
|
|
|
if make:
|
|
make_ = models.CarMake.objects.get(id_car_make=int(make))
|
|
context['model'] = make_.carmodel_set.filter(car__in=cars).distinct()
|
|
if make and model:
|
|
make_ = models.CarMake.objects.get(id_car_make=int(make))
|
|
model_ = models.CarModel.objects.get(id_car_model=int(model))
|
|
context['year'] = models.Car.objects.filter(id_car_make=make_,id_car_model=model_).values_list('year').distinct()
|
|
return context
|
|
def get_queryset(self):
|
|
dealer = get_user_type(self.request)
|
|
qs = super().get_queryset()
|
|
qs = qs.filter(dealer=dealer)
|
|
status = self.request.GET.get('status')
|
|
search = self.request.GET.get('search')
|
|
make = self.request.GET.get('make',None)
|
|
model = self.request.GET.get('model',None)
|
|
year = self.request.GET.get('year',None)
|
|
car_status = self.request.GET.get('car_status',None)
|
|
|
|
if status:
|
|
qs=qs.filter(status=status)
|
|
if search:
|
|
query = Q(vin__icontains=search)|Q(id_car_make__name__icontains=search)|Q(id_car_model__name__icontains=search)|Q(id_car_trim__name__icontains=search)|Q(vin=search)
|
|
qs=qs.filter(query)
|
|
if any([make, model, year, car_status]):
|
|
query = Q()
|
|
if make:
|
|
query &= Q(id_car_make=int(make))
|
|
if model:
|
|
query &= Q(id_car_model=model)
|
|
if year:
|
|
query &= Q(year=year)
|
|
if car_status:
|
|
query &= Q(status=car_status)
|
|
qs = qs.filter(query)
|
|
return qs
|
|
|
|
@login_required
|
|
def inventory_stats_view(request):
|
|
dealer = get_user_type(request)
|
|
|
|
# Base queryset for cars belonging to the dealer
|
|
cars = models.Car.objects.filter(dealer=dealer)
|
|
|
|
# Count for total, reserved, showroom, and unreserved cars
|
|
total_cars = cars.count()
|
|
reserved_cars = models.CarReservation.objects.count()
|
|
# showroom_cars = cars.filter(location='showroom').count()
|
|
# unreserved_cars = total_cars - reserved_cars
|
|
|
|
# Annotate total cars by make, model, and trim
|
|
cars = cars.select_related("id_car_make", "id_car_model", "id_car_trim").annotate(
|
|
make_total=Count("id_car_make"),
|
|
model_total=Count("id_car_model"),
|
|
trim_total=Count("id_car_trim"),
|
|
)
|
|
|
|
inventory = {}
|
|
for car in cars:
|
|
make = car.id_car_make
|
|
if make.id_car_make not in inventory:
|
|
inventory[make.id_car_make] = {
|
|
"make_id": make.id_car_make,
|
|
"make_name": make.get_local_name(),
|
|
"total_cars": 0,
|
|
"models": {},
|
|
}
|
|
inventory[make.id_car_make]["total_cars"] += 1
|
|
|
|
model = car.id_car_model
|
|
if model and model.id_car_model not in inventory[make.id_car_make]["models"]:
|
|
inventory[make.id_car_make]["models"][model.id_car_model] = {
|
|
"model_id": model.id_car_model,
|
|
"model_name": model.get_local_name(),
|
|
"total_cars": 0,
|
|
"trims": {},
|
|
}
|
|
try:
|
|
inventory[make.id_car_make]["models"][model.id_car_model]["total_cars"] += 1
|
|
|
|
trim = car.id_car_trim
|
|
if (
|
|
trim
|
|
and trim.id_car_trim
|
|
not in inventory[make.id_car_make]["models"][model.id_car_model][
|
|
"trims"
|
|
]
|
|
):
|
|
inventory[make.id_car_make]["models"][model.id_car_model]["trims"][
|
|
trim.id_car_trim
|
|
] = {
|
|
"trim_id": trim.id_car_trim,
|
|
"trim_name": trim.name,
|
|
"total_cars": 0,
|
|
}
|
|
inventory[make.id_car_make]["models"][model.id_car_model]["trims"][
|
|
trim.id_car_trim
|
|
]["total_cars"] += 1
|
|
except Exception as e:
|
|
print(e)
|
|
result = {
|
|
"total_cars": total_cars,
|
|
"reserved_cars": reserved_cars,
|
|
"makes": [
|
|
{
|
|
"make_id": make_data["make_id"],
|
|
"make_name": make_data["make_name"],
|
|
"total_cars": make_data["total_cars"],
|
|
"models": [
|
|
{
|
|
"model_id": model_data["model_id"],
|
|
"model_name": model_data["model_name"],
|
|
"total_cars": model_data["total_cars"],
|
|
"trims": list(model_data["trims"].values()),
|
|
}
|
|
for model_data in make_data["models"].values()
|
|
],
|
|
}
|
|
for make_data in inventory.values()
|
|
],
|
|
}
|
|
|
|
return render(request, "inventory/inventory_stats.html", {"inventory": result})
|
|
|
|
|
|
class CarDetailView(LoginRequiredMixin, DetailView):
|
|
model = models.Car
|
|
template_name = "inventory/car_detail.html"
|
|
context_object_name = "car"
|
|
|
|
|
|
class CarFinanceCreateView(LoginRequiredMixin, CreateView):
|
|
model = models.CarFinance
|
|
form_class = forms.CarFinanceForm
|
|
template_name = "inventory/car_finance_form.html"
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.car = get_object_or_404(models.Car, pk=self.kwargs["car_pk"])
|
|
return super().dispatch(request, *args, **kwargs)
|
|
|
|
def form_valid(self, form):
|
|
form.instance.car = self.car
|
|
messages.success(self.request, _("Car finance details saved successfully."))
|
|
return super().form_valid(form)
|
|
|
|
def get_success_url(self):
|
|
return reverse("car_detail", kwargs={"pk": self.car.pk})
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["car"] = self.car
|
|
return context
|
|
|
|
def get_form(self, form_class=None):
|
|
form = super().get_form(form_class)
|
|
dealer = get_user_type(self.request)
|
|
form.fields[
|
|
"additional_finances"
|
|
].queryset = models.AdditionalServices.objects.filter(dealer=dealer)
|
|
return form
|
|
|
|
# def get_initial(self):
|
|
# initial = super().get_initial()
|
|
# instance = self.get_object()
|
|
# dealer = get_user_type(self.request.user.dealer)
|
|
# selected_items = instance.additional_services.filter(dealer=dealer)
|
|
# initial["additional_finances"] = selected_items
|
|
# return initial
|
|
|
|
|
|
class CarFinanceUpdateView(LoginRequiredMixin, SuccessMessageMixin, UpdateView):
|
|
model = models.CarFinance
|
|
form_class = forms.CarFinanceForm
|
|
template_name = "inventory/car_finance_form.html"
|
|
success_message = _("Car finance details updated successfully.")
|
|
|
|
def get_success_url(self):
|
|
return reverse("car_detail", kwargs={"pk": self.object.car.pk})
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
kwargs["instance"] = self.get_object()
|
|
return kwargs
|
|
|
|
def get_initial(self):
|
|
initial = super().get_initial()
|
|
instance = self.get_object()
|
|
dealer = get_user_type(self.request)
|
|
selected_items = instance.additional_services.filter(dealer=dealer)
|
|
initial["additional_finances"] = selected_items
|
|
return initial
|
|
|
|
def get_form(self, form_class=None):
|
|
form = super().get_form(form_class)
|
|
dealer = get_user_type(self.request)
|
|
form.fields["additional_finances"].queryset = models.AdditionalServices.objects.filter(dealer=dealer)
|
|
return form
|
|
|
|
|
|
class CarUpdateView(LoginRequiredMixin, SuccessMessageMixin, UpdateView):
|
|
model = models.Car
|
|
form_class = forms.CarUpdateForm
|
|
template_name = "inventory/car_edit.html"
|
|
success_message = _("Car updated successfully.")
|
|
|
|
def get_success_url(self):
|
|
return reverse("car_detail", kwargs={"pk": self.object.pk})
|
|
|
|
|
|
class CarDeleteView(LoginRequiredMixin, SuccessMessageMixin, DeleteView):
|
|
model = models.Car
|
|
template_name = "inventory/car_confirm_delete.html"
|
|
success_url = reverse_lazy("inventory_stats")
|
|
|
|
def delete(self, request, *args, **kwargs):
|
|
messages.success(request, _("Car deleted successfully."))
|
|
return super().delete(request, *args, **kwargs)
|
|
|
|
|
|
class CarLocationCreateView(CreateView):
|
|
model = models.CarLocation
|
|
form_class = forms.CarLocationForm
|
|
template_name = "inventory/car_location_form.html"
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("car_detail", kwargs={"pk": self.object.car.pk})
|
|
|
|
def form_valid(self, form):
|
|
form.instance.car = get_object_or_404(models.Car, pk=self.kwargs["car_pk"])
|
|
dealer = get_user_type(self.request)
|
|
form.instance.owner = dealer
|
|
form.save()
|
|
messages.success(self.request, "Car saved successfully.")
|
|
return super().form_valid(form)
|
|
|
|
|
|
class CarLocationUpdateView(UpdateView):
|
|
model = models.CarLocation
|
|
form_class = forms.CarLocationForm
|
|
template_name = "inventory/car_location_form.html"
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("car_detail", kwargs={"pk": self.object.car.pk})
|
|
|
|
|
|
class CarTransferCreateView(CreateView):
|
|
model = models.CarTransfer
|
|
form_class = forms.CarTransferForm
|
|
template_name = "inventory/car_location_form.html"
|
|
|
|
def get_form(self, form_class=None):
|
|
form = super().get_form(form_class)
|
|
form.fields["to_dealer"].queryset = models.Dealer.objects.exclude(
|
|
pk=get_user_type(self.request).pk
|
|
).all()
|
|
form.fields["car"].queryset = models.Car.objects.filter(pk=self.kwargs["pk"])
|
|
return form
|
|
|
|
def get_initial(self):
|
|
initial = super().get_initial()
|
|
initial["car"] = get_object_or_404(models.Car, pk=self.kwargs["pk"])
|
|
return initial
|
|
|
|
def form_valid(self, form):
|
|
form.instance.from_dealer = get_user_type(self.request)
|
|
form.instance.car.status = "transfer"
|
|
form.instance.car.save()
|
|
return super().form_valid(form)
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("car_detail", kwargs={"pk": self.object.car.pk})
|
|
|
|
|
|
# def CarTransferDetailView(request, pk):
|
|
# transfer = get_object_or_404(models.CarTransfer, pk=pk)
|
|
# context = {"transfer": transfer}
|
|
# return render(request, "inventory/transfer_details.html", context)
|
|
|
|
class CarTransferDetailView(LoginRequiredMixin, SuccessMessageMixin, DetailView):
|
|
model = models.CarTransfer
|
|
template_name = "inventory/transfer_details.html"
|
|
context_object_name = "transfer"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["action"] = self.request.GET.get("action")
|
|
return context
|
|
def car_transfer_approve(request, car_pk, transfer_pk):
|
|
car = get_object_or_404(models.Car, pk=car_pk)
|
|
transfer = get_object_or_404(models.CarTransfer, pk=transfer_pk)
|
|
action = request.GET.get("action")
|
|
if action == "cancel":
|
|
transfer.status = "cancel"
|
|
transfer.active = False
|
|
transfer.save()
|
|
transfer.car.status = "available"
|
|
transfer.car.save()
|
|
messages.success(request, _("Car transfer canceled successfully."))
|
|
models.Notification.objects.create(
|
|
user=transfer.from_dealer.user,
|
|
message=f"Car transfer request from {transfer.to_dealer} is canceled.",
|
|
)
|
|
return redirect("car_detail", pk=car.pk)
|
|
transfer.status = "approved"
|
|
transfer.save()
|
|
url = request.build_absolute_uri(
|
|
reverse(
|
|
"transfer_preview", kwargs={"car_pk": car.pk, "transfer_pk": transfer.pk}
|
|
)
|
|
)
|
|
models.Notification.objects.create(
|
|
user=transfer.to_dealer.user,
|
|
message=f"Car transfer request from {transfer.from_dealer} is waiting for your acceptance. <a href='{url}'> Accept</a>",
|
|
)
|
|
messages.success(request, _("Car transfer approved successfully."))
|
|
return redirect("car_detail", pk=car.pk)
|
|
|
|
|
|
def car_transfer_accept_reject(request, car_pk, transfer_pk):
|
|
car = get_object_or_404(models.Car, pk=car_pk)
|
|
transfer = get_object_or_404(models.CarTransfer, pk=transfer_pk)
|
|
status = request.GET.get("status")
|
|
if status == "rejected":
|
|
transfer.status = "reject"
|
|
transfer.active = False
|
|
messages.success(request, _("Car transfer rejected successfully."))
|
|
models.Notification.objects.create(
|
|
user=transfer.from_dealer.user,
|
|
message=f"Car transfer request from {transfer.to_dealer} is rejected.",
|
|
)
|
|
transfer.save()
|
|
elif status == "accepted":
|
|
transfer.status = "accept"
|
|
transfer.save()
|
|
transfer_process = CarTransfer(car, transfer)
|
|
success = transfer_process.transfer_car()
|
|
# success = CarTransfer(car, transfer)
|
|
if success:
|
|
messages.success(request, _("Car Transfer Completed successfully."))
|
|
models.Activity.objects.create(content_object=car,notes=f"Transfered from {transfer.from_dealer} to {transfer.to_dealer}",created_by=request.user)
|
|
models.Notification.objects.create(
|
|
user=transfer.from_dealer.user,
|
|
message=f"Car transfer request from {transfer.to_dealer} is completed.",
|
|
)
|
|
return redirect("inventory_stats")
|
|
|
|
|
|
def CarTransferPreviewView(request, car_pk, transfer_pk):
|
|
transfer = get_object_or_404(models.CarTransfer, pk=transfer_pk)
|
|
if transfer.to_dealer != get_user_type(request):
|
|
return redirect("car_detail", pk=car_pk)
|
|
return render(request, "inventory/transfer_preview.html", {"transfer": transfer})
|
|
# def get_context_data(self, **kwargs):
|
|
# estimate = kwargs.get("object")
|
|
# if estimate.get_itemtxs_data():
|
|
# data = get_financial_values(estimate)
|
|
|
|
# kwargs["vat_amount"] = data["vat_amount"]
|
|
# kwargs["total"] = data["grand_total"]
|
|
# kwargs["discount_amount"] = data["discount_amount"]
|
|
# kwargs["vat"] = data["vat"]
|
|
# kwargs["car_and_item_info"] = data["car_and_item_info"]
|
|
# kwargs["additional_services"] = data["additional_services"]
|
|
# return super().get_context_data(**kwargs)
|
|
|
|
|
|
# class CarTransferView(View):
|
|
# template_name = "inventory/car_location_form.html"
|
|
|
|
# def get(self, request, *args, **kwargs):
|
|
# form = forms.CarTransferForm()
|
|
# car = models.Car.objects.filter(pk=self.kwargs["pk"])
|
|
# form.fields['to_dealer'].queryset = form.fields['to_dealer'].queryset.exclude(pk=get_user_type(request).pk)
|
|
# form.fields['car'].queryset = car
|
|
# form.initial['car'] = car.first()
|
|
# context = {"form": form}
|
|
# return render(request, self.template_name,context)
|
|
|
|
# def post(self, request, *args, **kwargs):
|
|
# form = forms.CarTransferForm(request.POST)
|
|
# if form.is_valid():
|
|
# from_dealer = get_user_type(request)
|
|
# car = form.cleaned_data['car']
|
|
# to_dealer = form.cleaned_data['to_dealer']
|
|
# remarks = form.cleaned_data['remarks']
|
|
# models.CarTransferLog.objects.create(car=car, from_dealer=from_dealer, to_dealer=to_dealer, remarks=remarks)
|
|
# # car = models.Car.objects.filter(pk=self.kwargs["pk"])
|
|
# # form.instance.car = car.first()
|
|
# # form.instance.to_dealer = get_user_type(request)
|
|
# # form.save()
|
|
# # messages.success(request, "Car transfered successfully.")
|
|
# return redirect("car_detail", pk=self.kwargs["pk"])
|
|
|
|
|
|
class CustomCardCreateView(LoginRequiredMixin, CreateView):
|
|
model = models.CustomCard
|
|
form_class = forms.CustomCardForm
|
|
template_name = "inventory/add_custom_card.html"
|
|
|
|
def form_valid(self, form):
|
|
car = get_object_or_404(models.Car, pk=self.kwargs["car_pk"])
|
|
form.instance.car = car
|
|
return super().form_valid(form)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["car"] = get_object_or_404(models.Car, pk=self.kwargs["car_pk"])
|
|
return context
|
|
|
|
def get_success_url(self):
|
|
messages.success(self.request, _("Custom Card added successfully."))
|
|
return reverse_lazy("car_detail", kwargs={"pk": self.kwargs["car_pk"]})
|
|
|
|
|
|
class CarRegistrationCreateView(LoginRequiredMixin, CreateView):
|
|
model = models.CarRegistration
|
|
form_class = forms.CarRegistrationForm
|
|
template_name = 'inventory/car_registration_form.html'
|
|
|
|
def form_valid(self, form):
|
|
car = get_object_or_404(models.Car, pk=self.kwargs["car_pk"])
|
|
form.instance.car = car
|
|
return super().form_valid(form)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["car"] = get_object_or_404(models.Car, pk=self.kwargs["car_pk"])
|
|
return context
|
|
|
|
def get_success_url(self):
|
|
messages.success(self.request, _("Registration added successfully."))
|
|
return reverse_lazy("car_detail", kwargs={"pk": self.kwargs["car_pk"]})
|
|
|
|
|
|
@login_required()
|
|
def reserve_car_view(request, car_id):
|
|
if request.method == "POST":
|
|
car = get_object_or_404(models.Car, pk=car_id)
|
|
if car.is_reserved():
|
|
messages.error(request, _("This car is already reserved."))
|
|
return redirect("car_detail", pk=car.pk)
|
|
response = reserve_car(car, request)
|
|
return response
|
|
return JsonResponse(
|
|
{"success": False, "message": "Invalid request method."}, status=400
|
|
)
|
|
|
|
|
|
@login_required
|
|
def manage_reservation(request, reservation_id):
|
|
reservation = get_object_or_404(
|
|
models.CarReservation, pk=reservation_id, reserved_by=request.user
|
|
)
|
|
|
|
if request.method == "POST":
|
|
action = request.POST.get("action")
|
|
if action == "renew":
|
|
reservation.reserved_until = timezone.now() + timezone.timedelta(hours=24)
|
|
reservation.save()
|
|
messages.success(request, _("Reservation renewed successfully."))
|
|
return redirect("car_detail", pk=reservation.car.pk)
|
|
|
|
elif action == "cancel":
|
|
car = reservation.car
|
|
reservation.delete()
|
|
car.status = models.CarStatusChoices.AVAILABLE
|
|
car.save()
|
|
messages.success(request, _("Reservation canceled successfully."))
|
|
return redirect("car_detail", pk=reservation.car.pk)
|
|
|
|
else:
|
|
return JsonResponse(
|
|
{"success": False, "message": _("Invalid action.")}, status=400
|
|
)
|
|
|
|
return JsonResponse(
|
|
{"success": False, "message": _("Invalid request method.")}, status=400
|
|
)
|
|
|
|
|
|
class DealerDetailView(LoginRequiredMixin, DetailView):
|
|
model = models.Dealer
|
|
template_name = "dealers/dealer_detail.html"
|
|
context_object_name = "dealer"
|
|
|
|
def get_queryset(self):
|
|
return models.Dealer.objects.annotate(
|
|
staff_count=Coalesce(Count("staff"), Value(0)) # Get the number of staff members
|
|
)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
|
|
dealer = self.object
|
|
# Fetch current staff count from the annotated queryset
|
|
staff_count = dealer.staff_count
|
|
|
|
# Get the quota value dynamically
|
|
quota_dict = get_user_quota(dealer.user)
|
|
allowed_users = quota_dict.get("Users", None) # Fetch quota or default to None
|
|
|
|
context["staff_count"] = staff_count
|
|
context["allowed_users"] = allowed_users
|
|
context["quota_display"] = f"{staff_count}/{allowed_users}" if allowed_users is not None else "N/A"
|
|
|
|
return context
|
|
|
|
|
|
class DealerUpdateView(LoginRequiredMixin, SuccessMessageMixin, UpdateView):
|
|
model = models.Dealer
|
|
form_class = forms.DealerForm
|
|
template_name = "dealers/dealer_form.html"
|
|
success_url = reverse_lazy("dealer_detail")
|
|
success_message = _("Dealer updated successfully.")
|
|
|
|
def get_success_url(self):
|
|
return reverse("dealer_detail", kwargs={"pk": self.object.pk})
|
|
|
|
# def get_form(self, form_class=None):
|
|
# form = super().get_form(form_class)
|
|
# if hasattr(form.fields, "dealer_type"):
|
|
# form.fields.pop("dealer_type")
|
|
# return form
|
|
#
|
|
# def get_form_class(self):
|
|
# if self.request.user.dealer.dealer_type == "OWNER":
|
|
# return forms.DealerForm
|
|
# else:
|
|
# return forms.UserForm
|
|
|
|
|
|
class CustomerListView(LoginRequiredMixin, ListView):
|
|
model = CustomerModel
|
|
home_label = _("customers")
|
|
context_object_name = "customers"
|
|
paginate_by = 10
|
|
template_name = "customers/customer_list.html"
|
|
ordering = ["-created"]
|
|
|
|
def get_queryset(self):
|
|
query = self.request.GET.get("q")
|
|
dealer = get_user_type(self.request)
|
|
|
|
customers = dealer.entity.get_customers().filter(additional_info__type="customer")
|
|
|
|
return apply_search_filters(customers, query)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["query"] = self.request.GET.get("q", "")
|
|
return context
|
|
|
|
|
|
class CustomerDetailView(LoginRequiredMixin, DetailView):
|
|
model = CustomerModel
|
|
template_name = "customers/view_customer.html"
|
|
context_object_name = "customer"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
dealer = get_user_type(self.request)
|
|
entity = dealer.entity
|
|
context = super().get_context_data(**kwargs)
|
|
# customer = f"{context['customer'].first_name} {context['customer'].middle_name} {context['customer'].last_name}"
|
|
# context["estimates"] = entity.get_estimates().filter(
|
|
# customer__customer_name=name
|
|
# )
|
|
context["estimates"] = entity.get_estimates().filter(customer=self.object)
|
|
context["invoices"] = entity.get_invoices().filter(customer=self.object)
|
|
|
|
|
|
# context["notes"] = models.Notes.objects.filter(
|
|
# content_type__model="customer", object_id=self.object.id
|
|
# )
|
|
# context["activities"] = models.Activity.objects.filter(
|
|
# content_type__model="customer", object_id=self.object.id
|
|
# )
|
|
return context
|
|
|
|
|
|
def add_note_to_customer(request, pk):
|
|
customer = get_object_or_404(CustomerModel, pk=pk)
|
|
if request.method == "POST":
|
|
form = forms.NoteForm(request.POST)
|
|
if form.is_valid():
|
|
note = form.save(commit=False)
|
|
note.content_object = customer
|
|
|
|
note.created_by = request.user
|
|
note.save()
|
|
return redirect("customer_detail", pk=pk)
|
|
else:
|
|
form = forms.NoteForm()
|
|
return render(request, "crm/note_form.html", {"form": form, "customer": customer})
|
|
|
|
|
|
def add_activity_to_customer(request, pk):
|
|
customer = get_object_or_404(CustomerModel, pk=pk)
|
|
if request.method == "POST":
|
|
form = forms.ActivityForm(request.POST)
|
|
if form.is_valid():
|
|
activity = form.save(commit=False)
|
|
activity.content_object = customer
|
|
activity.created_by = request.user
|
|
activity.save()
|
|
return redirect("customer_detail", pk=pk)
|
|
else:
|
|
form = forms.ActivityForm()
|
|
return render(
|
|
request, "crm/add_activity.html", {"form": form, "customer": customer}
|
|
)
|
|
|
|
|
|
def CustomerCreateView(request):
|
|
form = forms.CustomerForm()
|
|
|
|
if request.method == "POST":
|
|
form = forms.CustomerForm(request.POST)
|
|
dealer = get_user_type(request)
|
|
|
|
if form.is_valid():
|
|
email = form.cleaned_data["email"]
|
|
|
|
# Check if customer with this email already exists
|
|
if dealer.entity.get_customers().filter(email=email).exists():
|
|
messages.error(request, _("Customer with this email already exists."))
|
|
else:
|
|
# Create customer name
|
|
customer_name = (
|
|
f"{form.cleaned_data['first_name']} "
|
|
f"{form.cleaned_data['middle_name']} "
|
|
f"{form.cleaned_data['last_name']}"
|
|
)
|
|
|
|
# Create customer instance
|
|
try:
|
|
customer = dealer.entity.create_customer(
|
|
commit=False,
|
|
customer_model_kwargs={
|
|
"customer_name": customer_name,
|
|
"address_1": form.cleaned_data["address"],
|
|
"phone": form.cleaned_data["phone_number"],
|
|
"email": email,
|
|
|
|
}
|
|
)
|
|
|
|
customer.additional_info = {
|
|
"customer_info": {
|
|
"first_name": form.cleaned_data["first_name"],
|
|
"middle_name": form.cleaned_data["middle_name"],
|
|
"last_name": form.cleaned_data["last_name"],
|
|
},
|
|
"type": "customer",
|
|
}
|
|
customer.save()
|
|
|
|
messages.success(request, _("Customer created successfully."))
|
|
return redirect("customer_list")
|
|
|
|
except Exception as e:
|
|
messages.error(request, _(f"An error occurred: {str(e)}"))
|
|
else:
|
|
# Form is invalid, show errors
|
|
messages.error(request, _("Please correct the errors below."))
|
|
|
|
return render(request, "customers/customer_form.html", {"form": form})
|
|
|
|
|
|
def CustomerUpdateView(request, pk):
|
|
customer = get_object_or_404(CustomerModel, pk=pk)
|
|
if request.method == "POST":
|
|
# form = forms.CustomerForm(request.POST, instance=customer)
|
|
customer_dict = {
|
|
x: request.POST[x] for x in request.POST if x != "csrfmiddlewaretoken"
|
|
}
|
|
dealer = get_user_type(request)
|
|
customer_name = (
|
|
customer_dict["first_name"]
|
|
+ " "
|
|
+ customer_dict["middle_name"]
|
|
+ " "
|
|
+ customer_dict["last_name"]
|
|
)
|
|
|
|
instance = dealer.entity.get_customers().get(pk=pk)
|
|
instance.customer_name = customer_name
|
|
instance.address_1 = customer_dict["address"]
|
|
instance.phone = customer_dict["phone_number"]
|
|
instance.email = customer_dict["email"]
|
|
|
|
customer_dict["pk"] = str(instance.pk)
|
|
instance.additional_info["customer_info"] = customer_dict
|
|
instance.save()
|
|
messages.success(request, _("Customer updated successfully."))
|
|
return redirect("customer_list")
|
|
else:
|
|
form = forms.CustomerForm(
|
|
initial=customer.additional_info["customer_info"]
|
|
if "customer_info" in customer.additional_info
|
|
else {}
|
|
)
|
|
# form = CustomerModelForm
|
|
return render(request, "customers/customer_form.html", {"form": form})
|
|
# class CustomerUpdateView(UpdateView, LoginRequiredMixin, PermissionRequiredMixin):
|
|
# model = CustomerModel
|
|
# form_class = forms.CustomerForm
|
|
# template_name = "customers/customer_form.html"
|
|
|
|
|
|
|
|
@login_required
|
|
def delete_customer(request, pk):
|
|
customer = get_object_or_404(models.Customer, pk=pk)
|
|
customer.delete()
|
|
messages.success(request, _("Customer deleted successfully."))
|
|
return redirect("customer_list")
|
|
|
|
|
|
class VendorListView(LoginRequiredMixin, ListView):
|
|
model = VendorModel
|
|
context_object_name = "vendors"
|
|
paginate_by = 10
|
|
template_name = "vendors/vendors_list.html"
|
|
ordering = ["-created"]
|
|
|
|
def get_queryset(self):
|
|
query = self.request.GET.get("q")
|
|
dealer = get_user_type(self.request)
|
|
vendors = dealer.entity.get_vendors().filter(active=True)
|
|
return apply_search_filters(vendors, query)
|
|
|
|
|
|
|
|
# class VendorDetailView(LoginRequiredMixin, DetailView):
|
|
# model = models.Vendor
|
|
# template_name = "vendors/view_vendor.html"
|
|
def vendorDetailView(request, pk):
|
|
vendor = get_object_or_404(models.Vendor, pk=pk)
|
|
return render(request, template_name="vendors/view_vendor.html", context={"vendor": vendor})
|
|
|
|
|
|
class VendorCreateView(
|
|
LoginRequiredMixin,
|
|
SuccessMessageMixin,
|
|
CreateView,
|
|
):
|
|
model = models.Vendor
|
|
form_class = forms.VendorForm
|
|
template_name = "vendors/vendor_form.html"
|
|
success_url = reverse_lazy("vendor_list")
|
|
success_message = _("Vendor created successfully.")
|
|
|
|
def form_valid(self, form):
|
|
dealer = get_user_type(self.request)
|
|
form.instance.dealer = dealer
|
|
# instance = form.save(commit=False)
|
|
# instance.entity_model = dealer.entity
|
|
form.instance.save()
|
|
return super().form_valid(form)
|
|
|
|
|
|
class VendorUpdateView(
|
|
LoginRequiredMixin,
|
|
SuccessMessageMixin,
|
|
UpdateView,
|
|
):
|
|
model = models.Vendor
|
|
form_class = forms.VendorForm
|
|
template_name = "vendors/vendor_form.html"
|
|
success_url = reverse_lazy("vendor_list")
|
|
success_message = _("Vendor updated successfully.")
|
|
|
|
|
|
@login_required
|
|
def delete_vendor(request, pk):
|
|
vendor = get_object_or_404(models.Vendor, pk=pk)
|
|
# vendor.active = False
|
|
vendor.delete()
|
|
messages.success(request, _("Vendor deleted successfully."))
|
|
return redirect("vendor_list")
|
|
|
|
|
|
# class QuotationCreateView(LoginRequiredMixin, CreateView):
|
|
# model = models.SaleQuotation
|
|
# form_class = forms.QuotationForm
|
|
# template_name = "sales/quotation_form.html"
|
|
#
|
|
# def form_valid(self, form):
|
|
# form.instance.dealer = get_user_type(self.request)
|
|
# quotation = form.save()
|
|
# selected_cars = form.cleaned_data.get("cars")
|
|
# for car in selected_cars:
|
|
# car_finance = car.finances
|
|
# if car_finance:
|
|
# models.SaleQuotationCar.objects.create(
|
|
# quotation=quotation,
|
|
# car=car,
|
|
# )
|
|
#
|
|
# messages.success(self.request, _("Quotation created successfully."))
|
|
# return redirect("quotation_list")
|
|
|
|
|
|
# class QuotationListView(LoginRequiredMixin, ListView):
|
|
# model = models.SaleQuotation
|
|
# template_name = "sales/quotation_list.html"
|
|
# context_object_name = "quotations"
|
|
# paginate_by = 10
|
|
#
|
|
# def get_queryset(self):
|
|
# status = self.request.GET.get("status")
|
|
# dealer = get_user_type(self.request)
|
|
# queryset = dealer.sales.all()
|
|
# if status:
|
|
# queryset = queryset.filter(status=status)
|
|
# return queryset
|
|
|
|
|
|
# class QuotationDetailView(LoginRequiredMixin, DetailView):
|
|
# model = models.SaleQuotation
|
|
# template_name = "sales/quotation_detail.html"
|
|
# context_object_name = "quotation"
|
|
#
|
|
# def get_context_data(self, **kwargs):
|
|
# context = super().get_context_data(**kwargs)
|
|
# quotation = self.object
|
|
#
|
|
# context_result = get_calculations(quotation)
|
|
# context.update(context_result)
|
|
#
|
|
# return context
|
|
|
|
|
|
# @login_required
|
|
# def generate_invoice(request, pk):
|
|
# quotation = get_object_or_404(models.SaleQuotation, pk=pk)
|
|
# dealer = get_user_type(request)
|
|
# entity = dealer.entity
|
|
# if not quotation.is_approved:
|
|
# messages.error(
|
|
# request, "Quotation must be approved before converting to an invoice."
|
|
# )
|
|
# else:
|
|
# coa_qs, coa_map = entity.get_all_coa_accounts()
|
|
# cash_account = coa_qs.first().get_coa_accounts().filter(name="Cash")
|
|
# recivable_account = (
|
|
# coa_qs.first().get_coa_accounts().filter(name="Accounts Receivable")
|
|
# )
|
|
# customer = (
|
|
# entity.get_customers()
|
|
# .filter(customer_name=quotation.customer.get_full_name)
|
|
# .first()
|
|
# )
|
|
#
|
|
# invoice_model = entity.create_invoice(
|
|
# customer_model=customer,
|
|
# terms=InvoiceModel.TERMS_ON_RECEIPT,
|
|
# cash_account=cash_account.first(),
|
|
# prepaid_account=recivable_account.first(),
|
|
# coa_model=coa_qs.first(),
|
|
# )
|
|
#
|
|
# name_list = [
|
|
# f"{instance.car.year} {instance.car.id_car_make} {instance.car.id_car_model} {instance.car.id_car_trim}"
|
|
# for instance in quotation.quotation_cars.all()
|
|
# ]
|
|
#
|
|
# invoices_item_models = invoice_model.get_item_model_qs().filter(
|
|
# name__in=name_list
|
|
# )
|
|
#
|
|
# invoice_itemtxs = {
|
|
# im.item_number: {
|
|
# "unit_cost": im.default_amount,
|
|
# "quantity": 1,
|
|
# "total_amount": im.default_amount,
|
|
# }
|
|
# for im in invoices_item_models
|
|
# }
|
|
#
|
|
# invoice_itemtxs = invoice_model.migrate_itemtxs(
|
|
# itemtxs=invoice_itemtxs, commit=True, operation=InvoiceModel.ITEMIZE_APPEND
|
|
# )
|
|
# ledger = (
|
|
# entity.get_ledgers()
|
|
# .filter(name=f"Payment Ledger for Invoice {invoice_model}")
|
|
# .first()
|
|
# )
|
|
# if not ledger:
|
|
# ledger = entity.create_ledger(
|
|
# name=f"Payment Ledger for Invoice {invoice_model}", posted=True
|
|
# )
|
|
# journal_entry = JournalEntryModel.objects.create(
|
|
# posted=False,
|
|
# description=f"Payment for Invoice {invoice_model}",
|
|
# ledger=ledger,
|
|
# locked=False,
|
|
# origin="Payment",
|
|
# )
|
|
#
|
|
# quotation.payment_id = journal_entry.pk
|
|
# quotation.is_approved = True
|
|
# date = datetime.datetime.now()
|
|
# quotation.date_draft = date
|
|
# invoice_model.date_draft = date
|
|
# invoice_model.save()
|
|
# quotation.save()
|
|
#
|
|
# if not invoice_model.can_review():
|
|
# messages.error(request, "Quotation is not ready for review")
|
|
# return redirect("quotation_detail", pk=pk)
|
|
#
|
|
# invoice_model.mark_as_review()
|
|
# invoice_model.date_in_review = date
|
|
# quotation.date_in_review = date
|
|
# quotation.status = "In Review"
|
|
# invoice_model.save()
|
|
# quotation.save()
|
|
|
|
# elif status == "approved":
|
|
# if qoutation.status == "Approved":
|
|
# messages.error(request, "Quotation is already approved")
|
|
# return redirect("quotation_detail", pk=pk)
|
|
|
|
# invoice_model = invoice_model.filter(date_in_review=qoutation.date_in_review).first()
|
|
# if not invoice_model.can_approve():
|
|
# messages.error(request, "Quotation is not ready for approval")
|
|
# return redirect("quotation_detail", pk=pk)
|
|
|
|
# invoice_model.mark_as_approved(entity_slug=entity.slug, user_model=request.user.dealer.get_root_dealer.user)
|
|
# invoice_model.date_approved = date
|
|
# qoutation.date_approved = date
|
|
# invoice_model.save()
|
|
# qoutation.status = "Approved"
|
|
# qoutation.save()
|
|
# messages.success(request, _("Quotation Approved"))
|
|
# ledger = entity.create_ledger(
|
|
# name=f"Payment Ledger for Invoice {invoice_model}",
|
|
# posted=True
|
|
# )
|
|
|
|
# entity_unit,created = EntityUnitModel.objects.get_or_create(
|
|
# name="Sales Department",
|
|
# entity=entity,
|
|
# document_prefix="SD"
|
|
# )
|
|
|
|
# journal_entry = JournalEntryModel.objects.create(
|
|
# entity_unit=entity_unit,
|
|
# posted=False,
|
|
# description=f"Payment for Invoice {invoice_model}",
|
|
# ledger=ledger,
|
|
# locked=False,
|
|
# origin="Payment",
|
|
# )
|
|
|
|
# accounts_receivable = coa_qs.first().get_coa_accounts().filter(name="Accounts Receivable").first()
|
|
# if not accounts_receivable:
|
|
# accounts_receivable = entity.create_account(
|
|
# code="AR",
|
|
# role="asset",
|
|
# name="Accounts Receivable",
|
|
# coa_model=coa_qs.first(),
|
|
# balance_type="credit"
|
|
# )
|
|
|
|
# TransactionModel.objects.create(
|
|
# journal_entry=journal_entry,
|
|
# account=cash_account.first(), # Debit Cash
|
|
# amount=invoice_model.amount_due, # Payment amount
|
|
# tx_type='debit',
|
|
# description="Payment Received",
|
|
# )
|
|
|
|
# TransactionModel.objects.create(
|
|
# journal_entry=journal_entry,
|
|
# account=accounts_receivable, # Credit Accounts Receivable
|
|
# amount=invoice_model.amount_due, # Payment amount
|
|
# tx_type='credit',
|
|
# description="Payment Received",
|
|
# )
|
|
|
|
# invoice_model.mark_as_review()
|
|
# print("reviewed")
|
|
# invoice_model.mark_as_approved(entity_slug=entity.slug, user_model=request.user.dealer.get_root_dealer.user)
|
|
# print("approved")
|
|
# invoice_model.mark_as_paid(entity_slug=entity.slug, user_model=request.user.dealer.get_root_dealer.user)
|
|
# print("paid")
|
|
# invoice_model.save()
|
|
# messages.success(request, "Invoice created")
|
|
# return redirect("quotation_detail", pk=pk)
|
|
|
|
# return redirect('django_ledger:invoice-detail', entity_slug=quotation.entity.slug, invoice_pk=invoice.uuid)
|
|
|
|
|
|
# @login_required
|
|
# def post_quotation(request, pk):
|
|
# qoutation = get_object_or_404(models.SaleQuotation, pk=pk)
|
|
# dealer = get_user_type(request)
|
|
# entity = dealer.entity
|
|
# if qoutation.posted:
|
|
# messages.error(request, "Quotation is already posted")
|
|
# return redirect("quotation_detail", pk=pk)
|
|
# coa_qs, coa_map = entity.get_all_coa_accounts()
|
|
# cash_account = coa_qs.first().get_coa_accounts().filter(name="Cash")
|
|
# recivable_account = (
|
|
# coa_qs.first().get_coa_accounts().filter(name="Accounts Receivable")
|
|
# )
|
|
# customer = (
|
|
# entity.get_customers()
|
|
# .filter(customer_name=qoutation.customer.get_full_name)
|
|
# .first()
|
|
# )
|
|
# invoice_model = (
|
|
# entity.get_invoices()
|
|
# .filter(customer=customer, date_paid=qoutation.date_paid)
|
|
# .first()
|
|
# )
|
|
# ledger = (
|
|
# entity.get_ledgers()
|
|
# .filter(name=f"Payment Ledger for Invoice {invoice_model}")
|
|
# .first()
|
|
# )
|
|
# return
|
|
# if not ledger:
|
|
# ledger = entity.create_ledger(name=f"Payment Ledger for Invoice {invoice_model}",posted=True)
|
|
|
|
# entity_unit,created = EntityUnitModel.objects.get_or_create(
|
|
# name="Sales Department",
|
|
# entity=entity,
|
|
# document_prefix="SD"
|
|
# )
|
|
|
|
# journal_entry = JournalEntryModel.objects.create(
|
|
# entity_unit=entity_unit,
|
|
# posted=False,
|
|
# description=f"Payment for Invoice {invoice_model}",
|
|
# ledger=ledger,
|
|
# locked=False,
|
|
# origin="Payment",
|
|
# )
|
|
|
|
# TransactionModel.objects.create(
|
|
# journal_entry=journal_entry,
|
|
# account=cash_account.first(), # Debit Cash
|
|
# amount=invoice_model.amount_due, # Payment amount
|
|
# tx_type='debit',
|
|
# description="Payment Received",
|
|
# )
|
|
|
|
# TransactionModel.objects.create(
|
|
# journal_entry=journal_entry,
|
|
# account=recivable_account.first(), # Credit Accounts Receivable
|
|
# amount=invoice_model.amount_due, # Payment amount
|
|
# tx_type='credit',
|
|
# description="Payment Received",
|
|
# )
|
|
# journal_entry.posted = True
|
|
# qoutation.posted = True
|
|
# qoutation.save()
|
|
# journal_entry.save()
|
|
# messages.success(request, "Invoice posted")
|
|
# return redirect("quotation_detail", pk=pk)
|
|
|
|
|
|
# @login_required
|
|
# def mark_quotation(request, pk):
|
|
# qoutation = get_object_or_404(models.SaleQuotation, pk=pk)
|
|
# status = request.GET.get("status")
|
|
# dealer = request.user.dealer
|
|
# entity = dealer.entity
|
|
# date = datetime.datetime.now()
|
|
# customer = (
|
|
# entity.get_customers()
|
|
# .filter(customer_name=qoutation.customer.get_full_name)
|
|
# .first()
|
|
# )
|
|
# invoice_model = entity.get_invoices().filter(customer=customer)
|
|
# if status == "approved":
|
|
# if qoutation.status == "Approved":
|
|
# messages.error(request, "Quotation is already approved")
|
|
# return redirect("quotation_detail", pk=pk)
|
|
#
|
|
# invoice_model = invoice_model.filter(
|
|
# date_in_review=qoutation.date_in_review
|
|
# ).first()
|
|
# if not invoice_model.can_approve():
|
|
# messages.error(request, "Quotation is not ready for approval")
|
|
# return redirect("quotation_detail", pk=pk)
|
|
#
|
|
# invoice_model.mark_as_approved(
|
|
# entity_slug=entity.slug, user_model=request.user.dealer
|
|
# )
|
|
# invoice_model.date_approved = date
|
|
# qoutation.date_approved = date
|
|
# invoice_model.save()
|
|
# qoutation.status = "Approved"
|
|
# qoutation.save()
|
|
# for car in qoutation.quotation_cars.all():
|
|
# car.car.status = "reserved"
|
|
# car.car.save()
|
|
# messages.success(request, _("Quotation Approved"))
|
|
# elif status == "paid":
|
|
# if qoutation.status == "Paid":
|
|
# messages.error(request, "Quotation is already paid")
|
|
# return redirect("quotation_detail", pk=pk)
|
|
#
|
|
# invoice_model = invoice_model.filter(
|
|
# date_approved=qoutation.date_approved
|
|
# ).first()
|
|
# if not invoice_model.can_pay():
|
|
# messages.error(request, "Quotation is not ready for payment")
|
|
# return redirect("quotation_detail", pk=pk)
|
|
#
|
|
# invoice_model.mark_as_paid(
|
|
# entity_slug=entity.slug, user_model=request.user.dealer
|
|
# )
|
|
# invoice_model.date_paid = date
|
|
# qoutation.date_paid = date
|
|
# invoice_model.save()
|
|
# qoutation.status = "Paid"
|
|
# qoutation.save()
|
|
# messages.success(request, _("Quotation Paid"))
|
|
# return redirect("quotation_detail", pk=pk)
|
|
|
|
|
|
# @login_required
|
|
# def confirm_quotation(request, pk):
|
|
# quotation = get_object_or_404(models.SaleQuotation, pk=pk)
|
|
# if quotation.is_approved:
|
|
# messages.error(request, _("Quotation already approved."))
|
|
# return redirect("quotation_detail", pk=pk)
|
|
#
|
|
# try:
|
|
# # quotation.confirm()
|
|
# # quotation_cars = quotation.quotation_cars.annotate(total_price=F('car__total') * F('quantity'))
|
|
# # total = quotation.quotation_cars.aggregate(total_price=Sum(F('car__finances__selling_price') * F('quantity')))
|
|
#
|
|
# models.SalesOrder.objects.create(
|
|
# quotation=quotation,
|
|
# total_amount=quotation.total_vat,
|
|
# # total_amount=quotation.quotation_cars.aggregate(Sum("total_amount"))["total_amount__sum"],
|
|
# )
|
|
# quotation.is_approved = True
|
|
# quotation.save()
|
|
# messages.success(request, _("Quotation confirmed and sales order created."))
|
|
# except ValueError as e:
|
|
# messages.error(request, str(e))
|
|
# return redirect("quotation_detail", pk=pk)
|
|
|
|
#
|
|
# class SalesOrderDetailView(LoginRequiredMixin, DetailView):
|
|
# model = models.SalesOrder
|
|
# template_name = "sales/sales_order_detail.html"
|
|
# context_object_name = "sales_order"
|
|
# slug_field = "order_id"
|
|
# slug_url_kwarg = "order_id"
|
|
|
|
#group
|
|
class GroupListView(LoginRequiredMixin, ListView):
|
|
model = Group
|
|
context_object_name = "groups"
|
|
paginate_by = 10
|
|
template_name = "groups/group_list.html"
|
|
|
|
# def get_queryset(self):
|
|
# query = self.request.GET.get("q")
|
|
# dealer = get_user_type(self.request)
|
|
# staff = models.Staff.objects.filter(dealer=dealer).all()
|
|
# return apply_search_filters(staff, query)
|
|
|
|
class GroupDetailView(LoginRequiredMixin, DetailView):
|
|
model = Group
|
|
template_name = "groups/group_detail.html"
|
|
context_object_name = "group"
|
|
|
|
|
|
class GroupCreateView(
|
|
LoginRequiredMixin,
|
|
SuccessMessageMixin,
|
|
CreateView,
|
|
):
|
|
model = Group
|
|
form_class = forms.GroupForm
|
|
template_name = "groups/group_form.html"
|
|
success_url = reverse_lazy("group_list")
|
|
success_message = _("Group created successfully.")
|
|
|
|
# def form_valid(self, form):
|
|
# dealer = get_user_type(self.request)
|
|
|
|
# email = form.cleaned_data["email"]
|
|
# password = "Tenhal@123"
|
|
# user = User.objects.create_user(username=form.cleaned_data["name"], email=email, password=password)
|
|
# user.is_staff = True
|
|
# user.save()
|
|
# staff_member = StaffMember.objects.create(user=user)
|
|
# services = form.cleaned_data["service_offered"]
|
|
# if services:
|
|
# for service in services:
|
|
# staff_member.services_offered.add(service)
|
|
# staff = form.save(commit=False)
|
|
# staff.staff_member = staff_member
|
|
# staff.dealer = dealer
|
|
# staff.save()
|
|
# return super().form_valid(form)
|
|
|
|
|
|
class GroupUpdateView(
|
|
LoginRequiredMixin,
|
|
SuccessMessageMixin,
|
|
UpdateView,
|
|
):
|
|
model = Group
|
|
form_class = forms.GroupForm
|
|
template_name = "groups/group_form.html"
|
|
success_url = reverse_lazy("group_list")
|
|
success_message = _("Group updated successfully.")
|
|
|
|
# def get_form_kwargs(self):
|
|
# kwargs = super().get_form_kwargs()
|
|
# kwargs["instance"] = self.get_object() # Pass the Staff instance to the form
|
|
# return kwargs
|
|
|
|
# def get_form(self, form_class = None):
|
|
# form = super().get_form(form_class)
|
|
# form.fields['email'].disabled = True
|
|
# return form
|
|
# def get_initial(self):
|
|
# initial = super().get_initial()
|
|
# initial['service_offered'] = self.object.staff_member.services_offered.all()
|
|
# initial['email'] = self.object.staff_member.user.email
|
|
# return initial
|
|
# def form_valid(self, form):
|
|
# services = form.cleaned_data["service_offered"]
|
|
# if not services:
|
|
# self.object.staff_member.services_offered.clear()
|
|
# else:
|
|
# for service in services:
|
|
# self.object.staff_member.services_offered.add(service)
|
|
|
|
# staff = form.save(commit=False)
|
|
# staff.name = form.cleaned_data["name"]
|
|
# staff.arabic_name = form.cleaned_data["arabic_name"]
|
|
# staff.phone_number = form.cleaned_data["phone_number"]
|
|
# staff.staff_type = form.cleaned_data["staff_type"]
|
|
# staff.save()
|
|
# return super().form_valid(form)
|
|
|
|
def GroupDeleteview(request, pk):
|
|
group = get_object_or_404(Group, pk=pk)
|
|
group.delete()
|
|
messages.success(request, _("Group deleted successfully."))
|
|
return redirect("group_list")
|
|
|
|
def GroupPermissionView(request, pk):
|
|
group = get_object_or_404(Group, pk=pk)
|
|
if request.method == "POST":
|
|
form = forms.PermissionForm(request.POST)
|
|
group.permissions.clear()
|
|
permissions = request.POST.getlist("name")
|
|
|
|
for i in permissions:
|
|
try:
|
|
group.permissions.add(Permission.objects.get(id=int(i)))
|
|
except Permission.DoesNotExist:
|
|
continue
|
|
|
|
messages.success(request, _("Permission added successfully."))
|
|
return redirect("group_detail", pk=group.pk)
|
|
|
|
form = forms.PermissionForm(initial={"name": group.permissions.all()})
|
|
return render(request,"groups/group_permission_form.html",{"group": group, "form": form})
|
|
|
|
# Users
|
|
|
|
def UserGroupView(request, pk):
|
|
staff = get_object_or_404(models.Staff, pk=pk)
|
|
if request.method == "POST":
|
|
form = forms.UserGroupForm(request.POST)
|
|
groups = request.POST.getlist("name")
|
|
staff.groups.clear()
|
|
for i in groups:
|
|
try:
|
|
staff.groups.add(Group.objects.get(id=int(i)))
|
|
except Group.DoesNotExist:
|
|
continue
|
|
|
|
messages.success(request, _("Group added successfully."))
|
|
return redirect("user_detail", pk=staff.pk)
|
|
|
|
form = forms.UserGroupForm(initial={"name": staff.user.groups.all()})
|
|
return render(request,"users/user_group_form.html",{"staff": staff, "form": form})
|
|
|
|
class UserListView(LoginRequiredMixin, ListView):
|
|
model = models.Staff
|
|
context_object_name = "users"
|
|
paginate_by = 10
|
|
template_name = "users/user_list.html"
|
|
|
|
def get_queryset(self):
|
|
query = self.request.GET.get("q")
|
|
dealer = get_user_type(self.request)
|
|
staff = models.Staff.objects.filter(dealer=dealer).all()
|
|
return apply_search_filters(staff, query)
|
|
|
|
|
|
class UserDetailView(LoginRequiredMixin, DetailView):
|
|
model = models.Staff
|
|
template_name = "users/user_detail.html"
|
|
context_object_name = "user_"
|
|
|
|
|
|
class UserCreateView(
|
|
LoginRequiredMixin,
|
|
SuccessMessageMixin,
|
|
CreateView,
|
|
):
|
|
model = models.Staff
|
|
form_class = forms.StaffForm
|
|
template_name = "users/user_form.html"
|
|
success_url = reverse_lazy("user_list")
|
|
success_message = _("User created successfully.")
|
|
|
|
def form_valid(self, form):
|
|
dealer = get_user_type(self.request)
|
|
|
|
email = form.cleaned_data["email"]
|
|
password = "Tenhal@123"
|
|
user = User.objects.create_user(username=form.cleaned_data["name"], email=email, password=password)
|
|
user.is_staff = True
|
|
user.save()
|
|
staff_member = StaffMember.objects.create(user=user)
|
|
for service in form.cleaned_data["service_offered"]:
|
|
staff_member.services_offered.add(service)
|
|
staff = form.save(commit=False)
|
|
staff.staff_member = staff_member
|
|
staff.dealer = dealer
|
|
group = Group.objects.filter(name__iexact=staff.staff_type).first()
|
|
if group:
|
|
staff.groups.add(group)
|
|
staff.save()
|
|
return super().form_valid(form)
|
|
|
|
|
|
class UserUpdateView(
|
|
LoginRequiredMixin,
|
|
SuccessMessageMixin,
|
|
UpdateView,
|
|
):
|
|
model = models.Staff
|
|
form_class = forms.StaffForm
|
|
template_name = "users/user_form.html"
|
|
success_url = reverse_lazy("user_list")
|
|
success_message = _("User updated successfully.")
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
kwargs["instance"] = self.get_object() # Pass the Staff instance to the form
|
|
return kwargs
|
|
|
|
def get_form(self, form_class = None):
|
|
form = super().get_form(form_class)
|
|
form.fields['email'].disabled = True
|
|
return form
|
|
def get_initial(self):
|
|
initial = super().get_initial()
|
|
initial['email'] = self.object.staff_member.user.email
|
|
initial['service_offered'] = self.object.staff_member.services_offered.all()
|
|
return initial
|
|
def form_valid(self, form):
|
|
services = form.cleaned_data["service_offered"]
|
|
if not services:
|
|
self.object.staff_member.services_offered.clear()
|
|
else:
|
|
for service in services:
|
|
self.object.staff_member.services_offered.add(service)
|
|
|
|
staff = form.save(commit=False)
|
|
staff.name = form.cleaned_data["name"]
|
|
staff.arabic_name = form.cleaned_data["arabic_name"]
|
|
staff.phone_number = form.cleaned_data["phone_number"]
|
|
staff.staff_type = form.cleaned_data["staff_type"]
|
|
staff.save()
|
|
return super().form_valid(form)
|
|
|
|
def UserDeleteview(request, pk):
|
|
user = get_object_or_404(models.Staff, pk=pk)
|
|
user.staff_member.delete()
|
|
user.delete()
|
|
messages.success(request, _("User deleted successfully."))
|
|
return redirect("user_list")
|
|
|
|
|
|
# errors
|
|
def custom_page_not_found_view(request, exception):
|
|
return render(request, "errors/404.html", {})
|
|
|
|
|
|
def custom_error_view(request, exception=None):
|
|
return render(request, "errors/500.html", {})
|
|
|
|
|
|
def custom_permission_denied_view(request, exception=None):
|
|
return render(request, "errors/403.html", {})
|
|
|
|
|
|
def custom_bad_request_view(request, exception=None):
|
|
return render(request, "errors/400.html", {})
|
|
|
|
|
|
class OrganizationListView(LoginRequiredMixin, ListView):
|
|
model = CustomerModel
|
|
template_name = "organizations/organization_list.html"
|
|
context_object_name = "organizations"
|
|
paginate_by = 10
|
|
|
|
def get_queryset(self):
|
|
query = self.request.GET.get("q")
|
|
dealer = get_user_type(self.request)
|
|
organization = dealer.entity.get_customers().filter(additional_info__type="organization", active=True)
|
|
|
|
return apply_search_filters(organization, query)
|
|
|
|
|
|
|
|
|
|
class OrganizationDetailView(DetailView):
|
|
model = CustomerModel
|
|
template_name = "organizations/organization_detail.html"
|
|
context_object_name = "organization"
|
|
|
|
|
|
def OrganizationCreateView(request):
|
|
if request.method == "POST":
|
|
form = forms.OrganizationForm(request.POST)
|
|
# upload logo
|
|
|
|
organization_dict = {
|
|
x: request.POST[x] for x in request.POST if x != "csrfmiddlewaretoken"
|
|
}
|
|
dealer = get_user_type(request)
|
|
|
|
instance = dealer.entity.create_customer(
|
|
customer_model_kwargs={
|
|
"customer_name": organization_dict["name"],
|
|
"address_1": organization_dict["address"],
|
|
"phone": organization_dict["phone_number"],
|
|
"email": organization_dict["email"],
|
|
}
|
|
)
|
|
image = request.FILES.get("logo")
|
|
if image:
|
|
file_name = default_storage.save("images/{}".format(image.name), image)
|
|
file_url = default_storage.url(file_name)
|
|
|
|
organization_dict["logo"] = file_url
|
|
organization_dict["pk"] = str(instance.pk)
|
|
instance.additional_info["organization_info"] = organization_dict
|
|
instance.additional_info["type"] = "organization"
|
|
instance.save()
|
|
messages.success(request, _("Organization created successfully."))
|
|
return redirect("organization_list")
|
|
else:
|
|
form = forms.OrganizationForm()
|
|
return render(request, "organizations/organization_form.html", {"form": form})
|
|
|
|
|
|
def OrganizationUpdateView(request,pk):
|
|
organization = get_object_or_404(CustomerModel, pk=pk)
|
|
if request.method == "POST":
|
|
form = forms.OrganizationForm(request.POST)
|
|
|
|
organization_dict = {
|
|
x: request.POST[x] for x in request.POST if x != "csrfmiddlewaretoken"
|
|
}
|
|
dealer = get_user_type(request)
|
|
|
|
instance = dealer.entity.get_customers().get(
|
|
pk=organization.additional_info["organization_info"]["pk"]
|
|
)
|
|
instance.customer_name = organization_dict["name"]
|
|
instance.address_1 = organization_dict["address"]
|
|
instance.phone = organization_dict["phone_number"]
|
|
instance.email = organization_dict["email"]
|
|
|
|
organization_dict["logo"] = organization.additional_info["organization_info"]["logo"]
|
|
organization_dict["pk"] = str(instance.pk)
|
|
instance.additional_info["organization_info"] = organization_dict
|
|
instance.additional_info["type"] = "organization"
|
|
instance.save()
|
|
messages.success(request, _("Organization created successfully."))
|
|
return redirect("organization_list")
|
|
else:
|
|
form = forms.OrganizationForm(
|
|
initial=organization.additional_info["organization_info"] or {}
|
|
)
|
|
form.fields.pop("logo", None)
|
|
return render(request, "organizations/organization_form.html", {"form": form})
|
|
|
|
|
|
class OrganizationDeleteView(LoginRequiredMixin, SuccessMessageMixin, DeleteView):
|
|
model = models.Organization
|
|
template_name = "organizations/organization_confirm_delete.html"
|
|
success_url = reverse_lazy("organization_list")
|
|
success_message = "Organization deleted successfully."
|
|
|
|
|
|
class RepresentativeListView(LoginRequiredMixin, ListView):
|
|
model = models.Representative
|
|
template_name = "representatives/representative_list.html"
|
|
context_object_name = "representatives"
|
|
paginate_by = 10
|
|
|
|
def get_queryset(self):
|
|
query = self.request.GET.get("q")
|
|
dealer = get_user_type(self.request)
|
|
representative = models.Representative.objects.filter(dealer=dealer)
|
|
return apply_search_filters(representative, query)
|
|
|
|
|
|
class RepresentativeDetailView(DetailView):
|
|
model = models.Representative
|
|
template_name = "representatives/representative_detail.html"
|
|
context_object_name = "representative"
|
|
|
|
|
|
class RepresentativeCreateView(LoginRequiredMixin, SuccessMessageMixin, CreateView):
|
|
model = models.Representative
|
|
form_class = forms.RepresentativeForm
|
|
template_name = "representatives/representative_form.html"
|
|
success_url = reverse_lazy("representative_list")
|
|
success_message = "Representative created successfully."
|
|
|
|
def form_valid(self, form):
|
|
if form.is_valid():
|
|
form.instance.dealer = self.request.user.dealer
|
|
form.save()
|
|
return super().form_valid(form)
|
|
else:
|
|
return form.errors
|
|
|
|
|
|
class RepresentativeUpdateView(LoginRequiredMixin, SuccessMessageMixin, UpdateView):
|
|
model = models.Representative
|
|
form_class = forms.RepresentativeForm
|
|
template_name = "representatives/representative_form.html"
|
|
success_url = reverse_lazy("representative_list")
|
|
success_message = "Representative updated successfully."
|
|
|
|
|
|
class RepresentativeDeleteView(LoginRequiredMixin, SuccessMessageMixin, DeleteView):
|
|
model = models.Representative
|
|
template_name = "representatives/representative_confirm_delete.html"
|
|
success_url = reverse_lazy("representative_list")
|
|
success_message = "Representative deleted successfully."
|
|
|
|
|
|
# def quotation_pdf_view(request, pk):
|
|
# # Get the quotation object
|
|
# quotation = models.SaleQuotation.objects.get(pk=pk)
|
|
#
|
|
# # Render the HTML template for the quotation page
|
|
# context = {
|
|
# "quotation": quotation,
|
|
# }
|
|
# context_result = get_calculations(quotation)
|
|
# context = context.update(context_result)
|
|
#
|
|
# html_content = render_to_string("sales/quotation_pdf.html", context)
|
|
#
|
|
# # Create a PDF file
|
|
#
|
|
# pdf_file = HTML(string=html_content).render()
|
|
#
|
|
# # Save the PDF file to a file
|
|
# with open("quotation.pdf", "wb") as f:
|
|
# f.write(pdf_file.write_pdf())
|
|
#
|
|
# # Return the PDF file as a response
|
|
# return HttpResponse(pdf_file, content_type="application/pdf")
|
|
|
|
|
|
# @login_required
|
|
# def download_quotation_pdf(request, quotation_id):
|
|
# try:
|
|
# # Retrieve the quotation object
|
|
# quotation = models.SaleQuotation.objects.get(id=quotation_id)
|
|
# cars = models.SaleQuotationCar.objects.get(id=quotation_id)
|
|
# print(cars)
|
|
# services = cars.finance.additional_services.all()
|
|
# print(services)
|
|
#
|
|
# # Create a response object
|
|
# response = HttpResponse(content_type="application/pdf")
|
|
# response["Content-Disposition"] = (
|
|
# f'attachment; filename="quotation_{quotation.id}.pdf"'
|
|
# )
|
|
#
|
|
# # Call the PDF generation function
|
|
# # generate_quotation_pdf(response, quotation, services)
|
|
#
|
|
# return response
|
|
# except models.SaleQuotation.DoesNotExist:
|
|
# return HttpResponse("Quotation not found", status=404)
|
|
|
|
|
|
# @login_required
|
|
# def invoice_detail(request, pk):
|
|
# quotation = get_object_or_404(models.SaleQuotation, pk=pk)
|
|
# dealer = request.user.dealer
|
|
# entity = dealer.entity
|
|
# customer = (
|
|
# entity.get_customers()
|
|
# .filter(customer_name=quotation.customer.get_full_name)
|
|
# .first()
|
|
# )
|
|
# invoice_model = entity.get_invoices()
|
|
#
|
|
# invoice = invoice_model.filter(
|
|
# customer=customer, date_draft=quotation.date_draft
|
|
# ).first()
|
|
# return redirect("quotation_detail", pk=pk)
|
|
|
|
|
|
# @login_required
|
|
# def payment_invoice(request, pk):
|
|
# quotation = get_object_or_404(models.SaleQuotation, pk=pk)
|
|
# dealer = request.user.dealer
|
|
# entity = dealer.entity
|
|
# customer = (
|
|
# entity.get_customers()
|
|
# .filter(customer_name=quotation.customer.get_full_name)
|
|
# .first()
|
|
# )
|
|
# invoice_model = entity.get_invoices()
|
|
# invoice = invoice_model.filter(
|
|
# customer=customer, date_draft=quotation.date_draft
|
|
# ).first()
|
|
#
|
|
# return redirect("quotation_detail", pk=pk)
|
|
|
|
|
|
# class PaymentCreateView(LoginRequiredMixin, SuccessMessageMixin, CreateView):
|
|
# model = models.Payment
|
|
# form_class = forms.PaymentForm
|
|
# template_name = "sales/payments/payment_form.html"
|
|
# success_url = reverse_lazy("quotation_list")
|
|
# success_message = "Payment created successfully."
|
|
|
|
# def form_valid(self, form):
|
|
# quotation = get_object_or_404(models.SaleQuotation, pk=self.kwargs["pk"])
|
|
# form.instance.quotation = quotation
|
|
# form.save()
|
|
# return super().form_valid(form)
|
|
# def get_context_data(self, **kwargs):
|
|
# context = super().get_context_data(**kwargs)
|
|
# context["quotation"] = get_object_or_404(models.SaleQuotation, pk=self.kwargs["pk"])
|
|
# return context
|
|
|
|
|
|
# def payment_create(request, pk):
|
|
# quotation = get_object_or_404(models.SaleQuotation, pk=pk)
|
|
# dealer = get_user_type(request)
|
|
# if request.method == "POST":
|
|
# form = forms.PaymentForm(request.POST)
|
|
# if form.is_valid():
|
|
# form.instance.quotation = quotation
|
|
# insatnce = form.save()
|
|
#
|
|
# dealer = dealer
|
|
# entity = dealer.entity
|
|
# customer = (
|
|
# entity.get_customers()
|
|
# .filter(customer_name=quotation.customer.get_full_name)
|
|
# .first()
|
|
# )
|
|
# coa_qs, coa_map = entity.get_all_coa_accounts()
|
|
# cash_account = coa_qs.first().get_coa_accounts().filter(name="Cash")
|
|
# recivable_account = (
|
|
# coa_qs.first().get_coa_accounts().filter(name="Accounts Receivable")
|
|
# )
|
|
# journal_entry = JournalEntryModel.objects.filter(
|
|
# pk=quotation.payment_id
|
|
# ).first()
|
|
# TransactionModel.objects.create(
|
|
# journal_entry=journal_entry,
|
|
# account=cash_account.first(), # Debit Cash
|
|
# amount=insatnce.amount, # Payment amount
|
|
# tx_type="debit",
|
|
# description="Payment Received",
|
|
# )
|
|
#
|
|
# TransactionModel.objects.create(
|
|
# journal_entry=journal_entry,
|
|
# account=recivable_account.first(), # Credit Accounts Receivable
|
|
# amount=insatnce.amount, # Payment amount
|
|
# tx_type="credit",
|
|
# description="Payment Received",
|
|
# )
|
|
# journal_entry.posted = True
|
|
# quotation.posted = True
|
|
# quotation.save()
|
|
# journal_entry.save()
|
|
#
|
|
# invoice_model = (
|
|
# entity.get_invoices()
|
|
# .filter(date_approved=quotation.date_approved)
|
|
# .first()
|
|
# )
|
|
#
|
|
# invoice_model.mark_as_paid(
|
|
# entity_slug=entity.slug, user_model=request.user.dealer
|
|
# )
|
|
# date = timezone.now()
|
|
# invoice_model.date_paid = date
|
|
# quotation.date_paid = date
|
|
# invoice_model.save()
|
|
# quotation.status = "Paid"
|
|
# quotation.save()
|
|
#
|
|
# messages.success(request, "Payment created successfully.")
|
|
# return redirect("quotation_detail", pk=pk)
|
|
# else:
|
|
# form = forms.PaymentForm()
|
|
# return render(
|
|
# request,
|
|
# "sales/payments/payment_create.html",
|
|
# {"quotation": quotation, "form": form},
|
|
# )
|
|
|
|
|
|
# Ledger
|
|
|
|
|
|
# BANK ACCOUNT
|
|
class BankAccountListView(LoginRequiredMixin, ListView):
|
|
model = BankAccountModel
|
|
template_name = "ledger/bank_accounts/bank_account_list.html"
|
|
context_object_name = "bank_accounts"
|
|
paginate_by = 10
|
|
|
|
def get_queryset(self):
|
|
query = self.request.GET.get("q")
|
|
dealer = get_user_type(self.request)
|
|
bank_accounts = BankAccountModel.objects.filter(entity_model=dealer.entity)
|
|
return apply_search_filters(bank_accounts, query)
|
|
|
|
|
|
class BankAccountCreateView(LoginRequiredMixin, SuccessMessageMixin, CreateView):
|
|
model = BankAccountModel
|
|
form_class = BankAccountCreateForm
|
|
template_name = "ledger/bank_accounts/bank_account_form.html"
|
|
success_url = reverse_lazy("bank_account_list")
|
|
success_message = "Bank account created successfully."
|
|
|
|
def form_valid(self, form):
|
|
dealer = get_user_type(self.request)
|
|
form.instance.entity_model = dealer.entity
|
|
return super().form_valid(form)
|
|
|
|
def get_form_kwargs(self):
|
|
dealer = get_user_type(self.request)
|
|
entity = dealer.entity
|
|
kwargs = super().get_form_kwargs()
|
|
kwargs["entity_slug"] = entity.slug
|
|
kwargs["user_model"] = entity.admin
|
|
return kwargs
|
|
|
|
|
|
class BankAccountDetailView(LoginRequiredMixin, DetailView):
|
|
model = BankAccountModel
|
|
template_name = "ledger/bank_accounts/bank_account_detail.html"
|
|
context_object_name = "bank_account"
|
|
|
|
|
|
class BankAccountUpdateView(LoginRequiredMixin, SuccessMessageMixin, UpdateView):
|
|
model = BankAccountModel
|
|
form_class = BankAccountUpdateForm
|
|
template_name = "ledger/bank_accounts/bank_account_form.html"
|
|
success_url = reverse_lazy("bank_account_list")
|
|
success_message = "Bank account updated successfully."
|
|
|
|
def get_form_kwargs(self):
|
|
dealer = get_user_type(self.request)
|
|
entity = dealer.entity
|
|
kwargs = super().get_form_kwargs()
|
|
kwargs["entity_slug"] = entity.slug # Get entity_slug from URL
|
|
kwargs["user_model"] = entity.admin # Get user_model from the request
|
|
return kwargs
|
|
|
|
|
|
@login_required
|
|
def bank_account_delete(request, pk):
|
|
bank_account = get_object_or_404(BankAccountModel, pk=pk)
|
|
if request.method == "POST":
|
|
bank_account.delete()
|
|
messages.success(request, "Bank account deleted successfully.")
|
|
return redirect("bank_account_list")
|
|
return render(
|
|
request,
|
|
"ledger/bank_accounts/bank_account_delete.html",
|
|
{"bank_account": bank_account},
|
|
)
|
|
|
|
|
|
# Accounts
|
|
|
|
|
|
class AccountListView(LoginRequiredMixin, ListView):
|
|
model = AccountModel
|
|
template_name = "ledger/coa_accounts/account_list.html"
|
|
context_object_name = "accounts"
|
|
paginate_by = 10
|
|
|
|
def get_queryset(self):
|
|
query = self.request.GET.get("q")
|
|
dealer = get_user_type(self.request)
|
|
accounts = dealer.entity.get_all_accounts()
|
|
return apply_search_filters(accounts, query)
|
|
|
|
|
|
class AccountCreateView(LoginRequiredMixin, SuccessMessageMixin, CreateView):
|
|
model = AccountModel
|
|
form_class = AccountModelCreateForm
|
|
template_name = "ledger/coa_accounts/account_form.html"
|
|
success_url = reverse_lazy("account_list")
|
|
success_message = "Account created successfully."
|
|
|
|
def form_valid(self, form):
|
|
dealer = get_user_type(self.request)
|
|
form.instance.entity_model = dealer.entity
|
|
form.instance.coa_model = dealer.entity.get_default_coa()
|
|
form.instance.depth = 0
|
|
form.instance.path = form.instance.code
|
|
return super().form_valid(form)
|
|
|
|
def get_form_kwargs(self):
|
|
dealer = get_user_type(self.request)
|
|
kwargs = super().get_form_kwargs()
|
|
kwargs["coa_model"] = dealer.entity.get_default_coa()
|
|
return kwargs
|
|
|
|
def get_form(self, form_class=None):
|
|
form = super().get_form(form_class)
|
|
entity = get_user_type(self.request).entity
|
|
form.initial['coa_model'] = entity.get_default_coa()
|
|
return form
|
|
|
|
|
|
class AccountDetailView(LoginRequiredMixin, DetailView):
|
|
model = AccountModel
|
|
template_name = "ledger/coa_accounts/account_detail.html"
|
|
context_object_name = "account"
|
|
slug_field = "uuid"
|
|
DEFAULT_TXS_DAYS = 30
|
|
extra_context = {
|
|
"DEFAULT_TXS_DAYS": DEFAULT_TXS_DAYS,
|
|
"header_subtitle_icon": "ic:round-account-tree",
|
|
}
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
account_model: AccountModel = context["object"]
|
|
context["header_title"] = f"Account {account_model.code} - {account_model.name}"
|
|
context["page_title"] = f"Account {account_model.code} - {account_model.name}"
|
|
context["total_debits"] = sum(
|
|
x.amount for x in account_model.transactionmodel_set.filter(tx_type="debit")
|
|
)
|
|
context["total_credits"] = sum(
|
|
x.amount
|
|
for x in account_model.transactionmodel_set.filter(tx_type="credit")
|
|
)
|
|
txs_qs = (
|
|
account_model.transactionmodel_set.all()
|
|
.posted()
|
|
.order_by("journal_entry__timestamp")
|
|
.select_related(
|
|
"journal_entry",
|
|
"journal_entry__entity_unit",
|
|
"journal_entry__ledger__billmodel",
|
|
"journal_entry__ledger__invoicemodel",
|
|
)
|
|
)
|
|
|
|
return context
|
|
|
|
|
|
class AccountUpdateView(LoginRequiredMixin, SuccessMessageMixin, UpdateView):
|
|
model = AccountModel
|
|
form_class = AccountModelUpdateForm
|
|
template_name = "ledger/coa_accounts/account_form.html"
|
|
success_url = reverse_lazy("account_list")
|
|
success_message = "Account updated successfully."
|
|
|
|
def get_form(self, form_class=None):
|
|
form = super().get_form(form_class)
|
|
form.fields["_ref_node_id"].widget = HiddenInput()
|
|
form.fields["_position"].widget = HiddenInput()
|
|
return form
|
|
|
|
|
|
@login_required
|
|
def account_delete(request, pk):
|
|
account = get_object_or_404(AccountModel, pk=pk)
|
|
|
|
account.delete()
|
|
messages.success(request, "Account deleted successfully.")
|
|
return redirect("account_list")
|
|
|
|
|
|
# Sales list
|
|
def sales_list_view(request):
|
|
dealer = get_user_type(request)
|
|
entity = dealer.entity
|
|
|
|
transactions = ItemTransactionModel.objects.for_entity(entity_slug=entity.slug, user_model=dealer.user)
|
|
paginator = Paginator(transactions, 10)
|
|
page_number = request.GET.get('page')
|
|
page_obj = paginator.get_page(page_number)
|
|
txs = get_item_transactions(page_obj)
|
|
context = {"txs": txs, "page_obj": page_obj}
|
|
return render(request, "sales/sales_list.html", context)
|
|
|
|
|
|
# Estimates
|
|
class EstimateListView(LoginRequiredMixin, ListView):
|
|
model = EstimateModel
|
|
template_name = "sales/estimates/estimate_list.html"
|
|
context_object_name = "estimates"
|
|
paginate_by = 20
|
|
|
|
def get_queryset(self):
|
|
dealer = get_user_type(self.request)
|
|
entity = dealer.entity
|
|
status = self.request.GET.get('status')
|
|
queryset = entity.get_estimates()
|
|
if status:
|
|
queryset = queryset.filter(status=status)
|
|
return queryset
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# class EstimateCreateView(LoginRequiredMixin, SuccessMessageMixin, CreateView):
|
|
# model = EstimateModel
|
|
# form_class = EstimateModelCreateForm
|
|
# template_name = "sales/estimates/estimate_form.html"
|
|
# success_url = reverse_lazy("estimate_list")
|
|
# success_message = "Estimate created successfully."
|
|
|
|
# def get_form_kwargs(self):
|
|
# """
|
|
# Override this method to pass additional keyword arguments to the form.
|
|
# """
|
|
# entity = self.request.user.dealer.entity
|
|
# kwargs = super().get_form_kwargs()
|
|
# kwargs['entity_slug'] = entity.slug
|
|
# kwargs['user_model'] = entity.admin
|
|
# return kwargs
|
|
|
|
# def get_context_data(self, **kwargs):
|
|
# entity = self.request.user.dealer.entity
|
|
# kwargs['items'] = entity.get_items_all()
|
|
# return super().get_context_data(**kwargs)
|
|
# def get_customer_queryset(self):
|
|
# entity = self.request.user.dealer.entity
|
|
# return entity.get_customer_queryset()
|
|
|
|
# def form_valid(self, form):
|
|
# form.instance.entity = self.request.user.dealer.entity
|
|
# return super().form_valid(form)
|
|
|
|
|
|
# @csrf_exempt
|
|
@login_required
|
|
def create_estimate(request,pk=None):
|
|
dealer = get_user_type(request)
|
|
entity = dealer.entity
|
|
|
|
if request.method == "POST":
|
|
# try:
|
|
data = json.loads(request.body)
|
|
title = data.get("title")
|
|
customer_id = data.get("customer")
|
|
terms = data.get("terms")
|
|
customer = entity.get_customers().filter(pk=customer_id).first()
|
|
|
|
items = data.get("item", [])
|
|
quantities = data.get("quantity", [])
|
|
|
|
if not all([items, quantities]):
|
|
return JsonResponse(
|
|
{"status": "error", "message": "Items and Quantities are required"},
|
|
status=400,
|
|
)
|
|
|
|
if isinstance(quantities, list):
|
|
if "0" in quantities:
|
|
return JsonResponse(
|
|
{"status": "error", "message": "Quantity must be greater than zero"}
|
|
)
|
|
else:
|
|
if int(quantities) <= 0:
|
|
return JsonResponse(
|
|
{"status": "error", "message": "Quantity must be greater than zero"}
|
|
)
|
|
if isinstance(items, list):
|
|
for item, quantity in zip(items, quantities):
|
|
if int(quantity) > models.Car.objects.filter(hash=item,status='available').count():
|
|
return JsonResponse(
|
|
{"status": "error", "message": "Quantity must be less than or equal to the number of cars in stock"},
|
|
)
|
|
else:
|
|
if int(quantities) > models.Car.objects.filter(hash=items,status='available').count():
|
|
return JsonResponse(
|
|
{"status": "error", "message": "Quantity must be less than or equal to the number of cars in stock"},
|
|
)
|
|
estimate = entity.create_estimate(
|
|
estimate_title=title, customer_model=customer, contract_terms=terms
|
|
)
|
|
if isinstance(items, list):
|
|
item_quantity_map = {}
|
|
for item, quantity in zip(items, quantities):
|
|
if item in item_quantity_map:
|
|
item_quantity_map[item] += int(quantity)
|
|
else:
|
|
item_quantity_map[item] = int(quantity)
|
|
item_list = list(item_quantity_map.keys())
|
|
quantity_list = list(item_quantity_map.values())
|
|
|
|
items_list = [
|
|
{"item_id": item_list[i], "quantity": quantity_list[i]}
|
|
for i in range(len(item_list))
|
|
]
|
|
items_txs = []
|
|
for item in items_list:
|
|
# item_instance = ItemModel.objects.get(pk=item.get("item_id"))
|
|
car_instance = ItemModel.objects.filter(additional_info__car_info__hash=item.get("item_id")).all()
|
|
|
|
# car_instance = models.Car.objects.get(vin=item_instance.name)
|
|
for i in car_instance[:int(quantities[0])]:
|
|
items_txs.append(
|
|
{
|
|
"item_number": i.item_number,
|
|
"quantity": 1,
|
|
"unit_cost": i.additional_info.get('car_finance').get("selling_price"),
|
|
"unit_revenue": i.additional_info.get('car_finance').get("selling_price"),
|
|
"total_amount": (i.additional_info.get('car_finance').get("total_vat"))
|
|
}
|
|
)
|
|
|
|
estimate_itemtxs = {
|
|
item.get("item_number"): {
|
|
"unit_cost": item.get("unit_cost"),
|
|
"unit_revenue": item.get("unit_revenue"),
|
|
"quantity": item.get("quantity"),
|
|
"total_amount": item.get("total_amount"),
|
|
}
|
|
for item in items_txs
|
|
}
|
|
else:
|
|
item = entity.get_items_all().filter(pk=items).first()
|
|
instance = models.Car.objects.get(vin=item.name)
|
|
estimate_itemtxs = {
|
|
item.item_number: {
|
|
"unit_cost": instance.finances.cost_price,
|
|
"unit_revenue": instance.finances.selling_price,
|
|
"quantity": Decimal(quantities),
|
|
"total_amount": instance.finances.total_vat * int(quantities),
|
|
}
|
|
}
|
|
|
|
estimate.migrate_itemtxs(
|
|
itemtxs=estimate_itemtxs,
|
|
commit=True,
|
|
operation=EstimateModel.ITEMIZE_APPEND,
|
|
)
|
|
|
|
if isinstance(items, list):
|
|
for item in estimate_itemtxs.keys():
|
|
item_instance = ItemModel.objects.filter(item_number=item).first()
|
|
instance = models.Car.objects.get(vin=item_instance.name)
|
|
reserve_car(instance, request)
|
|
# for item in items:
|
|
# item_instance = ItemModel.objects.filter(additioinal_info__car_info__hash=item).first()
|
|
# instance = models.Car.objects.get(hash=item)
|
|
# reserve_car(instance, request)
|
|
|
|
else:
|
|
item_instance = ItemModel.objects.filter(additioinal_info__car_info__hash=items).first()
|
|
instance = models.Car.objects.get(hash=item)
|
|
response = reserve_car(instance, request)
|
|
|
|
opportunity_id = data.get("opportunity_id")
|
|
if opportunity_id != "None":
|
|
opportunity = models.Opportunity.objects.get(pk=int(opportunity_id))
|
|
opportunity.estimate = estimate
|
|
opportunity.save()
|
|
|
|
url = reverse("estimate_detail", kwargs={"pk": estimate.pk})
|
|
return JsonResponse(
|
|
{
|
|
"status": "success",
|
|
"message": "Quotation created successfully!",
|
|
"url": f"{url}",
|
|
}
|
|
)
|
|
|
|
form = forms.EstimateModelCreateForm(
|
|
entity_slug=entity.slug, user_model=entity.admin
|
|
)
|
|
form.fields["customer"].queryset = entity.get_customers().filter(active=True)
|
|
|
|
if pk:
|
|
opportunity = models.Opportunity.objects.get(pk=pk)
|
|
customer = opportunity.customer
|
|
form.initial['customer'] = customer
|
|
|
|
car_list = models.Car.objects.filter(dealer=dealer,colors__isnull=False,finances__isnull=False,status="available").annotate(color=F('colors__exterior__rgb'),color_name=F('colors__exterior__name')).values_list(
|
|
'id_car_make__name', 'id_car_model__name','id_car_serie__name','id_car_trim__name','color','color_name','hash').distinct()
|
|
context = {
|
|
"form": form,
|
|
"items": [
|
|
{
|
|
'make':x[0],
|
|
'model':x[1],
|
|
'serie':x[2],
|
|
'trim':x[3],
|
|
'color':x[4],
|
|
'color_name':x[5],
|
|
'hash': x[6]
|
|
}
|
|
for x in car_list
|
|
],
|
|
"opportunity_id": pk if pk else None
|
|
}
|
|
|
|
return render(request, "sales/estimates/estimate_form.html", context)
|
|
|
|
|
|
class EstimateDetailView(LoginRequiredMixin, DetailView):
|
|
model = EstimateModel
|
|
template_name = "sales/estimates/estimate_detail.html"
|
|
context_object_name = "estimate"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
estimate = kwargs.get("object")
|
|
if estimate.get_itemtxs_data():
|
|
calculator = CarFinanceCalculator(estimate)
|
|
finance_data = calculator.get_finance_data()
|
|
|
|
kwargs["data"] = finance_data
|
|
kwargs["invoice"] = (
|
|
InvoiceModel.objects.all().filter(ce_model=estimate).first()
|
|
)
|
|
return super().get_context_data(**kwargs)
|
|
|
|
|
|
def create_sale_order(request, pk):
|
|
estimate = get_object_or_404(EstimateModel, pk=pk)
|
|
items = estimate.get_itemtxs_data()[0].all()
|
|
|
|
if request.method == "POST":
|
|
form = forms.SaleOrderForm(request.POST)
|
|
if form.is_valid():
|
|
form.save()
|
|
if not estimate.is_approved():
|
|
estimate.mark_as_approved()
|
|
estimate.save()
|
|
for item in estimate.get_itemtxs_data()[0].all():
|
|
try:
|
|
item.item_model.additional_info['car_info']['status'] = 'sold'
|
|
item.item_model.save()
|
|
except KeyError:
|
|
pass
|
|
|
|
models.Car.objects.get(vin=item.item_model.name).mark_as_sold(user=request.user)
|
|
|
|
messages.success(request, "Sale Order created successfully")
|
|
return redirect("estimate_detail", pk=pk)
|
|
|
|
form = forms.SaleOrderForm()
|
|
form.fields["estimate"].queryset = EstimateModel.objects.filter(pk=pk)
|
|
form.initial["estimate"] = estimate
|
|
# data = get_car_finance_data(estimate)
|
|
calculator = CarFinanceCalculator(estimate)
|
|
finance_data = calculator.get_finance_data()
|
|
return render(
|
|
request,
|
|
"sales/estimates/sale_order_form.html",
|
|
{"form": form, "estimate": estimate, "items": items, "data": finance_data},
|
|
)
|
|
|
|
|
|
def preview_sale_order(request, pk):
|
|
estimate = get_object_or_404(EstimateModel, pk=pk)
|
|
data = get_car_finance_data(estimate)
|
|
return render(
|
|
request,
|
|
"sales/estimates/sale_order_preview.html",
|
|
{"order": estimate.sale_orders.first(), "data": data, "estimate": estimate},
|
|
)
|
|
|
|
|
|
class PaymentRequest(LoginRequiredMixin, DetailView):
|
|
model = EstimateModel
|
|
template_name = "sales/estimates/payment_request_detail.html"
|
|
context_object_name = "estimate"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["cars"] = [
|
|
models.Car.objects.get(vin=car.item_model.name)
|
|
for car in context["estimate"].get_itemtxs_data()[0].all()
|
|
]
|
|
|
|
return context
|
|
|
|
|
|
class EstimatePreviewView(DetailView):
|
|
model = EstimateModel
|
|
context_object_name = "estimate"
|
|
template_name = "sales/estimates/estimate_preview.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
estimate = kwargs.get("object")
|
|
if estimate.get_itemtxs_data():
|
|
data = get_financial_values(estimate)
|
|
|
|
kwargs["vat_amount"] = data["vat_amount"]
|
|
kwargs["total"] = data["grand_total"]
|
|
kwargs["discount_amount"] = data["discount_amount"]
|
|
kwargs["vat"] = data["vat"]
|
|
# kwargs["car_and_item_info"] = data["car_and_item_info"]
|
|
kwargs["additional_services"] = data["additional_services"]
|
|
return super().get_context_data(**kwargs)
|
|
|
|
|
|
@login_required
|
|
def estimate_mark_as(request, pk):
|
|
estimate = get_object_or_404(EstimateModel, pk=pk)
|
|
dealer = get_user_type(request)
|
|
entity = dealer.entity
|
|
mark = request.GET.get("mark")
|
|
if mark:
|
|
if mark == "review":
|
|
if not estimate.can_review():
|
|
messages.error(request, _("Estimate is not ready for review"))
|
|
return redirect("estimate_detail", pk=estimate.pk)
|
|
estimate.mark_as_review()
|
|
|
|
elif mark == "approved":
|
|
if not estimate.can_approve():
|
|
messages.error(request, _("Estimate is not ready for approval"))
|
|
return redirect("estimate_detail", pk=estimate.pk)
|
|
estimate.mark_as_approved()
|
|
messages.success(request, _("Estimate approved successfully."))
|
|
elif mark == "rejected":
|
|
if not estimate.can_cancel():
|
|
messages.error(request, _("Estimate is not ready for rejection"))
|
|
return redirect("estimate_detail", pk=estimate.pk)
|
|
estimate.mark_as_canceled()
|
|
messages.success(request, _("Estimate canceled successfully."))
|
|
elif mark == "completed":
|
|
if not estimate.can_complete():
|
|
messages.error(request, _("Estimate is not ready for completion"))
|
|
return redirect("estimate_detail", pk=estimate.pk)
|
|
elif mark == "canceled":
|
|
if not estimate.can_cancel():
|
|
messages.error(request, _("Estimate is not ready for cancelation"))
|
|
return redirect("estimate_detail", pk=estimate.pk)
|
|
estimate.mark_as_canceled()
|
|
messages.success(request, _("Estimate canceled successfully."))
|
|
estimate.save()
|
|
messages.success(request, "Estimate marked as " + mark.upper())
|
|
|
|
return redirect("estimate_detail", pk=estimate.pk)
|
|
|
|
|
|
# Invoice
|
|
class InvoiceListView(LoginRequiredMixin, ListView):
|
|
model = InvoiceModel
|
|
template_name = "sales/invoices/invoice_list.html"
|
|
context_object_name = "invoices"
|
|
paginate_by = 20
|
|
|
|
def get_queryset(self):
|
|
query = self.request.GET.get("q")
|
|
dealer = get_user_type(self.request)
|
|
invoices = dealer.entity.get_invoices()
|
|
return apply_search_filters(invoices, query)
|
|
|
|
|
|
class InvoiceDetailView(LoginRequiredMixin, DetailView):
|
|
model = InvoiceModel
|
|
template_name = "sales/invoices/invoice_detail.html"
|
|
context_object_name = "invoice"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
invoice = kwargs.get("object")
|
|
|
|
if invoice.get_itemtxs_data():
|
|
calculator = CarFinanceCalculator(invoice)
|
|
finance_data = calculator.get_finance_data()
|
|
kwargs["data"] = finance_data
|
|
kwargs["payments"] = JournalEntryModel.objects.filter(
|
|
ledger=invoice.ledger
|
|
).all()
|
|
|
|
return super().get_context_data(**kwargs)
|
|
|
|
|
|
class DraftInvoiceModelUpdateFormView(LoginRequiredMixin, UpdateView):
|
|
model = InvoiceModel
|
|
form_class = DraftInvoiceModelUpdateForm
|
|
template_name = "sales/invoices/draft_invoice_update.html"
|
|
success_url = reverse_lazy("invoice_list")
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
dealer = get_user_type(self.request)
|
|
kwargs["entity_slug"] = dealer.entity
|
|
kwargs["user_model"] = dealer.entity.admin
|
|
return kwargs
|
|
|
|
|
|
class ApprovedInvoiceModelUpdateFormView(LoginRequiredMixin, UpdateView):
|
|
model = InvoiceModel
|
|
form_class = ApprovedInvoiceModelUpdateForm
|
|
template_name = "sales/invoices/approved_invoice_update.html"
|
|
success_url = reverse_lazy("invoice_list")
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
dealer = get_user_type(self.request)
|
|
kwargs["entity_slug"] = dealer.entity
|
|
kwargs["user_model"] = dealer.entity.admin
|
|
return kwargs
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("invoice_detail", kwargs={"pk": self.object.pk})
|
|
|
|
|
|
class PaidInvoiceModelUpdateFormView(LoginRequiredMixin, UpdateView):
|
|
model = InvoiceModel
|
|
form_class = PaidInvoiceModelUpdateForm
|
|
template_name = "sales/invoices/paid_invoice_update.html"
|
|
success_url = reverse_lazy("invoice_list")
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
dealer = get_user_type(self.request)
|
|
kwargs["entity_slug"] = dealer.entity
|
|
kwargs["user_model"] = dealer.entity.admin
|
|
return kwargs
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("invoice_detail", kwargs={"pk": self.object.pk})
|
|
|
|
def form_valid(self, form):
|
|
invoice = form.save()
|
|
|
|
if invoice.get_amount_open() > 0:
|
|
messages.error(self.request, "Invoice is not fully paid")
|
|
return redirect("invoice_detail", pk=invoice.pk)
|
|
else:
|
|
invoice.post_ledger()
|
|
invoice.save()
|
|
return super().form_valid(form)
|
|
|
|
|
|
@login_required
|
|
def invoice_mark_as(request, pk):
|
|
invoice = get_object_or_404(InvoiceModel, pk=pk)
|
|
dealer = get_user_type(request)
|
|
mark = request.GET.get("mark")
|
|
if mark and mark == "accept":
|
|
if not invoice.can_approve():
|
|
messages.error(request, "invoice is not ready for approval")
|
|
return redirect("invoice_detail", pk=invoice.pk)
|
|
invoice.mark_as_approved(
|
|
entity_slug=dealer.entity.slug, user_model=dealer.entity.admin
|
|
)
|
|
invoice.save()
|
|
return redirect("invoice_detail", pk=invoice.pk)
|
|
|
|
|
|
def invoice_create(request, pk):
|
|
estimate = get_object_or_404(EstimateModel, pk=pk)
|
|
dealer = get_user_type(request)
|
|
entity = dealer.entity
|
|
|
|
if request.method == "POST":
|
|
form = forms.InvoiceModelCreateForm(
|
|
request.POST, entity_slug=entity.slug, user_model=entity.admin
|
|
)
|
|
if form.is_valid():
|
|
invoice = form.save(commit=False)
|
|
ledger = entity.create_ledger(name=str(invoice.pk))
|
|
invoice.ledgar = ledger
|
|
ledger.invoicemodel = invoice
|
|
ledger.save()
|
|
invoice.save()
|
|
|
|
# unit_items = estimate.get_itemtxs_data()[0]
|
|
# vat = models.VatRate.objects.filter(is_active=True).first()
|
|
calculator = CarFinanceCalculator(estimate)
|
|
finance_data = calculator.get_finance_data()
|
|
|
|
# total = 0
|
|
# discount_amount = 0
|
|
|
|
# itemtxs = []
|
|
# for item in unit_items:
|
|
# car = models.Car.objects.get(vin=item.item_model.name)
|
|
|
|
# total = Decimal(car.finances.total) * Decimal(item.ce_quantity)
|
|
# discount_amount = car.finances.discount_amount
|
|
|
|
# grand_total = Decimal(total) - Decimal(discount_amount)
|
|
# vat_amount = round(Decimal(grand_total) * Decimal(vat.rate), 2)
|
|
# grand_total += Decimal(vat_amount)
|
|
# unit_cost = grand_total / Decimal(item.ce_quantity)
|
|
# itemtxs.append(
|
|
# {
|
|
# "item_number": item.item_model.item_number,
|
|
# "unit_cost": unit_cost,
|
|
# "unit_revenue": unit_cost,
|
|
# "quantity": item.ce_quantity,
|
|
# "total_amount": grand_total,
|
|
# }
|
|
# )
|
|
invoice_itemtxs = {
|
|
i.get("item_number"): {
|
|
"unit_cost": i.get("total_vat"),
|
|
"quantity": i.get("quantity"),
|
|
"total_amount": i.get("total_vat"),
|
|
}
|
|
for i in finance_data.get("cars")
|
|
}
|
|
|
|
invoice_itemtxs = invoice.migrate_itemtxs(
|
|
itemtxs=invoice_itemtxs,
|
|
commit=True,
|
|
operation=InvoiceModel.ITEMIZE_APPEND,
|
|
)
|
|
invoice.bind_estimate(estimate)
|
|
invoice.mark_as_review()
|
|
estimate.mark_as_completed()
|
|
estimate.save()
|
|
invoice.save()
|
|
messages.success(request, "Invoice created successfully!")
|
|
return redirect("invoice_detail", pk=invoice.pk)
|
|
form = forms.InvoiceModelCreateForm(
|
|
entity_slug=entity.slug, user_model=entity.admin
|
|
)
|
|
|
|
form.initial.update(
|
|
{
|
|
"customer": estimate.customer,
|
|
"cash_account": entity.get_default_coa_accounts().get(name="Cash"),
|
|
"prepaid_account": entity.get_default_coa_accounts().get(
|
|
name="Accounts Receivable"
|
|
),
|
|
"unearned_account": entity.get_default_coa_accounts().get(
|
|
name="Deferred Revenue"
|
|
),
|
|
}
|
|
)
|
|
|
|
context = {
|
|
"form": form,
|
|
"estimate": estimate,
|
|
}
|
|
return render(request, "sales/invoices/invoice_create.html", context)
|
|
|
|
|
|
class InvoicePreviewView(LoginRequiredMixin, DetailView):
|
|
model = InvoiceModel
|
|
context_object_name = "invoice"
|
|
template_name = "sales/invoices/invoice_preview.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
dealer = get_user_type(self.request)
|
|
invoice = kwargs.get("object")
|
|
if invoice.get_itemtxs_data():
|
|
# data = get_financial_values(invoice)
|
|
calculator = CarFinanceCalculator(invoice)
|
|
finance_data = calculator.get_finance_data()
|
|
kwargs["data"] = finance_data
|
|
kwargs['dealer'] = dealer
|
|
# kwargs["vat_amount"] = data["vat_amount"]
|
|
# kwargs["total"] = data["grand_total"]
|
|
# kwargs["discount_amount"] = data["discount_amount"]
|
|
# kwargs["vat"] = data["vat"]
|
|
# kwargs["car_and_item_info"] = data["car_and_item_info"]
|
|
# kwargs["additional_services"] = data["additional_services"]
|
|
return super().get_context_data(**kwargs)
|
|
|
|
|
|
# payments
|
|
|
|
|
|
def PaymentCreateView(request, pk):
|
|
invoice = InvoiceModel.objects.filter(pk=pk).first()
|
|
bill = BillModel.objects.filter(pk=pk).first()
|
|
model = invoice if invoice else bill
|
|
dealer = get_user_type(request)
|
|
entity = dealer.entity
|
|
form = forms.PaymentForm()
|
|
if request.method == "POST":
|
|
form = forms.PaymentForm(request.POST)
|
|
if form.is_valid():
|
|
amount = form.cleaned_data.get("amount")
|
|
invoice = form.cleaned_data.get("invoice")
|
|
bill = form.cleaned_data.get("bill")
|
|
payment_method = form.cleaned_data.get("payment_method")
|
|
redirect_url = "invoice_detail" if invoice else "bill_detail"
|
|
model = invoice if invoice else bill
|
|
|
|
if not model.is_approved():
|
|
model.mark_as_approved(user_model=entity.admin)
|
|
if model.amount_paid == model.amount_due:
|
|
messages.error(request,"fully paid")
|
|
return redirect(redirect_url, pk=model.pk)
|
|
if model.amount_paid + amount > model.amount_due:
|
|
messages.error(request,"Amount exceeds due amount")
|
|
return redirect(redirect_url, pk=model.pk)
|
|
|
|
try:
|
|
if invoice:
|
|
set_invoice_payment(dealer, entity, invoice, amount, payment_method)
|
|
elif bill:
|
|
set_bill_payment(dealer, entity, bill, amount, payment_method)
|
|
messages.success(request, "Payment created successfully!")
|
|
return redirect(redirect_url, pk=model.pk)
|
|
except Exception as e:
|
|
messages.error(request, f"Error creating payment: {str(e)}")
|
|
else:
|
|
messages.error(request, f"Invalid form data: {str(form.errors)}")
|
|
# return redirect(redirect_url, pk=model.pk)
|
|
form = forms.PaymentForm()
|
|
if model:
|
|
form.initial["amount"] = model.amount_due - model.amount_paid
|
|
if isinstance(model, InvoiceModel):
|
|
form.initial["invoice"] = model
|
|
form.fields["bill"].widget = HiddenInput()
|
|
elif isinstance(model, BillModel):
|
|
form.initial["bill"] = model
|
|
form.fields["invoice"].widget = HiddenInput()
|
|
return render(
|
|
request, "sales/payments/payment_form.html", {"model": model, "form": form}
|
|
)
|
|
|
|
|
|
def PaymentListView(request):
|
|
dealer = get_user_type(request)
|
|
|
|
entity = dealer.entity
|
|
journals = JournalEntryModel.objects.filter(ledger__entity=entity).all()
|
|
return render(request, "sales/payments/payment_list.html", {"journals": journals})
|
|
|
|
|
|
def PaymentDetailView(request, pk):
|
|
journal = JournalEntryModel.objects.filter(pk=pk).first()
|
|
transactions = (
|
|
TransactionModel.objects.filter(journal_entry=journal)
|
|
.order_by("account__code")
|
|
.all()
|
|
)
|
|
return render(
|
|
request,
|
|
"sales/payments/payment_details.html",
|
|
{"journal": journal, "transactions": transactions},
|
|
)
|
|
|
|
|
|
def payment_mark_as_paid(request, pk):
|
|
invoice = get_object_or_404(InvoiceModel, pk=pk)
|
|
if request.method == "POST":
|
|
try:
|
|
if invoice.amount_due == invoice.amount_paid:
|
|
if not invoice.is_paid() and invoice.can_pay():
|
|
invoice.mark_as_paid(
|
|
entity_slug=invoice.ledger.entity.slug,
|
|
user_model=invoice.ledger.entity.admin,
|
|
)
|
|
invoice.save()
|
|
|
|
invoice.ledger.lock_journal_entries()
|
|
invoice.ledger.post_journal_entries()
|
|
|
|
invoice.ledger.post()
|
|
invoice.ledger.save()
|
|
messages.success(request, "Payment created successfully!")
|
|
else:
|
|
messages.error(
|
|
request,
|
|
"Invoice is not fully paid. Payment cannot be marked as paid.",
|
|
)
|
|
except Exception as e:
|
|
messages.error(request, f"Error: {str(e)}")
|
|
return redirect("invoice_detail", pk=invoice.pk)
|
|
|
|
|
|
# activity log
|
|
class UserActivityLogListView(ListView):
|
|
model = models.UserActivityLog
|
|
template_name = "dealers/activity_log.html"
|
|
context_object_name = "logs"
|
|
paginate_by = 20
|
|
|
|
def get_queryset(self):
|
|
queryset = super().get_queryset()
|
|
if "user" in self.request.GET:
|
|
queryset = queryset.filter(user__email=self.request.GET["user"])
|
|
return queryset
|
|
|
|
|
|
# CRM RELATED VIEWS
|
|
class LeadListView(ListView):
|
|
model = models.Lead
|
|
template_name = "crm/leads/lead_list.html"
|
|
context_object_name = "leads"
|
|
paginate_by = 10
|
|
|
|
def get_queryset(self):
|
|
dealer = get_user_type(self.request)
|
|
staff = getattr(self.request.user, "staff", None)
|
|
|
|
if staff:
|
|
return models.Lead.objects.filter(dealer=dealer, staff=staff)
|
|
return models.Lead.objects.filter(dealer=dealer)
|
|
|
|
|
|
class LeadDetailView(DetailView):
|
|
model = models.Lead
|
|
template_name = "crm/leads/lead_detail.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["notes"] = models.Notes.objects.filter(
|
|
content_type__model="lead", object_id=self.object.id
|
|
)
|
|
email_qs = models.Email.objects.filter(
|
|
content_type__model="lead", object_id=self.object.id
|
|
)
|
|
context["emails"] = {
|
|
"sent": email_qs.filter(status="SENT"),
|
|
"draft": email_qs.filter(status="DRAFT"),
|
|
}
|
|
context["activities"] = models.Activity.objects.filter(
|
|
content_type__model="lead", object_id=self.object.id
|
|
)
|
|
context["status_history"] = models.LeadStatusHistory.objects.filter(
|
|
lead=self.object
|
|
)
|
|
return context
|
|
|
|
|
|
def lead_create(request):
|
|
form = forms.LeadForm()
|
|
make = request.GET.get("id_car_make", None)
|
|
|
|
if make:
|
|
form.fields['id_car_model'].queryset = models.CarModel.objects.filter(id_car_make=int(make))
|
|
|
|
if request.method == "POST":
|
|
form = forms.LeadForm(request.POST)
|
|
|
|
# Filter car models based on the selected make (for POST requests)
|
|
if 'id_car_make' in request.POST:
|
|
form.fields['id_car_model'].queryset = models.CarModel.objects.filter(
|
|
id_car_make=int(request.POST['id_car_make'])
|
|
)
|
|
try:
|
|
if form.is_valid():
|
|
instance = form.save(commit=False)
|
|
dealer = get_user_type(request)
|
|
instance.dealer = dealer
|
|
staff = None
|
|
if hasattr(request.user, "staffmember"):
|
|
staff = request.user.staffmember.staff
|
|
instance.staff = staff
|
|
|
|
# creating customer in ledger
|
|
customer = dealer.entity.get_customers().filter(email=instance.email).first()
|
|
if not customer:
|
|
customer = dealer.entity.create_customer(
|
|
customer_model_kwargs={
|
|
"customer_name": instance.full_name,
|
|
"address_1": instance.address,
|
|
"phone": instance.phone_number,
|
|
"email": instance.email,
|
|
"sales_tax_rate": 0.15,
|
|
}
|
|
)
|
|
instance.customer = customer
|
|
instance.save()
|
|
messages.success(request, "Lead created successfully!")
|
|
return redirect("lead_list")
|
|
except Exception as e:
|
|
messages.error(request, f"Lead was not created ... : {str(e)}")
|
|
|
|
return render(request, "crm/leads/lead_form.html", {"form": form})
|
|
|
|
|
|
class LeadUpdateView(UpdateView):
|
|
model = models.Lead
|
|
form_class = forms.LeadForm
|
|
template_name = "crm/leads/lead_form.html"
|
|
success_url = reverse_lazy("lead_list")
|
|
|
|
def get_form(self, form_class=None):
|
|
form = super().get_form(form_class)
|
|
form.fields["id_car_model"].queryset = form.instance.id_car_make.carmodel_set.all()
|
|
return form
|
|
|
|
|
|
@login_required
|
|
def LeadDeleteView(request,pk):
|
|
lead = get_object_or_404(models.Lead, pk=pk)
|
|
lead.delete()
|
|
messages.success(request, "Lead deleted successfully!")
|
|
return redirect("lead_list")
|
|
|
|
|
|
@login_required
|
|
def add_note_to_lead(request, pk):
|
|
lead = get_object_or_404(models.Lead, pk=pk)
|
|
if request.method == "POST":
|
|
form = forms.NoteForm(request.POST)
|
|
if form.is_valid():
|
|
note = form.save(commit=False)
|
|
note.content_object = lead
|
|
note.created_by = request.user
|
|
note.save()
|
|
messages.success(request, "Note added successfully!")
|
|
return redirect("lead_detail", pk=lead.pk)
|
|
else:
|
|
form = forms.NoteForm()
|
|
return render(request, "crm/note_form.html", {"form": form, "lead": lead})
|
|
|
|
@login_required
|
|
def add_note_to_opportunity(request, pk):
|
|
opportunity = get_object_or_404(models.Opportunity, pk=pk)
|
|
if request.method == "POST":
|
|
notes = request.POST.get("notes")
|
|
if not notes:
|
|
messages.error(request, "Notes field is required.")
|
|
else:
|
|
models.Notes.objects.create(content_object=opportunity, created_by=request.user,note=notes)
|
|
messages.success(request, "Note added successfully!")
|
|
return redirect("opportunity_detail", pk=opportunity.pk)
|
|
|
|
|
|
@login_required
|
|
def update_note(request, pk):
|
|
note = get_object_or_404(models.Notes, pk=pk, created_by=request.user)
|
|
lead_pk = note.content_object.pk
|
|
|
|
if request.method == "POST":
|
|
form = forms.NoteForm(request.POST, instance=note)
|
|
if form.is_valid():
|
|
updated_note = form.save(commit=False)
|
|
updated_note.content_object = note.content_object
|
|
updated_note.created_by = request.user
|
|
updated_note.save()
|
|
messages.success(request, "Note updated successfully!")
|
|
return redirect("lead_detail", pk=lead_pk)
|
|
else:
|
|
form = forms.NoteForm(instance=note)
|
|
|
|
return render(request, "crm/note_form.html", {"form": form, "note": note})
|
|
|
|
|
|
@login_required
|
|
def delete_note(request, pk):
|
|
note = get_object_or_404(models.Notes, pk=pk, created_by=request.user)
|
|
lead_pk = note.content_object.pk
|
|
note.delete()
|
|
messages.success(request, _("Note deleted successfully."))
|
|
return redirect("lead_detail", pk=lead_pk)
|
|
|
|
|
|
@login_required
|
|
def lead_convert(request, pk):
|
|
lead = get_object_or_404(models.Lead, pk=pk)
|
|
dealer = get_user_type(request)
|
|
if hasattr(lead, "opportunity"):
|
|
messages.error(request, "Lead is already converted to customer.")
|
|
else:
|
|
customer = lead.convert_to_customer(dealer.entity)
|
|
models.Opportunity.objects.create(dealer=dealer,customer=customer,lead=lead,probability=50,stage=models.Stage.PROSPECT,staff=lead.staff,status=models.Status.QUALIFIED)
|
|
messages.success(request, "Lead converted to customer successfully!")
|
|
return redirect("lead_list")
|
|
|
|
@login_required
|
|
def schedule_lead(request, pk):
|
|
if not hasattr(request.user,"staffmember"):
|
|
messages.error(request, "You do not have permission to schedule lead.")
|
|
return redirect("lead_list")
|
|
dealer = get_user_type(request)
|
|
|
|
lead = get_object_or_404(models.Lead, pk=pk, dealer=dealer)
|
|
if request.method == "POST":
|
|
form = forms.ScheduleForm(request.POST)
|
|
if form.is_valid():
|
|
instance = form.save(commit=False)
|
|
instance.lead = lead
|
|
instance.scheduled_by = request.user
|
|
instance.save()
|
|
|
|
# Create AppointmentRequest
|
|
service = Service.objects.filter(name=instance.scheduled_type).first()
|
|
if not service:
|
|
messages.error(request, "Service not found!")
|
|
return redirect("lead_list")
|
|
# staff_member = StaffMember.objects.filter(user=request.user).first()
|
|
staff_member = request.user.staffmember
|
|
|
|
appointment_request = AppointmentRequest.objects.create(
|
|
date=instance.scheduled_at.date(),
|
|
start_time=instance.scheduled_at.time(),
|
|
end_time=(instance.scheduled_at + instance.duration).time(),
|
|
service=service,
|
|
staff_member=staff_member,
|
|
)
|
|
client = get_object_or_404(User, email=lead.email)
|
|
# Create Appointment
|
|
Appointment.objects.create(
|
|
client=client,
|
|
appointment_request=appointment_request,
|
|
phone=lead.phone_number,
|
|
address=lead.address,
|
|
)
|
|
|
|
messages.success(request, "Lead scheduled and appointment created successfully!")
|
|
return redirect("lead_list")
|
|
else:
|
|
messages.error(request, f"Invalid form data: {str(form.errors)}")
|
|
return redirect("lead_list")
|
|
|
|
form = forms.ScheduleForm()
|
|
return render(request, "crm/leads/schedule_lead.html", {"lead": lead, "form": form})
|
|
|
|
|
|
@login_required
|
|
def send_lead_email(request, pk,email_pk=None):
|
|
lead = get_object_or_404(models.Lead, pk=pk)
|
|
status = request.GET.get("status")
|
|
if status == 'draft':
|
|
models.Email.objects.create(content_object=lead, created_by=request.user,from_email="manager@tenhal.com", to_email=request.GET.get("to"), subject=request.GET.get("subject"), message=request.GET.get("message"),status=models.EmailStatus.DRAFT)
|
|
models.Activity.objects.create(content_object=lead, notes="Email Draft",created_by=request.user,activity_type=models.ActionChoices.EMAIL)
|
|
messages.success(request, _("Email Draft successfully!"))
|
|
response = HttpResponse(redirect("lead_detail", pk=lead.pk))
|
|
response['HX-Redirect'] = reverse('lead_detail', args=[lead.pk])
|
|
return response
|
|
|
|
dealer = get_user_type(request)
|
|
lead.status = models.Status.IN_PROGRESS
|
|
lead.save()
|
|
# lead.convert_to_customer(dealer.entity)
|
|
|
|
if request.method == "POST":
|
|
email_pk = request.POST.get('email_pk')
|
|
if email_pk not in [None,"None",""]:
|
|
email = get_object_or_404(models.Email, pk=int(email_pk))
|
|
email.status = models.EmailStatus.SENT
|
|
email.save()
|
|
else:
|
|
models.Email.objects.create(content_object=lead, created_by=request.user,from_email="manager@tenhal.com", to_email=request.POST.get("to"), subject=request.POST.get("subject"), message=request.POST.get("message"),status=models.EmailStatus.SENT)
|
|
send_email(
|
|
"manager@tenhal.com",
|
|
request.POST.get("to"),
|
|
request.POST.get("subject"),
|
|
request.POST.get("message"),
|
|
)
|
|
dealer = get_user_type(request)
|
|
models.Activity.objects.create(dealer=dealer,content_object=lead, notes="Email sent",created_by=request.user,activity_type=models.ActionChoices.EMAIL)
|
|
messages.success(request, _("Email sent successfully!"))
|
|
return redirect("lead_list")
|
|
msg = f"""
|
|
السلام عليكم
|
|
Dear {lead.full_name},
|
|
|
|
أود أن أشارككم تقدير المشروع الذي ناقشناه. يرجى العثور على الوثيقة التفصيلية للمقترح المرفقة.
|
|
|
|
I hope this email finds you well. I wanted to share with you the estimate for the project we discussed. Please find the detailed estimate document attached.
|
|
|
|
يرجى مراجعة المقترح وإعلامي إذا كانت لديك أي أسئلة أو مخاوف. إذا كانت كل شيء يبدو جيدًا، يمكننا المضي قدمًا في المشروع.
|
|
|
|
Please review the estimate and let me know if you have any questions or concerns. If everything looks good, we can proceed with the project.
|
|
|
|
شكراً لاهتمامكم بهذا الأمر.
|
|
Thank you for your attention to this matter.
|
|
|
|
تحياتي,
|
|
Best regards,
|
|
[Your Name]
|
|
[Your Position]
|
|
[Your Company]
|
|
[Your Contact Information]
|
|
"""
|
|
subject = ""
|
|
if email_pk:
|
|
email = get_object_or_404(models.Email, pk=email_pk)
|
|
msg = email.message
|
|
subject = email.subject
|
|
return render(
|
|
request,
|
|
"crm/leads/lead_send.html",
|
|
{"lead": lead, "message": msg,"subject":subject, "email_pk": email_pk},
|
|
)
|
|
|
|
|
|
@login_required
|
|
def add_activity_to_lead(request, pk):
|
|
lead = get_object_or_404(models.Lead, pk=pk)
|
|
if request.method == "POST":
|
|
form = forms.ActivityForm(request.POST)
|
|
if form.is_valid():
|
|
activity = form.save(commit=False)
|
|
activity.content_object = lead
|
|
activity.created_by = request.user
|
|
activity.save()
|
|
return redirect("lead_detail", pk=pk)
|
|
else:
|
|
form = forms.ActivityForm()
|
|
return render(request, "crm/add_activity.html", {"form": form, "lead": lead})
|
|
|
|
|
|
class OpportunityCreateView(CreateView, LoginRequiredMixin):
|
|
model = models.Opportunity
|
|
form_class = forms.OpportunityForm
|
|
template_name = "crm/opportunities/opportunity_form.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
dealer = get_user_type(self.request)
|
|
return context
|
|
|
|
def get_initial(self):
|
|
initial = super().get_initial()
|
|
if self.kwargs.get('pk',None):
|
|
lead = models.Lead.objects.get(pk=self.kwargs.get('pk'))
|
|
|
|
initial['customer'] = lead.customer
|
|
return initial
|
|
|
|
def form_valid(self, form):
|
|
dealer = get_user_type(self.request)
|
|
form.instance.dealer = dealer
|
|
# staff = dealer.staff
|
|
print(dealer)
|
|
# print(staff)
|
|
# form.instance.staff = staff
|
|
return super().form_valid(form)
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("opportunity_detail", kwargs={"pk": self.object.pk})
|
|
|
|
|
|
class OpportunityUpdateView(UpdateView, LoginRequiredMixin):
|
|
model = models.Opportunity
|
|
form_class = forms.OpportunityForm
|
|
template_name = "crm/opportunities/opportunity_form.html"
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("opportunity_detail", kwargs={"pk": self.object.pk})
|
|
|
|
|
|
class OpportunityDetailView(DetailView):
|
|
model = models.Opportunity
|
|
template_name = "crm/opportunities/opportunity_detail.html"
|
|
context_object_name = "opportunity"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
form = forms.OpportunityStatusForm()
|
|
url = reverse("opportunity_update_status", args=[self.object.pk])
|
|
form.fields["status"].widget.attrs["hx-get"] = url
|
|
form.fields["stage"].widget.attrs["hx-get"] = url
|
|
form.fields["status"].initial = self.object.status
|
|
form.fields["stage"].initial = self.object.stage
|
|
context["status_form"] = form
|
|
context["notes"] = models.Notes.objects.filter(content_type__model="opportunity", object_id=self.object.id)
|
|
context["activities"] = models.Activity.objects.filter(content_type__model="opportunity", object_id=self.object.id)
|
|
email_qs = models.Email.objects.filter(content_type__model="opportunity", object_id=self.object.id)
|
|
context["emails"] = {
|
|
"sent": email_qs.filter(status="SENT"),
|
|
"draft": email_qs.filter(status="DRAFT"),
|
|
}
|
|
return context
|
|
|
|
|
|
class OpportunityListView(ListView):
|
|
model = models.Opportunity
|
|
template_name = "crm/opportunities/opportunity_list.html"
|
|
context_object_name = "opportunities"
|
|
paginate_by = 10
|
|
|
|
def get_queryset(self):
|
|
dealer = get_user_type(self.request)
|
|
return models.Opportunity.objects.filter(dealer=dealer).all()
|
|
|
|
@login_required
|
|
def delete_opportunity(request, pk):
|
|
opportunity = get_object_or_404(models.Opportunity, pk=pk)
|
|
opportunity.delete()
|
|
messages.success(request, _("Opportunity deleted successfully."))
|
|
return redirect("opportunity_list")
|
|
|
|
def opportunity_update_status(request,pk):
|
|
opportunity = get_object_or_404(models.Opportunity, pk=pk)
|
|
status = request.GET.get("status")
|
|
stage = request.GET.get("stage")
|
|
if status:
|
|
opportunity.status = status
|
|
if stage:
|
|
opportunity.stage = stage
|
|
opportunity.save()
|
|
messages.success(request,"Opportunity status updated successfully")
|
|
# response = HttpResponse(render(request, "crm/opportunities/opportunity_detail.html"),{"opportunity":opportunity})
|
|
response = HttpResponse(redirect("opportunity_detail",pk=opportunity.pk))
|
|
response['HX-Refresh'] = 'true'
|
|
return response
|
|
# return render(request,"crm/opportunities/opportunity_detail.html",{"opportunity":opportunity})
|
|
|
|
# class OpportunityLogsView(LoginRequiredMixin, ListView):
|
|
# model = models.OpportunityLog
|
|
# template_name = "crm/opportunity_logs.html"
|
|
# context_object_name = "logs"
|
|
#
|
|
# def get_queryset(self):
|
|
# opportunity_id = self.kwargs["pk"]
|
|
# return models.OpportunityLog.objects.filter(
|
|
# opportunity_id=opportunity_id
|
|
# ).order_by("-created_at")
|
|
#
|
|
# def get_context_data(self, **kwargs):
|
|
# context = super().get_context_data(**kwargs)
|
|
# context["opportunity"] = models.Opportunity.objects.get(pk=self.kwargs["pk"])
|
|
# return context
|
|
|
|
|
|
class NotificationListView(LoginRequiredMixin, ListView):
|
|
model = models.Notification
|
|
template_name = "crm/notifications_history.html"
|
|
context_object_name = "notifications"
|
|
paginate_by = 20
|
|
ordering = "-created"
|
|
|
|
def get_queryset(self):
|
|
return models.Notification.objects.filter(user=self.request.user)
|
|
|
|
|
|
@login_required
|
|
def mark_notification_as_read(request, pk):
|
|
notification = get_object_or_404(models.Notification, pk=pk, user=request.user)
|
|
notification.is_read = True
|
|
notification.save()
|
|
messages.success(request, _("Notification marked as read."))
|
|
return redirect("notifications_history")
|
|
|
|
|
|
@login_required
|
|
def fetch_notifications(request):
|
|
notifications = models.Notification.objects.filter(
|
|
user=request.user, is_read=False
|
|
).order_by("-created")
|
|
# notifications_data = [
|
|
# {
|
|
# "id": notification.id,
|
|
# "message": notification.message,
|
|
# "created": notification.created.strftime("%Y-%m-%d %H:%M:%S"),
|
|
# }
|
|
# for notification in notifications
|
|
# ]
|
|
# return JsonResponse({"notifications": notifications_data})
|
|
return render(request, "notifications.html", {"notifications_": notifications})
|
|
|
|
|
|
class ItemServiceCreateView(LoginRequiredMixin, SuccessMessageMixin, CreateView):
|
|
model = models.AdditionalServices
|
|
form_class = forms.AdditionalServiceForm
|
|
template_name = "items/service/service_create.html"
|
|
success_url = reverse_lazy("item_service_list")
|
|
success_message = _("Service created successfully.")
|
|
context_object_name = "service"
|
|
|
|
def form_valid(self, form):
|
|
vat = models.VatRate.objects.get(is_active=True)
|
|
dealer = get_user_type(self.request)
|
|
form.instance.dealer = dealer
|
|
if form.instance.taxable:
|
|
form.instance.price = (form.instance.price * vat.rate) + form.instance.price
|
|
return super().form_valid(form)
|
|
|
|
|
|
class ItemServiceUpdateView(LoginRequiredMixin, SuccessMessageMixin, UpdateView):
|
|
model = models.AdditionalServices
|
|
form_class = forms.AdditionalServiceForm
|
|
template_name = "items/service/service_create.html"
|
|
success_url = reverse_lazy("item_service_list")
|
|
success_message = _("Service updated successfully.")
|
|
context_object_name = "service"
|
|
|
|
def form_valid(self, form):
|
|
vat = models.VatRate.objects.get(is_active=True)
|
|
dealer = get_user_type(self.request)
|
|
form.instance.dealer = dealer
|
|
if form.instance.taxable:
|
|
form.instance.price = (form.instance.price * vat.rate) + form.instance.price
|
|
return super().form_valid(form)
|
|
|
|
|
|
class ItemServiceListView(ListView, LoginRequiredMixin):
|
|
model = models.AdditionalServices
|
|
template_name = "items/service/service_list.html"
|
|
context_object_name = "services"
|
|
paginate_by = 20
|
|
|
|
def get_queryset(self):
|
|
dealer = get_user_type(self.request)
|
|
return models.AdditionalServices.objects.filter(dealer=dealer).all()
|
|
|
|
|
|
class ItemExpenseCreateView(CreateView, LoginRequiredMixin):
|
|
model = ItemModel
|
|
form_class = ExpenseItemCreateForm
|
|
template_name = "items/expenses/expense_create.html"
|
|
success_url = reverse_lazy("item_expense_list")
|
|
|
|
def get_form_kwargs(self):
|
|
dealer = get_user_type(self.request)
|
|
kwargs = super().get_form_kwargs()
|
|
kwargs["entity_slug"] = dealer.entity.slug
|
|
kwargs["user_model"] = dealer.entity.admin
|
|
return kwargs
|
|
|
|
def form_valid(self, form):
|
|
dealer = get_user_type(self.request)
|
|
form.instance.entity = dealer.entity
|
|
return super().form_valid(form)
|
|
|
|
|
|
class ItemExpenseUpdateView(UpdateView, LoginRequiredMixin):
|
|
model = ItemModel
|
|
form_class = ExpenseItemUpdateForm
|
|
template_name = "items/expenses/expense_update.html"
|
|
success_url = reverse_lazy("item_expense_list")
|
|
|
|
def get_form_kwargs(self):
|
|
dealer = get_user_type(self.request)
|
|
kwargs = super().get_form_kwargs()
|
|
kwargs["entity_slug"] = dealer.entity.slug
|
|
kwargs["user_model"] = dealer.entity.admin
|
|
return kwargs
|
|
|
|
def form_valid(self, form):
|
|
dealer = get_user_type(self.request)
|
|
form.instance.entity = dealer.entity
|
|
return super().form_valid(form)
|
|
|
|
|
|
class ItemExpenseListView(ListView, LoginRequiredMixin):
|
|
model = ItemModel
|
|
template_name = "items/expenses/expenses_list.html"
|
|
context_object_name = "expenses"
|
|
paginate_by = 20
|
|
|
|
def get_queryset(self):
|
|
dealer = get_user_type(self.request)
|
|
return dealer.entity.get_items_expenses()
|
|
|
|
|
|
class BillListView(ListView, LoginRequiredMixin):
|
|
model = BillModel
|
|
template_name = "ledger/bills/bill_list.html"
|
|
context_object_name = "bills"
|
|
|
|
def get_queryset(self):
|
|
dealer = get_user_type(self.request)
|
|
qs = dealer.entity.get_bills()
|
|
return qs
|
|
|
|
|
|
class BillDetailView(LoginRequiredMixin, DetailView):
|
|
model = BillModel
|
|
template_name = "ledger/bills/bill_detail.html"
|
|
context_object_name = "bill"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
bill = kwargs.get("object")
|
|
if bill.get_itemtxs_data():
|
|
txs = bill.get_itemtxs_data()[0]
|
|
|
|
transactions = [
|
|
{
|
|
"item": x,
|
|
"total": Decimal(x.unit_cost) * Decimal(x.quantity),
|
|
}
|
|
for x in txs
|
|
]
|
|
grand_total = sum(
|
|
Decimal(x.unit_cost) * Decimal(x.quantity)
|
|
for x in txs
|
|
)
|
|
# vat = models.VatRate.objects.filter(is_active=True).first()
|
|
# if vat:
|
|
# grand_total += round(Decimal(grand_total) * Decimal(vat.rate), 2)
|
|
kwargs["transactions"] = transactions
|
|
kwargs["grand_total"] = grand_total
|
|
print(dir(txs[0]))
|
|
return super().get_context_data(**kwargs)
|
|
|
|
|
|
class InReviewBillView(LoginRequiredMixin, UpdateView):
|
|
model = BillModel
|
|
form_class = InReviewBillModelUpdateForm
|
|
template_name = "ledger/bills/bill_update_form.html"
|
|
success_url = reverse_lazy("bill_list")
|
|
success_message = _("Bill updated successfully.")
|
|
context_object_name = "bill"
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
dealer = get_user_type(self.request)
|
|
kwargs["entity_model"] = dealer.entity
|
|
kwargs["user_model"] = dealer.entity.admin
|
|
return kwargs
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("bill_detail", kwargs={"pk": self.kwargs["pk"]})
|
|
|
|
def form_valid(self, form):
|
|
dealer = get_user_type(self.request)
|
|
form.instance.entity = dealer.entity
|
|
self.object.mark_as_review()
|
|
return super().form_valid(form)
|
|
|
|
|
|
class ApprovedBillModelView(LoginRequiredMixin, UpdateView):
|
|
model = BillModel
|
|
form_class = ApprovedBillModelUpdateForm
|
|
template_name = "ledger/bills/bill_update_form.html"
|
|
success_url = reverse_lazy("bill_list")
|
|
success_message = _("Bill updated successfully.")
|
|
context_object_name = "bill"
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
dealer = get_user_type(self.request)
|
|
kwargs["entity_model"] = dealer.entity
|
|
kwargs["user_model"] = dealer.entity.admin
|
|
return kwargs
|
|
|
|
def get_success_url(self):
|
|
return reverse_lazy("bill_detail", kwargs={"pk": self.kwargs["pk"]})
|
|
|
|
def form_valid(self, form):
|
|
dealer = get_user_type(self.request)
|
|
form.instance.entity = dealer.entity
|
|
if not self.object.is_approved():
|
|
self.object.mark_as_approved(user_model=dealer.entity.admin)
|
|
return super().form_valid(form)
|
|
|
|
|
|
@login_required
|
|
def bill_mark_as_approved(request, pk):
|
|
bill = get_object_or_404(BillModel, pk=pk)
|
|
if request.method == "POST":
|
|
dealer = get_user_type(request)
|
|
if bill.is_approved():
|
|
messages.error(request, _("Bill is already approved."))
|
|
return redirect("bill_detail", pk=bill.pk)
|
|
bill.mark_as_approved(user_model=dealer.entity.admin)
|
|
bill.save()
|
|
messages.success(request, _("Bill marked as approved successfully."))
|
|
return redirect("bill_detail", pk=bill.pk)
|
|
|
|
|
|
@login_required
|
|
def bill_mark_as_paid(request, pk):
|
|
bill = get_object_or_404(BillModel, pk=pk)
|
|
if request.method == "POST":
|
|
dealer = get_user_type(request)
|
|
if bill.is_paid():
|
|
messages.error(request, _("Bill is already paid."))
|
|
return redirect("bill_detail", pk=bill.pk)
|
|
if bill.amount_due == bill.amount_paid:
|
|
bill.mark_as_paid(user_model=dealer.entity.admin)
|
|
bill.save()
|
|
bill.ledger.lock_journal_entries()
|
|
bill.ledger.post_journal_entries()
|
|
bill.ledger.post()
|
|
bill.ledger.save()
|
|
messages.success(request, _("Bill marked as paid successfully."))
|
|
else:
|
|
messages.error(request, _("Amount paid is not equal to amount due."))
|
|
return redirect("bill_detail", pk=bill.pk)
|
|
|
|
# def get_context_data(self, **kwargs):
|
|
# dealer = get_user_type(self.request)
|
|
# context = super().get_context_data(**kwargs)
|
|
# context['entity_model'] = dealer.entity
|
|
# context['user_model'] = dealer.entity.admin
|
|
|
|
# return context
|
|
|
|
|
|
# class BillCreateView(LoginRequiredMixin, SuccessMessageMixin, CreateView):
|
|
# model = BillModel
|
|
# form_class = BillModelCreateForm
|
|
# template_name = "ledger/bills/bill_form.html"
|
|
# success_url = reverse_lazy("bill_list")
|
|
# success_message = _("Bill created successfully.")
|
|
# def get_form_kwargs(self):
|
|
# dealer = get_user_type(self.request)
|
|
# kwargs = super().get_form_kwargs()
|
|
# kwargs["entity_model"] = dealer.entity
|
|
# return kwargs
|
|
|
|
|
|
# def form_valid(self, form):
|
|
# dealer = get_user_type(self.request)
|
|
# form.instance.entity = dealer.entity
|
|
# ledger = dealer.entity.create_ledger(
|
|
# name=f"Bill for Vendor {form.instance.vendor.vendor_name}", posted=True
|
|
# )
|
|
# form.instance.ledger = ledger
|
|
# return super().form_valid(form)
|
|
|
|
@login_required
|
|
def bill_create(request):
|
|
dealer = get_user_type(request)
|
|
entity = dealer.entity
|
|
|
|
if request.method == "POST":
|
|
data = json.loads(request.body)
|
|
vendor_id = data.get("vendor")
|
|
terms = data.get("terms")
|
|
vendor = entity.get_vendors().filter(pk=vendor_id).first()
|
|
|
|
items = data.get("item", [])
|
|
quantities = data.get("quantity", [])
|
|
|
|
if not all([items, quantities]):
|
|
return JsonResponse(
|
|
{"status": "error", "message": "Items and Quantities are required"},
|
|
status=400,
|
|
)
|
|
if isinstance(quantities, list):
|
|
if "0" in quantities:
|
|
return JsonResponse(
|
|
{"status": "error", "message": "Quantity must be greater than zero"}
|
|
)
|
|
else:
|
|
if int(quantities) <= 0:
|
|
return JsonResponse(
|
|
{"status": "error", "message": "Quantity must be greater than zero"}
|
|
)
|
|
|
|
bill = entity.create_bill(vendor_model=vendor, terms=terms)
|
|
if isinstance(items, list):
|
|
item_quantity_map = {}
|
|
for item, quantity in zip(items, quantities):
|
|
if item in item_quantity_map:
|
|
item_quantity_map[item] += int(quantity)
|
|
else:
|
|
item_quantity_map[item] = int(quantity)
|
|
item_list = list(item_quantity_map.keys())
|
|
quantity_list = list(item_quantity_map.values())
|
|
|
|
items_list = [
|
|
{"item_id": item_list[i], "quantity": quantity_list[i]}
|
|
for i in range(len(item_list))
|
|
]
|
|
items_txs = []
|
|
for item in items_list:
|
|
item_instance = ItemModel.objects.get(pk=item.get("item_id"))
|
|
car = models.Car.objects.get(vin=item_instance.name)
|
|
quantity = Decimal(item.get("quantity"))
|
|
items_txs.append(
|
|
{
|
|
"item_number": item_instance.item_number,
|
|
"quantity": quantity,
|
|
"unit_cost": car.finances.cost_price,
|
|
"total_amount": car.finances.cost_price * quantity,
|
|
}
|
|
)
|
|
|
|
bill_itemtxs = {
|
|
item.get("item_number"): {
|
|
"unit_cost": item.get("unit_cost"),
|
|
"quantity": item.get("quantity"),
|
|
"total_amount": item.get("total_amount"),
|
|
}
|
|
for item in items_txs
|
|
}
|
|
else:
|
|
item = entity.get_items_all().filter(pk=items).first()
|
|
instance = models.Car.objects.get(vin=item.name)
|
|
bill_itemtxs = {
|
|
item.item_number: {
|
|
"unit_cost": instance.finances.cost_price,
|
|
"quantity": Decimal(quantities),
|
|
"total_amount": instance.finances.cost_price * Decimal(quantities),
|
|
}
|
|
}
|
|
|
|
bill_itemtxs = bill.migrate_itemtxs(
|
|
itemtxs=bill_itemtxs,
|
|
commit=True,
|
|
operation=BillModel.ITEMIZE_APPEND,
|
|
)
|
|
|
|
url = reverse("bill_detail", kwargs={"pk": bill.pk})
|
|
return JsonResponse(
|
|
{
|
|
"status": "success",
|
|
"message": "Bill created successfully!",
|
|
"url": f"{url}",
|
|
}
|
|
)
|
|
|
|
form = forms.BillModelCreateForm(entity_model=entity)
|
|
form.initial.update(
|
|
{
|
|
"cash_account": entity.get_default_coa_accounts().get(name="Cash"),
|
|
"prepaid_account": entity.get_default_coa_accounts().get(
|
|
name="Prepaid Expenses"
|
|
),
|
|
"unearned_account": entity.get_default_coa_accounts().get(
|
|
name="Accounts Payable"
|
|
),
|
|
}
|
|
)
|
|
car_list = models.Car.objects.filter(dealer=dealer)
|
|
context = {
|
|
"form": form,
|
|
"items": [
|
|
{
|
|
"car": x,
|
|
"product": entity.get_items_products().filter(name=x.vin).first(),
|
|
}
|
|
for x in car_list
|
|
],
|
|
}
|
|
|
|
return render(request, "ledger/bills/bill_form.html", context)
|
|
|
|
|
|
@login_required
|
|
def BillDeleteView(request, pk):
|
|
bill = get_object_or_404(BillModel, pk=pk)
|
|
bill.delete()
|
|
return redirect("bill_list")
|
|
|
|
|
|
# class SubscriptionPlans(ListView, LoginRequiredMixin):
|
|
# model = models.SubscriptionPlan
|
|
# template_name = "subscriptions/subscription_plan.html"
|
|
# context_object_name = "plans"
|
|
|
|
|
|
# orders
|
|
class OrderListView(ListView):
|
|
model = models.SaleOrder
|
|
template_name = "sales/orders/order_list.html"
|
|
context_object_name = "orders"
|
|
|
|
|
|
# email
|
|
@login_required
|
|
def send_email_view(request, pk):
|
|
estimate = get_object_or_404(EstimateModel, pk=pk)
|
|
if request.method == "POST":
|
|
# if not estimate.can_review():
|
|
# messages.error(request, "Estimate is not ready for review")
|
|
# return redirect("estimate_detail", pk=estimate.pk)
|
|
if not estimate.get_itemtxs_data()[0]:
|
|
messages.error(request, _("Estimate has no items"))
|
|
return redirect("estimate_detail", pk=estimate.pk)
|
|
|
|
send_email(
|
|
"manager@tenhal.com",
|
|
request.POST.get("to"),
|
|
request.POST.get("subject"),
|
|
request.POST.get("message"),
|
|
)
|
|
estimate.mark_as_review()
|
|
messages.success(request, _("Email sent successfully!"))
|
|
return redirect("estimate_detail", pk=estimate.pk)
|
|
link = reverse_lazy("estimate_preview", kwargs={"pk": estimate.pk})
|
|
msg = f"""
|
|
السلام عليكم
|
|
Dear {estimate.customer.customer_name},
|
|
|
|
أود أن أشارككم تقدير المشروع الذي ناقشناه. يرجى العثور على الوثيقة التفصيلية للمقترح المرفقة.
|
|
|
|
I hope this email finds you well. I wanted to share with you the estimate for the project we discussed. Please find the detailed estimate document attached.
|
|
|
|
يرجى مراجعة المقترح وإعلامي إذا كانت لديك أي أسئلة أو مخاوف. إذا كانت كل شيء يبدو جيدًا، يمكننا المضي قدمًا في المشروع.
|
|
|
|
Please review the estimate and let me know if you have any questions or concerns. If everything looks good, we can proceed with the project.
|
|
|
|
Estimate Link:
|
|
{link}
|
|
|
|
شكراً لاهتمامكم بهذا الأمر.
|
|
Thank you for your attention to this matter.
|
|
|
|
تحياتي,
|
|
Best regards,
|
|
[Your Name]
|
|
[Your Position]
|
|
[Your Company]
|
|
[Your Contact Information]
|
|
"""
|
|
return render(
|
|
request,
|
|
"sales/estimates/estimate_send.html",
|
|
{"estimate": estimate, "message": msg},
|
|
)
|
|
|
|
|
|
# errors
|
|
def custom_page_not_found_view(request, exception):
|
|
return render(request, "errors/404.html", {})
|
|
|
|
|
|
def custom_error_view(request, exception=None):
|
|
return render(request, "errors/500.html", {})
|
|
|
|
|
|
def custom_permission_denied_view(request, exception=None):
|
|
return render(request, "errors/403.html", {})
|
|
|
|
|
|
def custom_bad_request_view(request, exception=None):
|
|
return render(request, "errors/400.html", {})
|
|
|
|
|
|
# BALANCE SHEET
|
|
class BaseBalanceSheetRedirectView(DjangoLedgerSecurityMixIn, RedirectView):
|
|
def get_redirect_url(self, *args, **kwargs):
|
|
year = get_localdate().year
|
|
return reverse(
|
|
"entity-bs-year",
|
|
kwargs={"entity_slug": self.kwargs["entity_slug"], "year": year},
|
|
)
|
|
|
|
|
|
class FiscalYearBalanceSheetViewBase(FiscalYearBalanceSheetView,DjangoLedgerSecurityMixIn):
|
|
template_name = "ledger/reports/balance_sheet.html"
|
|
|
|
|
|
class QuarterlyBalanceSheetView(FiscalYearBalanceSheetViewBase, QuarterlyReportMixIn, DjangoLedgerSecurityMixIn):
|
|
"""
|
|
Quarter Balance Sheet View.
|
|
"""
|
|
|
|
|
|
class MonthlyBalanceSheetView(FiscalYearBalanceSheetViewBase, MonthlyReportMixIn, DjangoLedgerSecurityMixIn):
|
|
"""
|
|
Monthly Balance Sheet View.
|
|
"""
|
|
|
|
|
|
class DateBalanceSheetView(FiscalYearBalanceSheetViewBase, DateReportMixIn, DjangoLedgerSecurityMixIn):
|
|
"""
|
|
Date Balance Sheet View.
|
|
"""
|
|
|
|
|
|
# Income Statement -----------
|
|
|
|
|
|
class BaseIncomeStatementRedirectViewBase(BaseIncomeStatementRedirectView, DjangoLedgerSecurityMixIn):
|
|
def get_redirect_url(self, *args, **kwargs):
|
|
year = get_localdate().year
|
|
dealer = get_user_type(self.request)
|
|
return reverse(
|
|
"entity-ic-year", kwargs={"entity_slug": dealer.entity.slug, "year": year}
|
|
)
|
|
|
|
|
|
class FiscalYearIncomeStatementViewBase(FiscalYearIncomeStatementView, DjangoLedgerSecurityMixIn):
|
|
template_name = "ledger/reports/income_statement.html"
|
|
|
|
|
|
class QuarterlyIncomeStatementView(
|
|
FiscalYearIncomeStatementViewBase, QuarterlyReportMixIn, DjangoLedgerSecurityMixIn
|
|
):
|
|
"""
|
|
Quarter Income Statement View.
|
|
"""
|
|
|
|
|
|
class MonthlyIncomeStatementView(FiscalYearIncomeStatementViewBase, MonthlyReportMixIn, DjangoLedgerSecurityMixIn):
|
|
"""
|
|
Monthly Income Statement View.
|
|
"""
|
|
|
|
|
|
class DateModelIncomeStatementView(FiscalYearIncomeStatementViewBase, DateReportMixIn, DjangoLedgerSecurityMixIn):
|
|
"""
|
|
Date Income Statement View.
|
|
"""
|
|
|
|
|
|
# Cash Flow -----------
|
|
|
|
|
|
class BaseCashFlowStatementRedirectViewBase(BaseCashFlowStatementRedirectView, DjangoLedgerSecurityMixIn):
|
|
def get_redirect_url(self, *args, **kwargs):
|
|
year = get_localdate().year
|
|
dealer = get_user_type(self.request)
|
|
return reverse(
|
|
"entity-cf-year", kwargs={"entity_slug": dealer.entity.slug, "year": year}
|
|
)
|
|
|
|
|
|
class FiscalYearCashFlowStatementViewBase(FiscalYearCashFlowStatementView, DjangoLedgerSecurityMixIn):
|
|
template_name = "ledger/reports/cash_flow_statement.html"
|
|
|
|
|
|
class QuarterlyCashFlowStatementView(
|
|
FiscalYearCashFlowStatementViewBase, QuarterlyReportMixIn, DjangoLedgerSecurityMixIn
|
|
):
|
|
"""
|
|
Quarter Cash Flow Statement View.
|
|
"""
|
|
|
|
|
|
class MonthlyCashFlowStatementView(
|
|
FiscalYearCashFlowStatementViewBase, MonthlyReportMixIn, DjangoLedgerSecurityMixIn
|
|
):
|
|
"""
|
|
Monthly Cash Flow Statement View.
|
|
"""
|
|
|
|
|
|
class DateCashFlowStatementView(FiscalYearCashFlowStatementViewBase, DateReportMixIn, DjangoLedgerSecurityMixIn):
|
|
"""
|
|
Date Cash Flow Statement View.
|
|
"""
|
|
|
|
|
|
# Dashboard
|
|
|
|
class EntityModelDetailHandlerViewBase(EntityModelDetailHandlerView, DjangoLedgerSecurityMixIn):
|
|
|
|
def get_redirect_url(self, *args, **kwargs):
|
|
loc_date = get_localdate()
|
|
dealer = get_user_type(self.request)
|
|
unit_slug = self.get_unit_slug()
|
|
if unit_slug:
|
|
return reverse('unit-dashboard-month',
|
|
kwargs={
|
|
'entity_slug': dealer.entity.slug,
|
|
'unit_slug': unit_slug,
|
|
'year': loc_date.year,
|
|
'month': loc_date.month,
|
|
})
|
|
return reverse('entity-dashboard-month',
|
|
kwargs={
|
|
'entity_slug': dealer.entity.slug,
|
|
'year': loc_date.year,
|
|
'month': loc_date.month,
|
|
})
|
|
|
|
|
|
class EntityModelDetailBaseViewBase(EntityModelDetailBaseView, DjangoLedgerSecurityMixIn):
|
|
template_name = "ledger/reports/dashboard.html"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
dealer = get_user_type(self.request)
|
|
entity_model: EntityModel = dealer.entity
|
|
context['page_title'] = entity_model.name
|
|
context['header_title'] = entity_model.name
|
|
context['header_subtitle'] = _('Dashboard')
|
|
context['header_subtitle_icon'] = 'mdi:monitor-dashboard'
|
|
|
|
unit_slug = context.get('unit_slug', self.get_unit_slug())
|
|
KWARGS = dict(entity_slug=self.kwargs['entity_slug'])
|
|
|
|
if unit_slug:
|
|
KWARGS['unit_slug'] = unit_slug
|
|
|
|
url_pointer = 'entity' if not unit_slug else 'unit'
|
|
context['pnl_chart_id'] = f'djl-entity-pnl-chart-{randint(10000, 99999)}'
|
|
context['pnl_chart_endpoint'] = reverse(f'django_ledger:{url_pointer}-json-pnl', kwargs=KWARGS)
|
|
context['payables_chart_id'] = f'djl-entity-payables-chart-{randint(10000, 99999)}'
|
|
context['payables_chart_endpoint'] = reverse(f'django_ledger:{url_pointer}-json-net-payables', kwargs=KWARGS)
|
|
context['receivables_chart_id'] = f'djl-entity-receivables-chart-{randint(10000, 99999)}'
|
|
context['receivables_chart_endpoint'] = reverse(f'django_ledger:{url_pointer}-json-net-receivables',
|
|
kwargs=KWARGS)
|
|
|
|
return context
|
|
|
|
|
|
class FiscalYearEntityModelDashboardView(EntityModelDetailBaseViewBase, DjangoLedgerSecurityMixIn):
|
|
"""
|
|
Entity Fiscal Year Dashboard View.
|
|
"""
|
|
|
|
|
|
class QuarterlyEntityDashboardView(FiscalYearEntityModelDashboardView, QuarterlyReportMixIn, DjangoLedgerSecurityMixIn):
|
|
"""
|
|
Entity Quarterly Dashboard View.
|
|
"""
|
|
|
|
|
|
class MonthlyEntityDashboardView(FiscalYearEntityModelDashboardView, MonthlyReportMixIn, DjangoLedgerSecurityMixIn):
|
|
"""
|
|
Monthly Entity Dashboard View.
|
|
"""
|
|
|
|
|
|
class DateEntityDashboardView(FiscalYearEntityModelDashboardView, DateReportMixIn, DjangoLedgerSecurityMixIn):
|
|
"""
|
|
Date-specific Entity Dashboard View.
|
|
"""
|
|
|
|
|
|
class PayableNetAPIView(DjangoLedgerSecurityMixIn, EntityUnitMixIn, View):
|
|
http_method_names = ['get']
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
if request.user.is_authenticated:
|
|
dealer = get_user_type(request)
|
|
bill_qs = BillModel.objects.for_entity(
|
|
entity_slug=dealer.entity.slug,
|
|
user_model=dealer.entity.admin,
|
|
).unpaid()
|
|
|
|
# todo: implement this...
|
|
# unit_slug = self.get_unit_slug()
|
|
# if unit_slug:
|
|
# bill_qs.filter(ledger__journal_entry__entity_unit__slug__exact=unit_slug)
|
|
|
|
net_summary = accruable_net_summary(bill_qs)
|
|
net_payables = {
|
|
'net_payable_data': net_summary
|
|
}
|
|
|
|
return JsonResponse({
|
|
'results': net_payables
|
|
})
|
|
|
|
return JsonResponse({
|
|
'message': 'Unauthorized'
|
|
}, status=401)
|
|
|
|
|
|
class ReceivableNetAPIView(DjangoLedgerSecurityMixIn, EntityUnitMixIn, View):
|
|
http_method_names = ['get']
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
if request.user.is_authenticated:
|
|
dealer = get_user_type(request)
|
|
invoice_qs = InvoiceModel.objects.for_entity(
|
|
entity_slug=dealer.entity.slug,
|
|
user_model=dealer.entity.admin,
|
|
).unpaid()
|
|
|
|
# todo: implement this...
|
|
# unit_slug = self.get_unit_slug()
|
|
# if unit_slug:
|
|
# invoice_qs.filter(ledger__journal_entry__entity_unit__slug__exact=unit_slug)
|
|
|
|
net_summary = accruable_net_summary(invoice_qs)
|
|
|
|
net_receivable = {
|
|
'net_receivable_data': net_summary
|
|
}
|
|
|
|
return JsonResponse({
|
|
'results': net_receivable
|
|
})
|
|
|
|
return JsonResponse({
|
|
'message': 'Unauthorized'
|
|
}, status=401)
|
|
|
|
|
|
class PnLAPIView(DjangoLedgerSecurityMixIn, EntityUnitMixIn, View):
|
|
http_method_names = ['get']
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
if request.user.is_authenticated:
|
|
dealer = get_user_type(request)
|
|
entity = EntityModel.objects.for_user(
|
|
user_model=dealer.entity.admin).get(
|
|
slug__exact=dealer.entity.slug)
|
|
|
|
unit_slug = self.get_unit_slug()
|
|
|
|
io_digest = entity.digest(
|
|
user_model=self.request.user,
|
|
unit_slug=unit_slug,
|
|
equity_only=True,
|
|
signs=False,
|
|
by_period=True,
|
|
process_groups=True,
|
|
from_date=self.request.GET.get('fromDate'),
|
|
to_date=self.request.GET.get('toDate'),
|
|
|
|
# todo: For PnL to display proper period values must not use closing entries.
|
|
use_closing_entries=False
|
|
)
|
|
|
|
io_data = io_digest.get_io_data()
|
|
group_balance_by_period = io_data['group_balance_by_period']
|
|
group_balance_by_period = dict(sorted((k, v) for k, v in group_balance_by_period.items()))
|
|
|
|
entity_data = {
|
|
f'{month_name[k[1]]} {k[0]}': {d: float(f) for d, f in v.items()} for k, v in
|
|
group_balance_by_period.items()}
|
|
|
|
entity_pnl = {
|
|
'entity_slug': entity.slug,
|
|
'entity_name': entity.name,
|
|
'pnl_data': entity_data
|
|
}
|
|
|
|
return JsonResponse({
|
|
'results': entity_pnl
|
|
})
|
|
|
|
return JsonResponse({
|
|
'message': 'Unauthorized'
|
|
}, status=401)
|
|
|
|
|
|
class EmployeeCalendarView(ListView):
|
|
template_name = 'crm/employee_calendar.html'
|
|
model = Appointment
|
|
context_object_name = 'appointments'
|
|
|
|
def get_queryset(self):
|
|
query = self.request.GET.get('q')
|
|
dealer = get_user_type(self.request)
|
|
staff = getattr(self.request, 'staff', None)
|
|
if staff:
|
|
appointments = Appointment.objects.filter(appointment_request__staff_member=staff, ppointment_request__date__gt=timezone.now())
|
|
appointments = Appointment.objects.filter(appointment_request__date__gt=timezone.now())
|
|
return apply_search_filters(appointments, query)
|
|
|
|
|
|
|
|
def apply_search_filters(queryset, query):
|
|
if not query:
|
|
return queryset
|
|
|
|
search_filters = Q()
|
|
model = queryset.model
|
|
|
|
for field in model._meta.get_fields():
|
|
if hasattr(field, 'attname') and field.get_internal_type() in ["CharField", "TextField", "EmailField"]:
|
|
search_filters |= Q(**{f"{field.name}__icontains": query})
|
|
return queryset.filter(search_filters).distinct()
|
|
|
|
|
|
class CarListViewTable(ExportMixin, LoginRequiredMixin, SingleTableView):
|
|
model = models.Car
|
|
table_class = tables.CarTable
|
|
template_name = "inventory/car_list_table.html"
|
|
|
|
def get_queryset(self):
|
|
dealer = get_user_type(self.request)
|
|
return models.Car.objects.select_related(
|
|
"finances", "colors__exterior", "colors__interior"
|
|
).filter(dealer=dealer)
|
|
|