You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
440 lines
20 KiB
440 lines
20 KiB
# -*- coding: utf-8 -*-
|
|
#############################################################################
|
|
#
|
|
# Cybrosys Technologies Pvt. Ltd.
|
|
#
|
|
# Copyright (C) 2025-TODAY Cybrosys Technologies(<https://www.cybrosys.com>)
|
|
# Author: Jumana Jabin MP(<https://www.cybrosys.com>)
|
|
#
|
|
# You can modify it under the terms of the GNU AFFERO
|
|
# GENERAL PUBLIC LICENSE (AGPL v3), Version 3.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU AFFERO GENERAL PUBLIC LICENSE (AGPL v3) for more details.
|
|
#
|
|
# You should have received a copy of the GNU AFFERO GENERAL PUBLIC LICENSE
|
|
# (AGPL v3) along with this program.
|
|
# If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
#############################################################################
|
|
from datetime import datetime, timedelta
|
|
from odoo import http
|
|
from odoo.http import request
|
|
|
|
|
|
class OnlineSubscription(http.Controller):
|
|
"""Online Vehicle subscription through website"""
|
|
|
|
@http.route(['/online/subscription/city'], type='json', auth="public",
|
|
website=True)
|
|
def get_city(self, **kwargs):
|
|
"""Calling this function using ajax rpc in order to get city
|
|
based on state """
|
|
states = request.env['res.country.state'].sudo().search_read([],
|
|
['name'])
|
|
return states
|
|
|
|
@http.route('/online/subscription', auth='public', website=True)
|
|
def subscription_form(self):
|
|
"""This function will return vehicle with which state is not null"""
|
|
vehicle_id = request.env['fleet.vehicle'].sudo().search(
|
|
[('states_id', '!=', False)])
|
|
insurance_type = request.env['insurance.type'].sudo().search([])
|
|
vals = {
|
|
'states': vehicle_id.states_id,
|
|
'all_states': request.env['res.country.state'].sudo().search_read(
|
|
[], ['name']),
|
|
'cities': [rec.location for rec in vehicle_id],
|
|
'insurance_type': insurance_type,
|
|
}
|
|
return http.request.render('vehicle_subscription.subscription_form',
|
|
vals)
|
|
|
|
@http.route('/online/subscription/next', auth='public', website=True)
|
|
def vehicle_form(self, **kw):
|
|
"""Redirect to corresponding templates according to the
|
|
data provided by user in form page """
|
|
if kw.get('start_date'):
|
|
start_date = kw.get('start_date')
|
|
end_date = kw.get('end_date')
|
|
insurance = kw.get('insurance_type')
|
|
start = datetime.strptime(start_date, '%Y-%m-%d').date()
|
|
end = datetime.strptime(end_date, '%Y-%m-%d').date()
|
|
insurance_amount = request.env['vehicle.insurance'].sudo().browse(
|
|
int(insurance)).insurance_amount
|
|
# print("insurance_amount",insurance_amount)
|
|
insurance_type = request.env['vehicle.insurance'].sudo().search(
|
|
[('insurance_type_id.id', '=', insurance),
|
|
('start_date', '<=', start), ('end_date', '>=', end)])
|
|
vehicle_ids = insurance_type.vehicle_id
|
|
subscribed_vehicle_id = (request.env['fleet.subscription'].sudo().
|
|
search(
|
|
[('state', '=', 'subscribed')]).vehicle_id)
|
|
vehicle = request.env['fleet.vehicle'].sudo().search(
|
|
[('id', 'in', vehicle_ids.ids)])
|
|
vehicle_id = vehicle.filtered(
|
|
lambda v: v.id not in subscribed_vehicle_id.ids)
|
|
if vehicle_id:
|
|
for rec in vehicle_id:
|
|
rec.write({
|
|
'insurance': insurance,
|
|
'start': start,
|
|
'end': end,
|
|
})
|
|
data = {
|
|
'vehicles': vehicle_id,
|
|
'amount': insurance_amount,
|
|
'customers': request.env.user.partner_id.name,
|
|
}
|
|
return http.request.render('vehicle_subscription.vehicle_form',
|
|
data)
|
|
else:
|
|
return http.request.render(
|
|
'vehicle_subscription.subscription_vehicle_missing')
|
|
else:
|
|
return http.request.render('vehicle_subscription.vehicle_form')
|
|
|
|
@http.route(['/online/subscription/book'], type='json', auth="public",
|
|
website=True)
|
|
def get_vehicle(self, **kwargs):
|
|
"""Ajax RPC handler for booking vehicle subscription and
|
|
creating corresponding invoices in the backend."""
|
|
extra_km = kwargs.get('extra_km')
|
|
product_template_id = (request.env.ref(
|
|
'vehicle_subscription.product_template_vehicle_subscription_form').
|
|
id)
|
|
product_id = request.env['product.product'].sudo().search(
|
|
[('product_tmpl_id', '=', product_template_id)])
|
|
vehicle = int(kwargs.get('vehicle'))
|
|
customer = kwargs.get('customer')
|
|
checked = int(kwargs.get('checked'))
|
|
invoice_type = int(kwargs.get('invoice'))
|
|
vehicle_id = request.env['fleet.vehicle'].sudo().browse(int(vehicle))
|
|
customer_id = request.env['res.partner'].sudo().search(
|
|
[('name', '=', customer)])
|
|
if extra_km == '':
|
|
km = 0
|
|
else:
|
|
km = extra_km
|
|
# print(vehicle_id.insurance, "bbbbbbbbbb")
|
|
# insurance_amount = vehicle_id.insurance.insurance_amount
|
|
# insurance_amount = request.env['vehicle.insurance'].sudo().browse(
|
|
# int(vehicle_id.insurance)).insurance_amount
|
|
# price = vehicle_id.duration * vehicle_id.subscription_price
|
|
# print("aaaaaaaaaaaaaaaa",insurance_amount + price)
|
|
subscribe = request.env['fleet.subscription'].sudo().create({
|
|
'vehicle_id': vehicle_id.id,
|
|
'customer_id': customer_id.id,
|
|
'insurance_type_id': vehicle_id.insurance,
|
|
'start_date': vehicle_id.start,
|
|
'end_date': vehicle_id.end,
|
|
'extra_km': km,
|
|
'fuel': 'without_fuel' if checked == False else 'with_fuel',
|
|
})
|
|
subscribe.action_invoice()
|
|
# subscribe.sale_id.order_line.price_unit = price
|
|
subscribe.sale_id.action_confirm()
|
|
if invoice_type:
|
|
subscribe.sale_id._create_invoices().action_post()
|
|
subscribe.invoice_ids.is_subscription = True
|
|
subscribe.sale_id.invoice_ids.is_subscription = True
|
|
else:
|
|
subscribe.sale_id.invoice_status = 'invoiced'
|
|
total_price = subscribe.sale_id.order_line.price_unit
|
|
duration = vehicle_id.duration
|
|
per_day = total_price / duration
|
|
start_date = vehicle_id.start
|
|
end_date = vehicle_id.end
|
|
next_invoice_day = start_date
|
|
while next_invoice_day <= end_date:
|
|
next_invoice_day = next_invoice_day + timedelta(days=30)
|
|
if next_invoice_day <= end_date:
|
|
durations = (next_invoice_day - start_date).days
|
|
generate_invoice = request.env[
|
|
'account.move'].sudo().create({
|
|
'move_type': 'out_invoice',
|
|
'partner_id': customer_id.id,
|
|
'invoice_date': next_invoice_day,
|
|
'invoice_origin': subscribe.sale_id.name,
|
|
'invoice_line_ids': [(0, 0, {
|
|
'product_id': product_id.id,
|
|
'name': vehicle_id.name,
|
|
'price_unit': per_day * durations,
|
|
})]
|
|
})
|
|
generate_invoice.is_subscription = True
|
|
generate_invoice.action_post()
|
|
subscribe.sale_id.invoice_ids = [(4, generate_invoice.id)]
|
|
subscribe.invoice_ids = [(4, generate_invoice.id)]
|
|
else:
|
|
next_invoice_day = end_date
|
|
durations = (next_invoice_day - start_date).days
|
|
generate_invoice = request.env[
|
|
'account.move'].sudo().create({
|
|
'move_type': 'out_invoice',
|
|
'partner_id': customer_id.id,
|
|
'invoice_date': next_invoice_day,
|
|
'invoice_line_ids': [(0, 0, {
|
|
'product_id': product_id.id,
|
|
'name': vehicle_id.name,
|
|
'price_unit': per_day * durations,
|
|
})]
|
|
})
|
|
generate_invoice.is_subscription = True
|
|
generate_invoice.action_post()
|
|
subscribe.sale_id.invoice_ids = [(4, generate_invoice.id)]
|
|
subscribe.invoice_ids = [(4, generate_invoice.id)]
|
|
break
|
|
start_date = start_date + timedelta(days=30)
|
|
values = {
|
|
'subscription_id': subscribe.id
|
|
}
|
|
return values
|
|
|
|
@http.route(['/next/vehicle', '/next/vehicle/<int:subscription_id>'],
|
|
auth='public', website=True, type='http')
|
|
def subscription_create(self):
|
|
"""Return template for successful subscription"""
|
|
current_vehicle = request.env['fleet.subscription'].sudo().search([
|
|
('customer_id', '=', request.env.user.partner_id.id),
|
|
('state', '=', 'subscribed'),
|
|
], order='write_date desc', limit=1)
|
|
context = {
|
|
'vehicle_name': current_vehicle.vehicle_id.name,
|
|
'customer_name': request.env.user.partner_id.name,
|
|
}
|
|
return request.render('vehicle_subscription.subscription_form_success',
|
|
context)
|
|
|
|
@http.route(['/online/subscription/with/fuel'], type='json', auth="public",
|
|
website=True)
|
|
def get_with_fuel(self, **kwargs):
|
|
"""Calculate price for vehicle according to fuel type """
|
|
vehicle = int(kwargs.get('vehicle'))
|
|
km = kwargs.get('extra_km')
|
|
vehicle = request.env['fleet.vehicle'].sudo().browse(vehicle)
|
|
vehicle.write({
|
|
'extra_km': km,
|
|
})
|
|
insurance_amount = vehicle.insurance
|
|
amount = request.env['vehicle.insurance'].sudo() \
|
|
.browse(int(insurance_amount)).insurance_amount
|
|
if float(km) > vehicle.free_km:
|
|
new_price = (((vehicle.extra_km / vehicle.mileage) *
|
|
vehicle.fuel_rate) +
|
|
(vehicle.duration * vehicle.subscription_price) +
|
|
amount)
|
|
else:
|
|
if float(km) <= vehicle.free_km:
|
|
new_price = ((vehicle.duration * vehicle.subscription_price) +
|
|
amount)
|
|
return str(new_price)
|
|
|
|
@http.route(['/online/subscription/without/fuel'], type='json',
|
|
auth="public",
|
|
website=True)
|
|
def get_without_fuel(self, **kwargs):
|
|
"""Calculate price for vehicle according to fuel type """
|
|
vehicle = int(kwargs.get('vehicle'))
|
|
km = kwargs.get('extra_km')
|
|
vehicle = request.env['fleet.vehicle'].sudo().browse(vehicle)
|
|
insurance_amount = vehicle.insurance
|
|
amount = request.env['vehicle.insurance'].sudo() \
|
|
.browse(int(insurance_amount)).insurance_amount
|
|
vehicle.write({
|
|
'extra_km': km,
|
|
})
|
|
if float(km) > vehicle.free_km:
|
|
new_price = (((vehicle.duration * vehicle.subscription_price) +
|
|
amount) + (vehicle.charge_km * vehicle.extra_km))
|
|
else:
|
|
new_price = (
|
|
vehicle.duration * vehicle.subscription_price) + amount
|
|
return str(new_price)
|
|
|
|
@http.route('/online/subscription/cancel', auth='public', website=True)
|
|
def cancellation_form(self):
|
|
"""Cancel subscription form through website"""
|
|
customer_id = request.env['res.partner'].sudo().search(
|
|
[('name', '=', request.env.user.partner_id.name)])
|
|
vehicle_id = request.env['fleet.subscription'].sudo().search(
|
|
[('customer_id', '=', customer_id.id),
|
|
('state', '=', 'subscribed')])
|
|
vals = {
|
|
'customers': customer_id.name,
|
|
'vehicles': vehicle_id,
|
|
}
|
|
return http.request.render(
|
|
'vehicle_subscription.subscription_cancellation_form', vals)
|
|
|
|
@http.route('/online/choose/vehicle', type='json', auth="public",
|
|
website=True)
|
|
def choose_vehicle(self, **kwargs):
|
|
"""Only display vehicle of selected customer in website"""
|
|
customer = kwargs.get('customer_id')
|
|
customer_id = request.env['res.partner'].sudo().search(
|
|
[('name', '=', customer)])
|
|
vehicle_id = request.env['fleet.subscription'].sudo().search(
|
|
[('state', '=', 'subscribed'),
|
|
('customer_id', '=', customer_id.id)]).mapped('vehicle_id')
|
|
if vehicle_id:
|
|
vehicle = [(rec.id, rec.name) for rec in vehicle_id]
|
|
return [*set(vehicle)]
|
|
|
|
@http.route('/online/cancellation/click', auth='public', type='http',
|
|
website=True)
|
|
def cancellation_click_form(self, **kwargs):
|
|
"""Proceed with cancellation button click"""
|
|
customer = kwargs.get('customer')
|
|
vehicle = int(kwargs.get('vehicle'))
|
|
reason = kwargs.get('reason')
|
|
customer_id = request.env['res.partner'].sudo().search(
|
|
[('name', '=', customer)])
|
|
subscription = request.env['fleet.subscription'].sudo().browse(vehicle)
|
|
vehicle_id = subscription.vehicle_id
|
|
existing_request = request.env['cancellation.request'].sudo().search([
|
|
('customer_id', '=', customer_id.id),
|
|
('vehicle_id', '=', vehicle_id.id),
|
|
('state', '!=', 'cancel')
|
|
], limit=1)
|
|
if existing_request:
|
|
values = {
|
|
'customer': customer,
|
|
'vehicle': vehicle_id.name,
|
|
'existing_request': existing_request,
|
|
}
|
|
return request.render(
|
|
'vehicle_subscription.existing_cancellation_popup', values)
|
|
cancel_request = request.env['cancellation.request'].sudo().create({
|
|
'customer_id': customer_id.id,
|
|
'vehicle_id': vehicle_id.id,
|
|
'reason': reason,
|
|
})
|
|
values = {
|
|
'customer': customer,
|
|
'vehicle': vehicle_id.name,
|
|
}
|
|
cancel_request.state = 'to_approve'
|
|
return request.render('vehicle_subscription.booking_cancellation',
|
|
values)
|
|
|
|
@http.route('/online/subscription/change', auth='public', website=True)
|
|
def subscription_change_form(self):
|
|
"""Rendered response for the 'vehicle_subscription.
|
|
subscription_change_form' template,
|
|
containing the available vehicles and the current customer's name."""
|
|
customer = request.env.user.partner_id.name
|
|
customer_id = request.env['res.partner'].sudo().search(
|
|
[('name', '=', customer)])
|
|
invoice = request.env['account.move'].sudo().search([
|
|
('invoice_line_ids.product_id', 'like', 'Vehicle Subscription'),
|
|
('partner_id', '=', customer_id.id)
|
|
])
|
|
vehicle_names = [line.name for line in invoice.invoice_line_ids if
|
|
line.product_id.name == 'Vehicle Subscription']
|
|
vehicles = request.env['fleet.vehicle'].sudo().search(
|
|
[('name', 'in', vehicle_names)])
|
|
filtered_vehicles = vehicles
|
|
for vehicle in vehicles:
|
|
existing_request = request.env['subscription.request'].sudo().search([
|
|
('customer_id', '=', customer_id.id),
|
|
('current_vehicle_id', '=', vehicle.id),
|
|
('state', '!=', 'cancel'),('is_subscription' ,'!=',True)
|
|
])
|
|
already_request = request.env['subscription.request'].sudo().search([
|
|
('customer_id', '=', customer_id.id),
|
|
('current_vehicle_id', '=', vehicle.id),
|
|
('state', '!=', 'cancel'),('is_subscription' ,'=',True)
|
|
])
|
|
already_vehicle = already_request.current_vehicle_id
|
|
if existing_request:
|
|
values = {
|
|
'customer': customer,
|
|
'current_vehicle': existing_request.current_vehicle_id.name,
|
|
'existing_request': existing_request,
|
|
}
|
|
return request.render(
|
|
'vehicle_subscription.existing_subscription_popup', values)
|
|
else:
|
|
vals = {
|
|
'vehicles': filtered_vehicles.filtered(lambda v: v.id != already_vehicle.id),
|
|
'customers': customer_id.name,
|
|
}
|
|
return http.request.render(
|
|
'vehicle_subscription.subscription_change_form', vals)
|
|
|
|
@http.route('/online/subscription/change/vehicle', auth='public',
|
|
type='http', website=True)
|
|
def change_click_form(self, **kwargs):
|
|
""" Rendered response based on the conditions:
|
|
- If the 'customer' parameter exists, render the
|
|
'vehicle_subscription.subscription_change_button' template
|
|
with the provided data.
|
|
- If the 'customer' parameter does not exist, render the
|
|
'vehicle_subscription.subscription_change_boolean_false'
|
|
template."""
|
|
if kwargs.get('customer'):
|
|
customer = kwargs.get('customer')
|
|
vehicle = int(kwargs.get('vehicle'))
|
|
reason = kwargs.get('reason')
|
|
checkbox = kwargs.get('checkbox_model')
|
|
customer_id = request.env['res.partner'].sudo(). \
|
|
search([('name', '=', customer)])
|
|
vehicle_id = request.env['fleet.vehicle'].sudo().browse(vehicle)
|
|
new_vehicle_id = request.env['fleet.vehicle'].sudo() \
|
|
.search([('model_id', '!=', vehicle_id.model_id.id)])
|
|
if checkbox == 'on':
|
|
values = {
|
|
'customer_name': customer_id.name,
|
|
'vehicle_name': vehicle_id.name,
|
|
'vehicles': [rec for rec in new_vehicle_id],
|
|
'reason': reason,
|
|
}
|
|
return request.render(
|
|
'vehicle_subscription.subscription_change_button', values)
|
|
else:
|
|
return request.render(
|
|
'vehicle_subscription.subscription_change_boolean_false')
|
|
else:
|
|
return request.render(
|
|
'vehicle_subscription.subscription_change_button')
|
|
|
|
@http.route('/online/subscription/change/button', auth='public',
|
|
type='http', website=True)
|
|
def click_form(self, **kwargs):
|
|
"""Rendered response for the
|
|
'vehicle_subscription.change_subscription' template. """
|
|
customer = kwargs.get('customer')
|
|
reason = kwargs.get('reason')
|
|
current_vehicle = kwargs.get('vehicle')
|
|
vehicle_id = int(kwargs.get('new_vehicle'))
|
|
current_vehicle_id = request.env['fleet.vehicle'].sudo() \
|
|
.search([('name', '=', current_vehicle)])
|
|
customer_id = request.env['res.partner'].sudo() \
|
|
.search([('name', '=', customer)])
|
|
vehicle = request.env['fleet.vehicle'].sudo().browse(vehicle_id)
|
|
change_subscription = request.env['subscription.request'] \
|
|
.sudo().create({
|
|
'current_vehicle_id': current_vehicle_id.id,
|
|
'new_vehicle_id': vehicle.id,
|
|
'reason_to_change': reason,
|
|
'customer_id': customer_id.id,
|
|
'is_subscription': True,
|
|
})
|
|
change_subscription.is_subscription = True
|
|
change_subscription.state = 'to_approve'
|
|
return request.render('vehicle_subscription.change_subscription')
|
|
|
|
@http.route('/online/proceed/cancellation', auth='public', type='http',
|
|
website=True)
|
|
def proceed_cancellation(self):
|
|
"""Proceed with cancellation in change subscription """
|
|
return request.redirect('/online/subscription/cancel')
|
|
|
|
@http.route(['/web/signup/user'], type='http', auth="user",
|
|
website=True)
|
|
def redirect_login(self):
|
|
"""Used to redirect on clicking signup page"""
|
|
return request.redirect('/online/subscription')
|
|
|