def test_update_existing_data(self):
fixture = json_serializer.Serializer().serialize([
self.organization,
self.seat_type_verified,
self.program_type_masters,
self.program,
self.curriculum,
self.course,
self.course_run,
self.curriculum_course_membership,
])
self._mock_fixture_response(fixture)
self._call_load_program_fixture([str(self.program.uuid)])
self.program.title = 'program-title-modified'
self.course.title = 'course-title-modified'
new_course = CourseFactory(partner=self.partner,
authoring_organizations=[self.organization])
new_course_run = CourseRunFactory(course=new_course)
new_course_membership = CurriculumCourseMembershipFactory(
course=new_course, curriculum=self.curriculum)
fixture = json_serializer.Serializer().serialize([
self.organization,
self.seat_type_verified,
self.program_type_masters,
self.program,
self.curriculum,
self.course,
self.course_run,
self.curriculum_course_membership,
new_course_membership,
new_course,
new_course_run,
])
responses.reset()
self._mock_oauth_request()
self._mock_fixture_response(fixture)
self.reset_db_state()
self._call_load_program_fixture([str(self.program.uuid)])
stored_program = Program.objects.get(uuid=self.program.uuid)
self.assertEqual(stored_program.title, 'program-title-modified')
stored_program_courses = stored_program.curricula.first(
).course_curriculum.all()
modified_existing_course = stored_program_courses.get(
uuid=self.course.uuid)
stored_new_course = stored_program_courses.get(uuid=new_course.uuid)
self.assertEqual(len(stored_program_courses), 2)
self.assertEqual(modified_existing_course.title,
'course-title-modified')
self.assertEqual(stored_new_course.key, new_course.key)
def test_update_existing_program_type(self):
fixture = json_serializer.Serializer().serialize([
self.organization,
self.seat_type_verified,
self.program_type_masters,
self.program,
])
self._mock_fixture_response(fixture)
self.reset_db_state()
# set DB to have a conflicting program type on load
seat_type = SeatTypeFactory(
name='Something',
slug='something',
)
existing_program_type = ProgramTypeFactory(
name='Masters', slug='masters', applicable_seat_types=[seat_type])
self._call_load_program_fixture([str(self.program.uuid)])
stored_program = Program.objects.get(uuid=self.program.uuid)
# assert existing DB value is used
stored_program_type = stored_program.type
self.assertEqual(stored_program_type, existing_program_type)
# assert existing DB value is updated to match fixture
stored_seat_types = list(
stored_program_type.applicable_seat_types.all())
self.assertEqual(len(stored_seat_types), 1)
self.assertEqual(stored_seat_types[0].name,
self.seat_type_verified.name)
def test_existing_seat_types(self):
fixture = json_serializer.Serializer().serialize([
self.organization,
self.seat_type_verified,
self.program_type_masters,
self.program,
])
self._mock_fixture_response(fixture)
self.reset_db_state()
# create existing verified seat with different pk than fixture and
# a second seat type with the same pk but different values
new_pk = self.seat_type_verified.id + 1
SeatType.objects.create(id=new_pk, name='Verified', slug='verified')
SeatType.objects.create(id=self.seat_type_verified.id,
name='Test',
slug='test')
self._call_load_program_fixture([str(self.program.uuid)])
stored_program = Program.objects.get(uuid=self.program.uuid)
stored_seat_type = stored_program.type.applicable_seat_types.first()
self.assertEqual(stored_seat_type.id, new_pk)
self.assertEqual(stored_seat_type.name, self.seat_type_verified.name)
def get(self, request):
uuids_string = self.request.GET.get(self.QUERY_PARAM)
if not uuids_string:
return HttpResponse(self.HELP_STRING, status=404)
uuids_split = uuids_string.split(',')
try:
uuids = {UUID(uuid_str) for uuid_str in uuids_split}
except ValueError:
return HttpResponse(self.HELP_STRING, status=404)
if len(uuids) > self.MAX_REQUESTED_PROGRAMS:
return HttpResponse(
'Too many programs requested, only {} allowed.'.format(
self.MAX_REQUESTED_PROGRAMS),
status=422,
)
programs = use_read_replica_if_available(
Program.objects.filter(uuid__in=list(uuids)))
loaded_uuids = {program.uuid for program in programs}
bad_uuids = uuids - loaded_uuids
if bad_uuids:
return HttpResponse(
"Could not load programs from UUIDs: [{}]".format(",".join(
str(uuid) for uuid in bad_uuids)),
status=404,
)
objects = load_program_fixture(programs)
json_text = json.Serializer().serialize(objects)
return HttpResponse(json_text, content_type='text/json')
def test_remapping_courserun_programtype(self):
"""
Tests whether the remapping of program types works for the course run field that points to them
"""
self.course_run.expected_program_type = self.program_type_masters
self.course_run.save()
fixture = json_serializer.Serializer().serialize([
self.program_type_masters,
self.program_type_mm,
self.organization,
self.seat_type_verified,
self.program,
self.program_mm,
self.curriculum_program_membership,
self.curriculum_course_membership,
self.curriculum,
self.course,
self.course_mm,
self.course_run,
])
self._mock_fixture_response(fixture)
self.reset_db_state()
existing_program_type = self._set_up_masters_program_type()
self._call_load_program_fixture([str(self.program.uuid)])
stored_courserun = CourseRun.objects.get(key=self.course_run.key)
stored_program_type = stored_courserun.expected_program_type
self.assertEqual(existing_program_type, stored_program_type)
def test_update_existing_program_type(self):
fixture = json_serializer.Serializer().serialize([
self.organization,
self.seat_type_verified,
self.program_type_masters,
self.program,
])
self._mock_fixture_response(fixture)
self.reset_db_state()
existing_program_type = self._set_up_masters_program_type()
self._call_load_program_fixture([str(self.program.uuid)])
stored_program = Program.objects.get(uuid=self.program.uuid)
# assert existing DB value is used
stored_program_type = stored_program.type
self.assertEqual(stored_program_type, existing_program_type)
# assert existing DB value is updated to match fixture
stored_seat_types = list(
stored_program_type.applicable_seat_types.all())
self.assertEqual(len(stored_seat_types), 1)
self.assertEqual(stored_seat_types[0].name,
self.seat_type_verified.name)
def test_load_programs(self):
fixture = json_serializer.Serializer().serialize([
self.program_type_masters,
self.program_type_masters_translation,
self.program_type_mm,
self.program_type_mm_translation,
self.organization,
self.seat_type_verified,
self.program,
self.program_2,
self.program_mm,
self.curriculum_program_membership,
self.curriculum_course_membership,
self.curriculum,
self.course,
self.course_mm,
self.course_run,
self.course_run_mm,
])
self._mock_fixture_response(fixture)
requested_programs = [
str(self.program.uuid),
str(self.program_2.uuid),
]
self.reset_db_state()
self._call_load_program_fixture(requested_programs)
# walk through program structure to validate correct
# objects have been created
stored_program = Program.objects.get(uuid=self.program.uuid)
stored_program_2 = Program.objects.get(uuid=self.program_2.uuid)
assert stored_program.title == self.program.title
assert stored_program_2.title == self.program_2.title
stored_organization = stored_program.authoring_organizations.first()
assert stored_organization.name == self.organization.name
# partner should use existing edx value
assert stored_program.partner == self.default_partner
assert stored_organization.partner == self.default_partner
stored_program_type = stored_program.type
assert stored_program_type.name_t == self.program_type_masters.name
stored_seat_type = stored_program_type.applicable_seat_types.first()
assert stored_seat_type.name == self.seat_type_verified.name
stored_curriculum = stored_program.curricula.first()
assert stored_curriculum.uuid == self.curriculum.uuid
stored_course = stored_curriculum.course_curriculum.first()
assert stored_course.key == self.course.key
stored_mm = stored_curriculum.program_curriculum.first()
assert stored_mm.uuid == self.program_mm.uuid
stored_course_run = stored_course.course_runs.first()
assert stored_course_run.key == self.course_run.key
def get(self, request, cat):
# data = self.request.data
token = request.META.get('HTTP_AUTHORIZATION')
print(token)
if not token:
return HttpResponse({"Unauthorized": "Unauthorized"}, status="401")
elif token:
try:
tole = jwt.decode(token, "SECRET_KEY")
print(tole['email'], 'hijuhuyu')
email = tole['email']
if Buyer.objects.get(email=email):
print(cat)
if cat == 'food':
category = 100
if cat == 'clothes':
category = 200
if cat == 'babyproducts':
print(cat)
category = 400
if cat == 'accessories':
category = 300
obj = Item.objects.filter(category=category)
json_serializer = json.Serializer()
json_serialized = json_serializer.serialize(obj)
data = JSON.loads(json_serialized)
# print(json_serialized)
return Response(data)
except jwt.DecodeError:
return HttpResponse({"Unauthorized": "Unauthorized"},
status="401")
def export_int_conns(request):
scheme = request.GET.get('scheme', 'xml')
schemes = ['xml', 'json']
if scheme not in schemes:
scheme = 'xml'
connections = models.InternetConnection.objects.all()
ser = xml_serializer.Serializer()
if scheme == 'json':
ser = json_serializer.Serializer()
data = ser.serialize(connections)
return HttpResponse(data, content_type='application/' + scheme)
def test_ignore_program_external_key(self):
fixture = json_serializer.Serializer().serialize([
self.organization,
self.seat_type_verified,
self.program_type_masters,
self.program,
])
self._mock_fixture_response(fixture)
self.reset_db_state()
self._call_load_program_fixture([
'{uuid}:{external_key}'.format(uuid=str(self.program.uuid),
external_key='CS-104-FALL-2019')
])
Program.objects.get(uuid=self.program.uuid)
def export_library_users(request):
if not _is_auth(request):
return HttpResponse('Need auth', status=401)
scheme = request.GET.get('scheme', 'xml')
schemes = ['xml', 'json']
if scheme not in schemes:
scheme = 'xml'
objects = models.UserLibrary.objects.all()
ser = xml_serializer.Serializer()
if scheme == 'json':
ser = json_serializer.Serializer()
data = ser.serialize(objects)
return HttpResponse(data, content_type='application/' + scheme)
def test_fail_on_constraint_error(self):
# duplicate programs should successfully save but fail final constraint check
fixture = json_serializer.Serializer().serialize([
self.program,
self.program,
self.seat_type_verified,
self.program_type_masters,
])
self._mock_fixture_response(fixture)
self.reset_db_state()
with pytest.raises(IntegrityError) as err:
self._call_load_program_fixture([str(self.program.uuid)])
expected_msg = (
r'Checking database constraints failed trying to load fixtures. Unable to save program\(s\):'
).format(pk=self.organization.id)
assert re.match(expected_msg, str(err.value))
def test_fail_on_save_error(self):
fixture = json_serializer.Serializer().serialize([
self.organization,
])
# Should not be able to save an organization without uuid
fixture_json = json.loads(fixture)
fixture_json[0]['fields']['uuid'] = None
fixture = json.dumps(fixture_json)
self._mock_fixture_response(fixture)
self.reset_db_state()
with pytest.raises(IntegrityError) as err:
self._call_load_program_fixture([str(self.program.uuid)])
expected_msg = fr'Failed to save course_metadata.Organization\(pk={self.organization.id}\):'
assert re.match(expected_msg, str(err.value))
def my_page(request):
me = request.user
friends = me.friend_set.all().filter(accepted=True)
# me = get_object_or_404(User, id=pk) #me = 접속한 user
# friends = me.self_set.all() #me의 friend들
friends_enrollment = {}
motivation_from_friends = me.motivation_friend_set.all()
for friend in friends:
friends_enrollment[friend.me.id] = EnrollmentDate.objects.all().filter(enrollment__player=friend.me, date_result=True).count()
today = date.today() #오늘 날짜에 맞는 챌린지만 가져오게 하기
enrollmentdates = EnrollmentDate.objects.all().filter(
enrollment__player=me, date__year=today.year, date__month=today.month, date__day=today.day)
challenge_success = EnrollmentDate.objects.all().filter(
enrollment__player=me, date_result=True)#.order_by('-pk')
challenge_success_title = {}
for ch in challenge_success:
challenge_success_title[ch.enrollment.pk] = ch.enrollment.challenge.title
challenge_success_serializer = json.Serializer()
challenge_success_serialized = challenge_success_serializer.serialize(
challenge_success)
ctx = {
'me': me,
'friends': friends,
'enrollmentdates': enrollmentdates,
'friends_enrollment': friends_enrollment,
'motivation_from_friends': motivation_from_friends,
'challenge_success' : JSON.dumps(challenge_success_serialized),
'challenge_success_title' : JSON.dumps(challenge_success_title),
}
print(ctx)
return render(request, "login/mypage.html", ctx)
