16621609190

Committed 30 Jul 2025 11:43AM UTC coverage: 84.491% (+0.008%) from 84.483%

Build # 16621609190

Build Type

push

github

Committed by

rerowep

Commit Message

chore: update dependencies

Co-Authored-by: Peter Weber <peter.weber@rero.ch>

Run Details

4560 of 5397 relevant lines covered (84.49%)

0.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.29

/rero_mef/agents/api.py

# RERO MEF
# Copyright (C) 2020 RERO
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, version 3 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""API for manipulating records."""

from flask import current_app

from rero_mef.utils import build_ref_string

from ..api import Action, EntityIndexer, EntityRecord


class AgentRecord(EntityRecord):
    """Agent Record class."""

    name = None

    @classmethod
    def create(
        cls,
        data,
        id_=None,
        delete_pid=False,
        dbcommit=False,
        reindex=False,
        md5=True,
        **kwargs,
    ):
        """Create a new agent record."""
        return super().create(
            data=data,
            id_=id_,
            delete_pid=delete_pid,
            dbcommit=dbcommit,
            reindex=reindex,
            md5=True,
            **kwargs,
        )

    def delete(self, force=False, dbcommit=False, delindex=False):
        """Delete agent from MEF record."""
        from .mef.api import AgentMefRecord

        for mef_record in AgentMefRecord.get_mef(self.pid, self.name):
            mef_record.delete_ref(self, dbcommit=dbcommit, reindex=delindex)
        return super().delete(force=force, dbcommit=dbcommit, delindex=delindex)

    def create_or_update_mef(self, dbcommit=False, reindex=False, viaf_record=None):
        """Create or update MEF.

        :param dbcommit: Commit changes to DB.
        :param reindex: Reindex record.
        :param viaf_record: VIAF record to use if we know it before.
        :returns: MEF record, MEF action
        """
        from rero_mef.agents import AgentMefRecord, AgentViafRecord

        mef_records = []
        mef_pids = set()
        mef_actions = {}
        viaf_records = [viaf_record] if viaf_record else []
        viaf_pids = {viaf_record.pid} if viaf_record else set()
        # get all VIAF records
        for viaf in AgentViafRecord.get_viaf(self):
            if viaf.pid not in viaf_pids:
                viaf_pids.add(viaf.pid)
                viaf_records.append(viaf)
        if len(viaf_records) > 1:
            current_app.logger.error(
                f"MULTIPLE VIAF FOUND FOR: {self.name} {self.pid} | "
                f"viaf: {', '.join([viaf.pid for viaf in viaf_records])}"
            )
        # get all VIAF associated MEF records.
        for viaf in viaf_records:
            for mef in AgentMefRecord.get_mef(viaf.pid, viaf.name):
                if mef.pid not in mef_pids:
                    mef_pids.add(mef.pid)
                    mef_records.append(mef)
        # get all MEF records by agent pid
        for mef in AgentMefRecord.get_mef(self.pid, self.name):
            if mef.pid not in mef_pids:
                mef_pids.add(mef.pid)
                mef_records.append(mef)
        if len(mef_records) > 1:
            current_app.logger.error(
                f"MULTIPLE MEF FOUND FOR: {self.name} {self.pid} | "
                f"mef: {', '.join([mef.pid for mef in mef_records])}"
            )

        ref_string = build_ref_string(
            entity_type="agents", entity_name=self.name, entity_pid=self.pid
        )
        old_pids = set()
        if mef_records:
            # We have MEF records change them.
            for mef in mef_records[1:]:
                # Delete ref in MEF records
                if old_ref := mef.pop(self.name, None):
                    old_pid = old_ref["$ref"].split("/")[-1]
                    if old_pid != self.pid:
                        old_pids.add(old_pid)
                        mef_actions[old_pid] = Action.DELETE
                mef.update(data=mef, dbcommit=dbcommit, reindex=reindex)
                mef_actions[mef.pid] = Action.DISCARD
            # Update first MEF record
            mef_record = mef_records[0]
            if old_ref := mef_record.get(self.name):
                old_pid = old_ref["$ref"].split("/")[-1]
            else:
                old_pid = None
            if old_pid != self.pid:
                if old_pid:
                    old_pids.add(old_pid)
                    mef_actions[old_pid] = Action.DELETE
                mef_record[self.name] = {"$ref": ref_string}
            mef_record.set_deleted()
            mef_record = mef_record.update(
                data=mef_record, dbcommit=dbcommit, reindex=reindex
            )
            mef_actions[mef_record.pid] = Action.UPDATE
        else:
            # No MEF record create one.
            mef_data = {self.name: {"$ref": ref_string}}
            if self.deleted and not mef_data.get("deleted"):
                mef_data["deleted"] = self.deleted
            if viaf_records:
                mef_data["viaf_pid"] = viaf_records[0].pid
            mef_record = AgentMefRecord.create(
                data=mef_data,
                dbcommit=dbcommit,
                reindex=reindex,
            )
            mef_actions[mef_record.pid] = Action.CREATE
        if reindex:
            AgentMefRecord.flush_indexes()
        # create all MEF records for old pids
        for old_pid in old_pids:
            old_rec = self.get_record_by_pid(old_pid)
            mef, action = old_rec.create_or_update_mef(dbcommit=True, reindex=True)
            mef_actions[old_pid] = action
        return mef_record, mef_actions

    @classmethod
    def get_online_record(cls, id_, debug=False):
        """Get online Record.

        Has to be overloaded in agent class.

        :param id_: Id of online record.
        :param debug: Debug print.
        :returns: record or None
        Has to be overloaded in agent class.
        """
        raise NotImplementedError()

    def reindex(self, forceindex=False):
        """Reindex record."""
        from .mef.api import AgentMefRecord

        result = super().reindex(forceindex=forceindex)
        # reindex MEF records
        for mef_record in AgentMefRecord.get_mef(self.pid, self.name):
            mef_record.reindex(forceindex=forceindex)
        return result


class AgentIndexer(EntityIndexer):
    """Indexing class for agents."""

1	# RERO MEF
2	# Copyright (C) 2020 RERO
3	#
4	# This program is free software: you can redistribute it and/or modify
5	# it under the terms of the GNU Affero General Public License as published by
6	# the Free Software Foundation, version 3 of the License.
7	#
8	# This program is distributed in the hope that it will be useful,
9	# but WITHOUT ANY WARRANTY; without even the implied warranty of
10	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11	# GNU Affero General Public License for more details.
12	#
13	# You should have received a copy of the GNU Affero General Public License
14	# along with this program. If not, see <http://www.gnu.org/licenses/>.
15	"""API for manipulating records."""
16
17	from flask import current_app	1✔
18
19	from rero_mef.utils import build_ref_string	1✔
20
21	from ..api import Action, EntityIndexer, EntityRecord	1✔
22
23
24	class AgentRecord(EntityRecord):	1✔
25	"""Agent Record class."""
26
27	name = None	1✔
28
29	@classmethod	1✔
30	def create(	1✔
31	cls,
32	data,
33	id_=None,
34	delete_pid=False,
35	dbcommit=False,
36	reindex=False,
37	md5=True,
38	**kwargs,
39	):
40	"""Create a new agent record."""
41	return super().create(	1✔
42	data=data,
43	id_=id_,
44	delete_pid=delete_pid,
45	dbcommit=dbcommit,
46	reindex=reindex,
47	md5=True,
48	**kwargs,
49	)
50
51	def delete(self, force=False, dbcommit=False, delindex=False):	1✔
52	"""Delete agent from MEF record."""
53	from .mef.api import AgentMefRecord	1✔
54
55	for mef_record in AgentMefRecord.get_mef(self.pid, self.name):	1✔
56	mef_record.delete_ref(self, dbcommit=dbcommit, reindex=delindex)	1✔
57	return super().delete(force=force, dbcommit=dbcommit, delindex=delindex)	1✔
58
59	def create_or_update_mef(self, dbcommit=False, reindex=False, viaf_record=None):	1✔
60	"""Create or update MEF.
61
62	:param dbcommit: Commit changes to DB.
63	:param reindex: Reindex record.
64	:param viaf_record: VIAF record to use if we know it before.
65	:returns: MEF record, MEF action
66	"""
67	from rero_mef.agents import AgentMefRecord, AgentViafRecord	1✔
68
69	mef_records = []	1✔
70	mef_pids = set()	1✔
71	mef_actions = {}	1✔
72	viaf_records = [viaf_record] if viaf_record else []	1✔
73	viaf_pids = {viaf_record.pid} if viaf_record else set()	1✔
74	# get all VIAF records
75	for viaf in AgentViafRecord.get_viaf(self):	1✔
76	if viaf.pid not in viaf_pids:	1✔
77	viaf_pids.add(viaf.pid)	1✔
78	viaf_records.append(viaf)	1✔
79	if len(viaf_records) > 1:	1✔
80	current_app.logger.error(	×
81	f"MULTIPLE VIAF FOUND FOR: {self.name} {self.pid} \| "
82	f"viaf: {', '.join([viaf.pid for viaf in viaf_records])}"
83	)
84	# get all VIAF associated MEF records.
85	for viaf in viaf_records:	1✔
86	for mef in AgentMefRecord.get_mef(viaf.pid, viaf.name):	1✔
87	if mef.pid not in mef_pids:	1✔
88	mef_pids.add(mef.pid)	1✔
89	mef_records.append(mef)	1✔
90	# get all MEF records by agent pid
91	for mef in AgentMefRecord.get_mef(self.pid, self.name):	1✔
92	if mef.pid not in mef_pids:	1✔
93	mef_pids.add(mef.pid)	1✔
94	mef_records.append(mef)	1✔
95	if len(mef_records) > 1:	1✔
96	current_app.logger.error(	1✔
97	f"MULTIPLE MEF FOUND FOR: {self.name} {self.pid} \| "
98	f"mef: {', '.join([mef.pid for mef in mef_records])}"
99	)
100
101	ref_string = build_ref_string(	1✔
102	entity_type="agents", entity_name=self.name, entity_pid=self.pid
103	)
104	old_pids = set()	1✔
105	if mef_records:	1✔
106	# We have MEF records change them.
107	for mef in mef_records[1:]:	1✔
108	# Delete ref in MEF records
109	if old_ref := mef.pop(self.name, None):	1✔
110	old_pid = old_ref["$ref"].split("/")[-1]	1✔
111	if old_pid != self.pid:	1✔
112	old_pids.add(old_pid)	×
113	mef_actions[old_pid] = Action.DELETE	×
114	mef.update(data=mef, dbcommit=dbcommit, reindex=reindex)	1✔
115	mef_actions[mef.pid] = Action.DISCARD	1✔
116	# Update first MEF record
117	mef_record = mef_records[0]	1✔
118	if old_ref := mef_record.get(self.name):	1✔
119	old_pid = old_ref["$ref"].split("/")[-1]	1✔
120	else:
121	old_pid = None	1✔
122	if old_pid != self.pid:	1✔
123	if old_pid:	1✔
124	old_pids.add(old_pid)	×
125	mef_actions[old_pid] = Action.DELETE	×
126	mef_record[self.name] = {"$ref": ref_string}	1✔
127	mef_record.set_deleted()	1✔
128	mef_record = mef_record.update(	1✔
129	data=mef_record, dbcommit=dbcommit, reindex=reindex
130	)
131	mef_actions[mef_record.pid] = Action.UPDATE	1✔
132	else:
133	# No MEF record create one.
134	mef_data = {self.name: {"$ref": ref_string}}	1✔
135	if self.deleted and not mef_data.get("deleted"):	1✔
136	mef_data["deleted"] = self.deleted	1✔
137	if viaf_records:	1✔
138	mef_data["viaf_pid"] = viaf_records[0].pid	1✔
139	mef_record = AgentMefRecord.create(	1✔
140	data=mef_data,
141	dbcommit=dbcommit,
142	reindex=reindex,
143	)
144	mef_actions[mef_record.pid] = Action.CREATE	1✔
145	if reindex:	1✔
146	AgentMefRecord.flush_indexes()	1✔
147	# create all MEF records for old pids
148	for old_pid in old_pids:	1✔
149	old_rec = self.get_record_by_pid(old_pid)	×
150	mef, action = old_rec.create_or_update_mef(dbcommit=True, reindex=True)	×
151	mef_actions[old_pid] = action	×
152	return mef_record, mef_actions	1✔
153
154	@classmethod	1✔
155	def get_online_record(cls, id_, debug=False):	1✔
156	"""Get online Record.
157
158	Has to be overloaded in agent class.
159
160	:param id_: Id of online record.
161	:param debug: Debug print.
162	:returns: record or None
163	Has to be overloaded in agent class.
164	"""
165	raise NotImplementedError()	×
166
167	def reindex(self, forceindex=False):	1✔
168	"""Reindex record."""
169	from .mef.api import AgentMefRecord	1✔
170
171	result = super().reindex(forceindex=forceindex)	1✔
172	# reindex MEF records
173	for mef_record in AgentMefRecord.get_mef(self.pid, self.name):	1✔
174	mef_record.reindex(forceindex=forceindex)	1✔
175	return result	1✔
176
177
178	class AgentIndexer(EntityIndexer):	1✔
179	"""Indexing class for agents."""

rero / rero-mef / 16621609190

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous