def decorator(cls, *args): pool = Pool() Template = pool.get('product.template') transaction = Transaction() if (transaction.user != 0 and transaction.context.get('_check_access')): actions = iter(args) for records, values in zip(actions, actions): for field, msg in Template._modify_no_move: if field in values: if find_moves(cls, records): raise AccessError(gettext(msg)) # No moves for those records break if not values.get('template'): continue template = Template(values['template']) for record in records: for field, msg in Template._modify_no_move: if isinstance(getattr(Template, field), fields.Function): continue if getattr(record, field) != getattr(template, field): if find_moves(cls, [record]): raise AccessError(gettext(msg)) # No moves for this record break func(cls, *args)
def delete(cls, payments): for payment in payments: if payment.state != 'draft': raise AccessError( gettext('account_payment.msg_payment_delete_draft', payment=payment.rec_name)) super(Payment, cls).delete(payments)
def delete(cls, records): for record in records: if record.number: raise AccessError( gettext('account_fr_chorus.msg_invoice_delete_sent', invoice=record.invoice.rec_name)) super(InvoiceChorus, cls).delete(records)
def create(cls, vlist): for vals in vlist: for field_name in ('quantity', 'company'): if vals.get(field_name) is None: raise AccessError( gettext('purchase_request.msg_request_no_create')) return super(PurchaseRequest, cls).create(vlist)
def delete(cls, works): for work in works: if work.state not in {'request', 'draft'}: raise AccessError( gettext('production_work.msg_delete_request', work=work.rec_name)) super(Work, cls).delete(works)
def delete(cls, complaints): for complaint in complaints: if complaint.state != 'draft': raise AccessError( gettext('sale_complaint.msg_complaint_delete_draft', complaint=complaint.rec_name)) super(Complaint, cls).delete(complaints)
def delete(cls, actions): for action in actions: if action.result: raise AccessError( gettext('sale_complaint.msg_action_delete_result', action=action.rec_name)) super(Action, cls).delete(actions)
def write(cls, *args): if Transaction().user == 0: super(Uom, cls).write(*args) return actions = iter(args) all_uoms = [] for uoms, values in zip(actions, actions): if 'rate' not in values and 'factor' not in values \ and 'category' not in values: continue all_uoms += uoms old_uom = dict( (uom.id, (uom.factor, uom.rate, uom.category)) for uom in all_uoms) super(Uom, cls).write(*args) for uom in all_uoms: for i, field in ['factor', 'rate', 'category']: if getattr(uom, field) != old_uom[uom.id][i]: raise AccessError( gettext('product.msg_uom_modify_%s' % field, uom=uom.rec_name), gettext('product.msg_uom_modify_options'))
def delete(cls, assets): for asset in assets: if asset.state != 'draft': raise AccessError( gettext('account_asset.msg_delete_draft', asset=asset.rec_name)) return super(Asset, cls).delete(assets)
def delete(cls, requests): for request in requests: if request.purchase_line: raise AccessError( gettext('purchase_request.msg_request_delete_purchased', request=request.rec_name)) super(PurchaseRequest, cls).delete(requests)
def check_sled_period_closed(cls, lots): Period = Pool().get('stock.period') Move = Pool().get('stock.move') periods = Period.search([ ('state', '=', 'closed'), ], order=[('date', 'DESC')], limit=1) if not periods: return period, = periods for lots in grouped_slice(lots): lot_ids = [l.id for l in lots] moves = Move.search([('lot', 'in', lot_ids), [ 'OR', [ ('effective_date', '=', None), ('planned_date', '<=', period.date), ], ('effective_date', '<=', period.date), ]], limit=1) if moves: move, = moves raise AccessError( gettext( 'stock_lot_sled' '.msg_lot_modify_expiration_date_period_close', lot=move.lot.rec_name, move=move.rec_name))
def draft(cls, invoices): for invoice in invoices: if invoice.sales and invoice.state == 'cancel': raise AccessError( gettext('sale.msg_sale_invoice_reset_draft', invoice=invoice.rec_name)) return super(Invoice, cls).draft(invoices)
def write(cls, *args): actions = iter(args) for lines, values in zip(actions, actions): if (('duration' in values or 'work' in values) and any(l.invoice_line for l in lines)): raise AccessError( gettext('project_invoice.msg_modify_invoiced_line')) super(TimesheetLine, cls).write(*args)
def delete(cls, lines): for line in lines: if line.inventory_state not in {'cancelled', 'draft'}: raise AccessError( gettext('stock.msg_inventory_line_delete_cancel', line=line.rec_name, inventory=line.inventory.rec_name)) super(InventoryLine, cls).delete(lines)
def delete(cls, statements): # Cancel before delete cls.cancel(statements) for statement in statements: if statement.state != 'cancel': raise AccessError( gettext('account_statement.msg_statement_delete_cancel', statement=statement.rec_name)) super(Statement, cls).delete(statements)
def delete(cls, consumptions): for consumption in consumptions: if consumption.invoice_line: raise AccessError( gettext( 'sale_subscription' '.msg_consumption_modify_invoiced', consumption=consumption.rec_name)) super(LineConsumption, cls).delete(consumptions)
def delete(cls, mandates): for mandate in mandates: if mandate.state not in ('draft', 'canceled'): raise AccessError( gettext( 'account_payment_sepa' '.msg_mandate_delete_draft_canceled', mandate=mandate.rec_name)) super(Mandate, cls).delete(mandates)
def _check(cls, periods): Move = Pool().get('account.move') moves = Move.search([ ('period', 'in', [p.id for p in periods]), ], limit=1) if moves: raise AccessError( gettext('account.msg_modify_delete_period_moves', period=moves[0].period.rec_name))
def delete(cls, opportunities): # Cancel before delete cls.cancel(opportunities) for opportunity in opportunities: if opportunity.state != 'cancelled': raise AccessError( gettext('sale_opportunity.msg_opportunity_delete_cancel', opportunity=opportunity.rec_name)) super(SaleOpportunity, cls).delete(opportunities)
def delete(cls, requisitions): # Cancel before delete cls.cancel(requisitions) for requisition in requisitions: if requisition.state != 'cancelled': raise AccessError( gettext('purchase_requisition.msg_delete_cancel', requisition=requisition.rec_name)) super(PurchaseRequisition, cls).delete(requisitions)
def delete(cls, forecasts): # Cancel before delete cls.cancel(forecasts) for forecast in forecasts: if forecast.state != 'cancel': raise AccessError( gettext('stock_forecast.msg_forecast_delete_cancel', forecast=forecast.rec_name)) super(Forecast, cls).delete(forecasts)
def delete(cls, inventories): # Cancel before delete cls.cancel(inventories) for inventory in inventories: if inventory.state != 'cancelled': raise AccessError( gettext('stock.msg_inventory_delete_cancel', inventory=inventory.rec_name)) super(Inventory, cls).delete(inventories)
def delete(cls, records): for module in records: if module.state in ( 'activated', 'to upgrade', 'to remove', 'to activate', ): raise AccessError(gettext('ir.msg_module_delete_state')) return super(Module, cls).delete(records)
def write(cls, *args): actions = iter(args) for addresses, values in zip(actions, actions): if 'party' in values: for address in addresses: if address.party.id != values['party']: raise AccessError( gettext('party.msg_address_change_party', address=address.rec_name)) super(Address, cls).write(*args)
def write(cls, *args): for consumptions in args[::2]: for consumption in consumptions: if consumption.invoice_line: raise AccessError( gettext( 'sale_subscription' '.msg_consumption_modify_invoiced', consumption=consumption.rec_name)) super(LineConsumption, cls).write(*args)
def delete(cls, moves): fifo_moves = cls.search([ ('id', 'in', [m.id for m in moves]), ('fifo_quantity', '!=', 0.0), ]) if fifo_moves: raise AccessError( gettext('product_cost_fifo.msg_move_delete_fifo', move=fifo_moves[0].rec_name)) super(Move, cls).delete(moves)
def check_access(cls): pool = Pool() ModelAccess = pool.get('ir.model.access') ActionWizard = pool.get('ir.action.wizard') User = pool.get('res.user') context = Transaction().context if Transaction().user == 0: return with Transaction().set_context(_check_access=True): model = context.get('active_model') if model: Model = pool.get(model) if model and model != 'ir.ui.menu': ModelAccess.check(model, 'read') models = ActionWizard.get_models( cls.__name__, action_id=context.get('action_id')) if model and models and model not in models: raise AccessError( gettext('ir.msg_access_wizard_model_error', wizard=cls.__name__, model=model)) groups = set(User.get_groups()) wizard_groups = ActionWizard.get_groups( cls.__name__, action_id=context.get('action_id')) if wizard_groups: if not groups & wizard_groups: raise AccessError( gettext('ir.msg_access_wizard_error', name=cls.__name__)) elif model and model != 'ir.ui.menu': if (not callable(getattr(Model, 'table_query', None)) or Model.write.__func__ != ModelSQL.write.__func__): ModelAccess.check(model, 'write') if model: ids = context.get('active_ids') or [] id_ = context.get('active_id') if id_ not in ids: ids.append(id_) # Check read access Model.read(ids, ['id'])
def draft(cls, shipments): PurchaseLine = Pool().get('purchase.line') for shipment in shipments: for move in shipment.moves: if (move.state == 'cancel' and isinstance(move.origin, PurchaseLine)): raise AccessError( gettext('purchase.msg_purchase_move_reset_draft', move=move.rec_name)) return super(ShipmentInReturn, cls).draft(shipments)
def create(cls, vlist): Period = Pool().get('account.period') for vals in vlist: if vals.get('period'): period = Period(vals['period']) if period.state != 'open': raise AccessError( gettext('account' '.msg_create_journal_period_closed_period', period=period.rec_name)) return super(JournalPeriod, cls).create(vlist)
def draft(cls, shipments): SaleLine = Pool().get('sale.line') for shipment in shipments: for move in shipment.incoming_moves: if (move.state == 'cancel' and isinstance(move.origin, SaleLine)): raise AccessError( gettext('sale.msg_sale_move_reset_draft', move=move.rec_name)) return super(ShipmentOutReturn, cls).draft(shipments)