mirror of
https://github.com/OCA/pms.git
synced 2025-01-29 00:17:45 +02:00
331 lines
12 KiB
Python
331 lines
12 KiB
Python
# Copyright 2017 Alexandre Díaz
|
|
# Copyright 2017 Dario Lodeiros
|
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
|
|
import logging
|
|
|
|
from odoo import _, api, fields, models
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class ResPartner(models.Model):
|
|
_inherit = "res.partner"
|
|
|
|
reservations_count = fields.Integer(
|
|
string="Reservations",
|
|
help="Number of reservations of the partner",
|
|
compute="_compute_reservations_count",
|
|
)
|
|
folios_count = fields.Integer(
|
|
string="Folios",
|
|
help="Number of folios of the partner",
|
|
compute="_compute_folios_count",
|
|
)
|
|
is_agency = fields.Boolean(
|
|
string="Is Agency", help="Indicates if the partner is an agency"
|
|
)
|
|
sale_channel_id = fields.Many2one(
|
|
string="Sale Channel",
|
|
help="The sale channel of the partner",
|
|
comodel_name="pms.sale.channel",
|
|
domain=[("channel_type", "=", "indirect")],
|
|
ondelete="restrict",
|
|
)
|
|
default_commission = fields.Integer(string="Commission", help="Default commission")
|
|
apply_pricelist = fields.Boolean(
|
|
string="Apply Pricelist",
|
|
help="Indicates if agency pricelist is applied to his reservations",
|
|
)
|
|
invoice_to_agency = fields.Boolean(
|
|
string="Invoice Agency",
|
|
help="Indicates if agency invoices partner",
|
|
)
|
|
pms_property_ids = fields.Many2many(
|
|
string="Properties",
|
|
help="Properties with access to the element;"
|
|
" if not set, all properties can access",
|
|
required=False,
|
|
comodel_name="pms.property",
|
|
relation="res_partner_pms_property_rel",
|
|
column1="res_partner_id",
|
|
column2="pms_property_id",
|
|
ondelete="restrict",
|
|
check_pms_properties=True,
|
|
)
|
|
company_id = fields.Many2one(
|
|
check_pms_properties=True,
|
|
)
|
|
|
|
pms_checkin_partner_ids = fields.One2many(
|
|
string="Checkin Partners",
|
|
help="Associated checkin partners",
|
|
comodel_name="pms.checkin.partner",
|
|
inverse_name="partner_id",
|
|
)
|
|
|
|
gender = fields.Selection(
|
|
readonly=False,
|
|
store=True,
|
|
compute="_compute_gender",
|
|
)
|
|
|
|
birthdate_date = fields.Date(
|
|
readonly=False,
|
|
store=True,
|
|
compute="_compute_birthdate_date",
|
|
)
|
|
|
|
nationality_id = fields.Many2one(
|
|
readonly=False,
|
|
store=True,
|
|
compute="_compute_nationality_id",
|
|
)
|
|
|
|
email = fields.Char(
|
|
readonly=False,
|
|
store=True,
|
|
compute="_compute_email",
|
|
)
|
|
mobile = fields.Char(
|
|
readonly=False,
|
|
store=True,
|
|
compute="_compute_mobile",
|
|
)
|
|
|
|
firstname = fields.Char(
|
|
readonly=False,
|
|
store=True,
|
|
compute="_compute_firstname",
|
|
)
|
|
|
|
lastname = fields.Char(
|
|
readonly=False,
|
|
store=True,
|
|
compute="_compute_lastname",
|
|
)
|
|
|
|
lastname2 = fields.Char(
|
|
readonly=False,
|
|
store=True,
|
|
compute="_compute_lastname2",
|
|
)
|
|
|
|
@api.depends("pms_checkin_partner_ids", "pms_checkin_partner_ids.gender")
|
|
def _compute_gender(self):
|
|
if hasattr(super(), "_compute_gender"):
|
|
super()._compute_field()
|
|
for record in self:
|
|
if not record.gender and record.pms_checkin_partner_ids:
|
|
gender = list(set(record.pms_checkin_partner_ids.mapped("gender")))
|
|
if len(gender) == 1:
|
|
record.gender = gender[0]
|
|
else:
|
|
record.gender = False
|
|
elif not record.gender:
|
|
record.gender = False
|
|
|
|
@api.depends("pms_checkin_partner_ids", "pms_checkin_partner_ids.birthdate_date")
|
|
def _compute_birthdate_date(self):
|
|
if hasattr(super(), "_compute_birthdate_date"):
|
|
super()._compute_field()
|
|
for record in self:
|
|
if not record.birthdate_date and record.pms_checkin_partner_ids:
|
|
birthdate = list(
|
|
set(record.pms_checkin_partner_ids.mapped("birthdate_date"))
|
|
)
|
|
if len(birthdate) == 1:
|
|
record.birthdate_date = birthdate[0]
|
|
else:
|
|
record.birthdate_date = False
|
|
elif not record.birthdate_date:
|
|
record.birthdate_date = False
|
|
|
|
@api.depends("pms_checkin_partner_ids", "pms_checkin_partner_ids.nationality_id")
|
|
def _compute_nationality_id(self):
|
|
if hasattr(super(), "_compute_nationality_id"):
|
|
super()._compute_field()
|
|
for record in self:
|
|
if not record.nationality_id and record.pms_checkin_partner_ids:
|
|
nationality_id = list(
|
|
set(record.pms_checkin_partner_ids.mapped("nationality_id"))
|
|
)
|
|
if len(nationality_id) == 1:
|
|
record.nationality_id = nationality_id[0]
|
|
else:
|
|
record.nationality_id = False
|
|
elif not record.nationality_id:
|
|
record.nationality_id = False
|
|
|
|
@api.depends("pms_checkin_partner_ids", "pms_checkin_partner_ids.email")
|
|
def _compute_email(self):
|
|
if hasattr(super(), "_compute_email"):
|
|
super()._compute_field()
|
|
for record in self:
|
|
if not record.email and record.pms_checkin_partner_ids:
|
|
email = list(set(record.pms_checkin_partner_ids.mapped("email")))
|
|
if len(email) == 1:
|
|
record.email = email[0]
|
|
else:
|
|
record.email = False
|
|
elif not record.email:
|
|
record.email = False
|
|
|
|
@api.depends("pms_checkin_partner_ids", "pms_checkin_partner_ids.mobile")
|
|
def _compute_mobile(self):
|
|
if hasattr(super(), "_compute_mobile"):
|
|
super()._compute_field()
|
|
for record in self:
|
|
if not record.mobile and record.pms_checkin_partner_ids:
|
|
mobile = list(set(record.pms_checkin_partner_ids.mapped("mobile")))
|
|
if len(mobile) == 1:
|
|
record.mobile = mobile[0]
|
|
else:
|
|
record.mobile = False
|
|
elif not record.mobile:
|
|
record.mobile = False
|
|
|
|
@api.depends("pms_checkin_partner_ids", "pms_checkin_partner_ids.firstname")
|
|
def _compute_firstname(self):
|
|
if hasattr(super(), "_compute_firstname"):
|
|
super()._compute_field()
|
|
for record in self:
|
|
if not record.firstname and record.pms_checkin_partner_ids:
|
|
firstname = list(
|
|
set(record.pms_checkin_partner_ids.mapped("firstname"))
|
|
)
|
|
if len(firstname) == 1:
|
|
record.firstname = firstname[0]
|
|
else:
|
|
record.firstname = False
|
|
elif not record.firstname:
|
|
record.firstname = False
|
|
|
|
@api.depends("pms_checkin_partner_ids", "pms_checkin_partner_ids.lastname")
|
|
def _compute_lastname(self):
|
|
if hasattr(super(), "_compute_lastname"):
|
|
super()._compute_field()
|
|
for record in self:
|
|
if not record.lastname and record.pms_checkin_partner_ids:
|
|
lastname = list(
|
|
set(record.pms_checkin_partner_ids.mapped("lastname"))
|
|
)
|
|
if len(lastname) == 1:
|
|
record.lastname = lastname[0]
|
|
else:
|
|
record.lastname = False
|
|
elif not record.lastname:
|
|
record.lastname = False
|
|
|
|
@api.depends("pms_checkin_partner_ids", "pms_checkin_partner_ids.lastname2")
|
|
def _compute_lastname2(self):
|
|
if hasattr(super(), "_compute_lastname2"):
|
|
super()._compute_field()
|
|
for record in self:
|
|
if not record.lastname2 and record.pms_checkin_partner_ids:
|
|
lastname2 = list(
|
|
set(record.pms_checkin_partner_ids.mapped("lastname2"))
|
|
)
|
|
if len(lastname2) == 1:
|
|
record.lastname2 = lastname2[0]
|
|
else:
|
|
record.lastname2 = False
|
|
elif not record.lastname2:
|
|
record.lastname2 = False
|
|
|
|
def _compute_reservations_count(self):
|
|
# TODO: recuperar las reservas de los folios del partner
|
|
pms_reservation_obj = self.env["pms.reservation"]
|
|
for record in self:
|
|
record.reservations_count = pms_reservation_obj.search_count(
|
|
[
|
|
(
|
|
"partner_id.id",
|
|
"child_of",
|
|
record.id if isinstance(record.id, int) else False,
|
|
)
|
|
]
|
|
)
|
|
|
|
def _compute_folios_count(self):
|
|
pms_folio_obj = self.env["pms.folio"]
|
|
for record in self:
|
|
record.folios_count = pms_folio_obj.search_count(
|
|
[
|
|
(
|
|
"partner_id.id",
|
|
"=",
|
|
record.id if isinstance(record.id, int) else False,
|
|
)
|
|
]
|
|
)
|
|
|
|
@api.model
|
|
def name_search(self, name, args=None, operator="ilike", limit=100):
|
|
if not args:
|
|
args = []
|
|
domain = [
|
|
"|",
|
|
("phone", operator, name),
|
|
("mobile", operator, name),
|
|
]
|
|
partners = self.search(
|
|
domain + args,
|
|
limit=limit,
|
|
)
|
|
res = partners.name_get()
|
|
if limit:
|
|
limit_rest = limit - len(partners)
|
|
else:
|
|
limit_rest = limit
|
|
if limit_rest or not limit:
|
|
args += [("id", "not in", partners.ids)]
|
|
res += super(ResPartner, self).name_search(
|
|
name, args=args, operator=operator, limit=limit_rest
|
|
)
|
|
return res
|
|
|
|
@api.constrains("is_agency", "sale_channel_id")
|
|
def _check_is_agency(self):
|
|
for record in self:
|
|
if record.is_agency and not record.sale_channel_id:
|
|
raise models.ValidationError(_("Sale Channel must be entered"))
|
|
if record.is_agency and record.sale_channel_id.channel_type != "indirect":
|
|
raise models.ValidationError(
|
|
_("Sale Channel for an agency must be indirect")
|
|
)
|
|
if not record.is_agency and record.sale_channel_id:
|
|
record.sale_channel_id = None
|
|
|
|
# REVIEW: problems with odoo demo data
|
|
# @api.constrains("mobile", "email")
|
|
# def _check_duplicated(self):
|
|
# for record in self:
|
|
# partner, field = record._search_duplicated()
|
|
# if partner:
|
|
# raise models.ValidationError(
|
|
# _(
|
|
# "Partner %s found with same %s (%s)",
|
|
# partner.name,
|
|
# partner._fields[field].string,
|
|
# getattr(record, field),
|
|
# )
|
|
# )
|
|
|
|
def _search_duplicated(self):
|
|
self.ensure_one()
|
|
partner = False
|
|
for field in self._get_key_fields():
|
|
if getattr(self, field):
|
|
partner = self.search(
|
|
[(field, "=", getattr(self, field)), ("id", "!=", self.id)]
|
|
)
|
|
if partner:
|
|
field = field
|
|
return partner, field
|
|
|
|
@api.model
|
|
def _get_key_fields(self):
|
|
key_fields = super(ResPartner, self)._get_key_fields()
|
|
key_fields.extend(["document_number"])
|
|
return key_fields
|