def import_event_types():
models = get_json_data('events.eventtype.json')
for model in models:
fields = model['fields']
EventType.objects.get_or_create(
pk=model['pk'],
name=fields['name'])
def import_event_sign_ups():
models = get_json_data('events.eventsignup.json')
for model in models:
fields = model['fields']
pk = model['pk']
event_sign_up, _ = EventSignUp.objects.get_or_create(
pk=pk,
event=Event.objects.get(pk=fields['event']),
name=fields['name'],
driving=fields['driving'],
comments=fields['comments'],
email=fields['email'],
unsignup=fields['unsignup'])
if fields['person']:
event_sign_up.user = user_model.objects.get(pk=fields['person'])
event_sign_up.save()
try:
# Try to convert the naive datetime into an aware datetime, which
# may fail because of daylight savings time creating ambiguity for
# some timestamps
timestamp = make_aware(parser.parse(fields['timestamp']), timezone)
# Get a queryset of the single object so that update can be called,
# which doesn't call save and allows fields with auto_now=True to be
# overridden
event_sign_up = EventSignUp.objects.filter(pk=pk)
event_sign_up.update(timestamp=timestamp)
except AmbiguousTimeError:
print('ERROR: Could not import timestamp for {}'.format(
event_sign_up))
def import_event_attendances():
models = get_json_data('events.eventattendance.json')
for model in models:
fields = model['fields']
EventAttendance.objects.get_or_create(
pk=model['pk'],
event=Event.objects.get(pk=fields['event']),
user=user_model.objects.get(pk=fields['person']))
def import_terms():
models = get_json_data('noiro_main.semester.json')
for model in models:
fields = model['fields']
term, _ = Term.objects.get_or_create(
term=fields['semester'],
year=fields['year'],
current=fields['current'])
SEMESTER_TO_TERM[model['pk']] = term.pk
def import_departments():
models = get_json_data('courses.department.json')
for model in models:
fields = model['fields']
Department.objects.get_or_create(
pk=model['pk'],
long_name=fields['name'],
short_name=fields['abbreviation'][0:25],
abbreviation=fields['code'][0:25])
def import_project_reports():
# pylint: disable=E1103
models = get_json_data('projects.projectreport.json')
for model in models:
fields = model['fields']
pk = model['pk']
term = Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']])
project_report, _ = ProjectReport.objects.get_or_create(
pk=pk,
term=term,
date=parser.parse(fields['date']).date(),
title=fields['title'],
author=user_model.objects.get(pk=fields['author']),
committee=OfficerPosition.objects.get(pk=fields['committee']),
area=fields['area'],
organize_hours=fields['organize_hours'],
participate_hours=fields['participate_hours'],
is_new=fields['is_new'],
other_group=fields['other_group'],
description=fields['description'],
purpose=fields['purpose'],
organization=fields['organization'],
cost=fields['cost'],
problems=fields['problems'],
results=fields['results'],
non_tbp=fields['non_tbp'],
complete=fields['complete'])
for officer_pk in fields['officer_list']:
project_report.officer_list.add(user_model.objects.get(
pk=officer_pk))
for member_pk in fields['member_list']:
project_report.member_list.add(user_model.objects.get(
pk=member_pk))
for candidate_pk in fields['candidate_list']:
project_report.candidate_list.add(user_model.objects.get(
pk=candidate_pk))
if fields['attachment']:
attachment_location = os.path.join(
NOIRO_MEDIA_LOCATION, fields['attachment'])
with open(attachment_location, 'r') as attachment:
project_report.attachment = File(attachment)
project_report.save()
# Convert the naive datetime into an aware datetime
timestamp = make_aware(parser.parse(fields['timestamp']), timezone)
# Get a queryset of the single object so that update can be called,
# which doesn't call save and allows fields with auto_now=True to be
# overridden
project_report = ProjectReport.objects.filter(pk=pk)
# Set created and updated equal to timestamp because in noiro there
# is no created field and timestamp is updated whenever the object is
# updated
project_report.update(created=timestamp, updated=timestamp)
def import_event_requirements():
models = get_json_data('candidate_portal.eventrequirement.json')
for model in models:
fields = model['fields']
new_pk = model['pk'] + EVENT_REQUIREMENT_PK_CONVERSION
EventCandidateRequirement.objects.get_or_create(
pk=new_pk,
credits_needed=fields['num_required'],
term=Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']]),
event_type=EventType.objects.get(pk=fields['event_type']))
def import_officers():
models = get_json_data('noiro_main.officer.json')
for model in models:
fields = model['fields']
Officer.objects.get_or_create(
pk=model['pk'],
user=user_model.objects.get(pk=fields['user']),
position=OfficerPosition.objects.get(pk=fields['position']),
term=Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']]),
is_chair=fields['is_chair'])
def import_instructors():
models = get_json_data('courses.instructor.json')
for model in models:
fields = model['fields']
Instructor.objects.get_or_create(
pk=model['pk'],
first_name=fields['firstname'],
last_name=fields['lastname'],
department=Department.objects.get(pk=fields['department']),
website=fields['website'])
def import_event_requirements():
models = get_json_data('candidate_portal.eventrequirement.json')
for model in models:
fields = model['fields']
new_pk = model['pk'] + EVENT_REQUIREMENT_PK_CONVERSION
EventCandidateRequirement.objects.get_or_create(
pk=new_pk,
credits_needed=fields['num_required'],
term=Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']]),
event_type=EventType.objects.get(pk=fields['event_type']))
def import_courses():
models = get_json_data('courses.course.json')
for model in models:
fields = model['fields']
Course.objects.get_or_create(
pk=model['pk'],
department=Department.objects.get(pk=fields['department']),
number=fields['number'],
title=fields['title'],
description=fields['description'])
def import_candidate_progresses():
models = get_json_data('candidate_portal.eventrequirementexception.json')
for model in models:
fields = model['fields']
new_pk = fields['event_requirement'] + EVENT_REQUIREMENT_PK_CONVERSION
CandidateRequirementProgress.objects.get_or_create(
pk=model['pk'],
candidate=Candidate.objects.get(pk=fields['candidate_profile']),
requirement=EventCandidateRequirement.objects.get(pk=new_pk),
alternate_credits_needed=fields['new_num_required'],
comments=fields['comments'])
def import_course_instances():
models = get_json_data('courses.section.json')
for model in models:
fields = model['fields']
instance = CourseInstance.objects.get_or_create(
pk=model['pk'],
term=Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']]),
course=Course.objects.get(pk=fields['course']))[0]
instance.instructors = Instructor.objects.filter(
pk__in=fields['instructors'])
instance.save()
def import_candidate_progresses():
models = get_json_data('candidate_portal.eventrequirementexception.json')
for model in models:
fields = model['fields']
new_pk = fields['event_requirement'] + EVENT_REQUIREMENT_PK_CONVERSION
CandidateRequirementProgress.objects.get_or_create(
pk=model['pk'],
candidate=Candidate.objects.get(pk=fields['candidate_profile']),
requirement=EventCandidateRequirement.objects.get(pk=new_pk),
alternate_credits_needed=fields['new_num_required'],
comments=fields['comments'])
def import_challenges():
models = get_json_data('candidate_portal.challenge.json')
for model in models:
fields = model['fields']
Challenge.objects.get_or_create(
pk=model['pk'],
candidate=Candidate.objects.get(pk=fields['candidate_profile']),
challenge_type=ChallengeCandidateRequirement.objects.get(
pk=fields['challenge_type']).challenge_type,
description=fields['description'],
verifying_user=Officer.objects.get(pk=fields['officer']).user,
verified=fields['verified'])
def import_challenges():
models = get_json_data('candidate_portal.challenge.json')
for model in models:
fields = model['fields']
Challenge.objects.get_or_create(
pk=model['pk'],
candidate=Candidate.objects.get(pk=fields['candidate_profile']),
challenge_type=ChallengeCandidateRequirement.objects.get(
pk=fields['challenge_type']).challenge_type,
description=fields['description'],
verifying_user=Officer.objects.get(pk=fields['officer']).user,
verified=fields['verified'])
def import_challenge_requirements():
models = get_json_data('candidate_portal.challengerequirement.json')
for model in models:
fields = model['fields']
challenge_type, _ = ChallengeType.objects.get_or_create(
name=fields['challenge_type'])
ChallengeCandidateRequirement.objects.get_or_create(
pk=model['pk'],
credits_needed=fields['num_required'],
term=Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']]),
challenge_type=challenge_type)
def import_challenge_requirements():
models = get_json_data('candidate_portal.challengerequirement.json')
for model in models:
fields = model['fields']
challenge_type, _ = ChallengeType.objects.get_or_create(
name=fields['challenge_type'])
ChallengeCandidateRequirement.objects.get_or_create(
pk=model['pk'],
credits_needed=fields['num_required'],
term=Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']]),
challenge_type=challenge_type)
def import_quotes():
# pylint: disable=E1103
models = get_json_data('quoteboard.quote.json')
for model in models:
fields = model['fields']
pk = model['pk']
quote, _ = Quote.objects.get_or_create(
pk=pk,
quote=fields['quote_line'],
submitter=user_model.objects.get(pk=fields['poster']))
quote.speakers.add(user_model.objects.get(pk=fields['speaker']))
# Get a queryset of the single object so that update can be called,
# which doesn't call save and allows fields with auto_now_add=True to be
# overridden
quote = Quote.objects.filter(pk=pk)
quote.update(time=parser.parse(fields['quote_time']).date())
def import_quotes():
# pylint: disable=E1103
models = get_json_data('quoteboard.quote.json')
for model in models:
fields = model['fields']
pk = model['pk']
quote, _ = Quote.objects.get_or_create(
pk=pk,
quote=fields['quote_line'],
submitter=user_model.objects.get(pk=fields['poster']))
quote.speakers.add(user_model.objects.get(pk=fields['speaker']))
# Get a queryset of the single object so that update can be called,
# which doesn't call save and allows fields with auto_now_add=True to be
# overridden
quote = Quote.objects.filter(pk=pk)
quote.update(time=parser.parse(fields['quote_time']).date())
def import_user_achievements():
models = get_json_data('achievements.userachievement.json')
for model in models:
fields = model['fields']
achievement = ACHIEVEMENT_CONVERSION.get(fields['achievement'])
if achievement:
user_achievement, _ = UserAchievement.objects.get_or_create(
user=user_model.objects.get(pk=fields['user']),
achievement=Achievement.objects.get(short_name=achievement),
acquired=True,
term=Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']]),
data=fields['data'])
assigner = fields['assigner']
if assigner:
user_achievement.assigner = user_model.objects.get(pk=assigner)
user_achievement.save()
def import_exam_flags():
models = get_json_data('examfiles.examflag.json')
for model in models:
fields = model['fields']
# Don't import flags for exams that weren't imported because they were
# duplicates with a different file type
exam = get_object_or_none(Exam, pk=fields['exam'])
if not exam:
continue
exam_flag, _ = ExamFlag.objects.get_or_create(pk=model['pk'],
exam=exam,
reason=fields['reason'])
# Convert the naive datetime into an aware datetime
created = parser.parse(fields['created'])
exam_flag.created = make_aware(created, timezone)
exam_flag.save()
def import_exam_flags():
models = get_json_data('examfiles.examflag.json')
for model in models:
fields = model['fields']
# Don't import flags for exams that weren't imported because they were
# duplicates with a different file type
exam = get_object_or_none(Exam, pk=fields['exam'])
if not exam:
continue
exam_flag, _ = ExamFlag.objects.get_or_create(
pk=model['pk'],
exam=exam,
reason=fields['reason'])
# Convert the naive datetime into an aware datetime
created = parser.parse(fields['created'])
exam_flag.created = make_aware(created, timezone)
exam_flag.save()
def import_users():
models = get_json_data('auth.user.json')
for model in models:
fields = model['fields']
user = user_model.objects.create_user(
pk=model['pk'],
username=fields['username'],
email=fields['email'])
user.first_name = fields['first_name']
user.last_name = fields['last_name']
user.is_active = fields['is_active']
user.is_superuser = fields['is_superuser']
user.is_staff = fields['is_staff']
user.email = fields['email']
# Convert the naive datetime into an aware datetime
date_joined = parser.parse(fields['date_joined'])
user.date_joined = make_aware(date_joined, timezone)
user.save()
def import_candidates():
models = get_json_data('candidate_portal.candidateprofile.json')
for model in models:
fields = model['fields']
term = Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']])
user_pk = fields['user']
candidate, _ = Candidate.objects.get_or_create(
pk=model['pk'],
user=user_model.objects.get(pk=user_pk),
term=term,
initiated=HAS_INITIATED[user_pk])
photo_location = os.path.join(NOIRO_MEDIA_LOCATION,
CANDIDATE_PHOTO_LOCATION,
term.get_url_name(),
str(fields['user']) + '.jpg')
if os.path.exists(photo_location):
with open(photo_location, 'r') as photo:
candidate.photo = File(photo)
candidate.save()
def import_candidates():
models = get_json_data('candidate_portal.candidateprofile.json')
for model in models:
fields = model['fields']
term = Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']])
user_pk = fields['user']
candidate, _ = Candidate.objects.get_or_create(
pk=model['pk'],
user=user_model.objects.get(pk=user_pk),
term=term,
initiated=HAS_INITIATED[user_pk])
photo_location = os.path.join(
NOIRO_MEDIA_LOCATION,
CANDIDATE_PHOTO_LOCATION,
term.get_url_name(),
str(fields['user']) + '.jpg')
if os.path.exists(photo_location):
with open(photo_location, 'r') as photo:
candidate.photo = File(photo)
candidate.save()
def import_minutes():
# pylint: disable=E1103
models = get_json_data('minutes.minutes.json')
for model in models:
fields = model['fields']
pk = model['pk']
# Determine the meeting type based off the name
name = fields['name']
if name == 'OM' or ' OM' in name or 'officer meeting' in name.lower():
meeting_type = Minutes.OFFICER
elif name == 'EM' or ' EM' in name or 'exec meeting' in name.lower():
meeting_type = Minutes.EXEC
else:
meeting_type = Minutes.OTHER
Minutes.objects.get_or_create(
pk=pk,
name=name,
date=parser.parse(fields['date']).date(),
term=Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']]),
meeting_type=meeting_type,
notes=fields['notes'],
public=fields['public'],
author=user_model.objects.get(pk=fields['poster']))
# Convert the naive datetime into an aware datetime
timestamp = make_aware(parser.parse(fields['updated']), timezone)
# Get a queryset of the single object so that update can be called,
# which doesn't call save and allows fields with auto_now=True to be
# overridden
minutes = Minutes.objects.filter(pk=pk)
# Set created and updated equal to timestamp because in noiro there
# is no created field and timestamp is updated whenever the object is
# updated
minutes.update(created=timestamp, updated=timestamp)
def import_minutes():
# pylint: disable=E1103
models = get_json_data('minutes.minutes.json')
for model in models:
fields = model['fields']
pk = model['pk']
# Determine the meeting type based off the name
name = fields['name']
if name == 'OM' or ' OM' in name or 'officer meeting' in name.lower():
meeting_type = Minutes.OFFICER
elif name == 'EM' or ' EM' in name or 'exec meeting' in name.lower():
meeting_type = Minutes.EXEC
else:
meeting_type = Minutes.OTHER
Minutes.objects.get_or_create(
pk=pk,
name=name,
date=parser.parse(fields['date']).date(),
term=Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']]),
meeting_type=meeting_type,
notes=fields['notes'],
public=fields['public'],
author=user_model.objects.get(pk=fields['poster']))
# Convert the naive datetime into an aware datetime
timestamp = make_aware(parser.parse(fields['updated']), timezone)
# Get a queryset of the single object so that update can be called,
# which doesn't call save and allows fields with auto_now=True to be
# overridden
minutes = Minutes.objects.filter(pk=pk)
# Set created and updated equal to timestamp because in noiro there
# is no created field and timestamp is updated whenever the object is
# updated
minutes.update(created=timestamp, updated=timestamp)
def import_resumes():
models = get_json_data('user_profiles.resume.json')
for model in models:
fields = model['fields']
user = user_model.objects.get(pk=fields['user'])
pk = model['pk']
resume, _ = Resume.objects.get_or_create(
pk=pk,
user=user,
gpa=fields['gpa'],
full_text=fields['full_text'],
verified=fields['approved'],
critique=fields['critique_requested'],
release=fields['release'])
# Try to get the resume file, which may not exist (very rare)
try:
resume_location = os.path.join(
NOIRO_MEDIA_LOCATION, fields['file'])
with open(resume_location, 'r') as resume_file:
resume.resume_file = File(resume_file)
resume.save()
except IOError:
print 'Could not import {}\'s resume.'.format(user)
# Convert the naive datetime into an aware datetime
timestamp = make_aware(parser.parse(fields['timestamp']), timezone)
# Get a queryset of the single object so that update can be called,
# which doesn't call save and allows fields with auto_now=True to be
# overridden
resume = Resume.objects.filter(pk=pk)
# Set created and updated equal to timestamp because in noiro there
# is no created field and timestamp is updated whenever the object is
# updated
resume.update(created=timestamp, updated=timestamp)
def import_events():
models = get_json_data('events.event.json')
for model in models:
fields = model['fields']
# Convert the naive datetimes into aware datetimes
start_datetime = make_aware(
parser.parse(fields['start_datetime']), timezone)
end_datetime = make_aware(
parser.parse(fields['end_datetime']), timezone)
event, _ = Event.objects.get_or_create(
pk=model['pk'],
name=fields['name'],
event_type=EventType.objects.get(pk=fields['event_type']),
start_datetime=start_datetime,
end_datetime=end_datetime,
term=Term.objects.get(pk=SEMESTER_TO_TERM[fields['semester']]),
tagline=fields['tagline'],
description=fields['description'],
location=fields['location'],
contact=user_model.objects.get(pk=fields['contact']),
restriction=fields['restriction'],
signup_limit=fields['signup_limit'],
needs_drivers=fields['needs_drivers'],
cancelled=fields['cancelled'],
requirements_credit=fields['requirements_credit'])
if fields['committee']:
event.committee = OfficerPosition.objects.get(
pk=fields['committee'])
if fields['project_report']:
event.project_report = ProjectReport.objects.get(
pk=fields['project_report'])
event.save()
def import_exams():
# pylint: disable=R0912,R0914
models = get_json_data('examfiles.exam.json')
for model in models:
fields = model['fields']
year = int(fields['year'])
semester = fields['semester']
# Check for exams with unknown semesters
if semester == '??':
semester = Term.UNKNOWN
# Check for exams with unknown years (all stored with years less than 5)
if year < 5:
term = None
else:
term, _ = Term.objects.get_or_create(term=semester, year=year)
dept_pk, dept_abbreviation = DEPARTMENT_CONVERSION[
fields['department']]
department = Department.objects.get(pk=dept_pk)
course, _ = Course.objects.get_or_create(department=department,
number=fields['courseNumber'])
# Some last names contain in parenthesis the section number or some
# other information about the course, so remove that
last_names = fields['professor']
paren_index = last_names.find('(')
if paren_index != -1:
last_names = last_names[:paren_index]
# Multiple last names may be separated by commas or underscores
last_names = re.split(',|_', last_names.replace(' ', ''))
instructors = []
# Don't add any instructors to an exam if the instructor last name
# contains "unknown"
if 'unknown' not in last_names[0].lower():
for last_name in last_names:
instructor = Instructor.objects.filter(last_name=last_name,
department=department)
if instructor.exists():
instructor = instructor[0]
else:
instructor = Instructor.objects.create(
last_name=last_name, department=department)
instructors.append(instructor)
# Check if a course instance exists with the exact instructors given
# and create a course instance if one doesn't exist
course_instance = CourseInstance.objects.annotate(
count=Count('instructors')).filter(count=len(instructors),
course=course,
term=term)
for instructor in instructors:
course_instance = course_instance.filter(instructors=instructor)
if course_instance.exists():
course_instance = course_instance[0]
else:
course_instance = CourseInstance.objects.create(term=term,
course=course)
course_instance.instructors.add(*instructors)
course_instance.save()
# Check for unknown exam numbers
exam_number = fields['examNumber'].lower()
if exam_number == 'unknown' or exam_number == 'mt':
exam_number = Exam.UNKNOWN
# Check manually whether an exam already exists rather than use
# get_or_create because in order to specify a primary key for an exam
# when it's created, a unique id needs to assigned at the same time as
# well
exam = Exam.objects.filter(
course_instance=course_instance,
exam_number=exam_number,
exam_type=EXAM_TYPE_CONVERSION[fields['examOrSolution']])
# Don't import exams that were already imported, or exams for the same
# course instance but different file types
if exam.exists():
continue
exam = Exam.objects.create(
pk=model['pk'],
course_instance=course_instance,
exam_number=exam_number,
exam_type=EXAM_TYPE_CONVERSION[fields['examOrSolution']],
verified=fields['approved'],
unique_id=uuid.uuid4().hex)
if fields['submitter']:
exam.submitter = user_model.objects.get(pk=fields['submitter'])
# Exams use "unknown" as the semester in filenames if the semester
# is unknown
if semester == Term.UNKNOWN:
semester = 'unknown'
# Construct the old noiro filename for the exam file
filename = ('{dept}{course_num}-{term}{year}-{number}-'
'{instructors}-{type}.{ext}').format(
dept=dept_abbreviation,
course_num=fields['courseNumber'],
term=semester,
year=fields['year'][2:],
number=fields['examNumber'],
instructors=fields['professor'],
type=exam.exam_type,
ext=fields['filetype'])
exam_location = os.path.join(NOIRO_EXAMS_LOCATION, dept_abbreviation,
filename)
with open(exam_location, 'r') as exam_file:
exam.exam_file = File(exam_file)
exam.save()
def import_exams():
# pylint: disable=R0912,R0914
models = get_json_data('examfiles.exam.json')
for model in models:
fields = model['fields']
year = int(fields['year'])
semester = fields['semester']
# Check for exams with unknown semesters
if semester == '??':
semester = Term.UNKNOWN
# Check for exams with unknown years (all stored with years less than 5)
if year < 5:
term = None
else:
term, _ = Term.objects.get_or_create(term=semester, year=year)
dept_pk, dept_abbreviation = DEPARTMENT_CONVERSION[fields['department']]
department = Department.objects.get(pk=dept_pk)
course, _ = Course.objects.get_or_create(
department=department, number=fields['courseNumber'])
# Some last names contain in parenthesis the section number or some
# other information about the course, so remove that
last_names = fields['professor']
paren_index = last_names.find('(')
if paren_index != -1:
last_names = last_names[:paren_index]
# Multiple last names may be separated by commas or underscores
last_names = re.split(',|_', last_names.replace(' ', ''))
instructors = []
# Don't add any instructors to an exam if the instructor last name
# contains "unknown"
if 'unknown' not in last_names[0].lower():
for last_name in last_names:
instructor = Instructor.objects.filter(
last_name=last_name, department=department)
if instructor.exists():
instructor = instructor[0]
else:
instructor = Instructor.objects.create(
last_name=last_name, department=department)
instructors.append(instructor)
# Check if a course instance exists with the exact instructors given
# and create a course instance if one doesn't exist
course_instance = CourseInstance.objects.annotate(
count=Count('instructors')).filter(
count=len(instructors), course=course, term=term)
for instructor in instructors:
course_instance = course_instance.filter(instructors=instructor)
if course_instance.exists():
course_instance = course_instance[0]
else:
course_instance = CourseInstance.objects.create(
term=term, course=course)
course_instance.instructors.add(*instructors)
course_instance.save()
# Check for unknown exam numbers
exam_number = fields['examNumber'].lower()
if exam_number == 'unknown' or exam_number == 'mt':
exam_number = Exam.UNKNOWN
# Check manually whether an exam already exists rather than use
# get_or_create because in order to specify a primary key for an exam
# when it's created, a unique id needs to assigned at the same time as
# well
exam = Exam.objects.filter(
course_instance=course_instance,
exam_number=exam_number,
exam_type=EXAM_TYPE_CONVERSION[fields['examOrSolution']])
# Don't import exams that were already imported, or exams for the same
# course instance but different file types
if exam.exists():
continue
exam = Exam.objects.create(
pk=model['pk'],
course_instance=course_instance,
exam_number=exam_number,
exam_type=EXAM_TYPE_CONVERSION[fields['examOrSolution']],
verified=fields['approved'],
unique_id=uuid.uuid4().hex)
if fields['submitter']:
exam.submitter = user_model.objects.get(pk=fields['submitter'])
# Exams use "unknown" as the semester in filenames if the semester
# is unknown
if semester == Term.UNKNOWN:
semester = 'unknown'
# Construct the old noiro filename for the exam file
filename = ('{dept}{course_num}-{term}{year}-{number}-'
'{instructors}-{type}.{ext}').format(
dept=dept_abbreviation,
course_num=fields['courseNumber'],
term=semester,
year=fields['year'][2:],
number=fields['examNumber'],
instructors=fields['professor'],
type=exam.exam_type,
ext=fields['filetype'])
exam_location = os.path.join(
NOIRO_EXAMS_LOCATION, dept_abbreviation, filename)
with open(exam_location, 'r') as exam_file:
exam.exam_file = File(exam_file)
exam.save()
def import_user_profiles():
# pylint: disable=E1103
models = get_json_data('user_profiles.userprofile.json')
for model in models:
fields = model['fields']
HAS_INITIATED[fields['user']] = fields['has_initiated']
user_profile, _ = UserProfile.objects.get_or_create(
pk=model['pk'],
user=user_model.objects.get(pk=fields['user']),
preferred_name=fields['preferred_name'],
middle_name=fields['middle_name'],
gender=fields['gender'],
alt_email=fields['alt_email'],
cell_phone=fields['cell_phone'],
home_phone=fields['home_phone'],
receive_text=fields['receive_text'],
local_address1=fields['local_address1'],
local_address2=fields['local_address2'],
local_city=fields['local_city'],
local_state=fields['local_state'],
local_zip=fields['local_zip'],
perm_address1=fields['perm_address1'],
perm_address2=fields['perm_address2'],
perm_city=fields['perm_city'],
perm_state=fields['perm_state'],
perm_zip=fields['perm_zip'],
international_address=fields['international_address'])
if fields['birthday']:
user_profile.birthday = parser.parse(fields['birthday']).date()
user_profile.save()
if fields['picture']:
picture_location = os.path.join(
NOIRO_MEDIA_LOCATION, fields['picture'])
with open(picture_location, 'r') as picture:
user_profile.picture = File(picture)
user_profile.save()
student_info, _ = CollegeStudentInfo.objects.get_or_create(
pk=model['pk'],
user=user_model.objects.get(pk=fields['user']))
for major_pk in fields['major']:
student_info.major.add(Major.objects.get(
pk=major_pk + MAJOR_PK_CONVERSION))
if fields['start_semester']:
student_info.start_term = Term.objects.get(
pk=SEMESTER_TO_TERM[fields['start_semester']])
if fields['grad_semester']:
student_info.grad_term = Term.objects.get(
pk=SEMESTER_TO_TERM[fields['grad_semester']])
student_info.save()
user = user_model.objects.get(pk=fields['user'])
student_profile, _ = StudentOrgUserProfile.objects.get_or_create(
pk=model['pk'], user=user, bio=fields['bio'])
if fields['initiation_semester']:
student_profile.initiation_term = Term.objects.get(
pk=SEMESTER_TO_TERM[fields['initiation_semester']])
student_profile.save()
