Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

models.py
dcca0cc9fee2paginated-inlines

models.py
View Options

			"""
			Django object models for the django_api application of the OACCT project.

			Ref: database_model_20210421_MB.drawio 21.04.2021

			"""

			from django.db import models
			from django.contrib.auth.models import User

			import datetime
			from django.utils.translation import gettext as _


			class Country(models.Model):
			""" Countries: used as attributes by Publishers and Organizations

			:param name: full English name
			:type name: str, optional
			:param iso_code: ISO 3166-1 Alpha-3 code https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3#Officially_assigned_code_elements
			:type iso_code: str, optional
			"""
			name = models.CharField(verbose_name="Country name", max_length=120, null=True)
			iso_code = models.CharField(max_length=3, null=True)

			def __str__(self):
			return f"{self.name}"

			class Meta:
			verbose_name_plural = 'Countries'
			ordering = ('name',)


			class Language(models.Model):
			""" Languages: used as attributes by Journals

			:param name: full English name
			:type name: str, optional
			:param iso_code: ISO 639-2 code https://en.wikipedia.org/wiki/ISO_639-2
			:type iso_code: str, optional
			"""
			name = models.CharField(verbose_name="Language name", max_length=120, null=True)
			iso_code = models.CharField(max_length=3, null=True)

			def __str__(self):
			return f"{self.name}"

			class Meta:
			ordering = ('name',)


			class Oa(models.Model):
			""" Open Access status: used as attribute by Journals

			:param status: short name, ideally one word i.e. Green, Gold, UNKNOWN...
			:type status: str, optional
			:param description: description text up to 1000 characters
			:type status: str, optional
			:param subscription: does a journal with this status require a subscription?
			:type subscription: bool
			:param accepted_manuscript: does a journal with this status generally allow to distribute the accepted manuscript?
			:type accepted_manuscript: bool
			:param apc: does a journal with this status require Article Processing Charges (APCs)?
			:type apc: bool
			:param final_version: does a journal with this status generally allow to distribute the published version?
			:type final_version: bool

			"""
			status = models.CharField(max_length=1000, null=True)
			description = models.CharField(max_length=1000, null=True)
			subscription = models.BooleanField(default=False)
			accepted_manuscript = models.BooleanField(default=False)
			apc = models.BooleanField(default=False)
			final_version = models.BooleanField(default=False)

			def __str__(self):
			return f"{self.status}"

			class Meta:
			ordering = ('-subscription',)
			verbose_name = "Open Access status"
			verbose_name_plural = "Open Access statuses"


			class Publisher(models.Model):
			""" Publishers: corporations or societies in charge of Journals

			:param name: name
			:type status: str, optional
			:param city: location of the main office
			:type city: str, optional
			:param state: if applicable, state or province
			:type state: str, optional
			:param country: home country or countries
			:type country: many-to-many relationship with the `Country` class
			:param starting_year: founding year
			:type starting_year: int, optional
			:param website: main web site
			:type website: URL
			:param oa_policies: web link to general Open Access policy if applicable
			:type oa_policies: URL
			"""
			name = models.CharField(verbose_name="Publisher name", max_length=1000, null=True)
			city = models.CharField(max_length=100, null=True)
			state = models.CharField(max_length=3, null=True)
			country = models.ManyToManyField("Country")
			starting_year = models.IntegerField(blank=True, null=True)
			website = models.URLField(max_length=1000)
			oa_policies = models.URLField(max_length=1000)

			def __str__(self):
			return f"{self.name}"

			class Meta:
			ordering = ('name',)


			class Issn(models.Model):
			""" Issns: a multiple property of Journals

			:param journal: Journal object to which the ISSN belongs
			:type journal: class `Journal`, optional
			:param issn: ISSN code such as 1234-5678
			:type issn: str
			:param issn_type: Print, Electronic or Other
			:type issn_type: str
			"""
			PRINT = '1'
			ELECTRONIC = '2'
			OTHER = '3'

			TYPE_CHOICES = (
			(PRINT, 'Print'),
			(ELECTRONIC, 'Electronic'),
			(OTHER, 'Other'),
			)
			journal = models.ForeignKey("Journal", null=True, on_delete=models.CASCADE, related_name = "classIssn") #journal.classissn
			issn = models.CharField(max_length=9, null=False)
			"""ISSN code such as 1234-5678
			"""
			issn_type = models.CharField(
			choices=TYPE_CHOICES,
			max_length=10,
			blank=True
			)

			def __str__(self):
			return f"{self.issn} ({dict(self.TYPE_CHOICES)[self.issn_type]})"

			class Meta:
			ordering = ('issn',)


			class Journal(models.Model):
			""" Journals: one of the big entities in the application

			:param name: journal title
			:type name: str
			:param name_short_iso_4: ISO 4 abbreviation of the title
			:type name_short_iso_4: str
			:param publisher: zero or more publishers in charge of the Journal
			:type publisher: many-to-many relationshio with class `Publisher`
			:param website: home page of the journal
			:type website: URL
			:param language: the journal publishes articles in these zero or more languages
			:type language: many-to-many relationship with class `Journal`
			:param oa_options: web page with the journal's Open Access conditions
			:type oa_options: URL, optional
			:param oa_status: Open Access status
			:type oa_status: reference to an `Oa` object
			:param starting_year: founding year
			:type starting_year: int, optional
			:param end_year: end year if applicable
			:type ending_year: int, optional
			:param doaj_seal: did the journal obtain the DOAJ Seal? https://doaj.org/apply/seal/
			:type doaj_seal: bool
			:param doaj_status: is the journal accepted in the Directory of Open Access Journals? https://doaj.org
			:type doaj_status: bool
			:param lockss: is the journal archived by LOCKSS? https://www.lockss.org/about
			:type lockss: bool
			:param nlch: please remind me what this is supposed to be
			:type nlch: bool
			:param portico: did the journal obtain the DOAJ Seal? https://doaj.org/apply/seal/
			:type portico: is the journal archived by Portico? https://www.portico.org/
			:param qoam_av_score: Quality Open Access Marker (QOAM) score https://www.qoam.eu/
			:type qoam_av_score: decimal number
			"""
			name = models.CharField(verbose_name="Journal name", max_length=800, blank=True, null=True) # search journal with name
			name_short_iso_4 = models.CharField(max_length=300, blank=True, null=True)
			publisher = models.ManyToManyField(Publisher)
			website = models.URLField(max_length=300, blank=True, null=True)
			language = models.ManyToManyField(Language)
			# 2021-08-11: only one-to-many relationship between Journal and ISSN
			# issn = models.ForeignKey("Issn", null=True, on_delete=models.CASCADE)
			oa_options = models.URLField(max_length=1000, blank=True, null=True)
			oa_status = models.ForeignKey("Oa", related_name ="oa_status", on_delete=models.CASCADE, null=True)
			starting_year = models.IntegerField(blank=True, null=True)
			end_year = models.IntegerField(blank=True, null=True)
			doaj_seal = models.BooleanField(default=False)
			doaj_status = models.BooleanField(default=False)
			lockss = models.BooleanField(default=False)
			nlch = models.BooleanField(default=False)
			portico = models.BooleanField(default=False)
			qoam_av_score = models.DecimalField(decimal_places=2, max_digits=5, blank=True, null=True)

			def __str__(self):
			return f"{self.name} from {self.website}"

			class Meta:
			ordering = ('name',)


			class Organization(models.Model):
			""" Organizations: one of the big entities in the application, organizations (research institutions or funders) who employ or fund the authors/researchers

			:param name: name of the organization
			:type name: str
			:param website: web site of the organization
			:type website: URL, optional
			:param country: zero or more home countries
			:type country: many-to-many relationship with class `Country`
			:param ror: Research Organization Registry (ROR) indentifier https://ror.org/
			:type ror: str, optional
			:param fundref: Crossref Funder Registry identifier https://www.crossref.org/services/funder-registry/
			:type fundref: str, optional
			:param starting_year: founding year
			:type starting_year: int, optional
			:param is_funder: if True, the organization is a funding agency, if False a research organization
			:type is_funder: bool
			:param ir_name: name of the oeganization's institutional repository for publications, if applicable
			:type ir_name: str, optional
			:param ir_url: address of the oeganization's institutional repository for publications, if applicable
			:type ir_name: URL, optional
			"""
			name = models.CharField(verbose_name="Organization name", max_length=600, null=True)
			website = models.URLField(max_length=600, blank=True, null=True)
			country = models.ManyToManyField("Country")
			ror = models.CharField(max_length=255, blank=True, null=True)
			fundref = models.CharField(max_length=255, blank=True, null=True)
			starting_year = models.IntegerField(blank=True, null=True)
			is_funder = models.BooleanField(default=False)
			ir_name = models.CharField(verbose_name="Institutional repository name", max_length=40, null=True, blank=True)
			ir_url = models.URLField(verbose_name="Institutional repository URL", max_length=100, null=True, blank=True)

			def __str__(self):
			return f"{self.name}"

			class Meta:
			ordering = ('name',)


			class Version(models.Model):
			""" Possible versions of an article during its life cycle: submitted version, accepted version, published version

			:param name: name of the version
			:type name: str
			"""
			description = models.CharField(max_length=300, null=False)

			def __str__(self):
			return f"{self.description}"


			class Licence(models.Model):
			""" Licenses that can or must be applied to an article version

			:param name_or_abbrev: name or abbreviation for the license: copyright, CC-BY,...
			:type name_or_abbrev: str
			:param website: web page that describes the license terms
			:type website: URL, optional
			"""
			name_or_abbrev = models.CharField(max_length=300, null=False)
			website = models.URLField(max_length=600, null=True, blank=True)

			class Meta:
			ordering = ('name_or_abbrev',)

			def __str__(self):
			return f"{self.name_or_abbrev}"


			class Cost_factor_type(models.Model):
			""" Cost factor types: amount, discount...

			:param name: name of the type
			:type name: str
			"""
			name = models.CharField(max_length=300, null=False)

			def __str__(self):
			return f"{self.name}"


			class Cost_factor(models.Model):
			""" Cost factors: financial terms applicable to use an Open Access option

			:param cost_factor_type: type of the cost factor
			:type ost_factor_type: reference to a `Cost_factor` object
			:param amount: actual cost or discount
			:type amount: int
			:param symbol: currency code or %
			:type symbol: str
			:param comment: extra information in free text
			:type comment: str, optionaé
			"""
			cost_factor_type = models.ForeignKey(Cost_factor_type, on_delete=models.CASCADE, blank=True, null=True)
			amount = models.IntegerField(null=False)
			symbol = models.CharField(max_length=10, null=False)
			comment = models.CharField(max_length=120, default="")

			class Meta:
			ordering = ('amount',)

			def __str__(self):
			return f"{self.id} - {self.amount} {self.symbol} - {self.comment}"


			class Term(models.Model):
			""" Terms: possible options to disseminate an article in Open Access

			:param version: zero or more versions for which the Term is applicable (currently only 1 is supported by the application)
			:type version: many-to-many relationship to the `Version` class
			:param cost_factor: zero or more possible cost factors
			:type cost_factor: many-to-many relationship to the `Cost_factor` class
			:param licence: zero or more possible licenses
			:type licence: many-to-many relationship to the `Licence` class
			:param embargo_months: duration of a possible embargo in months
			:type embargo_months: int
			:param ir_archiving: is archiving in an institutional repository allowed/required or not?
			:type ir_archiving: bool
			:param comment: extra information as free text
			:type comment: str, optional
			"""
			version = models.ManyToManyField(Version)
			cost_factor = models.ManyToManyField(Cost_factor)
			licence = models.ManyToManyField(Licence)
			embargo_months = models.IntegerField(blank=True, null=True)
			ir_archiving = models.BooleanField(default=False)
			comment = models.CharField(max_length=600, null=True, blank=True)

			def __str__(self):
			try:
			# Maybe these fields should not allow NULL values?
			if self.embargo_months is None:
			embargo = 'no_'
			else:
			embargo = str(self.embargo_months)

			if self.comment is None:
			comment = ''
			else:
			comment = str(self.comment)

			term_data = (str(self.id),
			';'.join([str(x) for x in self.version.all()]),
			';'.join([str(x) for x in self.licence.all()]),
			';'.join([str(x) for x in self.cost_factor.all()]),
			f'Archiving{str(self.ir_archiving)} {embargo}months',
			comment,)
			return ' - '.join(term_data)
			except RecursionError:
			# The JSON import in the admin module somehow throws a ValueError during the loading process
			# probably due to incomplete information in the many2many relationships
			# Then the error log apparently triggers a cascade of errors until
			# the RecursionError level is hit. Falling back to a basic __str__
			# for the RecursionError seems to bypass the problem.
			return f"[Term.__str__() error] {self.id} - {self.comment}"

			class Meta:
			ordering = ('-ir_archiving', 'embargo_months', 'comment')


			class ConditionType(models.Model):
			""" Condition types: issued by a journal, by an organization, or agreement between both?

			:param condition_issuer: `organization-only`, `agreement` or `journal-only`
			:type condition_issuer: str
			"""
			condition_issuer = models.CharField(max_length=300, null=False)

			def __str__(self):
			return f"{self.condition_issuer}"


			class ConditionSubType(models.Model):
			""" Condition subtypes: in case we need to distinguish more finely than the 3 main condition types

			:param label: name of the subtype
			:type label_issuer: str
			"""
			label = models.CharField(max_length=300, null=False)

			def __str__(self):
			return f"{self.label}"

			@classmethod
			def get_default_pk(cls):
			""" An automatic subtype is attributed to any newly created `CondtionSet` object
			"""
			condition_subtype, created = cls.objects.get_or_create(label='Automatic')
			return condition_subtype.pk


			class ConditionSet(models.Model):
			""" Condition sets: collections of Open Access terms applicable to zero or more Journals and zero or more Organizations
			for some specific reason (policy document, agreement, contract...).

			:param condition_type: type for the condition set
			:type condition_type: reference to a `ConditionType` object
			:param subtype: subtype for the condition set
			:type subtype: eference to a `ConditionSubType` object
			:param organization: zero or more organisations to which the condition set is applicable
			:type organization: many-to-many relationship with the `Organization` class with `OrganizationCondition` objects as connectors
			:param journal: zero or more journals to which the condition set is applicable
			:type journal: many-to-many relationship with the `Journal` class with `JournalCondition` objects as connectors
			:param term: zero or more terms included in the condition set
			:type term: many-to-many relationship with the `Term` class
			:param source: web page with information about the condition set (origin, perimeter, etc.)
			:type source: URL, optional
			:param comment: description of the condition set as free text (will be used as a title in the frontend)
			:type comment: str, optional
			"""
			condition_type = models.ForeignKey(ConditionType, on_delete=models.CASCADE, blank=True, null=True)
			subtype = models.ForeignKey(ConditionSubType, on_delete=models.CASCADE,
			default=ConditionSubType.get_default_pk, null=True)
			organization = models.ManyToManyField(
			Organization,
			through='OrganizationCondition',
			through_fields=('condition_set', 'organization')
			)
			journal = models.ManyToManyField(
			Journal,
			through='JournalCondition',
			through_fields=('condition_set', 'journal')
			)
			term = models.ManyToManyField(Term)
			source = models.URLField(max_length=600, null=True, blank=True)
			comment = models.CharField(max_length=100, null=True, blank=True)

			def __str__(self):
			return f"{self.id} {self.condition_type}\|{self.comment}"

			class Meta:
			# TODO does this work??? 2ndary sort showing institution first, funder second
			# ordering = ('condition_type__pk', 'organization__is_funder', 'subtype__id', 'comment')
			# No it does not, it duplicates most journal policies (one copy for funders, one for institutions)
			ordering = ('condition_type__pk', 'subtype__id', 'comment')


			class OrganizationCondition(models.Model):
			""" Organization-ConditionSet connector, linking `organization` with
			`condition`. The first (`valid_from`) and last (`valid_until`) known days of validity are recorded.
			"""
			organization = models.ForeignKey(Organization, on_delete=models.CASCADE, blank=True, null=True)
			condition_set = models.ForeignKey(ConditionSet, on_delete=models.CASCADE, blank=True, null=True)
			valid_from = models.DateField(blank=True, null=True)
			valid_until = models.DateField(blank=True, null=True)

			class Meta:
			verbose_name = "Organization/condition_set relationship"

			def __str__(self):
			return f"{self.id} {self.organization.name}/ConditionSet {self.condition_set.id}"


			class JournalCondition(models.Model):
			""" Journal-ConditionSet connector, linking `journal` with
			`condition`. The first (`valid_from`) and last (`valid_until`) known days of validity are recorded.
			"""
			journal = models.ForeignKey(Journal, on_delete=models.CASCADE, blank=True, null=True)
			condition_set = models.ForeignKey(ConditionSet, on_delete=models.CASCADE, blank=True, null=True)
			valid_from = models.DateField(blank=True, null=True)
			valid_until = models.DateField(blank=True, null=True)

			class Meta:
			verbose_name = "Journal/condition_set relationship"

			def __str__(self):
			return f"{self.id} {self.journal.name}/{self.condition_set}"

rOACCT/django_api/models.pydcca0cc9fee2paginated-inlines

models.pyView Options

rOACCT/django_api/models.py
dcca0cc9fee2paginated-inlines

models.py
View Options