def confirm_group(request):
if request.user.is_authenticated():
if is_firewallz_admin(request.user):
pass
else:
logout(request)
return HttpResponseRedirect('/regsoft/')
else:
return HttpResponseRedirect('/regsoft/')
grp = Group()
grp.group_code = group_code_generator()
grp.save()
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
print(data)
for dt in data['data']:
print(dt['pk'])
Player = Regplayer.objects.get(pk=dt['pk'])
print(Player.name.name)
Player.entered = True
Player.unbilled_amt = 1100 - int(Player.name.pcramt)
Player.name.grp_leader = dt['groupleader']
Player.save()
pl = Enteredplayer()
pl.regplayer = Player
pl.group = grp
pl.save()
if dt['groupleader'] == 1:
grp.group_leader = int(dt['pk'])
grp.save()
data = {"groupcode": grp.group_code, "pk": grp.pk}
return HttpResponse(json.dumps(data), content_type='application/json')
def create_new_group(request, listing_id):
try:
listing = Listing.objects.get(pk=listing_id)
except Listing.DoesNotExist:
viewlog.error(
"{request.path}: Listing with PK {listing_id} does not exist")
return Response({'error': "Listing not found"},
status=status.HTTP_404_NOT_FOUND)
if listing.group is not None:
viewlog.error("{request.path}: Listing already in a Group")
return Response({'error': "Listing is already in a group"},
status=status.HTTP_400_BAD_REQUEST)
if listing.lister != request.user:
viewlog.error(
"{request.path}: Only lister of a listing can create a group for listing"
)
return Response(
{'error': "Only lister can create a group for a listing"},
status=status.HTTP_400_BAD_REQUEST)
group = Group()
group.start = listing.start
group.end = listing.end
group.to_location = listing.to_location
group.from_location = listing.from_location
group.save()
group.members.add(listing)
group.save()
return Response(group.to_dict(), status=status.HTTP_201_CREATED)
def _create_unique_key(team: Group):
team_id_changed = team.pk % 1000 + 1000
owner_id_changed = team.owner.pk % 1000 + 1000
date_now = datetime.today()
date_changed_str = '{}{}{}{}{}{}{}'.format(date_now.day, date_now.month,
date_now.year, date_now.hour,
date_now.minute,
date_now.second,
date_now.microsecond)
key = '{}{}{}'.format(team_id_changed, owner_id_changed, date_changed_str)
team.key = key
team.save()
def create_team(request):
if auth.get_user(request).is_anonymous:
return redirect('/')
profile = get_user_profile(request)
if profile.company is None:
return render(request, 'main/errors/global_error.html',
{'global_error': "403"})
new_group = Group()
new_group.owner = profile
new_group.name = 'Новая команда'
new_group.description = 'Измените описание в настройках'
new_group.company = profile.company
new_group.save()
_create_unique_key(new_group)
profile.groups.add(new_group)
return redirect('/team/{}/'.format(new_group.pk))
def create_group(self, week, group): group = Group(week=week, group=group) group.save() for player_id in [1,2,3,4]: group.players.add(Player.objects.get(id=player_id)) return group
def create_new_groups(*args, **kwargs):
"""Puts records into new groups if they do not have one yet and can meld with one another.
Each record will have only one group (person) or none if it's alone.
Predicate methods must contain one or more method names from GroupRecord class.
Predicate methods must be defined and maintained in GroupRecord model.
Call with "satisfies_new_group_condition" to form new groups.
"""
def key_function(gr):
"""For sorting by birth date"""
if gr.birth_date is None:
return date.today()
else:
return gr.birth_date
predicate_methods = kwargs.pop(
'predicate_methods',
['satisfies_new_group_condition', 'not_forbidden'])
if len(predicate_methods) == 0:
raise AttributeError(
"Predicate methods must contain at least one method")
print("Starting creation of new groups")
print("Extracting records")
key = key_function
unresolved_records = list(GroupRecord.objects.filter(group__isnull=True))
unresolved_records.sort(key=key)
record_groups = []
print("Sorting")
for k, g in groupby(unresolved_records, key=key):
record_groups.append(list(g))
records_to_update = []
groups_to_update = []
print("Iterating through groups")
cntr = 0
total = len(record_groups)
for same_date_group in record_groups:
cntr += 1
if cntr % 100 == 0:
print("{} of {} date groups handled".format(cntr, total))
new_groups = []
for record_pair in combinations(same_date_group, 2):
a = record_pair[0]
b = record_pair[1]
if a.check_predicates(predicate_methods=predicate_methods,
another_record=b,
**kwargs):
a_in_group = False
b_in_group = False
new_group = None
if a.group is not None and a.group in new_groups:
a_in_group = True
new_group = a.group
if b.group is not None and b.group in new_groups:
b_in_group = True
new_group = b.group
if new_group is None:
new_group = Group()
new_groups.append(new_group)
new_group.save()
if not a_in_group:
a.group = new_group
records_to_update.append(a)
if not b_in_group:
b.group = new_group
records_to_update.append(b)
groups_to_update.extend(new_groups)
for group in new_groups:
for record in same_date_group:
if record.group == group and record.birth_date is not None:
group.birth_date = record.birth_date
bulk_update(new_groups, update_fields=['birth_date'])
print("Have {0} records to save".format(len(records_to_update)))
bulk_update(records_to_update, update_fields=['group'])
print("Have {0} groups to update inconsistency".format(
len(groups_to_update)))
mark_inconsistency(groups_to_update)
print("Creation of new groups: done")
def initialize_data(self, data): group = Group(week=data['week'], group=data['group']) group.save() for player in data['players']: group.players.add(Player.objects.get(id=player['id']))
def initialize_data(self, data):
group = Group(week=data['week'], group=data['group'])
group.save()
for player in data['players']:
group.players.add(Player.objects.get(id=player['id']))
"11-807", "11-811", "11-809", "11-801", "11-807", "11-809", "11-810",
"11-807", "11-805", "11-806", "11-806", "11-804", "11-804", "11-802",
"11-807", "11-801", "11-805", "11-807", "11-801", "11-810", "11-801",
"11-803", "11-804", "11-804", "11-807", "11-807", "11-804", "11-801",
"11-801", "11-803"
]
ress = [
"не использую", "stepik", "youtube", "матпрофи", "гуглю", "javarush",
"acmp"
]
maxSem = 6
print("started generating groups (группы)")
for gr in groups:
g = Group(name=gr)
g.save()
print("groups generated")
print("started generating subjects")
for sb in subjects:
s = Subject(name=sb)
s.save()
print("subjects generated")
print("started generating res")
for re in ress:
r = AdditionalEduResource(name=re, url="somesite.com")
r.save()
i = 0
print("res generated")
print("started generating users")
while i < len(surnames):
user = User.objects.create_user(username=surnames[i] + str(i),
def create_group(self, week, group):
group = Group(week=week, group=group)
group.save()
for player_id in [1, 2, 3, 4]:
group.players.add(Player.objects.get(id=player_id))
return group
def create_group(name='group_name_test'):
group = Group(**locals())
group.save()
return group
