def setUp(self):
super(TestFieldsExist, self).setUp()
self.Model = self.env[get_modelname(Model)]
self.resurrected_fields = [
'parent_id',
'child_ids',
]
def setUp(self):
super(TestPricelistTypeFields, self).setUp()
self.Model = self.env[get_modelname(PricelistType)]
self.resurrected_fields = [
'name',
'key',
]
class Project(models.Model):
_inherit = models.get_modelname(BaseProject)
state = fields.Selection(
selection=[('draft', 'New'), ('open', 'In Progress'),
('cancelled', 'Cancelled'), ('pending', 'Pending'),
('close', 'Closed')],
string='Status',
required=True,
copy=False,
default='open',
track_visibility='onchange',
)
def set_done(self):
return self.write(dict(state='close'))
def set_cancel(self):
return self.write(dict(state='cancelled'))
def set_pending(self):
return self.write(dict(state='pending'))
def set_open(self):
return self.write(dict(state='open'))
class Menu(models.Model):
_inherit = get_modelname(ir_ui_menu)
@api.model
def get_user_roots(self):
preview_menu = None
if self._uid != SUPERUSER_ID:
widget_models = XopgiBoardWidgetRel.get_widget_capable_models()
# if active user has no widget to see on preview.
if not any(m.get_user_widgets() for m in widget_models):
preview_menu = self.env.ref('xopgi_board.menu_board_my_dash',
raise_if_not_found=False)
return super(Menu, self.with_context(
exclude_menu_items=preview_menu)).get_user_roots()
@api.model
def search(self, args, offset=0, limit=None, order=None, count=False):
from xoeuf.osv import expression as expr
exclude = self.env.context.get('exclude_menu_items')
if exclude:
args = expr.AND([args, [('id', 'not in', exclude.ids)]])
return super(Menu, self).search(args,
offset=offset,
limit=limit,
order=order,
count=count)
class AnalyticAccount(models.Model):
_inherit = models.get_modelname(AccountAnalyticAccount)
manager_id = fields.Many2one(
'res.users',
'Account Manager',
track_visibility='onchange'
)
class ResGroupWidget(models.Model):
_name = 'res.group.widget'
_order = 'group, priority'
_inherit = WIDGET_REL_MODEL_NAME
group = fields.Many2one(get_modelname(res_groups), required=True)
def get_user_widgets(self):
'''Returns the groups in which the current user is located
'''
return self.sudo().search([('group.users', '=', self._uid)
]).sudo(self._uid)
class MrpBomLine(models.Model):
_inherit = models.get_modelname(BomLines)
type = fields.Selection(
[('normal', 'Manufacture this product'),
('phantom', 'Ship this product as a set of components (kit)')],
string='BoM Type',
default='normal',
required=True,
help=("Kit (Phantom): When processing a sales order for this product, "
"the delivery order will contain the raw materials,"
"instead of the finished product.")
)
class AnalyticAccount(models.Model):
_inherit = models.get_modelname(AccountAnalyticAccount)
state = fields.Selection(
selection=[('draft', 'New'),
('open', 'In Progress'),
('pending', 'To Renew'),
('close', 'Closed'),
('cancelled', 'Cancelled')],
string='Status',
required=True,
default='draft',
track_visibility='onchange',
copy=False
)
def setUp(self):
super(TestFieldsView, self).setUp()
self.Model = self.env[get_modelname(Model)]
group_user = self.env.ref('sales_team.group_sale_salesman')
self.user = self.env['res.users'].create({
'name':
'Mark User',
'login':
'******',
'email':
'*****@*****.**',
'signature':
'--\nMark',
'notify_email':
'always',
'groups_id': [(6, 0, [group_user.id])]
})
class AnalyticAccount(models.Model):
_inherit = models.get_modelname(AccountAnalyticAccount)
@api.multi
def set_open(self):
return self.write({'state': 'open'})
@api.multi
def set_close(self):
return self.write({'state': 'close'})
@api.multi
def set_pending(self):
return self.write({'state': 'pending'})
@api.multi
def set_cancel(self):
return self.write({'state': 'cancelled'})
class AnalyticAccount(models.Model):
_inherit = get_modelname(AccountAnalyticAccount)
parent_id = fields.Many2one(comodel_name='account.analytic.account',
string='Parent Analytic Account',
select=2)
child_ids = fields.One2many(comodel_name='account.analytic.account',
inverse_name='parent_id',
string='Child Accounts')
@api.multi
def check_recursion(self, parent=None):
return super(AnalyticAccount, self)._check_recursion(parent=parent)
_constraints = [
(check_recursion,
'Error! You cannot create recursive analytic accounts.',
['parent_id']),
]
class ProductPricelist(models.Model):
_inherit = get_modelname(BasePricelist)
_name = _inherit
@api.model
def _pricelist_type_get(self):
pricelists = self.env['product.pricelist.type'].search([],
order='name')
return [(p.key, p.name) for p in pricelists]
@api.model
def _pricelist_type_default(self):
pricelist_type1 = self.env['product.pricelist.type'].search([],
limit=1)
return pricelist_type1 and pricelist_type1.key or None
type = fields.Selection(selection=_pricelist_type_get,
string='Pricelist Type',
default=_pricelist_type_default)
class ProductPricelistItem(models.Model):
_inherit = get_modelname(BasePricelistItem)
_name = _inherit
@api.model
def _get_price_field_get(self):
PriceType = self.env['product.price.type']
types = PriceType.search([])
result = []
for line in types:
result.append((line.field, line.name))
result.append(('pricelist', _('Other Pricelist')))
return result
base = fields.Selection(
selection="_get_price_field_get",
string="Based on",
required=True,
default="list_price",
help="Base price for computation."
)
class PurchaseOrder(models.Model):
_inherit = models.get_modelname(PurchaseOrder)
bid_date = fields.Datetime(
string='Bid Received On',
readonly=True,
help="Date on which the bid was received"
)
state = fields.Selection([
('draft', 'Draft PO'),
('sent', 'RFQ Sent'),
('bid', 'Bid Received'),
('to approve', 'To Approve'),
('purchase', 'Purchase Order'),
('done', 'Done'),
('cancel', 'Cancelled')])
incoterm_id = fields.Many2one(
'stock.incoterms',
string="Incoterm",
help=("International Commercial Terms are a series of predefined "
"commercial terms used in international transactions.")
)
@api.multi
def accion_bid_received(self):
return self.write({'state': 'bid', 'bid_date': fields.Datetime.now()})
@api.multi
def button_confirm(self):
approve = self.browse()
for order in self:
if order.state in ['draft', 'sent', 'bid']:
approve |= order
# Odoo 9+ skips orders that are not in 'draft', or 'sent'. So
# we trick it to process orders in state 'bid'.
if order.state == 'bid':
order.state = 'sent'
return super(PurchaseOrder, approve).button_confirm()
class mail_message(models.Model):
"""Store the translated name of the model that the message reference to."""
_name = _inherit = get_modelname(MailMessage)
model_names = fields.Char(
compute='_get_model_names',
search='_search_model_names',
string='Associated to',
)
@api.multi
def _get_model_names(self):
for message in self:
if message.model:
translations = translate_model_name(
self,
message['model'],
)
message.model_names = ' | '.join(translations)
@api.model
def _search_model_names(self, operator, value):
ir_translation = self.env['ir.translation']
translations = ir_translation.search(
[
('name', '=', 'ir.model,name'), # Search in model names
'|', # If any of:
('src', operator, value), # source matches value
('value', operator, value), # translation matches value
], )
model_names = list({trans.src for trans in translations})
models = [
m.model
for m in self.env['ir.model'].search([('name', 'in', model_names)])
]
return [('model', 'in', models)]
def setUp(self):
super(TestFieldsExist, self).setUp()
self.Model = self.env[get_modelname(Model)]
self.resurrected_fields = ['name', 'field', 'currency_id']
class AnalyticLine(models.Model):
_inherit = get_modelname(AccountAnalyticLine)
parent_account_id = fields.Many2one(related="account_id.parent_id",
store=True,
readonly=True)
def setUp(self):
super(TestFieldsExist, self).setUp()
self.Model = self.env[get_modelname(Model)]
self.resurrected_fields = [
'state', 'set_open', 'set_close', 'set_pending', 'set_cancel'
]
class AnalyticAccount(models.Model):
_inherit = models.get_modelname(AccountAnalyticAccount)
date_start = fields.Date(string='Start Date')
date = fields.Date(string='Expiration Date', track_visibility='onchange')
class ResGroup(models.Model):
_inherit = get_modelname(res_groups)
widgets = fields.One2many('res.group.widget', 'group')
class MessageRecipients(models.Model):
_name = get_modelname(Message)
_inherit = _name
recipients = fields.Char()
def setUp(self):
super(TestFieldsExist, self).setUp()
self.Model = self.env[get_modelname(Model)]
self.resurrected_fields = [
'state',
]
class AnalyticAccount(models.Model):
_inherit = get_modelname(AccountAnalyticAccount)
code = fields.Char(default=lambda self: self.env['ir.sequence'].get(
'account.analytic.account'))
