Update factories

affiliations/factories.py

+import factory
+
+from .constants import INSTITUTION_TYPES
+from .models import Institution, Affiliation
+
+
+class InstitutionFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker('company')
+    acronym = factory.lazy_attribute(lambda o: o.name[:16])
+    country = factory.Faker('country_code')
+    type = factory.Iterator(INSTITUTION_TYPES, getter=lambda c: c[0])
+
+    class Meta:
+        model = Institution
+        django_get_or_create = ('name',)
+
+
+class AffiliationFactory(factory.django.DjangoModelFactory):
+    institution = factory.SubFactory('affiliations.factories.InstitutionFactory')
+    contributor = factory.SubFactory('scipost.factories.ContributorFactory')
+    begin_date = factory.Faker('date_this_decade')
+    end_date = factory.Faker('future_date', end_date="+2y")
+
+    class Meta:
+        model = Affiliation
+        django_get_or_create = ('institution', 'contributor')

affiliations/forms.py

 from django import forms
 from django.forms import BaseModelFormSet, modelformset_factory
-# from django.db.models import F
 
 from django_countries import countries
 from django_countries.fields import LazyTypedChoiceField

colleges/factories.py

+import factory
+
+from scipost.models import Contributor
+
+from .models import Fellowship
+
+
+class BaseFellowshipFactory(factory.django.DjangoModelFactory):
+    contributor = factory.Iterator(Contributor.objects.all())
+    start_date = factory.Faker('date_this_year')
+    until_date = factory.Faker('date_between', start_date="now", end_date="+2y")
+
+    guest = factory.Faker('boolean', chance_of_getting_true=10)
+
+    class Meta:
+        model = Fellowship
+        django_get_or_create = ('contributor', 'start_date')
+        abstract = True
+
+
+class FellowshipFactory(BaseFellowshipFactory):
+    pass

colleges/management/commands/create_fellowships.py

+from django.core.management.base import BaseCommand
+
+from colleges import factories
+
+
+class Command(BaseCommand):
+    help = 'Create random Fellowships objects using the factories.'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            'number', action='store', default=0, type=int,
+            help='Number of Fellowships to add')
+
+    def handle(self, *args, **kwargs):
+        self.create_fellowships(kwargs['number'])
+
+    def create_fellowships(self, n):
+        factories.FellowshipFactory.create_batch(n)
+        self.stdout.write(self.style.SUCCESS('Successfully created {n} Fellowships.'.format(n=n)))

commentaries/factories.py

@@ -30,10 +30,9 @@ class BaseCommentaryFactory(factory.django.DjangoModelFactory):
     pub_date = factory.Faker('date_this_decade')
     pub_abstract = factory.Faker('paragraph')
 
-    @factory.post_generation
-    def arxiv_link(self, create, extracted, **kwargs):
-        self.arxiv_link = 'https://arxiv.org/abs/%s' % self.arxiv_identifier
-        self.arxiv_or_DOI_string = self.arxiv_identifier
+    arxiv_link = factory.lazy_attribute(lambda o: 'https://arxiv.org/abs/%s' % o.arxiv_identifier)
+    arxiv_or_DOI_string = factory.lazy_attribute(lambda o: (
+        o.arxiv_identifier if o.arxiv_identifier else o.pub_DOI))
 
     @factory.post_generation
     def create_urls(self, create, extracted, **kwargs):
@@ -77,3 +76,9 @@ class UnpublishedCommentaryFactory(BaseCommentaryFactory):
 class UnvettedUnpublishedCommentaryFactory(UnpublishedCommentaryFactory):
     vetted = False
     vetted_by = None
+
+
+class PublishedCommentaryFactory(BaseCommentaryFactory):
+    arxiv_identifier = ''
+    arxiv_link = ''
+    arxiv_or_DOI_string = factory.lazy_attribute(lambda o: o.pub_DOI)

commentaries/management/commands/create_commentaries.py

+from django.core.management.base import BaseCommand
+
+from commentaries import factories
+
+
+class Command(BaseCommand):
+    help = 'Create random Commentaries objects using the factories.'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            'number', action='store', default=0, type=int,
+            help='Number of Commentaries to add')
+
+    def handle(self, *args, **kwargs):
+        self.create_commentaries(kwargs['number'])
+
+    def create_commentaries(self, n):
+        factories.CommentaryFactory.create_batch(n)
+        self.stdout.write(self.style.SUCCESS('Successfully created {n} Commentaries.'.format(n=n)))

comments/factories.py

+import random
 import factory
 
 from commentaries.models import Commentary
@@ -44,9 +45,15 @@ class CommentaryCommentFactory(CommentFactory):
 class SubmissionCommentFactory(CommentFactory):
     content_object = factory.Iterator(Submission.objects.all())
 
+    @factory.post_generation
+    def replies(self, create, extracted, **kwargs):
+        if create:
+            for i in range(random.randint(0, 2)):
+                ReplyCommentFactory(content_object=self)
+
 
 class ReplyCommentFactory(CommentFactory):
-    content_object = factory.SubFactory(SubmissionCommentFactory)
+    content_object = factory.SubFactory(SubmissionCommentFactory, replies=False)
     is_author_reply = factory.Faker('boolean')
 
 

common/helpers/__init__.py

@@ -93,14 +93,22 @@ def random_external_doi():
         '1742-5468',
         '0550-3213(96)'
     ))
-    return '10.%s/%s.%s' % (
-        random_digits(5), journal, random_pub_number())
+    return '10.%s/%s.%s' % (random_digits(5), journal, random_pub_number())
 
 
 def random_digits(n):
     return "".join(random.choice(string.digits) for _ in range(n))
 
 
+def generate_orcid():
+    return '{}-{}-{}-{}'.format(
+        random_digits(4),
+        random_digits(4),
+        random_digits(4),
+        random_digits(4),
+    )
+
+
 def filter_keys(dictionary, keys_to_keep):
     # Field is empty if not on model.
     return {key: dictionary.get(key, "") for key in keys_to_keep}

journals/management/commands/create_issues.py

+from django.core.management.base import BaseCommand
+
+from journals import factories
+
+
+class Command(BaseCommand):
+    help = 'Create Issue objects using the factories.'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            'number', action='store', default=0, type=int,
+            help='Number of Issues to add')
+
+    def handle(self, *args, **kwargs):
+        self.create_issues(kwargs['number'])
+
+    def create_issues(self, n):
+        factories.IssueFactory.create_batch(n)
+        self.stdout.write(self.style.SUCCESS('Successfully created {n} Issues.'.format(n=n)))

journals/management/commands/create_journals.py

+from django.core.management.base import BaseCommand
+
+from journals import factories
+
+
+class Command(BaseCommand):
+    help = 'Create Journal objects using the factories.'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            'number', action='store', default=0, type=int,
+            help='Number of Journals to add')
+
+    def handle(self, *args, **kwargs):
+        self.create_journals(kwargs['number'])
+
+    def create_journals(self, n):
+        factories.JournalFactory.create_batch(n)
+        self.stdout.write(self.style.SUCCESS('Successfully created {n} Journals.'.format(n=n)))

journals/management/commands/create_volumes.py

+from django.core.management.base import BaseCommand
+
+from journals import factories
+
+
+class Command(BaseCommand):
+    help = 'Create Volume objects using the factories.'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            'number', action='store', default=0, type=int,
+            help='Number of Volumes to add')
+
+    def handle(self, *args, **kwargs):
+        self.create_volumes(kwargs['number'])
+
+    def create_volumes(self, n):
+        factories.VolumeFactory.create_batch(n)
+        self.stdout.write(self.style.SUCCESS('Successfully created {n} Volumes.'.format(n=n)))

news/management/commands/create_news.py

+from django.core.management.base import BaseCommand
+
+from news import factories
+
+
+class Command(BaseCommand):
+    help = 'Create random News Item objects using the factories.'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            'number', action='store', default=0, type=int,
+            help='Number of News items to add')
+
+    def handle(self, *args, **kwargs):
+        self.create_news_items(kwargs['number'])
+
+    def create_news_items(self, n):
+        factories.NewsItemFactory.create_batch(n)
+        self.stdout.write(self.style.SUCCESS('Successfully created {n} News Items.'.format(n=n)))

scipost/factories.py

@@ -4,31 +4,36 @@ import random
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Group
 
+from common.helpers import generate_orcid
 from submissions.models import Submission
 
 from .models import Contributor, EditorialCollege, EditorialCollegeFellowship, Remark
 from .constants import TITLE_CHOICES, SCIPOST_SUBJECT_AREAS
 
-from django_countries.data import COUNTRIES
-from faker import Faker
-
 
 class ContributorFactory(factory.django.DjangoModelFactory):
-    title = random.choice(list(dict(TITLE_CHOICES).keys()))
+    title = factory.Iterator(TITLE_CHOICES, getter=lambda c: c[0])
     user = factory.SubFactory('scipost.factories.UserFactory', contributor=None)
     status = 1  # normal user
-    vetted_by = factory.SubFactory('scipost.factories.ContributorFactory', vetted_by=None)
-    personalwebpage = factory.Faker('url')
-    country_of_employment = factory.Iterator(list(COUNTRIES))
-    affiliation = factory.Faker('company')
+    vetted_by = factory.Iterator(Contributor.objects.all())
+    personalwebpage = factory.Faker('uri')
     expertises = factory.Iterator(SCIPOST_SUBJECT_AREAS[0][1], getter=lambda c: [c[0]])
-    personalwebpage = factory.Faker('domain_name')
+    orcid_id = factory.lazy_attribute(lambda n: generate_orcid())
     address = factory.Faker('address')
+    invitation_key = factory.Faker('md5')
+    activation_key = factory.Faker('md5')
+    key_expires = factory.Faker('future_datetime')
 
     class Meta:
         model = Contributor
         django_get_or_create = ('user',)
 
+    @factory.post_generation
+    def add_to_vetting_editors(self, create, extracted, **kwargs):
+        if create:
+            from affiliations.factories import AffiliationFactory
+            AffiliationFactory(contributor=self)
+
 
 class VettingEditorFactory(ContributorFactory):
     @factory.post_generation
@@ -69,7 +74,7 @@ class EditorialCollegeFactory(factory.django.DjangoModelFactory):
 
     class Meta:
         model = EditorialCollege
-        django_get_or_create = ('discipline', )
+        django_get_or_create = ('discipline',)
 
 
 class EditorialCollegeFellowshipFactory(factory.django.DjangoModelFactory):
@@ -85,7 +90,7 @@ class SubmissionRemarkFactory(factory.django.DjangoModelFactory):
     contributor = factory.Iterator(Contributor.objects.all())
     submission = factory.Iterator(Submission.objects.all())
     date = factory.Faker('date_time_this_decade')
-    remark = factory.lazy_attribute(lambda x: Faker().paragraph())
+    remark = factory.Faker('paragraph')
 
     class Meta:
         model = Remark

scipost/management/commands/create_contributors.py

+from django.core.management.base import BaseCommand
+
+from scipost import factories
+
+
+class Command(BaseCommand):
+    help = 'Create random Contributor objects using the factories.'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            'number', action='store', default=0, type=int,
+            help='Number of Contributors to add')
+
+    def handle(self, *args, **kwargs):
+        self.create_contributors(kwargs['number'])
+
+    def create_contributors(self, n):
+        factories.ContributorFactory.create_batch(n)
+        self.stdout.write(self.style.SUCCESS('Successfully created {n} Contributors.'.format(n=n)))