mirror of
https://github.com/Kalenis/kalenislims.git
synced 2023-12-14 07:13:04 +01:00
163 lines
5.6 KiB
Python
163 lines
5.6 KiB
Python
# -*- coding: utf-8 -*-
|
|
# This file is part of lims module for Tryton.
|
|
# The COPYRIGHT file at the top level of this repository contains
|
|
# the full copyright notices and license terms.
|
|
|
|
from trytond.model import fields, ModelSQL
|
|
from trytond.pyson import In, Eval, Bool, If
|
|
from trytond.pool import Pool, PoolMeta
|
|
from trytond.transaction import Transaction
|
|
|
|
|
|
class Location(metaclass=PoolMeta):
|
|
__name__ = 'stock.location'
|
|
|
|
storage_time = fields.Integer('Storage time (in months)')
|
|
internal_shipment_to_location_restrictions =\
|
|
fields.Many2Many('stock.location-stock.location',
|
|
'from_location','to_location',
|
|
'Internal Shipment To Location Restrictions')
|
|
|
|
@classmethod
|
|
def search_rec_name(cls, name, clause):
|
|
field = None
|
|
for field in ('code', 'name'):
|
|
records = cls.search([(field,) + tuple(clause[1:])], limit=1)
|
|
if records:
|
|
break
|
|
if records:
|
|
return [(field,) + tuple(clause[1:])]
|
|
return [(cls._rec_name,) + tuple(clause[1:])]
|
|
|
|
|
|
class Move(metaclass=PoolMeta):
|
|
__name__ = 'stock.move'
|
|
|
|
fraction = fields.Many2One('lims.fraction', 'Fraction', select=True,
|
|
ondelete='CASCADE', states={
|
|
'readonly': (In(Eval('state'), ['cancel', 'assigned', 'done']) |
|
|
Bool(Eval('fraction_readonly')))},
|
|
domain=[
|
|
If(~Eval('fraction'),
|
|
('current_location', '=', Eval('from_location')),
|
|
('id', '=', Eval('fraction'))),
|
|
],
|
|
depends=['state', 'fraction_readonly', 'from_location'])
|
|
fraction_readonly = fields.Function(fields.Boolean('Fraction Read Only'),
|
|
'on_change_with_fraction_readonly')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super().__setup__()
|
|
cls.origin.readonly = True
|
|
|
|
@classmethod
|
|
def _get_origin(cls):
|
|
models = super()._get_origin()
|
|
models.append('lims.fraction')
|
|
return models
|
|
|
|
@fields.depends('from_location', 'to_location', 'product')
|
|
def on_change_with_fraction_readonly(self, name=None):
|
|
Config = Pool().get('lims.configuration')
|
|
|
|
config = Config(1)
|
|
if not config.fraction_product:
|
|
return True
|
|
if not self.product or self.product != config.fraction_product:
|
|
return True
|
|
if (self.from_location and self.to_location and
|
|
self.from_location.type == 'storage' and
|
|
self.to_location.type == 'storage'):
|
|
return False
|
|
return True
|
|
|
|
@classmethod
|
|
def copy(cls, moves, default=None):
|
|
with Transaction().set_context(check_current_location=False):
|
|
return super().copy(moves, default=default)
|
|
|
|
|
|
class ShipmentInternal(metaclass=PoolMeta):
|
|
__name__ = 'stock.shipment.internal'
|
|
|
|
to_location_domain = fields.Function(fields.Many2Many(
|
|
'stock.location',None, None,
|
|
'Internal Shipment To Location Restrictions Domain'), 'on_change_with_to_location_domain')
|
|
|
|
@fields.depends('from_location')
|
|
def on_change_with_to_location_domain(self, name=None):
|
|
if self.from_location and self.from_location.internal_shipment_to_location_restrictions:
|
|
return [x.id for x in self.from_location.internal_shipment_to_location_restrictions]
|
|
return []
|
|
|
|
@classmethod
|
|
def copy(cls, shipments, default=None):
|
|
with Transaction().set_context(check_current_location=False):
|
|
return super().copy(shipments, default=default)
|
|
|
|
@classmethod
|
|
def _sync_moves(cls, shipments):
|
|
with Transaction().set_context(check_current_location=False):
|
|
super()._sync_moves(shipments)
|
|
|
|
@classmethod
|
|
def _set_transit(cls, shipments):
|
|
with Transaction().set_context(check_current_location=False):
|
|
super()._set_transit(shipments)
|
|
|
|
@classmethod
|
|
def draft(cls, shipments):
|
|
with Transaction().set_context(check_current_location=False):
|
|
super().draft(shipments)
|
|
|
|
@classmethod
|
|
def wait(cls, shipments):
|
|
with Transaction().set_context(check_current_location=False):
|
|
super().wait(shipments)
|
|
|
|
@classmethod
|
|
def ship(cls, shipments):
|
|
with Transaction().set_context(check_current_location=False):
|
|
super().ship(shipments)
|
|
|
|
@classmethod
|
|
def done(cls, shipments):
|
|
with Transaction().set_context(check_current_location=False):
|
|
super().done(shipments)
|
|
|
|
@classmethod
|
|
def cancel(cls, shipments):
|
|
with Transaction().set_context(check_current_location=False):
|
|
super().cancel(shipments)
|
|
|
|
@classmethod
|
|
def assign_try(cls, shipments):
|
|
with Transaction().set_context(check_current_location=False):
|
|
return super().assign_try(shipments)
|
|
|
|
@classmethod
|
|
def assign_force(cls, shipments):
|
|
with Transaction().set_context(check_current_location=False):
|
|
super().assign_force(shipments)
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super().__setup__()
|
|
cls.to_location.domain = [
|
|
[('type', 'in', ['view', 'storage', 'lost_found'])],
|
|
[If(Eval('to_location_domain'),
|
|
('id','in',Eval('to_location_domain')),
|
|
('id','>',0))]]
|
|
|
|
|
|
class LocationShipmentInternalRestrictionLocation(ModelSQL):
|
|
'Location restriction'
|
|
__name__ = 'stock.location-stock.location'
|
|
|
|
from_location =\
|
|
fields.Many2One('stock.location', 'Input location',
|
|
required=True, ondelete='CASCADE')
|
|
to_location =\
|
|
fields.Many2One('stock.location', 'Output location',
|
|
required=True, ondelete='CASCADE')
|