def create_group(request, pk=None):
if pk:
group = Group.objects.get(id=pk)
else:
group = Group()
if request.method == "POST":
group = GroupModelForm(request.POST, instance=group)
if group.is_valid():
created_group = group.save()
formset = GroupMemberFormSet(request.POST, instance=created_group)
print(formset)
if formset.is_valid():
formset.save()
print(formset.cleaned_data)
return HttpResponseRedirect(reverse('groups'))
else:
print("formset invalid")
print(formset.errors)
context = {
'group_form': group,
'formset': formset,
}
else:
print("form invalic")
formset = GroupMemberFormSet(instance=Group())
context = {
'group_form': group,
'formset': formset,
}
else:
if pk:
group = Group.objects.get(id=pk)
group_form = GroupModelForm(instance=group)
else:
group = Group()
group_form = GroupModelForm()
formset = GroupMemberFormSet(instance=group)
context = {
'group_form': group_form,
'formset': formset,
}
template = loader.get_template('groups/create_update.html')
return HttpResponse(template.render(context, request))
def groups(request):
"""
:param request:
:return:
"""
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('index'))
if not request.user.is_superuser:
return HttpResponseRedirect(reverse('index'))
error_messages = []
if request.method == 'POST':
form = groupAddForm(request.POST)
if form.is_valid():
group = form.cleaned_data
new_group = Group(name=group['name'])
new_group.save()
return HttpResponseRedirect(request.get_full_path())
else:
for msg_err in form.errors.values():
error_messages.append(msg_err.as_text())
groups = Group.objects.all().order_by('name')
groups_inst = []
for group in groups:
groups_inst.append(
(group, Instance.objects.filter(group=group).order_by('name')))
return render(request, 'groups.html', locals())
def test_membership(self):
membership = Membership()
user = User.objects.create_user('Testy McTest', '*****@*****.**',
'testpassword')
user.save()
group = Group()
group.name = "Test Group"
group.save()
membership.user = User.objects.get(id=user.id)
membership.group = Group.objects.get(id=group.id)
membership.is_admin = False
membership.save()
test_membership = Membership.objects.get(id=membership.id)
self.assertEquals(test_membership, membership)
self.assertEquals(test_membership.user, User.objects.get(id=user.id))
self.assertEquals(test_membership.group,
Group.objects.get(id=group.id))
self.assertEquals(test_membership.is_admin, False)
membership.delete()
group.delete()
user.delete()
def save(self):
if self.model is None:
self.model = Group(name='', visible=True, key='')
data = self.cleaned_data
self.model.name=data['name']
self.model.visible=data['visible']
self.model.key=data.get('key')
return self.model
def add(group_name):
try:
group = Group(name=group_name, user_id=g.auth['sub'])
db.session.add(group)
db.session.commit()
except IntegrityError as e:
raise AlreadyExistsError(group_name)
return ('', HTTPStatus.NO_CONTENT)
def setUp(self):
self.tournament = Tournament()
self.tournament.save()
self.group = Group(letter='A')
self.group.tournament_id = self.tournament.id
self.group.save()
self.team = Team(name='Brazil')
self.team.group_id = self.group.id
def setUp(self):
user_obj = User(email='*****@*****.**', is_lecture=True)
user_obj.set_password("randPassword")
user_obj.save()
group = Group()
group.save()
lecture_groups = LectureGroups(user=user_obj)
lecture_groups.groups_list.add(group)
lecture_groups.save()
def setUp(self):
user_obj = User(email='*****@*****.**')
user_obj.set_password("randPassword")
user_obj.save()
group = Group()
group.save()
student_groups = StudentGroups(user=user_obj)
student_groups.groups_list.add(group)
student_groups.save()
def test_group(self):
group = Group()
group.name = "Test Group"
group.save()
test_group = Group.objects.get(id=group.id)
self.assertEquals(test_group, group)
self.assertEquals(test_group.name, "Test Group")
self.assertEquals(test_group.date_created, group.date_created)
group.delete()
def setUp(self):
self.club = Club(name="NTNUI")
self.club.save()
self.group = Group(name="NTNUI Fotball", club=self.club)
self.group.save()
self.user = User.objects.create_superuser("testuser",
email="*****@*****.**",
password="******")
self.user.save()
self.interest = Interest(session_id="c00k13M0n5t3r", group=self.group)
self.interest.save()
self.factory = APIRequestFactory()
self.interests = Interest.objects.all()
def post(self, request):
name = request.POST.get('name')
group = Group()
group.name = name
group.start_date = start_date
group.max_students = max_students
group.save()
print(group)
return redirect('/groups/all')
def post(self, request, *args, **kwargs):
data = request.data
#create a new group given the name, description, and image
serializer = GroupSerializer(data=data)
if (serializer.is_valid(raise_exception=True)):
group_obj = Group(name=data.get('name'),
description=data.get('description'),
image=data.get('image'))
group_obj.save()
#associate the group with the owner and members through Membership
owner = request.user
if (not Membership.objects.filter(user=owner,
group=group_obj).exists()):
own_mem_obj = Membership(user=owner, group=group_obj, owner=True)
own_mem_obj.save()
members = data.get('members', '')
members = [item.strip() for item in members.strip().split(',')]
for member in members:
try:
user_obj = User.objects.get(email=member)
except User.DoesNotExists:
pass
if (not Membership.objects.filter(user=user_obj,
group=group_obj).exists()):
mem_obj = Membership(user=user_obj,
group=group_obj,
owner=False)
mem_obj.save()
#notify the group
msg_obj = BuddyMessage(user=user_obj,
group=group_obj,
message=''.join((user_obj.buddycode,
' joined the group')),
message_type=settings.MSG_TYPE_JOIN)
msg_obj.save()
#create an activity for the owner
if (not CreateGroup.objects.filter(user=owner,
group=group_obj).exists()):
activity_obj = CreateGroup(owner=owner,
group=group_obj,
longitude=owner.longitude,
latitude=owner.latitude)
activity_obj.save()
return Response({"success": True}, status=HTTP_200_OK)
def save(self, commit=True):
group = Group(name=self.cleaned_data['name'],
tagline=self.cleaned_data['tagline'],
description=self.cleaned_data['description'],
email=self.cleaned_data['email'],
website=self.cleaned_data['website'],
owner=self.owner,
location=self.cleaned_data['location'],
address=self.cleaned_data['address'],
city=self.cleaned_data['city'],
state=self.cleaned_data['state'],
zip_code=self.cleaned_data['zip_code'],
approvalNeeded=self.cleaned_data['approvalNeeded'],
private=self.cleaned_data['private'])
return group
def create(self, request, *args, **kwargs):
data = dict(request.data)
user = request.user
level = Level.safe_get(data.get('level_id'))
admin = Member.safe_get(data.get('admin_id'))
parent_group = Group.safe_get(data.get('parent_group_id'))
group = Group()
group.title = data.get('title', '')
group.level_id = level.to_dbref() if level else None
group.admin_id = admin.to_dbref() if admin else None
group.created_at = datetime.utcnow()
group.created_by = user.to_dbref() if user.id else None
group.parent_group_id = parent_group.id if parent_group else None
group.save()
response = {"id": str(group.id), "title": group.title}
return HTTPResponse(response)
def create_course_group(self, request, pk=None):
course = self.get_object()
group_name = request.data.get('name')
group = Group(name=group_name, course=course)
group.save()
for student in group.students.all():
assign_perm('groups.view_group', student.user, group)
# Assign view permission to students in group
for assistant in group.course.assistant_set.all():
assign_perm('groups.view_group', assistant.user, group)
assign_perm('groups.change_group', assistant.user, group)
assign_perm('groups.change_group', group.course.professor.user, group)
assign_perm('groups.delete_group', group.course.professor.user, group)
assign_perm('groups.view_group', group.course.professor.user, group)
return Response(GroupSerializer(group).data)
def create_group(name, email, url_root, owner):
"""
_name_ Name of group
_email_ Email address for group (?)
_url_root_ acSite
_owner_ MCID of user/doctor that controls this group
"""
u = User()
u.mcid = mcid_generator.next_mcid()
u.email = email
u.set_password(str(u.mcid))
u.first_name = name
u.last_name = 'Group'
u.rolehack = 'rls'
u.acctype = 'GROUP'
u.updatetime = 0
u.ccrlogupdatetime = 0
u.save()
g = Group()
g.grouptypeid = 0
g.name = name
g.accid_id = u.mcid
g.save()
p = Practice()
p.providergroupid = g
p.practicename = name
p.accid_id = u.mcid
p.save()
p.practiceRlsUrl = urljoin(url_root, 'acct/ws/R.php?pid=%d' % p.practiceid)
p.save()
g.parentid = p.practiceid
g.save()
ga = Groupadmin()
ga.groupinstanceid = g.groupinstanceid
ga.adminaccid = owner
ga.save()
add_to_group(g, owner)
return g, p
def setUp(self):
self.phase = Tournament.FIRST_PHASE
self.group_letter = 'A'
self.team_a_name = 'Brazil'
self.team_b_name = 'Germany'
self.tournament = Tournament(phase=self.phase)
self.tournament.save()
self.group = Group(letter=self.group_letter)
self.group.tournament_id = self.tournament.id
self.group.save()
self.team_a_goals = random.randint(0, 10)
self.team_b_goals = random.randint(0, 10)
self.team_a = Team(name=self.team_a_name)
self.team_b = Team(name=self.team_b_name)
self.team_a.group_id = self.group.id
self.team_b.group_id = self.group.id
self.team_a.save()
self.team_b.save()
def handle(self, *args, **options):
Group.objects.all().delete()
Category.objects.all().delete()
Choice.objects.all().delete()
Question.objects.all().delete()
#сбрасываем автоинкремент чтобы не ловить индекс категории
from django.db import connection
cursor = connection.cursor()
sql = 'ALTER TABLE groups_group AUTO_INCREMENT=1;'
cursor.execute(sql)
sql = 'ALTER TABLE questions_category AUTO_INCREMENT=1;'
cursor.execute(sql)
for i in range(0, self.groups_pool_length):
group = Group(name=self.groups_prefix + str(i + 1))
group.save()
print 'Таблица групп наполнена'
for i in range(0, self.categories_pool_length):
category = Category(name=self.categories_prefix + str(i + 1))
category.save()
print 'Таблица категорий наполнена'
import random
for i in range(0, self.questions_pool_length):
a = random.randint(0, 20)
b = random.randint(0, 20)
answer = a + b
question_text = '%s %s. Введите правильный ответ в выражении %s+%s' % (
self.questions_prefix, i, a, b)
question = Question(
category=Category.objects.all().order_by('?')[0],
question=question_text,
answer=str(answer))
question.save()
for j in range(3):
choice = Choice(
question=question,
choice_text=answer +
(-1)**random.randint(0, 10) * random.randint(1, 3))
choice.save()
print 'Таблицы вопросов и выборов наполнены'
def create_group(group_name, articles, num_comments, clone_and_sample):
"""
Create group from articles (sampling its comments)
"""
try:
group = Group.objects.get(name=group_name)
except DoesNotExist:
group = Group(name=group_name)
if clone_and_sample:
group.articles = [
clone_and_sample_comments(art, num_comments) for art in articles
]
else:
group.articles = articles
group.save()
return group
def addGroup(request):
if request.method == 'GET':
return HttpResponse(render(request, 'add_group.html'))
elif request.method == 'POST':
name = request.POST.get('name')
start_date = request.POST.get('startDate')
max_students = request.POST.get('maxStudents')
group = Group()
group.name = name
group.start_date = start_date
group.max_students = max_students
group.save()
return redirect('/groups/all')
def handle(self, **options):
group_id = options['group_id']
if group_id:
group_id = int(group_id)
if not group_id:
raise Exception("--group_id is required!")
group_src = Group.objects.get(id=group_id)
group_dst = Group()
group_dst.__dict__ = copy.deepcopy(group_src.__dict__)
group_dst.id = None
group_dst.name += " copy"
group_dst.save()
for student_src in group_src.students.all():
print "Copy student {0}".format(
student_src.get_full_name().encode("utf-8"))
group_dst.students.add(student_src)
def groups_edit(request, pk):
"""Edit an Group"""
try:
object = Group.objects.get(pk=pk)
except:
object = Group()
if request.method == 'POST': # If the form has been submitted...
form = GroupForm(request.POST, instance=object)
if form.is_valid(): # If the form is valid
object = form.save()
messages.success(request, 'The group has been saved.')
return redirect(reverse('groups.views.groups_list'))
else:
form = GroupForm(instance=object)
return render_to_response('groups/groups/edit.html', {'form': form},
context_instance=RequestContext(request))
def setUp(self):
lecture = User(email='*****@*****.**', first_name='John', last_name='Snow', is_student=False, is_lecture=True)
lecture2 = User(email='*****@*****.**', first_name='Harry', last_name='Potter', is_student=False, is_lecture=True)
lecture.set_password("randPassword")
lecture.save()
lecture2.save()
student = User(email='*****@*****.**', first_name='Frodo', last_name='Baggins')
student2 = User(email='*****@*****.**', first_name='Titus', last_name='Flavius')
student3 = User(email='*****@*****.**', first_name='Philip', last_name='Capet')
student.save()
student2.save()
student3.save()
group = Group(course='python', lectures_list=[Lecture(lecture=lecture)],
enrolled_list=[Enrolled(student=student,
marks_list=[Mark(value=5, max_points=10, for_what="exercise", note=""),
Mark(value=2, max_points=10, for_what="quiz", note="")]),
Enrolled(student=student2,
marks_list=[Mark(value=7, max_points=10, for_what="exercise", note=""),
Mark(value=10, max_points=10, for_what="quiz", note="")]
)])
group.save()
def group(request):
'''Creates a view of group to add a new group reading the user posted data.'''
groups = Group.objects.all()
if request.method == 'POST':
form = GroupForm(request.POST)
if form.is_valid():
group_code = form.cleaned_data['group_code']
name = form.cleaned_data['name']
description = form.cleaned_data['description']
try:
group = Group()
group.group_code = group_code
group.name = name
group.description = description
group.save()
except:
pass
return HttpResponseRedirect(reverse('index'))
else:
form = GroupForm()
return render(request, 'groups/group.html', {
'groups': groups,
'form': form
})
def setUp(self):
self.project = Project(group=Group(name='name', slug='slug'))
def groups(request):
if request.POST:
item = Group(name=request.POST['name'])
item.save()
object_list = Group.objects.all().order_by("name")
return render(request, 'groups/index.html', locals())
def create_test_offering():
"""
main test course: interesting data for grades, marking, submission, groups
"""
from grades.models import Activity, LetterActivity, CalNumericActivity, CalLetterActivity
from submission.models import SubmissionComponent
from submission.models.code import CodeComponent
from submission.models.pdf import PDFComponent
from groups.models import Group, GroupMember
from marking.models import ActivityComponent
crs = CourseOffering.objects.get(slug=TEST_COURSE_SLUG)
crs.set_labtut(True)
crs.set_url("http://www.cs.sfu.ca/CC/165/common/")
crs.set_taemail("*****@*****.**")
crs.save()
# create example activities
a1 = NumericActivity.objects.get(offering=crs, slug='a1')
a2 = NumericActivity(offering=crs,
name="Assignment 2",
short_name="A2",
status="URLS",
due_date=crs.semester.start +
datetime.timedelta(days=70),
percent=10,
group=True,
max_grade=20,
position=2)
a2.set_url("http://www.cs.sfu.ca/CC/165/common/a2")
a2.save()
pr = LetterActivity(offering=crs,
name="Project",
short_name="Proj",
status="URLS",
due_date=crs.semester.start +
datetime.timedelta(days=80),
percent=40,
group=True,
position=3)
pr.save()
re = LetterActivity(offering=crs,
name="Report",
short_name="Rep",
status="URLS",
due_date=crs.semester.start +
datetime.timedelta(days=81),
percent=10,
group=False,
position=4)
re.save()
ex = NumericActivity(offering=crs,
name="Final Exam",
short_name="Exam",
status="URLS",
due_date=None,
percent=30,
group=False,
max_grade=90,
position=5)
ex.save()
to = CalNumericActivity(offering=crs,
name="Final Percent",
short_name="Perc",
status="INVI",
due_date=None,
percent=0,
group=False,
max_grade=100,
formula="[[activitytotal]]",
position=6)
to.save()
to = CalLetterActivity(offering=crs,
name="Letter Grade",
short_name="Letter",
status="INVI",
due_date=None,
percent=0,
group=False,
numeric_activity=to,
position=6)
to.save()
# make A1 submittable and markable
s = CodeComponent(activity=a1,
title=u"Cöde File",
description="The code you're submitting.",
allowed=".py,.java")
s.save()
s = PDFComponent(activity=a1,
title="Report",
description="Report on what you did.",
specified_filename="report.pdf")
s.save()
m = ActivityComponent(
numeric_activity=a1,
max_mark=5,
title=u"Part ➀",
description="Part ➀ was done well and seems to work.",
position=1,
slug='part-1')
m.save()
m = ActivityComponent(
numeric_activity=a1,
max_mark=5,
title="Part 2",
description="Part 2 was done well and seems to work.",
position=2)
m.save()
# create some groups
members = list(Member.objects.filter(offering=crs, role='STUD'))
random.shuffle(members)
m = members.pop()
g = Group(name="SomeGroup", courseoffering=crs, manager=m)
g.save()
for m in [m, members.pop()]:
gm = GroupMember(group=g, student=m, confirmed=True, activity=a2)
gm.save()
m = members.pop()
g = Group(name="AnotherGroup", courseoffering=crs, manager=m)
g.save()
for m in [m, members.pop(), members.pop()]:
gm = GroupMember(group=g, student=m, confirmed=True, activity=a2)
gm.save()
gm = GroupMember(group=g, student=m, confirmed=True, activity=pr)
gm.save()
return itertools.chain(
Activity.objects.all(),
NumericActivity.objects.all(),
LetterActivity.objects.all(),
CalNumericActivity.objects.all(),
CalLetterActivity.objects.all(),
SubmissionComponent.objects.all(),
CodeComponent.objects.all(),
PDFComponent.objects.all(),
Group.objects.all(),
GroupMember.objects.all(),
ActivityComponent.objects.all(),
)
def submit(request, course_slug):
person = get_object_or_404(Person, userid=request.user.username)
course = get_object_or_404(CourseOffering, slug=course_slug)
member = Member.objects.exclude(role='DROP').get(person=person,
offering=course)
is_staff = is_course_staff_by_slug(request, course_slug)
span = course.group_span_activities()
error_info = None
name = request.POST.get('GroupName')
if name:
name = name[:30]
#Check if group has a unique name
if Group.objects.filter(name=name, courseoffering=course):
error_info = "A group named \"%s\" already exists" % (name)
messages.add_message(request, messages.ERROR, error_info)
return HttpResponseRedirect(
reverse('offering:groups:groupmanage',
kwargs={'course_slug': course_slug}))
#Check if the group name is empty, these two checks may need to be moved to forms later.
if name == "":
error_info = "Group name cannot be empty: please enter a group name."
messages.add_message(request, messages.ERROR, error_info)
return HttpResponseRedirect(
reverse('offering:groups:groupmanage',
kwargs={'course_slug': course_slug}))
else:
# find selected activities
selected_act = []
activities = Activity.objects.filter(offering=course,
group=True,
deleted=False)
if not is_staff:
activities = activities.exclude(status='INVI')
for activity in activities:
activityForm = ActivityForm(request.POST, prefix=activity.slug)
if activityForm.is_valid(
) and activityForm.cleaned_data['selected'] == True:
selected_act.append(activity)
# no selected activities: fail.
if not selected_act:
messages.add_message(request, messages.ERROR,
"Group not created: no activities selected.")
return HttpResponseRedirect(
reverse('offering:groups:groupmanage',
kwargs={'course_slug': course_slug}))
# check groups_span_activities restriction if it's set
if not span and not is_staff and len(selected_act) > 1:
# students cannot violate groups_span_activities restriction, but instructors can
messages.add_message(
request, messages.ERROR,
"Group not created: groups cannot last for more than one activity in this course."
)
return HttpResponseRedirect(
reverse('offering:groups:groupmanage',
kwargs={'course_slug': course_slug}))
groupForSemester = False
#validate database integrity before saving anything.
#If one student is in a group for an activity, he/she cannot be in another group for the same activity.
if is_course_student_by_slug(request, course_slug):
isStudentCreatedGroup = True
studentList = []
studentList.append(member)
elif is_course_staff_by_slug(request, course_slug):
isStudentCreatedGroup = False
studentList = []
students = Member.objects.select_related('person').filter(
offering=course, role='STUD')
for student in students:
studentForm = StudentForm(request.POST,
prefix=student.person.userid)
if studentForm.is_valid(
) and studentForm.cleaned_data['selected'] == True:
studentList.append(student)
#Check if students has already in a group
if _validateIntegrity(request, isStudentCreatedGroup, groupForSemester,
course, studentList, selected_act) == False:
return HttpResponseRedirect(
reverse('offering:groups:groupmanage',
kwargs={'course_slug': course_slug}))
#No selected members,group creating will fail.
if not studentList:
messages.add_message(request, messages.ERROR,
"Group not created: no members selected.")
return HttpResponseRedirect(
reverse('offering:groups:groupmanage',
kwargs={'course_slug': course_slug}))
group = Group(name=name,
manager=member,
courseoffering=course,
groupForSemester=groupForSemester)
group.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description="created a new group %s for %s." %
(group.name, course),
related_object=group)
l.save()
if is_course_student_by_slug(request, course_slug):
for activity in selected_act:
groupMember = GroupMember(group=group,
student=member,
confirmed=True,
activity_id=activity.id)
groupMember.save()
#LOG EVENT#
l = LogEntry(
userid=request.user.username,
description=
"automatically became a group member of %s for activity %s."
% (group.name, groupMember.activity),
related_object=groupMember)
l.save()
messages.add_message(request, messages.SUCCESS, 'Group Created')
return HttpResponseRedirect(
reverse('offering:groups:groupmanage',
kwargs={'course_slug': course_slug}))
elif is_course_staff_by_slug(request, course_slug):
students = Member.objects.select_related('person').filter(
offering=course, role='STUD')
for student in students:
studentForm = StudentForm(request.POST,
prefix=student.person.userid)
if studentForm.is_valid(
) and studentForm.cleaned_data['selected'] == True:
for activity in selected_act:
groupMember = GroupMember(group=group,
student=student,
confirmed=True,
activity_id=activity.id)
groupMember.save()
#LOG EVENT#
l = LogEntry(
userid=request.user.username,
description=
"added %s as a group member to %s for activity %s."
% (student.person.userid, group.name,
groupMember.activity),
related_object=groupMember)
l.save()
n = NewsItem(user=student.person,
author=member.person,
course=group.courseoffering,
source_app="group",
title="Added to Group",
content="You have been added the group %s." %
(group.name),
url=reverse(
'offering:groups:groupmanage',
kwargs={'course_slug': course.slug}))
n.save()
messages.add_message(request, messages.SUCCESS, 'Group Created')
return HttpResponseRedirect(
reverse('offering:groups:view_group',
kwargs={
'course_slug': course_slug,
'group_slug': group.slug
}))
else:
return HttpResponseForbidden()
def add_group(u, g):
from groups.models import Group, Affiliation
group = Affiliation(user=u, group=g)
group.save()
default = Affiliation(user=u, group=Group(pk='default'))
default.save()
def test_group_submission_view(self):
"""
test if group submission can be viewed by group member and non group member
"""
now = datetime.datetime.now()
_, course = create_offering()
a1 = NumericActivity(name="Assignment 1",
short_name="A1",
status="RLS",
offering=course,
position=2,
max_grade=15,
due_date=now,
group=True)
a1.save()
a2 = NumericActivity(name="Assignment 2",
short_name="A2",
status="RLS",
offering=course,
position=1,
max_grade=15,
due_date=now,
group=True)
a2.save()
p = Person.objects.get(userid="ggbaker")
member = Member(person=p,
offering=course,
role="INST",
career="NONS",
added_reason="UNK")
member.save()
c1 = URL.Component(activity=a1, title="URL Link", position=8)
c1.save()
c2 = Archive.Component(activity=a1,
title="Archive File",
position=1,
max_size=100000)
c2.save()
c3 = Code.Component(activity=a1,
title="Code File",
position=3,
max_size=2000,
allowed=".py")
c3.save()
userid1 = "0aaa0"
userid2 = "0aaa1"
userid3 = "0aaa2"
for u in [userid1, userid2, userid3]:
p = Person.objects.get(userid=u)
m = Member(person=p,
offering=course,
role="STUD",
credits=3,
career="UGRD",
added_reason="UNK")
m.save()
m = Member.objects.get(person__userid=userid1, offering=course)
g = Group(name="Test Group", manager=m, courseoffering=course)
g.save()
gm = GroupMember(group=g, student=m, confirmed=True, activity=a1)
gm.save()
gm = GroupMember(group=g, student=m, confirmed=True, activity=a2)
gm.save()
m = Member.objects.get(person__userid=userid2, offering=course)
gm = GroupMember(group=g, student=m, confirmed=True, activity=a1)
gm.save()
gm = GroupMember(group=g, student=m, confirmed=True, activity=a2)
gm.save()
m = Member.objects.get(person__userid=userid3, offering=course)
gm = GroupMember(group=g, student=m, confirmed=True, activity=a2)
gm.save()
client = Client()
# login as "0aaa0", member of group : test_group for assignment1 and assgnment2
client.login_user("0aaa0")
#submission page for assignment 1
url = reverse('offering:submission:show_components',
kwargs={
'course_slug': course.slug,
'activity_slug': a1.slug
})
response = basic_page_tests(self, client, url)
self.assertContains(
response,
"This is a group activity. You will submit on behalf of the group “Test Group”."
)
self.assertContains(
response, "You haven't made a submission for this component.")
