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)
