party.py

# This file is part of Tryton.  The COPYRIGHT file at the top level of
# this repository contains the full copyright notices and license terms.
import json
from functools import partial

from sql import As, Column, Literal, Null, Union, With
from sql.aggregate import Min

from trytond.config import config
from trytond.model import ModelSQL, ModelView, fields
from trytond.pool import Pool, PoolMeta
from trytond.transaction import Transaction

dumps = partial(json.dumps, separators=(',', ':'), sort_keys=True)
default_depth = config.getint('party_relationship', 'depth', default=7)


class RelationType(ModelSQL, ModelView):
    'Relation Type'
    __name__ = 'party.relation.type'

    name = fields.Char('Name', required=True, translate=True,
        help="The main identifier of the relation type.")
    reverse = fields.Many2One('party.relation.type', 'Reverse Relation',
        help="Create automatically the reverse relation.")
    usages = fields.MultiSelection([], "Usages")

    @classmethod
    def view_attributes(cls):
        attributes = super().view_attributes()
        if not cls.usages.selection:
            attributes.extend([
                    ('//separator[@name="usages"]',
                        'states', {'invisible': True}),
                    ('//field[@name="usages"]', 'invisible', 1),
                    ])
        return attributes


class Relation(ModelSQL):
    'Party Relation'
    __name__ = 'party.relation'

    from_ = fields.Many2One('party.party', 'From', required=True, select=True,
        ondelete='CASCADE')
    to = fields.Many2One('party.party', 'To', required=True, select=True,
        ondelete='CASCADE')
    type = fields.Many2One('party.relation.type', 'Type', required=True,
        select=True)

    @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,
            ('from_',) + tuple(clause[1:]),
            ('to',) + tuple(clause[1:]),
            ('type',) + tuple(clause[1:]),
            ]


class RelationAll(Relation, ModelView):
    'Party Relation'
    __name__ = 'party.relation.all'

    @classmethod
    def get_table_for_table_query(cls):
        Relation = Pool().get('party.relation')
        return Relation.__table__()

    @classmethod
    def table_query(cls):
        pool = Pool()
        Relation = pool.get('party.relation')
        Type = pool.get('party.relation.type')
        # FLA: Fix #11470: Add a hook in order to be able to use it in
        # party_cog to manage party relation history
        relation = cls.get_table_for_table_query()
        type = Type.__table__()

        tables = {
            None: (relation, None)
            }
        reverse_tables = {
            None: (relation, None),
            'type': {
                None: (type, (relation.type == type.id)
                    & (type.reverse != Null)),
                },
            }

        columns = []
        reverse_columns = []
        for name, field in Relation._fields.items():
            if hasattr(field, 'get'):
                continue
            column, reverse_column = cls._get_column(tables, reverse_tables,
                name)
            columns.append(column)
            reverse_columns.append(reverse_column)

        def convert_from(table, tables):
            right, condition = tables[None]
            if table:
                table = table.join(right, condition=condition)
            else:
                table = right
            for k, sub_tables in tables.items():
                if k is None:
                    continue
                table = convert_from(table, sub_tables)
            return table

        query = convert_from(None, tables).select(*columns)
        reverse_query = convert_from(None, reverse_tables).select(
            *reverse_columns)
        return Union(query, reverse_query, all_=True)

    @classmethod
    def _get_column(cls, tables, reverse_tables, name):
        table, _ = tables[None]
        reverse_table, _ = reverse_tables[None]
        if name == 'id':
            return As(table.id * 2, name), As(reverse_table.id * 2 + 1, name)
        elif name == 'from_':
            # FLA: Fix #11470: Use column in order to be able to use
            # _get_history_table
            return Column(table, 'from_'), reverse_table.to.as_(name)
        elif name == 'to':
            # FLA: Fix #11470: Use column in order to be able to use
            # _get_history_table
            return table.to, Column(reverse_table, 'from_').as_(name)
        elif name == 'type':
            reverse_type, _ = reverse_tables[name][None]
            return table.type, reverse_type.reverse.as_(name)
        else:
            return Column(table, name), Column(reverse_table, name)

    @staticmethod
    def convert_instances(relations):
        "Converts party.relation.all instances to party.relation "
        pool = Pool()
        Relation = pool.get('party.relation')
        return Relation.browse([x.id // 2 for x in relations])

    @property
    def reverse_id(self):
        if self.id % 2:
            return self.id - 1
        else:
            return self.id + 1

    @classmethod
    def create(cls, vlist):
        pool = Pool()
        Relation = pool.get('party.relation')
        relations = Relation.create(vlist)
        return cls.browse([r.id * 2 for r in relations])

    @classmethod
    def write(cls, *args):
        pool = Pool()
        Relation = pool.get('party.relation')
        RelationType = pool.get('party.relation.type')

        all_records = sum(args[0:None:2], [])

        # Increase transaction counter
        Transaction().counter += 1

        # Clean local cache
        for record in all_records:
            for record_id in (record.id, record.reverse_id):
                record._local_cache.pop(record_id, None)

        # Clean cursor cache
        for cache in Transaction().cache.values():
            if cls.__name__ in cache:
                cache_cls = cache[cls.__name__]
                for record in all_records:
                    for record_id in (record.id, record.reverse_id):
                        cache_cls.pop(record_id, None)

        actions = iter(args)
        args = []
        for relations, values in zip(actions, actions):
            reverse_values = values.copy()
            if 'from_' in values and 'to' in values:
                reverse_values['from_'], reverse_values['to'] = \
                    reverse_values['to'], reverse_values['from_']
            elif 'from_' in values:
                reverse_values['to'] = reverse_values.pop('from_')
            elif 'to' in values:
                reverse_values['from_'] = reverse_values.pop('to')
            if values.get('type'):
                type_ = RelationType(values['type'])
                reverse_values['type'] = (type_.reverse.id
                    if type_.reverse else None)
            straight_relations = [r for r in relations if not r.id % 2]
            reverse_relations = [r for r in relations if r.id % 2]
            if straight_relations:
                args.extend(
                    (cls.convert_instances(straight_relations), values))
            if reverse_relations:
                args.extend(
                    (cls.convert_instances(reverse_relations), reverse_values))
        Relation.write(*args)

    @classmethod
    def delete(cls, relations):
        pool = Pool()
        Relation = pool.get('party.relation')

        # Increase transaction counter
        Transaction().counter += 1

        # Clean cursor cache
        for cache in list(Transaction().cache.values()):
            for cache in (cache,
                    list(cache.get('_language_cache', {}).values())):
                if cls.__name__ in cache:
                    cache_cls = cache[cls.__name__]
                    for record in relations:
                        for record_id in (record.id, record.reverse_id):
                            cache_cls.pop(record_id, None)

        Relation.delete(cls.convert_instances(relations))


class Party(metaclass=PoolMeta):
    __name__ = 'party.party'

    relations = fields.One2Many('party.relation.all', 'from_', 'Relations')

    @classmethod
    def _distance_query(cls, usages=None, party=None, depth=None):
        pool = Pool()
        RelationAll = pool.get('party.relation.all')
        RelationType = pool.get('party.relation.type')

        transaction = Transaction()
        context = transaction.context
        database = transaction.database

        query = super()._distance_query(
            usages=usages, party=party, depth=depth)

        if usages is None:
            usages = context.get('relation_usages', [])
        if party is None:
            party = context.get('related_party')
        if depth is None:
            depth = context.get('depth', default_depth)

        if not party:
            return query

        all_relations = RelationAll.__table__()

        if usages:
            relation_type = RelationType.__table__()
            try:
                usages_clause = database.json_any_keys_exist(
                    relation_type.usages, list(usages))
            except NotImplementedError:
                usages_clause = Literal(False)
                for usage in usages:
                    usages_clause |= relation_type.usages.like(
                        '%' + dumps(usage) + '%')
            relations = (all_relations
                .join(relation_type,
                    condition=all_relations.type == relation_type.id)
                .select(
                    all_relations.from_, all_relations.to,
                    where=usages_clause))
        else:
            relations = all_relations

        distance = With('from_', 'to', 'distance', recursive=True)
        distance.query = relations.select(
            Column(relations, 'from_'),
            relations.to,
            Literal(1).as_('distance'),
            where=Column(relations, 'from_') == party)
        distance.query |= (distance
            .join(relations,
                condition=distance.to == Column(relations, 'from_'))
            .select(
                distance.from_,
                relations.to,
                (distance.distance + Literal(1)).as_('distance'),
                where=(relations.to != party)
                & (distance.distance < depth)))
        distance.query.all_ = True

        relation_distance = distance.select(
            distance.to, Min(distance.distance).as_('distance'),
            group_by=[distance.to], with_=[distance])
        if query:
            relation_distance |= query
        return relation_distance