def next(self):
from django.utils.timezone import utc
for s in self.handle:
# TODO !
#per summary gestire:
# "lon": s.key("lon").enqi(),
# "lat": s.key("lat").enqi(),
# "date": [s["datemin"].isoformat(), s["datemax"].isoformat()],
jsonline=json.dumps({
"ident": s.get("ident"),
"lon": s.key("lon").enqi(),
"lat": s.key("lat").enqi(),
"network": s["rep_memo"],
"date": list(utc.localize(d) for d in s.date_extremes())
if self.summary else utc.localize(s["date"]),
"data": [{
"vars": {
s["var"]: {
"v": s[s["var"]]
}
},
"timerange": s["trange"],
"level": s["level"],
}]
},default=json_serial)+"\n"
yield jsonline
def test_PIZ14_tie(self):
rulecard = RuleCard.objects.get(ref_name = 'PIZ14')
player1, scoresheet1 = _prepare_scoresheet_and_returns_tuple(self.game, "p1", olives = 3)
player2, scoresheet2 = _prepare_scoresheet_and_returns_tuple(self.game, "p2", pepperoni = 2)
player3, scoresheet3 = _prepare_scoresheet_and_returns_tuple(self.game, "p3", mushrooms = 2)
player4, scoresheet4 = _prepare_scoresheet_and_returns_tuple(self.game, "p4", artichoke = 2)
rih1, rih2 = mommy.make(RuleInHand, game = self.game, player = player1, _quantity = 2)
rih3, rih4 = mommy.make(RuleInHand, game = self.game, player = player2, _quantity = 2)
rih5 = mommy.make(RuleInHand, game = self.game, player = player3)
rih6 = mommy.make(RuleInHand, game = self.game, player = player4)
mommy.make(Trade, game = self.game, initiator = player1, responder = player2, status = 'ACCEPTED', # 4 cards for p1 & p2
initiator_offer = _prepare_offer(self.game, player1, [rih1, rih2], {'pepperoni': 1}),
responder_offer = _prepare_offer(self.game, player2, [rih3, rih4], {'olives': 3}),
closing_date = utc.localize(datetime.datetime(2013, 11, 1, 13, 00, 0)))
mommy.make(Trade, game = self.game, initiator = player3, responder = player4, status = 'ACCEPTED', # 2 cards for p3 & p4
initiator_offer = _prepare_offer(self.game, player3, [rih5]),
responder_offer = _prepare_offer(self.game, player4, [rih6]),
closing_date = utc.localize(datetime.datetime(2013, 11, 2, 13, 00, 0)))
rulecard.perform([scoresheet1, scoresheet2, scoresheet3, scoresheet4])
self.assertEqual(3*2 + 10, scoresheet1.total_score)
assertRuleApplied(scoresheet1, rulecard, 'Your trades have included the largest number of exchanged rule cards in the game (4 cards, tied with p2). You earn a bonus of 10 point.',
score = 10)
self.assertEqual(2*3 + 10, scoresheet2.total_score)
assertRuleApplied(scoresheet2, rulecard, 'Your trades have included the largest number of exchanged rule cards in the game (4 cards, tied with p1). You earn a bonus of 10 point.',
score = 10)
self.assertEqual(2*2, scoresheet3.total_score)
assertRuleNotApplied(scoresheet3, rulecard)
self.assertEqual(2*2, scoresheet4.total_score)
assertRuleNotApplied(scoresheet4, rulecard)
def test_messages(self):
user = User()
user.save()
thread = Thread(title="test", author=user)
thread.save()
first_message = Message(author=user,
thread=thread,
content="hello",
created_date=utc.localize(datetime.now()),
modified_date=utc.localize(datetime.now()))
first_message.save()
second_message = Message(author=user,
thread=thread,
content="hello as well",
created_date=utc.localize(datetime.now()),
modified_date=utc.localize(datetime.now()))
second_message.save()
messages = thread.messages()
self.assertEquals(messages[0].id, first_message.id)
self.assertEquals(messages[1].id, second_message.id)
def test_all_rules_pizzaz_together(self):
for rule in RuleCard.objects.filter(ruleset__id = 3):
self.game.rules.add(rule)
gp1 = _prepare_hand(self.game, "p1", peppers = 2, chicken = 2, eggplant = 1, gorgonzola = 1) # PIZ08, PIZ10, PIZ16x2, PIZ20
gp2 = _prepare_hand(self.game, "p2", ham = 4, garlic = 1, mushrooms = 1) # PIZ04, PIZ08, PIZ09, PIZ10, PIZ12, PIZ18
gp3 = _prepare_hand(self.game, "p3", capers = 3, mushrooms = 3, sausage = 3, bacon = 1) # PIZ04, PIZ07, PIZ10x3, PIZ17
gp4 = _prepare_hand(self.game, "p4", bacon = 3, oregano = 1, gorgonzola = 2, artichoke = 1, prosciutto = 3, tomato = 2) # PIZ06, PIZ10x4, PIZ16x2, PIZ17, PIZ18
gp5 = _prepare_hand(self.game, "p5", anchovies = 1, artichoke = 1, arugula = 1, olives = 1, onions = 1, oregano = 2) # PIZ04, PIZ07, PIZ10, PIZ11x2, PIZ16x3, PIZ18, PIZ19
gp6 = _prepare_hand(self.game, "p6", mussels = 2, parmesan = 1, olives = 1) # PIZ10, PIZ12, PIZ20
rih1 = mommy.make(RuleInHand, game = self.game, player = gp3.player)
rih2 = mommy.make(RuleInHand, game = self.game, player = gp5.player)
mommy.make(Trade, game = self.game, initiator = gp2.player, responder = gp6.player, status = 'ACCEPTED', # PIZ13 to p2 and p6
initiator_offer = _prepare_offer(self.game, gp2.player, [], {'mussels': 2, 'parmesan': 1}),
responder_offer = _prepare_offer(self.game, gp6.player, [], {'ham': 4, 'garlic': 1}),
closing_date = utc.localize(datetime.datetime(2013, 11, 1, 13, 00, 0)))
mommy.make(Trade, game = self.game, initiator = gp3.player, responder = gp5.player, status = 'ACCEPTED', # PIZ14 to p3 and p5
initiator_offer = _prepare_offer(self.game, gp2.player, [rih1]),
responder_offer = _prepare_offer(self.game, gp6.player, [rih2]),
closing_date = utc.localize(datetime.datetime(2013, 11, 1, 13, 00, 0)))
# + everyone loses 20 points with PIZ15
scoresheets = tally_scores(self.game)
self.assertEqual(6, len(scoresheets))
self.assertEqual(0 + 2*6 + 2 + 3*2 + 4 + 6 - 20, scoresheets[0].total_score)
self.assertEqual(4*3 + 0 + 2 + 6 + 4 + 12 + 2 + 10 - 20, scoresheets[1].total_score)
self.assertEqual(3*2 + 3*2 + 3*5 + 3 + 6 + 12 + 3*4 + 10 - 20, scoresheets[2].total_score)
self.assertEqual(3*3 + 0 + 2*6 + 4 + 3*3 + 2*4 - 2*8 + 4*4 + 2*2 - 20, scoresheets[3].total_score)
self.assertEqual(3 + 4 + 4 + 2 + 4 + 0 + 6 + 12 + 4 + 2*8 + 4*2 + 10 + 10 - 20, scoresheets[4].total_score)
self.assertEqual(2*3 + 3 + 2 + 4 + 12 + 6 + 10 - 20, scoresheets[5].total_score)
def test_PIZ13_tie_but_same_players(self):
# if the tie is between trades involving the same two players, the bonus is still awarded
rulecard = RuleCard.objects.get(ref_name = 'PIZ13')
player1, scoresheet1 = _prepare_scoresheet_and_returns_tuple(self.game, "p1", olives = 3, mozzarella = 2)
player2, scoresheet2 = _prepare_scoresheet_and_returns_tuple(self.game, "p2", pepperoni = 2, pineapple = 1, ham = 1)
mommy.make(Trade, game = self.game, initiator = player2, responder = player1, status = 'ACCEPTED', # 8 cards too
initiator_offer = _prepare_offer(self.game, player2, [], {'mushrooms': 2, 'mozzarella': 2}),
responder_offer = _prepare_offer(self.game, player1, [], {'pepperoni': 2, 'pineapple': 2}),
closing_date = utc.localize(datetime.datetime(2013, 11, 21, 12, 12, 0)))
mommy.make(Trade, game = self.game, initiator = player1, responder = player2, status = 'ACCEPTED', # 8 cards
initiator_offer = _prepare_offer(self.game, player1, [], {'mushrooms': 2, 'ham': 1}),
responder_offer = _prepare_offer(self.game, player2, [], {'olives': 3, 'mozzarella': 2}),
closing_date = utc.localize(datetime.datetime(2013, 11, 18, 15, 35, 0)))
rulecard.perform([scoresheet1, scoresheet2])
# the score detail text should show the datetime of the first trade in chronological order of its closing_date (accepted date)
self.assertEqual(3*2 + 2*3 + 10, scoresheet1.total_score)
assertRuleApplied(scoresheet1, rulecard, 'Your trade with p2 (accepted on 2013/11/18 03:35 PM) included 8 cards. ' +
'It is the largest number of cards exchanged in a trade. You both earn a bonus of 10 points.',
score = 10)
self.assertEqual(2*3 + 2 + 3 + 10, scoresheet2.total_score)
assertRuleApplied(scoresheet2, rulecard, 'Your trade with p1 (accepted on 2013/11/18 03:35 PM) included 8 cards. ' +
'It is the largest number of cards exchanged in a trade. You both earn a bonus of 10 points.',
score = 10)
def test_replies(self):
user = User()
user.save()
thread = Thread(title="test", author=user)
thread.save()
first_message = Message(author=user,
thread=thread,
content="hello",
created_date=utc.localize(datetime.now()),
modified_date=utc.localize(datetime.now()))
first_message.save()
second_message = Message(author=user,
thread=thread,
content="hello as well",
parent_message=first_message,
created_date=utc.localize(datetime.now()),
modified_date=utc.localize(datetime.now()))
second_message.save()
messages = thread.messages()
self.assertEquals(messages[0], first_message)
replies = first_message.replies()
self.assertEquals(replies[0], second_message)
replies_with_self = first_message.replies(include_self=True)
self.assertEquals(replies_with_self[0], first_message)
self.assertEquals(replies_with_self[1], second_message)
def post_create_thread(request):
errors = []
params = deepValidateAndFetch(request, errors)
if len(errors) == 0:
with transaction.atomic():
thread = Thread(title=params['title'],
author=params['author'],
section_id=params['section'])
if params['visibility'] == 'private':
thread.recipient = params['recipient']
if params['visibility'] == 'class':
thread.lesson = params['lesson']
if params['visibility'] == 'public':
thread.professor = params['professor']
thread.save()
if params['skills_fetched']:
thread.skills = params['fetched_skills']
thread.save()
sendNotification(getWSNotificationForNewThread(thread))
original_message = Message(
content=params['content'],
thread=thread,
author=params['author'],
created_date=utc.localize(datetime.now()),
modified_date=utc.localize(datetime.now()))
original_message.save()
sendNotification(getNotificationForNewMessage(original_message))
return redirect(thread)
else:
skills, sections = get_skills(request)
params['skills'] = skills
params['sections'] = sections
if params['skills_fetched']:
params['selected_skills'] = map(lambda x: x.id,
params['fetched_skills'])
else:
params['selected_skills'] = []
if params['section'] is not None:
params['selected_section'] = int(params['section'])
return render(request, "forum/new_thread.haml", {
"errors": errors,
"data": params
})
def get_last_visit(user, thread):
if LastThreadVisit.objects.filter(user=user, thread=thread).exists():
last_visit = LastThreadVisit.objects.get(user=user, thread=thread)
date = last_visit.last_visit
last_visit.last_visit = utc.localize(datetime.now())
else:
last_visit = LastThreadVisit(user=user,
thread=thread,
last_visit=utc.localize(datetime.now()))
date = utc.localize(datetime.min)
last_visit.save()
return date
def save(self, *args, **kwargs):
bounds = self.get_bounds()
if bounds:
self._start_datetime = utc.localize(
datetime.datetime.fromtimestamp(bounds['start_timestamp']))
self._finish_datetime = utc.localize(
datetime.datetime.fromtimestamp(bounds['finish_timestamp']))
self._north = bounds['north']
self._south = bounds['south']
self._west = bounds['west']
self._east = bounds['east']
self._count = len(self.data)
super(Route, self).save(*args, **kwargs)
def create_call_long_name(long_name, short_name, funding_instrument=None):
if funding_instrument is None:
funding_instrument = create_funding_instrument()
call, created = Call.objects.get_or_create(long_name=long_name,
short_name=short_name,
call_open_date=utc.localize(datetime(2019, 1, 1)),
submission_deadline=utc.localize(datetime(2025, 1, 31)),
finance_year=2020,
budget_maximum=100_000, other_funding_question=False,
proposal_partner_question=True,
funding_instrument=funding_instrument)
return call
def clean(self):
cleaned_data = super().clean()
errors = {}
if 'overall_budget' in cleaned_data and cleaned_data[
'overall_budget'] is not None:
if cleaned_data['overall_budget'] < 0:
errors['overall_budget'] = 'Budget needs to be greater than 0'
elif cleaned_data['overall_budget'] > self._call.budget_maximum:
errors['overall_budget'] = f'Budget is greater than the maximum budget for this call: ' \
f'{thousands_separator(self._call.budget_maximum)} CHF'
if self._call.keywords_in_general_information_question:
keywords_validation(errors, cleaned_data, 'keywords')
if self._raise_duplicated_title:
errors['title'] = forms.ValidationError(
mark_safe(
'A proposal already exists with the same title and applicant for this call. '
'Rather than starting from scratch again please use the link with which you were provided to '
'edit your application. Otherwise please contact SPI '
'<a href="mailto:[email protected]">[email protected]</a> to receive a reminder of'
' the link.'))
# Converts date to datetime objects to compare with the end of the call.
# The combine and datetime.datetime.min.time() makes it the beginning of the day
proposal_start_date = datetime.datetime.combine(
cleaned_data['start_date'], datetime.datetime.min.time())
proposal_end_date = datetime.datetime.combine(
cleaned_data['end_date'], datetime.datetime.min.time())
proposal_start_date = utc.localize(proposal_start_date)
proposal_end_date = utc.localize(proposal_end_date)
call_submission_deadline = self._call.submission_deadline
if proposal_end_date < proposal_start_date:
errors['start_date'] = forms.ValidationError(
'Proposal start date needs to be before end date')
if proposal_end_date < call_submission_deadline:
errors['end_date'] = forms.ValidationError(
'Proposal end date needs to be after call submission deadline')
if errors:
raise forms.ValidationError(errors)
return cleaned_data
def save(self, *args, **kwargs):
bounds = self.get_bounds()
if bounds:
self._start_datetime = utc.localize(
datetime.datetime.fromtimestamp(bounds['start_timestamp'])
)
self._finish_datetime = utc.localize(
datetime.datetime.fromtimestamp(bounds['finish_timestamp'])
)
self._north = bounds['north']
self._south = bounds['south']
self._west = bounds['west']
self._east = bounds['east']
self._count = len(self.data)
super(Route, self).save(*args, **kwargs)
def edit_message(request, id, message_id):
thread = get_object_or_404(Thread, pk=id)
message = get_object_or_404(Message, pk=message_id)
if not can_update(thread, message, request.user):
return HttpResponse(status=403,
content="Permissions missing to edit this message")
file = request.FILES.get('file')
content = request.POST.get("content")
if content is None or len(content) == 0:
return HttpResponse(status=400, content="Missing content")
if file is not None:
for attach in MessageAttachment.objects.filter(message_id=message_id):
os.remove(attach.file.path)
attach.delete()
name = os.path.split(file.name)[1]
MessageAttachment.objects.create(name=name, file=file, message=message)
message.modified_date = utc.localize(datetime.now())
message.content = content
message.save()
return redirect(message)
def goal_completed(request):
'''
The is the function that gets called when the person thinks that they have completed
something in the time frame. We need to check if the person has completed it,
'''
##don't know if this is correct, but I think I need to make sure that the times are good and
##to not trust the updated things. I can just call update goal to begin with. Yeah...
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('login'))
if request.is_ajax():
response_data = {}
#need to get the goal. Identified by id, make sure that no one else's id is in the way
gid = request.POST['gid']
member = get_object_or_404(Member, user=request.user.id)
goal = Goal.objects.get(pk=gid)
if goal.member != member: #malicious or something
response_data['success'] = 'false'
return HttpResponse(json.dumps(response_data), content_type='application/json')
goal = goal_update(goal,member)
state = check_goal_state(goal)
if state == Status.COMPLETE:
response_data['success'] = 'false'
return HttpResponse(json.dumps(response_data), content_type='application/json')
else:
prev_complete = goal.num_completed_in_frame
goal.num_completed_in_frame += 1
if prev_complete + 1 == goal.times_in_frame:
goal.consecutive += 1
goal.last_completed = utc.localize(datetime.datetime.now())
goal = goal_update(goal,member)
context = {}
context['goal'] = goal
return render_to_response('goals/goal_view.html',context,context_instance=RequestContext(request))
def import_stock_report_dump(sourcefile):
with open(sourcefile) as f:
reader = csv.DictReader(f)
for row in reader:
site = Location.get_by_code(row['Site ID'])
if not site:
print(row)
continue
reporter = Connection.objects.get(identity=row['Mobile']).contact.worker
created = utc.localize(datetime.utcfromtimestamp(int(row['Timestamp'])))
logs = []
for chunk in row['Items'].split(';'):
bits = chunk.split()
item = Item.get_by_code(bits[0])
received = int(bits[1])
holding = int(bits[2])
logs.append(InventoryLog.objects.create(item=item,
last_quantity_received=received,
current_holding=holding))
report = StockReport.objects.create(site=site, reporter=reporter,
created=created)
report.logs.add(*logs)
print('Done')
def test_get_thread_page(self):
user = User()
user.save()
thread = Thread(title="test", author=user)
thread.save()
first_message = Message(author=user,
thread=thread,
content="hello",
created_date=utc.localize(datetime.now()),
modified_date=utc.localize(datetime.now()))
first_message.save()
response = self.c.get('/forum/thread/' + str(thread.id))
context = response.context
self.assertEquals(context["thread"], thread)
self.assertEquals(context["messages"][0], thread.messages()[0])
self.assertEquals(response.status_code, 200)
def update_current_state(self):
"""Computes the value of current_state based on relevant instances of
ProgramReport and/or taking into account current values of training_date
and last_report_date.
N.B. this method does not call save() so one must do that explicitly to
actually store the state update.
"""
data = ProgramReport.objects.filter(
program_id=self.program.pk,
site_id=self.site.pk).order_by('created')
if data.count() == 0:
if self.training_date:
current_time = utc.localize(datetime.utcnow())
eight_week_bound = current_time - relativedelta(weeks=8)
if self.last_report_date \
and self.last_report_date > eight_week_bound:
self.current_state = 'ACTIVE-BAD'
else:
self.current_state = 'INACTIVE-TRAINED'
else:
self.current_state = 'OUT'
else:
last_report_create_date = data.reverse()[0].created
current_time = utc.localize(datetime.utcnow())
eight_week_bound = current_time - relativedelta(weeks=8)
sixteen_week_bound = current_time - relativedelta(weeks=16)
if last_report_create_date > eight_week_bound:
self.current_state = 'ACTIVE'
elif last_report_create_date > sixteen_week_bound:
if self.last_report_date \
and self.last_report_date > eight_week_bound:
self.current_state = 'ACTIVE-BAD'
else:
self.current_state = 'INACTIVE-NEW'
else:
if self.last_report_date \
and self.last_report_date > eight_week_bound:
self.current_state = 'ACTIVE-BAD'
else:
self.current_state = 'INACTIVE'
def test_list_of_calls_not_open_yet(self):
c = Client()
self._call.call_open_date = utc.localize(datetime(2099, 1, 1))
self._call.save()
response = c.get(reverse('call-list'))
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Open calls')
self.assertNotContains(response,
'GreenLAnd Circumnavigation Expedition')
def validate_ownership_shared_note(request, note_id, code, check_expiry_date=True):
# Get sharable link and note
try:
note = Note.objects.filter(id=note_id, trash=False).get()
sharable_link = SharableLink.objects.filter(note_id=note_id).filter(code=code).get()
except:
raise Http404('Note does not exist.')
# Check expiry date
if check_expiry_date and sharable_link.expiry_date < utc.localize(datetime.now()):
raise Http404('This share link has expired.')
return note, sharable_link
def setUp(self):
self.first_user = User(username="******")
self.first_user.set_password('12345')
self.first_user.save()
self.second_user = User(username="******")
self.second_user.set_password('12345')
self.second_user.save()
self.third_user = User(username="******")
self.third_user.save()
self.first_student = Student(user=self.first_user)
self.first_student.save()
self.second_student = Student(user=self.second_user)
self.second_student.save()
self.teacher = Professor(user=self.third_user)
self.teacher.save()
self.stage = Stage(id=1, name="Stage1", level=1)
self.stage.save()
self.lesson = Lesson(id=1, name="Lesson 1", stage_id=1)
self.lesson.save()
self.thread_lesson = Thread.objects.create(author=self.first_user,
lesson=self.lesson,
title="Thread 1",
id=1)
self.thread_lesson.save()
self.thread_id = self.thread_lesson.id
self.message = Message.objects.create(
author=self.first_user,
content="Content of message",
thread=self.thread_lesson,
created_date=utc.localize(datetime.now()),
modified_date=utc.localize(datetime.now()))
self.message.save()
self.c = Client()
self.c.login(username='******', password='******')
self.c2 = Client()
self.c2.login(username='******', password='******')
self.file = SimpleUploadedFile('file.txt', b'OOOOOOOOOOOOOOOOOOOO')
self.attachment = MessageAttachment.objects.create(
name=self.file.name, file=self.file, message=self.message)
self.attachment.save()
def test_PIZ14(self):
""" The player(s) having traded the largest number of rule cards (given + received) during the course of
the game will earn a 10 points bonus. In case of a tie, each player will earn the bonus. """
rulecard = RuleCard.objects.get(ref_name = 'PIZ14')
player1, scoresheet1 = _prepare_scoresheet_and_returns_tuple(self.game, "p1", olives = 3)
player2, scoresheet2 = _prepare_scoresheet_and_returns_tuple(self.game, "p2", pepperoni = 1)
player3, scoresheet3 = _prepare_scoresheet_and_returns_tuple(self.game, "p3", mushrooms = 2)
rih1, rih2, rih3 = mommy.make(RuleInHand, game = self.game, player = player1, _quantity = 3)
rih4, rih5, rih6, rih7 = mommy.make(RuleInHand, game = self.game, player = player2, _quantity = 4)
rih8, rih9, rih10 = mommy.make(RuleInHand, game = self.game, player = player3, _quantity = 3)
# p2 has 6 cards exchanged, p1 and p3 only 5 because we don't take into account the commodities and the DECLINED trade
mommy.make(Trade, game = self.game, initiator = player1, responder = player2, status = 'ACCEPTED', # 3 cards for p1 & p2
initiator_offer = _prepare_offer(self.game, player1, [rih1]),
responder_offer = _prepare_offer(self.game, player2, [rih4, rih5]),
closing_date = utc.localize(datetime.datetime(2013, 11, 1, 13, 00, 0)))
mommy.make(Trade, game = self.game, initiator = player2, responder = player3, status = 'ACCEPTED', # 3 cards for p2 & p3
initiator_offer = _prepare_offer(self.game, player2, [rih6, rih7]),
responder_offer = _prepare_offer(self.game, player3, [rih8]),
closing_date = utc.localize(datetime.datetime(2013, 11, 2, 13, 00, 0)))
mommy.make(Trade, game = self.game, initiator = player1, responder = player3, status = 'ACCEPTED', # 2 cards for p1 & p3
initiator_offer = _prepare_offer(self.game, player1, [rih2], {'olives': 3}),
responder_offer = _prepare_offer(self.game, player3, [rih9]),
closing_date = utc.localize(datetime.datetime(2013, 11, 3, 13, 00, 0)))
mommy.make(Trade, game = self.game, initiator = player1, responder = player3, status = 'DECLINED',
initiator_offer = _prepare_offer(self.game, player1, [rih3]),
responder_offer = _prepare_offer(self.game, player3, [rih10]),
closing_date = utc.localize(datetime.datetime(2013, 11, 4, 13, 00, 0)))
rulecard.perform([scoresheet1, scoresheet2, scoresheet3])
self.assertEqual(3*2, scoresheet1.total_score)
assertRuleNotApplied(scoresheet1, rulecard)
self.assertEqual(3 + 10, scoresheet2.total_score)
assertRuleApplied(scoresheet2, rulecard, 'Your trades have included the largest number of exchanged rule cards in the game (6 cards). You earn a bonus of 10 point.',
score = 10)
self.assertEqual(2*2, scoresheet3.total_score)
assertRuleNotApplied(scoresheet3, rulecard)
def test_get_thread_page_date(self):
user = User()
user.save()
thread = Thread(title="test", author=user)
thread.save()
first_message = Message(author=user,
thread=thread,
content="hello",
created_date=utc.localize(datetime.now()),
modified_date=utc.localize(datetime.now()))
first_message.save()
response = self.c.get('/forum/thread/' + str(thread.id))
context = response.context
date = context["last_visit"]
response = self.c.get('/forum/thread/' + str(thread.id))
context = response.context
second_date = context["last_visit"]
self.assertNotEquals(date, second_date)
def VoteView(request, id):
data = {}
d=0
title = get_object_or_404(Titles, id=id)
now = utc.localize(datetime.datetime.utcnow())
options = Options.objects.filter(title=title)
data = {"options": options, "title": title}
if title.published == '0':
data.update({'error':'Preview Mode'})
if title.user == request.user:
data.update({'this':'true'})
return render(request, 'VotingApp/index.html', data)
title.end = title.end+datetime.timedelta(hours=6) - datetime.timedelta(minutes=30)
if title.end <= now:
# SendResults(title)
data.update({'error':'Polls have ended results are'})
return render(request, 'VotingApp/index.html', data)
# now = now.replace(tzinfo=utc).strftime('%D: %H:%M:%S')
time_left = (title.end-now-datetime.timedelta(hours=5)-datetime.timedelta(minutes=30))
data.update({"time_left" : str(time_left)[:-7]})
if request.method == "POST" and d == 0:
user_email = get_client_ip(request)
if Emails.objects.filter(email=user_email).exists():
newemail = Emails.objects.filter(email=user_email)[0]
else:
newemail = Emails.objects.create()
newemail.email = user_email
newemail.save()
emailss = Voted.objects.filter(email=newemail)
if emailss.filter(title=title).exists():
data.update({'error' : "You have already placed a vote !!"})
return render(request, 'VotingApp/index.html', data)
instance = Options.objects.get(name=request.POST['name'])
instance.vote +=1
instance.save()
Voted.objects.create(email=newemail, title=title)
data.update({'message' : "Suckessfully Voted for "+ request.POST['name']})
return render(request, 'VotingApp/index.html', data)
def test_PIZ13_tie(self):
rulecard = RuleCard.objects.get(ref_name = 'PIZ13')
player1, scoresheet1 = _prepare_scoresheet_and_returns_tuple(self.game, "p1", olives = 3, mozzarella = 2)
player2, scoresheet2 = _prepare_scoresheet_and_returns_tuple(self.game, "p2", pepperoni = 2, pineapple = 1, ham = 1)
player3, scoresheet3 = _prepare_scoresheet_and_returns_tuple(self.game, "p3", mushrooms = 2, mozzarella = 2)
mommy.make(Trade, game = self.game, initiator = player1, responder = player2, status = 'ACCEPTED', # 8 cards
initiator_offer = _prepare_offer(self.game, player1, [], {'mushrooms': 2, 'ham': 1}),
responder_offer = _prepare_offer(self.game, player2, [], {'olives': 3, 'mozzarella': 2}),
closing_date = utc.localize(datetime.datetime(2013, 11, 18, 15, 35, 0)))
mommy.make(Trade, game = self.game, initiator = player2, responder = player3, status = 'ACCEPTED', # 8 cards too
initiator_offer = _prepare_offer(self.game, player2, [], {'mushrooms': 2, 'mozzarella': 2}),
responder_offer = _prepare_offer(self.game, player3, [], {'pepperoni': 2, 'pineapple': 2}),
closing_date = utc.localize(datetime.datetime(2013, 11, 21, 12, 12, 0)))
rulecard.perform([scoresheet1, scoresheet2, scoresheet3])
self.assertEqual(3*2 + 2*3, scoresheet1.total_score)
assertRuleNotApplied(scoresheet1, rulecard)
self.assertEqual(2*3 + 2 + 3, scoresheet2.total_score)
assertRuleNotApplied(scoresheet2, rulecard)
self.assertEqual(2*2 + 2*3, scoresheet3.total_score)
assertRuleNotApplied(scoresheet3, rulecard)
def _get_day(day):
"""Get the start and end time with support for celery-encoded strings, dates, and datetimes."""
start_date = get_ad_day()
if day:
log.info("Got day: %s", day)
if not isinstance(day, (datetime.datetime, datetime.date)):
log.info("Converting day from string")
day = parse_iso8601(day)
start_date = day.replace(hour=0, minute=0, second=0, microsecond=0)
if is_naive(start_date):
start_date = utc.localize(start_date)
end_date = start_date + datetime.timedelta(days=1)
return (start_date, end_date)
def reply_thread(request, id):
thread = get_object_or_404(Thread, pk=id)
message_id = request.GET.get('reply_to')
form = MessageReplyForm(
request.POST,
request.FILES) # POST contains data, FILEs contains attachment
author = User.objects.get(pk=request.user.id)
if form.is_valid():
content = form.cleaned_data['content']
file = form.cleaned_data['file']
with transaction.atomic():
message = Message.objects.create(
content=content,
thread=thread,
author=author,
created_date=utc.localize(datetime.now()),
modified_date=utc.localize(datetime.now()))
if message_id is not None:
parent_message = get_object_or_404(Message, pk=message_id)
message.parent_message = parent_message
if file is not None:
name = os.path.split(file.name)[1]
MessageAttachment.objects.create(name=name,
file=file,
message=message)
message.save()
thread.modified_date = message.created_date
thread.save()
sendNotification(getNotificationForNewMessage(message))
return redirect(message)
else:
return HttpResponse(status=400, content="Malformed request")
def test_PIZ13(self):
"""The trade featuring the largest number of cards of the game (rules and toppings given by both players
combined) will give a bonus of 10 points to both players involved. Only accepted trades count.
In case of a tie between two or more trades, no one earns the bonus."""
rulecard = RuleCard.objects.get(ref_name = 'PIZ13')
player1, scoresheet1 = _prepare_scoresheet_and_returns_tuple(self.game, "p1", mushrooms = 5, ham = 1)
player2, scoresheet2 = _prepare_scoresheet_and_returns_tuple(self.game, "p2", olives = 3, mozzarella = 3, pepperoni = 2, pineapple = 1)
player3, scoresheet3 = _prepare_scoresheet_and_returns_tuple(self.game, "p3", mushrooms = 2, mozzarella = 2, pineapple = 4)
rih1 = mommy.make(RuleInHand, game = self.game, player = player1, rulecard = rulecard)
rih2 = mommy.make(RuleInHand, game = self.game, player = player2, rulecard = rulecard)
rih3 = mommy.make(RuleInHand, game = self.game, player = player3, rulecard = rulecard)
mommy.make(Trade, game = self.game, initiator = player1, responder = player2, status = 'REPLIED', # 12 cards included, but trade not ACEPTED
initiator_offer = _prepare_offer(self.game, player1, [rih1], {'mushrooms': 5, 'ham': 1}),
responder_offer = _prepare_offer(self.game, player2, [rih2], {'olives': 3, 'mozzarella': 3}))
mommy.make(Trade, game = self.game, initiator = player2, responder = player3, status = 'ACCEPTED', # 8 cards included, including 2 rulecards
initiator_offer = _prepare_offer(self.game, player2, [rih3], {'mushrooms': 2, 'mozzarella': 2}), # (see below)
responder_offer = _prepare_offer(self.game, player3, [rih2], {'pepperoni': 1, 'pineapple': 1}),
closing_date = utc.localize(datetime.datetime(2013, 11, 21, 15, 25, 0)))
mommy.make(Trade, game = self.game, initiator = player1, responder = player3, status = 'ACCEPTED', # 7 cards included, only commodities
initiator_offer = _prepare_offer(self.game, player1, [], {'mushrooms': 3}), # (to test that rulecards are included)
responder_offer = _prepare_offer(self.game, player3, [], {'pineapple': 4}),
closing_date = utc.localize(datetime.datetime(2013, 11, 22, 16, 25, 0)))
rulecard.perform([scoresheet1, scoresheet2, scoresheet3])
self.assertEqual(5*2 + 3, scoresheet1.total_score)
assertRuleNotApplied(scoresheet1, rulecard)
self.assertEqual(3*2 + 3*3 + 2*3 + 2 + 10, scoresheet2.total_score)
assertRuleApplied(scoresheet2, rulecard, 'Your trade with p3 (accepted on 2013/11/21 03:25 PM) included 8 cards. ' +
'It is the largest number of cards exchanged in a trade. You both earn a bonus of 10 points.',
score = 10)
self.assertEqual(2*2 + 2*3 + 4*2 + 10, scoresheet3.total_score)
assertRuleApplied(scoresheet3, rulecard, 'Your trade with p2 (accepted on 2013/11/21 03:25 PM) included 8 cards. ' +
'It is the largest number of cards exchanged in a trade. You both earn a bonus of 10 points.',
score = 10)
def index(request):
cal = timezone('US/Pacific')
utc_time = utc.localize(datetime.now()) #time in utc
#convert to PST
local_day = utc_time.astimezone(cal).strftime('%b %d, %Y')
local_time = utc_time.astimezone(cal).strftime('%I:%M %p')
print local_day #for debugging
print local_time #for debugging
#pass date/time with context object
context = {'day': local_day, 'time': local_time}
return render(request, 'time_app/index.html', context)
def import_message_dump(sourcefile):
with open(sourcefile) as f:
reader = csv.DictReader(f)
for row in reader:
connection = Connection.objects.get(identity=row['Connection'])
direction = row['Direction']
timestamp = utc.localize(datetime.utcfromtimestamp(int(row['Timestamp'])))
text = row['Text']
Message.objects.create(connection=connection,
direction=direction, date=timestamp,
text=text)
print('Done')
def TitleEdit(request,id):
if request.method == "POST":
title = get_object_or_404(Titles, id=id)
if title.published == '0':
d=1
title.title = request.POST['title']
try:
days = int(request.POST['end_in'])
title.published =1
date = utc.localize(datetime.datetime.today()) + datetime.timedelta(days=days)
title.end = date
title.save()
except:
title.save()
return redirect(reverse('titles',args=[id]))
def validate_ownership_shared_note(request,
note_id,
code,
check_expiry_date=True):
# Get sharable link and note
try:
note = Note.objects.filter(id=note_id).get()
sharable_link = SharableLink.objects.filter(note_id=note_id).filter(
code=code).get()
except:
raise Http404('Note does not exist.')
# Check expiry date
if check_expiry_date and sharable_link.expiry_date < utc.localize(
datetime.now()):
raise Http404('This share link has expired.')
return note, sharable_link
def test_proposal_new_post_too_late(self):
c = Client()
self._call.submission_deadline = utc.localize(datetime(2000, 1, 1))
self._call.save()
data = self._proposal_post_data(self._call.submission_deadline +
timedelta(days=1))
data['proposal_form-title'] = ['Too late?']
response = c.post(f'{reverse("proposal-add")}?call={self._call.id}',
data=data)
self.assertEqual(302, response.status_code)
self.assertEqual('/proposal/cannot-modify/', response.url)
messages = get_response_messages(response)
self.assertIn('deadline has now passed', messages[0].message)
def import_program_report_dump(sourcefile):
with open(sourcefile) as f:
reader = csv.DictReader(f)
for row in reader:
site = Location.get_by_code(row['Site ID'])
if not site:
print(row)
continue
reporter = Connection.objects.get(identity=row['Mobile']).contact.worker
created = utc.localize(datetime.utcfromtimestamp(int(row['Timestamp'])))
modified = created
group = PatientGroup.get_by_code(row['Group'])
program = Program.get_by_code(row['Program'])
period_code = row['Period code']
period_number = row['Period number']
atot = int(row['Atot'])
tin = int(row['Tin'])
tout = int(row['Tout'])
dead = int(row['Dead'])
deft = int(row['DefT'])
dcur = int(row['Dcur'])
dmed = int(row['Dmed'])
ProgramReport.objects.create(site=site,
reporter=reporter,
created=created,
modified=modified,
group=group,
program=program,
period_number=period_number,
period_code=period_code,
new_marasmic_patients=atot,
patients_transferred_in=tin,
patients_transferred_out=tout,
patient_deaths=dead,
unconfirmed_patient_defaults=deft,
patients_cured=dcur,
unresponsive_patients=dmed)
print('Done')
def create_sepaduedate_instances(OrderPayment, SepaDueDate):
for op in OrderPayment.objects.filter(provider='sepadebit').filter(
info__isnull=False):
# prevents dependency from the info_data property
op_info_data = json.loads(op.info)
# either use provided remind_after value or date and add a ts to it
r_a = getattr(op_info_data, 'remind_after', op_info_data['date'])
remind_after = utc.localize(datetime.strptime(r_a, '%Y-%m-%d'))
due_date = SepaDueDate(date=op_info_data['date'],
reminded=getattr(op_info_data, 'reminded',
True),
remind_after=remind_after)
due_date.payment = op
due_date.save()
del op_info_data['date']
op.info = json.dumps(op_info_data, sort_keys=True)
op.save()
def import_stockout_dump(sourcefile):
with open(sourcefile) as f:
reader = csv.DictReader(f)
for row in reader:
site = Location.get_by_code(row['Site ID'])
reporter = Connection.objects.get(identity=row['Mobile']).contact.worker
created = utc.localize(datetime.utcfromtimestamp(int(row['Timestamp'])))
modified = created
stockout = StockOutReport.objects.create(site=site,
reporter=reporter, created=created, modified=modified)
items = []
for item_code in row['Items'].split(','):
items.append(Item.get_by_code(item_code.strip()))
stockout.items.add(*items)
print('Done')
def get_queryset(self):
qs = super(RouteListView, self).get_queryset()
competition_id = self.request.query_params.get("competition_id")
competition_ids = self.request.query_params.getlist("competition_id[]")
competitor_id = self.request.query_params.get("competitor_id")
competitor_ids = self.request.query_params.getlist("competitor_id[]")
created_after = self.request.query_params.get("created_after")
if competitor_id:
qs = qs.filter(competitor_id=competitor_id)
if competition_id:
competitor_ids = Competitor.objects.filter(
competition_id=competition_id
).values_list('pk', flat=True)
elif competition_ids:
competitor_ids = Competitor.objects.filter(
competition_id__in=competition_ids
).values_list('pk', flat=True)
if not (competition_ids or competition_id or competitor_id or
competitor_ids):
query = Q(publication_policy='public')
if not self.request.user.is_anonymous():
query |= Q(publisher=self.request.user)
competition_ids = Competition.objects.filter(
query
).values_list('pk', flat=True)
competitor_ids = Competitor.objects.filter(
competition_id__in=competition_ids
).values_list('pk', flat=True)
if competitor_ids:
qs = qs.filter(competitor_id__in=competitor_ids)
if created_after is not None:
from django.utils.timezone import utc
try:
start_epoch = float(created_after)
except ValueError:
raise ParseError()
start_datetime = datetime.datetime.fromtimestamp(start_epoch)
start = utc.localize(start_datetime)
qs = qs.filter(created__gt=start)
return qs
def get_queryset(self):
qs = super(RouteListView, self).get_queryset()
competition_id = self.request.query_params.get("competition_id")
competition_ids = self.request.query_params.getlist("competition_id[]")
competitor_id = self.request.query_params.get("competitor_id")
competitor_ids = self.request.query_params.getlist("competitor_id[]")
created_after = self.request.query_params.get("created_after")
if competitor_id:
qs = qs.filter(competitor_id=competitor_id)
if competition_id:
competitor_ids = Competitor.objects.filter(
competition_id=competition_id).values_list('pk', flat=True)
elif competition_ids:
competitor_ids = Competitor.objects.filter(
competition_id__in=competition_ids).values_list('pk',
flat=True)
if not (competition_ids or competition_id or competitor_id
or competitor_ids):
query = Q(publication_policy='public')
if not self.request.user.is_anonymous():
query |= Q(publisher=self.request.user)
competition_ids = Competition.objects.filter(query).values_list(
'pk', flat=True)
competitor_ids = Competitor.objects.filter(
competition_id__in=competition_ids).values_list('pk',
flat=True)
if competitor_ids:
qs = qs.filter(competitor_id__in=competitor_ids)
if created_after is not None:
from django.utils.timezone import utc
try:
start_epoch = float(created_after)
except ValueError:
raise ParseError()
start_datetime = datetime.datetime.fromtimestamp(start_epoch)
start = utc.localize(start_datetime)
qs = qs.filter(created__gt=start)
return qs
def goal_completed(request):
'''
The is the function that gets called when the person thinks that they have completed
something in the time frame. We need to check if the person has completed it,
'''
##don't know if this is correct, but I think I need to make sure that the times are good and
##to not trust the updated things. I can just call update goal to begin with. Yeah...
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('login'))
if request.is_ajax():
response_data = {}
#need to get the goal. Identified by id, make sure that no one else's id is in the way
gid = request.POST['gid']
member = get_object_or_404(Member, user=request.user.id)
goal = Goal.objects.get(pk=gid)
if goal.member != member: #malicious or something
response_data['success'] = 'false'
return HttpResponse(json.dumps(response_data),
content_type='application/json')
goal = goal_update(goal, member)
state = check_goal_state(goal)
if state == Status.COMPLETE:
response_data['success'] = 'false'
return HttpResponse(json.dumps(response_data),
content_type='application/json')
else:
prev_complete = goal.num_completed_in_frame
goal.num_completed_in_frame += 1
if prev_complete + 1 == goal.times_in_frame:
goal.consecutive += 1
goal.last_completed = utc.localize(datetime.datetime.now())
goal = goal_update(goal, member)
context = {}
context['goal'] = goal
return render_to_response('goals/goal_view.html',
context,
context_instance=RequestContext(request))
def test_PIZ15(self):
""" The cooks who will not have performed a trade with at least 7 different players during the game will
lose 20 points. Only accepted trades with at least one card (rule or topping) given by each player count. """
rulecard = RuleCard.objects.get(ref_name = 'PIZ15')
players = []
scoresheets = []
rih = []
for i in range(11):
player, scoresheet = _prepare_scoresheet_and_returns_tuple(self.game, "p{0}".format(i), olives = 3, mozzarella = 2)
players.append(player)
scoresheets.append(scoresheet)
rih.append(mommy.make(RuleInHand, game = self.game, player = player))
for i in range(9): # 2 trades with 2 different players for each player 1 to 8, plus one trade including player 0 and one including player 9
mommy.make(Trade, game = self.game, initiator = players[i], responder = players[i+1], status = 'ACCEPTED',
initiator_offer = _prepare_offer(self.game, players[i], [], {'olives': 1}),
responder_offer = _prepare_offer(self.game, players[i+1], [], {'mozzarella': 1}),
closing_date = utc.localize(datetime.datetime(2013, 11, i+1, 13, 00, 0)))
for i in range(1, 6): # 5 more different friends to trade with for player 0, but those trades do not include cards, only free informations
mommy.make(Trade, game = self.game, initiator = players[0], responder = players[i], status = 'ACCEPTED',
initiator_offer = mommy.make(Offer, free_information = 'free'),
responder_offer = mommy.make(Offer, free_information = 'info'),
closing_date = utc.localize(datetime.datetime(2013, 11, 10+i, 14, 00, 0)))
for i in range(1, 6): # 5 more different friends to trade with for player 1, but those trades were not ACCEPTED
mommy.make(Trade, game = self.game, initiator = players[1], responder = players[i], status = 'REPLIED',
initiator_offer = _prepare_offer(self.game, players[1], [], {'olives': 2}),
responder_offer = _prepare_offer(self.game, players[i], [], {'mozzarella': 2}),
closing_date = utc.localize(datetime.datetime(2013, 11, 15+i, 15, 00, 0)))
for i in range(1, 6): # 5 more different friends to trade with for player 2, but the responder did not give any card
mommy.make(Trade, game = self.game, initiator = players[2], responder = players[i], status = 'ACCEPTED',
initiator_offer = _prepare_offer(self.game, players[2], [], {'olives': 2}),
responder_offer = mommy.make(Offer, free_information = 'info'),
closing_date = utc.localize(datetime.datetime(2013, 11, 20+i, 16, 00, 0)))
for i in range(1, 6): # 5 more different friends to trade with players 7 and 8, making them both avoiding the loss
mommy.make(Trade, game = self.game, initiator = players[7], responder = players[i], status = 'ACCEPTED',
initiator_offer = _prepare_offer(self.game, players[7], [], {'olives': 2}),
responder_offer = _prepare_offer(self.game, players[i], [rih[i]], {}), # only a rulecard, to check they are taken in account
closing_date = utc.localize(datetime.datetime(2013, 11, 24+i, 17, 00, 0)))
mommy.make(Trade, game = self.game, initiator = players[i], responder = players[8], status = 'ACCEPTED',
initiator_offer = _prepare_offer(self.game, players[i], [rih[i]], {}),
responder_offer = _prepare_offer(self.game, players[8], [], {'mozzarella': 2}),
closing_date = utc.localize(datetime.datetime(2013, 11, 24+i, 18, 00, 0)))
for scoresheet in scoresheets:
rulecard.perform(scoresheet)
for i in [0, 9]:
self.assertEqual(3*2 + 2*3 - 20, scoresheets[i].total_score)
assertRuleApplied(scoresheets[i], rulecard, 'Since you have performed trades (including one card or more given by each player) with only 1 other player (less than the 7 players required), you lose 20 points.', score = -20)
for i in range(1, 6):
self.assertEqual(3*2 + 2*3 - 20, scoresheets[i].total_score)
assertRuleApplied(scoresheets[i], rulecard, 'Since you have performed trades (including one card or more given by each player) with only 4 different players (less than the 7 players required), you lose 20 points.', score = -20)
self.assertEqual(3*2 + 2*3 - 20, scoresheets[6].total_score)
assertRuleApplied(scoresheets[6], rulecard, 'Since you have performed trades (including one card or more given by each player) with only 2 different players (less than the 7 players required), you lose 20 points.', score = -20)
self.assertEqual(3*2 + 2*3, scoresheets[7].total_score)
assertRuleNotApplied(scoresheets[7], rulecard)
self.assertEqual(3*2 + 2*3, scoresheets[8].total_score)
assertRuleNotApplied(scoresheets[8], rulecard)
self.assertEqual(3*2 + 2*3 - 20, scoresheets[10].total_score)
assertRuleApplied(scoresheets[10], rulecard, 'Since you have not performed any trades (including one card or more given by each player) although you were required to do it with at least 7 other players, you lose 20 points.', score = -20)
def test_get_timestamp(self):
self.assertEqual(1386953223, get_timestamp(utc.localize(datetime.datetime(2013, 12, 13, 16, 47, 03))))
def select_rules(request):
if 'ruleset' not in request.session or 'start_date' not in request.session\
or 'end_date' not in request.session or 'players' not in request.session:
return redirect('create_game')
ruleset = Ruleset.objects.get(pk = request.session['ruleset'])
# transform back timestamp to datetime.datetime
start_date = utc.localize(datetime.datetime.utcfromtimestamp(request.session['start_date']))
end_date = utc.localize(datetime.datetime.utcfromtimestamp(request.session['end_date']))
players = get_user_model().objects.filter(id__in = request.session['players'])
try:
validate_dates(start_date, end_date)
validate_number_of_players(players, ruleset)
except ValidationError:
return redirect('create_game')
rulecards = RuleCard.objects.filter(ruleset = ruleset).order_by('ref_name')
# We'll have (A) nb_max_rulecards * MIN_COPIES_OF_EACH_RULECARD cards in play on one hand,
# and we will have (B) len(players) * starting_rules cards dealt at the beginning on the other hand.
# Those two numbers should be the same, but if it's not possible, the second one must be higher: (A) <= (B).
# Which gives: nb_max_rulecards <= len(players) * starting_rules / MIN_COPIES_OF_EACH_RULECARD
nb_max_rulecards = int(len(players) * float(ruleset.starting_rules) / MIN_COPIES_OF_EACH_RULECARD)
if request.method == 'POST':
selected_rules = []
for rulecard in rulecards:
if rulecard.mandatory:
selected_rules.append(rulecard)
continue
key = "rulecard_{0}".format(rulecard.id)
if key in request.POST and request.POST[key] == "True":
selected_rules.append(rulecard)
rulecard.selected = True
if len(selected_rules) > nb_max_rulecards:
error = "Please select at most {0} rule cards (including the mandatory ones)".format(nb_max_rulecards)
return render(request, 'game/select_rules.html', {'rulecards': rulecards, 'session': request.session, 'ruleset': ruleset,
'start_date': start_date, 'end_date': end_date, 'players': players,
'nb_max_rulecards': nb_max_rulecards, 'error': error})
game = Game.objects.create(ruleset = ruleset,
master = request.user,
start_date = start_date,
end_date = end_date)
for player in players:
GamePlayer.objects.create(game = game, player = player)
for rule in selected_rules:
game.rules.add(rule)
# deal starting cards
if not deal_cards(game):
game.delete()
error = "We failed to deal cards without the difference of starting scores being too large. Please try again."
return render(request, 'game/select_rules.html', {'rulecards': rulecards, 'session': request.session, 'ruleset': ruleset,
'start_date': start_date, 'end_date': end_date, 'players': players,
'nb_max_rulecards': nb_max_rulecards, 'error': error})
del request.session['ruleset']
del request.session['start_date']
del request.session['end_date']
del request.session['players']
# record score stats at the game creation
stats.record(game)
# email notification
all_players = {}
for player in game.players.all():
all_players[player] = {'name': player.name,
'url': request.build_absolute_uri(reverse('otherprofile', args=[player.id]))}
for player in all_players.iterkeys():
opponents = dict(all_players) # make a copy
del opponents[player]
list_opponents = sorted(opponents.itervalues(), key = lambda opponent: opponent['name'])
rules = rules_in_hand(game, player)
commodities = commodities_in_hand(game, player)
utils.send_notification_email('game_create', player,
{'game': game, 'opponents': list_opponents, 'rules': rules, 'commodities': commodities,
'player_timezone': player.timezone,
'url': request.build_absolute_uri(reverse('game', args=[game.id]))})
# email notification for the admins
utils.send_notification_email('game_create_admin', [admin[1] for admin in settings.ADMINS],
{'game': game, 'players': sorted(all_players.itervalues(), key = lambda player: player['name']),
'rules': selected_rules})
return redirect('game', game.id)
else:
return render(request, 'game/select_rules.html', {'rulecards': rulecards, 'ruleset': ruleset,
'start_date': start_date, 'end_date': end_date, 'players': players,
'nb_max_rulecards': nb_max_rulecards})
def format_for_timezone(value):
''' working some crazy datetime magic that might be working '''
''' based on http://stackoverflow.com/questions/17193228/python-twitter-api-tweet-timestamp-convert-from-utc-to-est '''
utc = timezone('UTC')
utc_created_at = utc.localize(value)
return utc_created_at
def get_timestamp(dt = now()):
""" Returns the number of seconds since Jan. 1st, 1970, midnight """
return int((dt - utc.localize(datetime.datetime(1970, 1, 1, 0, 0, 0))).total_seconds())
