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.
260 lines
10 KiB
260 lines
10 KiB
# -*- coding: utf-8 -*-
|
|
###############################################################################
|
|
#
|
|
# Cybrosys Technologies Pvt. Ltd.
|
|
#
|
|
# Copyright (C) 2023-TODAY Cybrosys Technologies(<https://www.cybrosys.com>)
|
|
# Author: Mohamed Muzammil VP (odoo@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 odoo import api, fields, models
|
|
|
|
|
|
class EmployeePurchaseRequisition(models.Model):
|
|
""" Model for storing purchase requisition """
|
|
_name = 'employee.purchase.requisition'
|
|
_description = 'Purchase Requisition'
|
|
_inherit = "mail.thread", "mail.activity.mixin"
|
|
|
|
name = fields.Char(
|
|
string="Reference No", help="Reference Number", readonly=True
|
|
)
|
|
employee_id = fields.Many2one(
|
|
'hr.employee', string='Employee', required=True,
|
|
help='Choose the employee'
|
|
)
|
|
dept_id = fields.Many2one(
|
|
'hr.department', related='employee_id.department_id', store=True,
|
|
help='Choose Department', string='Department'
|
|
)
|
|
user_id = fields.Many2one(
|
|
'res.users', string='Requisition Responsible', required=True,
|
|
help='Requisition responsible user'
|
|
)
|
|
requisition_date = fields.Date(
|
|
string="Requisition Date", default=lambda self: fields.Date.today(),
|
|
help='Date of Requisition'
|
|
)
|
|
receive_date = fields.Date(
|
|
string="Received Date", readonly=True, help='Receive Date'
|
|
)
|
|
requisition_deadline = fields.Date(
|
|
string="Requisition Deadline", help="End date of Purchase requisition"
|
|
)
|
|
company_id = fields.Many2one(
|
|
'res.company', string='Company', default=lambda self: self.env.company,
|
|
help='Select the company'
|
|
)
|
|
requisition_order_ids = fields.One2many(
|
|
'requisition.order', 'requisition_product_id', required=True,
|
|
string="Requisition Order", help="Requisition order")
|
|
confirm_id = fields.Many2one(
|
|
'res.users', string='Confirmed By', default=lambda self: self.env.uid,
|
|
readonly=True, help='User who Confirmed the requisition.'
|
|
)
|
|
manager_id = fields.Many2one(
|
|
'res.users', string='Department Manager', readonly=True,
|
|
help='Department Manager'
|
|
)
|
|
requisition_head_id = fields.Many2one(
|
|
'res.users', string='Approved By', readonly=True,
|
|
help='User who approved the requisition.'
|
|
)
|
|
rejected_user_id = fields.Many2one(
|
|
'res.users', string='Rejected By', readonly=True,
|
|
help='user who rejected the requisition'
|
|
)
|
|
confirmed_date = fields.Date(
|
|
string='Confirmed Date', readonly=True,
|
|
help='Date of Requisition Confirmation'
|
|
)
|
|
department_approval_date = fields.Date(
|
|
string='Department Approval Date', readonly=True,
|
|
help='Department Approval Date'
|
|
)
|
|
approval_date = fields.Date(
|
|
string='Approved Date', readonly=True, help='Requisition Approval Date'
|
|
)
|
|
reject_date = fields.Date(
|
|
string='Rejection Date', readonly=True,
|
|
help='Requisition Rejected Date'
|
|
)
|
|
source_location_id = fields.Many2one(
|
|
'stock.location', string='Source Location',
|
|
help='Source location of requisition.'
|
|
)
|
|
destination_location_id = fields.Many2one(
|
|
'stock.location', string="Destination Location",
|
|
help='Destination location of requisition.'
|
|
)
|
|
delivery_type_id = fields.Many2one(
|
|
'stock.picking.type', string='Delivery To', help='Type of Delivery.'
|
|
)
|
|
internal_picking_id = fields.Many2one(
|
|
'stock.picking.type', string="Internal Picking",
|
|
help="Choose picking type"
|
|
)
|
|
requisition_description = fields.Text(
|
|
string="Reason For Requisition", help="Write description"
|
|
)
|
|
purchase_count = fields.Integer(
|
|
string='Purchase Count', help="Count of purchase order"
|
|
)
|
|
internal_transfer_count = fields.Integer(
|
|
string='Internal Transfer count', help="Internal transfer count"
|
|
)
|
|
state = fields.Selection(
|
|
[('new', 'New'),
|
|
('waiting_department_approval', 'Waiting Department Approval'),
|
|
('waiting_head_approval', 'Waiting Head Approval'),
|
|
('approved', 'Approved'),
|
|
('purchase_order_created', 'Purchase Order Created'),
|
|
('received', 'Received'),
|
|
('cancelled', 'Cancelled')], string="State", default='new',
|
|
copy=False, tracking=True, help="State of the record"
|
|
)
|
|
has_internal = fields.Boolean(string='Has Internal Transfer',
|
|
help="Will become true if this purchase "
|
|
"requisition has internal transfer",
|
|
compute="_compute_has_internal")
|
|
|
|
@api.model
|
|
def create(self, vals):
|
|
"""Generate purchase requisition sequence"""
|
|
if vals.get('name', 'New') == 'New':
|
|
vals['name'] = self.env['ir.sequence'].next_by_code(
|
|
'employee.purchase.requisition') or 'New'
|
|
return super(EmployeePurchaseRequisition, self).create(vals)
|
|
|
|
@api.depends('requisition_order_ids')
|
|
def _compute_has_internal(self):
|
|
"""Method to compute whether there is any internal transfer in the
|
|
purchase requisition"""
|
|
for rec in self:
|
|
has_internal_transfer = False
|
|
for order in rec.requisition_order_ids:
|
|
if order.requisition_type == 'internal_transfer':
|
|
has_internal_transfer = True
|
|
break
|
|
if has_internal_transfer:
|
|
rec.has_internal = True
|
|
else:
|
|
rec.has_internal = False
|
|
|
|
def action_confirm_requisition(self):
|
|
"""Confirm purchase requisition"""
|
|
self.source_location_id = self.employee_id.department_id.department_location_id.id
|
|
self.destination_location_id = self.employee_id.employee_location_id.id
|
|
self.delivery_type_id = self.source_location_id.warehouse_id.in_type_id.id
|
|
self.internal_picking_id = self.source_location_id.warehouse_id.int_type_id.id
|
|
self.write({'state': 'waiting_department_approval'})
|
|
self.confirm_id = self.env.uid
|
|
self.confirmed_date = fields.Date.today()
|
|
|
|
def action_department_approval(self):
|
|
"""Approval from the department"""
|
|
self.write({'state': 'waiting_head_approval'})
|
|
self.manager_id = self.env.uid
|
|
self.department_approval_date = fields.Date.today()
|
|
|
|
def action_department_cancel(self):
|
|
"""Cancellation from department """
|
|
self.write({'state': 'cancelled'})
|
|
self.rejected_user_id = self.env.uid
|
|
self.reject_date = fields.Date.today()
|
|
|
|
def action_head_approval(self):
|
|
"""Approval from department head"""
|
|
self.write({'state': 'approved'})
|
|
self.requisition_head_id = self.env.uid
|
|
self.approval_date = fields.Date.today()
|
|
|
|
def action_head_cancel(self):
|
|
"""Cancellation from department head"""
|
|
self.write({'state': 'cancelled'})
|
|
self.rejected_user_id = self.env.uid
|
|
self.reject_date = fields.Date.today()
|
|
|
|
def action_create_purchase_order(self):
|
|
"""Create purchase order and internal transfer"""
|
|
for rec in self.requisition_order_ids:
|
|
if rec.requisition_type == 'internal_transfer':
|
|
self.env['stock.picking'].create({
|
|
'location_id': self.source_location_id.id,
|
|
'location_dest_id': self.destination_location_id.id,
|
|
'picking_type_id': self.internal_picking_id.id,
|
|
'requisition_order': self.name,
|
|
'move_ids_without_package': [(0, 0, {
|
|
'name': rec.product_id.name,
|
|
'product_id': rec.product_id.id,
|
|
'product_uom': rec.product_id.uom_id,
|
|
'product_uom_qty': rec.quantity,
|
|
'location_id': self.source_location_id.id,
|
|
'location_dest_id': self.destination_location_id.id,
|
|
})]
|
|
})
|
|
else:
|
|
self.env['purchase.order'].create({
|
|
'partner_id': self.employee_id.work_contact_id.id,
|
|
'requisition_order': self.name,
|
|
"order_line": [(0, 0, {
|
|
'product_id': rec.product_id.id,
|
|
'product_qty': rec.quantity,
|
|
})]})
|
|
self.write({'state': 'purchase_order_created'})
|
|
self.purchase_count = self.env['purchase.order'].search_count([
|
|
('requisition_order', '=', self.name)])
|
|
self.internal_transfer_count = self.env['stock.picking'].search_count([
|
|
('requisition_order', '=', self.name)])
|
|
|
|
def action_receive(self):
|
|
"""Receive purchase requisition"""
|
|
self.write({'state': 'received'})
|
|
self.receive_date = fields.Date.today()
|
|
|
|
def get_purchase_order(self):
|
|
"""Purchase order smart button, when click on the smart button it
|
|
gives the purchase order of the user"""
|
|
self.ensure_one()
|
|
return {
|
|
'type': 'ir.actions.act_window',
|
|
'name': 'Purchase Order',
|
|
'view_mode': 'tree,form',
|
|
'res_model': 'purchase.order',
|
|
'domain': [('requisition_order', '=', self.name)],
|
|
}
|
|
|
|
def get_internal_transfer(self):
|
|
"""Internal transfer smart button, when click on the smart button it
|
|
gives the internal transfer of the user"""
|
|
self.ensure_one()
|
|
return {
|
|
'type': 'ir.actions.act_window',
|
|
'name': 'Internal Transfers',
|
|
'view_mode': 'tree,form',
|
|
'res_model': 'stock.picking',
|
|
'domain': [('requisition_order', '=', self.name)],
|
|
}
|
|
|
|
def action_print_report(self):
|
|
"""Print purchase requisition report"""
|
|
data = {
|
|
'employee': self.employee_id.name,
|
|
'records': self.read(),
|
|
'order_ids': self.requisition_order_ids.read(),
|
|
}
|
|
return self.env.ref(
|
|
'all_in_one_purchase_kit.report_purchase_requisition_action'
|
|
).report_action(self, data=data)
|
|
|