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())