class Project(metaclass=PoolMeta):
__name__ = 'lims.project'
int_itl_party = fields.Many2One('party.party', 'ITL Party',
depends=['type'], states={
'required': Bool(Equal(Eval('type'), 'itl')),
})
int_result_date = fields.Date('Result date')
int_report_reception = fields.Date('Report reception')
int_evaluation = fields.Text('Evaluation',
depends=['type', 'end_date'], states={
'required': And(Equal(Eval('type'), 'itl'),
Bool(Eval('end_date'))),
})
@classmethod
def __setup__(cls):
super().__setup__()
project_type = ('itl', 'Interlaboratory')
if project_type not in cls.type.selection:
cls.type.selection.append(project_type)
@classmethod
def view_attributes(cls):
return super().view_attributes() + [
('//group[@id="itl"]', 'states', {
'invisible': Not(Bool(Equal(Eval('type'), 'itl'))),
}),
]
def __setup__(cls):
super(InpatientMealOrder, cls).__setup__()
cls._buttons.update(
{'cancel': {
'invisible': Not(Equal(Eval('state'), 'ordered'))
}})
cls._buttons.update({
'generate': {
'invisible':
Or(Equal(Eval('state'), 'ordered'),
Equal(Eval('state'), 'done'))
},
})
cls._buttons.update(
{'done': {
'invisible': Not(Equal(Eval('state'), 'ordered'))
}})
cls._error_messages.update({
'meal_order_warning':
'===== MEAL WARNING ! =====\n\n\n'
'This patient has special meal needs \n\n'
'Check and acknowledge that\n'
'the meal items in this order are correct \n\n',
'health_professional_warning':
'No health professional associated to this user',
})
t = cls.__table__()
cls._sql_constraints = [
('meal_order_uniq', Unique(t, t.meal_order),
'The Meal Order code already exists'),
]
def __setup__(cls):
super(InpatientRegistration, cls).__setup__()
# Make readonly for bed depends on a person being hospitalised or
# discharged from the hospital
cls.bed.states = {'required': True,
'readonly': Or(Equal(Eval('state'), 'hospitalized'),
Equal(Eval('state'), 'confirmed'),
Equal(Eval('state'), 'done'))}
# Changed depends to accommodate state
cls.bed.depends = ['name', 'state']
# make discharge_date not required
cls.discharge_date.required = False
if not cls.discharge_date.states:
cls.discharge_date.states = {}
cls.discharge_date.states['invisible'] = Not(
In(Eval('state'), ['done', 'hospitalized']))
# rename the set of states
cls.state.selection = [
('free', 'Pending'),
('cancelled', 'Cancelled'),
('confirmed', 'Confirmed'),
('hospitalized', 'Admitted'),
('done', 'Discharged/Done')
]
# discharge_date is the real thing
cls.discharge_date.string = 'Discharged'
def __setup__(cls):
super(InpatientRegistration, cls).__setup__()
cls._sql_constraints = [('name_uniq', 'unique(name)',
'The Registration code already exists')]
cls._error_messages.update({
'bed_is_not_available':
'Bed is not available',
'destination_bed_unavailable':
'Destination bed unavailable'
})
cls._buttons.update({
'confirmed': {
'invisible':
And(Not(Equal(Eval('state'), 'free')),
Not(Equal(Eval('state'), 'cancelled'))),
},
'cancel': {
'invisible': Not(Equal(Eval('state'), 'confirmed')),
},
'discharge': {
'invisible': Not(Equal(Eval('state'), 'hospitalized')),
},
'admission': {
'invisible': Not(Equal(Eval('state'), 'confirmed')),
},
})
def __setup__(cls):
super(Appointment, cls).__setup__()
cls._error_messages.update(
no_institution="No institution specified in appointment [%s]")
cls.state.selection = APPOINTMENT_STATES
cls._buttons.update({
'start_encounter': {
'readonly':
Not(And(Equal(Eval('state'), 'arrived'), Bool(Eval('name')))),
'invisible':
In(Eval('state'), ['processing', 'done']),
},
'goto_encounter': {
'invisible': Not(In(Eval('state'), ['processing', 'done']))
},
'client_arrived': {
'readonly':
Not(And(Equal(Eval('state'), 'confirmed'), Bool(Eval('name'))))
}
})
ro_states = {'readonly': Not(In(Eval('state'), ['confirmed', 'free']))}
cls.patient.states.update(ro_states)
cls.institution.states = ro_states
cls.state.states = ro_states
cls.appointment_date.states = ro_states
cls.comments.states.update(
{'invisible': ~Eval('can_do_details', False)})
def view_attributes(cls):
return [
('//group[@id="motor_vehicle_accident"]', 'states', {
'invisible': Not(Equal(Eval('injury_type'), 'motor_vehicle')),
}),
('//group[@id="violent_injury"]', 'states', {
'invisible': Not(Equal(Eval('injury_type'), 'violence')),
}),
('//group[@id="iss_place"]', 'states', {
'invisible': Equal(Eval('injury_type'), 'motor_vehicle'),
}),
]
def __setup__(cls):
super(TransportRequest, cls).__setup__()
t = cls.__table__()
cls._sql_constraints = [
('code_uniq', Unique(t,t.code),
'This Request Code already exists'),
]
cls._buttons.update({
'open_support': {'invisible': Equal(Eval('state'), 'open')},
'close_support': {'invisible': Equal(Eval('state'), 'closed')},
})
class InvoiceLine(ModelSQL, ModelView):
"""Invoice Line"""
_name = 'account.invoice.line'
work = fields.Many2One('timesheet.work', 'Work')
timesheet_lines = fields.One2Many(
'timesheet.line',
'invoice_line',
'Timesheet Lines',
add_remove=[
('invoice_line', '=', False),
('work', '=', Eval('work')),
('billable', '=', True),
('hours', '>', 0),
],
)
# add timesheet_lines to on_change_with list on parent
quantity = fields.Float('Quantity',
digits=(16, Eval('unit_digits', 2)),
states={
'invisible': Not(Equal(Eval('type'), 'line')),
'required': Equal(Eval('type'), 'line'),
},
on_change_with=['timesheet_lines'])
# add timesheet_lines to on_change_with list on parent
amount = fields.Function(
fields.Numeric('Amount',
digits=(16,
Get(Eval('_parent_invoice',
{}), 'currency_digits',
Eval('currency_digits', 2))),
states={
'invisible':
Not(In(Eval('type'), ['line', 'subtotal'])),
},
on_change_with=[
'type',
'quantity',
'unit_price',
'_parent_invoice.currency',
'currency',
'timesheet_lines',
]), 'get_amount')
def on_change_with_quantity(self, vals):
hours = 0.0
for line in vals.get('timesheet_lines'):
hours = hours + line.get('hours')
return hours
def __setup__(cls):
cls._buttons.update({
'generate_prescription': {
'invisible': Equal(Eval('state'), 'validated'),
},
'create_prescription': {
'invisible':
Or(Equal(Eval('state'), 'done'),
Equal(Eval('state'), 'validated'))
},
})
''' Allow calling the set_signature method via RPC '''
cls.__rpc__.update({
'set_signature': RPC(readonly=False),
})
class Hora(ModelSQL, ModelView):
'Hora'
__name__ = 'rrhh.pa.208.hora'
name = fields.Char('Nombre', required=True)
description = fields.Text('Descripcion')
tipo = fields.Selection([
('normal', 'Normal'),
('sobretiempo', 'Sobretiempo'),
('descuento', 'Descuento'),
],
'Tipo',
required=True)
recargo = fields.Numeric('% Recargo',
digits=(16, Eval('currency_digits', 2)),
states={
'invisible':
Not(Equal(Eval('tipo'), 'sobretiempo')),
},
depends=['currency_digits', 'tipo'])
currency_digits = fields.Function(fields.Integer('Currency Digits'),
'get_currency_digits')
orden = fields.Integer('Orden')
active = fields.Boolean('Active')
@staticmethod
def default_active():
return True
@staticmethod
def default_currency_digits():
return _get_currency_digits()
def get_currency_digits(self, name=None):
return _get_currency_digits()
class Sale(metaclass=PoolMeta):
__name__ = 'sale.sale'
price_list = fields.Many2One(
'product.price_list',
'Price List',
help="Use to compute the unit price of lines.",
domain=[('company', '=', Eval('company'))],
states={
'readonly':
Or(Not(Equal(Eval('state'), 'draft')), Bool(Eval('lines', [0]))),
},
depends=['state', 'company'])
@classmethod
def __setup__(cls):
super(Sale, cls).__setup__()
cls.party.states['readonly'] = (cls.party.states['readonly']
| Eval('lines', [0]))
cls.lines.states['readonly'] = (cls.lines.states['readonly']
| ~Eval('party'))
if 'party' not in cls.lines.depends:
cls.lines.depends.append('party')
def on_change_party(self):
pool = Pool()
Configuration = pool.get('sale.configuration')
super(Sale, self).on_change_party()
if self.party and self.party.sale_price_list:
self.price_list = self.party.sale_price_list
else:
config = Configuration(1)
self.price_list = config.sale_price_list
def __setup__(cls):
super(PatientSESAssessment, cls).__setup__()
cls._buttons.update({
'end_assessment': {'invisible': Equal(Eval('state'), 'done')}
})
cls._order.insert(0, ('assessment_date', 'DESC'))
def __setup__(cls):
super(OphthalmologyEvaluation, cls).__setup__()
cls._buttons.update(
{'end_evaluation': {
'invisible': Equal(Eval('state'), 'done')
}})
def __setup__(cls):
super(PatientSESAssessment, cls).__setup__()
cls._buttons.update(
{'end_assessment': {
'invisible': Equal(Eval('state'), 'done')
}})
class Sale:
__name__ = 'sale.sale'
price_list = fields.Many2One('product.price_list', 'Price List',
domain=[('company', '=', Eval('company'))],
states={
'readonly': Or(Not(Equal(Eval('state'), 'draft')),
Bool(Eval('lines', [0]))),
},
depends=['state', 'company'])
@classmethod
def __setup__(cls):
super(Sale, cls).__setup__()
cls.party.states['readonly'] = (cls.party.states['readonly']
| Eval('lines', [0]))
cls.lines.states['readonly'] = (cls.lines.states['readonly']
| ~Eval('party'))
if 'party' not in cls.lines.depends:
cls.lines.depends.append('party')
def on_change_party(self):
super(Sale, self).on_change_party()
self.price_list = None
if self.party and self.party.sale_price_list:
self.price_list = self.party.sale_price_list
def __setup__(cls):
super(PatientLabTestRequest, cls).__setup__()
cls._buttons.update({
'update_service': {
'readonly': Equal(Eval('state'), 'done'),
},
})
def __setup__(cls):
super().__setup__()
project_type = ('tas', 'TAS')
if project_type not in cls.type.selection:
cls.type.selection.append(project_type)
cls.client.states = {'required': Bool(Equal(Eval('type'), 'tas'))}
cls.client.depends = ['type']
def __setup__(cls):
super(PatientPrescriptionOrder, cls).__setup__()
cls._buttons.update({
'update_service': {
'readonly': Equal(Eval('state'), 'done'),
},
})
def __setup__(cls):
super(LabTest, cls).__setup__()
cls._buttons.update({
'generate_document': {
'invisible': Not(Equal(Eval('state'), 'draft')),
},
'set_to_draft': {
'invisible': Not(Equal(Eval('state'), 'done')),
},
'sign_document': {
'invisible': Not(Equal(Eval('state'), 'done')),
},
})
''' Allow calling the set_signature method via RPC '''
cls.__rpc__.update({
'set_signature': RPC(readonly=False),
})
class PriceAdjustment(ModelView):
"""Price Adjustment"""
__name__ = 'hrp_report.price_adjustment'
type = fields.Selection([
('00', u'时间'),
('01', u'药品简码'),
],
'type',
select=True,
states={
'readonly': Bool(Eval('moves')),
}) # 查询类型
drug_code = fields.Many2One(
'product.product',
'drug_code',
select=True,
states={'readonly': ~Equal(Eval('type'), '01')},
depends=['type']) # 药品简码
start_time = fields.Date('start_time',
select=True,
states={'readonly': ~Equal(Eval('type'), '00')},
depends=['type']) # 开始时间
end_time = fields.Date('end_time',
select=True,
states={'readonly': ~Equal(Eval('type'), '00')},
depends=['type']) # 结束时间
find = fields.Boolean('find', select=True) # 查找按钮
moves = fields.One2Many('hrp_report.price_adjustment_message', 'None',
'moves') # 显示界面
@fields.depends('type', 'start_time', 'start_time', 'drug_code')
def on_change_type(self):
if self.type == '00':
Date = Pool().get('ir.date')
today = str(Date.today())
self.start_time = today
self.end_time = today
self.drug_code = None
else:
self.start_time = None
self.end_time = None
@staticmethod
def default_type():
return '00'
def __setup__(cls):
super(School, cls).__setup__()
cls._buttons.update({
'approve_school': {
'invisible': Equal(Eval('state'), 'approved')
}
})
def __setup__(cls):
super().__setup__()
project_type = ('implementation', 'Implementation')
if project_type not in cls.type.selection:
cls.type.selection.append(project_type)
cls.external_quality_control.states['invisible'] = Bool(
Equal(Eval('type'), 'implementation'))
cls.external_quality_control.depends = ['type']
def __setup__(cls):
super(PartyIdentifier, cls).__setup__()
cls.code.states['readonly'] = Equal(Eval('type'), 'client_number')
for new_type in [
('client_number', 'Client Number'),
]:
if new_type not in cls.type.selection:
cls.type.selection.append(new_type)
def __setup__(cls):
super().__setup__()
cls._sql_constraints = []
cls.start_uom.states = {
'invisible': ~Equal(Eval('quality_type'), 'quantitative'),
'required': Equal(Eval('quality_type'), 'quantitative'),
}
cls.start_uom.depends = ['quality_type']
cls.end_uom.states = {
'invisible': ~Equal(Eval('quality_type'), 'quantitative'),
}
cls.end_uom.depends = ['quality_type']
cls.initial_concentration.states = {
'invisible': ~Equal(Eval('quality_type'), 'quantitative'),
}
cls.initial_concentration.depends = ['quality_type']
cls.final_concentration.states = {
'invisible': ~Equal(Eval('quality_type'), 'quantitative'),
}
cls.final_concentration.depends = ['quality_type']
cls.limit_digits.states = {
'invisible': ~Equal(Eval('quality_type'), 'quantitative'),
}
cls.limit_digits.depends = ['quality_type']
cls.calc_decimals.states = {
'invisible': ~Equal(Eval('quality_type'), 'quantitative'),
}
cls.calc_decimals.depends = ['quality_type']
def __setup__(cls):
super(HealthService, cls).__setup__()
cls._sql_constraints += [('name_uniq', 'UNIQUE(name)',
'The Service ID must be unique')]
cls._buttons.update({
'button_set_to_draft': {
'invisible': Equal(Eval('state'), 'draft')
}
})
class Invoice:
"Add payment register record to sale"
__name__ = "account.invoice"
nereid_payment_register = fields.Many2One(
'nereid.payment.register',
'Nereid Payment Record',
states={
'readonly': Not(Equal(Eval('state'), 'draft')),
})
def __setup__(cls):
cls._buttons.update({
'sign_evaluation': {
'invisible': Not(Equal(Eval('state'), 'done')),
},
})
''' Allow calling the set_signature method via RPC '''
cls.__rpc__.update({
'set_signature': RPC(readonly=False),
})
def __setup__(cls):
cls._buttons.update({
'generate_death_certificate': {
'invisible': Not(Equal(Eval('state'), 'signed')),
},
})
''' Allow calling the set_signature method via RPC '''
cls.__rpc__.update({
'set_signature': RPC(readonly=False),
})
def __setup__(cls):
super(FederationQueue, cls).__setup__()
t = cls.__table__()
cls._sql_constraints = [
('msgid_uniq', Unique(t,t.msgid), \
'The Message ID must be unique !'),]
cls._buttons.update({
'send': {'invisible': Equal(Eval('state'), 'sent')}
})
class TestlReturnRequest(ModelView):
'Internal Return Request'
__name__ = 'hrp_new_product.test_return_request'
_rec_name = 'number'
product_name = fields.Char('product_name', select=True,
readonly=True) #产品名字
product = fields.Many2One("product.product",
"Product",
required=True,
readonly=True) #产品
from_location = fields.Many2One("stock.location",
"from_location",
select=True,
readonly=True) #
to_location = fields.Many2One("stock.location",
"to_location",
select=True,
readonly=True) #
code = fields.Char('code', select=True, readonly=True) #编码
drug_specifications = fields.Char('drug_specifications',
select=True,
readonly=True) #规格
uom = fields.Many2One('product.uom', 'company', select=True,
readonly=True) #单位
return_quantity = fields.Integer('Return Quantity',
select=True,
readonly=True) #请退数量
comment = fields.Text('Comment', select=True) #备注
can_return_quantity = fields.Float('Can Return Quantity',
select=True,
states={
'readonly':
Equal(Eval('examine'), '02'),
}) #可以退的药品数量
examine = fields.Selection([
('00', u''),
('01', u'未审核'),
('02', u'已审核'),
],
'Examine',
select=True) #退药审核
is_direct_sending = fields.Boolean('Is_direct_sending',
select=True,
readonly=True) #是否直送
party = fields.Many2One('party.party', 'party', select=True) #供应商
@classmethod
def search_product(cls, name, domain=None):
location_ids = Transaction().context.get('product')
return cls._search_quantity(name,
location_ids,
domain,
grouping=('product', 'product'))
