def _update_analytic_line_columns(self, cr, ids=None, context=None):
super(AnalyticAxis, self)._update_analytic_line_columns(cr, ids, context)
context = context or {}
if isinstance(ids, (int, long)):
ids = [ids]
if not ids:
ids = self.search(cr, 1, [], context={'active_test': False})
line_obj = self.pool.get('crossovered.budget.lines')
for axis in self.browse(cr, 1, ids, context):
if (not axis.active or context.get('unlink_axis') or not axis.is_budget_axis) and axis.column_label in line_obj._columns:
del line_obj._columns[axis.column_label]
if axis.field_ids:
for field in axis.field_ids:
column = '%s_%s' % (axis.column_label, field.id)
if column in line_obj._columns:
del line_obj._columns[column]
elif axis.active and axis.is_budget_axis:
line_obj._columns[axis.column_label] = fields.many2one(axis.model, axis.name,
domain=axis.domain and eval(axis.domain) or [],
required=axis.required)
if axis.field_ids:
for field in axis.field_ids:
column = '%s_%s' % (axis.column_label, field.id)
line_obj._columns[column] = fields.related(axis.column_label, field.name,
type=field.ttype, relation=field.relation,
store={
# To store and to avoid the field re-computation
'crossovered.budget.lines': (lambda self, cr, uid, ids, context=None: [], None, 10),
})
line_obj._auto_init(cr, context)
return True
def _update_analytic_line_columns(self, cr, ids=None, context=None):
context = context or {}
if isinstance(ids, (int, long)):
ids = [ids]
if not ids:
ids = self.search(cr, 1, [], context={'active_test': False})
line_obj = self.pool.get('account.analytic.line')
non_unicity_fields = line_obj._non_unicity_fields[:]
for axis in self.browse(cr, 1, ids, context):
if (not axis.active or context.get('unlink_axis')) and axis.column_label in line_obj._columns:
del line_obj._columns[axis.column_label]
if axis.field_ids:
for field in axis.field_ids:
column = '%s_%s' % (axis.column_label, field.id)
if column in line_obj._columns:
del line_obj._columns[column]
elif axis.active:
# To be compatible with smile_analytic_forecasting
if hasattr(line_obj, '_non_unicity_fields'):
if axis.is_unicity_field and axis.column_label in line_obj._non_unicity_fields:
line_obj._non_unicity_fields.remove(axis.column_label)
elif not axis.is_unicity_field and axis.column_label not in line_obj._non_unicity_fields:
line_obj._non_unicity_fields.append(axis.column_label)
###
line_obj._columns[axis.column_label] = fields.many2one(axis.model, axis.name,
domain=axis.domain and eval(axis.domain) or [],
required=axis.required, ondelete=axis.ondelete)
if axis.field_ids:
for field in axis.field_ids:
column = '%s_%s' % (axis.column_label, field.id)
line_obj._columns[column] = fields.related(axis.column_label,
field.name, type=field.ttype,
relation=field.relation, store={
# To store and to avoid the field re-computation
'account.analytic.line': (lambda self, cr, uid, ids,
context=None: [], None, 10),
})
line_obj._auto_init(cr, context)
# To be compatible with smile_analytic_forecasting
if hasattr(line_obj, '_non_unicity_fields'):
if line_obj._non_unicity_fields != non_unicity_fields:
cr.execute("SELECT count(0) FROM pg_class WHERE relname = 'account_analytic_line_multi_columns_index'")
exists = cr.fetchone()
if exists[0]:
cr.execute('DROP INDEX account_analytic_line_multi_columns_index')
cr.execute('CREATE INDEX account_analytic_line_multi_columns_index '
'ON account_analytic_line (%s)' % ', '.join(line_obj._get_unicity_fields()))
###
return True
class xml_profile_line(osv.osv):
_name = "xml.profile.line"
_description = "XML Profile line"
_columns = {
'profile_id':
fields.many2one('xml.profile', 'XML Profile', required=True),
'xml_field':
fields.many2one('xml.export.field',
'Export Field',
required=True,
ondelete="restrict"),
'openerp_field':
fields.many2one('ir.model.fields', 'OpenERP Field'),
'openerp_model':
fields.many2one('ir.model', 'OpenERP Model'),
'action':
fields.selection((
('field', 'Field Value'),
('compute', 'Empty/Compute Value'),
('attribute', 'Alter Attribute'),
('repeat', 'Repeat per record'),
('repeat_sub', 'Repeat per value'),
),
string='Action',
required=True),
'code':
fields.text(
'Code',
help='Any custom code (python expression) you want to apply'),
'include_code':
fields.text(
'Include code',
help='Python expression which will toggle inclusion in export'),
'notes':
fields.text('Notes'),
'sequence':
fields.related('xml_field',
'sequence',
type='integer',
string='Sequence',
readonly=True),
}
_defaults = {
'include_code': 'True',
}
class hr_employee(osv.osv):
_name = "hr.employee"
_inherit = "hr.employee"
_columns = {
'product_id':
fields.many2one(
'product.product',
'Product',
help=
"Specifies employee's designation as a product with type 'service'."
),
'journal_id':
fields.many2one('account.analytic.journal', 'Analytic Journal'),
'uom_id':
fields.related('product_id',
'uom_id',
type='many2one',
relation='product.uom',
string='Unit of Measure',
store=True,
readonly=True)
}
def _getAnalyticJournal(self, cr, uid, context=None):
md = self.pool.get('ir.model.data')
try:
result = md.get_object_reference(cr, uid, 'hr_timesheet',
'analytic_journal')
return result[1]
except ValueError:
pass
return False
def _getEmployeeProduct(self, cr, uid, context=None):
md = self.pool.get('ir.model.data')
try:
result = md.get_object_reference(cr, uid, 'product',
'product_consultant')
return result[1]
except ValueError:
pass
return False
_defaults = {
'journal_id': _getAnalyticJournal,
'product_id': _getEmployeeProduct
}
class stock_picking_out(osv.osv):
_inherit = 'stock.picking.out'
_columns = {
'is_bom_move':
fields.boolean('BOM Move', readonly=False),
'ref_mo_id':
fields.many2one('mrp.production',
'Ref MO',
domain=[('parent_id', '=', False)]),
'ref_sub_mo_ids':
fields.related('ref_mo_id',
'child_ids',
type='one2many',
relation='mrp.production',
string='Ref Sub-MOs',
readonly=True),
'department_id':
fields.many2one('hr.department', 'Department', readonly=False),
}
_defaults = {
'is_bom_move': lambda s, cr, uid, c: c.get('is_bom_move', False),
}
def copy(self, cr, uid, id, default=None, context=None):
if default.get('name', '/') == '/':
picking_obj = self.pool.get('stock.picking')
picking = picking_obj.browse(cr, uid, id, context=context)
if picking.id and picking.is_bom_move:
name = self.pool.get('ir.sequence').get(cr, uid, 'bom.move')
default.update(name=name)
return super(stock_picking_out, self).copy(cr,
uid,
id,
default=default,
context=context)
def create(self, cr, user, vals, context=None):
if ('name' not in vals) or (vals.get('name') == '/'):
# For BOM Move
seq_obj_name = \
vals.get('is_bom_move', False) and 'bom.move' or False
if seq_obj_name:
vals['name'] = \
self.pool.get('ir.sequence').get(cr, user, seq_obj_name)
new_id = super(stock_picking_out, self).create(cr, user, vals, context)
return new_id
class jmdpuerchaseorder(osv.Model):
_inherit = "purchase.order"
_columns = {
'deducible':
fields.boolean(string="Gasto Deducible"),
'plaza':
fields.many2one("plaza", "Plaza Origen"),
'gasto_oficina':
fields.boolean("Gastos de Oficina"),
'nombre_corto':
fields.related("proyecto",
"nombre_corto",
type="char",
string="Nombre Corto",
readonly=True,
store=True)
}
class qc_test_template_line(osv.osv):
_name = 'qc.test.template.line'
_order = 'sequence asc'
def onchange_proof_id(self, cr, uid, ids, proof_id, context):
if not proof_id:
return {}
proof = self.pool.get('qc.proof').browse(cr, uid, proof_id, context)
return {
'value': {
'type': proof.type,
}}
_columns = {
'name': fields.char('Name', size=64),
'sequence': fields.integer('Sequence', required=True),
'test_template_id': fields.many2one('qc.test.template',
'Test Template', select=True),
'proof_id': fields.many2one('qc.proof', 'Proof', required=True,
select=True),
'valid_value_ids': fields.many2many('qc.posible.value',
'qc_template_value_rel', 'template_line_id', 'value_id',
'Values'),
'method_id': fields.many2one('qc.proof.method', 'Method', select=True),
'notes': fields.text('Notes'),
# Only if quantitative
'min_value': fields.float('Min',
digits_compute=dp.get_precision('Quality Control')),
# Only if quantitative
'max_value': fields.float('Max',
digits_compute=dp.get_precision('Quality Control')),
# Only if quantitative
'uom_id': fields.many2one('product.uom', 'UoM'),
'type': fields.selection([
('qualitative', 'Qualitative'),
('quantitative', 'Quantitative'),
], 'Type', select=True),
'company_id': fields.related('test_template_id', 'company_id',
type='many2one', relation='res.company', string='Company',
store=True, readonly=True),
}
_defaults = {
'sequence': lambda *b: 1,
}
class fuel_exchange_status_archive(osv.osv):
""" To manage Fuel Exchange Status archive """
_name = "fuel_exchange_status_archive"
def _get_amount(self, cr, uid, ids, name, attr, context=None):
res = {}
for line in self.browse(cr, uid, ids, context=context):
#if not line.vehicle_id.fuel_amount_id:
# print "________________",line.vehicle_id.fuel_amount_id
# line.vehicle_id.write({'fuel_amount_id':False})
if line.vehicle_id.fuel_amount_id:
print ".................", line.vehicle_id.fuel_amount_id.fuel_amount
#res[line.id] = line.vehicle_id.fuel_amount_id.fuel_amount
return res
_columns = {
'vehicle_id':
fields.many2one('fleet.vehicle', 'Vehicle'),
'fuel_exchange_status':
fields.selection([('exchange', 'Currently Disbursed'),
('stop', 'Stopped')], 'Fuel Exchange Status'),
'fuel_stop_reason_id':
fields.many2one('fuel.stop.reasons', 'Fuel Stopped Reason'),
'date':
fields.date('Date'),
'details':
fields.text('Details'),
'fuel_type':
fields.selection([('gasoline', 'Gasoline'), ('diesel', 'Benzene'),
('electric', 'Electric'), ('hybrid', 'Hybrid')],
string='Fuel Type',
help='Fuel Used by the vehicle',
readonly=True),
'use':
fields.related('vehicle_id',
'use',
type='many2one',
string='Vehicle Use',
readonly=True,
relation='fleet.vehicle.use'),
'fuel_amount':
fields.float(string="Fuel amount"),
}
class ch_depindent_wo(osv.osv):
_name = "ch.depindent.wo"
_description = "Ch Depindent WO"
_columns = {
## Basic Info
'header_id':
fields.many2one('kg.depindent.line',
'Dept Indent Line',
required=True,
ondelete='cascade'),
'wo_id':
fields.char('WO', required=True),
#~ 'w_order_id': fields.many2one('kg.work.order','WO',required=True, domain="[('state','=','confirmed')]"),
'w_order_id':
fields.related('w_order_line_id',
'header_id',
type='many2one',
string='WO',
store=True),
'w_order_line_id':
fields.many2one('ch.work.order.details', 'WO', required=True),
'qty':
fields.float('Indent Qty', required=True),
}
def _check_qty(self, cr, uid, ids, context=None):
rec = self.browse(cr, uid, ids[0])
if rec.qty <= 0.00:
return False
return True
_constraints = [
(_check_qty, 'You cannot save with zero qty !', ['WO Qty']),
]
def onchange_wo(self, cr, uid, ids, w_order_line_id):
value = {'wo_id': ''}
if w_order_line_id:
wo_rec = self.pool.get('ch.work.order.details').browse(
cr, uid, w_order_line_id)
value = {'wo_id': wo_rec.order_no}
return {'value': value}
class training_session(osv.osv):
_inherit = 'training.session'
_columns = {
'location_id' : fields.many2one('training.location', 'Location', select=1, help='The location for seance'),
'seats' : fields.related('location_id', 'seats', type='integer', string='Maximum Seats',
readonly=True, help='Maximum seats available in location')
}
#def copy(self, cr, uid, session_id, defaults=None, context=None):
# defaults['location_id'] = 0
# return super(training_session, self).copy(cr, uid, session_id, defaults, context)
def _create_seance(self, cr, uid, session, context=None):
seance_ids = super(training_session, self)._create_seance(cr, uid, session, context=context)
if session.location_id:
self.pool.get('training.seance').write(cr, uid, seance_ids, {'location_id' : session.location_id.id}, context=context)
return seance_ids
class project_work(OpenbaseCore):
_name = "project.task.work"
_description = "Task work"
_inherit = "project.task.work"
_columns = {
'manager_id':
fields.related('ask_id',
'manager_id',
type='many2one',
string='Services'),
'user_id':
fields.many2one('res.users', 'Done by', required=False, select="1"),
'team_id':
fields.many2one('openstc.team', 'Done by', required=False, select="1"),
'partner_id':
fields.many2one('res.partner', 'Done by', required=False, select="1"),
}
class l10n_es_tesoreria_facturas(osv.osv):
_name = 'l10n.es.tesoreria.facturas'
_inherit = 'l10n.es.tesoreria.facturas'
_columns = {
'inv_type':
fields.related('factura_id',
'type',
type="selection",
selection=[
('out_invoice', 'Customer Invoice'),
('in_invoice', 'Supplier Invoice'),
('out_refund', 'Customer Refund'),
('in_refund', 'Supplier Refund'),
],
string="Tipo"),
'payment_term':
fields.many2one('account.payment.term', 'Plazo de Pago'),
}
class account_invoice(osv.Model):
_inherit = 'account.invoice'
_columns = {
'is_einvoice':
fields.related('journal_id',
'is_einvoice',
string='Electronic Invoice',
type='boolean',
readonly=True),
'einvoice_ids':
fields.many2many('account.einvoice',
'account_einvoice_invoice_rel',
'invoice_id',
'einvoice_id',
string="Electronic Invoices",
readonly=True),
}
class OeMedicalSpecialty(osv.Model):
_name = 'oemedical.specialty'
_columns = {
'code':
fields.char(size=25, string='Code'),
'name':
fields.char(size=256, string='Name', required=True),
'description':
fields.text(string='Description'),
'parent_id':
fields.many2one('oemedical.specialty', 'Parent Specialty'),
'parent_name':
fields.related('parent_id',
'name',
type='char',
readonly=True,
string='Parent Specialty'),
'child_ids':
fields.one2many('oemedical.specialty', 'parent_id',
'Child Specialties'),
'cost':
fields.float(string='Appointment Cost'),
}
_defaults = {'cost': 40}
def _check_cost(self, cr, uid, ids, context=None):
for obj in self.browse(cr, uid, ids, context=context):
if obj.cost <= 0:
return False
return True
_sql_constraints = [
('name_uniq', 'UNIQUE(name)', 'Name must be unique!'),
]
_constraints = [
(osv.osv._check_recursion,
'Error! You can not create recursive specialties.', ['parent_id']),
(_check_cost,
'El costo de la consulta de esta especialidad no puede ser menor o igual a cero.',
[])
]
class purchase_order(osv.osv):
_inherit = "purchase.order"
_columns = {
'project_id':
fields.many2one('project.project',
'Project',
states={
'confirmed': [('readonly', True)],
'approved': [('readonly', True)],
'done': [('readonly', True)]
}),
'project_manager':
fields.related('project_id',
'user_id',
readonly=True,
string='Project Manager',
type='many2one',
relation="res.users",
store=True),
}
def onchange_project_id(self, cr, uid, ids, project_id):
analytic_account_id = ''
if project_id:
project_obj = self.pool.get('project.project')
#Read the project's analytic account
analytic_account_id = project_obj.read(
cr, uid, project_id,
'analytic_account_id')['analytic_account_id']
lines = self.pool.get('purchase.order.line')
for po in self.browse(cr, uid, ids, context=None):
#Get the order lines
for line in po.order_line:
lines.write(cr, uid, line.id, {
'account_analytic_id': analytic_account_id,
})
return {}
class hr_contract(osv.osv):
_name = 'hr.contract'
_description = 'Contract'
_columns = {
'name':
fields.char('Contract Reference', size=32, required=True),
'employee_id':
fields.many2one('hr.employee', "Employee", required=True),
'department_id':
fields.related('employee_id',
'department_id',
string="Department",
readonly=True),
'type_id':
fields.many2one('hr.contract.type', "Contract Type"),
'job_id':
fields.many2one('hr.job', 'Job Title'),
'date_start':
fields.date('Start Date', required=True),
'trial_date_start':
fields.date('Start Date', required=True),
'trial_date_end':
fields.date('Start Date', required=True),
'date_end':
fields.date('End Date'),
'working_hours':
fields.many2one('resource.calendar', 'Working Schedule'),
'wage_type_id':
fields.many2one('hr.contract.wage.type2', 'Wage Type'),
'wage':
fields.float('Wage', digits=(16, 2), required=True),
'advantages':
fields.text('Advantages'),
'advantages_net':
fields.float('Net Advantages Value', digits=(16, 2)),
'advantages_gross':
fields.float('Gross Advantages Value', digits=(16, 2)),
'notes':
fields.text('Notes'),
}
_defaults = {
'date_start': lambda *a: time.strftime("%Y-%m-%d"),
}
class mo_planning_line(osv.osv):
_name = 'mo.planning.line'
_columns = {
'planning_id': fields.many2one('mo.planning','MO Planning'),
'product_id': fields.many2one('product.product','Product', required=True),
'workcenter_id': fields.many2one('mrp.workcenter', 'Work Center', required=True),
'cycle_nbr': fields.float('Number of Cycles', required=True,
help="Number of iterations this work center has to do in the specified operation of the routing."),
'hour_nbr': fields.float('Number of Hours', required=True, help="Time in hours for this Work Center to achieve the operation of the specified routing."),
'name': fields.char('Name', size=64, required=True),
'sequence': fields.integer('Sequence', help="Gives the sequence order when displaying a list of routing Work Centers."),
'note': fields.text('Description'),
'company_id': fields.related('routing_id', 'company_id', type='many2one', relation='res.company', string='Company'),
'employee_id': fields.many2one('hr.employee', 'Worker', required=True),
'location_id': fields.many2one('stock.location', 'Location', required=True),
'routing_id': fields.many2one('mrp.routing', 'Parent Routing', select=True, ondelete='cascade',
help="Routing indicates all the Work Centers used, for how long and/or cycles." \
"If Routing is indicated then,the third tab of a production order (Work Centers) will be automatically pre-completed."),
}
class task(osv.osv):
_inherit = 'project.task'
_columns = {
'project_id':
fields.many2one(
'project.project',
'Project',
select=True,
ondelete='cascade',
help=
"If you have [?] in the project name, it means there are no analytic account linked to this project."
),
'partner_id':
fields.related('project_id',
'partner_id',
type='many2one',
relation='res.partner',
string='Partner'),
}
class customs_form_line(osv.osv):
_name = 'customs.form.line'
_description = ''
_rec_name = 'tax_code'
_columns = {
'customs_form_id':
fields.many2one('customs.form',
'Customs',
required=True,
ondelete='cascade'),
'tax_code':
fields.many2one('customs.duty',
'Tax',
ondelete='restrict',
required=True,
readonly=False),
'amount':
fields.float('Amount',
required=True,
digits_compute=dp.get_precision('Account')),
'imex_tax_line':
fields.one2many('account.invoice.tax',
'cfl_id',
'Vat lines',
attrs="{'readonly':[('vat_detail','=',True)], \
'required':[('vat_detail','=',True)]}"),
'vat_detail':
fields.related('tax_code',
'vat_detail',
type='boolean',
string='Tax detail',
store=False,
readonly=True)
}
_defaults = {}
_sql_constraints = [
('code_uniq', 'UNIQUE(customs_form_id,tax_code)',
'The code must be unique! (for this form)'),
]
class account_analytic_journal(osv.Model):
_inherit = 'account.analytic.journal'
_columns = {
'journal_id':
fields.many2one(
'account.journal',
string="Account Journal",
help="This journal is used to make the financial cost center moves"
),
'charge_account_id':
fields.related(
'journal_id',
'charge_account_id',
type='many2one',
relation='account.account',
string='Charge Account',
readonly=True,
help="Usually used in account moves of financial cost center")
}
class account_payment_term_line(osv.osv):
_inherit = "account.payment.term.line"
_columns = {
'is_discount':
fields.related('payment_id',
'is_discount',
type='boolean',
string='Is Cash Discount',
readonly=True),
'discount':
fields.float(
'Discount (%)',
digits=(4, 2),
),
'discount_income_account_id':
fields.property(
'account.account',
type='many2one',
relation='account.account',
string='Discount Income Account',
view_load=True,
help="This account will be used to post the cash discount income"),
'discount_expense_account_id':
fields.property(
'account.account',
type='many2one',
relation='account.account',
string='Discount Expense Account',
view_load=True,
help="This account will be used to post the cash discount expense"
),
}
def onchange_discount(self, cr, uid, ids, discount):
if not discount: return {}
result = {}
result = {
'value': {
'value_amount': round(1 - (discount / 100.0), 2),
}
}
return result
class neos_baseline(osv.osv):
_name = "neos.baseline"
_description = "Base line concept business"
_columns = {
'name':
fields.char('Name', size=100, required=True),
'code':
fields.char('Code', size=50, required=True),
'version':
fields.char('Version', size=100, required=True),
'description':
fields.text('Description',
help="Objective description of the Base line."),
'iteration_ids':
fields.one2many('neos.iteration', 'baseline_id', 'Base line'),
'baseline_details_lines':
fields.one2many('neos.baseline.details', 'baseline_id', 'Process'),
'method_id':
fields.many2one('neos.method', 'Method', required=True),
'setup_id':
fields.many2one('df.bl.workingdays',
'Set-up Working days',
required=True),
'task_ids':
fields.related('method_id',
'tasks_ids',
type='one2many',
relation='neos.tasks'),
'state':
fields.selection(
[('draft', 'Draft'), ('progress', 'Being planned')],
'State',
readonly=True,
required=True,
help='When the task is created the state is \'Draft\'.\n state.\
\n When the task is being planned, the state is set to \'Being planned\'.'
),
'date_start':
fields.datetime('Starting Date', select=True),
}
_defaults = {
'state': 'draft',
}
class sale_order_line_dimension_custom_values(osv.osv):
_name = "sale.order.line.dimension_custom_values"
def _get_to_update_ids(self, cr, uid, ids, context=None):
result = []
for sol in self.pool.get('sale.order.line').browse(cr, uid, ids, context=context):
for d_c_value in sol.dimension_custom_value_ids:
result.append(d_c_value.id)
return result
_columns = {
"dimension_type_id": fields.many2one("product.variant.dimension.type", "Dimension Type"),
"custom_value": fields.char('Custom Value', size=64),
"sale_order_line_id": fields.many2one("sale.order.line", "Sale Order Line"),
"mrp_production_id": fields.related('sale_order_line_id', 'mrp_production_id', type="many2one", relation="mrp.production", string="Production Order",
store={
'sale.order.line': (_get_to_update_ids, None, 10),
}),
}
class jmdstockmove(osv.Model):
_inherit = "stock.move"
def get_cost(self, cr, uid, ids, fieldname, args, context=None):
ret = {}
for i in self.browse(cr, uid, ids, context):
ret[i.id] = 0.0
print(("Multiplicando " + str(i.product_qty) +
" por " + str(i.product_id.cost)))
ret[i.id] = i.product_qty * i.product_id.standard_price
return ret
_columns = {
'unit_price': fields.related("product_id", "standard_price",
type="float", string="Costo Unitario", realtion="product.product",
readonly=True, store=False),
'total_cost': fields.function(get_cost, string="Costo Total",
type="float", store=False)
}
class mrp_production_workcenter_line(osv.osv):
_inherit = 'mrp.production.workcenter.line'
def _get_color_stock(self, cr, uid, ids, field_names, arg, context=None):
res = {}
mvs = []
moves = []
for line in self.browse(cr, uid, ids, context=context):
if line.product:
moves = self.pool.get('stock.move').search(cr, uid, [('product_id','=',line.product.id),('picking_id.type','=','out'),('state','not in',('done','cancel'))])
if moves:
for move in moves:
obj = self.pool.get('stock.move').browse(cr,uid, move)
if obj.date_expected[:10] == time.strftime('%Y-%m-%d'):
mvs.append(obj.id)
if mvs and line.stock < 0:
res[line.id] = 2
elif not mvs and line.stock < 0:
res[line.id] = 3
elif line.stock > 0:
res[line.id] = 4
return res
def _get_date_stop(self, cr, uid, ids, field_names, arg, context=None):
res = {}
for line in self.browse(cr, uid, ids, context=context):
if line.date_expected and line.hour:
start = datetime.strptime(line.date_expected, "%Y-%m-%d %H:%M:%S")
stop = start + timedelta(hours=line.hour)
res[line.id] = stop.strftime("%Y-%m-%d %H:%M:%S")
return res
_columns = {
'operators_ids': fields.many2many('hr.employee', 'hr_employee_mrp_prod_workc_line_rel', 'workcenter_line_id', 'employee_id', string='Operators'),
'production_stops_ids': fields.one2many('production.stops', 'production_workcenter_line_id', 'Production Stops'),
'time_start': fields.float('Time before prod.', help="Time in hours for the setup."),
'time_stop': fields.float('Time after prod.', help="Time in hours for the cleaning."),
'gasoleo_start': fields.float('Gasoleo start'),
'gasoleo_stop': fields.float('Gasoleo stop'),
'color': fields.integer('Color Index'),
'move_id': fields.related('production_id', 'move_prod_id', type='many2one',relation='stock.move', string='Move', readonly=True),
'address': fields.related('move_id', 'address_id', type='many2one', string='address', relation='res.partner.address', readonly=True),
'partnerid': fields.related('address', 'partner_id', type='many2one', string='Parnter', relation='res.partner',readonly=True),
'partner_name': fields.related('partnerid', 'name', type='char', string='Parntername', readonly=True),
'date_expected': fields.related('move_id', 'date_expected', type='datetime', string='date', readonly=True),
'date_stop': fields.function(_get_date_stop, type="datetime", string="Date stop", readonly=True),
'stock': fields.related('product', 'real_virtual_available', type='float', string='Stock', readonly=True),
'color_stock': fields.function(_get_color_stock, type="integer", string="Color stock", readonly=True),
'routing_id': fields.many2one('mrp.routing', 'Routing', readonly=True),
'real_time': fields.float('Real time')
}
class external_shop_group(magerp_osv.magerp_osv):
_inherit = "external.shop.group"
#Return format of API:{'code': 'base', 'name': 'Main', 'website_id': '1', 'is_default': '1', 'sort_order': '0', 'default_group_id': '1'}
# default_group_id is the default shop of the external_shop_group (external_shop_group = website)
def _get_default_shop_id(self, cr, uid, ids, prop, unknow_none, context):
res = {}
for shop_group in self.browse(cr, uid, ids, context):
if shop_group.default_shop_integer_id:
rid = self.pool.get('sale.shop').extid_to_oeid(
cr, uid, shop_group.default_shop_integer_id,
shop_group.referential_id.id)
res[shop_group.id] = rid
else:
res[shop_group.id] = False
return res
_columns = {
'code':
fields.char('Code', size=100),
'is_default':
fields.boolean('Is Default?'),
'sort_order':
fields.integer('Sort Order'),
'default_shop_integer_id':
fields.integer(
'Default Store'
), #This field can't be a many2one because shop_group field will be mapped before creating Shop (Shop = Store, shop_group = website)
'default_shop_id':
fields.function(_get_default_shop_id,
type="many2one",
relation="sale.shop",
method=True,
string="Default Store"),
'referential_type':
fields.related('referential_id',
'type_id',
type='many2one',
relation='external.referential.type',
string='External Referential Type'),
}
class media_service_category(osv.osv):
"""
To manage media service category """
_name = "media.service.category"
_description = 'Media services category'
_columns = {
'name':
fields.char('Name', size=64, required=True),
'company_id':
fields.many2one('res.company', 'Company', required=True,
readonly=True),
'templet_id':
fields.many2one('account.account.template', 'Account Templet'),
'code':
fields.related('templet_id',
'code',
type='char',
relation='account.account.template',
string='Code',
store=True,
readonly=True),
'name_type':
fields.many2one('account.account.type', 'Account Type'),
'analytic_id':
fields.property('account.analytic.account',
type='many2one',
relation='account.analytic.account',
string='Analytic account',
method=True,
view_load=True),
'department_id':
fields.many2one(
'hr.department',
'Department',
),
}
_defaults = {
'company_id':
lambda self, cr, uid, c: self.pool.get('res.company').
_company_default_get(cr, uid, 'media.service.category', context=c),
}
class l10n_es_aeat_mod349_partner_refund_detail(osv.osv):
_name = 'l10n.es.aeat.mod349.partner_refund_detail'
_description = 'AEAT 349 Model - Partner refund detail'
_columns = {
'refund_id':
fields.many2one('l10n.es.aeat.mod349.partner_refund',
'Partner refund ID'),
'invoice_id':
fields.many2one('account.invoice', 'Invoice ID'),
'amount_untaxed':
fields.float('Amount untaxed'),
'date':
fields.related('invoice_id',
'date_invoice',
type="date",
string="Date",
readonly=True)
}
class pact_order_line(osv.osv) :
_name = "pact.order.line"
_columns = {
'name': fields.related('custody_id', 'code', type='char', relation='account.asset.asset', string='Serial Code', store=True , readonly=True),
'pact_order_id' : fields.many2one('asset.pact.order' , 'Pact Order ID' ),
'custody_id' : fields.many2one('account.asset.asset' , 'Custody' ,),
'category_id' : fields.many2one('account.asset.category' , 'Category' ,),
'custody_location_id' :fields.many2one('account.asset.location' , 'Location' ),
'employee_id' : fields.many2one('hr.employee','Responsible',),
'custody_type' : fields.selection([('department','Administrative'),('personal' , 'Personal')], 'Custody Type',),
}
_sql_constraints = [
('serial_code_uniq', 'unique(pact_order_id,custody_id)', 'Serial Code For Item must be unique !'),
]
class sale_order(osv.osv):
_inherit = "sale.order"
_columns = {
'project':
fields.many2one('project.project',
'Project',
readonly=True,
states={'draft': [('readonly', False)]},
help="The project related to a sales order."),
'project_manager':
fields.related('project',
'user_id',
readonly=True,
string='Project Manager',
type='many2one',
relation="res.users",
store=True),
}
class sale_order_line(osv.osv):
_inherit = 'sale.order.line'
_columns = {
'product_id':
fields.many2one('product.product',
'Product',
domain=[('sale_ok', '=', True)],
change_default=True,
required=True),
'product_ref':
fields.related('product_id',
'name',
string='Product',
readonly=True,
type='char',
help='The product part number'),
}
_rec_name = 'product_ref'
class jmdacuerdo(osv.Model):
_name = "ea.acuerdo"
_inherit = "mail.thread"
def get_cantidad(self, cr, uid, ids, fieldname, args, context=None):
ret = {}
for i in self.browse(cr, uid, ids, context):
cantidad = 0
for j in i.linea_ids:
cantidad += j.cantidad
ret[i.id] = cantidad
return ret
_columns = {
'name': fields.char("Acuerdos"),
'partner_id': fields.many2one("res.partner", string="SEA"),
'proyecto_id': fields.many2one("project.project", string="Proyecto"),
'fecha': fields.date("Fecha"),
'parcialidades': fields.integer("Número de Parcialidades"),
'precio_entrevista': fields.float("Precio por Entrevista"),
'linea_ids': fields.one2many("ea.acuerdo.linea", "acuerdo_id", string="Lineas"),
'nombre_corto': fields.related('proyecto_id', 'nombre_corto',
string="Nombre Corto", type="char"),
'cantidad': fields.function(get_cantidad, string="Cantidad", type="integer"),
#contrato
'solicitante': fields.char("Solicitante"),
'prestador': fields.char("Prestador"),
'para': fields.char("Para"),
#Proyecto
'fecha_hora': fields.datetime("Fecha y hora de capacitación"),
'metodologia': fields.text("Metodología"),
'tipo_entrevista': fields.char("Tipo de Entrevista"),
'inicio': fields.date("Fecha de Inicio"),
'termino': fields.char("Fecha de Fin"),
'equipos': fields.integer("Equipos a participar"),
'suervisores': fields.integer("Supervisores"),
'investigadores': fields.integer("Investigadores"),
#Pagos
'parcialidades': fields.integer("Número de Parcialidades"),
'costo': fields.char("Costo por dispositivo móvil/internet"),
}
'project_id': fields.many2one('project.project', 'Intervention', ondelete='set null'),
'equipment_ids':fields.many2many('openstc.equipment', 'openstc_equipment_task_rel', 'task_id', 'equipment_id', 'Equipments'),
'consumable_ids':fields.many2many('openbase.consumable', 'openbase_consumable_task_rel', 'task_id', 'consumable_id', 'Fournitures'),
'parent_id': fields.many2one('project.task', 'Parent Task'),
'intervention_assignement_id':fields.many2one('openstc.intervention.assignement', 'Assignement'),
'absent_type_id':fields.many2one('openstc.absent.type', 'Type d''abscence'),
'category_id':fields.many2one('openstc.task.category', 'Category'),
'state': fields.selection([('absent', 'Absent'),('draft', 'New'),('open', 'In Progress'),('pending', 'Pending'), ('done', 'Done'), ('cancelled', 'Cancelled')], 'State', readonly=True, required=True,
help='If the task is created the state is \'Draft\'.\n If the task is started, the state becomes \'In Progress\'.\n If review is needed the task is in \'Pending\' state.\
\n If the task is over, the states is set to \'Done\'.'),
'team_id': fields.many2one('openstc.team', 'Team'),
'km': fields.integer('Km', select=1),
'oil_qtity': fields.float('oil quantity', select=1),
'oil_price': fields.float('oil price', select=1),
'site1':fields.related('project_id','site1',type='many2one',relation='openstc.site', string='Site',store={'project.task':[lambda self,cr,uid,ids,ctx={}:ids, ['project_id'], 10],
'project.project':[_get_task_from_inter, ['site1'],11]}),
'inter_desc': fields.related('project_id', 'description', type='char'),
'inter_equipment': fields.related('project_id', 'equipment_id', type='many2one',relation='openstc.equipment'),
'cancel_reason': fields.text('Cancel reason'),
'agent_or_team_name':fields.function(_get_agent_or_team_name, type='char', method=True, store=False),
'cost':fields.float('Cost', type='float', digits=(5,2)),
'hr_cost':fields.float('Cost', type='float', digits=(5,2)),
'equipment_cost':fields.float('Cost', type='float', digits=(5,2)),
'consumable_cost':fields.float('Cost', type='float', digits=(5,2)),
}
_defaults = {'active': lambda *a: True, 'user_id':None}
"""
Creates an orphan task : not attached to intervention
from lxml import etree
class res_company(osv.Model):
"""override company to add currency update"""
def button_refresh_currency(self, cr, uid, ids, context=None):
"""Refresh the currency ! For all the company now"""
service_id = None
if 'service_id' not in context:
raise osv.except_osv(_('Warning!'),
_('You must choose bank for currency rate update. Also, that bank must have defined update service.'))
else:
service_id = context['service_id']
currency_updater_obj = self.pool.get('res.currency.rate.update')
try:
currency_updater_obj.run_currency_update(cr, uid, service_id, None, None,
called_from='company', context=context)
except Exception, e:
return False
return True
_inherit = "res.company"
_columns = {
# activate the currency update
'update_service_id': fields.many2one(obj='res.currency.rate.update.service', string='Currency update service'),
'service_currency_to_update': fields.related('update_service_id', 'currency_to_update',
type="many2many", relation='res.currency',
string='currency to update with this service', readonly=True),
}
}
}
def _estado_defecto(self, cr, uid, context=None):
estado = self.pool.get('bag.state').search(cr, uid, [('name', '=', 'Recibido')])
return estado
_name = 'bag.service'
_description = 'Service Order'
_columns = {
'name': fields.char('Numero Orden', size=24),
'type': fields.selection([('particular', 'Particular'), ('airline', 'Aerolinea')], 'Type', required=True),
'date': fields.date('Fecha', required=True),
'date_promised': fields.date('Fecha Prometida', required=True),
'partner_id' : fields.many2one('res.partner', 'Cliente'),
'address_str': fields.related('partner_id', 'street', type='char', size='128'),
'address_num_str': fields.related('partner_id', 'street_num', type='char'),
'piso_dpto_str': fields.related('partner_id', 'piso_dpto', type='char', size='128'),
'phone_str': fields.related('partner_id', 'phone_str', type='char', size='128'),
'zone_str': fields.related('partner_id', 'street', type='char'),
'type_id': fields.many2one('bag.type', 'Tipo'),
'format_id': fields.many2one('bag.format', 'Formato'),
'color_id': fields.many2one('bag.color', 'Color'),
'material_id': fields.many2one('bag.material', 'Material'),
'size_id': fields.many2one('bag.size', 'Tamano'),
'description': fields.char('Descripcion', size=64),
'brand': fields.char('Marca', size=64),
'model': fields.char('Modelo', size=64),
'airline_id': fields.many2one('bag.airline', 'Aerolinea', required=True),
'branch': fields.char('Sucursal', size=32),
'scale_id': fields.many2one('bag.scale', 'Escala'),
'Standard Body (Text)'),
'pem_body_html':fields.text(
'Body (Text-Web Client Only)'),
'pem_attachments_ids':fields.many2many(
'ir.attachment',
'mail_attachments_rel',
'mail_id',
'att_id',
'Attachments'),
'pem_account_id' :fields.many2one(
'poweremail.core_accounts',
'User account',
required=True),
'pem_user':fields.related(
'pem_account_id',
'user',
type="many2one",
relation="res.users",
string="User"),
'server_ref':fields.integer(
'Server Reference of mail',
help="Applicable for inward items only."),
'pem_recd':fields.char('Received at', size=50),
'mail_type':fields.selection([
('multipart/mixed',
'Has Attachments'),
('multipart/alternative',
'Plain Text & HTML with no attachments'),
('multipart/related',
'Intermixed content'),
('text/plain',
'Plain Text'),
_columns = {
"email_from": fields.char("From", size=64),
"email_to": fields.char("Recipient (To)", size=250),
"email_cc": fields.char("CC", size=250),
"email_bcc": fields.char("BCC", size=250),
"reply_to": fields.char("Reply-To", size=250),
"message_id": fields.char("Message-ID", size=250),
"subject": fields.char("Subject", size=200),
"body_text": fields.text("Standard Body (Text)"),
"body_html": fields.text("Body (Rich Text Clients Only)"),
"attachments_ids": fields.many2many(
"ir.attachment", "mail_attachments_rel", "mail_id", "att_id", "Attachments"
),
"account_id": fields.many2one("email_template.account", "User account", required=True),
"user": fields.related("account_id", "user", type="many2one", relation="res.users", string="User"),
"server_ref": fields.integer("Server Reference of mail", help="Applicable for inward items only"),
"mail_type": fields.selection(
[
("multipart/mixed", "Has Attachments"),
("multipart/alternative", "Plain Text & HTML with no attachments"),
("multipart/related", "Intermixed content"),
("text/plain", "Plain Text"),
("text/html", "HTML Body"),
],
"Mail Contents",
),
# I like GMAIL which allows putting same mail in many folders
# Lets plan it for 0.9
"folder": fields.selection(
[("drafts", "Drafts"), ("outbox", "Outbox"), ("trash", "Trash"), ("sent", "Sent Items")],
#along with this program. If not, see <http://www.gnu.org/licenses/>. #
###############################################################################
from osv import osv, fields
FISCAL_POSITION_COLUMNS = {
'cfop_id': fields.many2one('l10n_br_account.cfop', 'CFOP'),
'fiscal_category_id': fields.many2one('l10n_br_account.fiscal.category',
'Categoria Fiscal'),
'type': fields.selection([('input', 'Entrada'), ('output', 'Saida')],
'Tipo'),
'type_tax_use': fields.selection([('sale', 'Sale'),
('purchase', 'Purchase'),
('all', 'All')], 'Tax Application'),
'fiscal_category_fiscal_type': fields.related(
'fiscal_category_id', 'fiscal_type', type='char', readonly=True,
relation='l10n_br_account.fiscal.category', store=True,
string='Fiscal Type'),
'inv_copy_note': fields.boolean('Copiar Observação na Nota Fiscal'),
'asset_operation': fields.boolean('Operação de Aquisição de Ativo',
help="Caso seja marcada essa opção, \
será incluido o IPI na base de \
calculo do ICMS.")}
class account_fiscal_position_template(osv.Model):
_inherit = 'account.fiscal.position.template'
_columns = FISCAL_POSITION_COLUMNS
def onchange_type(self, cr, uid, ids, type=False, context=None):
type_tax = {'input': 'purhcase', 'output': 'sale'}
return {'value': {'type_tax_use': type_tax.get(type, 'all'),
