class CircPolicyIdentifier(RecordIdentifier):
"""Sequence generator for circultion policies identifiers."""
__tablename__ = 'circ_policy_id'
__mapper_args__ = {'concrete': True}
recid = db.Column(
db.BigInteger().with_variant(db.Integer, 'sqlite'),
primary_key=True, autoincrement=True,
)
class HoldingIdentifier(RecordIdentifier):
"""Sequence generator for holdings identifiers."""
__tablename__ = 'holding_id'
__mapper_args__ = {'concrete': True}
recid = db.Column(
db.BigInteger().with_variant(db.Integer, 'sqlite'),
primary_key=True, autoincrement=True,
)
class AcqReceiptIdentifier(RecordIdentifier):
"""Sequence generator for acquisition receipt identifiers."""
__tablename__ = 'acq_receipt_id'
__mapper_args__ = {'concrete': True}
recid = db.Column(
db.BigInteger().with_variant(db.Integer, 'sqlite'),
primary_key=True,
autoincrement=True,
)
class AgentGndIdentifier(RecordIdentifier):
"""Sequence generator for GND Authority identifiers."""
__tablename__ = 'agent_gnd_id'
__mapper_args__ = {'concrete': True}
recid = db.Column(
db.BigInteger().with_variant(db.Integer, 'sqlite'),
primary_key=True,
autoincrement=True,
)
class PatronTransactionIdentifier(RecordIdentifier):
"""Sequence generator for Patron Transaction identifiers."""
__tablename__ = 'patron_transaction_id'
__mapper_args__ = {'concrete': True}
recid = db.Column(
db.BigInteger().with_variant(db.Integer, 'sqlite'),
primary_key=True,
autoincrement=True,
)
# 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/>.
"""Define relation between records and buckets."""
from __future__ import absolute_import
from invenio_db import db
from invenio_pidstore.models import RecordIdentifier
class {{ cookiecutter.class_name }}Identifier(RecordIdentifier):
"""Sequence generator for {{ cookiecutter.class_name }} identifiers."""
__tablename__ = '{{ cookiecutter.name }}_id'
__mapper_args__ = {'concrete': True}
recid = db.Column(
db.BigInteger().with_variant(db.Integer, 'sqlite'),
primary_key=True, autoincrement=True,
)
class RecordIdentifier(db.Model):
"""Sequence generator for integer record identifiers.
The sole purpose of this model is to generate integer record identifiers in
sequence using the underlying database's auto increment features in a
transaction friendly manner. The feature is primarily provided to support
legacy Invenio instances to continue their current record identifier
scheme. For new instances we strong encourage to not use auto incrementing
record identifiers, but instead use e.g. UUIDs as record identifiers.
"""
__tablename__ = 'pidstore_recid'
recid = db.Column(db.BigInteger().with_variant(db.Integer, "sqlite"),
primary_key=True,
autoincrement=True)
@classmethod
def next(cls):
"""Return next available record identifier."""
try:
with db.session.begin_nested():
obj = cls()
db.session.add(obj)
except IntegrityError: # pragma: no cover
with db.session.begin_nested():
# Someone has likely modified the table without using the
# models API. Let's fix the problem.
cls._set_sequence(cls.max())
obj = cls()
db.session.add(obj)
return obj.recid
@classmethod
def max(cls):
"""Get max record identifier."""
max_recid = db.session.query(func.max(cls.recid)).scalar()
return max_recid if max_recid else 0
@classmethod
def _set_sequence(cls, val):
"""Internal function to reset sequence to specific value.
Note: this function is for PostgreSQL compatibility.
:param val: The value to be set.
"""
if db.engine.dialect.name == 'postgresql': # pragma: no cover
db.session.execute(
"SELECT setval(pg_get_serial_sequence("
"'{0}', 'recid'), :newval)".format(cls.__tablename__),
dict(newval=val))
@classmethod
def insert(cls, val):
"""Insert a record identifier.
:param val: The `recid` column value to insert.
"""
with db.session.begin_nested():
obj = cls(recid=val)
db.session.add(obj)
cls._set_sequence(cls.max())
class Archive(db.Model, Timestamp):
"""Registers the status of a sip: archived or not.
The status is a member of
:py:class:`invenio_archivematica.models.ArchiveStatus`.
A sip can have only one archive, and an archive applies to only
one sip.
"""
__tablename__ = 'archivematica_archive'
__table_args__ = (db.Index('idx_ark_sip',
'sip_id'), db.Index('idx_ark_status', 'status'),
db.Index('idx_ark_accession_id', 'accession_id'))
id = db.Column(db.BigInteger().with_variant(db.Integer, 'sqlite'),
primary_key=True)
"""ID of the Archive object."""
sip_id = db.Column(UUIDType,
db.ForeignKey(SIP.id, name='fk_archivematica_sip_id'),
nullable=False)
"""SIP related with the Archive."""
status = db.Column(ChoiceType(ArchiveStatus, impl=db.String(20)),
nullable=False)
"""Status of the archive."""
accession_id = db.Column(db.String(255), nullable=True, unique=True)
"""Accessioned ID of the AIP in Archivematica."""
archivematica_id = db.Column(UUIDType, nullable=True)
"""ID of the AIP in Archivematica."""
# Relations
sip = db.relationship(SIP)
"""Relationship with SIP."""
#
# Class methods
#
@classmethod
def create(cls, sip, accession_id=None, archivematica_id=None):
"""Create a new Archive object and add it to the session.
The new Archive object will have a NEW status
:param sip: the sip attached to the archive
:type sip: :py:class:`invenio_sipstore.models.SIP`
:param str accession_id: the accession ID of the AIP
:param str archivematica_id: The UUID of the AIP
"""
ark = cls(sip=sip,
status=ArchiveStatus.NEW,
accession_id=accession_id,
archivematica_id=archivematica_id)
db.session.add(ark)
return ark
@classmethod
def get_from_sip(cls, uuid):
"""Return the Archive object associated to the given sip.
It tries to get the Archive object associated to the sip. If it
exists, it returns it, otherwise it returns None.
:param str uuid: the uuid of the sip
:rtype: :py:class:`invenio_archivematica.models.Archive` or None
"""
return cls.query.filter_by(sip_id=uuid).one_or_none()
@classmethod
def get_from_accession_id(cls, accession_id):
"""Return the Archive object associated to the given accession_id.
If the accession_id is not in the table, it returns None.
:param str accession_id: the accession_id of the Archive object.
:rtype: :py:class:`invenio_archivematica.models.Archive` or None
"""
return cls.query.filter_by(accession_id=accession_id).one_or_none()
