コード例 #1
0
class StaffList(ModelSQL, ModelView):
    'Staff list'
    _name = 'ekd.company.staff_list'
    _description = __doc__

    company = fields.Many2One('company.company', 'Company', required=True)
    staff = fields.Many2One('ekd.company.staff', 'Staff list')
    department = fields.Many2One('ekd.company.department', 'Department')
    name = fields.Char('Name', size=None, required=True)
    job_function = fields.Many2One('ekd.company.job_function', 'Job function')
    category = fields.Many2One('ekd.company.employee.category', 'Category')
    start_date = fields.Date('Start Date')
    end_date = fields.Date('End Date')
    regular = fields.Boolean('Regular appointment')
    free_rate = fields.Function(fields.Float('Free of bets', digits=(3, 3)),
                                'get_free_rate')
    #schedule = fields.Many2One('ekd.timesheet.schedule', 'Schedule')
    payroll = fields.Selection([('hourly', 'Hourly rates'),
                                ('dayly', 'Daily rate'),
                                ('monthly', 'Monthly salary')],
                               'Accounting payroll')
    rate_payroll = fields.Function(
        fields.Numeric('Rate payroll', digits=(16, 2)), 'get_rate_payroll')
    time_management = fields.Selection([('in_day', 'In Day'),
                                        ('in_hour', 'In Hour')],
                                       'Time management')
    work_rate = fields.Float('Number of bets', digits=(3, 3))
    personal = fields.One2Many('ekd.company.employee.account', 'staff_list',
                               'Employee')
    payroll = fields.One2Many('ekd.company.staff_list.payroll', 'staff_list',
                              'Payroll')
    active = fields.Boolean('Active')
    note = fields.Text('Note')
    state = fields.Selection([
        ('draft', 'Draft'),
        ('active', 'Active'),
        ('archive', 'Archive'),
    ],
                             'State',
                             readonly=True,
                             required=True,
                             select=1)

    #def __init__(self):
    #    super(StaffList, self).__init__()

    def default_company(self):
        return Transaction().context.get('company') or False

    def get_free_rate(self, ids, name):
        res = {}.fromkeys(ids, 0.0)
        for line in self.browse(ids):
            res[line.id] = line.work_rate
            for employee in line.personal:
                res[line.id] -= employee.work_rate

    def get_rate_payroll(self, ids, name):
        res = {}.fromkeys(ids, Decimal('0.0'))
        for line in self.browse(ids):
            for rate_payroll in line.payroll:
                res[line.id] += rate_payroll.rate
コード例 #2
0
ファイル: test.py プロジェクト: vitalliykashuta/trytond
class Date(ModelSQL):
    'Date'
    __name__ = 'test.date'
    date = fields.Date(string='Date', help='Test date', required=False)
コード例 #3
0
class Work(sequence_ordered(), tree(separator='\\'), ModelSQL, ModelView):
    'Work Effort'
    __name__ = 'project.work'
    name = fields.Char('Name', required=True, select=True)
    type = fields.Selection([('project', 'Project'), ('task', 'Task')],
                            'Type',
                            required=True,
                            select=True)
    company = fields.Many2One('company.company',
                              'Company',
                              required=True,
                              select=True)
    party = fields.Many2One('party.party',
                            'Party',
                            states={
                                'invisible': Eval('type') != 'project',
                            },
                            depends=['type'])
    party_address = fields.Many2One('party.address',
                                    'Contact Address',
                                    domain=[('party', '=', Eval('party'))],
                                    states={
                                        'invisible': Eval('type') != 'project',
                                    },
                                    depends=['party', 'type'])
    timesheet_works = fields.One2Many('timesheet.work',
                                      'origin',
                                      'Timesheet Works',
                                      readonly=True,
                                      size=1)
    timesheet_available = fields.Function(
        fields.Boolean('Available on timesheets'),
        'get_timesheet_available',
        setter='set_timesheet_available')
    timesheet_start_date = fields.Function(fields.Date(
        'Timesheet Start',
        states={
            'invisible': ~Eval('timesheet_available'),
        },
        depends=['timesheet_available']),
                                           'get_timesheet_date',
                                           setter='set_timesheet_date')
    timesheet_end_date = fields.Function(fields.Date(
        'Timesheet End',
        states={
            'invisible': ~Eval('timesheet_available'),
        },
        depends=['timesheet_available']),
                                         'get_timesheet_date',
                                         setter='set_timesheet_date')
    timesheet_duration = fields.Function(
        fields.TimeDelta(
            'Duration',
            'company_work_time',
            help="Total time spent on this work and the sub-works."),
        'get_total')
    effort_duration = fields.TimeDelta('Effort',
                                       'company_work_time',
                                       help="Estimated Effort for this work.")
    total_effort = fields.Function(
        fields.TimeDelta(
            'Total Effort',
            'company_work_time',
            help="Estimated total effort for this work and the sub-works."),
        'get_total')
    progress = fields.Float('Progress',
                            domain=[
                                'OR',
                                ('progress', '=', None),
                                [
                                    ('progress', '>=', 0),
                                    ('progress', '<=', 1),
                                ],
                            ],
                            help='Estimated progress for this work.')
    total_progress = fields.Function(
        fields.Float(
            'Total Progress',
            digits=(16, 4),
            help='Estimated total progress for this work and the sub-works.',
            states={
                'invisible': Eval('total_progress', None) == None,
            }), 'get_total')
    comment = fields.Text('Comment')
    parent = fields.Many2One('project.work',
                             'Parent',
                             left='left',
                             right='right',
                             ondelete='RESTRICT',
                             domain=[
                                 ('company', '=', Eval('company', -1)),
                             ],
                             depends=['company'])
    left = fields.Integer('Left', required=True, select=True)
    right = fields.Integer('Right', required=True, select=True)
    children = fields.One2Many('project.work',
                               'parent',
                               'Children',
                               domain=[
                                   ('company', '=', Eval('company', -1)),
                               ],
                               depends=['company'])
    state = fields.Selection([
        ('opened', 'Opened'),
        ('done', 'Done'),
    ],
                             'State',
                             required=True,
                             select=True)

    @staticmethod
    def default_type():
        return 'task'

    @classmethod
    def default_company(cls):
        return Transaction().context.get('company')

    @staticmethod
    def default_state():
        return 'opened'

    @classmethod
    def default_left(cls):
        return 0

    @classmethod
    def default_right(cls):
        return 0

    @classmethod
    def __register__(cls, module_name):
        TimesheetWork = Pool().get('timesheet.work')
        cursor = Transaction().connection.cursor()
        table_project_work = cls.__table_handler__(module_name)
        project = cls.__table__()
        timesheet = TimesheetWork.__table__()

        work_exist = table_project_work.column_exist('work')
        add_parent = (not table_project_work.column_exist('parent')
                      and work_exist)
        add_company = (not table_project_work.column_exist('company')
                       and work_exist)
        add_name = (not table_project_work.column_exist('name') and work_exist)

        super(Work, cls).__register__(module_name)

        # Migration from 3.4: change effort into timedelta effort_duration
        if table_project_work.column_exist('effort'):
            cursor.execute(*project.select(
                project.id, project.effort, where=project.effort != Null))
            for id_, effort in cursor.fetchall():
                duration = datetime.timedelta(hours=effort)
                cursor.execute(
                    *project.update([project.effort_duration], [duration],
                                    where=project.id == id_))
            table_project_work.drop_column('effort')

        # Migration from 3.6: add parent, company, drop required on work,
        # fill name
        if add_parent:
            second_project = cls.__table__()
            query = project.join(
                timesheet, condition=project.work == timesheet.id).join(
                    second_project,
                    condition=timesheet.parent == second_project.work).select(
                        project.id, second_project.id)
            cursor.execute(*query)
            for id_, parent in cursor.fetchall():
                cursor.execute(*project.update([project.parent], [parent],
                                               where=project.id == id_))
            cls._rebuild_tree('parent', None, 0)
        if add_company:
            cursor.execute(*project.join(
                timesheet, condition=project.work == timesheet.id).select(
                    project.id, timesheet.company))
            for id_, company in cursor.fetchall():
                cursor.execute(*project.update([project.company], [company],
                                               where=project.id == id_))
        table_project_work.not_null_action('work', action='remove')
        if add_name:
            cursor.execute(*project.join(
                timesheet, condition=project.work == timesheet.id).select(
                    project.id, timesheet.name))
            for id_, name in cursor.fetchall():
                cursor.execute(*project.update([project.name], [name],
                                               where=project.id == id_))

        # Migration from 4.0: remove work
        if work_exist:
            table_project_work.drop_constraint('work_uniq')
            update = Transaction().connection.cursor()
            cursor.execute(*project.select(
                project.id, project.work, where=project.work != Null))
            for project_id, work_id in cursor:
                update.execute(*timesheet.update(
                    [timesheet.origin, timesheet.name],
                    ['%s,%s' % (cls.__name__, project_id), Null],
                    where=timesheet.id == work_id))
            table_project_work.drop_column('work')

    @classmethod
    def index_set_field(cls, name):
        index = super(Work, cls).index_set_field(name)
        if name in {'timesheet_start_date', 'timesheet_end_date'}:
            index = cls.index_set_field('timesheet_available') + 1
        return index

    @classmethod
    def validate(cls, works):
        super(Work, cls).validate(works)
        for work in works:
            work.check_state()

    def check_state(self):
        if (self.state == 'opened'
                and (self.parent and self.parent.state == 'done')):
            raise WorkValidationError(
                gettext('project.msg_work_invalid_parent_state',
                        child=self.rec_name,
                        parent=self.parent.rec_name))
        if self.state == 'done':
            for child in self.children:
                if child.state == 'opened':
                    raise WorkValidationError(
                        gettext('project.msg_work_invalid_children_state',
                                parent=self.rec_name,
                                child=child.rec_name))

    @property
    def effort_hours(self):
        if not self.effort_duration:
            return 0
        return self.effort_duration.total_seconds() / 60 / 60

    @property
    def total_effort_hours(self):
        if not self.total_effort:
            return 0
        return self.total_effort.total_seconds() / 60 / 60

    @property
    def timesheet_duration_hours(self):
        if not self.timesheet_duration:
            return 0
        return self.timesheet_duration.total_seconds() / 60 / 60

    @classmethod
    def default_timesheet_available(cls):
        return False

    def get_timesheet_available(self, name):
        return bool(self.timesheet_works)

    @classmethod
    def set_timesheet_available(cls, projects, name, value):
        pool = Pool()
        Timesheet = pool.get('timesheet.work')

        to_create = []
        to_delete = []
        for project in projects:
            if not project.timesheet_works and value:
                to_create.append({
                    'origin': str(project),
                    'company': project.company.id,
                })
            elif project.timesheet_works and not value:
                to_delete.extend(project.timesheet_works)

        if to_create:
            Timesheet.create(to_create)
        if to_delete:
            Timesheet.delete(to_delete)

    def get_timesheet_date(self, name):
        if self.timesheet_works:
            func = {
                'timesheet_start_date': min,
                'timesheet_end_date': max,
            }[name]
            return func(getattr(w, name) for w in self.timesheet_works)

    @classmethod
    def set_timesheet_date(cls, projects, name, value):
        pool = Pool()
        Timesheet = pool.get('timesheet.work')
        timesheets = [w for p in projects for w in p.timesheet_works]
        if timesheets:
            Timesheet.write(timesheets, {
                name: value,
            })

    @classmethod
    def sum_tree(cls, works, values, parents):
        result = values.copy()
        works = set((w.id for w in works))
        leafs = works - set(parents.values())
        while leafs:
            for work in leafs:
                works.remove(work)
                parent = parents.get(work)
                if parent in result:
                    result[parent] += result[work]
            next_leafs = set(works)
            for work in works:
                parent = parents.get(work)
                if not parent:
                    continue
                if parent in next_leafs and parent in works:
                    next_leafs.remove(parent)
            leafs = next_leafs
        return result

    @classmethod
    def get_total(cls, works, names):
        cursor = Transaction().connection.cursor()
        table = cls.__table__()

        works = cls.search([
            ('parent', 'child_of', [w.id for w in works]),
        ])
        work_ids = [w.id for w in works]
        parents = {}
        for sub_ids in grouped_slice(work_ids):
            where = reduce_ids(table.id, sub_ids)
            cursor.execute(*table.select(table.id, table.parent, where=where))
            parents.update(cursor.fetchall())

        if 'total_progress' in names and 'total_effort' not in names:
            names = list(names)
            names.append('total_effort')

        result = {}
        for name in names:
            values = getattr(cls, '_get_%s' % name)(works)
            result[name] = cls.sum_tree(works, values, parents)

        if 'total_progress' in names:
            digits = cls.total_progress.digits[1]
            total_progress = result['total_progress']
            total_effort = result['total_effort']
            for work in works:
                if total_effort[work.id]:
                    total_progress[work.id] = round(
                        total_progress[work.id] /
                        (total_effort[work.id].total_seconds() / 60 / 60),
                        digits)
                else:
                    total_effort[work.id] = None
        return result

    @classmethod
    def _get_total_effort(cls, works):
        return {w.id: w.effort_duration or datetime.timedelta() for w in works}

    @classmethod
    def _get_timesheet_duration(cls, works):
        durations = {}
        for work in works:
            value = datetime.timedelta()
            for timesheet_work in work.timesheet_works:
                if timesheet_work.duration:
                    value += timesheet_work.duration
            durations[work.id] = value
        return durations

    @classmethod
    def _get_total_progress(cls, works):
        return {w.id: w.effort_hours * (w.progress or 0) for w in works}

    @classmethod
    def copy(cls, project_works, default=None):
        if default is None:
            default = {}
        else:
            default = default.copy()
        default.setdefault('children', None)
        return super().copy(project_works, default=default)

    @classmethod
    def delete(cls, project_works):
        TimesheetWork = Pool().get('timesheet.work')

        # Get the timesheet works linked to the project works
        timesheet_works = [
            w for pw in project_works for w in pw.timesheet_works
        ]

        super(Work, cls).delete(project_works)

        if timesheet_works:
            with Transaction().set_context(_check_access=False):
                TimesheetWork.delete(timesheet_works)

    @classmethod
    def search_global(cls, text):
        for record, rec_name, icon in super(Work, cls).search_global(text):
            icon = icon or 'tryton-project'
            yield record, rec_name, icon
コード例 #4
0
class Paciente(Persona):
    'Paciente'
    _name = 'cefiro.paciente'
    _description = __doc__

    sexo = fields.Selection([('M', 'Masculino'), ('F', 'Femenino'),
                             ('I', u'No contesta/Otro')], 'Sexo')
    nacimiento = fields.Date('Fecha de Nacimiento')
    edad = fields.Function(
        fields.Char('Edad'), 'get_edad'
    )  #fields.Integer('Edad') #Habría que relacionarlo con la fecha de nacimiento y hacerlo de sólo lectura
    telefono = fields.Char(
        u'Teléfono fijo'
    )  #Char por si hay telefonos internacionales, u otros símbolos
    celular = fields.Char(
        u'Teléfono celular')  #Char por si hay códigos que no sean números
    #
    lista = fields.Many2One('cefiro.lista', 'Lista de espera')
    #
    convenioSAPPA = fields.Selection([('f', 'Funcionario'), ('c', u'Cónyuge'),
                                      ('p', u'Padre/Madre'), ('h', u'Hijo/a')],
                                     u'Relación para el convenio')
    lugarTrabajo = fields.Char('Lugar de trabajo')
    funcionario = fields.Char(
        u'Número de funcionario')  #Lo pongo char por si hay letras
    #
    atencionMedica = fields.Selection([('msp', u'MSP/ASSE'),
                                       ('mut', 'Mutualista')],
                                      u'Tipo de Atención Médica')
    mutualista = fields.Char('Nombre de la Mutualista')
    #
    fechaIngresoExpediente = fields.Date('Fecha de ingreso del expediente')
    motivo = fields.Text('Motivo de Consulta')
    observaciones = fields.Text('Observaciones')
    #
    horarioPref = fields.Char('Horario de Preferencia')
    psicologo = fields.Many2One('cefiro.psicologo', u'Psicólogo')
    consultas = fields.Many2Many('cefiro.encuentro', 'persona', 'evento',
                                 'Consultas')
    #
    #Formularios entregados para el SAPPA
    form_OQ45T1 = fields.Boolean(u'OQ45-T1')
    form_OQ45T2 = fields.Boolean(u'OQ45-T2')
    form_EncuestaSatisfaccion = fields.Boolean(u'Encuesta de Satisfacción')
    form_EcuestaSatPExtProfesional = fields.Boolean(
        u'Encuesta de Satisfacción - Prof. Externo : Profesional')
    form_EncuestaSatPExtPaciente = fields.Boolean(
        u'Encuesta de Satisfacción - Prof. Externo: Paciente')
    #
    profExternoDerivacion = fields.Boolean('Derivado a profesional externo')
    profExternoNombre = fields.Char('Nombre del profesional externo')
    profExternoFecha = fields.Date(u'Fecha de derivación')

    #Cálculo de la edad
    def get_edad(self, ids, name):
        #usu = User()
        #usu.create([('name','pruebalala'),('login','loolololo')])
        ahora = date.today()
        res = {}
        for pac in self.browse(ids):
            edadtemp = relativedelta(ahora, pac.nacimiento)
            res[pac.id] = str(edadtemp.years) + u' años'
        return res
コード例 #5
0
class AparRepresentationForm(Workflow, ModelSQL, ModelView):
    'APAR Representation Form'

    __name__ = 'apar.representation'

    mail = fields.Boolean('Mail')
    representation_id = fields.Char('Representation Number', readonly=True)
    raised_by = fields.Many2One('company.employee', 'Employee', readonly=True)
    subject = fields.Char(
        'Subject',
        states={
            'readonly': ~Eval('state').in_(['draft']),
        },
        depends=['state'],
    )
    text = fields.Text(
        'Details',
        states={
            'readonly': ~Eval('state').in_(['draft']),
        },
        depends=['state'],
    )
    raised_on = fields.Date('Raised On', readonly=True)
    state = fields.Selection(
        [('draft', 'Draft'), ('reporting_officer', 'Reporting Officer'),
         ('reviewing_officer', 'Reviewing Officer'), ('hod', 'HOD'),
         ('accepting_authority', 'Accepting Authority'),
         ('acr_cell', 'ACR Cell'),
         ('submitted_to_acr_cell', 'Submitted to ACR Cell'),
         ('director', 'Director'), ('closed', 'Closed')],
        'Status',
        readonly=True)
    comments_reporting = fields.Text(
        'Comments by Reporting Officer',
        states={
            'readonly': ~Eval('state').in_(['reporting_officer']),
        },
        depends=['state'],
    )
    comments_reviewing = fields.Text(
        'Comments by Reviewing Officer',
        states={
            'readonly': ~Eval('state').in_(['reviewing_officer']),
        },
        depends=['state'],
    )
    comments_accepting = fields.Text(
        'Comments by Accepting Authority',
        states={
            'readonly': ~Eval('state').in_(['accepting_authority']),
        },
        depends=['state'],
    )
    comments_hod = fields.Text(
        'Comments by HoD',
        states={
            'readonly': ~Eval('state').in_(['hod']),
        },
        depends=['state'],
    )
    comments_director = fields.Text(
        'Comments by Director',
        states={
            'readonly': ~Eval('state').in_(['director']),
        },
        depends=['state'],
    )
    present_score = fields.Integer('Present Score')
    score = fields.Integer('Final Score')
    signatures = fields.One2Many('apar.representation.signatures',
                                 'representation', 'Signatures')

    @classmethod
    def __setup__(cls):
        super().__setup__()
        cls._buttons.update({
            "submit": {
                'invisible': ~Eval('state').in_(['draft']),
                'depends': ['state']
            },
            "forward_to_reporting": {
                'invisible': ~Eval('state').in_(['submitted_to_acr_cell']),
                'depends': ['state']
            },
            "forward_to_reviewing": {
                'invisible': ~Eval('state').in_(['reporting_officer']),
                'depends': ['state']
            },
            "forward_to_accepting": {
                'invisible': ~Eval('state').in_(['reviewing_officer']),
                'depends': ['state']
            },
            "forward_to_HoD": {
                'invisible': ~Eval('state').in_(['accepting_authority']),
                'depends': ['state']
            },
            "forward_to_acr": {
                'invisible': ~Eval('state').in_(['hod']),
                'depends': ['state']
            },
            "forward_to_director": {
                'invisible': ~Eval('state').in_(['acr_cell']),
                'depends': ['state']
            },
            "close": {
                'invisible': ~Eval('state').in_(['director']),
                'depends': ['state']
            }
        })

        cls._transitions |= set((
            ('draft', 'submitted_to_acr_cell'),
            ('submitted_to_acr_cell', 'reporting_officer'),
            ('reporting_officer', 'reviewing_officer'),
            ('reviewing_officer', 'accepting_authority'),
            ('accepting_authority', 'hod'),
            ('hod', 'acr_cell'),
            ('acr_cell', 'director'),
            ('director', 'closed'),
            ('closed', 'closed'),
        ))

    @staticmethod
    def default_state():
        return 'draft'

    def form_signature(self):

        pool = Pool()
        sign_obj = pool.get('apar.representation.signatures')
        User = pool.get('res.user')
        user = User(Transaction().user)

        employee = user.employee
        place = 'Delhi'

        vals = {
            'signed_by_user': user.id,
            'signed_by_employee': employee.id if employee else None,
            'designation': employee.designation.id if employee else None,
            'signed_on': pool.get('ir.date').today(),
            'place': place,
            'representation': self.id
        }

        sign_obj.create([vals])

    @classmethod
    @ModelView.button
    @Workflow.transition('submitted_to_acr_cell')
    def submit(self, records):
        for record in records:
            record.form_signature()

    @classmethod
    @ModelView.button
    @Workflow.transition('reporting_officer')
    def forward_to_reporting(self, records):
        for record in records:
            record.form_signature()

    @classmethod
    @ModelView.button
    @Workflow.transition('reviewing_officer')
    def forward_to_reviewing(self, records):
        for record in records:
            record.form_signature()

    @classmethod
    @ModelView.button
    @Workflow.transition('accepting_authority')
    def forward_to_accepting(self, records):
        for record in records:
            record.form_signature()

    @classmethod
    @ModelView.button
    @Workflow.transition('hod')
    def forward_to_HoD(self, records):
        for record in records:
            record.form_signature()

    @classmethod
    @ModelView.button
    @Workflow.transition('acr_cell')
    def forward_to_acr(self, records):
        for record in records:
            record.form_signature()

    @classmethod
    @ModelView.button
    @Workflow.transition('director')
    def forward_to_director(self, records):
        # TODO: Confirm from the user
        #  if he is sure that he wants to sign the document.
        for record in records:
            record.form_signature()

    @classmethod
    @ModelView.button
    @Workflow.transition('closed')
    def close(self, records):
        for record in records:
            record.form_signature()
コード例 #6
0
class QuotationLine(ModelSQL, ModelView):
    "Purchase Request For Quotation Line"
    __name__ = 'purchase.request.quotation.line'

    supplier = fields.Function(fields.Many2One('party.party', 'Supplier'),
                               'get_supplier')
    supply_date = fields.Date('Supply Date',
                              help="When it should be delivered.")
    product = fields.Function(fields.Many2One('product.product', 'Product'),
                              'get_product',
                              searcher='search_product')
    description = fields.Text('Description',
                              states={'required': ~Eval('product')},
                              depends=['product'])
    quantity = fields.Float('Quantity',
                            digits=(16, Eval('unit_digits', 2)),
                            required=True,
                            depends=['unit_digits'])
    unit = fields.Many2One(
        'product.uom',
        'Unit',
        ondelete='RESTRICT',
        states={
            'required': Bool(Eval('product')),
        },
        domain=[
            If(Bool(Eval('product_uom_category')),
               ('category', '=', Eval('product_uom_category')),
               ('category', '!=', -1)),
        ],
        depends=['product', 'product_uom_category'])
    unit_digits = fields.Function(fields.Integer('Unit Digits'),
                                  'on_change_with_unit_digits')
    product_uom_category = fields.Function(
        fields.Many2One('product.uom.category', 'Product Uom Category'),
        'on_change_with_product_uom_category')
    unit_price = fields.Numeric('Unit Price', digits=price_digits)
    currency = fields.Many2One('currency.currency',
                               'Currency',
                               states={
                                   'required': Bool(Eval('unit_price')),
                               },
                               depends=['unit_price'])
    currency_digits = fields.Function(fields.Integer('Currency Digits'),
                                      'on_change_with_currency_digits')
    request = fields.Many2One(
        'purchase.request',
        'Request',
        ondelete='CASCADE',
        select=True,
        required=True,
        domain=[
            If(
                Eval('quotation_state') == 'draft',
                ('state', 'in', ['draft', 'quotation', 'received']),
                (),
            ),
        ],
        states={'readonly': Eval('quotation_state') != 'draft'},
        depends=['quotation_state'],
        help="The request which this line belongs to.")
    quotation = fields.Many2One('purchase.request.quotation',
                                'Quotation',
                                ondelete='CASCADE',
                                required=True,
                                domain=[
                                    ('supplier', '=', Eval('supplier')),
                                ],
                                depends=['supplier'])
    quotation_state = fields.Function(fields.Selection('get_quotation_state',
                                                       'Quotation State'),
                                      'on_change_with_quotation_state',
                                      searcher='search_quotation_state')

    @staticmethod
    def order_quotation_state(tables):
        pool = Pool()
        Quotation = pool.get('purchase.request.quotation')
        quotation_line, _ = tables[None]
        quotation = Quotation.__table__()
        tables['purchase.request.quotation'] = {
            None: (quotation, quotation_line.quotation == quotation.id),
        }
        return [
            Case((quotation.state == 'received', 0), else_=1), quotation.state
        ]

    def get_supplier(self, name):
        if self.quotation and self.quotation.supplier:
            return self.quotation.supplier.id

    @fields.depends('request', '_parent_request.product',
                    '_parent_request.description', '_parent_request.quantity',
                    '_parent_request.uom', '_parent_request.company.currency',
                    '_parent_request.supply_date')
    def on_change_request(self):
        if self.request:
            self.product = self.request.product
            self.description = self.request.description
            self.quantity = self.request.quantity
            self.unit = self.request.uom
            if self.request.company:
                self.currency = self.request.company.currency
            self.supply_date = self.request.supply_date or datetime.date.max

    @fields.depends('unit')
    def on_change_with_unit_digits(self, name=None):
        if self.unit:
            return self.unit.digits
        return None

    @fields.depends('product')
    def on_change_with_product_uom_category(self, name=None):
        if self.product:
            return self.product.default_uom_category.id

    @fields.depends('currency')
    def on_change_with_currency_digits(self, name=None):
        if self.currency:
            return self.currency.digits
        return None

    @classmethod
    def get_quotation_state(cls):
        pool = Pool()
        Quotation = pool.get('purchase.request.quotation')
        return (Quotation.fields_get(['state'])['state']['selection'])

    @fields.depends('quotation', '_parent_quotation.state')
    def on_change_with_quotation_state(self, name=None):
        pool = Pool()
        Quotation = pool.get('purchase.request.quotation')
        if self.quotation:
            return self.quotation.state
        return Quotation.default_state()

    @classmethod
    def search_quotation_state(cls, name, clause):
        return [('quotation.state', ) + tuple(clause[1:])]

    def get_rec_name(self, name):
        return '%s - %s' % (self.quotation.rec_name, self.supplier.rec_name)

    @classmethod
    def search_rec_name(cls, name, clause):
        names = clause[2].split(' - ', 1)
        res = [('quotation', clause[1], names[0])]
        if len(names) != 1 and names[1]:
            res.append(('supplier', clause[1], names[1]))
        return res

    @classmethod
    def delete(cls, quotationlines):
        pool = Pool()
        Request = pool.get('purchase.request')
        requests = [l.request for l in quotationlines]
        super(QuotationLine, cls).delete(quotationlines)
        Request.update_state(requests)

    def get_product(self, name):
        if self.request and self.request.product:
            return self.request.product.id

    @classmethod
    def search_product(cls, name, clause):
        return [('request.' + clause[0], ) + tuple(clause[1:])]
コード例 #7
0
ファイル: period.py プロジェクト: dozymoe/stock
class Period(Workflow, ModelSQL, ModelView):
    'Stock Period'
    __name__ = 'stock.period'
    date = fields.Date('Date', required=True, states={
            'readonly': Eval('state') == 'closed',
            }, depends=['state'])
    company = fields.Many2One('company.company', 'Company', required=True,
        domain=[
            ('id', If(Eval('context', {}).contains('company'), '=', '!='),
                Eval('context', {}).get('company', -1)),
            ])
    caches = fields.One2Many('stock.period.cache', 'period', 'Caches',
        readonly=True)
    state = fields.Selection([
        ('draft', 'Draft'),
        ('closed', 'Closed'),
        ], 'State', select=True, readonly=True)

    @classmethod
    def __setup__(cls):
        super(Period, cls).__setup__()
        cls._error_messages.update({
                'close_period_future_today': ('You can not close a period '
                    'in the future or today.'),
                'close_period_assigned_move': (
                    'You can not close a period when '
                    'there still are assigned moves.'),
                })
        cls._transitions |= set((
                ('draft', 'closed'),
                ('closed', 'draft'),
                ))
        cls._buttons.update({
                'draft': {
                    'invisible': Eval('state') == 'draft',
                    'depends': ['state'],
                    },
                'close': {
                    'invisible': Eval('state') == 'closed',
                    'depends': ['state'],
                    },
                })

    @staticmethod
    def default_company():
        return Transaction().context.get('company')

    @staticmethod
    def default_state():
        return 'draft'

    @staticmethod
    def groupings():
        return [('product',)]

    @staticmethod
    def get_cache(grouping):
        pool = Pool()
        if all(g == 'product' or g.startswith('product.') for g in grouping):
            return pool.get('stock.period.cache')

    def get_rec_name(self, name):
        return str(self.date)

    @classmethod
    @ModelView.button
    @Workflow.transition('draft')
    def draft(cls, periods):
        for grouping in cls.groupings():
            Cache = cls.get_cache(grouping)
            caches = []
            for sub_periods in grouped_slice(periods):
                caches.append(Cache.search([
                            ('period', 'in',
                                [p.id for p in sub_periods]),
                            ], order=[]))
            Cache.delete(list(chain(*caches)))

    @classmethod
    @ModelView.button
    @Workflow.transition('closed')
    def close(cls, periods):
        pool = Pool()
        Product = pool.get('product.product')
        Location = pool.get('stock.location')
        Move = pool.get('stock.move')
        Date = pool.get('ir.date')
        transaction = Transaction()
        connection = transaction.connection
        database = transaction.database

        # XXX: A move in the period could be inserted before the lock
        # from a different transaction. It will not be taken in the pbl
        # computation but it is quite rare because only past periods are
        # closed.
        database.lock(connection, Move._table)
        if database.has_select_for():
            move = Move.__table__()
            query = move.select(Literal(1), for_=For('UPDATE', nowait=True))
            with connection.cursor() as cursor:
                cursor.execute(*query)

        locations = Location.search([
                ('type', 'not in', ['warehouse', 'view']),
                ], order=[])
        today = Date.today()

        recent_date = max(period.date for period in periods)
        if recent_date >= today:
            cls.raise_user_error('close_period_future_today')
        if Move.search([
                    ('state', '=', 'assigned'),
                    ['OR', [
                            ('effective_date', '=', None),
                            ('planned_date', '<=', recent_date),
                            ],
                        ('effective_date', '<=', recent_date),
                        ]]):
            cls.raise_user_error('close_period_assigned_move')

        for grouping in cls.groupings():
            Cache = cls.get_cache(grouping)
            to_create = []
            for period in periods:
                with Transaction().set_context(
                        stock_date_end=period.date,
                        stock_date_start=None,
                        stock_assign=False,
                        forecast=False,
                        stock_destinations=None,
                        ):
                    pbl = Product.products_by_location(
                        [l.id for l in locations], grouping=grouping)
                for key, quantity in pbl.items():
                    values = {
                        'location': key[0],
                        'period': period.id,
                        'internal_quantity': quantity,
                        }
                    for i, field in enumerate(grouping, 1):
                        values[field] = key[i]
                    to_create.append(values)
            if to_create:
                Cache.create(to_create)
コード例 #8
0
class InternalApply(ModelView):
    'Internal Apply'

    __name__ = 'hrp_internal_delivery.internal_apply'
    _rec_name = 'number'

    number = fields.Char('Number', size=None, select=True)
    type = fields.Selection(
        [
            ('00', u'常规药请领单'),
            ('06', u'直送药请领单'),
            ('2017', u' '),
        ],
        'Type', select=True, required=True, states={
            'readonly': Bool(Eval('moves'))})

    starts = fields.Selection([
        ('00', u'西药'),
        ('01', u'中成药'),
        ('02', u'中草药'),
        ('03', u'颗粒中'),
        ('04', u'原料药'),
        ('05', u'敷药'),
        ('07', u'同位素'),
    ], 'Starts', sort=False, select=True, states={
        'invisible': Equal(Eval('type'), '2017')
    }, )

    medicine = fields.Selection([
        ('00', u''),
        ('2', u'临采'),
        ('02', u'精一'),
        ('03', u'麻醉'),
    ], 'medicine', select=True,
        # states={
        #     'invisible':~Equal(Eval('starts'),'00')| Equal(Eval('type'),'06')
        #     },
    )
    special = fields.Selection([
        ('00', u'直送'),
    ], 'special', select=True
        , states={
            'readonly': Equal(Eval('type'), '06'),
            'invisible': ~Equal(Eval('type'), '06'),
        },
        depends=['type'],
    )
    planned_date = fields.Date('Planned Date', readonly=True)

    moves = fields.One2Many('hrp_internal_delivery.test_apply', 'parents', 'Moves')
    from_location = fields.Many2One('stock.location', 'from_location', readonly=True)
    to_location = fields.Many2One('stock.location', 'to_location', readonly=True)
    warehouse_to_location = fields.Many2One('stock.location', 'warehouse_to_location', select=True)

    # change_state = fields.Boolean('change_state',select=True)#更改请领状态

    @staticmethod
    def default_type():
        return '2017'

    @staticmethod
    def default_from_location():
        Config = Pool().get('purchase.configuration')
        config = Config(1)
        return config.warehouse.storage_location.id  # 默认为中心药房

    @staticmethod
    def default_to_location():
        UserId = Pool().get('hrp_internal_delivery.test_straight')
        return UserId.get_user_id()

    @staticmethod
    def default_planned_date():
        Date = Pool().get('ir.date')
        today = str(Date.today())
        return today

    @fields.depends('type')
    def on_change_type(self):
        if self.type == '06':
            self.special = '00'
        else:
            pass

    @fields.depends('starts', 'moves', 'special', 'to_location', 'medicine')
    def on_change_starts(self):
        Product = Pool().get('product.product')
        Date = Pool().get('ir.date')
        MOVE = Pool().get('hrp_new_product.new_product')
        list = []
        if self.special == None:
            locals = self.to_location
            if self.medicine == None:
                mmm = MOVE.search([
                    ('interim', 'in', ['1', '00']),
                    ('drug_type', '=', self.starts),
                    ('is_direct_sending', '=', False),
                    ('to_location', '=', locals),
                ])
            else:
                if self.medicine == '2':
                    mmm = MOVE.search([
                        ('drug_type', '=', self.starts),
                        ('is_direct_sending', '=', False),
                        ('to_location', '=', locals),
                        ('interim', 'in', ['2', '01']),
                    ])
                else:
                    mmm = MOVE.search([
                        ('drug_type', '=', self.starts),
                        ('is_direct_sending', '=', False),
                        ('to_location', '=', locals),
                        ('interim', '=', self.medicine),
                    ])
            for i in mmm:
                dict = {}
                dict['code'] = i.code
                dict['product'] = i.product.id
                dict['product_name'] = i.product.name
                dict['drug_specifications'] = i.drug_specifications
                dict['company'] = i.uom
                dict['a_charge'] = i.a_charge
                with Transaction().set_context(stock_date_end=Date.today()):
                    quantities = Product.products_by_location([locals], [i.product.id], with_childs=True)
                if quantities.values():
                    stock_level = [v for v in quantities.values()][0]
                else:
                    stock_level = 0.0
                dict['stock_level'] = str(stock_level)
                outpatient_ = str(i.outpatient_7days)
                dict['outpatient_7days'] = outpatient_.ljust(5, ' ')
                stock_levels = float(i.outpatient_7days) - stock_level
                if stock_levels <= 0:
                    dict['odd_numbers'] = '0.0'
                else:
                    dict['odd_numbers'] = str(stock_levels)
                dict['is_direct_sending'] = i.is_direct_sending
                dict['lot'] = i.lot
                dict['is_collar'] = False
                dict['party'] = i.party
                dict['unit_price'] = i.unit_price
                list.append(dict)
            self.moves = list
        if self.special == '00':
            locals = self.to_location
            mmm = MOVE.search([
                ('drug_type', '=', self.starts),
                ('is_direct_sending', '=', True),
                ('to_location', '=', locals),
            ])
            for i in mmm:
                dict = {}
                dict['code'] = i.code
                dict['product'] = i.product.id
                dict['product_name'] = i.product.name
                dict['drug_specifications'] = i.drug_specifications
                dict['company'] = i.uom
                dict['odd_numbers'] = i.odd_numbers
                dict['a_charge'] = i.a_charge
                with Transaction().set_context(stock_date_end=Date.today()):
                    quantities = Product.products_by_location([locals], [i.product.id], with_childs=True)
                if quantities.values():
                    stock_level = [v for v in quantities.values()][0]
                else:
                    stock_level = 0.0
                dict['stock_level'] = str(stock_level)
                if i.outpatient_7days == 0:
                    dict['outpatient_7days'] = '0.0'
                else:
                    dict['outpatient_7days'] = str(i.outpatient_7days)
                stock_levels = i.outpatient_7days - stock_level
                if stock_levels <= 0:
                    dict['odd_numbers'] = '0.0'
                else:
                    dict['odd_numbers'] = stock_levels
                dict['is_direct_sending'] = i.is_direct_sending
                dict['lot'] = i.lot
                dict['is_collar'] = i.is_collar
                dict['party'] = i.party
                dict['unit_price'] = i.unit_price
                list.append(dict)
            self.moves = list

    # 西药特殊,精神一,麻醉
    @fields.depends('medicine', 'moves', 'starts', 'special', 'to_location')
    def on_change_medicine(self):
        Product = Pool().get('product.product')
        Date = Pool().get('ir.date')
        MOVE = Pool().get('hrp_new_product.new_product')
        list = []
        locals = self.to_location
        if self.special == None:
            search_move = MOVE.search([
                ('is_direct_sending', '=', False),
                ('interim', '=', self.medicine),
                ('drug_type', '=', self.starts),
                ('to_location', '=', locals),
            ])
            for i in search_move:
                dict = {}
                dict['code'] = i.code
                dict['product'] = i.product.id
                dict['product_name'] = i.product.name
                dict['drug_specifications'] = i.drug_specifications
                dict['company'] = i.uom
                dict['a_charge'] = i.a_charge
                with Transaction().set_context(stock_date_end=Date.today()):
                    quantities = Product.products_by_location([locals], [i.product.id], with_childs=True)
                if quantities.values():
                    stock_level = [v for v in quantities.values()][0]
                else:
                    stock_level = 0.0
                dict['stock_level'] = str(stock_level)
                Ljust = str(i.outpatient_7days)
                dict['outpatient_7days'] = Ljust.ljust(5, ' ')
                stock_levels = float(i.outpatient_7days) - stock_level
                if stock_levels <= 0:
                    dict['odd_numbers'] = '0.0'
                else:
                    dict['odd_numbers'] = str(stock_levels)
                dict['is_direct_sending'] = i.is_direct_sending
                dict['lot'] = i.lot
                dict['is_collar'] = i.is_collar
                dict['party'] = i.party
                dict['unit_price'] = i.unit_price
                list.append(dict)
        if self.starts == None:
            pass
        if self.special == '00':
            locals = self.to_location
            search_move = MOVE.search([
                ('drug_type', '=', self.starts),
                ('interim', '=', self.medicine),
                ('is_direct_sending', '=', True),
                ('to_location', '=', locals),
            ])
            for i in search_move:
                dict = {}
                dict['code'] = i.code
                dict['product'] = i.product.id
                dict['product_name'] = i.product.name
                dict['drug_specifications'] = i.drug_specifications
                dict['company'] = i.uom
                dict['odd_numbers'] = i.odd_numbers
                dict['a_charge'] = i.a_charge
                with Transaction().set_context(stock_date_end=Date.today()):
                    quantities = Product.products_by_location([locals], [i.product.id], with_childs=True)
                if quantities.values():
                    stock_level = [v for v in quantities.values()][0]
                else:
                    stock_level = 0.0
                dict['stock_level'] = str(stock_level)
                dict['outpatient_7days'] = i.outpatient_7days
                stock_levels = i.outpatient_7days - stock_level
                if stock_levels <= 0:
                    dict['odd_numbers'] = '0.0'
                else:
                    dict['odd_numbers'] = stock_levels
                dict['is_direct_sending'] = i.is_direct_sending
                dict['lot'] = i.lot
                dict['is_collar'] = i.is_collar
                dict['party'] = i.party
                dict['unit_price'] = i.unit_price
                list.append(dict)
        self.moves = list

    @staticmethod
    def default_actives():
        return '00'

    @staticmethod
    def default_company():
        return Transaction().context.get('company')
コード例 #9
0
ファイル: formulario.py プロジェクト: guzmanico23/cefiro
class Formulario(ModelSQL, ModelView):
    'Formulario'
    _name = 'cefiro.formulario'
    _description = __doc__
    _rec_name = 'fecha'
    #	name = fields.Char('Nombre del paciente')

    #Paciente Asociado y datos autocompletados. Implementar esto. Tema de las edades (el paciente tiene una edad actual, y va yendo a consultas con distintas edades).
    paciente = fields.Many2One('cefiro.paciente', 'Paciente')

    #Tipo de consulta
    fecha = fields.Date('Fecha de consulta inicial', required=True)
    tipoConsulta = fields.Selection([('esp', u'Consulta espontánea'),
                                     ('tra', u'Traído'),
                                     ('ori', u'Consulta por orientación'),
                                     ('der', 'Derivado')], 'Tipo de Consulta')
    derivador = fields.Selection([('med', u'Especialidad Médica'),
                                  ('psiq', 'Psiquiatra'),
                                  ('edu', u'Institución Educativa'),
                                  ('otra', 'Otra')], 'Derivado por')
    derivEspec = fields.Char('Especifique')

    #Motivo de consulta
    motivoPaciente1 = fields.Char(u'Motivo según el paciente (1)')
    motivoPaciente1Cod = fields.Char(u'Código')
    motivoPaciente2 = fields.Char(u'Motivo según el paciente (2)')
    motivoPaciente2Cod = fields.Char(u'Código')
    motivoPaciente3 = fields.Char(u'Motivo según el paciente (3)')
    motivoPaciente3Cod = fields.Char(u'Código')

    motivoAcompa1 = fields.Char(u'Motivo según el Acompañante (1)')
    motivoAcompa1Cod = fields.Char(u'Código')
    motivoAcompa2 = fields.Char(u'Motivo según el Acompañante (2)')
    motivoAcompa2Cod = fields.Char(u'Código')
    motivoAcompa3 = fields.Char(u'Motivo según el Acompañante (3)')
    motivoAcompa3Cod = fields.Char(u'Código')

    motivoPsico1 = fields.Char(u'Motivo según el Psicólogo (1)')
    motivoPsico1Cod = fields.Char(u'Código')
    motivoPsico2 = fields.Char(u'Motivo según el Psicólogo (2)')
    motivoPsico2Cod = fields.Char(u'Código')
    motivoPsico3 = fields.Char(u'Motivo según el Psicólogo (3)')
    motivoPsico3Cod = fields.Char(u'Código')

    motivoComplementaria = fields.Text(u'Descripción Comlpementaria')

    #Datos personales extra
    lugarNacimiento = fields.Char('Lugar de Nacimiento')

    #Vivienda y Trabajo
    tipoVivienda = fields.Selection([('casa', 'la casa'),
                                     ('calle', 'la calle'),
                                     ('inst', u'institución protectora'),
                                     ('car', 'privado de libertad')],
                                    'Vive en')
    #convive = fields.One2Many() Hay que hacer uno para familiares posibles. Por ahora va un Selection.
    convive = fields.Selection([('solo', 'Vive solo'), ('madre', 'Madre'),
                                ('padre', 'Padre'), ('madra', 'Madrastra'),
                                ('padra', 'Padrastro'), ('her', 'Hermano'),
                                ('pare', 'Pareja'), ('hijo', 'Hijo'),
                                ('otros', 'Otros')], u'Con quién convive')
    situacionCony = fields.Selection(
        [('sol', u'Soltero/a'),
         ('casado', u'Casado/a (incluye separado/a sin divorcio)'),
         ('divor', u'Divorciado/a'), ('viudo', u'Viudo/a'),
         ('ulibre', u'Unión libre'),
         ('slibre', u'Separado de unión libre')], 'Estado Conyugal')

    vivHabitaTot = fields.Integer('Habitaciones totales')
    vivHabitaDor = fields.Integer('Dormitorios')
    vivBanos = fields.Integer(u'Cantidad de Baños')
    vivBanoComp = fields.Boolean(u'Baño compartido')
    vivBanoTipo = fields.Selection(
        [('red', 'Red general'), ('fosa', u'Fosa séptica o pozo negro'),
         ('otro', u'Otro (hueco en suelo, superficie)')],
        u'Tipo de instalación sanitaria')

    trabSituacion = fields.Selection([('trab', 'Trabaja'),
                                      ('bus', 'Busca por primera vez'),
                                      ('no', 'No trabaja'),
                                      ('pas', u'Pasantía'),
                                      ('pens', 'Pensionista'),
                                      ('jub', 'Jubilado')],
                                     u'Situación Laboral')
    trabMulti = fields.Boolean('Multiempleo')
    trabHoras = fields.Integer('Horas Totales')
    trabHorasPrin = fields.Integer('Horas Trabajo Principal')
    trabInicio = fields.Integer('Edad de inicio de trabajo')
    trabInfantil = fields.Boolean('Trabajo infantil')
    trabJuvenil = fields.Boolean('Trabajo juvenil')
    trabLegal = fields.Boolean('Trabajo legalizado')
    trabInsalubre = fields.Boolean('Trabajo insalubre')
    trabTipoRel = fields.Selection([('pub', u'Empleado Público'),
                                    ('priv', 'Empleado Privado'),
                                    ('indep', 'Empleado Independiente'),
                                    ('otro', 'Otro')], u'Tipo de Relación')
    trabObs = fields.Text('Observaciones')

    trabPadre = fields.Selection([('trab', 'Trabaja'),
                                  ('bus', 'Busca por primera vez'),
                                  ('no', 'No trabaja'), ('pas', u'Pasantía'),
                                  ('pens', 'Pensionista'),
                                  ('jub', 'Jubilado')],
                                 u'Situación Laboral del Padre')
    trabMadre = fields.Selection([('trab', 'Trabaja'),
                                  ('bus', 'Busca por primera vez'),
                                  ('no', 'No trabaja'), ('pas', u'Pasantía'),
                                  ('pens', 'Pensionista'),
                                  ('jub', 'Jubilado')],
                                 u'Situación Laboral de la Madre')
    trabPareja = fields.Selection([('trab', 'Trabaja'),
                                   ('bus', 'Busca por primera vez'),
                                   ('no', 'No trabaja'), ('pas', u'Pasantía'),
                                   ('pens', 'Pensionista'),
                                   ('jub', 'Jubilado')],
                                  u'Situación Laboral de la Pareja')

    #Educación
    eduFormalNivel = fields.Selection([('no', 'No escolarizado'),
                                       ('priInc', 'Primaria Incompleta'),
                                       ('pri', 'Primaria Completa'),
                                       ('secInc', 'Secundaria Incompleta'),
                                       ('sec', 'Secundaria Completa'),
                                       ('tercInc', 'Terciaria Incompleta'),
                                       ('terc', 'Terciaria Completa'),
                                       ('uniInc', 'Universitaria Incompleta'),
                                       ('uni', 'Universitaria Completa')],
                                      u'Nivel de Educación Formal')
    eduFormalNivelMax = fields.Integer(
        u'Máximo año aprobado (en caso de no haber completado lo último que estudió)'
    )

    eduCentrosPrimaria = fields.Char(u'Centros en los que estudió')
    eduPubliPrimaria = fields.Selection([('publi', u'Pública'),
                                         ('priv', 'Privada')],
                                        u'Tipo de institución')
    eduDifPrimaria = fields.Boolean(u'Presentó dificultades de aprendizaje')
    eduDifTipoPrimaria = fields.Char(u'Tipo de dificultad que presentó')
    eduRepePrimaria = fields.Integer(
        u'Cantidad de años repetidos (si no hay dejar vacío)')
    eduRepeCausaPrimaria = fields.Char(u'Causa de la repetición de años')
    eduDeserPrimaria = fields.Boolean(u'Deserción o Exclusión')

    eduCentrosSecundaria = fields.Char(u'Centros en los que estudió')
    eduPubliSecundaria = fields.Selection([('publi', u'Pública'),
                                           ('priv', 'Privada')],
                                          u'Tipo de institución')
    eduDifSecundaria = fields.Boolean(u'Presentó dificultades de aprendizaje')
    eduDifTipoSecundaria = fields.Char(u'Tipo de dificultad que presentó')
    eduRepeSecundaria = fields.Integer(
        u'Cantidad de años repetidos (si no hay dejar vacío)')
    eduRepeCausaSecundaria = fields.Char(u'Causa de la repetición de años')
    eduDeserSecundaria = fields.Boolean(u'Deserción o Exclusión')

    eduCentrosTerciaria = fields.Char(u'Centros en los que estudió')
    eduPubliTerciaria = fields.Selection([('publi', u'Pública'),
                                          ('priv', 'Privada')],
                                         u'Tipo de institución')

    eduCentrosUniv = fields.Char(u'Centros en los que estudió')
    eduPubliUniv = fields.Selection([('publi', u'Pública'),
                                     ('priv', 'Privada')],
                                    u'Tipo de institución')

    eduNoForCurso1 = fields.Char('Curso')
    eduNoForCentro1 = fields.Char('Centro')
    eduNoForPubli1 = fields.Selection([('publi', u'Pública'),
                                       ('priv', 'Privada')],
                                      u'Tipo de institución')
    eduNoForAsis1 = fields.Selection([('actual', 'Asiste'),
                                      ('pasado', u'Asistió')], 'Momento')

    eduNoForCurso2 = fields.Char('Curso')
    eduNoForCentro2 = fields.Char('Centro')
    eduNoForPubli2 = fields.Selection([('publi', u'Pública'),
                                       ('priv', 'Privada')],
                                      u'Tipo de institución')
    eduNoForAsis2 = fields.Selection([('actual', 'Asiste'),
                                      ('pasado', u'Asistió')], 'Momento')

    eduNoForCurso3 = fields.Char('Curso')
    eduNoForCentro3 = fields.Char('Centro')
    eduNoForPubli3 = fields.Selection([('publi', u'Pública'),
                                       ('priv', 'Privada')],
                                      u'Tipo de institución')
    eduNoForAsis3 = fields.Selection([('actual', 'Asiste'),
                                      ('pasado', u'Asistió')], 'Momento')

    eduPadre = fields.Selection([('no', 'No escolarizado'),
                                 ('priInc', 'Primaria Incompleta'),
                                 ('pri', 'Primaria Completa'),
                                 ('secInc', 'Secundaria Incompleta'),
                                 ('sec', 'Secundaria Completa'),
                                 ('tercInc', 'Terciaria Incompleta'),
                                 ('terc', 'Terciaria Completa'),
                                 ('uniInc', 'Universitaria Incompleta'),
                                 ('uni', 'Universitaria Completa')],
                                u'Nivel de Educación Formal del Padre')

    eduMadre = fields.Selection([('no', 'No escolarizado'),
                                 ('priInc', 'Primaria Incompleta'),
                                 ('pri', 'Primaria Completa'),
                                 ('secInc', 'Secundaria Incompleta'),
                                 ('sec', 'Secundaria Completa'),
                                 ('tercInc', 'Terciaria Incompleta'),
                                 ('terc', 'Terciaria Completa'),
                                 ('uniInc', 'Universitaria Incompleta'),
                                 ('uni', 'Universitaria Completa')],
                                u'Nivel de Educación Formal de la Madre')

    eduPareja = fields.Selection([('no', 'No escolarizado'),
                                  ('priInc', 'Primaria Incompleta'),
                                  ('pri', 'Primaria Completa'),
                                  ('secInc', 'Secundaria Incompleta'),
                                  ('sec', 'Secundaria Completa'),
                                  ('tercInc', 'Terciaria Incompleta'),
                                  ('terc', 'Terciaria Completa'),
                                  ('uniInc', 'Universitaria Incompleta'),
                                  ('uni', 'Universitaria Completa')],
                                 u'Nivel de Educación Formal de la Pareja')

    #Antecedentes
    antPedagogica = fields.Selection([('conc', u'Concluida'),
                                      ('aba', 'Abandonada'),
                                      ('cur', 'En Curso')],
                                     u'Intervención Pedagógica')
    antPedagogicaPocas = fields.Boolean('Menos de 3 consultas')
    antPedagogicaMeses = fields.Integer(u'Duración en meses')
    antPedagogicaMedicacion = fields.Boolean(u'Medicación')
    antPedagogicaMedTipo = fields.Selection([('ansiolitico', u'Ansiolíticos'),
                                             ('antidepre', 'Antidepresivos'),
                                             ('neurolep', u'Neurolépticos'),
                                             ('otro', 'Otros')],
                                            u'Tipo de Medicación')
    antPedagogicaObs = fields.Char(u'Motivo y Obs.')

    antMedica = fields.Selection([('conc', u'Concluida'),
                                  ('aba', 'Abandonada'), ('cur', 'En Curso')],
                                 u'Intervención Médica')
    antMedicaPocas = fields.Boolean('Menos de 3 consultas')
    antMedicaMeses = fields.Integer(u'Duración en meses')
    antMedicaMedicacion = fields.Boolean(u'Medicación')
    antMedicaMedTipo = fields.Selection([('ansiolitico', u'Ansiolíticos'),
                                         ('antidepre', 'Antidepresivos'),
                                         ('neurolep', u'Neurolépticos'),
                                         ('otro', 'Otros')],
                                        u'Tipo de Medicación')
    antMedicaObs = fields.Char(u'Motivo y Obs.')

    antPsicologica = fields.Selection([('conc', u'Concluida'),
                                       ('aba', 'Abandonada'),
                                       ('cur', 'En Curso')],
                                      u'Intervención Psicológica')
    antPsicologicaPocas = fields.Boolean('Menos de 3 consultas')
    antPsicologicaMeses = fields.Integer(u'Duración en meses')
    antPsicologicaMedicacion = fields.Boolean(u'Medicación')
    antPsicologicaMedTipo = fields.Selection([('ansiolitico', u'Ansiolíticos'),
                                              ('antidepre', 'Antidepresivos'),
                                              ('neurolep', u'Neurolépticos'),
                                              ('otro', 'Otros')],
                                             u'Tipo de Medicación')
    antPsicologicaObs = fields.Char(u'Motivo y Obs.')

    antPsiquiatrica = fields.Selection([('conc', u'Concluida'),
                                        ('aba', 'Abandonada'),
                                        ('cur', 'En Curso')],
                                       u'Intervención Psiquiátrica')
    antPsiquiatricaPocas = fields.Boolean('Menos de 3 consultas')
    antPsiquiatricaMeses = fields.Integer(u'Duración en meses')
    antPsiquiatricaMedicacion = fields.Boolean(u'Medicación')
    antPsiquiatricaMedTipo = fields.Selection(
        [('ansiolitico', u'Ansiolíticos'), ('antidepre', 'Antidepresivos'),
         ('neurolep', u'Neurolépticos'),
         ('otro', 'Otros')], u'Tipo de Medicación')
    antPsiquiatricaObs = fields.Char(u'Motivo y Obs.')

    antPsiqInter = fields.Selection([('conc', u'Concluida'),
                                     ('aba', 'Abandonada'),
                                     ('cur', 'En Curso')],
                                    u'Internación Psiquiátrica')
    antPsiqInterPocas = fields.Boolean('Menos de 3 consultas')
    antPsiqInterMeses = fields.Integer(u'Duración en meses')
    antPsiqInterMedicacion = fields.Boolean(u'Medicación')
    antPsiqInterMedTipo = fields.Selection([('ansiolitico', u'Ansiolíticos'),
                                            ('antidepre', 'Antidepresivos'),
                                            ('neurolep', u'Neurolépticos'),
                                            ('otro', 'Otros')],
                                           u'Tipo de Medicación')
    antPsiqInterObs = fields.Char(u'Motivo y Obs.')

    antIntOtra = fields.Selection([('conc', u'Concluida'),
                                   ('aba', 'Abandonada'), ('cur', 'En Curso')],
                                  u'Otra')
    antIntOtraPocas = fields.Boolean('Menos de 3 consultas')
    antIntOtraMeses = fields.Integer(u'Duración en meses')
    antIntOtraMedicacion = fields.Boolean(u'Medicación')
    antIntOtraMedTipo = fields.Selection([('ansiolitico', u'Ansiolíticos'),
                                          ('antidepre', 'Antidepresivos'),
                                          ('neurolep', u'Neurolépticos'),
                                          ('otro', 'Otros')],
                                         u'Tipo de Medicación')
    antIntOtraObs = fields.Char(u'Motivo y Obs.')

    antDisca = fields.Boolean(u'Tiene algún tipo de discapacidad')
    antDiscaTipo = fields.Char('Tipo')
    antAyudaTec = fields.Boolean(u'Utiliza algún tipo de ayuda técnica')
    antAyudaTecLentes = fields.Boolean(u'Lentes')
    antAyudaTecBaston = fields.Boolean(u'Bastón')
    antAyudaTecAudifono = fields.Boolean(u'Audífono')
    antAyudaTecOtro = fields.Boolean(u'Otro')
    antAyudaTecObs = fields.Char('Obs.')

    antPrestacion = fields.Boolean(
        u'Beneficiario de prestación por discapacidad')
    antPrestPension = fields.Boolean(u'Pensión no contributiva')
    antPrestJubil = fields.Boolean(u'Jubilación por incapacidad')
    antPrestAsigDoble = fields.Boolean(u'Asignación doble')
    antPrestAyuda = fields.Boolean(u'Ayuda especial')
    antPrestEquidad = fields.Boolean(u'Plan de equidad')

    antCeguera = fields.Boolean(u'Ceguera y/o dism. de visión')
    antSordera = fields.Boolean(u'Sordera / hipoacusia')
    antMotriz = fields.Boolean(u'Ceguera y/o dism. de visión')
    antDependencia = fields.Boolean(u'Dependencia de otra persona')

    antAsma = fields.Boolean(u'Asma')
    antEpilepsia = fields.Boolean(u'Epilepsia')
    antDiabetes = fields.Boolean(u'Diabetes')
    antTiroides = fields.Boolean(u'Enf. Tiroidea')
    antCancer = fields.Boolean(u'Cáncer')
    antVIH = fields.Boolean(u'VIH/SIDA')
    antOsteo = fields.Boolean(u'Pat. Osteoarticular')
    antCardio = fields.Boolean(u'Enf. Cardiovascular')

    antAccidente1Edad = fields.Integer('Edad')
    antAccidente1Tipo = fields.Char('Tipo')
    antAccidente2Edad = fields.Integer('Edad')
    antAccidente2Tipo = fields.Char('Tipo')
    antCirugia1Edad = fields.Integer('Edad')
    antCirugia1Tipo = fields.Char('Tipo')
    antCirugia2Edad = fields.Integer('Edad')
    antCirugia2Tipo = fields.Char('Tipo')

    antAutoeliminCant = fields.Integer(
        u'Cantidad de intentos de autoeliminación')
    antAutoelim1Edad = fields.Integer('Edad')
    antAutoelim1Tipo = fields.Char('Tipo')
    antAutoelim2Edad = fields.Integer('Edad')
    antAutoelim2Tipo = fields.Char('Tipo')

    #Violencia y Uso de Sustancias
    tvioDanoPsico = u'¿Su pareja o alguien importante para usted le ha causado daño emocional o psicológico en forma repetida?\n (Por ej.: por medio de alguna de las siguientes situaciones: insultos, maltrato a sus hijos, hacerlo/a\n sentir avergonzado/a o humillado/a desprecio por las tareas que usted realiza, destrucción de objetos\n de amigos o parientes, otras.)'
    vioDanoPsico = fields.Selection([('si', u'Sí'), ('no', 'No'),
                                     ('nc', 'No desea contestar')],
                                    tvioDanoPsico)
    vioDanoPsicoQuien = fields.Char(u'¿Quién/es lo hizo/cieron?')
    vioDanoPsicoNino = fields.Boolean(u'Niño/a')
    vioDanoPsicoAdoles = fields.Boolean(u'Adolescente')
    vioDanoPsicoJoven = fields.Boolean(u'Joven')
    vioDanoPsicoAdulto = fields.Boolean(u'Adulto/a')
    vioDanoPsicoMayor = fields.Boolean(u'Mayor de 65')
    vioDanoPsicoEmbarazo = fields.Boolean(u'Embarazo/postparto')
    vioDanoPsicoActual = fields.Selection([('si', u'Sí'), ('no', 'No'),
                                           ('nc', 'No desea contestar')],
                                          u'¿Sucede actualmente?')

    tvioDanoFisico = u'¿Su pareja o alguien importante para usted le ha causado daño físico grave al menos una vez, o le ha hecho agresiones menores en forma reiterada?\n (Por ej.: empujones, golpe de puños, quemaduras, zamarreos, mordeduras, ahorcamiento, pellizcos, palizas, golpes con objetos,\n tirón de pelo, patadas, daño con armas, cachetadas, otra forma.)'
    vioDanoFisico = fields.Selection([('si', u'Sí'), ('no', 'No'),
                                      ('nc', 'No desea contestar')],
                                     tvioDanoFisico)
    vioDanoFisicoQuien = fields.Char(u'¿Quién/es lo hizo/cieron?')
    vioDanoFisicoNino = fields.Boolean(u'Niño/a')
    vioDanoFisicoAdoles = fields.Boolean(u'Adolescente')
    vioDanoFisicoJoven = fields.Boolean(u'Joven')
    vioDanoFisicoAdulto = fields.Boolean(u'Adulto/a')
    vioDanoFisicoMayor = fields.Boolean(u'Mayor de 65')
    vioDanoFisicoEmbarazo = fields.Boolean(u'Embarazo/postparto')
    vioDanoFisicoActual = fields.Selection([('si', u'Sí'), ('no', 'No'),
                                            ('nc', 'No desea contestar')],
                                           u'¿Sucede actualmente?')

    tvioDanoSexual = u'¿Cuando usted era niño/a recuerda haber sido tocado/a de manera inapropiada por alguien o haber tenido relaciones o contacto sexual?'
    vioDanoSexual = fields.Selection([('si', u'Sí'), ('no', 'No'),
                                      ('nc', 'No desea contestar')],
                                     tvioDanoSexual)
    vioDanoSexualQuien = fields.Char(u'¿Quién/es lo hizo/cieron?')

    tvioViola = u'¿Alguna vez en su vida ha sido obligado/a a tener relaciones o contacto sexual?\n (Por ej.: empleo de la fuerza física, de intimidación o amenaza para mantener relaciones sexuales no deseadas.)'
    vioViola = fields.Selection([('si', u'Sí'), ('no', 'No'),
                                 ('nc', 'No desea contestar')], tvioViola)
    vioViolaQuien = fields.Char(u'¿Quién/es lo hizo/cieron?')
    vioViolaNino = fields.Boolean(u'Niño/a')
    vioViolaAdoles = fields.Boolean(u'Adolescente')
    vioViolaJoven = fields.Boolean(u'Joven')
    vioViolaAdulto = fields.Boolean(u'Adulto/a')
    vioViolaMayor = fields.Boolean(u'Mayor de 65')
    vioViolaEmbarazo = fields.Boolean(u'Embarazo/postparto')
    vioViolaActual = fields.Selection([('si', u'Sí'), ('no', 'No'),
                                       ('nc', 'No desea contestar')],
                                      u'¿Sucede actualmente?')

    vioPensamiento = fields.Selection([
        ('si', u'Sí'), ('no', 'No'), ('nc', 'No desea contestar')
    ], u'Hoy, en su casa, ¿piensa usted que podría sufrir alguna de las situaciones antes nombradas?'
                                      )

    tsustAlcohol = u'Durante los últimos 30 días, ¿con qué frecuencia usted bebió al menos 4 medidas de cualquier\n clase de bebida con alcohol en un mismo día?'
    sustAlcohol = fields.Selection(
        [('nunca', 'Nunca'), ('unames', 'Una vez al mes'),
         ('dosmes', '2 o 3 veces al mes'),
         ('unasemana', 'Una vez a la semana'),
         ('dossemana', u'2 dóas a la semana o más')], tsustAlcohol)
    tsustCigarro = u'Durante los últimos 30 días, ¿con qué frecuencia usted fumó cigarrillos, tabaco o pipa?'
    sustCigarro = fields.Selection(
        [('nunca', 'Nunca'), ('unames', 'Una vez al mes'),
         ('dosmes', '2 o 3 veces al mes'),
         ('unasemana', 'Una vez a la semana'),
         ('dossemana', u'2 dóas a la semana o más')], tsustCigarro)
    tsustMedicamento = u'Durante los últimos 30 días, ¿con qué frecuencia usted usó algunos de los siguientes medicamentos \n POR SU CUENTA (esto es sin una receta de su médico o en cantidades mayores a las recetadas)?\n Medicamentos para el dolor como tramadol o morfina, estimulantes como ritalina, tranquilizantes como Lexotán.'
    sustMedicamento = fields.Selection(
        [('nunca', 'Nunca'), ('unames', 'Una vez al mes'),
         ('dosmes', '2 o 3 veces al mes'),
         ('unasemana', 'Una vez a la semana'),
         ('dossemana', u'2 dóas a la semana o más')], tsustMedicamento)
    tsustDroga = u'Durante los últimos 30 días, ¿con qué frecuencia usted usó algunas de las siguientes sustancias:\n Marihuana, Cocaína, Pasta Base, Crack, Estimulantes como éxtasis, Halucinógenos como hongos o LSD,\n Heroína, Inhalantes como pegamento?'
    sustDroga = fields.Selection([('nunca', 'Nunca'),
                                  ('unames', 'Una vez al mes'),
                                  ('dosmes', '2 o 3 veces al mes'),
                                  ('unasemana', 'Una vez a la semana'),
                                  ('dossemana', u'2 dóas a la semana o más')],
                                 tsustDroga)
コード例 #10
0
ファイル: health_orthanc.py プロジェクト: mdn57/health
class OrthancStudy(ModelSQL, ModelView):
    """Orthanc study"""

    __name__ = "gnuhealth.orthanc.study"

    patient = fields.Many2One("gnuhealth.orthanc.patient", "Patient", readonly=True)
    uuid = fields.Char("UUID", readonly=True, required=True)
    description = fields.Char("Description", readonly=True)
    date = fields.Date("Date", readonly=True)
    ident = fields.Char("ID", readonly=True)
    institution = fields.Char(
        "Institution", readonly=True, help="Imaging center where study was undertaken"
    )
    ref_phys = fields.Char("Referring Physician", readonly=True)
    req_phys = fields.Char("Requesting Physician", readonly=True)
    server = fields.Many2One("gnuhealth.orthanc.config", "Server", readonly=True)
    link = fields.Function(
        fields.Char("URL", help="Link to study in Orthanc Explorer"), "get_link"
    )
    imaging_test = fields.Many2One("gnuhealth.imaging.test.result", "Test")

    def get_link(self, name):
        pre = "".join([self.server.domain.rstrip("/"), "/"])
        add = "app/explorer.html#study?uuid={}".format(self.uuid)
        return urljoin(pre, add)

    @classmethod
    def __setup__(cls):
        super().__setup__()
        t = cls.__table__()
        cls._sql_constraints = [
            (
                "uuid_unique",
                Unique(t, t.server, t.uuid),
                "UUID must be unique for a given server",
            )
        ]

    def get_rec_name(self, name):
        return ": ".join((self.ident or self.uuid, self.description or ""))

    @staticmethod
    def get_info_from_dicom(studies):
        """Extract information for writing to database"""

        data = []

        for study in studies:
            try:
                date = datetime.strptime(
                    study["MainDicomTags"]["StudyDate"], "%Y%m%d"
                ).date()
            except:
                date = None
            try:
                description = study["MainDicomTags"]["RequestedProcedureDescription"]
            except:
                description = None
            data.append(
                {
                    "parent_patient": study["ParentPatient"],
                    "uuid": study["ID"],
                    "description": description,
                    "date": date,
                    "ident": study.get("MainDicomTags").get("StudyID"),
                    "institution": study.get("MainDicomTags").get("InstitutionName"),
                    "ref_phys": study.get("MainDicomTags").get(
                        "ReferringPhysicianName"
                    ),
                    "req_phys": study.get("MainDicomTags").get("RequestingPhysician"),
                }
            )
        return data

    @classmethod
    def update_studies(cls, studies, server):
        """Update studies"""

        entries = cls.get_info_from_dicom(studies)
        updates = []
        for entry in entries:
            try:
                study = cls.search(
                    [("uuid", "=", entry["uuid"]), ("server", "=", server)], limit=1
                )[0]
                study.description = entry["description"]
                study.date = entry["date"]
                study.ident = entry["ident"]
                study.institution = entry["institution"]
                study.ref_phys = entry["ref_phys"]
                study.req_phys = entry["req_phys"]
                updates.append(study)
                logger.info("Updating study {}".format(entry["uuid"]))
            except:
                continue
                logger.warning("Unable to update study {}".format(entry["uuid"]))
        cls.save(updates)

    @classmethod
    def create_studies(cls, studies, server):
        """Create studies"""

        pool = Pool()
        Patient = pool.get("gnuhealth.orthanc.patient")

        entries = cls.get_info_from_dicom(studies)
        for entry in entries:
            try:
                patient = Patient.search(
                    [("uuid", "=", entry["parent_patient"]), ("server", "=", server)],
                    limit=1,
                )[0]
            except:
                patient = None
                logger.warning(
                    "No parent patient found for study {}".format(entry["ID"])
                )
            entry.pop("parent_patient")  # remove non-model entry
            entry["server"] = server
            entry["patient"] = patient
        cls.create(entries)
コード例 #11
0
ファイル: hba_loan.py プロジェクト: kakamble-aiims/work
class HouseBuildingLoan(Workflow, ModelSQL, ModelView):
    'House Building Loan'
    __name__ = 'hba.loan'

    salary_code = fields.Char('Salary Code',
                              states={
                                  'readonly': ~Eval('state').in_(['draft']),
                              },
                              depends=['state'],
                              required=True)
    employee = fields.Many2One('company.employee',
                               'Name of Applicant',
                               states={
                                   'readonly': ~Eval('state').in_(['draft']),
                               },
                               depends=['state'],
                               required=True)
    designation = fields.Many2One("employee.designation",
                                  "Designation",
                                  states={
                                      'readonly':
                                      ~Eval('state').in_(['draft']),
                                  },
                                  depends=['state'],
                                  required=True)
    department = fields.Many2One("company.department",
                                 "Department",
                                 states={
                                     'readonly': ~Eval('state').in_(['draft']),
                                 },
                                 depends=['state'],
                                 required=True)
    post_held = fields.Selection([
        ('permanent', 'Permanent'), ('temporary_offg', 'Temporary/Offg'),
        ('length_of_service', 'Length of service on the date of application')
    ],
                                 string='Post held',
                                 sort=False,
                                 states={
                                     'readonly': ~Eval('state').in_(['draft']),
                                 },
                                 depends=['state'],
                                 required=True)
    place_of_posting = fields.Char('Place of Posting',
                                   states={
                                       'readonly':
                                       ~Eval('state').in_(['draft']),
                                   },
                                   depends=['state'],
                                   required=True)
    scale_pay = fields.Char('Scale Pay',
                            states={
                                'readonly': ~Eval('state').in_(['draft']),
                            },
                            depends=['state'],
                            required=True)
    pension_rule = fields.Selection([
        ('nps', 'NPS'),
        ('gpf', 'GPF'),
    ],
                                    string='Pension Rule',
                                    sort=False,
                                    states={
                                        'readonly':
                                        ~Eval('state').in_(['draft']),
                                    },
                                    depends=['state'],
                                    required=True)
    retirement_date = fields.Date('Date of Retirement', required=True)
    advance = fields.Selection(
        [('yes', 'Yes'), ('no', 'No')],
        string='Any Other advance/Final withdrawal taken\
        for purchase of land/construction',
        sort=False,
        required=True)
    advance_needed = fields.Selection(
        [('plot', 'Purchase of Plot'),
         ('construction', 'Construction of new House'),
         ('enlarging_house', 'Enlarging existing House'),
         ('ready_built', 'Purchase of Ready Built House'),
         ('own_house', 'Own House')],
        string='Advance Needed for',
        sort=False,
        required=True)
    advance_amount = fields.Float('Amount',
                                  states={
                                      'invisible':
                                      ~Eval('advance').in_(['yes']),
                                  },
                                  depends=['advance'])
    source = fields.Char('Source',
                         states={
                             'invisible': ~Eval('advance').in_(['yes']),
                         },
                         depends=['advance'])
    attest_copy = fields.Many2One('ir.attachment',
                                  'attested Copy',
                                  states={
                                      'invisible':
                                      ~Eval('advance').in_(['yes']),
                                  },
                                  depends=['advance'])
    location_address = fields.Char(
        'Location with Address',
        states={
            'invisible':
            ~Eval('advance_needed').in_(['plot', 'enlarging_house']),
        },
        depends=['advance_needed'])
    location_type = fields.Selection([
        ('rural', 'Rural'),
        ('urbun', 'Urban'),
    ],
                                     string='Location Type',
                                     sort=False,
                                     states={
                                         'invisible':
                                         ~Eval('advance_needed').in_(['plot']),
                                     },
                                     depends=['advance_needed'])
    clearly = fields.Selection([('yes', 'Yes'), ('no', 'No')],
                               string='Is it Clearly Demacrated & Developed',
                               sort=False,
                               states={
                                   'invisible':
                                   ~Eval('advance_needed').in_(['plot']),
                               },
                               depends=['advance_needed'])
    area = fields.Float('Apporximate area(in sq.mts.)',
                        states={
                            'invisible': ~Eval('advance_needed').in_(['plot']),
                        },
                        depends=['advance_needed'])
    cost = fields.Float('cost',
                        states={
                            'invisible': ~Eval('advance_needed').in_(['plot']),
                        },
                        depends=['advance_needed'])
    amount = fields.Float('Amount actually paid',
                          states={
                              'invisible':
                              ~Eval('advance_needed').in_(['plot']),
                          },
                          depends=['advance_needed'])
    acquired = fields.Char('If not Purchase when proposed to be acquired',
                           states={
                               'invisible':
                               ~Eval('advance_needed').in_(['plot']),
                           },
                           depends=['advance_needed'])
    unexpired = fields.Char('Unexpired portion of lease if not free hold',
                            states={
                                'invisible':
                                ~Eval('advance_needed').in_(['plot']),
                            },
                            depends=['advance_needed'])
    amount_required = fields.Float('Amount of advance required', required=True)
    installment_no = fields.Integer('No. of instalments for repayment',
                                    required=True)
    construction = fields.One2Many(
        'construction',
        'hba_loan',
        'Construction',
        states={
            'invisible': ~Eval('advance_needed').in_(['construction']),
        },
        depends=['advance_needed'])
    floor = fields.Integer('Floor-wise area to be constructed')
    plinth_area = fields.Float('Plinth area(in sq.mtrs.')
    enlargement = fields.Float(
        'Plinth area proposed for enlargement(in sq. mtrs.)')
    cunstr_cost = fields.Float('Construction Cost')
    enlargement_cost = fields.Float('Cost of proposed enlargement')
    total_plinth = fields.Float('Total Plinth area')
    total_cost = fields.Float('Total Cost')
    constructed = fields.Date('When Constructed')
    price_settled = fields.Float('Price Settled')
    agency = fields.Char('The Agency from whom to be purchased')
    already_paid = fields.Float('Already paid')
    to_be_paid = fields.Float('To be Paid')
    own_house = fields.One2Many('own.house',
                                'hba_loan',
                                'Own House',
                                states={
                                    'invisible':
                                    ~Eval('advance_needed').in_(['own_house']),
                                },
                                depends=['advance_needed'])
    loan_line = fields.One2Many('hba.loan.line',
                                'loan',
                                'Installment Lines',
                                readonly=True)
    payout = fields.Float('Payout',
                          states={
                              'readonly': ~Eval('state').in_(['draft']),
                              'invisible': ~Eval('refund').in_(['refundable']),
                          },
                          depends=['state'])
    pending = fields.Float('Pending',
                           states={
                               'readonly': ~Eval('state').in_(['draft']),
                               'invisible':
                               ~Eval('refund').in_(['refundable']),
                           },
                           depends=['state'])
    reschedule = fields.Float('Reschedule',
                              states={
                                  'readonly': ~Eval('state').in_(['draft']),
                                  'invisible':
                                  ~Eval('refund').in_(['refundable']),
                              },
                              depends=['state'])
    state = fields.Selection([('draft', 'Draft'),
                              ('forwarded_to_jo', 'Forwarded to JO'),
                              ('forwarded_to_ao', 'Forwarded to AO'),
                              ('approve', 'Approved'), ('cancel', 'Cancel')],
                             'Status',
                             readonly=True,
                             sort=False)
    cancel_reason = fields.Char(
        'Cancel Reason',
        states={
            'invisible': ~Eval('state').in_(['forwarded_to_ao', 'cancel']),
            'readonly': ~Eval('state').in_(['forwarded_to_ao']),
        },
        depends=['state'],
    )
    check = fields.Boolean('Check',
                           states={
                               'invisible':
                               Eval('state').in_([
                                   'draft', 'forwarded_to_ao',
                                   'forwarded_to_jo', 'approve', 'cancel'
                               ]),
                           },
                           depends=['state'])

    @staticmethod
    def default_state():
        return 'draft'

    @staticmethod
    def default_employee():
        pool = Pool()
        User = pool.get('res.user')
        user = User(Transaction().user)
        employee = user.employee
        return employee.id if employee else None

    @staticmethod
    def default_salary_code():
        pool = Pool()
        User = pool.get('res.user')
        user = User(Transaction().user)
        employee = user.employee
        return employee.salary_code if employee else None

    @staticmethod
    def default_designation():
        pool = Pool()
        User = pool.get('res.user')
        user = User(Transaction().user)
        employee = user.employee
        return employee.designation.id if employee.designation else None

    @staticmethod
    def default_department():
        pool = Pool()
        User = pool.get('res.user')
        user = User(Transaction().user)
        employee = user.employee
        return employee.department.id if employee.department else None

    @staticmethod
    def default_pay_in_band():
        pool = Pool()
        User = pool.get('res.user')
        user = User(Transaction().user)
        employee = user.employee
        return employee.pay_in_band if employee else None

    @staticmethod
    def default_pension_rule():
        pool = Pool()
        User = pool.get('res.user')
        user = User(Transaction().user)
        employee = user.employee
        return employee.gpf_nps if employee else None

    @classmethod
    def validate(cls, records):
        """Method to validate records(rows) in a model(table)"""
        super().validate(records)
        for record in records:
            house_loan = cls.search([('id', '!=', record.id),
                                     ('employee', '=', record.employee),
                                     ('state', '=', 'approve')])
            if house_loan:
                cls.raise_user_error('You have alraedy take house loan')

    @classmethod
    def view_attributes(cls):
        """Define states for attributes in form view"""
        plot = ~Eval('advance_needed').in_(['plot'])
        construction = ~Eval('advance_needed').in_(['construction'])
        enlarging_house = ~Eval('advance_needed').in_(['enlarging_house'])
        ready_built = ~Eval('advance_needed').in_(['ready_built'])
        own_house = ~Eval('advance_needed').in_(['own_house'])

        attribute = [
            ("//page[@id='plot']", "states", {
                "invisible": plot
            }),
            ("//page[@id='construction']", "states", {
                "invisible": construction
            }),
            ("//page[@id='existing_house']", "states", {
                "invisible": enlarging_house
            }),
            ("//page[@id='build_house']", "states", {
                "invisible": ready_built
            }),
            ("//page[@id='own_house']", "states", {
                "invisible": own_house
            }),
        ]
        return attribute

    @fields.depends('employee')
    def on_change_employee(self, name=None):
        if self.employee:
            self.salary_code = self.employee.salary_code
            self.designation = self.employee.designation
            self.department = self.employee.department
            self.pay_in_band = self.employee.pay_in_band
            if self.employee.gpf_nps:
                self.pension_rule = self.employee.gpf_nps

    @classmethod
    def __setup__(cls):
        """Setup workflow transitions and button properties
           when an instance of this class is initialized"""
        super().__setup__()
        cls._transitions |= set((
            ('draft', 'forwarded_to_jo'),
            ('forwarded_to_jo', 'forwarded_to_ao'),
            ('forwarded_to_ao', 'approve'),
            ('forwarded_to_ao', 'cancel'),
        ))
        cls._buttons.update({
            'calculate_instalment': {},
            'submitted_to_jo': {
                'invisible': ~Eval('state').in_(['draft']),
                'depends': ['state'],
            },
            'forward_to_jo': {
                'invisible': ~Eval('state').in_(['forwarded_to_jo']),
                'depends': ['state'],
            },
            'forward_to_ao': {
                'invisible': ~Eval('state').in_(['forwarded_to_ao']),
                'depends': ['state'],
            },
            'cancel': {
                'invisible': ~Eval('state').in_(['forwarded_to_ao']),
                'depends': ['state'],
            },
        })

    @classmethod
    def calculate_instalment(cls, records):
        for record in records:
            if record.check == False:
                cls.loan_installment(records)
                record.check = True
                record.save()

    @classmethod
    @ModelView.button
    @Workflow.transition('forwarded_to_jo')
    def submitted_to_jo(cls, records):
        """Change status of loan application to forwarded_to_jo"""
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('forwarded_to_ao')
    def forward_to_jo(cls, records):
        """Change status of loan application to forwarded_to_ao"""
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('approve')
    def forward_to_ao(cls, records):
        """Change status of loan application to approve"""
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('cancel')
    def cancel(cls, records):
        """Change status of loan application to cancel"""
        for record in records:
            if not record.cancel_reason:
                cls.raise_user_error('Please fill the Cancel reason')
        pass

    @classmethod
    def loan_installment(cls, records):
        """Calculate number of installments for loan"""
        count = 0
        LoanLine = Pool().get('hba.loan.line')
        for loan in records:
            amount = (loan.amount_required / loan.installment_no)
            for line in range(1, int(loan.installment_no) + 1):
                mydate = datetime.now().month
                month = mydate - 1
                if month + line > 12:
                    count += 1
                    if count > 12:
                        count = 1
                    months = datetime.now().date(1900, count, 1).strftime('%B')
                else:
                    months = datetime.now().date(1900, month + line,
                                                 1).strftime('%B')
                vals = {
                    'month': months,
                    'amount': amount,
                    'status': 'pending',
                    'loan': loan.id
                }
                line = LoanLine.create([vals])

    @classmethod
    def write(cls, *args):
        """ Override default write method of model """
        actions = iter(args)
        for mechanisms, values in zip(actions, actions):
            if 'installment_no' in values.keys(
            ) or 'amount_required' in values.keys():
                cls.change_loan_installment(mechanisms, values)
        super().write(*args)

    @classmethod
    def change_loan_installment(cls, records, values):
        """Change number of installments pending for loan"""
        cursor = Transaction().connection.cursor()
        LoanLine = Pool().get('hba.loan.line')
        amount = 0
        for loan in records:
            cursor.execute(
                'SELECT sum(amount) FROM hba_loan_line \
                WHERE loan=%s AND status != %s', (loan.id, 'pending'))
            total_amount = cursor.fetchone()
            if total_amount[0]:
                reschedule = loan.amount_required - total_amount[0]
                cls.write(records, {
                    'payout': total_amount[0],
                    'reschedule': reschedule
                })
                amount = (reschedule / values['installment_no'])
            else:
                if 'installment_no' in values.keys():
                    amount = (loan.amount_required / values['installment_no'])
                elif 'amount_required' in values.keys():
                    amount = (values['amount_required'] / loan.installment_no)
                elif 'installment_no' in values.keys(
                ) and 'amount_required' in values.keys():
                    amount = (values['amount_required'] /
                              values['installment_no'])
            cursor.execute(
                'delete FROM hba_loan_line WHERE loan=%s \
            AND status = %s', (loan.id, 'pending'))
            count = 0
            installment_no = 0
            if 'installment_no' in values.keys():
                installment_no = values['installment_no']
            else:
                installment_no = loan.installment_no
            for line in range(1, int(installment_no) + 1):
                mydate = datetime.now().month
                if total_amount[0]:
                    month = mydate
                else:
                    month = mydate - 1
                if month + line > 12:
                    count += 1
                    if count > 12:
                        count = 1
                    months = datetime(1900, count, 1).date().strftime('%B')
                else:
                    months = datetime(1900, month + line,
                                      1).date().strftime('%B')
                vals = {
                    'month': months,
                    'amount': amount,
                    'status': 'pending',
                    'loan': loan.id
                }
                line = LoanLine.create([vals])
コード例 #12
0
ファイル: health_orthanc.py プロジェクト: mdn57/health
class OrthancPatient(ModelSQL, ModelView):
    """Orthanc patient information"""

    __name__ = "gnuhealth.orthanc.patient"

    patient = fields.Many2One(
        "gnuhealth.patient", "Patient", help="Local linked patient"
    )
    name = fields.Char("PatientName", readonly=True)
    bd = fields.Date("Birthdate", readonly=True)
    ident = fields.Char("PatientID", readonly=True)
    uuid = fields.Char("PatientUUID", readonly=True, required=True)
    studies = fields.One2Many(
        "gnuhealth.orthanc.study", "patient", "Studies", readonly=True
    )
    server = fields.Many2One("gnuhealth.orthanc.config", "Server", readonly=True)
    link = fields.Function(
        fields.Char("URL", help="Link to patient in Orthanc Explorer"), "get_link"
    )

    def get_link(self, name):
        pre = "".join([self.server.domain.rstrip("/"), "/"])
        add = "app/explorer.html#patient?uuid={}".format(self.uuid)
        return urljoin(pre, add)

    @classmethod
    def __setup__(cls):
        super().__setup__()
        t = cls.__table__()
        cls._sql_constraints = [
            (
                "uuid_unique",
                Unique(t, t.server, t.uuid),
                "UUID must be unique for a given server",
            )
        ]

    @staticmethod
    def get_info_from_dicom(patients):
        """Extract information for writing to database"""

        data = []
        for patient in patients:
            try:
                bd = datetime.strptime(
                    patient["MainDicomTags"]["PatientBirthDate"], "%Y%m%d"
                ).date()
            except:
                bd = None
            data.append(
                {
                    "name": patient.get("MainDicomTags").get("PatientName"),
                    "bd": bd,
                    "ident": patient.get("MainDicomTags").get("PatientID"),
                    "uuid": patient.get("ID"),
                }
            )
        return data

    @classmethod
    def update_patients(cls, patients, server):
        """Update patients"""

        Patient = pool.get("gnuhealth.patient")

        entries = cls.get_info_from_dicom(patients)
        updates = []
        for entry in entries:
            try:
                patient = cls.search(
                    [("uuid", "=", entry["uuid"]), ("server", "=", server)], limit=1
                )[0]
                patient.name = entry["name"]
                patient.bd = entry["bd"]
                patient.ident = entry["ident"]
                if not patient.patient:  # don't update unless no patient attached
                    try:
                        g_patient = Patient.search(
                            [("puid", "=", entry["ident"])], limit=1
                        )[0]
                        patient.patient = g_patient
                        logger.info(
                            "New Matching PUID found for {}".format(entry["ident"])
                        )
                    except:
                        pass
                updates.append(patient)
                logger.info("Updating patient {}".format(entry["uuid"]))
            except:
                continue
                logger.warning("Unable to update patient {}".format(entry["uuid"]))
        cls.save(updates)

    @classmethod
    def create_patients(cls, patients, server):
        """Create patients"""

        pool = Pool()
        Patient = pool.get("gnuhealth.patient")

        entries = cls.get_info_from_dicom(patients)
        for entry in entries:
            try:
                g_patient = Patient.search([("puid", "=", entry["ident"])], limit=1)[0]
                logger.info("Matching PUID found for {}".format(entry["uuid"]))
            except:
                g_patient = None
            entry["server"] = server
            entry["patient"] = g_patient
        cls.create(entries)
コード例 #13
0
class PurchaseRequest(ModelSQL, ModelView):
    'Purchase Request'
    __name__ = 'purchase.request'

    product = fields.Many2One('product.product',
                              'Product',
                              required=True,
                              select=True,
                              readonly=True,
                              domain=[('purchasable', '=', True)])
    party = fields.Many2One('party.party',
                            'Party',
                            select=True,
                            states=STATES,
                            depends=DEPENDS)
    quantity = fields.Float('Quantity',
                            required=True,
                            states=STATES,
                            digits=(16, Eval('uom_digits', 2)),
                            depends=DEPENDS + ['uom_digits'])
    uom = fields.Many2One('product.uom',
                          'UOM',
                          required=True,
                          select=True,
                          states=STATES,
                          depends=DEPENDS)
    uom_digits = fields.Function(fields.Integer('UOM Digits'),
                                 'on_change_with_uom_digits')
    computed_quantity = fields.Float('Computed Quantity', readonly=True)
    computed_uom = fields.Many2One('product.uom',
                                   'Computed UOM',
                                   readonly=True)
    purchase_date = fields.Date('Best Purchase Date', readonly=True)
    supply_date = fields.Date('Expected Supply Date', readonly=True)
    default_uom_digits = fields.Function(fields.Integer('Default UOM Digits'),
                                         'on_change_with_default_uom_digits')
    stock_level = fields.Float('Stock at Supply Date',
                               readonly=True,
                               digits=(16, Eval('default_uom_digits', 2)),
                               depends=['default_uom_digits'])
    warehouse = fields.Many2One('stock.location',
                                "Warehouse",
                                states={
                                    'required': Eval('warehouse_required',
                                                     False),
                                },
                                domain=[('type', '=', 'warehouse')],
                                depends=['warehouse_required'],
                                readonly=True)
    warehouse_required = fields.Function(fields.Boolean('Warehouse Required'),
                                         'get_warehouse_required')
    purchase_line = fields.Many2One('purchase.line',
                                    'Purchase Line',
                                    readonly=True)
    purchase = fields.Function(fields.Many2One('purchase.purchase',
                                               'Purchase'),
                               'get_purchase',
                               searcher='search_purchase')
    company = fields.Many2One('company.company',
                              'Company',
                              required=True,
                              readonly=True,
                              domain=[
                                  ('id',
                                   If(In('company', Eval('context', {})), '=',
                                      '!='), Eval('context',
                                                  {}).get('company', -1)),
                              ])
    origin = fields.Reference('Origin',
                              selection='get_origin',
                              readonly=True,
                              required=True)
    exception_ignored = fields.Boolean('Ignored Exception')
    state = fields.Function(fields.Selection([
        ('purchased', 'Purchased'),
        ('done', 'Done'),
        ('draft', 'Draft'),
        ('cancel', 'Cancel'),
        ('exception', 'Exception'),
    ], 'State'),
                            'get_state',
                            searcher='search_state')

    @classmethod
    def __setup__(cls):
        super(PurchaseRequest, cls).__setup__()
        cls._order[0] = ('id', 'DESC')
        cls._error_messages.update({
            'create_request': ('Purchase requests are only created '
                               'by the system.'),
            'delete_purchase_line': ('You can not delete purchased '
                                     'request.'),
        })
        cls._buttons.update({
            'handle_purchase_cancellation_exception': {
                'invisible': Eval('state') != 'exception',
            },
        })

    @classmethod
    def __register__(cls, module_name):
        pool = Pool()
        ModelData = pool.get('ir.model.data')
        TableHandler = backend.get('TableHandler')
        model_data = ModelData.__table__()
        super(PurchaseRequest, cls).__register__(module_name)

        # Migration from 3.6: removing the constraint on the quantity
        tablehandler = TableHandler(cls, module_name)
        tablehandler.drop_constraint('check_purchase_request_quantity')

        # Migration from 3.8: renaming module of Purchase Request group entry
        cursor = Transaction().connection.cursor()
        cursor.execute(*model_data.update(
            columns=[model_data.module],
            values=['purchase_request'],
            where=((model_data.fs_id == 'group_purchase_request')
                   & (model_data.module == 'stock_supply'))))

    def get_rec_name(self, name):
        if self.warehouse:
            return "%s@%s" % (self.product.name, self.warehouse.name)
        else:
            return self.product.name

    @classmethod
    def search_rec_name(cls, name, clause):
        res = []
        names = clause[2].split('@', 1)
        res.append(('product.template.name', clause[1], names[0]))
        if len(names) != 1 and names[1]:
            res.append(('warehouse', clause[1], names[1]))
        return res

    @staticmethod
    def default_company():
        return Transaction().context.get('company')

    @staticmethod
    def default_exception_ignored():
        return False

    def get_purchase(self, name):
        if self.purchase_line:
            return self.purchase_line.purchase.id

    @classmethod
    def search_purchase(cls, name, clause):
        return [('purchase_line.purchase', ) + tuple(clause[1:])]

    @property
    def currency(self):
        return self.company.currency

    def get_state(self, name):
        if self.purchase_line:
            if (self.purchase_line.purchase.state == 'cancel'
                    and not self.exception_ignored):
                return 'exception'
            elif self.purchase_line.purchase.state == 'cancel':
                return 'cancel'
            elif self.purchase_line.purchase.state == 'done':
                return 'done'
            else:
                return 'purchased'
        return 'draft'

    @classmethod
    def search_state(cls, name, clause):
        pool = Pool()
        Purchase = pool.get('purchase.purchase')
        PurchaseLine = pool.get('purchase.line')

        request = cls.__table__()
        purchase_line = PurchaseLine.__table__()
        purchase = Purchase.__table__()

        _, operator_, state = clause
        Operator = fields.SQL_OPERATORS[operator_]
        state_case = Case(
            ((purchase.state == 'cancel')
             & (request.exception_ignored == False), 'exception'),
            ((purchase.state == 'cancel')
             & (request.exception_ignored == True), 'cancel'),
            (purchase.state == 'done', 'done'),
            (request.purchase_line != Null, 'purchased'),
            else_='draft')
        state_query = request.join(
            purchase_line,
            type_='LEFT',
            condition=request.purchase_line == purchase_line.id).join(
                purchase,
                type_='LEFT',
                condition=purchase_line.purchase == purchase.id).select(
                    request.id, where=Operator(state_case, state))

        return [('id', 'in', state_query)]

    def get_warehouse_required(self, name):
        return self.product.type in ('goods', 'assets')

    @fields.depends('uom')
    def on_change_with_uom_digits(self, name=None):
        if self.uom:
            return self.uom.digits
        return 2

    @fields.depends('product')
    def on_change_with_default_uom_digits(self, name=None):
        if self.product:
            return self.product.default_uom.digits
        return 2

    @classmethod
    def _get_origin(cls):
        'Return the set of Model names for origin Reference'
        return set()

    @classmethod
    def get_origin(cls):
        pool = Pool()
        IrModel = pool.get('ir.model')
        models = IrModel.search([
            ('model', 'in', list(cls._get_origin())),
        ])
        return [(m.model, m.name) for m in models]

    @classmethod
    def create(cls, vlist):
        for vals in vlist:
            for field_name in ('product', 'quantity', 'uom', 'company'):
                if vals.get(field_name) is None:
                    cls.raise_user_error('create_request')
        return super(PurchaseRequest, cls).create(vlist)

    @classmethod
    def delete(cls, requests):
        if any(r.purchase_line for r in requests):
            cls.raise_user_error('delete_purchase_line')
        super(PurchaseRequest, cls).delete(requests)

    @classmethod
    def find_best_supplier(cls, product, date):
        '''
        Return the best supplier and purchase_date for the product.
        '''
        Date = Pool().get('ir.date')

        supplier = None
        today = Date.today()
        for product_supplier in product.product_suppliers:
            supply_date = product_supplier.compute_supply_date(date=today)
            timedelta = date - supply_date
            if not supplier and timedelta >= datetime.timedelta(0):
                supplier = product_supplier.party
                break

        if supplier:
            purchase_date = product_supplier.compute_purchase_date(date)
        else:
            purchase_date = today
        return supplier, purchase_date

    @classmethod
    @ModelView.button_action(
        'purchase_request.wizard_purchase_cancellation_handle_exception')
    def handle_purchase_cancellation_exception(cls, purchases):
        pass
コード例 #14
0
class HealthService(ModelSQL, ModelView):
    'Health Service'
    __name__ = 'gnuhealth.health_service'

    STATES = {'readonly': Eval('state') == 'invoiced'}

    name = fields.Char('ID', readonly=True)
    desc = fields.Char('Description')
    patient = fields.Many2One('gnuhealth.patient',
                              'Patient',
                              required=True,
                              states=STATES)
    institution = fields.Many2One('gnuhealth.institution', 'Institution')

    service_date = fields.Date('Date')
    service_line = fields.One2Many('gnuhealth.health_service.line',
                                   'name',
                                   'Service Line',
                                   help="Service Line")
    state = fields.Selection([
        ('draft', 'Draft'),
        ('invoiced', 'Invoiced'),
    ],
                             'State',
                             readonly=True)
    invoice_to = fields.Many2One('party.party', 'Invoice to')

    @classmethod
    def __setup__(cls):
        super(HealthService, cls).__setup__()

        t = cls.__table__()
        cls._sql_constraints = [
            ('name_unique', Unique(t,
                                   t.name), 'The Service ID must be unique'),
        ]
        cls._buttons.update({
            'button_set_to_draft': {
                'invisible': Equal(Eval('state'), 'draft')
            }
        })

    @staticmethod
    def default_state():
        return 'draft'

    @staticmethod
    def default_service_date():
        return datetime.date.today()

    @staticmethod
    def default_institution():
        HealthInst = Pool().get('gnuhealth.institution')
        institution = HealthInst.get_institution()
        return institution

    @classmethod
    @ModelView.button
    def button_set_to_draft(cls, services):
        cls.write(services, {'state': 'draft'})

    @classmethod
    def create(cls, vlist):
        Sequence = Pool().get('ir.sequence')
        Config = Pool().get('gnuhealth.sequences')

        vlist = [x.copy() for x in vlist]
        for values in vlist:
            if not values.get('name'):
                config = Config(1)
                values['name'] = Sequence.get_id(
                    config.health_service_sequence.id)
        return super(HealthService, cls).create(vlist)
コード例 #15
0
class Party:
    __name__ = 'party.party'
    vat_number_city = fields.Char('VAT Number City',
                                  states={'readonly': ~Eval('active', True)})
    type_document = fields.Selection([
        ('', ''),
        ('04', 'RUC'),
        ('05', 'Cedula'),
        ('06', 'Pasaporte'),
        ('07', 'Consumidor Final'),
    ],
                                     'Type Document',
                                     states={
                                         'readonly': ~Eval('active', True),
                                     },
                                     depends=['active'])
    mandatory_accounting = fields.Selection([
        ('yes', 'Yes'),
        ('no', 'No'),
    ],
                                            'Mandatory Accounting',
                                            required=False)
    first_name = fields.Char('Primer Nombre')
    second_name = fields.Char('Segundo Nombre')
    first_family_name = fields.Char('Primer Apellido')
    second_family_name = fields.Char('Segundo Apellido')
    commercial_name = fields.Char('Commercial Name')
    type_party = fields.Selection(
        [
            ('', ''),
            ('sociedad', 'Sociedad'),
            ('persona_natural', 'Personal natural'),
            ('contribuyente_especial', 'Contribuyente especial'),
            ('entidad_publica', 'Entidad del sector publico'),
            ('companias_seguros', 'Companias de aseguros y reaseguros'),
        ],
        'Type Party',
        states={
            'readonly': ~Eval('active', True),
            'invisible': Eval('type_document') != '04',
        })
    registro_mercantil = fields.Char(
        'Registro Mercantil', states={'readonly': ~Eval('active', True)})
    start_activities = fields.Date('Start Activities')

    @classmethod
    def __setup__(cls):
        super(Party, cls).__setup__()
        cls._error_messages.update(
            {'invalid_vat_number': ('Invalid VAT Number "%s".')})
        cls._sql_constraints += [
            ('vat_number', 'UNIQUE(vat_number)', 'VAT Number already exists!'),
        ]

    @staticmethod
    def default_type_document():
        return '04'

    @staticmethod
    def default_mandatory_accounting():
        return 'no'

    @classmethod
    def search_rec_name(cls, name, clause):
        parties = cls.search([
            ('vat_number', ) + tuple(clause[1:]),
        ], limit=1)
        if parties:
            return [('vat_number', ) + tuple(clause[1:])]
        return [('name', ) + tuple(clause[1:])]

    @classmethod
    def validate(cls, parties):
        for party in parties:
            if party.type_document == '04' and bool(party.vat_number):
                super(Party, cls).validate(parties)

    def pre_validate(self):
        if not self.vat_number:
            return
        if self.vat_number == '9999999999999':
            return
        vat_number = self.vat_number.replace(".", "")
        if vat_number.isdigit() and len(vat_number) > 9:
            is_valid = self.compute_check_digit(vat_number)
            if is_valid:
                return
        self.raise_user_error('invalid_vat_number', (self.vat_number, ))

    def compute_check_digit(self, raw_number):
        "Compute the check digit - Modulus 10 and 11"
        factor = 2
        x = 0
        set_check_digit = None
        if self.type_document == '04':
            # Si es RUC valide segun el tipo de tercero
            if self.type_party == 'persona_natural':
                if len(raw_number) != 13 or int(
                        raw_number[2]) > 5 or raw_number[-3:] != '001':
                    return
                number = raw_number[:9]
                set_check_digit = raw_number[9]
                for n in number:
                    y = int(n) * factor
                    if y >= 10:
                        y = int(str(y)[0]) + int(str(y)[1])
                    x += y
                    if factor == 2:
                        factor = 1
                    else:
                        factor = 2
                res = (x % 10)
                if res == 0:
                    value = 0
                else:
                    value = 10 - (x % 10)
            elif self.type_party == 'entidad_publica':
                if not len(raw_number) == 13 or raw_number[2] != '6' \
                    or raw_number[-3:] != '001':
                    return
                number = raw_number[:8]
                set_check_digit = raw_number[8]
                for n in reversed(number):
                    x += int(n) * factor
                    factor += 1
                    if factor == 8:
                        factor = 2
                value = 11 - (x % 11)
                if value == 11:
                    value = 0
            else:
                if len(raw_number) != 13 or \
                    (self.type_party in ['sociedad', 'companias_seguros'] \
                    and int(raw_number[2]) != 9) or raw_number[-3:] != '001':
                    return
                number = raw_number[:9]
                set_check_digit = raw_number[9]
                for n in reversed(number):
                    x += int(n) * factor
                    factor += 1
                    if factor == 8:
                        factor = 2
                value = 11 - (x % 11)
                if value == 11:
                    value = 0
        else:
            #Si no tiene RUC valide: cedula, pasaporte, consumidor final (cedula)
            if len(raw_number) != 10:
                return
            number = raw_number[:9]
            set_check_digit = raw_number[9]
            for n in number:
                y = int(n) * factor
                if y >= 10:
                    y = int(str(y)[0]) + int(str(y)[1])
                x += y
                if factor == 2:
                    factor = 1
                else:
                    factor = 2
            res = (x % 10)
            if res == 0:
                value = 0
            else:
                value = 10 - (x % 10)
        return (set_check_digit == str(value))
コード例 #16
0
class Work(DeactivableMixin, ModelSQL, ModelView):
    'Work'
    __name__ = 'timesheet.work'
    name = fields.Char('Name',
                       states={
                           'invisible': Bool(Eval('origin')),
                           'required': ~Eval('origin'),
                       },
                       depends=['origin'],
                       help="The main identifier of the work.")
    origin = fields.Reference(
        'Origin',
        selection='get_origin',
        states={
            'invisible': Bool(Eval('name')),
            'required': ~Eval('name'),
        },
        depends=['name'],
        help="Use to relate the time spent to other records.")
    duration = fields.Function(
        fields.TimeDelta('Timesheet Duration',
                         'company_work_time',
                         help="Total time spent on this work."),
        'get_duration')
    timesheet_start_date = fields.Date(
        'Timesheet Start',
        domain=[
            If(
                Eval('timesheet_start_date') & Eval('timesheet_end_date'),
                ('timesheet_start_date', '<=', Eval('timesheet_end_date')),
                ()),
        ],
        depends=['timesheet_end_date'],
        help="Restrict adding lines before the date.")
    timesheet_end_date = fields.Date(
        'Timesheet End',
        domain=[
            If(
                Eval('timesheet_start_date') & Eval('timesheet_end_date'),
                ('timesheet_end_date', '>=', Eval('timesheet_start_date')),
                ()),
        ],
        depends=['timesheet_start_date'],
        help="Restrict adding lines after the date.")
    company = fields.Many2One('company.company',
                              'Company',
                              required=True,
                              select=True,
                              help="Make the work belong to the company.")
    timesheet_lines = fields.One2Many('timesheet.line',
                                      'work',
                                      'Timesheet Lines',
                                      depends=['active'],
                                      states={
                                          'readonly':
                                          Not(Bool(Eval('active'))),
                                      },
                                      help="Spend time on this work.")
    # Self referring field to use for aggregation in graph view
    work = fields.Function(fields.Many2One('timesheet.work', 'Work'),
                           'get_work')

    @classmethod
    def __setup__(cls):
        super(Work, cls).__setup__()
        t = cls.__table__()
        cls._sql_constraints += [
            ('origin_unique', Unique(t, t.origin, t.company),
             'timesheet.msg_work_origin_unique_company'),
        ]

    @classmethod
    def __register__(cls, module_name):
        table_h = cls.__table_handler__(module_name)
        table = cls.__table__()
        cursor = Transaction().connection.cursor()

        super(Work, cls).__register__(module_name)

        # Migration from 4.0: remove required on name
        table_h.not_null_action('name', 'remove')

        # Migration from 4.0: remove parent, left and right
        if table_h.column_exist('parent'):
            id2name = {}
            id2parent = {}
            cursor.execute(*table.select(table.id, table.parent, table.name))
            for id_, parent, name in cursor:
                id2name[id_] = name
                id2parent[id_] = parent

            for id_, name in id2name.items():
                parent = id2parent[id_]
                while parent:
                    name = '%s\\%s' % (id2name[parent], name)
                    parent = id2parent[parent]
                cursor.execute(
                    *table.update([table.name], [name], where=table.id == id_))
            table_h.drop_column('parent')
        table_h.drop_column('left')
        table_h.drop_column('right')

        # Migration from 4.0: remove timesheet_available
        if table_h.column_exist('timesheet_available'):
            cursor.execute(*table.delete(
                where=table.timesheet_available == Literal(False)))
            table_h.drop_column('timesheet_available')

    @staticmethod
    def default_company():
        return Transaction().context.get('company')

    @classmethod
    def _get_origin(cls):
        'Return list of Model names for origin Reference'
        return []

    @classmethod
    def get_origin(cls):
        Model = Pool().get('ir.model')
        models = cls._get_origin()
        models = Model.search([
            ('model', 'in', models),
        ])
        return [('', '')] + [(m.model, m.name) for m in models]

    @classmethod
    def get_duration(cls, works, name):
        pool = Pool()
        Line = pool.get('timesheet.line')
        transaction = Transaction()
        cursor = transaction.connection.cursor()
        context = transaction.context

        table_w = cls.__table__()
        line = Line.__table__()
        ids = [w.id for w in works]
        durations = dict.fromkeys(ids, None)
        where = Literal(True)
        if context.get('from_date'):
            where &= line.date >= context['from_date']
        if context.get('to_date'):
            where &= line.date <= context['to_date']
        if context.get('employees'):
            where &= line.employee.in_(context['employees'])

        query_table = table_w.join(line,
                                   'LEFT',
                                   condition=line.work == table_w.id)

        for sub_ids in grouped_slice(ids):
            red_sql = reduce_ids(table_w.id, sub_ids)
            cursor.execute(*query_table.select(table_w.id,
                                               Sum(line.duration),
                                               where=red_sql & where,
                                               group_by=table_w.id))
            for work_id, duration in cursor.fetchall():
                # SQLite uses float for SUM
                if duration and not isinstance(duration, datetime.timedelta):
                    duration = datetime.timedelta(seconds=duration)
                durations[work_id] = duration
        return durations

    def get_work(self, name):
        return self.id

    def get_rec_name(self, name):
        if isinstance(self.origin, ModelStorage):
            return self.origin.rec_name
        else:
            return self.name

    @classmethod
    def search_rec_name(cls, name, clause):
        if clause[1].startswith('!') or clause[1].startswith('not '):
            bool_op = 'AND'
        else:
            bool_op = 'OR'
        return [
            bool_op,
            ('name', ) + tuple(clause[1:]),
        ] + [('origin.rec_name', ) + tuple(clause[1:]) + (origin, )
             for origin in cls._get_origin()]

    @classmethod
    def copy(cls, works, default=None):
        if default is None:
            default = {}
        else:
            default = default.copy()
        default.setdefault('timesheet_lines', None)
        return super(Work, cls).copy(works, default=default)

    @classmethod
    def validate(cls, works):
        super(Work, cls).validate(works)
        for work in works:
            if work.origin and not work._validate_company():
                raise CompanyValidationError(
                    gettext('timesheet.msg_work_company_different_origin',
                            work=work.rec_name))

    def _validate_company(self):
        return True

    @classmethod
    def search_global(cls, text):
        for record, rec_name, icon in super(Work, cls).search_global(text):
            icon = icon or 'tryton-clock'
            yield record, rec_name, icon

    @property
    def hours(self):
        if not self.duration:
            return 0
        return self.duration.total_seconds() / 60 / 60
コード例 #17
0
ファイル: planification.py プロジェクト: Kalenis/kalenislims
class PlanificationProfessionalLine(ModelSQL, ModelView):
    'Planification Professional Line'
    __name__ = 'lims.planification.professional.line'

    template = fields.Many2One('lims.template.analysis_sheet', 'Template')
    laboratory = fields.Many2One('lims.laboratory', 'Laboratory')
    professional = fields.Many2One('lims.laboratory.professional',
        'Professional')
    date = fields.Date('Date')
    state = fields.Selection([
        ('draft', 'Draft'),
        ('active', 'Active'),
        ('validated', 'Validated'),
        ('done', 'Done'),
        ], 'State')
    samples_qty = fields.Function(fields.Integer('# Samples'),
        'get_fields')
    completion_percentage = fields.Function(fields.Numeric('Complete',
        digits=(1, 4), domain=[
            ('completion_percentage', '>=', 0),
            ('completion_percentage', '<=', 1),
            ]),
        'get_fields')
    color = fields.Function(fields.Char('Color'), 'get_color')

    @classmethod
    def __setup__(cls):
        super().__setup__()
        cls._order.insert(0, ('date', 'ASC'))

    @classmethod
    def table_query(cls):
        pool = Pool()
        Sheet = pool.get('lims.analysis_sheet')
        Compilation = pool.get('lims.interface.compilation')
        sheet = Sheet.__table__()
        compilation = Compilation.__table__()

        context = Transaction().context
        where = Literal(True)
        if context.get('laboratory'):
            where &= sheet.laboratory == context.get('laboratory')
        if context.get('from_date'):
            where &= compilation.date_time >= datetime.combine(
                context.get('from_date'), time(0, 0))
        if context.get('to_date'):
            where &= compilation.date_time <= datetime.combine(
                context.get('to_date'), time(23, 59))

        columns = []
        for fname, field in cls._fields.items():
            if hasattr(field, 'set'):
                continue
            if fname == 'date':
                column = Cast(compilation.date_time, 'date').as_(fname)
            else:
                column = Column(sheet, fname).as_(fname)
            columns.append(column)
        return sheet.join(compilation,
            condition=sheet.compilation == compilation.id).select(*columns,
            where=where)

    @classmethod
    def get_fields(cls, records, name):
        pool = Pool()
        Sheet = pool.get('lims.analysis_sheet')

        sheets = Sheet.browse(records)
        return {s.id: getattr(s, name) for s in sheets}

    def get_color(self, name):
        return 'lightblue'
コード例 #18
0
ファイル: cms.py プロジェクト: alexbodn/nereid-cms
class Article(Workflow, ModelSQL, ModelView, CMSMenuItemMixin):
    "CMS Articles"
    __name__ = 'nereid.cms.article'
    _rec_name = 'uri'

    uri = fields.Char('URI', required=True, select=True, translate=True)
    title = fields.Char('Title', required=True, select=True, translate=True)
    content = fields.Text('Content', required=True, translate=True)
    template = fields.Char('Template', required=True)
    image = fields.Many2One('nereid.static.file', 'Image')
    employee = fields.Many2One('company.employee', 'Employee')
    author = fields.Many2One('nereid.user', 'Author')
    published_on = fields.Date('Published On')
    publish_date = fields.Function(fields.Char('Publish Date'),
                                   'get_publish_date')
    sequence = fields.Integer('Sequence', required=True, select=True)
    reference = fields.Reference('Reference', selection='allowed_models')
    description = fields.Text('Short Description')
    attributes = fields.One2Many('nereid.cms.article.attribute', 'article',
                                 'Attributes')
    categories = fields.Many2Many(
        'nereid.cms.category-article',
        'article',
        'category',
        'Categories',
    )
    content_type = fields.Selection('content_type_selection',
                                    'Content Type',
                                    required=True)
    # Article can have a banner
    banner = fields.Many2One('nereid.cms.banner', 'Banner')
    state = fields.Selection([('draft', 'Draft'), ('published', 'Published'),
                              ('archived', 'Archived')],
                             'State',
                             required=True,
                             select=True,
                             readonly=True)

    @classmethod
    def __setup__(cls):
        super(Article, cls).__setup__()
        cls._order.insert(0, ('sequence', 'ASC'))
        cls._transitions |= set((
            ('draft', 'published'),
            ('published', 'draft'),
            ('published', 'archived'),
            ('archived', 'draft'),
        ))
        cls._buttons.update({
            'archive': {
                'invisible': Eval('state') != 'published',
            },
            'publish': {
                'invisible': Eval('state').in_(['published', 'archived']),
            },
            'draft': {
                'invisible': Eval('state') == 'draft',
            }
        })

    @classmethod
    def content_type_selection(cls):
        """
        Returns a selection for content_type.
        """
        default_types = [('html', 'HTML'), ('plain', 'Plain Text')]

        if markdown:
            default_types.append(('markdown', 'Markdown'))
        if publish_parts:
            default_types.append(('rst', 'reStructured TeXT'))

        return default_types

    @classmethod
    def default_content_type(cls):
        """
        Default content_type.
        """
        return 'plain'

    def __html__(self):
        """
        Uses content_type field to generate html content.
        Concept from Jinja2's Markup class.
        """
        if self.content_type == 'rst':
            if publish_parts:
                res = publish_parts(self.content, writer_name='html')
                return res['html_body']
            self.raise_user_error(
                "`docutils` not installed, to render rst articles.")
        if self.content_type == 'markdown':
            if markdown:
                return markdown(self.content)
            self.raise_user_error(
                "`markdown` not installed, to render markdown article.")
        return self.content

    @classmethod
    @ModelView.button
    @Workflow.transition('archived')
    def archive(cls, articles):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('published')
    def publish(cls, articles):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('draft')
    def draft(cls, articles):
        pass

    @classmethod
    def allowed_models(cls):
        MenuItem = Pool().get('nereid.cms.menuitem')

        return MenuItem.allowed_models()

    @fields.depends('title', 'uri')
    def on_change_title(self):
        if self.title and not self.uri:
            self.uri = slugify(self.title)

    @staticmethod
    def default_template():
        return 'article.jinja'

    @staticmethod
    def default_employee():
        User = Pool().get('res.user')

        if 'employee' in Transaction().context:
            return Transaction().context['employee']

        user = User(Transaction().user)
        if user.employee:
            return user.employee.id

        if has_request_context() and current_user.employee:
            return current_user.employee.id

    @staticmethod
    def default_author():
        if has_request_context():
            return current_user.id

    @staticmethod
    def default_published_on():
        Date = Pool().get('ir.date')
        return Date.today()

    @classmethod
    @route('/article/<uri>')
    def render(cls, uri):
        """
        Renders the template
        """
        try:
            article, = cls.search([
                ('uri', '=', uri),
                ('state', '=', 'published'),
            ])
        except ValueError:
            abort(404)
        return render_template(article.template, article=article)

    @classmethod
    @route('/sitemaps/article-index.xml')
    def sitemap_index(cls):
        index = SitemapIndex(cls, [])
        return index.render()

    @classmethod
    @route('/sitemaps/article-<int:page>.xml')
    def sitemap(cls, page):
        sitemap_section = SitemapSection(cls, [], page)
        sitemap_section.changefreq = 'daily'
        return sitemap_section.render()

    @classmethod
    def get_publish_date(cls, records, name):
        """
        Return publish date to render on view
        """
        res = {}
        for record in records:
            res[record.id] = str(record.published_on)
        return res

    def get_absolute_url(self, **kwargs):
        return url_for('nereid.cms.article.render', uri=self.uri, **kwargs)

    @staticmethod
    def default_state():
        if 'published' in Transaction().context:
            return 'published'
        return 'draft'

    def get_menu_item(self, max_depth):
        """
        Return huge dictionary with serialized article category for menu item

        {
            title: <display name>,
            link: <url>,
            record: <instance of record>  # if type_ is `record`
        }
        """
        return {
            'record': self,
            'title': self.title,
            'link': self.get_absolute_url(),
        }

    def atom_id(self):
        """
        Returns an atom ID for the article
        """
        return ('tag:' + current_website.name + ',' + self.publish_date +
                ':Article/' + str(self.id))

    def atom_publish_date(self):
        """
        Returns the article's publish date with timezone set as UTC
        """
        return pytz.utc.localize(
            datetime.combine(self.published_on, datetime.min.time()))

    def serialize(self, purpose=None):
        """
        Serialize Article records
        """
        if purpose == 'atom':
            # The keys in the dictionary returned are used by Werkzeug's
            # AtomFeed class.
            return {
                'id':
                self.atom_id(),
                'title':
                self.title,
                'author': (self.author.serialize(
                    purpose=purpose) if self.author else None),
                'content':
                self.content,
                'content_type':
                ('text' if self.content_type == 'plain' else 'html'),
                'link': {
                    'rel': 'alternate',
                    'type': 'text/html',
                    'href': self.get_absolute_url(external=True),
                },
                'category': [
                    category.serialize(purpose=purpose)
                    for category in self.categories
                ],
                'published':
                self.atom_publish_date(),
                'updated':
                self.write_date or self.atom_publish_date(),
            }
        elif hasattr(super(Article, self), 'serialize'):
            return super(Article, self).serialize(purpose=purpose)

    @classmethod
    @route('/article/all.atom')
    def atom_feed(cls):
        """
        Renders the atom feed for all articles.
        """
        feed = AtomFeed("All Articles",
                        feed_url=request.url,
                        url=request.host_url)
        for article in cls.search([('state', '=', 'published')]):
            feed.add(**article.serialize(purpose='atom'))

        return feed.get_response()
コード例 #19
0
ファイル: hshn.py プロジェクト: jerome76/web-prototype
class Hshn(ModelSQL, ModelView):
    """ Class for business logic of the module hshn.
        The used fields, set deafult values,
        button actions and special logic for sending a mail are defined in the Class """
    __name__ = "hshn.hshn"
    company = fields.Many2One('company.company', 'Company', required=True,
        states={
            'readonly': (Eval('state') != 'draft') | Eval('lines', [0]),
            },
        domain=[
            ('id', If(Eval('context', {}).contains('company'), '=', '!='),
                Eval('context', {}).get('company', -1)),
            ],
        depends=['state'], select=True)

    topic = fields.Char('Topic', required=True, help='Please enter your topic')
    project_study_spo3 = fields.Selection([
        ('None', ''),
        ('SEPS', 'SEPS'),
        ('PSBWL', 'PSBWL'),
        ('PSWIN', 'PSWIN'),
        ('PSIT', 'PSIT'),
    ], 'Project study SPO3', states={
        'readonly': Eval('spo_selection') != 'SPO3',
        'required': Bool(Eval('spo_selection') != 'SPO4')
    }, help='Please select the project study for which you will submit the proposal'+
        '\n SEPS  = Project Study Software development EDV-No: 281531'+
        '\n PSBWL = Project Study BWL EDV-No:281542'+
        '\n PSWIN = Project Study economic computer science EDV-No: 281560'+
        '\n PSIT  = Project Study IT-Systems EDV-No:281584')
    project_study_spo4 = fields.Selection([
        ('None', ''),
        ('PSEIS', 'PSEIS'),
        ('PSEMU', 'PSEMU'),
        ('PSIT', 'PSIT'),
        ('PSAIS', 'PSAIS'),
        ('PSIM', 'PSIM'),
        ('PSSMU', 'PSSMU'),
        ('PSSMM', 'PSSMM'),
        ('PSSRM', 'PSSRM'),
    ], 'Project study SPO4', states={
        'readonly': Eval('spo_selection') != 'SPO4',
        'required': Bool(Eval('spo_selection') != 'SPO3')
    }, help='Please select the project study for which you will submit the proposal' +
        '\n PSEIS = Project Study Enterprise Information Systems EDV-No: 281761' +
        '\n PSEMU = Project Study Development mobile Enterprise Applications EDV-No:281760' +
        '\n PSIT  = Project Study IT-Systems EDV-No: 281765' +
        '\n PSAIS = Project Study Analytic Information Systems and Data Science EDV-No:281784' +
        '\n PSIM  = Project Study Information Management EDV-No: 281780' +
        '\n PSSMU = Project Study Social Media in enterprise context' +
        '\n PSSMM = Project Study Social Media Management and Audiovisual Communication EDV-No:281796' +
        '\n PSSRM = Project Study Social Relationship Management EDV-No:281790')
    description = fields.Text('Description', required=True, help='Please enter a detailed ' +
                                                                 'description of the topic \n Note: You can also add attachments')
    input_date = fields.Date('Date', readonly=True)
    like_count = fields.Integer('Like count', readonly=True)
    lecturer = fields.Many2One('party.party', 'Lecturer', required=True, select=True, )
    mail = fields.Boolean('Mail to lecturer', states={
        'readonly': Not(Bool(Eval('lecturer'))),
    }, help='Select the lecturer which you want to assign')
    spo_selection = fields.Selection([
        ('SPO3', 'SPO3'),
        ('SPO4', 'SPO4')
    ], 'SPO', help='Please select the SPO for which you will submit the proposal')

    @classmethod
    def default_like_count(cls):
        """Set the default value of the like_count field to 0.
        Because a new topic doesn't has likes"""
        return 0

    @classmethod
    def default_input_date(cls):
        """Set the default value of the input_date fied to the current date"""
        return datetime.date.today()

    @classmethod
    def default_spo_selection(cls):
        """Set the default value of the spo_selection fied to SPO3"""
        return 'SPO3'

    @classmethod
    def default_project_study_spo3(cls):
        """Set the default value of the project_study_spo3 fied to None.
        This is necessary because this field is required  and doesn't can be undefined"""
        return 'None'

    @classmethod
    def default_project_study_spo4(cls):
        """Set the default value of the project_study_spo4 fied to None.
        This is necessary because this field is required  and doesn't can be undefined"""
        return 'None'

    @classmethod
    def default_like_state(cls):
        """Set the default value of the state field to false"""
        return 'like'

    @staticmethod
    def default_company():
        return Transaction().context.get('company')

    def _get_like_btn(self):
        return {}

    def get_like_btn(self):
        return {}

    @classmethod
    def __setup__(cls):
        super(Hshn, cls).__setup__()
        """Initialize the like_btn"""
        cls._buttons.update({
            'like_btn': {
            }
            })

    @fields.depends('spo_selection')
    def on_change_spo_selection(self):
        """Change the value of the fields project_study_spo3 and project_study_spo4 to ''
        and None depending on which SPO was selectet in the spo_selection field.
        This is necessary for the required fields logic"""
        if self.spo_selection == 'SPO3':
            self.project_study_spo3 = ''
            self.project_study_spo4 = 'None'
        else:
            self.project_study_spo4 = ''
            self.project_study_spo3 = 'None'

    @classmethod
    @ModelView.button
    def like_btn(cls, records):
        """Defines the logic by clicking on the Button.
        Count up the field like_count by one and save the changes into the database.
        It also insets a row in the table hshn_user to save which user liked which topic.
        This will be needed for deactivating the like button and activation the dislike button"""

        pool = Pool()
        model_hshn = pool.get('hshn.hshn')

        # get the current user ID
        user_id = Transaction().user

        model_user = pool.get('hshn.user')

        for row in records:

            # check if user already liked the topic
            user_list = model_user.search([('create_uid', '=', user_id)])

            for user in user_list:
                if user.hshn_id is not None:
                    if row.id is user.hshn_id.id:
                        # topic already liked
                        return

            # save the liked topic to the user
            values2 = [{'id':user_id, 'hshn_id':row.id}]
            model_user.create(values2)

            # count up the likes
            if row.like_count is None:
                row.like_count = 1
            else:
                row.like_count += 1

        # Save the updatet record
        model_hshn.save(records)

        return 'reload'


    @classmethod
    def validate(cls, records_mail):
        """Check before saving if the field mail is selected(True) and send in this case the entered
        values via mail to the lecturer.
        The email will be send to all email addresses which are saved for the lecturer in
        party.contact_mechanism"""
        super(Hshn, cls)

        pool = Pool()
        model = pool.get('party.contact_mechanism')
        try:
            server = get_smtp_server()
        except :
            pass

        # get the record
        row = records_mail

        # Read in the mail content
        mail_content = {}
        file = open('../trytond/modules/hshn/mail.txt')
        for line in file:
            try:
                name, var = line.partition('=')
            except ValueError:
                continue
            mail_content[name.strip()] = var

        return
        # send a mail
        if row.mail is True:

            # set the spo
            if row.spo_selection == 'SPO3':
                project_study = row.project_study_spo3
            else:
                project_study = row.project_study_spo4

            # get the party of the selected lecturer
            records_contact = model.search([('party', '=', row.lecturer)])

            # send a mail to each mail address which is saved for the lecturer
            for row2 in records_contact:
                if row2.type == 'email':
                    try:
                        server.sendmail(mail_content['mail_address'], row2.value, mail_content['mail_message1'] +
                            str(row.lecturer.name) +
                            mail_content['mail_message2'] +
                            '\n'+cls.topic.string+': ' + str(row.topic) + '\n'+cls.description.string+': ' +
                            str(row.description) + '\n' + str(row.spo_selection) + mail_content['mail_message3'] +
                            str(project_study))
                    except:
                        pass

        # set mail to false
        row.mail = False
コード例 #20
0
class Service(Workflow, ModelSQL, ModelView):
    'Service'
    __name__ = 'service.service'
    __history = True
    company = fields.Many2One(
        'company.company',
        'Company',
        required=True,
        readonly=True,
        select=True,
        domain=[
            ('id', If(Eval('context', {}).contains('company'), '=',
                      '!='), Eval('context', {}).get('company', -1)),
        ],
        depends=_DEPENDS)
    party = fields.Many2One('party.party',
                            'Party',
                            states=_STATES,
                            required=True)
    number_service = fields.Char('No. Comprobante', readonly=True)
    type = fields.Selection(_TYPE,
                            'Type',
                            select=True,
                            states={
                                'readonly':
                                ((Eval('state') == 'delivered')
                                 | Eval('context', {}).get('type')),
                            })

    total = fields.Function(
        fields.Numeric('Total',
                       states={
                           'invisible': Eval('type') == 'home_service',
                       }), 'get_amount')

    entry_date = fields.Date('Entry Date',
                             states=_STATES,
                             domain=[('entry_date', '<',
                                      Eval('delivery_date', None))],
                             depends=['delivery_date'])
    delivery_date = fields.Date('Estimated Delivery Date',
                                states=_STATES,
                                domain=[('delivery_date', '>',
                                         Eval('entry_date', None))],
                                depends=['entry_date'])
    technical = fields.Many2One('company.employee',
                                'Technical',
                                states=_STATES)
    garanty = fields.Boolean('Garanty', help="Income Garanty", states=_STATES)
    new = fields.Boolean('New',
                         states={
                             'invisible': ~Eval('garanty', True),
                             'readonly': Eval('state') == 'delivered',
                         })
    lined = fields.Boolean('Lined',
                           states={
                               'invisible': ~Eval('garanty', True),
                               'readonly': Eval('state') == 'delivered',
                           })
    beaten = fields.Boolean('Beaten',
                            states={
                                'invisible': ~Eval('garanty', True),
                                'readonly': Eval('state') == 'delivered',
                            })
    broken = fields.Boolean('Broken',
                            states={
                                'invisible': ~Eval('garanty', True),
                                'readonly': Eval('state') == 'delivered',
                            })
    stained = fields.Boolean('Stained',
                             states={
                                 'invisible': ~Eval('garanty', True),
                                 'readonly': Eval('state') == 'delivered',
                             })
    invoice_date = fields.Date('Invoice Date',
                               states={
                                   'invisible': ~Eval('garanty', True),
                                   'readonly': Eval('state') == 'delivered',
                               })
    invoice_number = fields.Char('Invoice number',
                                 states={
                                     'invisible': ~Eval('garanty', True),
                                     'readonly': Eval('state') == 'delivered',
                                 })
    case_number = fields.Char('Case number',
                              states={
                                  'invisible': ~Eval('garanty', True),
                                  'readonly': Eval('state') == 'delivered',
                              })
    send_date = fields.Date('Send Date',
                            states={
                                'invisible': ~Eval('garanty', True),
                                'readonly': Eval('state') == 'delivered',
                            })
    remission = fields.Char('No. guide remission',
                            states={
                                'invisible': ~Eval('garanty', True),
                                'readonly': Eval('state') == 'delivered',
                            })
    transport = fields.Char('Transport',
                            states={
                                'invisible': ~Eval('garanty', True),
                                'readonly': Eval('state') == 'delivered',
                            })
    photo = fields.Binary('Foto', states=_STATES)
    state = fields.Selection([('pending', 'Pending'), ('review', 'In Review'),
                              ('ready', 'Ready'),
                              ('without', 'Without Solution'),
                              ('warranty', 'Warranty not cover'),
                              ('delivered', 'Delivered')],
                             'State',
                             readonly=True)
    lines = fields.One2Many('service.service.line',
                            'service',
                            'Lines',
                            states=_STATES)

    accessories = fields.Text('Accessories',
                              states={
                                  'readonly': Eval('accessories') != '',
                              })
    observations = fields.Text('Observations', states=_STATES)
    history_lines = fields.One2Many('service.service.history_lines', 'service',
                                    'Lines')
    total_home_service = fields.Numeric('Total',
                                        states={
                                            'invisible':
                                            Eval('type') == 'service',
                                        })

    detail = fields.Text('Repair Detail',
                         states={
                             'invisible': Eval('state') != 'delivered',
                             'readonly': Eval('detail') != '',
                         })
    state_date = fields.Function(fields.Char('State Date'), 'get_state_date')

    equipo = fields.Char('Equipo')
    marca = fields.Char('Marca')
    modelo = fields.Char('Modelo')

    direccion = fields.Char(u'Dirección',
                            states={
                                'invisible': ~Eval('party'),
                            })
    telefono = fields.Char(u'Teléfono', states={
        'invisible': ~Eval('party'),
    })
    correo = fields.Char(u'Correo Electrónico',
                         states={
                             'invisible': ~Eval('party'),
                         })

    @classmethod
    def __setup__(cls):
        super(Service, cls).__setup__()
        cls.__rpc__['getTechnicalService'] = RPC(check_access=False,
                                                 readonly=False)

        cls._error_messages.update({
            'modify_invoice': ('You can not modify service "%s".'),
            'delete_cancel': ('You can not delete service "%s".'),
        })

        cls._transitions |= set((
            ('pending', 'review'),
            ('review', 'ready'),
            ('review', 'without'),
            ('review', 'warranty'),
            ('ready', 'delivered'),
            ('without', 'delivered'),
            ('warranty', 'delivered'),
        ))

        cls._buttons.update({
            'review': {
                'invisible': Eval('state') != ('pending')
            },
            'ready': {
                'invisible':
                Eval('state').in_(['pending', 'ready', 'without', 'delivered'])
            },
            'without': {
                'invisible':
                Eval('state').in_(['pending', 'ready', 'without', 'delivered'])
            },
            'warranty': {
                'invisible':
                ~Eval('garanty', True) | (Eval('state').in_(
                    ['pending', 'ready', 'without', 'delivered']))
            },
            'delivered': {
                'invisible':
                Eval('state').in_(['review', 'pending', 'delivered'])
            },
        })

    @fields.depends('invoice_date', 'garanty')
    def on_change_invoice_date(self):
        res = {}
        Date = Pool().get('ir.date')
        if self.garanty != None:
            year = Date.today() - datetime.timedelta(days=365)
            if self.invoice_date < year:
                res['invoice_date'] = self.invoice_date
                self.raise_user_error(
                    u'Está seguro de la fecha de ingreso: "%s"'
                    u'tiene mas de un año de garantia', (self.invoice_date))
        else:
            res['invoice_date'] = self.invoice_date

        return res

    @fields.depends('party')
    def on_change_party(self):
        res = {}
        if self.party:
            if self.party.addresses[0]:
                res['direccion'] = self.party.addresses[0].street
            else:
                res['direccion'] = ""
            if self.party.phone:
                res['telefono'] = self.party.phone
            elif self.party.mobile:
                res['telefono'] = self.party.mobile
            else:
                res['telefono'] = ""
            if self.party.email:
                res['correo'] = self.party.email
            else:
                res['correo'] = ""
        else:
            res['direccion'] = ""
            res['telefono'] = ""
            res['correo'] = ""

        return res

    @fields.depends('lines')
    def on_change_lines(self):
        res = {}
        if self.lines:
            for line in self.lines:
                if line.product:
                    res['equipo'] = line.periferic.name
                else:
                    res['equipo'] = ""

                if line.trademark:
                    res['marca'] = line.trademark.name
                else:
                    res['marca'] = ""

                if line.model:
                    res['modelo'] = line.model
                else:
                    res['modelo'] = ""
        return res

    @classmethod
    def get_state_date(cls, services, names):
        pool = Pool()
        Date = pool.get('ir.date')
        date_now = Date.today()
        result = {n: {s.id: '' for s in services} for n in names}
        for name in names:
            for service in services:
                if (service.delivery_date < date_now) and (service.state !=
                                                           'delivered'):
                    result[name][service.id] = 'vencida'
                elif (service.delivery_date
                      == date_now) and (service.state != 'delivered'):
                    result[name][service.id] = 'vence_hoy'
                else:
                    result[name][service.id] = ''
        return result

    @staticmethod
    def default_entry_date():
        Date = Pool().get('ir.date')
        return Date.today()

    @staticmethod
    def default_accessories():
        return ''

    @staticmethod
    def default_detail():
        return ''

    @staticmethod
    def default_delivery_date():
        Date = Pool().get('ir.date')
        return Date.today() + datetime.timedelta(days=1)

    @staticmethod
    def default_state():
        return 'pending'

    @staticmethod
    def default_type():
        return Transaction().context.get('type', 'service')

    @staticmethod
    def default_company():
        return Transaction().context.get('company')

    @classmethod
    def get_amount(cls, services, names):
        amount = Decimal(0.0)
        total = dict((i.id, _ZERO) for i in services)
        for service in services:
            for line in service.lines:
                if line.reference_amount:
                    amount += line.reference_amount
            total[service.id] = amount

        result = {
            'total': total,
        }
        for key in result.keys():
            if key not in names:
                del result[key]
        return result

    @fields.depends('total', 'total_home_service')
    def on_change_total_home_service(self):
        res = {}

        if self.total_home_service:
            res['total'] = self.total_home_service
        else:
            res['total'] = Decimal(0.0)

        return res

    def set_number(self):
        pool = Pool()
        Period = pool.get('account.period')
        Sequence = pool.get('ir.sequence.strict')
        Date = pool.get('ir.date')

        if self.number_service:
            return

        test_state = True

        accounting_date = self.entry_date
        period_id = Period.find(self.company.id,
                                date=accounting_date,
                                test_state=test_state)
        period = Period(period_id)
        sequence = period.get_service_sequence(self.type)
        if not sequence:
            self.raise_user_error('no_withholding_sequence', {
                'withholding': self.rec_name,
                'period': period.rec_name,
            })
        with Transaction().set_context(date=self.entry_date or Date.today()):
            number = Sequence.get_id(sequence.id)
            vals = {'number_service': number}
            if (not self.entry_date and self.type in ('service')):
                vals['entry_date'] = Transaction().context['date']
        self.write([self], vals)

    @classmethod
    def check_modify(cls, services):
        for service in services:
            if (service.state in ('delivered')):
                cls.raise_user_error('modify_invoice',
                                     (service.number_service, ))

    @classmethod
    def delete(cls, services):
        cls.check_modify(services)
        for service in services:
            if (service.state in ('review', 'ready', 'without', 'warranty',
                                  'delivered')):
                cls.raise_user_error('delete_cancel',
                                     (service.number_service, ))
        super(Service, cls).delete(services)

    @classmethod
    def copy(cls, services, default=None):
        if default is None:
            default = {}
        default = default.copy()
        default['state'] = 'pending'
        default['number_service'] = None
        default['type'] = 'service'
        return super(Service, cls).copy(services, default=default)

    @classmethod
    @ModelView.button
    @Workflow.transition('review')
    def review(cls, services):
        for service in services:
            pool = Pool()
            Contact = pool.get('party.contact_mechanism')
            Address = pool.get('party.address')

            if service.party:
                if service.party.addresses[0].street:
                    addresses = service.party.addresses[0]
                    addresses.street = service.direccion
                    addresses.save()
                else:
                    if service.direccion:
                        party = service.party
                        party.address = Address.create([{
                            'street':
                            service.direccion,
                            'party':
                            service.party.id
                        }])
                        party.save()
                    else:
                        service.raise_user_error(
                            u'Actualice la dirección del cliente')

                if service.party.email:
                    emails = Contact.search([('party', '=', service.party),
                                             ('type', '=', 'email')])
                    for email in emails:
                        email.value = service.correo
                        email.save()
                else:
                    if service.correo:
                        contact_mechanisms = []
                        contact_mechanisms.append({
                            'type': 'email',
                            'value': service.correo,
                            'party': service.party.id
                        })
                        contact_mechanisms = Contact.create(contact_mechanisms)
                    else:
                        service.raise_user_error(
                            'Actualice el correo del cliente')

                if service.party.phone:
                    phones = Contact.search([('party', '=', service.party),
                                             ('type', '=', 'phone')])
                    for phone in phones:
                        phone.value = service.telefono
                        phone.save()
                else:
                    if service.telefono:
                        contact_mechanisms = []
                        contact_mechanisms.append({
                            'type': 'phone',
                            'value': service.telefono,
                            'party': service.party.id,
                        })
                        contact_mechanisms = Contact.create(contact_mechanisms)
                    else:
                        service.raise_user_error(
                            u'Actualice el teléfono del cliente')

            service.raise_user_warning(
                'datos%s' % service.id,
                u'Está seguro que los datos del cliente:\n "%s"'
                u'\nCorreo: "%s" y Teléfono: "%s", \nestán actualizados.',
                (service.party.name, service.correo, service.telefono))

            service.set_number()

        cls.write([i for i in services if i.state != 'review'], {
            'state': 'review',
        })

    @classmethod
    @ModelView.button
    @Workflow.transition('ready')
    def ready(cls, services):
        cls.write([i for i in services if i.state != 'ready'], {
            'state': 'ready',
        })

    @classmethod
    @ModelView.button
    @Workflow.transition('without')
    def without(cls, services):
        cls.write([i for i in services if i.state != 'without'], {
            'state': 'without',
        })

    @classmethod
    @ModelView.button
    @Workflow.transition('warranty')
    def warranty(cls, services):
        cls.write([i for i in services if i.state != 'warranty'], {
            'state': 'warranty',
        })

    @classmethod
    @ModelView.button
    @Workflow.transition('delivered')
    def delivered(cls, services):
        cls.write([i for i in services if i.state != 'delivered'], {
            'state': 'delivered',
        })

    @classmethod
    def getTechnicalService(cls, identificacion):
        pool = Pool()
        Service = pool.get('service.service')
        Party = pool.get('party.party')
        parties = Party.search([('vat_number', '=', identificacion)])
        for p in parties:
            party = p
        services = Service.search([('party', '=', party)])
        all_services = []
        if services:
            for service in services:
                lines_services = {}
                for line in service.lines:
                    lines_services[0] = str(service.entry_date)
                    lines_services[1] = str(service.delivery_date)
                    lines_services[2] = service.number_service
                    lines_services[3] = line.periferic.name
                    lines_services[4] = line.trademark.name
                    lines_services[5] = line.model
                    lines_services[6] = line.failure
                    lines_services[7] = str(line.reference_amount)
                    lines_services[8] = line.technical.party.name
                    lines_services[9] = service.state
                    lines_services[10] = service.accessories
                    lines_services[11] = service.detail
                    all_services.append(lines_services)
            return all_services
        else:
            return []
コード例 #21
0
class OpenChartAccountStart(ModelView):
    'Open Chart of Accounts'
    __name__ = 'analytic_account.open_chart.start'
    start_date = fields.Date('Start Date')
    end_date = fields.Date('End Date')
コード例 #22
0
class BalanceProductFixedAssets(ModelSQL, ModelView):
    "Turnover and Balances Fixed Assets"
    _name = "ekd.balances.fixed_assets"
    _description =__doc__
    _inherits = {'ekd.balances.assets': 'assets'}

    assets = fields.Many2One('ekd.balances.assets', 'Assets', required=True,
            ondelete='CASCADE')

    date_income = fields.Date('Date Income', required=True)
    date_expense = fields.Date('Date Expense')
    period_income = fields.Many2One('ekd.period', 'Period Income', required=True, select=2, 
                domain=[
                    ('company','=',Eval('company'))
                ])
    period_expense = fields.Many2One('ekd.period', 'Period Expense', select=2, 
                domain=[
                    ('company','=',Eval('company'))
                ])
    initial_cost = fields.Numeric('Initial cost', digits=(16, Eval('currency_digits', 2)))
    replacement = fields.Numeric('Replacement value', digits=(16, Eval('currency_digits', 2)))
    residual = fields.Numeric('Residual value', digits=(16, Eval('currency_digits', 2)))
    deprecation = fields.Many2Many("ekd.balances.fixed_assets.deprecation", 'fixed_assets', 'move_line', 'Deprecation')

    state = fields.Selection([
                ('draft','Draft'),
                ('open','Open'),
                ('done','Closed'),
                ('deleted','Deleted')
                ], 'State', required=True)
    deleted = fields.Boolean('Flag Deleting')

    def __init__(self):
        super(BalanceProductFixedAssets, self).__init__()

    def default_state(self):
        return Transaction().context.get('state') or 'draft'

    def default_company(self):
        return Transaction().context.get('company') or False

    def default_currency_digits(self):
        return 2

    def get_rec_name(self, ids, name):
        if not ids:
            return {}
        res = {}
        for balance in self.browse(ids):
            res[balance.id] = balance.product.name
        return res

    def get_currency_digits(self, ids, name):
        res = {}.fromkeys(ids, 2)
        company_id = Transaction().context.get('company')
        company = self.pool.get('company.company').browse(company_id)
        for line in self.browse(ids):
            if line.account.currency:
                res[line.id] = line.account.currency.currency_digits
            elif company.currency:
                res[line.id] = company.currency.currency_digits
コード例 #23
0
ファイル: payment.py プロジェクト: emperadorxp1/TrytonModules
class Mandate(Workflow, ModelSQL, ModelView):
    'SEPA Mandate'
    __name__ = 'account.payment.sepa.mandate'
    party = fields.Many2One('party.party',
                            'Party',
                            required=True,
                            select=True,
                            states={
                                'readonly':
                                Eval('state').in_(
                                    ['requested', 'validated', 'canceled']),
                            },
                            depends=['state'])
    account_number = fields.Many2One(
        'bank.account.number',
        'Account Number',
        ondelete='RESTRICT',
        states={
            'readonly': Eval('state').in_(['validated', 'canceled']),
            'required': Eval('state') == 'validated',
        },
        domain=[
            ('type', '=', 'iban'),
            ('account.owners', '=', Eval('party')),
        ],
        depends=['state', 'party'])
    identification = fields.Char('Identification',
                                 size=35,
                                 states={
                                     'readonly':
                                     Eval('identification_readonly', True),
                                     'required':
                                     Eval('state') == 'validated',
                                 },
                                 depends=['state', 'identification_readonly'])
    identification_readonly = fields.Function(
        fields.Boolean('Identification Readonly'),
        'get_identification_readonly')
    company = fields.Many2One(
        'company.company',
        'Company',
        required=True,
        select=True,
        domain=[
            ('id', If(Eval('context', {}).contains('company'), '=',
                      '!='), Eval('context', {}).get('company', -1)),
        ],
        states={
            'readonly': Eval('state') != 'draft',
        },
        depends=['state'])
    type = fields.Selection([
        ('recurrent', 'Recurrent'),
        ('one-off', 'One-off'),
    ],
                            'Type',
                            states={
                                'readonly':
                                Eval('state').in_(['validated', 'canceled']),
                            },
                            depends=['state'])
    sequence_type_rcur = fields.Boolean("Always use RCUR",
                                        states={
                                            'invisible':
                                            Eval('type') == 'one-off',
                                        },
                                        depends=['type'])
    scheme = fields.Selection([
        ('CORE', 'Core'),
        ('B2B', 'Business to Business'),
    ],
                              'Scheme',
                              required=True,
                              states={
                                  'readonly':
                                  Eval('state').in_(['validated', 'canceled']),
                              },
                              depends=['state'])
    scheme_string = scheme.translated('scheme')
    signature_date = fields.Date('Signature Date',
                                 states={
                                     'readonly':
                                     Eval('state').in_(
                                         ['validated', 'canceled']),
                                     'required':
                                     Eval('state') == 'validated',
                                 },
                                 depends=['state'])
    state = fields.Selection([
        ('draft', 'Draft'),
        ('requested', 'Requested'),
        ('validated', 'Validated'),
        ('canceled', 'Canceled'),
    ],
                             'State',
                             readonly=True)
    payments = fields.One2Many('account.payment', 'sepa_mandate', 'Payments')
    has_payments = fields.Function(fields.Boolean('Has Payments'),
                                   'has_payments')

    @classmethod
    def __setup__(cls):
        super(Mandate, cls).__setup__()
        cls._transitions |= set((
            ('draft', 'requested'),
            ('requested', 'validated'),
            ('validated', 'canceled'),
            ('requested', 'canceled'),
            ('requested', 'draft'),
        ))
        cls._buttons.update({
            'cancel': {
                'invisible': ~Eval('state').in_(['requested', 'validated']),
                'depends': ['state'],
            },
            'draft': {
                'invisible': Eval('state') != 'requested',
                'depends': ['state'],
            },
            'request': {
                'invisible': Eval('state') != 'draft',
                'depends': ['state'],
            },
            'validate_mandate': {
                'invisible': Eval('state') != 'requested',
                'depends': ['state'],
            },
        })
        t = cls.__table__()
        cls._sql_constraints = [
            ('identification_unique', Unique(t, t.company, t.identification),
             'account_payment_sepa.msg_mandate_unique_id'),
        ]

    @staticmethod
    def default_company():
        return Transaction().context.get('company')

    @staticmethod
    def default_type():
        return 'recurrent'

    @classmethod
    def default_sequence_type_rcur(cls):
        return False

    @staticmethod
    def default_scheme():
        return 'CORE'

    @staticmethod
    def default_state():
        return 'draft'

    @staticmethod
    def default_identification_readonly():
        pool = Pool()
        Configuration = pool.get('account.configuration')
        config = Configuration(1)
        return bool(config.sepa_mandate_sequence)

    def get_identification_readonly(self, name):
        return bool(self.identification)

    def get_rec_name(self, name):
        if self.identification:
            return self.identification
        return '(%s)' % self.id

    @classmethod
    def search_rec_name(cls, name, clause):
        return [tuple(('identification', )) + tuple(clause[1:])]

    @classmethod
    def create(cls, vlist):
        pool = Pool()
        Sequence = pool.get('ir.sequence')
        Configuration = pool.get('account.configuration')

        config = Configuration(1)
        vlist = [v.copy() for v in vlist]
        for values in vlist:
            if (config.sepa_mandate_sequence
                    and not values.get('identification')):
                values['identification'] = Sequence.get_id(
                    config.sepa_mandate_sequence.id)
            # Prevent raising false unique constraint
            if values.get('identification') == '':
                values['identification'] = None
        return super(Mandate, cls).create(vlist)

    @classmethod
    def write(cls, *args):
        actions = iter(args)
        args = []
        for mandates, values in zip(actions, actions):
            # Prevent raising false unique constraint
            if values.get('identification') == '':
                values = values.copy()
                values['identification'] = None
            args.extend((mandates, values))
        super(Mandate, cls).write(*args)

    @classmethod
    def copy(cls, mandates, default=None):
        if default is None:
            default = {}
        else:
            default = default.copy()
        default.setdefault('payments', [])
        default.setdefault('signature_date', None)
        default.setdefault('identification', None)
        return super(Mandate, cls).copy(mandates, default=default)

    @property
    def is_valid(self):
        if self.state == 'validated':
            if self.type == 'one-off':
                if not self.has_payments:
                    return True
            else:
                return True
        return False

    @property
    def sequence_type(self):
        if self.type == 'one-off':
            return 'OOFF'
        elif not self.sequence_type_rcur and (not self.payments or all(
                not p.sepa_mandate_sequence_type
                for p in self.payments) or all(p.rejected
                                               for p in self.payments)):
            return 'FRST'
        # TODO manage FNAL
        else:
            return 'RCUR'

    @classmethod
    def has_payments(cls, mandates, name):
        pool = Pool()
        Payment = pool.get('account.payment')
        payment = Payment.__table__
        cursor = Transaction().connection.cursor()

        has_payments = dict.fromkeys([m.id for m in mandates], False)
        for sub_ids in grouped_slice(mandates):
            red_sql = reduce_ids(payment.sepa_mandate, sub_ids)
            cursor.execute(*payment.select(payment.sepa_mandate,
                                           Literal(True),
                                           where=red_sql,
                                           group_by=payment.sepa_mandate))
            has_payments.update(cursor.fetchall())

        return {'has_payments': has_payments}

    @classmethod
    @ModelView.button
    @Workflow.transition('draft')
    def draft(cls, mandates):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('requested')
    def request(cls, mandates):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('validated')
    def validate_mandate(cls, mandates):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('canceled')
    def cancel(cls, mandates):
        # TODO must be automaticaly canceled 13 months after last collection
        pass

    @classmethod
    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)
コード例 #24
0
class CompensationMoveStart(ModelView, BankMixin):
    'Create Compensation Move Start'
    __name__ = 'account.move.compensation_move.start'
    party = fields.Many2One('party.party', 'Party', readonly=True)
    account = fields.Many2One('account.account',
                              'Account',
                              domain=[
                                  'OR', ('type.receivable', '=', True),
                                  ('type.payable', '=', True)
                              ],
                              required=True)
    date = fields.Date('Date')
    maturity_date = fields.Date('Maturity Date')
    description = fields.Char('Description')
    payment_kind = fields.Selection([
        ('both', 'Both'),
        ('payable', 'Payable'),
        ('receivable', 'Receivable'),
    ], 'Payment Kind')
    payment_type = fields.Many2One('account.payment.type',
                                   'Payment Type',
                                   domain=[('kind', '=', Eval('payment_kind'))
                                           ],
                                   depends=['payment_kind'])

    @staticmethod
    def default_date():
        pool = Pool()
        return pool.get('ir.date').today()

    @staticmethod
    def default_maturity_date():
        pool = Pool()
        return pool.get('ir.date').today()

    @classmethod
    def default_get(cls, fields, with_rec_name=True):
        pool = Pool()
        Line = pool.get('account.move.line')
        PaymentType = pool.get('account.payment.type')

        defaults = super(CompensationMoveStart,
                         cls).default_get(fields, with_rec_name)

        party = None
        company = None
        amount = Decimal('0.0')

        lines = Line.browse(Transaction().context.get('active_ids', []))
        for line in lines:
            amount += line.debit - line.credit
            if not party:
                party = line.party
            elif party != line.party:
                raise UserError(
                    gettext('account_bank.different_parties',
                            party=line.party.rec_name,
                            line=line.rec_name))
            if not company:
                company = line.account.company
        if (company and company.currency.is_zero(amount)
                and len(set([x.account for x in lines])) == 1):
            raise UserError(gettext('account_bank.normal_reconcile'))
        if amount > 0:
            defaults['payment_kind'] = 'receivable'
        else:
            defaults['payment_kind'] = 'payable'
        defaults['bank_account'] = None
        if party:
            defaults['party'] = party.id
            if (defaults['payment_kind'] in ['receivable', 'both']
                    and party.customer_payment_type):
                defaults['payment_type'] = party.customer_payment_type.id
            elif (defaults['payment_kind'] in ['payable', 'both']
                  and party.supplier_payment_type):
                defaults['payment_type'] = party.supplier_payment_type.id
            if defaults.get('payment_type'):
                payment_type = PaymentType(defaults['payment_type'])
                defaults['account_bank'] = payment_type.account_bank

                self = cls()
                self.payment_type = payment_type
                self.party = party
                self._get_bank_account()
                defaults['account_bank_from'] = (
                    self.on_change_with_account_bank_from())
                defaults['bank_account'] = (self.bank_account.id
                                            if self.bank_account else None)
            if amount > 0:
                defaults['account'] = (party.account_receivable.id
                                       if party.account_receivable else None)
            else:
                defaults['account'] = (party.account_payable.id
                                       if party.account_payable else None)
        return defaults

    def on_change_with_payment_type(self, name=None):
        pass
コード例 #25
0
class Document(ModelSQL, ModelView):
    "Documents"
    _name='ekd.document'
    _order_name = 'date_document'
    _order=['date_document', 'date_account']
    _description=__doc__

    company = fields.Many2One('company.company', 'Company', readonly=True)
    model = fields.Many2One('ir.model', 'Model', domain=[('model','like','ekd.document%')])
    model_str = fields.Char('Model Name', size=128)
    direction = fields.Selection([
                    ('input','Input'),
                    ('move','Move'),
                    ('internal','Internal'),
                    ('output','Output')
                    ],'Direction document')
    name = fields.Char('Description')
    template = fields.Many2One('ekd.document.template', 'Document Name', help="Template documents", order_field="%(table)s.template %(order)s")
    note = fields.Text('Note document')
    number_our = fields.Char('Number Outgoing', size=32, readonly=True, 
                            states={
                                'invisible': Not(Bool(Eval('number_our')))
                                })
    number_in = fields.Char('Number of incoming', size=32)
    date_document = fields.Date('Date Create')
    date_account = fields.Date('Date Account')
    employee = fields.Many2One('company.employee', 'Employee')
    from_party = fields.Many2One('party.party', 'From partner')
    to_party = fields.Many2One('party.party', 'To partner')
    amount = fields.Numeric('Amount Document', digits=(16, Eval("currency_digits",2)))
    amount_payment = fields.Function(fields.Numeric('Amount Payment', digits=(16, Eval("currency_digits", 2))), 'get_payment_field')
    amount_paid = fields.Function(fields.Numeric('Amount Paid', digits=(16, Eval("currency_digits", 2))), 'get_paid_field')
    currency = fields.Many2One('currency.currency', 'Currency')
    currency_digits = fields.Function(fields.Integer('Currency Digits' , on_change_with=['currency']), 'get_currency_digits')
    document_base = fields.Reference('Document Base', selection='documents_base_get',
                on_change=['document_base', 'lines'])
    lines = fields.One2Many('ekd.document.line.product', 'invoice', 'Lines')
    childs = fields.One2Many('ekd.document','parent', 'Child documents', readonly=True)
    parent = fields.Many2One('ekd.document', 'Parent document')
    state = fields.Selection(_STATES_FULL, 'State', readonly=True)
    stage = fields.Many2One('ekd.document.template.stage', 'Stage', readonly=True)
    journal_work = fields.One2Many('ekd.document.journal_work','document','Journal Change Stages', readonly=True)
    post_date = fields.Date('Date Post')
    active = fields.Boolean('Active', required=True)
    id_1c = fields.Char("ID import from 1C", size=None, select=1)
    deleting = fields.Boolean('Flag Deleting')

    def __init__(self): 
        super(Document, self).__init__()

        self._order.insert(0, ('company','ASC'))
        self._order.insert(0, ('date_document', 'ASC'))
        self._order.insert(0, ('template', 'ASC'))
        self._order.insert(0, ('date_account', 'ASC'))
        self._order.insert(0, ('number_our', 'ASC'))

    def default_state(self):
        return 'draft'

    def default_date_document(self):
        context = Transaction().context
        if context.get('date_document'):
            return context.get('date_document')
        elif context.get('current_date'):
            return context.get('current_date')
        return datetime.datetime.now()

    def default_date_account(self ):
        context = Transaction().context
        if context.get('date_account'):
            return context.get('date_account')
        elif context.get('current_date'):
            return context.get('current_date')
        return datetime.datetime.now()

    def default_from_party(self):
        return Transaction().context.get('from_party')

    def default_to_party(self):
        return Transaction().context.get('to_party')

    def default_company(self ):
        return Transaction().context.get('company')

    def default_child(self):
        return Transaction().context.get('child')

    def default_amount(self):
        return Transaction().context.get('amount')

    def default_name(self):
        return Transaction().context.get('name')

    def default_note(self):
        return Transaction().context.get('note')

    def default_currency(self):
        company_obj = self.pool.get('company.company')
        currency_obj = self.pool.get('currency.currency')
        context = Transaction().context
        if context.get('company'):
            company = company_obj.browse(context['company'])
            return company.currency.id
        return False

    def default_currency_digits(self):
        company_obj = self.pool.get('company.company')
        context = Transaction().context
        if context.get('company'):
            company = company_obj.browse(context['company'])
            return company.currency.digits
        return 2

    def default_active(self):
        return True

    def documents_base_dict_get(self, model=False):
        if not model:
            model = self._name
        dictions_obj = self.pool.get('ir.dictions')
        res = []
        diction_ids = dictions_obj.search( [
                                ('model', 'like', 'ekd.document.head%'),
                                ('pole', '=', 'document_base'),
                                ])
        if diction_ids:
            for diction in dictions_obj.browse( diction_ids):
                res.append([diction.key, diction.value])
        return res

    def documents_base_get(self):
        return self.documents_base_dict_get(self._name)

    def get_rec_name(self, ids, name):
        res={}

        for document in self.browse(ids):
            if document.template:
                if document.template.shortcut:
                        TemplateName = document.template.shortcut
                else:
                        TemplateName = document.template.name

            if document.number_our:
                DocumentNumber = document.number_our
            elif document.number_in:
                DocumentNumber = document.number_in
            else:
                DocumentNumber = u'без номера'

            if document.date_document:
                DocumentDate = document.date_document.strftime('%d.%m.%Y')
            else:
                DocumentDate = u'без даты'

            if document.template:
                 res[document.id] = TemplateName+ u' № '+DocumentNumber+u' от '+DocumentDate
            else:
                 res[document.id] = u'Без имени № '+ DocumentNumber+u' от '+DocumentDate

        return res

    def get_payment_field(self, ids, name):
        res = {}
        cursor = Transaction().cursor
        for id in ids:
            res.setdefault(id, Decimal('0.0'))
        cursor.execute("SELECT doc_base, SUM(amount_payment) "\
                        "FROM ekd_document_line_payment "\
                        "WHERE doc_base in ("+','.join(map(str,ids))+") and state in ('wait0', 'wait1', 'payment') "\
                        "GROUP BY doc_base")
        for id, sum in cursor.fetchall():
            # SQLite uses float for SUM
            if not isinstance(sum, Decimal):
                sum = Decimal(str(sum))
            res[id] = sum
        return res

    def get_paid_field(self, ids, name):
        res = {}
        cursor = Transaction().cursor
        for id in ids:
            res.setdefault(id, Decimal('0.0'))
        cursor.execute("SELECT doc_base, SUM(amount_payment) "\
                        "FROM ekd_document_line_payment "\
                        "WHERE doc_base in ("+','.join(map(str,ids))+") and state='done' "\
                        "GROUP BY doc_base")
        for id, sum in cursor.fetchall():
            # SQLite uses float for SUM
            if not isinstance(sum, Decimal):
                sum = Decimal(str(sum))
            res[id] = sum
        return res

    def get_currency_digits(self, ids, name):
        assert name in ('currency_digits'), 'Invalid name %s' % (name)
        res={}.fromkeys(ids, 2)
        for document in self.browse(ids):
            if document.currency:
                res[document.id] = document.currency.digits
        return res

    def on_change_document_base(self, values):
        return values

    def button_draft(self, ids):
        for document in self.browse(ids):
            if document.template.model:
                self.pool.get(document.template.model).button_draft(ids)

    def button_cancel(self, ids):
        for document in self.browse(ids):
            if document.template.model:
                self.pool.get(document.template.model).button_cancel(ids)

    def button_restore(self, ids):
        for document in self.browse(ids):
            if document.template.model:
                self.pool.get(document.template.model).button_restore(ids)

    def button_issued(self, ids):
        for document in self.browse(idst):
            if document.template.model:
                self.pool.get(document.template.model).button_issued(ids)

    def button_on_payment(self, ids):
        for document in self.browse(idst):
            if document.template.model:
                self.pool.get(document.template.model).button_payment(ids)

    def button_pay(self, ids):
        for document in self.browse(idst):
            if document.template.model:
                self.pool.get(document.template.model).button_pay(ids)

    def button_confirmed(self, ids):
        for document in self.browse(idst):
            if document.template.model:
                self.pool.get(document.template.model).button_confirmed(ids)
コード例 #26
0
ファイル: hr_payslip.py プロジェクト: kakamble-aiims/work
class HrPayslip(Workflow, ModelSQL, ModelView):
    '''Pay Slip'''

    __name__ = 'hr.payslip'

    employee = fields.Many2One(
        'company.employee',
        'Employee',
        states={'readonly': ~Eval('state').in_(['draft'])},
        depends=['state'])
    salary_code = fields.Char(
        'Salary Code',
        states={'readonly': ~Eval('state').in_(['draft'])},
        depends=['state'])
    structure = fields.Many2One(
        'salary.structure',
        'Structure',
        states={'readonly': ~Eval('state').in_(['draft'])},
        depends=['state'])
    contract = fields.Many2One(
        'hr.contract',
        'Salary Details',
        states={'readonly': ~Eval('state').in_(['draft'])},
        depends=['state'])
    code = fields.Integer('Code',
                          states={'readonly': ~Eval('state').in_(['draft'])},
                          depends=['state'])
    name = fields.Char('name',
                       states={'readonly': ~Eval('state').in_(['draft'])},
                       depends=['state'])
    number = fields.Char('Reference',
                         states={'readonly': ~Eval('state').in_(['draft'])},
                         depends=['state'])
    date_from = fields.Date('Date From',
                            states={'readonly': ~Eval('state').in_(['draft'])},
                            depends=['state'])
    date_to = fields.Date('Date To',
                          states={'readonly': ~Eval('state').in_(['draft'])},
                          depends=['state'])
    state = fields.Selection([('draft', 'Draft'), ('verify', 'Waiting'),
                              ('done', 'Done'), ('cancel', 'Rejected'),
                              ('confirm', 'Successful')],
                             'Status',
                             readonly=True)
    lines = fields.One2Many('hr.payslip.line',
                            'slip',
                            string='Payslip Lines',
                            states={'readonly': ~Eval('state').in_(['draft'])},
                            depends=['state'])
    pay_and_allowance = fields.One2Many(
        'hr.payslip.line',
        'slip',
        string='Payslip Lines',
        domain=[('category.code', 'in', ['Basic', 'Allowance', 'Gross',
                                         'Net'])],
        states={'readonly': ~Eval('state').in_(['draft'])},
        depends=['state'])
    deductions = fields.One2Many(
        'hr.payslip.line',
        'slip',
        string='Payslip Lines',
        domain=[('category.code', 'in', ['Deduction'])],
        states={'readonly': ~Eval('state').in_(['draft'])},
        depends=['state'])
    details_by_salary_rule_category = fields.One2Many(
        'hr.payslip.line',
        'slip',
        string='Details by Salary Rule',
        states={'readonly': ~Eval('state').in_(['draft'])},
        depends=['state'])
    payslip_run = fields.Many2One(
        'hr.payslip.run',
        'Payslip Batches',
        states={'readonly': ~Eval('state').in_(['draft'])},
        depends=['state'])  #batches in payslip.run
    bank_name = fields.Char('Bank Name',
                            states={'readonly': ~Eval('state').in_(['draft'])},
                            depends=['state'],
                            readonly=True)
    ifsc = fields.Char('IFSC Code',
                       states={'readonly': ~Eval('state').in_(['draft'])},
                       depends=['state'],
                       readonly=True)
    bank_address = fields.Text(
        'Bank Address',
        states={'readonly': ~Eval('state').in_(['draft'])},
        depends=['state'],
        readonly=True)
    account_no = fields.Integer(
        'Account Number',
        states={'readonly': ~Eval('state').in_(['draft'])},
        depends=['state'],
        readonly=True)
    bank_status = fields.Char(
        'Bank Account Status',
        states={'readonly': ~Eval('state').in_(['draft'])},
        depends=['state'],
        readonly=True)

    @fields.depends('employee')
    def on_change_employee(self):
        self.salary_code = self.employee.salary_code
        self.number = self
        self.bank_name = self.employee.bank_name.bank
        self.bank_address = self.employee.bank_address
        self.account_no = self.employee.account_no
        self.bank_status = self.employee.bank_status
        start_date = datetime.date.today()
        contract = Pool().get('hr.contract')
        contracts = contract.search([('employee', '=', self.employee),
                                     ('date_start', '<=', start_date),
                                     ('date_end', '>=', start_date)])

    @property
    def pay_and_allowances(self):
        allowances_lines = []
        if self.lines:
            for line in self.lines:
                if line.category.code in ['BASIC', 'ALW']:
                    allowances_lines.append(line)
        return allowances_lines

    @property
    def deductions(self):
        deductions_lines = []
        if self.lines:
            for line in self.lines:
                if line.category.code in ['DED']:
                    deductions_lines.append(line)
        return deductions_lines

    @staticmethod
    def default_state():
        return 'draft'

    @classmethod
    def __setup__(cls):
        super().__setup__()
        cls._order = [
            ('salary_code', 'ASC'),
        ]
        cls._transitions |= set((
            ('draft', 'verify'),
            ('verify', 'confirm'),
            ('confirm', 'done'),
            ('confirm', 'cancel'),
            ('verify', 'cancel'),
        ))
        cls._buttons.update({
            'verify': {
                'invisible': ~Eval('state').in_(['draft']),
                'depends': ['state'],
            },
            'cancel': {
                'invisible': ~Eval('state').in_(['confirm', 'verify']),
                'depends': ['state'],
            },
            'confirm': {
                'invisible': ~Eval('state').in_(['verify']),
                'depends': ['state'],
            },
            'done': {
                'invisible': ~Eval('state').in_(['confirm']),
                'depends': ['state'],
            },
        })

    @classmethod
    @ModelView.button
    @Workflow.transition('verify')
    def verify(cls, records):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('cancel')
    def cancel(cls, records):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('confirm')
    def confirm(cls, records):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('done')
    def done(cls, records):
        pass

    def calculate_rules(self):
        structure = self.structure
        PayslipLine = Pool().get('hr.payslip.line')

        for rule in structure.rules:
            condition = rule.check(
                self,
                self.employee,
                self.contract,
            )
            if not condition:
                continue
            amount = rule.calculate(
                self,
                self.employee,
                self.contract,
            )
            vals = {
                'name': rule.name,
                'code': rule.code,
                'slip': self.id,
                'salary_rule': rule.id,
                'category': rule.category.id,
                'employee': self.employee.id,
                'amount': amount,
                'total': amount,
                'priority': rule.priority
            }
            print(vals)
            line = PayslipLine.create([vals])

    @classmethod
    #@ModelView.button_action('payroll.payslip_line_view_tree')
    def _compute_salary(cls, records):
        pass

    @classmethod
    def default_date_from(cls):
        start_date = datetime.date.today().replace(day=1)
        # y=datetime.datetime(x.year,x.month,1)
        return start_date

    @classmethod
    def default_date_to(cls):
        today = datetime.date.today().month
        end_date = (datetime.date.today().replace(month=today + 1, day=1) -
                    datetime.timedelta(days=1))
        return end_date

    @classmethod
    def default_payslip_month_year(cls):
        month = datetime.date.today().strftime("%B")
        year = datetime.date.today().year
        date_ = month + ", " + str(year)
        return date_

    @classmethod
    def validate(cls, records):
        super(HrPayslip, cls).validate(records)
        for record in records:
            if not record.salary_code:
                cls.raise_user_error('Enter Salary Code')
コード例 #27
0
ファイル: test.py プロジェクト: vitalliykashuta/trytond
class DateRequired(ModelSQL):
    'Date Required'
    __name__ = 'test.date_required'
    date = fields.Date(string='Date', help='Test date', required=True)
コード例 #28
0
ファイル: stock.py プロジェクト: emperadorxp1/TrytonModules
class ShipmentDrop(Workflow, ModelSQL, ModelView):
    "Drop Shipment"
    __name__ = 'stock.shipment.drop'

    effective_date = fields.Date('Effective Date', readonly=True)
    planned_date = fields.Date('Planned Date',
                               states={
                                   'readonly': Eval('state') != 'draft',
                               },
                               depends=['state'])
    company = fields.Many2One(
        'company.company',
        'Company',
        required=True,
        states={
            'readonly': Eval('state') != 'draft',
        },
        domain=[
            ('id', If(Eval('context', {}).contains('company'), '=',
                      '!='), Eval('context', {}).get('company', -1)),
        ],
        depends=['state'])
    reference = fields.Char('Reference',
                            select=1,
                            states={
                                'readonly': Eval('state') != 'draft',
                            },
                            depends=['state'])
    supplier = fields.Many2One('party.party',
                               'Supplier',
                               required=True,
                               states={
                                   'readonly': (((Eval('state') != 'draft')
                                                 | Eval('supplier_moves', [0]))
                                                & Eval('supplier')),
                               },
                               depends=['state', 'supplier'])
    contact_address = fields.Many2One('party.address',
                                      'Contact Address',
                                      states={
                                          'readonly': Eval('state') != 'draft',
                                      },
                                      domain=[('party', '=', Eval('supplier'))
                                              ],
                                      depends=['state', 'supplier'])
    customer = fields.Many2One('party.party',
                               'Customer',
                               required=True,
                               states={
                                   'readonly': (((Eval('state') != 'draft')
                                                 | Eval('customer_moves', [0]))
                                                & Eval('customer')),
                               },
                               depends=['state'])
    delivery_address = fields.Many2One('party.address',
                                       'Delivery Address',
                                       required=True,
                                       states={
                                           'readonly':
                                           Eval('state') != 'draft',
                                       },
                                       domain=[('party', '=', Eval('customer'))
                                               ],
                                       depends=['state', 'customer'])
    moves = fields.One2Many('stock.move',
                            'shipment',
                            'Moves',
                            domain=[
                                ('company', '=', Eval('company')),
                                [
                                    'OR',
                                    [
                                        ('from_location.type', '=',
                                         'supplier'),
                                        ('to_location.type', '=', 'drop'),
                                    ],
                                    [
                                        ('from_location.type', '=', 'drop'),
                                        ('to_location.type', '=', 'customer'),
                                    ],
                                ],
                            ],
                            depends=['company'],
                            readonly=True)
    supplier_moves = fields.One2Many(
        'stock.move',
        'shipment',
        'Supplier Moves',
        filter=[('to_location.type', '=', 'drop')],
        states={
            'readonly': Eval('state').in_(['shipped', 'done', 'cancel']),
        },
        depends=['state', 'supplier'])
    customer_moves = fields.One2Many('stock.move',
                                     'shipment',
                                     'Customer Moves',
                                     filter=[('from_location.type', '=',
                                              'drop')],
                                     states={
                                         'readonly':
                                         Eval('state') != 'shipped',
                                     },
                                     depends=['state', 'customer'])
    code = fields.Char('Code', select=1, readonly=True)
    state = fields.Selection([
        ('draft', 'Draft'),
        ('waiting', 'Waiting'),
        ('shipped', 'Shipped'),
        ('done', 'Done'),
        ('cancel', 'Canceled'),
    ],
                             'State',
                             readonly=True)

    @classmethod
    def __register__(cls, module_name):
        pool = Pool()
        Move = pool.get('stock.move')
        PurchaseLine = pool.get('purchase.line')
        PurchaseRequest = pool.get('purchase.request')
        SaleLine = pool.get('sale.line')
        Location = pool.get('stock.location')
        move = Move.__table__()
        purchase_line = PurchaseLine.__table__()
        purchase_request = PurchaseRequest.__table__()
        sale_line = SaleLine.__table__()
        location = Location.__table__()
        cursor = Transaction().connection.cursor()

        super(ShipmentDrop, cls).__register__(module_name)

        # Migration from 3.6
        cursor.execute(*location.select(Count(location.id),
                                        where=(location.type == 'drop')))
        has_drop_shipment, = cursor.fetchone()

        if not has_drop_shipment:
            drop_shipment = Location(name='Migration Drop Shipment',
                                     type='drop',
                                     active=False)
            drop_shipment.save()
            drop_shipment_location = drop_shipment.id

            move_sale_query = move.join(
                purchase_line,
                condition=move.origin ==
                Concat('purchase.line,', purchase_line.id)).join(
                    purchase_request,
                    condition=purchase_request.purchase_line ==
                    purchase_line.id).join(
                        sale_line,
                        condition=sale_line.purchase_request ==
                        purchase_request.id).select(
                            move.id,
                            move.to_location,
                            sale_line.id,
                            where=move.shipment.like('stock.shipment.drop,%'))
            cursor.execute(*move_sale_query)
            move_sales = cursor.fetchall()

            for sub_move in grouped_slice(move_sales):
                sub_ids = [s[0] for s in sub_move]
                cursor.execute(*move.update(columns=[move.to_location],
                                            values=[drop_shipment_location],
                                            where=move.id.in_(sub_ids)))

            cursor.execute(*move.select(limit=1))
            moves = list(cursor_dict(cursor))
            if moves:
                move_columns = moves[0].keys()
                columns = [Column(move, c) for c in move_columns if c != 'id']
                create_move = move.insert(
                    columns=columns,
                    values=move.select(
                        *columns,
                        where=move.shipment.like('stock.shipment.drop,%')))
                cursor.execute(*create_move)

            for move_id, customer_location, line_id in move_sales:
                cursor.execute(
                    *move.update(columns=[
                        move.origin, move.from_location, move.to_location
                    ],
                                 values=[
                                     Concat('sale.line,', str(line_id)),
                                     drop_shipment_location, customer_location
                                 ],
                                 where=(move.id == move_id)))

    @classmethod
    def __setup__(cls):
        super(ShipmentDrop, cls).__setup__()
        cls._transitions |= set((
            ('draft', 'waiting'),
            ('waiting', 'shipped'),
            ('draft', 'cancel'),
            ('waiting', 'cancel'),
            ('waiting', 'draft'),
            ('cancel', 'draft'),
            ('shipped', 'done'),
            ('shipped', 'cancel'),
        ))
        cls._buttons.update({
            'cancel': {
                'invisible': Eval('state').in_(['cancel', 'done']),
                'depends': ['state'],
            },
            'draft': {
                'invisible':
                ~Eval('state').in_(['cancel', 'draft', 'waiting']),
                'icon':
                If(Eval('state') == 'cancel', 'tryton-undo', 'tryton-back'),
                'depends': ['state'],
            },
            'wait': {
                'invisible': Eval('state') != 'draft',
                'depends': ['state'],
            },
            'ship': {
                'invisible': Eval('state') != 'waiting',
                'depends': ['state'],
            },
            'done': {
                'invisible': Eval('state') != 'shipped',
                'depends': ['state'],
            },
        })

    @staticmethod
    def default_state():
        return 'draft'

    @staticmethod
    def default_company():
        return Transaction().context.get('company')

    @fields.depends('supplier')
    def on_change_supplier(self):
        if self.supplier:
            self.contact_address = self.supplier.address_get()
        else:
            self.contact_address = None

    @fields.depends('customer')
    def on_change_customer(self):
        if self.customer:
            self.delivery_address = self.customer.address_get(type='delivery')
        else:
            self.delivery_address = None

    def _get_move_planned_date(self):
        '''
        Return the planned date for moves
        '''
        return self.planned_date

    @classmethod
    def _set_move_planned_date(cls, shipments):
        '''
        Set planned date of moves for the shipments
        '''
        Move = Pool().get('stock.move')
        to_write = []
        for shipment in shipments:
            planned_date = shipment._get_move_planned_date()
            to_write.extend(([
                m for m in shipment.moves
                if m.state not in ('assigned', 'done', 'cancel')
            ], {
                'planned_date': planned_date,
            }))
        if to_write:
            Move.write(*to_write)

    @classmethod
    def create(cls, vlist):
        pool = Pool()
        Sequence = pool.get('ir.sequence')
        Config = pool.get('stock.configuration')

        vlist = [x.copy() for x in vlist]
        config = Config(1)
        for values in vlist:
            values['code'] = Sequence.get_id(config.shipment_drop_sequence)
        shipments = super(ShipmentDrop, cls).create(vlist)
        cls._set_move_planned_date(shipments)
        return shipments

    @classmethod
    def write(cls, *args):
        super(ShipmentDrop, cls).write(*args)
        cls._set_move_planned_date(sum(args[::2], []))

    @classmethod
    def copy(cls, shipments, default=None):
        if default is None:
            default = {}
        else:
            default = default.copy()
        default.setdefault('moves', None)
        return super(ShipmentDrop, cls).copy(shipments, default=default)

    @classmethod
    def delete(cls, shipments):
        pool = Pool()
        Move = pool.get('stock.move')

        cls.cancel(shipments)
        for shipment in shipments:
            if shipment.state != 'cancel':
                raise AccessError(
                    gettext('sale_supply_drop_shipment'
                            '.msg_drop_shipment_delete_cancel') % {
                                'shipment': shipment.rec_name,
                            })
        Move.delete([m for s in shipments for m in s.supplier_moves])
        super(ShipmentDrop, cls).delete(shipments)

    @classmethod
    @ModelView.button
    @Workflow.transition('cancel')
    @process_sale('customer_moves')
    @process_purchase('supplier_moves')
    def cancel(cls, shipments):
        Move = Pool().get('stock.move')
        Move.cancel([m for s in shipments for m in s.supplier_moves])
        Move.cancel([
            m for s in shipments for m in s.customer_moves
            if s.state == 'shipped'
        ])
        Move.write([
            m for s in shipments
            for m in s.customer_moves if s.state != 'shipped'
        ], {'shipment': None})

    @classmethod
    @ModelView.button
    @Workflow.transition('draft')
    def draft(cls, shipments):
        pool = Pool()
        Move = pool.get('stock.move')
        PurchaseLine = pool.get('purchase.line')
        SaleLine = pool.get('sale.line')
        for shipment in shipments:
            for move in shipment.moves:
                if (move.state == 'cancel'
                        and isinstance(move.origin, (PurchaseLine, SaleLine))):
                    raise AccessError(
                        gettext('sale_supply_drop_shipment.msg_reset_move',
                                move=move.rec_name))
        Move.draft(
            [m for s in shipments for m in s.moves if m.state != 'staging'])

    @classmethod
    def _synchronize_moves(cls, shipments):
        pool = Pool()
        UoM = pool.get('product.uom')
        Move = pool.get('stock.move')

        to_save = []
        cost_exp = Decimal(str(10.0**-Move.cost_price.digits[1]))
        for shipment in shipments:
            product_qty = defaultdict(int)
            product_cost = defaultdict(int)

            for c_move in shipment.customer_moves:
                if c_move.state == 'cancel':
                    continue
                product_qty[c_move.product] += UoM.compute_qty(
                    c_move.uom,
                    c_move.quantity,
                    c_move.product.default_uom,
                    round=False)

            s_product_qty = defaultdict(int)
            for s_move in shipment.supplier_moves:
                if s_move.state == 'cancel':
                    continue
                if s_move.cost_price:
                    internal_quantity = Decimal(str(s_move.internal_quantity))
                    product_cost[s_move.product] += (s_move.unit_price *
                                                     internal_quantity)

                quantity = UoM.compute_qty(s_move.uom,
                                           s_move.quantity,
                                           s_move.product.default_uom,
                                           round=False)
                s_product_qty[s_move.product] += quantity
                if product_qty[s_move.product]:
                    if quantity <= product_qty[s_move.product]:
                        product_qty[s_move.product] -= quantity
                        continue
                    else:
                        out_quantity = (quantity - product_qty[s_move.product])
                        out_quantity = UoM.compute_qty(
                            s_move.product.default_uom, out_quantity,
                            s_move.uom)
                        product_qty[s_move.product] = 0
                else:
                    out_quantity = s_move.quantity

                if not out_quantity:
                    continue
                unit_price = UoM.compute_price(s_move.product.default_uom,
                                               s_move.product.list_price,
                                               s_move.uom)
                new_customer_move = shipment._get_customer_move(s_move)
                new_customer_move.quantity = out_quantity
                new_customer_move.unit_price = unit_price
                to_save.append(new_customer_move)

            for product, cost in product_cost.items():
                qty = Decimal(str(s_product_qty[product]))
                if qty:
                    product_cost[product] = (cost / qty).quantize(cost_exp)
            for c_move in list(shipment.customer_moves) + to_save:
                if c_move.id is not None and c_move.state == 'cancel':
                    continue
                c_move.cost_price = product_cost[c_move.product]
                if c_move.id is None:
                    continue
                if product_qty[c_move.product] > 0:
                    exc_qty = UoM.compute_qty(c_move.product.default_uom,
                                              product_qty[c_move.product],
                                              c_move.uom)
                    removed_qty = UoM.compute_qty(c_move.uom,
                                                  min(exc_qty,
                                                      c_move.quantity),
                                                  c_move.product.default_uom,
                                                  round=False)
                    c_move.quantity = max(
                        0, c_move.uom.round(c_move.quantity - exc_qty))
                    product_qty[c_move.product] -= removed_qty
                to_save.append(c_move)

        if to_save:
            Move.save(to_save)

    def _get_customer_move(self, move):
        pool = Pool()
        Move = pool.get('stock.move')
        return Move(
            from_location=move.to_location,
            to_location=self.customer.customer_location,
            product=move.product,
            uom=move.uom,
            quantity=move.quantity,
            shipment=self,
            planned_date=self.planned_date,
            company=move.company,
            currency=move.company.currency,
            unit_price=move.unit_price,
        )

    @classmethod
    @ModelView.button
    @Workflow.transition('waiting')
    def wait(cls, shipments):
        pool = Pool()
        PurchaseRequest = pool.get('purchase.request')
        SaleLine = pool.get('sale.line')
        Move = pool.get('stock.move')

        requests = []
        for sub_lines in grouped_slice([
                m.origin.id for s in shipments for m in s.supplier_moves
                if m.origin
        ]):
            requests += PurchaseRequest.search([
                ('purchase_line', 'in', list(sub_lines)),
            ])
        pline2request = {r.purchase_line: r for r in requests}
        sale_lines = SaleLine.search([
            ('purchase_request', 'in', [r.id for r in requests]),
        ])
        request2sline = {sl.purchase_request: sl for sl in sale_lines}

        to_save = []
        for shipment in shipments:
            for move in shipment.supplier_moves:
                if not move.origin:
                    continue
                sale_line = request2sline.get(pline2request.get(move.origin))
                if not sale_line:
                    continue
                for move in sale_line.moves:
                    if (move.state not in ('cancel', 'done')
                            and not move.shipment
                            and move.from_location.type == 'drop'):
                        move.shipment = shipment
                        to_save.append(move)
        Move.save(to_save)
        cls._synchronize_moves(shipments)

    @classmethod
    @ModelView.button
    @Workflow.transition('shipped')
    @process_purchase('supplier_moves')
    def ship(cls, shipments):
        pool = Pool()
        Move = pool.get('stock.move')
        Move.do([m for s in shipments for m in s.supplier_moves])
        cls._synchronize_moves(shipments)

    @classmethod
    @ModelView.button
    @Workflow.transition('done')
    @process_sale('customer_moves')
    def done(cls, shipments):
        pool = Pool()
        Move = pool.get('stock.move')
        Date = pool.get('ir.date')
        Move.do([m for s in shipments for m in s.customer_moves])
        cls.write(shipments, {
            'effective_date': Date.today(),
        })
コード例 #29
0
ファイル: product.py プロジェクト: joseantarias/stock
class ProductQuantitiesByWarehouseMove(ModelSQL, ModelView):
    "Product Quantities By Warehouse Moves"
    __name__ = 'stock.product_quantities_warehouse.move'

    date = fields.Date("Date")
    move = fields.Many2One('stock.move', "Move")
    origin = fields.Reference("Origin", selection='get_origin')
    quantity = fields.Float("Quantity")
    cumulative_quantity_start = fields.Function(
        fields.Float("Cumulative Quantity Start"), 'get_cumulative_quantity')
    cumulative_quantity_delta = fields.Float("Cumulative Quantity Delta")
    cumulative_quantity_end = fields.Function(
        fields.Float("Cumulative Quantity End"), 'get_cumulative_quantity')
    company = fields.Many2One('company.company', "Company")

    @classmethod
    def __setup__(cls):
        super().__setup__()
        cls._order.insert(0, ('date', 'ASC'))

    @classmethod
    def table_query(cls):
        pool = Pool()
        Date = pool.get('ir.date')
        Location = pool.get('stock.location')
        Move = pool.get('stock.move')
        Product = pool.get('product.product')
        move = from_ = Move.__table__()
        transaction = Transaction()
        context = transaction.context
        database = transaction.database
        today = Date.today()

        if context.get('product_template') is not None:
            product = Product.__table__()
            from_ = move.join(product, condition=move.product == product.id)
            product_clause = product.template == context['product_template']
        else:
            product_clause = move.product == context.get('product', -1)

        if 'warehouse' in context:
            warehouse = Location(context.get('warehouse'))
            if context.get('stock_skip_warehouse'):
                location_id = warehouse.storage_location.id
            else:
                location_id = warehouse.id
        else:
            location_id = -1
        warehouse = With('id',
                         query=Location.search([
                             ('parent', 'child_of', [location_id]),
                         ],
                                               query=True,
                                               order=[]))
        date_column = Coalesce(move.effective_date, move.planned_date)
        quantity = Case((move.to_location.in_(warehouse.select(
            warehouse.id)), move.internal_quantity),
                        else_=-move.internal_quantity)
        if database.has_window_functions():
            cumulative_quantity_delta = Sum(quantity,
                                            window=Window(
                                                [date_column],
                                                order_by=[move.id.asc]))
        else:
            cumulative_quantity_delta = Literal(0)
        return (from_.select(
            move.id.as_('id'),
            Literal(0).as_('create_uid'),
            CurrentTimestamp().as_('create_date'),
            Literal(None).as_('write_uid'),
            Literal(None).as_('write_date'),
            date_column.as_('date'),
            move.id.as_('move'),
            move.origin.as_('origin'),
            quantity.as_('quantity'),
            cumulative_quantity_delta.as_('cumulative_quantity_delta'),
            move.company.as_('company'),
            where=product_clause
            & ((move.from_location.in_(warehouse.select(warehouse.id))
                & ~move.to_location.in_(warehouse.select(warehouse.id)))
               | (~move.from_location.in_(warehouse.select(warehouse.id))
                  & move.to_location.in_(warehouse.select(warehouse.id))))
            & ((date_column < today) & (move.state == 'done')
               | (date_column >= today)),
            with_=warehouse))

    @classmethod
    def get_origin(cls):
        pool = Pool()
        Move = pool.get('stock.move')
        return Move.get_origin()

    @classmethod
    def get_cumulative_quantity(cls, records, names):
        pool = Pool()
        Product = pool.get('product.product')
        transaction = Transaction()
        database = transaction.database
        trans_context = transaction.context

        def valid_context(name):
            return (trans_context.get(name) is not None
                    and isinstance(trans_context[name], int))

        if not any(map(valid_context, ['product', 'product_template'])):
            return {r.id: None for r in records}

        if trans_context.get('product') is not None:
            grouping = ('product', )
            grouping_filter = ([trans_context['product']], )
            key = trans_context['product']
        else:
            grouping = ('product.template', )
            grouping_filter = ([trans_context.get('product_template')], )
            key = trans_context['product_template']
        warehouse_id = trans_context.get('warehouse')

        def cast_date(date):
            if isinstance(date, str):
                date = datetime.date(*map(int, date.split('-', 2)))
            return date

        dates = sorted({cast_date(r.date) for r in records})
        quantities = {}
        date_start = None
        for date in dates:
            try:
                context = {
                    'stock_date_start': date_start,
                    'stock_date_end': date - datetime.timedelta(days=1),
                    'forecast': True,
                }
            except OverflowError:
                pass
            with Transaction().set_context(**context):
                quantities[date] = Product.products_by_location(
                    [warehouse_id],
                    grouping=grouping,
                    grouping_filter=grouping_filter,
                    with_childs=True).get((warehouse_id, key), 0)
            date_start = date
        cumulate = 0
        for date in dates:
            cumulate += quantities[date]
            quantities[date] = cumulate

        result = {}
        if database.has_window_functions():
            if 'cumulative_quantity_start' in names:
                result['cumulative_quantity_start'] = {
                    r.id: (quantities[cast_date(r.date)] +
                           r.cumulative_quantity_delta - r.quantity)
                    for r in records
                }
            if 'cumulative_quantity_end' in names:
                result['cumulative_quantity_end'] = {
                    r.id: (quantities[cast_date(r.date)] +
                           r.cumulative_quantity_delta)
                    for r in records
                }
        else:
            values = {r.id: quantities[cast_date(r.date)] for r in records}
            for name in names:
                result[name] = values
        return result

    def get_rec_name(self, name):
        return self.move.rec_name
コード例 #30
0
class PurchaseRequisition(Workflow, ModelSQL, ModelView):
    "Purchase Requisition"
    __name__ = 'purchase.requisition'
    _rec_name = 'number'
    _states = {
        'readonly': Eval('state') != 'draft',
        }

    company = fields.Many2One(
        'company.company', "Company", required=True, select=True,
        states={
            'readonly': (Eval('state') != 'draft') | Eval('lines', [0]),
            })
    number = fields.Char('Number', readonly=True, select=True)
    description = fields.Char('Description', states=_states)
    employee = fields.Many2One(
        'company.employee', 'Employee', required=True, states=_states)
    supply_date = fields.Date(
        'Supply Date',
        states={
            'required': ~Eval('state').in_(['draft', 'cancelled']),
            'readonly': _states['readonly'],
            })
    warehouse = fields.Many2One(
        'stock.location', 'Warehouse',
        domain=[
            ('type', '=', 'warehouse'),
            ],
        states=_states)
    currency = fields.Many2One(
        'currency.currency', 'Currency',
        states={
            'readonly': (_states['readonly']
                | (Eval('lines', [0]) & Eval('currency'))),
            })
    total_amount = fields.Function(
        Monetary("Total", currency='currency', digits='currency'),
        'get_amount')
    total_amount_cache = Monetary(
        "Total Cache", currency='currency', digits='currency')
    lines = fields.One2Many(
        'purchase.requisition.line', 'requisition', 'Lines',
        states=_states)

    approved_by = employee_field(
        "Approved By", states=['approved', 'processing', 'done', 'cancelled'])
    rejected_by = employee_field(
        "Rejected By", states=['rejected', 'processing', 'done', 'cancelled'])
    state = fields.Selection([
            ('draft', "Draft"),
            ('waiting', "Waiting"),
            ('rejected', "Rejected"),
            ('approved', "Approved"),
            ('processing', "Processing"),
            ('done', "Done"),
            ('cancelled', "Cancelled"),
            ], "State", readonly=True, required=True, sort=False)

    del _states

    @classmethod
    def __setup__(cls):
        super(PurchaseRequisition, cls).__setup__()
        cls._transitions |= set((
                ('cancelled', 'draft'),
                ('rejected', 'draft'),
                ('draft', 'cancelled'),
                ('draft', 'waiting'),
                ('waiting', 'draft'),
                ('waiting', 'rejected'),
                ('waiting', 'approved'),
                ('approved', 'processing'),
                ('approved', 'draft'),
                ('processing', 'done'),
                ('done', 'processing'),
                ))
        cls._buttons.update({
                'cancel': {
                    'invisible': Eval('state') != 'draft',
                    'depends': ['state'],
                    },
                'draft': {
                    'invisible': ~Eval('state').in_(
                        ['cancelled', 'waiting', 'approved', 'rejected']),
                    'icon': If(Eval('state').in_(['cancelled', 'rejected']),
                        'tryton-undo',
                        'tryton-back'),
                    'depends': ['state'],
                    },
                'wait': {
                    'pre_validate': [('supply_date', '!=', None)],
                    'invisible': ((Eval('state') != 'draft')
                        | ~Eval('lines', [])),
                    'readonly': ~Eval('lines', []),
                    'depends': ['state'],
                    },
                'approve': {
                    'invisible': Eval('state') != 'waiting',
                    'depends': ['state'],
                    },
                'process': {
                    'invisible': ~Eval('state').in_(
                        ['approved', 'processing']),
                    'icon': If(Eval('state') == 'approved',
                        'tryton-forward', 'tryton-refresh'),
                    'depends': ['state'],
                    },
                'reject': {
                    'invisible': Eval('state') != 'waiting',
                    'depends': ['state'],
                    },
                })
        # The states where amounts are cached
        cls._states_cached = ['approved', 'done', 'rejected',
            'processing', 'cancelled']

    @classmethod
    def __register__(cls, module_name):
        cursor = Transaction().connection.cursor()
        table = cls.__table__()

        super().__register__(module_name)

        # Migration from 5.6: rename state cancel to cancelled
        cursor.execute(*table.update(
                [table.state], ['cancelled'],
                where=table.state == 'cancel'))

    @classmethod
    def default_state(cls):
        return 'draft'

    @classmethod
    def default_company(cls):
        return Transaction().context.get('company')

    @classmethod
    def default_employee(cls):
        return Transaction().context.get('employee')

    @classmethod
    def default_warehouse(cls):
        Location = Pool().get('stock.location')
        return Location.get_default_warehouse()

    @classmethod
    def default_currency(cls):
        Company = Pool().get('company.company')
        company = Transaction().context.get('company')
        if company:
            return Company(company).currency.id

    @fields.depends('lines', 'currency')
    def on_change_with_total_amount(self):
        self.total_amount = Decimal('0.0')
        if self.lines:
            for line in self.lines:
                self.total_amount += getattr(line, 'amount', None) or 0
        if self.currency:
            self.total_amount = self.currency.round(self.total_amount)
        return self.total_amount

    @classmethod
    def store_cache(cls, requisitions):
        for requisition in requisitions:
            requisition.total_amount_cache = requisition.total_amount
        cls.save(requisitions)

    @classmethod
    def get_amount(cls, requisitions, name):
        total_amount = {}

        # Sort cached first and re-instantiate to optimize cache management
        requisitions = sorted(requisitions,
            key=lambda r: r.state in cls._states_cached, reverse=True)
        requisitions = cls.browse(requisitions)
        for requisition in requisitions:
            if (requisition.state in cls._states_cached
                    and requisition.total_amount_cache is not None):
                total_amount[requisition.id] = requisition.total_amount_cache
            else:
                total_amount[requisition.id] = (
                    requisition.on_change_with_total_amount())
        return total_amount

    @classmethod
    def create_requests(cls, requisitions):
        pool = Pool()
        Request = pool.get('purchase.request')
        requests = []
        for requisition in requisitions:
            for line in requisition.lines:
                request = line.compute_request()
                if request:
                    requests.append(request)
        if requests:
            Request.save(requests)

    @classmethod
    def view_attributes(cls):
        return super().view_attributes() + [
            ('/tree', 'visual',
                If(Eval('state') == 'cancelled', 'muted', '')),
            ]

    @classmethod
    def create(cls, vlist):
        pool = Pool()
        Config = pool.get('purchase.configuration')

        config = Config(1)
        vlist = [v.copy() for v in vlist]
        default_company = cls.default_company()
        for values in vlist:
            if values.get('number') is None:
                values['number'] = config.get_multivalue(
                    'purchase_requisition_sequence',
                    company=values.get('company', default_company)).get()
        return super(PurchaseRequisition, cls).create(vlist)

    @classmethod
    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 check_for_waiting(self):
        if not self.warehouse:
            for line in self.lines:
                if line.product and line.product.type in {'goods', 'assets'}:
                    raise RequiredValidationError(
                        gettext('purchase_requisition.msg_warehouse_required',
                            requisition=self.rec_name))

    @classmethod
    def copy(cls, requisitions, default=None):
        if default is None:
            default = {}
        else:
            default = default.copy()
        default.setdefault('number', None)
        default.setdefault('supply_date', None)
        default.setdefault('approved_by')
        default.setdefault('rejected_by')
        return super(PurchaseRequisition, cls).copy(
            requisitions, default=default)

    @classmethod
    @ModelView.button
    @Workflow.transition('cancelled')
    def cancel(cls, requisitions):
        cls.store_cache(requisitions)

    @classmethod
    @ModelView.button
    @Workflow.transition('draft')
    @reset_employee('approved_by', 'rejected_by')
    def draft(cls, requisitions):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('waiting')
    def wait(cls, requisitions):
        for requisition in requisitions:
            requisition.check_for_waiting()

    @classmethod
    @ModelView.button
    @Workflow.transition('rejected')
    @set_employee('rejected_by')
    def reject(cls, requisitions):
        pass

    @classmethod
    @ModelView.button
    @Workflow.transition('approved')
    @set_employee('approved_by')
    def approve(cls, requisitions):
        pool = Pool()
        Configuration = pool.get('purchase.configuration')
        transaction = Transaction()
        context = transaction.context
        cls.store_cache(requisitions)
        config = Configuration(1)
        with transaction.set_context(
                queue_scheduled_at=config.purchase_process_after,
                queue_batch=context.get('queue_batch', True)):
            cls.__queue__.process(requisitions)

    @classmethod
    @Workflow.transition('processing')
    def proceed(cls, requisitions):
        pass

    @classmethod
    @Workflow.transition('done')
    def do(cls, requisitions):
        pass

    @classmethod
    @ModelView.button
    def process(cls, requisitions):
        done = []
        process = []
        requisitions = [r for r in requisitions
            if r.state in {'approved', 'processing', 'done'}]
        cls.create_requests(requisitions)
        for requisition in requisitions:
            if requisition.is_done():
                if requisition.state != 'done':
                    done.append(requisition)
            elif requisition.state != 'processing':
                process.append(requisition)
        if process:
            cls.proceed(process)
        if done:
            cls.do(done)

    def is_done(self):
        return all(
            r.purchase and r.purchase.state in {'cancelled', 'confirmed'}
            for l in self.lines for r in l.purchase_requests)