e667ae68-7418-40f7-b1db-97651d428761

Committed 11 Aug 2025 05:17PM UTC coverage: 46.666% (+1.3%) from 45.341%

Build # e667ae68-7418-40f7-b1db-97651d428761

Build Type

push

circleci

Committed by

mpasternak

Commit Message

Merge branch 'release/v202508.1188'

Run Details

11 of 116 new or added lines in 8 files covered. (9.48%)

1186 existing lines in 91 files now uncovered.

17772 of 38083 relevant lines covered (46.67%)

1.19 hits per line

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

23.01

src/pbn_api/client.py

import json
import random
import sys
import time
import warnings
from builtins import NotImplementedError
from pprint import pprint
from urllib.parse import parse_qs, quote, urlparse

import requests
from django.core.mail import mail_admins
from django.db import transaction
from django.db.models import Model
from requests import ConnectionError
from requests.exceptions import JSONDecodeError as RequestsJSONDecodeError
from requests.exceptions import SSLError
from sentry_sdk import capture_exception
from simplejson.errors import JSONDecodeError

from import_common.core import (
    matchuj_aktualna_dyscypline_pbn,
    matchuj_nieaktualna_dyscypline_pbn,
)
from import_common.normalization import normalize_kod_dyscypliny
from pbn_api.adapters.wydawnictwo import (
    OplataZaWydawnictwoPBNAdapter,
    WydawnictwoPBNAdapter,
)
from pbn_api.const import (
    DEFAULT_BASE_URL,
    NEEDS_PBN_AUTH_MSG,
    PBN_DELETE_PUBLICATION_STATEMENT,
    PBN_GET_DISCIPLINES_URL,
    PBN_GET_INSTITUTION_PUBLICATIONS_V2,
    PBN_GET_INSTITUTION_STATEMENTS,
    PBN_GET_JOURNAL_BY_ID,
    PBN_GET_LANGUAGES_URL,
    PBN_GET_PUBLICATION_BY_ID_URL,
    PBN_POST_INSTITUTION_STATEMENTS_URL,
    PBN_POST_PUBLICATION_FEE_URL,
    PBN_POST_PUBLICATION_NO_STATEMENTS_URL,
    PBN_POST_PUBLICATIONS_URL,
    PBN_SEARCH_PUBLICATIONS_URL,
)
from pbn_api.exceptions import (
    AccessDeniedException,
    AuthenticationConfigurationError,
    AuthenticationResponseError,
    CannotDeleteStatementsException,
    HttpException,
    NeedsPBNAuthorisationException,
    NoFeeDataException,
    NoPBNUIDException,
    PBNUIDChangedException,
    PBNUIDSetToExistentException,
    PraceSerwisoweException,
    PublikacjaInstytucjiV2NieZnalezionaException,
    ResourceLockedException,
    SameDataUploadedRecently,
    ZnalezionoWielePublikacjiInstytucjiV2Exception,
)
from pbn_api.models import TlumaczDyscyplin
from pbn_api.models.discipline import Discipline, DisciplineGroup
from pbn_api.models.sentdata import SentData

from django.contrib.contenttypes.models import ContentType

from django.utils.itercompat import is_iterable


def smart_content(content):
    try:
        return content.decode("utf-8")
    except UnicodeDecodeError:
        return content


class PBNClientTransport:
    def __init__(self, app_id, app_token, base_url, user_token=None):
        self.app_id = app_id
        self.app_token = app_token

        self.base_url = base_url
        if self.base_url is None:
            self.base_url = DEFAULT_BASE_URL

        self.access_token = user_token


class PageableResource:
    def __init__(self, transport, res, url, headers, body=None, method="get"):
        self.url = url
        self.headers = headers
        self.transport = transport
        self.body = body
        self.method = getattr(transport, method)

        try:
            self.page_0 = res["content"]
        except KeyError:
            self.page_0 = []

        self.current_page = res["number"]
        self.total_elements = res["totalElements"]
        self.total_pages = res["totalPages"]
        self.done = False

    def count(self):
        return self.total_elements

    def fetch_page(self, current_page):
        if current_page == 0:
            return self.page_0
        # print(f"FETCH {current_page}")

        kw = {"headers": self.headers}
        if self.body:
            kw["body"] = self.body

        ret = self.method(self.url + f"&page={current_page}", **kw)
        # print(f"FETCH DONE {current_page}")

        try:
            return ret["content"]
        except KeyError:
            return

    def __iter__(self):
        for n in range(0, self.total_pages):
            yield from self.fetch_page(n)


class OAuthMixin:
    @classmethod
    def get_auth_url(klass, base_url, app_id):
        return f"{base_url}/auth/pbn/api/registration/user/token/{app_id}"

    @classmethod
    def get_user_token(klass, base_url, app_id, app_token, one_time_token):
        headers = {
            "X-App-Id": app_id,
            "X-App-Token": app_token,
        }
        body = {"oneTimeToken": one_time_token}
        url = f"{base_url}/auth/pbn/api/user/token"
        response = requests.post(url=url, json=body, headers=headers)
        try:
            response.json()
        except ValueError:
            if response.content.startswith(b"Mismatched X-APP-TOKEN: "):
                raise AuthenticationConfigurationError(
                    "Token aplikacji PBN nieprawidłowy. Poproś administratora "
                    "o skonfigurowanie prawidłowego tokena aplikacji PBN w "
                    "ustawieniach obiektu Uczelnia. "
                )

            raise AuthenticationResponseError(response.content)

        return response.json().get("X-User-Token")

    def authorize(self, base_url, app_id, app_token):
        from pbn_api.conf import settings

        if self.access_token:
            return True

        self.access_token = getattr(settings, "PBN_CLIENT_USER_TOKEN", None)
        if self.access_token:
            return True

        auth_url = OAuthMixin.get_auth_url(base_url, app_id)

        print(
            f"""I have launched a web browser with {auth_url} ,\nplease log-in,
             then paste the redirected URL below. \n"""
        )
        import webbrowser

        webbrowser.open(auth_url)
        redirect_response = input("Paste the full redirect URL here:")
        one_time_token = parse_qs(urlparse(redirect_response).query).get("ott")[0]
        print("ONE TIME TOKEN", one_time_token)

        self.access_token = OAuthMixin.get_user_token(
            base_url, app_id, app_token, one_time_token
        )

        print("ACCESS TOKEN", self.access_token)
        return True


class RequestsTransport(OAuthMixin, PBNClientTransport):
    def get(self, url, headers=None, fail_on_auth_missing=False):
        sent_headers = {"X-App-Id": self.app_id, "X-App-Token": self.app_token}
        if self.access_token:
            sent_headers["X-User-Token"] = self.access_token

        # Jeżeli ustawimy taki nagłówek dla "niewinnych" zapytań GET, to PBN
        # API odrzuca takie połączenie z kodem 403, stąd nie:
        # if hasattr(self, "access_token"):
        #     sent_headers["X-User-Token"] = self.access_token

        if headers is not None:
            sent_headers.update(headers)

        retries = 0
        MAX_RETRIES = 15

        while retries < MAX_RETRIES:
            try:
                ret = requests.get(self.base_url + url, headers=sent_headers)
                break
            except (SSLError, ConnectionError) as e:
                retries += 1
                time.sleep(random.randint(1, 5))
                if retries >= MAX_RETRIES:
                    raise e

        if ret.status_code == 403:
            if fail_on_auth_missing:
                raise AccessDeniedException(url, smart_content(ret.content))
            # Needs auth
            if ret.json()["message"] == "Access Denied":
                # Autoryzacja użytkownika jest poprawna, jednakże nie ma on po stronie PBN
                # takiego uprawnienia...
                raise AccessDeniedException(url, smart_content(ret.content))

            # elif ret.json['message'] == "Forbidden":  # <== to dostaniemy, gdy token zły lub brak

            if hasattr(self, "authorize"):
                ret = self.authorize(self.base_url, self.app_id, self.app_token)
                if not ret:
                    return

                # Podejmuj ponowną próbę tylko w przypadku udanej autoryzacji
                return self.get(url, headers, fail_on_auth_missing=True)

        if ret.status_code >= 400:
            raise HttpException(ret.status_code, url, smart_content(ret.content))

        try:
            return ret.json()
        except (RequestsJSONDecodeError, JSONDecodeError) as e:
            if ret.status_code == 200 and b"prace serwisowe" in ret.content:
                # open("pbn_client_dump.html", "wb").write(ret.content)
                raise PraceSerwisoweException()
            raise e

    def post(self, url, headers=None, body=None, delete=False):
        if not hasattr(self, "access_token"):
            ret = self.authorize(self.base_url, self.app_id, self.app_token)
            if not ret:
                return
            return self.post(url, headers=headers, body=body, delete=delete)

        sent_headers = {
            "X-App-Id": self.app_id,
            "X-App-Token": self.app_token,
            "X-User-Token": self.access_token,
        }

        if headers is not None:
            sent_headers.update(headers)

        method = requests.post
        if delete:
            method = requests.delete

        ret = method(self.base_url + url, headers=sent_headers, json=body)

        # if ret.status_code != 200:
        #     pprint(sent_headers)
        #     pprint(body)

        if ret.status_code == 403:
            try:
                ret_json = ret.json()
            except BaseException:
                raise HttpException(
                    ret.status_code,
                    url,
                    "Blad podczas odkodowywania JSON podczas odpowiedzi 403: "
                    + smart_content(ret.content),
                )

            # Needs auth
            if ret_json.get("message") == "Access Denied":
                # Autoryzacja użytkownika jest poprawna, jednakże nie ma on po stronie PBN
                # takiego uprawnienia...
                raise AccessDeniedException(url, smart_content(ret.content))

            if ret_json.get("message") == "Forbidden" and ret_json.get(
                "description"
            ).startswith(NEEDS_PBN_AUTH_MSG):
                # (403, '/api/v1/search/publications?size=10', '{"code":403,"message":"Forbidden",
                # "description":"W celu poprawnej autentykacji należy podać poprawny token użytkownika aplikacji. Podany
                # token użytkownika ... w ramach aplikacji ... nie istnieje lub został
                # unieważniony!"}')
                raise NeedsPBNAuthorisationException(
                    ret.status_code, url, smart_content(ret.content)
                )

            # mpasternak, 5.09.2021: nie do końca jestem pewny, czy kod wywołujący self.authorize (nast. 2 linijki)
            # zostawić w tej sytuacji. Tak było 'historycznie', ale widzę też, że po wywołaniu self.authorize
            # ta funkcja zawsze wykonywała "if ret.status_code >= 403" i zwracała Exception. Teoretycznie
            # to chyba zostało tutaj z powodu klienta command-line, który to na ten moment priorytetem
            # przecież nie jest.
            if hasattr(self, "authorize"):
                self.authorize(self.base_url, self.app_id, self.app_token)
                # self.authorize()

        # mpasternak 7.09.2021, poniżej "przymiarki" do analizowania zwróconych błędów z PBN
        #
        # if ret.status_code == 400:
        #     try:
        #         ret_json = ret.json()
        #     except BaseException:
        #         raise HttpException(
        #             ret.status_code,
        #             url,
        #             "Blad podczas odkodowywania JSON podczas odpowiedzi 400: "
        #             + smart_content(ret.content),
        #         )
        #     if ret_json.get("message") == "Bad Request" and ret_json.get("description") == "Validation failed."
        #     and ret_json.get("details")
        #
        #     HttpException(400, '/api/v1/publications',
        #                   '{"code":400,"message":"Bad Request","description":"Validation failed.",
        #                   "details":{"doi":"DOI jest błędny lub nie udało się pobrać informacji z serwisu DOI!"}}')

        if ret.status_code >= 400:
            if ret.status_code == 423 and smart_content(ret.content) == "Locked":
                raise ResourceLockedException(
                    ret.status_code, url, smart_content(ret.content)
                )

            raise HttpException(ret.status_code, url, smart_content(ret.content))

        try:
            return ret.json()
        except (RequestsJSONDecodeError, JSONDecodeError) as e:
            if ret.status_code == 200:
                if ret.content == b"":
                    return

                if b"prace serwisowe" in ret.content:
                    # open("pbn_client_dump.html", "wb").write(ret.content)
                    raise PraceSerwisoweException()

            raise e

    def delete(
        self,
        url,
        headers=None,
        body=None,
    ):
        return self.post(url, headers, body, delete=True)

    def _pages(self, method, url, headers=None, body=None, page_size=10, *args, **kw):
        # Stronicowanie zwraca rezultaty w taki sposób:
        # {'content': [{'mongoId': '5e709189878c28a04737dc6f',
        #               'status': 'ACTIVE',
        # ...
        #              'versionHash': '---'}]}],
        #  'first': True,
        #  'last': False,
        #  'number': 0,
        #  'numberOfElements': 10,
        #  'pageable': {'offset': 0,
        #               'pageNumber': 0,
        #               'pageSize': 10,
        #               'paged': True,
        #               'sort': {'sorted': False, 'unsorted': True},
        #               'unpaged': False},
        #  'size': 10,
        #  'sort': {'sorted': False, 'unsorted': True},
        #  'totalElements': 68577,
        #  'totalPages': 6858}

        chr = "?"
        if url.find("?") >= 0:
            chr = "&"

        url = url + f"{chr}size={page_size}"
        chr = "&"

        for elem in kw:
            url += chr + elem + "=" + quote(kw[elem])

        method_function = getattr(self, method)

        if method == "get":
            res = method_function(url, headers)
        elif method == "post":
            res = method_function(url, headers, body=body)
        else:
            raise NotImplementedError

        if "pageable" not in res:
            warnings.warn(
                f"PBNClient.{method}_page request for {url} with headers {headers} did not return a paged resource, "
                f"maybe use PBNClient.{method} (without 'page') instead",
                RuntimeWarning,
            )
            return res
        return PageableResource(
            self, res, url=url, headers=headers, body=body, method=method
        )

    def get_pages(self, url, headers=None, page_size=10, *args, **kw):
        return self._pages(
            "get", url=url, headers=headers, page_size=page_size, *args, **kw
        )

    def post_pages(self, url, headers=None, body=None, page_size=10, *args, **kw):
        # Jak get_pages, ale methoda to post
        if body is None:
            body = kw

        return self._pages(
            "post",
            url=url,
            headers=headers,
            body=body,
            page_size=page_size,
            *args,
            **kw,
        )


class ConferencesMixin:
    def get_conferences(self, *args, **kw):
        return self.transport.get_pages("/api/v1/conferences/page", *args, **kw)

    def get_conferences_mnisw(self, *args, **kw):
        return self.transport.get_pages("/api/v1/conferences/mnisw/page", *args, **kw)

    def get_conference(self, id):
        return self.transport.get(f"/api/v1/conferences/{id}")

    def get_conference_editions(self, id):
        return self.transport.get(f"/api/v1/conferences/{id}/editions")

    def get_conference_metadata(self, id):
        return self.transport.get(f"/api/v1/conferences/{id}/metadata")


class DictionariesMixin:
    def get_countries(self):
        return self.transport.get("/api/v1/dictionary/countries")
        return self.transport.get("/api/v1/dictionary/countries")

    def get_disciplines(self):
        return self.transport.get(PBN_GET_DISCIPLINES_URL)

    def get_languages(self):
        return self.transport.get(PBN_GET_LANGUAGES_URL)


class InstitutionsMixin:
    def get_institutions(self, status="ACTIVE", *args, **kw):
        return self.transport.get_pages(
            "/api/v1/institutions/page", status=status, *args, **kw
        )

    def get_institution_by_id(self, id):
        return self.transport.get(f"/api/v1/institutions/{id}")

    def get_institution_by_version(self, version):
        return self.transport.get_pages(f"/api/v1/institutions/version/{version}")

    def get_institution_metadata(self, id):
        return self.transport.get_pages(f"/api/v1/institutions/{id}/metadata")

    def get_institutions_polon(self, includeAllVersions="true", *args, **kw):
        return self.transport.get_pages(
            "/api/v1/institutions/polon/page",
            includeAllVersions=includeAllVersions,
            *args,
            **kw,
        )

    def get_institutions_polon_by_uid(self, uid):
        return self.transport.get(f"/api/v1/institutions/polon/uid/{uid}")

    def get_institutions_polon_by_id(self, id):
        return self.transport.get(f"/api/v1/institutions/polon/{id}")


class InstitutionsProfileMixin:
    def get_institution_publications(self, page_size=10) -> PageableResource:
        return self.transport.get_pages(
            "/api/v1/institutionProfile/publications/page", page_size=page_size
        )

    def get_institution_publications_v2(
        self,
    ) -> PageableResource:
        return self.transport.get_pages(PBN_GET_INSTITUTION_PUBLICATIONS_V2)

    def get_institution_statements(self, page_size=10):
        return self.transport.get_pages(
            PBN_GET_INSTITUTION_STATEMENTS,
            page_size=page_size,
        )

    def get_institution_statements_of_single_publication(
        self, pbn_uid_id, page_size=50
    ):
        return self.transport.get_pages(
            PBN_GET_INSTITUTION_STATEMENTS + "?publicationId=" + pbn_uid_id,
            page_size=page_size,
        )

    def get_institution_publication_v2(
        self,
        objectId,
    ):
        return self.transport.get_pages(
            PBN_GET_INSTITUTION_PUBLICATIONS_V2 + f"?publicationId={objectId}",
        )

    def delete_all_publication_statements(self, publicationId):
        url = PBN_DELETE_PUBLICATION_STATEMENT.format(publicationId=publicationId)
        try:
            return self.transport.delete(
                url,
                body={"all": True, "statementsOfPersons": []},
            )
        except HttpException as e:
            if e.status_code != 400 or not e.url.startswith(url):
                raise e
            try:
                ret_json = json.loads(e.content)
            except BaseException:
                raise e

            if (
                ret_json.get("description") != "Validation failed."
                or e.content.find("Nie można usunąć oświadczeń") < 0
            ):
                raise e

            raise CannotDeleteStatementsException(e.content)

    def delete_publication_statement(self, publicationId, personId, role):
        return self.transport.delete(
            PBN_DELETE_PUBLICATION_STATEMENT.format(publicationId=publicationId),
            body={"statementsOfPersons": [{"personId": personId, "role": role}]},
        )

    def post_discipline_statements(self, statements_data):
        """
        Send discipline statements to PBN API.

        Args:
            statements_data (list): List of statement dictionaries containing discipline information

        Returns:
            dict: Response from PBN API
        """
        return self.transport.post(
            PBN_POST_INSTITUTION_STATEMENTS_URL, body=statements_data
        )


class JournalsMixin:
    def get_journals_mnisw(self, *args, **kw):
        return self.transport.get_pages("/api/v1/journals/mnisw/page", *args, **kw)

    def get_journals_mnisw_v2(self, *args, **kw):
        return self.transport.get_pages("/api/v2/journals/mnisw/page", *args, **kw)

    def get_journals(self, *args, **kw):
        return self.transport.get_pages("/api/v1/journals/page", *args, **kw)

    def get_journals_v2(self, *args, **kw):
        return self.transport.get_pages("/api/v2/journals/page", *args, **kw)

    def get_journal_by_version(self, version):
        return self.transport.get(f"/api/v1/journals/version/{version}")

    def get_journal_by_id(self, id):
        return self.transport.get(PBN_GET_JOURNAL_BY_ID.format(id=id))

    def get_journal_metadata(self, id):
        return self.transport.get(f"/api/v1/journals/{id}/metadata")


class PersonMixin:
    def get_people_by_institution_id(self, id):
        return self.transport.get(f"/api/v1/person/institution/{id}")

    def get_person_by_natural_id(self, id):
        return self.transport.get(f"/api/v1/person/natural/{id}")

    def get_person_by_orcid(self, orcid):
        return self.transport.get(f"/api/v1/person/orcid/{orcid}")

    def get_people(self, *args, **kw):
        return self.transport.get_pages("/api/v1/person/page", *args, **kw)

    def get_person_by_polon_uid(self, uid):
        return self.transport.get(f"/api/v1/person/polon/{uid}")

    def get_person_by_version(self, version):
        return self.transport.get(f"/api/v1/person/version/{version}")

    def get_person_by_id(self, id):
        return self.transport.get(f"/api/v1/person/{id}")


class PublishersMixin:
    def get_publishers_mnisw(self, *args, **kw):
        return self.transport.get_pages("/api/v1/publishers/mnisw/page", *args, **kw)

    def get_publishers_mnisw_yearlist(self, *args, **kw):
        return self.transport.get_pages(
            "/api/v1/publishers/mnisw/page/yearlist", *args, **kw
        )

    def get_publishers(self, *args, **kw):
        return self.transport.get_pages("/api/v1/publishers/page", *args, **kw)

    def get_publisher_by_version(self, version):
        return self.transport.get(f"/api/v1/publishers/version/{version}")

    def get_publisher_by_id(self, id):
        return self.transport.get(f"/api/v1/publishers/{id}")

    def get_publisher_metadata(self, id):
        return self.transport.get(f"/api/v1/publishers/{id}/metadata")


class PublicationsMixin:
    def get_publication_by_doi(self, doi):
        return self.transport.get(
            f"/api/v1/publications/doi/?doi={quote(doi, safe='')}",
        )

    def get_publication_by_doi_page(self, doi):
        return self.transport.get_pages(
            f"/api/v1/publications/doi/page?doi={quote(doi, safe='')}",
            headers={"doi": doi},
        )

    def get_publication_by_id(self, id):
        return self.transport.get(PBN_GET_PUBLICATION_BY_ID_URL.format(id=id))

    def get_publication_metadata(self, id):
        return self.transport.get(f"/api/v1/publications/id/{id}/metadata")

    def get_publications(self, **kw):
        return self.transport.get_pages("/api/v1/publications/page", **kw)

    def get_publication_by_version(self, version):
        return self.transport.get(f"/api/v1/publications/version/{version}")


class SearchMixin:
    def search_publications(self, *args, **kw):
        return self.transport.post_pages(PBN_SEARCH_PUBLICATIONS_URL, body=kw)


def rename_dict_key(data, old_key, new_key):
    """
    Recursively rename a dictionary key in a dictionary and all nested dictionaries.

    Args:
        data: Dictionary or any data structure that may contain dictionaries
        old_key: The key to be renamed
        new_key: The new key name

    Returns:
        The modified data structure with renamed keys
    """
    if isinstance(data, dict):
        # Create a new dictionary with renamed keys
        new_dict = {}
        for key, value in data.items():
            # Rename the key if it matches
            new_key_name = new_key if key == old_key else key
            # Recursively process the value
            new_dict[new_key_name] = rename_dict_key(value, old_key, new_key)
        return new_dict
    elif isinstance(data, list):
        # Process each item in the list
        return [rename_dict_key(item, old_key, new_key) for item in data]
    else:
        # Return the value unchanged if it's not a dict or list
        return data


class PBNClient(
    ConferencesMixin,
    DictionariesMixin,
    InstitutionsMixin,
    InstitutionsProfileMixin,
    JournalsMixin,
    PersonMixin,
    PublicationsMixin,
    PublishersMixin,
    SearchMixin,
):
    _interactive = False

    def __init__(self, transport: RequestsTransport):
        self.transport = transport

    def post_publication(self, json):
        return self.transport.post(PBN_POST_PUBLICATIONS_URL, body=json)

    def post_publication_no_statements(self, json):
        """
        Ta funkcja służy do wysyłania publikacji BEZ oświadczeń.

        Bierzemy słownik JSON z publikacji-z-oświadczeniami i przetwarzamy go.

        :param json:
        :return:
        """

        # PBN zmienił givenNames na firstName
        for elem in json.get("authors", []):
            elem["firstName"] = elem.pop("givenNames")

        # PBN życzy abstrakty w root
        abstracts = json.pop("languageData", {}).get("abstracts", [])
        if abstracts:
            json["abstracts"] = abstracts

        # PBN nie życzy opłat
        json.pop("fee", None)

        # PBN zmienił nazwę mniswId na ministryId
        json = rename_dict_key(json, "mniswId", "ministryId")

        # Można próbować
        return self.transport.post(PBN_POST_PUBLICATION_NO_STATEMENTS_URL, body=[json])

    def post_publication_fee(self, publicationId, json):
        return self.transport.post(
            PBN_POST_PUBLICATION_FEE_URL.format(id=publicationId), body=json
        )

    def get_publication_fee(self, publicationId):
        res = self.transport.post_pages(
            "/api/v1/institutionProfile/publications/search/fees",
            body={"publicationIds": [str(publicationId)]},
        )
        if not res.count():
            return
        elif res.count() == 1:
            return list(res)[0]
        else:
            raise NotImplementedError("count > 1")

    def upload_publication(
        self, rec, force_upload=False, export_pk_zero=None, always_affiliate_to_uid=None
    ):
        """
        Ta funkcja wysyła dane publikacji na serwer, w zależności od obecności oświadczeń
        w JSONie (klucz: "statements") używa albo api /v1/ do wysyłki publikacji "ze wszystkim",
        albo korzysta z api /v1/ repozytoryjnego.

        Zwracane wyniki wyjściowe też różnią się w zależnosci od użytego API stąd też ta funkcja
        stara się w miarę rozsądnie to ogarnąć.
        """

        js = WydawnictwoPBNAdapter(
            rec,
            export_pk_zero=export_pk_zero,
            always_affiliate_to_uid=always_affiliate_to_uid,
        ).pbn_get_json()

        if not force_upload:
            needed = SentData.objects.check_if_needed(rec, js)
            if not needed:
                raise SameDataUploadedRecently(
                    SentData.objects.get_for_rec(rec).last_updated_on
                )

        try:
            if "statements" in js:
                ret = self.post_publication(js)
                objectId = ret.get("objectId", None)
                bez_oswiadczen = False

            else:
                ret = self.post_publication_no_statements(js)

                if len(ret) == 1:
                    try:
                        objectId = ret[0].get("id", None)
                    except KeyError:
                        raise Exception(
                            f"Serwer zwrócił nieoczekiwaną odpowiedź. {ret=}"
                        )
                    bez_oswiadczen = True
                else:
                    raise Exception(
                        "Lista zwróconych obiektów przy wysyłce pracy bez oświadczeń różna od jednego. "
                        "Sytuacja nieobsługiwana, proszę o kontakt z autorem programu. "
                    )

        except Exception as e:
            SentData.objects.updated(rec, js, uploaded_okay=False, exception=str(e))
            raise e

        return objectId, ret, js, bez_oswiadczen

    def download_publication(self, doi=None, objectId=None):
        from .integrator import zapisz_mongodb
        from .models import Publication

        assert doi or objectId

        if doi:
            data = self.get_publication_by_doi(doi)
        elif objectId:
            data = self.get_publication_by_id(objectId)

        return zapisz_mongodb(data, Publication)

    @transaction.atomic
    def download_statements_of_publication(self, pub):
        from pbn_api.models import OswiadczenieInstytucji
        from .integrator import pobierz_mongodb, zapisz_oswiadczenie_instytucji

        OswiadczenieInstytucji.objects.filter(publicationId_id=pub.pk).delete()

        pobierz_mongodb(
            self.get_institution_statements_of_single_publication(pub.pk, 5120),
            None,
            fun=zapisz_oswiadczenie_instytucji,
            client=self,
            disable_progress_bar=True,
        )

    def pobierz_publikacje_instytucji_v2(self, objectId):
        from pbn_api.integrator import zapisz_publikacje_instytucji_v2

        elem = list(self.get_institution_publication_v2(objectId=objectId))
        if not elem:
            raise PublikacjaInstytucjiV2NieZnalezionaException(objectId)

        if len(elem) != 1:
            raise ZnalezionoWielePublikacjiInstytucjiV2Exception(objectId)

        return zapisz_publikacje_instytucji_v2(self, elem[0])

    def sync_publication(
        self,
        pub,
        notificator=None,
        force_upload=False,
        delete_statements_before_upload=False,
        export_pk_zero=None,
        always_affiliate_to_uid=None,
    ):
        """
        @param delete_statements_before_upload: gdy True, kasuj oświadczenia publikacji przed wysłaniem (jeżeli posiada
        PBN UID)
        """

        # if not pub.doi:
        #     raise WillNotExportError("Ustaw DOI dla publikacji")

        pub = self.eventually_coerce_to_publication(pub)

        #
        if (
            delete_statements_before_upload
            and hasattr(pub, "pbn_uid_id")
            and pub.pbn_uid_id is not None
        ):
            try:
                self.delete_all_publication_statements(pub.pbn_uid_id)

                # Jeżeli zostały skasowane dane, to wymuś wysłanie rekordu, niezależnie
                # od stanu tabeli SentData
                force_upload = True
            except HttpException as e:
                NIE_ISTNIEJA = "Nie istnieją oświadczenia dla publikacji"

                ignored_exception = False

                if e.status_code == 400:
                    if e.json:
                        try:
                            try:
                                msg = e.json["details"]["publicationId"]
                            except KeyError:
                                msg = e.json["details"][
                                    f"publicationId.{pub.pbn_uid_id}"
                                ]
                            if NIE_ISTNIEJA in msg:
                                ignored_exception = True
                        except (TypeError, KeyError):
                            if NIE_ISTNIEJA in e.content:
                                ignored_exception = True

                    else:
                        if NIE_ISTNIEJA in e.content:
                            ignored_exception = True

                if not ignored_exception:
                    raise e

        # Wgraj dane do PBN
        objectId, ret, js, bez_oswiadczen = self.upload_publication(
            pub,
            force_upload=force_upload,
            export_pk_zero=export_pk_zero,
            always_affiliate_to_uid=always_affiliate_to_uid,
        )

        if bez_oswiadczen:
            if notificator is not None:
                notificator.info(
                    "Rekord nie posiada oświadczeń - wysłano do repozytorium. "
                )

        if not objectId:
            msg = (
                f"UWAGA. Serwer PBN nie odpowiedział prawidłowym PBN UID dla"
                f" wysyłanego rekordu. Zgłoś sytuację do administratora serwisu. "
                f"{ret=}, {js=}, {pub=}"
            )
            if notificator is not None:
                notificator.error(msg)

            try:
                raise NoPBNUIDException(msg)
            except NoPBNUIDException as e:
                capture_exception(e)

            mail_admins("Serwer PBN nie zwrocil ID publikacji", msg, fail_silently=True)

            return

        # Pobierz zwrotnie dane z PBN
        publication = self.download_publication(objectId=objectId)

        if not bez_oswiadczen:
            self.download_statements_of_publication(publication)
            try:
                self.pobierz_publikacje_instytucji_v2(objectId=objectId)
            except PublikacjaInstytucjiV2NieZnalezionaException:
                notificator.warning(
                    "Nie znaleziono oświadczeń dla publikacji po stronie PBN w wersji V2 API."
                )

        # Utwórz obiekt zapisanych danych. Dopiero w tym miejscu, bo jeżeli zostanie
        # utworzony nowy rekord po stronie PBN, to pbn_uid_id musi wskazywać na
        # bazę w tabeli Publication, która została chwile temu pobrana...
        SentData.objects.updated(pub, js, pbn_uid_id=objectId)
        if pub.pbn_uid_id is not None and pub.pbn_uid_id != objectId:
            SentData.objects.updated(pub, js, pbn_uid_id=pub.pbn_uid_id)

        if pub.pbn_uid_id != objectId:
            # Rekord dostaje nowe objectId z PBNu.

            # Czy rekord JUŻ Z PBN UID dostaje nowe PBN UID z PBNu? Powiadom użytkownika.
            if pub.pbn_uid_id is not None:
                if notificator is not None:
                    notificator.error(
                        f"UWAGA UWAGA UWAGA. Wg danych z PBN zmodyfikowano PBN UID tego rekordu "
                        f"z wartości {pub.pbn_uid_id} na {objectId}. Technicznie nie jest to błąd, "
                        f"ale w praktyce dobrze by było zweryfikować co się zadziało, zarówno po stronie"
                        f"PBNu jak i BPP. Być może operujesz na rekordzie ze zdublowanym DOI/stronie WWW."
                    )

                message = (
                    f"Zarejestrowano zmianę ZAPISANEGO WCZEŚNIEJ PBN UID publikacji przez PBN, \n"
                    f"Publikacja:\n{pub}\n\n"
                    f"z UIDu {pub.pbn_uid_id} na {objectId}"
                )

                try:
                    raise PBNUIDChangedException(message)
                except PBNUIDChangedException as e:
                    capture_exception(e)

                mail_admins(
                    "Zmiana PBN UID publikacji przez serwer PBN",
                    message,
                    fail_silently=True,
                )

            # Z kolei poniższy kod odpowiada na sytuację dość niepożądana. Zakładamy, że do PBN został wysłany nowy,
            # czysty rekord czyli bez PBN UID, zas PBN odpowiedział PBN UIDem istniejącego już w bazie rekordu.
            from bpp.models import Rekord

            istniejace_rekordy = Rekord.objects.filter(pbn_uid_id=objectId)
            if pub.pbn_uid_id is None and istniejace_rekordy.exists():
                if notificator is not None:
                    notificator.error(
                        f'UWAGA UWAGA UWAGA. Wysłany rekord "{pub}" dostał w odpowiedzi z serwera PBN numer UID '
                        f"rekordu JUŻ ISTNIEJĄCEGO W BAZIE DANYCH BPP, a konkretnie {istniejace_rekordy.all()}. "
                        f"Z przyczyn oczywistych NIE MOGĘ ustawić takiego PBN UID gdyż wówczas unikalność numerów PBN "
                        f"UID byłaby naruszona. Zapewne też doszło do "
                        f"NADPISANIA danych w/wym rekordu po stronie PBNu. Powinieneś/aś wycofać zmiany w PBNie "
                        f"za pomocą GUI, zgłosić tą sytuację do administratora oraz zaprzestać prób wysyłki "
                        f"tego rekordu do wyjaśnienia. "
                    )

                message = (
                    f"Zarejestrowano ustawienie nowo wysłanej pracy ISTNIEJĄCEGO JUŻ W BAZIE PBN UID\n"
                    f"Publikacja:\n{pub}\n\n"
                    f"UIDu {objectId}\n"
                    f"Istniejąca praca/e: {istniejace_rekordy.all()}"
                )

                try:
                    raise PBNUIDSetToExistentException(message)
                except PBNUIDSetToExistentException as e:
                    capture_exception(e)

                mail_admins(
                    "Ustawienie ISTNIEJĄCEGO JUŻ W BAZIE PBN UID publikacji przez serwer PBN",
                    message,
                    fail_silently=True,
                )

                # NIE zapisuj takiego numeru PBN
                return

            pub.pbn_uid = publication
            pub.save()

        return publication

    def eventually_coerce_to_publication(self, pub: Model | str) -> Model:
        if type(pub) is str:
            # Ciag znaków w postaci wydawnictwo_zwarte:123 pozwoli na podawanie tego
            # parametru do wywołań z linii poleceń
            model, pk = pub.split(":")
            ctype = ContentType.objects.get(app_label="bpp", model=model)
            pub = ctype.model_class().objects.get(pk=pk)

        return pub

    def upload_publication_fee(self, pub: Model):
        pub = self.eventually_coerce_to_publication(pub)
        if pub.pbn_uid_id is None:
            raise NoPBNUIDException(
                f"PBN UID (czyli 'numer odpowiednika w PBN') dla rekordu '{pub}' jest pusty."
            )

        fee = OplataZaWydawnictwoPBNAdapter(pub).pbn_get_json()
        if not fee:
            raise NoFeeDataException(
                f"Brak danych o opłatach za publikację {pub.pbn_uid_id}"
            )

        return self.post_publication_fee(pub.pbn_uid_id, fee)

    def exec(self, cmd):
        try:
            fun = getattr(self, cmd[0])
        except AttributeError as e:
            if self._interactive:
                print("No such command: %s" % cmd)
                return
            else:
                raise e

        def extract_arguments(lst):
            args = ()
            kw = {}
            for elem in lst:
                if elem.find(":") >= 1:
                    k, n = elem.split(":", 1)
                    kw[k] = n
                else:
                    args += (elem,)

            return args, kw

        args, kw = extract_arguments(cmd[1:])
        res = fun(*args, **kw)

        if not sys.stdout.isatty():
            # Non-interactive mode, just output the json
            import json

            print(json.dumps(res))
        else:
            if type(res) is dict:
                pprint(res)
            elif is_iterable(res):
                if self._interactive and hasattr(res, "total_elements"):
                    print(
                        "Incoming data: no_elements=",
                        res.total_elements,
                        "no_pages=",
                        res.total_pages,
                    )
                    input("Press ENTER to continue> ")
                for elem in res:
                    pprint(elem)

    @transaction.atomic
    def download_disciplines(self):
        """Zapisuje słownik dyscyplin z API PBN do lokalnej bazy"""

        for elem in self.get_disciplines():
            validityDateFrom = elem.get("validityDateFrom", None)
            validityDateTo = elem.get("validityDateTo", None)
            uuid = elem["uuid"]

            parent_group, created = DisciplineGroup.objects.update_or_create(
                uuid=uuid,
                defaults={
                    "validityDateFrom": validityDateFrom,
                    "validityDateTo": validityDateTo,
                },
            )

            for discipline in elem["disciplines"]:
                # print("XXX", discipline["uuid"])
                Discipline.objects.update_or_create(
                    parent_group=parent_group,
                    uuid=discipline["uuid"],
                    defaults=dict(
                        code=discipline["code"],
                        name=discipline["name"],
                        polonCode=discipline["polonCode"],
                        scientificFieldName=discipline["scientificFieldName"],
                    ),
                )

    @transaction.atomic
    def sync_disciplines(self):
        self.download_disciplines()
        try:
            cur_dg = DisciplineGroup.objects.get_current()
        except DisciplineGroup.DoesNotExist:
            raise ValueError(
                "Brak aktualnego słownika dyscyplin na serwerze. Pobierz aktualny słownik "
                "dyscyplin z PBN."
            )

        from bpp.models import Dyscyplina_Naukowa

        for dyscyplina in Dyscyplina_Naukowa.objects.all():
            wpis_tlumacza = TlumaczDyscyplin.objects.get_or_create(
                dyscyplina_w_bpp=dyscyplina
            )[0]

            wpis_tlumacza.pbn_2024_now = matchuj_aktualna_dyscypline_pbn(
                dyscyplina.kod, dyscyplina.nazwa
            )
            # Domyślnie szuka dla lat 2018-2022
            wpis_tlumacza.pbn_2017_2021 = matchuj_nieaktualna_dyscypline_pbn(
                dyscyplina.kod, dyscyplina.nazwa, rok_min=2018, rok_max=2022
            )

            wpis_tlumacza.pbn_2022_2023 = matchuj_nieaktualna_dyscypline_pbn(
                dyscyplina.kod, dyscyplina.nazwa, rok_min=2023, rok_max=2024
            )

            wpis_tlumacza.save()

        for discipline in cur_dg.discipline_set.all():
            if discipline.name == "weterynaria":
                pass
            # Każda dyscyplina z aktualnego słownika powinna być wpisana do systemu BPP
            try:
                TlumaczDyscyplin.objects.get(pbn_2024_now=discipline)
            except TlumaczDyscyplin.DoesNotExist:
                try:
                    dyscyplina_w_bpp = Dyscyplina_Naukowa.objects.get(
                        kod=normalize_kod_dyscypliny(discipline.code)
                    )
                    TlumaczDyscyplin.objects.get_or_create(
                        dyscyplina_w_bpp=dyscyplina_w_bpp
                    )

                except Dyscyplina_Naukowa.DoesNotExist:
                    dyscyplina_w_bpp = Dyscyplina_Naukowa.objects.create(
                        kod=normalize_kod_dyscypliny(discipline.code),
                        nazwa=discipline.name,
                    )
                    TlumaczDyscyplin.objects.get_or_create(
                        dyscyplina_w_bpp=dyscyplina_w_bpp
                    )

    def interactive(self):
        self._interactive = True
        while True:
            cmd = input("cmd> ")
            if cmd == "exit":
                break
            self.exec(cmd.split(" "))

iplweb / bpp / e667ae68-7418-40f7-b1db-97651d428761

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