class PartyCreditLimitAmount(ModelSQL, CompanyValueMixin): "Party Credit Limit Amount" __name__ = 'party.party.credit_limit_amount' party = fields.Many2One( 'party.party', "Party", ondelete='CASCADE', select=True) credit_limit_amount = fields.Numeric( "Credit Limit Amount", digits=(16, Eval('credit_limit_digits', 2)), depends=['credit_limit_digits']) credit_limit_digits = fields.Function(fields.Integer('Currency Digits'), 'on_change_with_credit_limit_digits') @classmethod def __register__(cls, module_name): TableHandler = backend.get('TableHandler') exist = TableHandler.table_exist(cls._table) super(PartyCreditLimitAmount, cls).__register__(module_name) if not exist: cls._migrate_property([], [], []) @classmethod def _migrate_property(cls, field_names, value_names, fields): field_names.append('credit_limit_amount') value_names.append('credit_limit_amount') fields.append('company') migrate_property( 'party.party', field_names, cls, value_names, parent='party', fields=fields) @fields.depends('company') def on_change_with_credit_limit_digits(self, name=None): if self.company: return self.company.currency.digits
class DocumentPaymentLine(ModelSQL, ModelView): "Documents Payment Line" _name='ekd.document.line.payment' _description=__doc__ doc_payment = fields.Many2One('ekd.document', 'Document Payment', ondelete="CASCADE") doc_base = fields.Many2One('ekd.document.head.request', 'Document Base') amount_payment = fields.Numeric('Amount Payment', digits=(16,2)) line_request = fields.Many2One('ekd.document.line.request', 'Line Request of money') line_ref = fields.Reference(selection='get_line_ref', string='Ref.') type_transaction = fields.Selection([ ('income_cash','Income in Cash'), ('expense_cash','Expense in Cash'), ('return_cash','Return in Cash'), ('income_bank','Income in Bank'), ('expense_bank','Expense in Bank'), ('return_bank','Return in Bank') ], 'Type Transaction') state = fields.Selection([ ('deleted','Deleted'), ('done','Done'), ('payment','Payment'), ('wait_bank','Waiting Confirm Bank') ], 'State') def get_line_ref(self): dictions_obj = self.pool.get('ir.dictions') res = [] diction_ids = dictions_obj.search([ ('model', '=', 'ekd.document.line.payment'), ('pole', '=', 'line_ref'), ]) for diction in dictions_obj.browse(diction_ids): res.append([diction.key, diction.value]) return res
class MagentoTax(ModelSQL, ModelView): "Magento Tax" __name__ = "sale.channel.magento.tax" # TODO: Add Domain channel = fields.Many2One( "sale.channel", "Channel", required=True, select=True ) tax_percent = fields.Numeric( "Tax Percent", digits=(16, 4), required=True, select=True ) taxes = fields.Many2Many( "sale.channel.magento.tax.tax_rel", "channel_tax", "tax", "Taxes" ) @classmethod def __setup__(cls): super(MagentoTax, cls).__setup__() cls._error_messages.update({ 'unique_tax_percent_per_channel': "Tax percent must be unique per channel" }) cls._sql_constraints += [ ('unique_tax_percent', 'UNIQUE(channel, tax_percent)', 'unique_tax_percent_per_channel') ]
class Line: __name__ = 'account.move.line' amount_residual = fields.Function(fields.Numeric('Amount Residual', digits=(16, 2)), 'get_amount_residual') def get_amount_residual(self, name): Invoice = Pool().get('account.invoice') res = Decimal('0.0') if self.reconciliation or \ not self.account.kind in ('payable', 'receivable'): return res move_line_total = self.debit - self.credit invoices = Invoice.search([ ('move', '=', self.move.id), ]) if invoices: invoice = invoices[0] for payment_line in invoice.payment_lines: if payment_line.id == self.id: continue move_line_total += payment_line.debit - payment_line.credit res = move_line_total return res
class Rate(ModelSQL, ModelView): 'Rate' __name__ = 'currency.currency.rate' _rec_name = 'date' date = fields.Date('Date', required=True, select=True) rate = fields.Numeric('Rate', digits=(12, 6), required=1) currency = fields.Many2One('currency.currency', 'Currency', ondelete='CASCADE',) @classmethod def __setup__(cls): super(Rate, cls).__setup__() cls._sql_constraints = [ ('date_currency_uniq', 'UNIQUE(date, currency)', 'A currency can only have one rate by date.'), ('check_currency_rate', 'CHECK(rate >= 0)', 'The currency rate must greater than or equal to 0'), ] cls._order.insert(0, ('date', 'DESC')) @staticmethod def default_date(): Date = Pool().get('ir.date') return Date.today() @classmethod def check_xml_record(self, records, values): return True
class LoginsToApp(ModelSQL, ModelView): #docstring for AssessmentImage 'Registrations to mobile App' # Internal class name. Always used as a reference inside Tryton # default: '<module_name>.<class_name>' on Tryton # becomes '<module_name>_<class_name>' in the database __name__ = 'iversta.logins-to-app' # ———————————————- One2Many Many2One fields —————————————————————————— # ———————————————————— Plain fields ———————————————————————————— login = fields.Char('Login', help='User login') full_name = fields.Char('Full name', help='A full name of a user') token_issued = fields.Char('New token issued', help='A new token issued for a new login') token_used = fields.Char('Token used', help='Current token used to login') user_id = fields.Numeric('Tryton ID in Tryton', help='DB id in Tryton DB') login_result = fields.Selection([('S', 'Sucessful'), ('U', 'Failed')], 'Login Result', help='Result of login attempt') app_ver = fields.Char( 'Mobile App ver', readonly=True, help='Version of mobile app that used for inspection') device_id = fields.Char('Mobile Device id', readonly=True, help='Device that used for inspection') @staticmethod def default_login_result(): return 'U'
class StockShipmentInvoiceReport(ModelSQL, ModelView): """StockShipmentInvoiceReport""" __name__ = "hrp_inventory_report.stock_shipment_invoice_report" number = fields.Function(fields.Char('number', select=True), 'get_data') # 序号 party = fields.Many2One('party.party', 'party', select=True) # 特定供应商 order = fields.Char('order', select=True) # 入库单号 actual_payment = fields.Function( fields.Numeric('actual_payment', digits=(16, 2), readonly=True), 'get_quantity') # 实付金额 invoice_number = fields.Function( fields.Char('invoice_number', select=True), 'get_invoice_number') @staticmethod def table_query(): pass def get_data(self, name): pass def get_quantity(self, name): pass def get_invoice_number(self, name): pass
class Inventory(metaclass=PoolMeta): __name__ = 'stock.inventory' total_cost = fields.Function( fields.Numeric('Total Cost', digits=price_digits), 'get_total_cost') @fields.depends('lines') def on_change_lines(self): self.total_cost = self.get_total_cost() def get_total_cost(self, name=None): result = Decimal('0.0') for line in self.lines: if line.total_cost: result += line.total_cost return result @classmethod def complete_lines(cls, inventories, fill=True): super(Inventory, cls).complete_lines(inventories, fill) cls.set_cost_price(inventories) @classmethod def set_cost_price(cls, inventories): for inventory in inventories: for line in inventory.lines: line.cost_price = line.product.template.cost_price line.save() inventory.save()
class GiftCardPrice(ModelSQL, ModelView): "Gift Card Price" __name__ = 'product.product.gift_card.price' _rec_name = 'price' product = fields.Many2One("product.product", "Product", required=True, select=True) price = fields.Numeric("Price", required=True) @classmethod def __setup__(cls): super(GiftCardPrice, cls).__setup__() cls._error_messages.update( {'negative_amount': 'Price can not be negative'}) @classmethod def validate(cls, prices): """ Validate product price for gift card """ super(GiftCardPrice, cls).validate(prices) for price in prices: price.check_price() def check_price(self): """ Price can not be negative """ if self.price < 0: self.raise_user_error("negative_amount")
class Rate(ModelSQL, ModelView): 'Rate' __name__ = 'currency.currency.rate' date = fields.Date('Date', required=True, select=True, help="From when the rate applies.") rate = fields.Numeric('Rate', digits=(12, 6), required=1, help="The floating exchange rate used to convert the currency.") currency = fields.Many2One('currency.currency', 'Currency', ondelete='CASCADE', help="The currency on which the rate applies.") @classmethod def __setup__(cls): super(Rate, cls).__setup__() t = cls.__table__() cls._sql_constraints = [ ('date_currency_uniq', Unique(t, t.date, t.currency), 'A currency can only have one rate by date.'), ('check_currency_rate', Check(t, t.rate >= 0), 'The currency rate must greater than or equal to 0'), ] cls._order.insert(0, ('date', 'DESC')) @staticmethod def default_date(): Date = Pool().get('ir.date') return Date.today() @classmethod def check_xml_record(cls, records, values): return True def get_rec_name(self, name): return str(self.date)
class AccountDistribution(ModelView, ModelSQL): "Analytic Account Distribution" __name__ = 'analytic_account.account.distribution' parent = fields.Many2One('analytic_account.account', "Parent", required=True, select=True) root = fields.Function(fields.Many2One('analytic_account.account', "Root"), 'on_change_with_root') account = fields.Many2One('analytic_account.account', "Account", required=True, domain=[ ('root', '=', Eval('root', -1)), ], depends=['root']) ratio = fields.Numeric("Ratio", required=True, domain=[ ('ratio', '>=', 0), ('ratio', '<=', 1), ]) @classmethod def __setup__(cls): super(AccountDistribution, cls).__setup__() cls._order.insert(0, ('ratio', 'DESC')) @fields.depends('parent', '_parent_parent.root') def on_change_with_root(self, name=None): if self.parent: return self.parent.root.id
class Exemplary(ModelSQL, ModelView): 'Exemplary' __name__ = 'library.book.exemplary' _rec_name = 'identifier' book = fields.Many2One('library.book', 'Book', ondelete='CASCADE', required=True) identifier = fields.Char('Identifier', required=True) acquisition_date = fields.Date('Acquisition Date') acquisition_price = fields.Numeric('Acquisition Price', digits=(16, 2), domain=[ 'OR', ('acquisition_price', '=', None), ('acquisition_price', '>', 0) ]) @classmethod def __setup__(cls): super().__setup__() t = cls.__table__() cls._sql_constraints += [ ('identifier_uniq', Unique(t, t.identifier), 'The identifier must be unique!'), ] @classmethod def default_acquisition_date(cls): return datetime.date.today() def get_rec_name(self, name): return '%s: %s' % (self.book.rec_name, self.identifier)
class TestPaymentTermViewResult(ModelView): 'Test Payment Term' __name__ = 'account.invoice.payment_term.test.result' date = fields.Date('Date', readonly=True) amount = fields.Numeric('Amount', readonly=True, digits=(16, Eval('currency_digits', 2)), depends=['currency_digits']) currency_digits = fields.Integer('Currency Digits')
class TestBabiModel(ModelSQL, ModelView): 'Test BABI Model' __name__ = 'babi.test' date = fields.Date('Date') category = fields.Char('Category') amount = fields.Numeric('Amount')
class ProductListPrice(ModelSQL, CompanyValueMixin): "Product List Price" __name__ = 'product.list_price' template = fields.Many2One('product.template', "Template", ondelete='CASCADE', select=True) list_price = fields.Numeric("List Price", digits=price_digits) @classmethod def __register__(cls, module_name): TableHandler = backend.get('TableHandler') exist = TableHandler.table_exist(cls._table) super(ProductListPrice, cls).__register__(module_name) if not exist: cls._migrate_property([], [], []) @classmethod def _migrate_property(cls, field_names, value_names, fields): field_names.append('list_price') value_names.append('list_price') fields.append('company') migrate_property('product.template', field_names, cls, value_names, parent='template', fields=fields)
class EmployeeCostPrice(ModelSQL, ModelView): 'Employee Cost Price' __name__ = 'company.employee_cost_price' date = fields.Date('Date', required=True, select=True) cost_price = fields.Numeric('Cost Price', digits=price_digits, required=True, help="Hourly cost price") employee = fields.Many2One('company.employee', 'Employee') @classmethod def __register__(cls, module_name): TableHandler = backend.get('TableHandler') super(EmployeeCostPrice, cls).__register__(module_name) table = TableHandler(cls, module_name) # Migration from 2.8 drop date_cost_price_uniq table.drop_constraint('date_cost_price_uniq') @classmethod def __setup__(cls): super(EmployeeCostPrice, cls).__setup__() t = cls.__table__() cls._sql_constraints = [ ('employee_date_cost_price_uniq', Unique(t, t.employee, t.date, t.cost_price), 'A employee can only have one cost price by date.'), ] cls._order.insert(0, ('date', 'DESC')) @staticmethod def default_cost_price(): return Decimal(0) @staticmethod def default_date(): Date = Pool().get('ir.date') return Date.today() def get_rec_name(self, name): return str(self.date) @classmethod def delete(cls, prices): Employee = Pool().get('company.employee') super(EmployeeCostPrice, cls).delete(prices) Employee._cost_prices_cache.clear() @classmethod def create(cls, vlist): Employee = Pool().get('company.employee') prices = super(EmployeeCostPrice, cls).create(vlist) Employee._cost_prices_cache.clear() return prices @classmethod def write(cls, *args): Employee = Pool().get('company.employee') super(EmployeeCostPrice, cls).write(*args) Employee._cost_prices_cache.clear()
class Party(metaclass=PoolMeta): __name__ = 'party.party' pyafipws_fce = fields.Boolean('MiPyme FCE', states={'readonly': ~Eval('active', True)}, depends=['active']) pyafipws_fce_amount = fields.Numeric( 'MiPyme FCE Amount', digits=(16, Eval('pyafipws_fce_amount_digits', 2)), states={ 'readonly': Or(~Eval('pyafipws_fce', False), ~Eval('active', True)), }, depends=['active', 'pyafipws_fce_amount_digits', 'pyafipws_fce']) pyafipws_fce_amount_digits = fields.Function( fields.Integer('Currency Digits'), 'get_pyafipws_fce_amount_digits') @staticmethod def default_pyafipws_fce_amount(): return Decimal('0') def get_pyafipws_fce_amount_digits(self, name): pool = Pool() Company = pool.get('company.company') company_id = Transaction().context.get('company') if company_id: company = Company(company_id) return company.currency.digits
class TestApply(ModelView): """Test Apply""" __name__ = 'hrp_internal_delivery.test_apply' _rec_name = 'number' product = fields.Many2One("product.product", "Product", required=True) # 产品 product_name = fields.Char('product_name', select=True, readonly=True) # 产品 code = fields.Char('code', select=True, readonly=True) # 编码 drug_specifications = fields.Char('drug_specifications', select=True, readonly=True) # 规格 company = fields.Many2One('product.uom', 'company', select=True, readonly=True) # 单位 odd_numbers = fields.Char('odd_numbers', select=True, readonly=True) # 建议请领数量 a_charge = fields.Char('a_charge', select=True, readonly=True) # 件装量 stock_level = fields.Char('stock_level', select=True, readonly=True) # 现有库存量 outpatient_7days = fields.Char('Outpatient_7days', select=True, readonly=True) # 7日量 proposal = fields.Float('proposal', select=True, states=STATES , depends=['is_direct_sending']) # 请领数量 is_direct_sending = fields.Boolean('Is_direct_sending', select=True, readonly=True) # 是否直送 is_collar = fields.Boolean('is_collar', select=True) # 是否请领 party = fields.Many2One('party.party', 'Party', select=True) # 供应商 unit_price = fields.Numeric('unit_price', digits=(16, 4)) # 价格 parent = fields.Many2One('hrp_internal_delivery.internal_apply', 'parent', select=True) @staticmethod def default_is_collar(): return False
class Deduccion(ModelSQL, ModelView): 'Deduccion' __name__ = 'rrhh.pa.208.deduccion' name = fields.Char('Nombre', required=True) description = fields.Text('Descripcion') tipo = fields.Selection([ ('porcentaje', 'Porcentaje'), ('fijo', 'Monto Fijo'), ], 'Tipo', required=True) valor = fields.Numeric('Valor', required=True, digits=(16, Eval('valor_digits', 4)), depends=['valor_digits']) valor_digits = fields.Function(fields.Integer('Valor Digits'), 'get_valor_digits') orden = fields.Integer('Orden') ley = fields.Boolean('De Ley') active = fields.Boolean('Active') @staticmethod def default_active(): return True @staticmethod def default_valor_digits(): return 4 def get_valor_digits(self, name=None): return 4
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 SurgerySupply(ModelSQL, ModelView): 'Supplies related to the surgery' __name__ = 'gnuhealth.surgery_supply' name = fields.Many2One('gnuhealth.surgery', 'Surgery') qty = fields.Numeric('Qty', required=True, help="Initial required quantity") supply = fields.Many2One('product.product', 'Supply', required=True, domain=[('is_medical_supply', '=', True)], help="Supply to be used in this surgery") notes = fields.Char('Notes') qty_used = fields.Numeric('Used', required=True, help="Actual amount used")
class ExportData(ModelSQL): "Export Data" __name__ = 'test.export_data' boolean = fields.Boolean('Boolean') integer = fields.Integer('Integer') float = fields.Float('Float') numeric = fields.Numeric('Numeric') char = fields.Char('Char') text = fields.Text('Text') date = fields.Date('Date') datetime = fields.DateTime('DateTime') timedelta = fields.TimeDelta('TimeDelta') selection = fields.Selection([ (None, ''), ('select1', 'Select 1'), ('select2', 'Select 2'), ], 'Selection') many2one = fields.Many2One('test.export_data.target', 'Many2One') many2many = fields.Many2Many('test.export_data.relation', 'many2many', 'target', 'Many2Many') one2many = fields.One2Many('test.export_data.target', 'one2many', 'One2Many') reference = fields.Reference('Reference', [ (None, ''), ('test.export_data.target', 'Target'), ])
class ProductCostHistory(ModelSQL, ModelView): 'History of Product Cost' __name__ = 'product.product.cost_history' product = fields.Many2One('product.product', "Product") date = fields.DateTime('Date') cost_price = fields.Numeric('Cost Price') @classmethod def __setup__(cls): super(ProductCostHistory, cls).__setup__() cls._order.insert(0, ('date', 'DESC')) @classmethod def table_query(cls): pool = Pool() ProductCostPrice = pool.get('product.cost_price') history = ProductCostPrice.__table_history__() return history.select(Max(Column(history, '__id')).as_('id'), Max(history.create_uid).as_('create_uid'), Max(history.create_date).as_('create_date'), Max(history.write_uid).as_('write_uid'), Max(history.write_date).as_('write_date'), Coalesce(history.write_date, history.create_date).as_('date'), history.product.as_('product'), history.cost_price.as_('cost_price'), group_by=(history.id, Coalesce(history.write_date, history.create_date), history.product, history.cost_price)) def get_rec_name(self, name): return str(self.date)
class Vehiculo(ModelView, ModelSQL): 'Vehiculo' __name__ = 'oci.vehiculo' _order = 'name' active = fields.Boolean('Active') name = fields.Char('Pantente', required=True) km = fields.Integer('Kilometros') monto = fields.Function(fields.Numeric('Monto Total'), 'get_monto') monto_mensual = fields.Function(fields.Numeric('Monto Mensual'), 'get_monto_mensual') modelo = fields.Char('Modelo', required=True) marca = fields.Char('Marca', required=True) bonos = fields.One2Many('oci.bono', 'name', 'Bonos', readonly=True) def get_monto(self, name): monto = 0 for bono in self.bonos: monto += bono.monto return monto def get_monto_mensual(self, name): monto = 0 Date = Pool().get('ir.date') today = Date.today() today2 = today.replace(day=1) bonos = Bono.search([('fecha', '>', today2)]) for bono in bonos: monto = bono.monto return monto def get_combustible(self, fecha1, fecha2): bonos = Bono.search([('fecha', '>=', fecha1), ('fecha', '<=', fecha2), ('name', '=', self.id)]) return bonos def get_monto_entre_fechas(self, fecha1, fecha2): bonos = Bono.search([('fecha', '>=', fecha1), ('fecha', '<=', fecha2), ('name', '=', self.id)]) monto = 0 for bono in bonos: monto += bono.monto return monto @staticmethod def default_active(): return True
class RrhhCv(ModelSQL, ModelView): 'Curriculum Vitae' __name__ = 'rrhh.cv' estado_cv = fields.Selection([ ('CITADO', 'Citado'), ('ANULADO', 'Anulado'), ('PENDIENTE', 'Pendiente'), (None, ''), ], 'Estado CV', sort=False, required=True) nombre = fields.Char('Apellido y Nombre',40) photo1 = fields.Binary('Foto', states = STATES) fecha_presen = fields.Date('Fecha de Presentacion') fecha_nac = fields.Date('Fecha Nac.') cuil = fields.Char('Cuil',13) telefono = fields.Char('Telefono',30) celular = fields.Char('Celular',20) direccion = fields.Char('Calle',20) altura = fields.Char('Altura',10) piso = fields.Char('Piso',5) dto = fields.Char('Dto.',5) entrecalle = fields.Char('Entre Calle',20) localidad = fields.Char('Localidad',20) ccosto = fields.Many2One('gnuhealth.hospital.building', 'Edificio') categoria = fields.Many2One('rrhh.categoria', 'Categoria') convenio = fields.Selection([ ('SI', 'Si'), ('NO', 'No'), ], 'Convenio', sort=False, required=True) sueldo = fields.Numeric('Sueldo', digits=(10,2)) tliqui = fields.Selection([ ('M', 'Mensual'), ('Q', 'Quincena'), ], 'Tipo Liquidacion', sort=False, required=True) tip_tur = fields.Selection([ ('Dia' ,'Dia'),('Tarde', 'Tarde'),('Noche', 'Noche'),('Mixto', 'Mixto')], 'Turno', sort=False, required=False) entrada = fields.Time('Hor.Entrada') salida = fields.Time('Hor.Salida') observaciones = fields.Text('Observaciones') evaluacion = fields.Text('Evaluacion') otros = fields.Text('Otros') cv_photo1 = fields.Binary('Imagen1', states = STATES) cv_photo2 = fields.Binary('Imagen2', states = STATES) cv_photo3 = fields.Binary('Imagen3', states = STATES) email = fields.Char('E-Mail',40) #~ --------------- Calculo de edad del empleado ---------------- edad_emple = fields.Function(fields.Char('Edad de Postulante',7, on_change_with=['date_nac']),"on_change_with_date_agecv") def on_change_with_date_agecv(self,name=None): import datetime fecha_1=datetime.date.today().year fecha_2= self.date_nac.year diff = fecha_1 - fecha_2 years = str(diff) return years + ' años'
class Origin(origin_mixin(_states, _depends), ModelSQL, ModelView): "Account Statement Origin" __name__ = 'account.statement.origin' _rec_name = 'number' lines = fields.One2Many( 'account.statement.line', 'origin', "Lines", states={ 'readonly': ((Eval('statement_id', -1) < 0) | ~Eval('statement_state').in_(['draft', 'validated'])), }, domain=[ ('statement', '=', Eval('statement')), ('date', '=', Eval('date')), ], depends=['statement', 'date', 'statement_id']) statement_id = fields.Function(fields.Integer("Statement ID"), 'on_change_with_statement_id') pending_amount = fields.Function(fields.Numeric( "Pending Amount", digits=(16, Eval('_parent_statement', {}).get('currency_digits', 2))), 'on_change_with_pending_amount', searcher='search_pending_amount') informations = fields.Dict('account.statement.origin.information', "Informations", readonly=True) @fields.depends('statement') def on_change_with_statement_id(self, name=None): if self.statement: return self.statement.id return -1 @fields.depends('lines', 'amount') def on_change_with_pending_amount(self, name=None): lines_amount = sum( getattr(l, 'amount') or Decimal(0) for l in self.lines) return (self.amount or Decimal(0)) - lines_amount @classmethod def search_pending_amount(cls, name, clause): pool = Pool() Line = pool.get('account.statement.line') table = cls.__table__() line = Line.__table__() _, operator, value = clause Operator = fields.SQL_OPERATORS[operator] query = (table.join( line, 'LEFT', condition=line.origin == table.id).select( table.id, having=Operator(table.amount - Coalesce(Sum(line.amount), 0), value), group_by=table.id)) return [('id', 'in', query)]
class ExpenseMoveReference(ModelView, ModelSQL): 'Expense Move Reference' __name__ = 'account.iesa.expense.move.line' expense = fields.Many2One('account.iesa.expense', 'Expense') party = fields.Many2One('party.party', 'Party') description = fields.Char('Description') amount = fields.Numeric('Amount')
class Configuration: __name__ = 'production.configuration' supply_period = fields.Property(fields.Numeric('Supply Period', digits=(16, 0), help='In number of days', required=True)) @staticmethod def default_supply_period(): return Decimal(0)
class Employee(metaclass=PoolMeta): __name__ = 'company.employee' cost_price = fields.Function( fields.Numeric('Cost Price', digits=price_digits, help="Hourly cost price for this Employee."), 'get_cost_price') cost_prices = fields.One2Many('company.employee_cost_price', 'employee', 'Cost Prices', help="List of hourly cost price over time.") _cost_prices_cache = Cache('company_employee.cost_prices') def get_cost_price(self, name): ''' Return the cost price at the date given in the context or the current date ''' ctx_date = Transaction().context.get('date', None) return self.compute_cost_price(ctx_date) def get_employee_costs(self): "Return a sorted list by date of start date and cost_price" pool = Pool() CostPrice = pool.get('company.employee_cost_price') # Get from cache employee costs or fetch them from the db employee_costs = self._cost_prices_cache.get(self.id) if employee_costs is None: cost_prices = CostPrice.search([ ('employee', '=', self.id), ], order=[('date', 'ASC')]) employee_costs = [] for cost_price in cost_prices: employee_costs.append((cost_price.date, cost_price.cost_price)) self._cost_prices_cache.set(self.id, employee_costs) return employee_costs def compute_cost_price(self, date=None): "Return the cost price at the given date" pool = Pool() Date = pool.get('ir.date') employee_costs = self.get_employee_costs() if date is None: with Transaction().set_context(company=self.company.id): date = Date.today() # compute the cost price for the given date cost = 0 if employee_costs and date >= employee_costs[0][0]: for edate, ecost in employee_costs: if date >= edate: cost = ecost else: break return cost
class Type(ModelSQL, ModelView): 'Account Type' __name__ = 'account.account.type' level = fields.Function(fields.Numeric('Level',digits=(2,0)), '_get_level') custom_amount = fields.Function(fields.Numeric('Custom Amount', digits=(2,0)), '_get_custom_amount') type_display_balance = fields.Selection([('debit','Debit'), ('credit','Credit')], 'Type') def _get_level(self, parent=None): level = 0 if self.parent: level = self.parent.level + 1 return level def _get_childs_by_order(self, res=None): '''Returns the records of all the children computed recursively, and sorted by sequence. Ready for the printing''' Account = Pool().get('account.account.type') if res is None: res = [] childs = Account.search([('parent', '=', self.id)], order=[('sequence','ASC')]) if len(childs)>=1: for child in childs: res.append(Account(child.id)) child._get_childs_by_order(res=res) return res def _get_custom_amount(self, name): amount = 0 if self.type_display_balance == 'credit': amount = - self.amount else: amount = self.amount return amount @staticmethod def default_type_display_balance(): return 'debit'