From 536a1a56acff3b061a880ea2c49e9d577e9f0925 Mon Sep 17 00:00:00 2001
From: Carlos Vega <carlos.vega@uni.lu>
Date: Mon, 15 Oct 2018 20:23:28 +0200
Subject: [PATCH] dummy data version 1
---
smash/create_dummy_data.py | 588 +++++++++++++++++++++++++++++++++++++
1 file changed, 588 insertions(+)
create mode 100644 smash/create_dummy_data.py
diff --git a/smash/create_dummy_data.py b/smash/create_dummy_data.py
new file mode 100644
index 00000000..51a33e49
--- /dev/null
+++ b/smash/create_dummy_data.py
@@ -0,0 +1,588 @@
+from django.conf import settings
+import django
+import os
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "smash.settings")
+django.setup()
+from django.contrib.auth.models import User
+from web.models import StudySubject, Appointment, Study, Subject, Worker, Location, Language, Country, WorkerStudyRole, Item, FlyingTeam, Room, MailTemplate
+from web.models.constants import REDCAP_TOKEN_CONFIGURATION_TYPE, REDCAP_BASE_URL_CONFIGURATION_TYPE, \
+ SEX_CHOICES_MALE, SEX_CHOICES_FEMALE, SUBJECT_TYPE_CHOICES_CONTROL, SUBJECT_TYPE_CHOICES_PATIENT, CONTACT_TYPES_PHONE, \
+ MONDAY_AS_DAY_OF_WEEK, COUNTRY_AFGHANISTAN_ID, VOUCHER_STATUS_NEW, GLOBAL_STUDY_ID, DEFAULT_LOCALE_NAME
+from web.models.constants import MAIL_TEMPLATE_CONTEXT_APPOINTMENT, MAIL_TEMPLATE_CONTEXT_VISIT, \
+ MAIL_TEMPLATE_CONTEXT_SUBJECT, MAIL_TEMPLATE_CONTEXT_VOUCHER
+from web.models.worker_study_role import ROLE_CHOICES_PROJECT_MANAGER, ROLE_CHOICES_SECRETARY, ROLE_CHOICES_DOCTOR, WORKER_VOUCHER_PARTNER
+from web.tests.functions import get_resource_path
+
+from collections import defaultdict
+import logging
+logger = logging.getLogger(__name__)
+
+def add_mail_templates(languages):
+ template_file = get_resource_path('upcoming_appointment_FR.docx')
+ t1, _ = MailTemplate.objects.update_or_create(name='test_fr', language=languages[0], context=MAIL_TEMPLATE_CONTEXT_APPOINTMENT,template_file = template_file)
+
+ t2, _ = MailTemplate.objects.update_or_create(name='test_fr', language=languages[0], context=MAIL_TEMPLATE_CONTEXT_VOUCHER, template_file =template_file)
+
+ t3, _ = MailTemplate.objects.update_or_create(name='test_fr', language=languages[0], context=MAIL_TEMPLATE_CONTEXT_VISIT, template_file =template_file)
+
+ t4, _ = MailTemplate.objects.update_or_create(name='test_en', language=languages[1], context=MAIL_TEMPLATE_CONTEXT_SUBJECT, template_file = template_file)
+
+ return [t1, t2, t3, t4]
+
+def add_flying_teams():
+ places = ['Belval', 'Belvaux', 'Arlon', 'Metz']
+ return [FlyingTeam.objects.update_or_create(place=place)[0] for place in places]
+
+def add_items(): #equipments
+ items = [
+ {'name': 'Table', 'is_fixed': True, 'disposable': False},
+ {'name': 'X-Ray Machine', 'is_fixed': True, 'disposable': False},
+ {'name': 'The mysterious potion', 'is_fixed': False, 'disposable': True},
+ {'name': 'Even more mysterious potion', 'is_fixed': False, 'disposable': True}]
+ return [Item.objects.update_or_create(**item)[0] for item in items]
+
+def add_rooms(equipments):
+ rooms = [
+ {'owner': 'McOwner', 'city': 'Esch', 'address': 'Rue', 'floor': 1, 'is_vehicle': False, 'room_number': 1},
+ {'owner': 'McOwner', 'city': 'Luxembourg', 'address': 'Rue', 'floor': 2, 'is_vehicle': False, 'room_number': 2},
+ {'owner': 'McOwner', 'city': 'Vianden', 'address': 'Rue', 'floor': 1, 'is_vehicle': False, 'room_number': 4},
+ {'owner': 'McOwner', 'city': 'Petange', 'address': 'Rue', 'floor': 4, 'is_vehicle': False, 'room_number': 2}]
+
+ return_rooms = []
+ for i in range(len(rooms)):
+ room, _ = Room.objects.update_or_create(**rooms[i])
+ room.equipment = [equipments[i%len(equipments)]]
+ return_rooms.append(room)
+
+ return return_rooms
+
+def add_languages():
+ languages = ['French', 'English', 'Luxembourgish', 'German', 'Spanish', 'Portuguese']
+ return [Language.objects.update_or_create(name=language, locale=DEFAULT_LOCALE_NAME)[0] for language in languages]
+
+def add_subjects(locations):
+ subjects = [
+ {'first_name': 'Sick', 'last_name': 'Guy', 'sex': SEX_CHOICES_MALE, 'country_id': COUNTRY_AFGHANISTAN_ID},
+ {'first_name': 'Patient', 'last_name': 'Pers', 'sex': SEX_CHOICES_FEMALE, 'country_id': COUNTRY_AFGHANISTAN_ID},
+ {'first_name': 'Control', 'last_name': 'Lia', 'sex': SEX_CHOICES_FEMALE, 'country_id': COUNTRY_AFGHANISTAN_ID},
+ {'first_name': 'Sick Jr.', 'last_name': 'Norg', 'sex': SEX_CHOICES_MALE, 'country_id': COUNTRY_AFGHANISTAN_ID},
+ {'first_name': 'Patient Jr.', 'last_name': 'Voga', 'sex': SEX_CHOICES_FEMALE, 'country_id': COUNTRY_AFGHANISTAN_ID},
+ {'first_name': 'Control Jr.', 'last_name': 'Yung', 'sex': SEX_CHOICES_FEMALE, 'country_id': COUNTRY_AFGHANISTAN_ID},
+ {'first_name': 'Patient 2', 'last_name': 'Porl', 'sex': SEX_CHOICES_FEMALE, 'country_id': COUNTRY_AFGHANISTAN_ID},
+ {'first_name': 'Control 2', 'last_name': 'Weal', 'sex': SEX_CHOICES_FEMALE, 'country_id': COUNTRY_AFGHANISTAN_ID},
+ {'first_name': 'John Jr.', 'last_name': 'Righ', 'sex': SEX_CHOICES_MALE, 'country_id': COUNTRY_AFGHANISTAN_ID},
+ {'first_name': 'Carol', 'last_name': 'Adams', 'sex': SEX_CHOICES_FEMALE, 'country_id': COUNTRY_AFGHANISTAN_ID},
+ {'first_name': 'Control Jr.', 'last_name': 'Roi', 'sex': SEX_CHOICES_FEMALE, 'country_id': COUNTRY_AFGHANISTAN_ID}
+ ]
+
+ types = [SUBJECT_TYPE_CHOICES_CONTROL, SUBJECT_TYPE_CHOICES_PATIENT]
+ letters = ['P', 'C', 'E', 'V']
+ letters2 = ['V', 'L', 'O', 'E']
+ letters3 = ['L', 'P', 'E', 'V']
+
+ study = Study.objects.filter(id=GLOBAL_STUDY_ID)[0]
+
+ study_subjects = []
+ for i, subject in enumerate(subjects):
+ subject, _ = Subject.objects.update_or_create(**subject)
+ if i%3 == 0:
+ screening_number = '{}-{:03}; {}-{:03}'.format(letters[i%len(letters)], i, letters2[i%len(letters2)], (i+1)*2)
+ elif i%2 != 0:
+ screening_number = '{}-{:03}; {}-{:03}'.format(letters2[i%len(letters2)], (i+1)*2, letters[i%len(letters)], i)
+ else:
+ screening_number = '{}-{:03}'.format(letters3[i%len(letters3)], i)
+ study_subject, _ = StudySubject.objects.update_or_create(subject=subject, defaults={'default_location':locations[i%len(locations)], 'type':types[i%len(types)], 'screening_number':screening_number, 'study':study})
+ study_subjects.append(study_subject)
+
+ return study_subject
+
+def add_locations():
+ l1, _ = Location.objects.update_or_create(name='Luxembourg', color='#f00', prefix='L')
+ l2, _ = Location.objects.update_or_create(name='Esch', color='#0f0', prefix='E')
+ l3, _ = Location.objects.update_or_create(name='Petange', color='#00f', prefix='P')
+ l4, _ = Location.objects.update_or_create(name='Vianden', color='#0ff', prefix='V')
+ return [l1, l2, l3, l4]
+
+def add_workers(locations, languages):
+
+ users = [
+ {'username':'manager', 'email':'manager@hospital.abc', 'password':'password1234'},
+ {'username':'secretary', 'email':'secretary@hospital.abc', 'password':'password1234'},
+ {'username':'doctor', 'email':'doctor@hospital.abc', 'password':'password1234'},
+ {'username':'doctor2', 'email':'doctor2@hospital.abc', 'password':'password1234'}
+ ]
+
+ workers = [
+ {'first_name':'Manager', 'last_name': 'Office', 'email':'manager@hospital.abc',
+ 'specialization': 'spec', 'unit':"Parkinson", 'phone_number':'0123456789'},
+ {'first_name':'Secretary', 'last_name': 'Office', 'email':'secretary@hospital.abc',
+ 'specialization': 'spec', 'unit':"Parkinson", 'phone_number':'0123456789'},
+ {'first_name':'Doctor', 'last_name': 'Office', 'email':'doctor@hospital.abc',
+ 'specialization': 'spec', 'unit':"Parkinson", 'phone_number':'0123456789'},
+ {'first_name':'Doctor2', 'last_name': 'Office', 'email':'doctor2@hospital.abc',
+ 'specialization': 'spec', 'unit':"Parkinson", 'phone_number':'0123456789'}
+ ]
+
+ roles = [ROLE_CHOICES_PROJECT_MANAGER, ROLE_CHOICES_SECRETARY, ROLE_CHOICES_DOCTOR, ROLE_CHOICES_DOCTOR]
+
+ for i in range(len(users)):
+ user, _ = User.objects.update_or_create(username=users[i]['username'], defaults=users[i])
+ user.set_password(users[i]['password']) # internally triggers the password hashing mechanism
+ user.save()
+ workers[i]['user'] = user
+ worker, _ = Worker.objects.update_or_create(first_name=workers[i]['first_name'], last_name=workers[i]['last_name'], defaults=workers[i])
+ worker.locations = [locations[i%len(locations)]]
+ worker.languages = [languages[i%len(locations)]]
+ WorkerStudyRole.objects.update_or_create(worker=worker, study_id=GLOBAL_STUDY_ID, role=roles[i])
+
+from faker.providers import BaseProvider, color
+from numpy.random import choice
+from faker import Faker
+import unidecode
+
+class smashProvider(BaseProvider):
+
+ __provider__ = 'smash'
+ __lang__ = 'fr_FR'
+ fake = Faker()
+
+ specialists = ['Psychiatrist', 'Radiologist', 'Immunologist', 'Anesthesiologist', 'Surgeon', 'Pediatrician', 'Neurologist', 'Medical examiner']
+ units = ['LHI', 'PCR', 'LCSB', 'ACO', 'PLI', 'LRSU']
+ workerRoles = [ROLE_CHOICES_PROJECT_MANAGER, ROLE_CHOICES_SECRETARY, ROLE_CHOICES_DOCTOR, ROLE_CHOICES_DOCTOR]
+
+ #towns and cities
+ near_fr_towns = ['Metz', 'Audun-le-Tiche', 'Thionville']
+ near_de_towns = ['Trier']
+ near_be_towns = ['Aubange', 'Arlon']
+ luxtowns = ['Luxembourg City', 'Esch-sur-Alzette', 'Differdange', 'Dudelange', 'Ettelbruck', 'Diekirch', 'Wiltz', 'Rumelange', 'Echternach', 'Grevenmacher', 'Remich', 'Vianden']
+
+ #if you add or remove cities, be careful and change the probabilities as well
+ #here the probs ensure the luxembourgish towns have 0.8 prob, and so on...
+ cities = luxtowns + near_fr_towns + near_de_towns + near_be_towns
+ city_prob = [0.8/len(luxtowns)] *len(luxtowns) + \
+ [0.1/len(near_fr_towns)] *len(near_fr_towns) + \
+ [0.05/len(near_de_towns)]*len(near_de_towns) + \
+ [0.05/len(near_be_towns)]*len(near_be_towns)
+
+ alreadyCreatedLocations = {}
+ #languages
+ language_base_dir = './smash/web/static/flags/'
+ language_flags = {
+ 'French' : 'FR.png',
+ 'English': 'GB.png',
+ 'Spanish': 'ES.png',
+ 'Portuguese': 'PT.png',
+ 'Luxembourgish': 'LU.png',
+ 'German': 'DE.png',
+ 'Dutch' : 'NL.png'
+ }
+ languages = ['English', 'Luxembourgish', 'French', 'German', 'Portuguese', 'Spanish', 'Dutch']
+ languages_prob = [0.25, 0.2, 0.16, 0.16, 0.13, 0.05, 0.05]
+ alreadyCreatedLanguages = {}
+ #items
+ items = ['Ambulance', 'Bandages', 'Examination Table', 'X-Ray Machine', 'Lab Coat', 'Needle', 'Stretcher', 'Vial', 'Wheelchair']
+ alreadyCreatedItems = {}
+ #flying teams
+ places = ['Belval', 'Belvaux', 'Arlon', 'Metz']
+ alreadyCreatedFlyingTeams = {}
+ #countries
+ countries = ['France', 'Luxembourg', 'Germamny', 'Belgium']
+
+ alreadyCreatedCountries = {}
+
+ screening_number_ctrs = defaultdict(int)
+
+ def getLuxembourgTown(self):
+ return self.fake.word(ext_word_list=self.luxtowns)
+
+ def getFrenchTown(self):
+ return self.fake.word(ext_word_list=self.near_fr_towns)
+
+ def getBelgiumTown(self):
+ return self.fake.word(ext_word_list=self.near_be_towns)
+
+ def getDeutschTown(self):
+ return self.fake.word(ext_word_list=self.near_de_towns)
+
+ def getWorkerRole(self):
+ return self.fake.word(ext_word_list=self.workerRoles)
+
+ #flying teams
+ def createSmashFlyingTeams(self):
+ return [self.createSmashFlyingTeam(place=place) for place in self.places]
+
+ def createSmashFlyingTeam(self, place=None):
+ if place is None:
+ place = self.fake.word(ext_word_list=self.places)
+ flying_team, _ = FlyingTeam.objects.update_or_create(place=place)
+
+ self.alreadyCreatedFlyingTeams[place] = flying_team
+
+ return flying_team
+
+ #item
+ def createSmashItems(self):
+ '''
+ Returns a list of Item objects
+ '''
+ return [self.createSmashItem(name=item) for item in self.items]
+
+ def createSmashItem(self, name=None, is_fixed=None, disposable=None):
+ '''
+ Returns an Item object
+ '''
+ if name is None:
+ name = self.fake.word(ext_word_list=self.items)
+
+ if is_fixed is None:
+ is_fixed = self.fake.boolean(chance_of_getting_true=75)
+
+ if disposable is None:
+ disposable = self.fake.boolean(chance_of_getting_true=75)
+
+ item, _ = Item.objects.update_or_create(name=name, is_fixed=is_fixed, disposable=disposable)
+
+ self.alreadyCreatedItems[name] = item
+
+ return item
+
+ def getSmashAlreadyCreatedItem(self, max_n=3):
+ if len(self.alreadyCreatedItems.keys()) == 0:
+ self.createSmashItems()
+
+ keys = set(choice(self.alreadyCreatedItems.keys(), max_n))
+ return [self.alreadyCreatedItems[key] for key in keys]
+
+ #room
+ def createSmashRooms(self, n=4):
+ return [self.createSmashRoom() for _ in xrange(n)]
+
+ def createSmashRoom(self, equipment=None, owner=None, address=None, city=None, room_number=None, floor=None, is_vehicle=None):
+ '''
+ equipment: List of Item objects:
+ owner: string:
+ address: string:
+ city: string:
+ room_number: int:
+ floor: int:
+ is_vehicle: boolean:
+ '''
+ if equipment is None:
+ item = self.fake.word(ext_word_list=self.alreadyCreatedItems.keys())
+ equipment = self.getSmashAlreadyCreatedItem()
+
+ if owner is None:
+ owner = self.fake.first_name()
+
+ if address is None:
+ address = '{}, {} {}'.format(self.fake.word(ext_word_list=self.cities), self.fake.random_digit_not_null_or_empty(), self.fake.street_name())
+ address = address.replace('\n', ' ')
+
+ if city is None:
+ city = self.fake.word(ext_word_list=self.cities)
+
+ if room_number is None:
+ room_number = choice(range(10), 1)[0] #choice returns a list
+
+ if floor is None:
+ floor = choice(range(10), 1)[0]
+
+ if is_vehicle is None:
+ is_vehicle = self.fake.boolean(chance_of_getting_true=25)
+
+ dicc = {'owner': owner, 'city': city, 'address': address,
+ 'floor': floor, 'room_number': room_number, 'is_vehicle': is_vehicle}
+ room, _ = Room.objects.update_or_create(**dicc)
+ room.equipment.set(equipment)
+ room.save()
+
+ return room
+
+ #country
+ def getAlreadyCreatedSmashCountry(self):
+ if len(self.alreadyCreatedCountries) == 0:
+ self.createSmashCountries()
+
+ name = self.fake.word(ext_word_list=self.countries)
+ return self.alreadyCreatedCountries[name]
+
+ def createSmashCountries(self):
+ return [self.createSmashCountry(name=country) for country in self.countries]
+
+ def createSmashCountry(self, name=None, order=0):
+ if name is None:
+ name = self.fake.word(ext_word_list=self.countries)
+ country, _ = Country.objects.update_or_create(name=name, order=order)
+ self.alreadyCreatedCountries[name] = country
+ return country
+
+ def createSmashScreeningNumber(self, prefix):
+ self.screening_number_ctrs[prefix]+=1
+ return '{}-{:03}'.format(prefix, self.screening_number_ctrs[prefix])
+
+ #subject
+ def createSmashStudySubjects(self, n=30):
+ '''
+ Returns a list of tuples (subject, study_subject)
+ '''
+ study = Study.objects.filter(id=GLOBAL_STUDY_ID)[0]
+ return [self.createSmashStudySubject(study=study) for _ in xrange(n)]
+
+ def createSmashStudySubject(self, subject=None, study=None, postponed=None,
+ datetime_contact_reminder=None, type=None, default_location=None, flying_team=None,
+ screening_number=None): # complete code and args...
+
+ if subject is None:
+ subject = self.createSmashSubject()
+
+ if study is None:
+ study = Study.objects.filter(id=GLOBAL_STUDY_ID)[0]
+
+ if type is None:
+ type = choice([SUBJECT_TYPE_CHOICES_CONTROL, SUBJECT_TYPE_CHOICES_PATIENT], 1, p=[0.2, 0.8])
+ type = type[0]
+
+ if default_location is None:
+ default_location = self.getAlreadyCreatedSmashLocation()
+
+ if screening_number is None:
+ screening_number = self.createSmashScreeningNumber(default_location.prefix)
+
+ study_subject, _ = StudySubject.objects.update_or_create(subject=subject,
+ defaults={'default_location':default_location, 'type':type,
+ 'screening_number': screening_number, 'study':study})
+
+ return study_subject
+
+ def createSmashSubject(self, first_name=None, last_name=None, languages=None,
+ default_written_communication_language=None, phone_number=None, social_security_number=None,
+ sex=None, country_id=None, date_born=None, address=None,
+ postal_code=None, city=None, country=None, dead=None):
+
+ if first_name is None:
+ first_name = self.fake.first_name()
+
+ if last_name is None:
+ last_name = self.fake.last_name()
+
+ if languages is None:
+ languages = self.getAlreadyCreatedSmashLanguages()
+
+ if default_written_communication_language is None:
+ getAlreadyCreatedSmashLanguages = languages[0]
+
+ if phone_number is None:
+ phone_number = self.fake.phone_number()
+
+ if social_security_number is None:
+ social_security_number = self.fake.ean(length=8)
+
+ if sex is None:
+ sex = self.fake.word(ext_word_list=[SEX_CHOICES_MALE, SEX_CHOICES_FEMALE])
+
+ if country_id is None:
+ country_id = COUNTRY_AFGHANISTAN_ID
+
+ if date_born is None:
+ date_born = self.fake.date_of_birth(minimum_age=50, maximum_age=105).strftime('%Y-%m-%d')
+ if address is None:
+ address = self.fake.address()
+ if postal_code is None:
+ postal_code = self.fake.postcode()
+ if city is None:
+ city = self.fake.word(ext_word_list=self.cities)
+ if country is None:
+ country = self.getAlreadyCreatedSmashCountry()
+ if dead is None:
+ dead = self.fake.boolean(chance_of_getting_true=1)
+
+ dicc = {'first_name': first_name, 'last_name': last_name,
+ 'default_written_communication_language': default_written_communication_language,
+ 'phone_number': phone_number, 'social_security_number': social_security_number,
+ 'sex': sex, 'country_id': country_id, 'date_born': date_born, 'address': address,
+ 'postal_code': postal_code, 'city': city, 'country': country, 'dead': dead}
+
+ subject, _ = Subject.objects.update_or_create(**dicc)
+ subject.languages.set(languages)
+ subject.save()
+
+ return subject
+
+ #user
+ def createSmashUser(self, username=None, email=None, password='password1234'):
+ '''
+ username: string: Sets the username. By default None. Random values are generated unless other value is provided.
+ email: string: Sets the email. By default None. Random values are generated unless other value is provided.
+ password: string: Sets the password. By default password1234 unless other value is provided.
+ Returns a user
+ '''
+ first_name = self.fake.first_name().lower().replace('_', '')
+ last_name = self.fake.last_name().lower().replace('_', '')
+ if username is None:
+ username = u'{}_{}'.format(first_name, last_name)
+ username = unidecode.unidecode(username)
+
+ if email is None:
+ email = u'{}.{}@smash.lu'.format(first_name, last_name)
+ email = unidecode.unidecode(email)
+ #create user
+ defaults = {'email':email, 'password': password}
+ user, _ = User.objects.update_or_create(username=username, defaults=defaults)
+ user.set_password(password)
+ user.save()
+ return user
+
+ #worker
+ def createSmashWorkers(self, n=10):
+ '''
+ :n int: number of workers to create
+
+ Returns a list of tuples (user, worker, workerStuyRole)
+ '''
+ logger.info('creating Smash Worker...')
+ return [self.createSmashWorker() for _ in xrange(n)]
+
+ def createSmashWorker(self, first_name=None, last_name=None, username=None, email=None, specialization=None, unit=None, phone_number=None, password='password1234', role=None):
+ '''
+ first_name: string: Sets the first_name. By default None. Random values are generated. Provide a value to overwrite random generation
+ last_name: string: Sets the last_name. By default None. Random values are generated. Provide a value to overwrite random generation
+ username: string: Sets the username. By default None. Random values are generated. Provide a value to overwrite random generation
+ email: string: Sets the email. By default None. Random values are generated. Provide a value to overwrite random generation
+ specialization: string: Sets the specialization. By default None. Random values are generated. Provide a value to overwrite random generation
+ unit: string: Sets the unit. By default None. Random values are generated. Provide a value to overwrite random generation
+ phone_number: string: Sets the phone_number. By default None. Random values are generated. Provide a value to overwrite random generation
+ password: string: Sets the password. By default None. Random values are generated. Provide a value to overwrite random generation
+ role: string: Sets the role. By default None. Random values are generated. Provide a value to overwrite random generation
+ Returns a tuple with (user, worker, workerStuyRole)
+ '''
+ if first_name is None:
+ first_name = self.fake.first_name()
+
+ if last_name is None:
+ last_name = self.fake.last_name()
+
+ if username is None:
+ username = u'{}_{}'.format(first_name, last_name)
+
+ if email is None:
+ email = u'{}.{}@smash.lu'.format(first_name, last_name)
+
+ if specialization is None:
+ specialization = self.getSmashSpecialization()
+
+ if unit is None:
+ unit = self.getSmashUnit()
+
+ if phone_number is None:
+ phone_number = self.fake.phone_number()
+
+ if role is None:
+ role = self.getWorkerRole()
+
+ #create user
+ user = self.createSmashUser(username=username, email=email, password=password)
+
+ #create worker
+ defaults = {'first_name': first_name, 'last_name': last_name,
+ 'email': email, 'unit':unit, 'specialization': specialization,
+ 'phone_number': phone_number, 'user': user}
+ worker, _ = Worker.objects.update_or_create(first_name=first_name,
+ last_name=last_name, defaults=defaults)
+
+ worker.locations.set([self.getAlreadyCreatedSmashLocation()])
+ worker.languages.set(self.getAlreadyCreatedSmashLanguages())
+ worker.save()
+
+ #create workerStudyRole
+ workerStudyRole, _ = WorkerStudyRole.objects.update_or_create(worker=worker,
+ study_id=GLOBAL_STUDY_ID, role=role)
+
+ #unit
+ def getSmashUnit(self):
+ return self.fake.word(ext_word_list=self.units)
+
+ #specialization
+ def getSmashSpecialization(self):
+ return self.fake.word(ext_word_list=self.specialists)
+
+ #languages
+ def createSmashLanguages(self):
+ '''
+ Returns a list of Language objects
+ '''
+ logger.info('creating Smash Languages...')
+ return [self.createSmashLanguage(name=name) for name in self.languages]
+
+ def createSmashLanguage(self, name=None, locale=DEFAULT_LOCALE_NAME):
+ '''
+ Returns a Language object
+ '''
+ if name is None:
+ name = self.fake.word(ext_word_list=self.languages)
+
+ language, _ = Language.objects.update_or_create(name=name, locale=locale)
+ self.alreadyCreatedLanguages[name] = language
+ return language
+
+ def getAlreadyCreatedSmashLanguages(self, max_n=3):
+ '''
+ Returns a list of Languages from the already created languages,
+ if no languages are created, then the list is generated.
+
+ max_n: int: maximum number of languages to return
+
+ Returns a list of Language objects.
+ '''
+ if len(self.alreadyCreatedLanguages.keys()) == 0:
+ self.createSmashLanguages()
+
+ languages = choice(self.languages, max_n, p=self.languages_prob)
+ keys = set(languages) #unique
+ return [self.alreadyCreatedLanguages[key] for key in keys]
+
+ #locations
+ def getAlreadyCreatedSmashLocation(self):
+ return self.random_element(self.alreadyCreatedLocations.values())
+
+ def createSmashLocations(self, n=5):
+ logger.info('creating Smash Locations...')
+ return [self.createSmashLocation() for _ in xrange(n)]
+
+ def createSmashLocation(self, city=None, color=None, prefix=None):
+ if city is None:
+ city = choice(self.cities, 1, p=self.city_prob)[0]
+
+ if color is None:
+ color = self.fake.hex_color()
+
+ if prefix is None:
+ prefix = city[:1]
+
+ location, _ = Location.objects.update_or_create(name=city, color=color, prefix=prefix)
+
+ self.alreadyCreatedLocations[city] = location
+
+ return location
+
+if __name__ == "__main__":
+ fake = Faker()
+ fake.add_provider(smashProvider)
+
+ fake.createSmashFlyingTeams()
+ fake.createSmashItems()
+ fake.createSmashRooms()
+ fake.createSmashLocations()
+ fake.createSmashLanguages()
+ fake.createSmashCountries()
+
+ fake.createSmashWorkers()
+ fake.createSmashStudySubjects()
+
+ # flying_teams = add_flying_teams()
+ # items = add_items()
+ # add_rooms(items)
+ # locations = add_locations()
+ # languages = add_languages()
+ # add_workers(locations, languages)
+ # add_mail_templates(languages)
+ # add_subjects(locations)
\ No newline at end of file
--
GitLab