def bid_review_summary(self): interest_string = '' for interest in self.interest_list: interest_string += interest + ', \n' availability_string = '' unavailability_string = '' for window in self.available_windows.all(): availability_string += unicode(window) + ', \n' for window in self.unavailable_windows.all(): unavailability_string += unicode(window) + ', \n' commitments = '' for event in self.profile.get_schedule(self.b_conference): start_time = date_format(event.start_time, "DATETIME_FORMAT") end_time = date_format(event.end_time, "TIME_FORMAT") commitment_string = "%s - %s to %s, \n " % ( str(event), start_time, end_time) commitments += commitment_string format_string = "Availability: %s\n Conflicts: %s\n Commitments: %s" scheduling = format_string % (availability_string, unavailability_string, commitments) return [self.profile.display_name, self.profile.user_object.email, self.profile.preferences.in_hotel, self.number_shifts, scheduling, interest_string, self.pre_event, self.background, acceptance_states[self.accepted][1]]
def test_saveagain(self): current_date = create_doc(self.factory.user) self.factory.xfer = DocumentShow() self.calljson('/lucterios.documents/documentShow', {"document": "1"}, False) self.assert_observer('core.custom', 'lucterios.documents', 'documentShow') self.assertEqual(self.json_meta['title'], "Afficher le document") self.assert_count_equal('', 9) self.assert_comp_equal(('LABELFORM', 'name'), "doc1.png", (1, 0, 2, 1)) self.assert_comp_equal(('LABELFORM', 'folder'), ">truc2", (1, 1, 2, 1)) self.assert_comp_equal(('LABELFORM', 'description'), "doc 1", (1, 2, 2, 1)) self.assert_comp_equal(('LABELFORM', 'modifier'), '---', (1, 3, 1, 1)) self.assert_comp_equal(('LABELFORM', 'date_modification'), formats.date_format(current_date, "DATETIME_FORMAT"), (2, 3, 1, 1)) self.assert_comp_equal(('LABELFORM', 'creator'), "empty", (1, 4, 1, 1)) self.assert_comp_equal(('LABELFORM', 'date_creation'), formats.date_format(current_date, "DATETIME_FORMAT"), (2, 4, 1, 1)) self.assertEqual(len(self.json_actions), 3) self.factory.xfer = DocumentAddModify() self.calljson('/lucterios.documents/documentAddModify', {'SAVE': 'YES', "document": "1", 'description': 'old doc', 'folder': 3}, False) docs = Document.objects.all().order_by('id') self.assertEqual(len(docs), 3) self.assertEqual(docs[0].folder.id, 3) self.assertEqual(docs[0].name, 'doc1.png') self.assertEqual(docs[0].description, "old doc") self.assertEqual(docs[0].creator.username, "empty") self.assertEqual(docs[0].modifier.username, "empty") self.assertNotEqual(docs[0].date_creation, docs[0].date_modification)
def serialize(self): """ Returns JSON serializable dict of instance """ return dict( name=self.name, bnet_id=self.bnet_id, region=self.region, ranked=not self.is_unranked, ladder_name=self.ladder_name, ladder_id=self.ladder_id, country=self.get_country_display(), league=self.get_league_display(), race=self.get_race_display(), last_game=date_format(self.last_game, 'SHORT_DATE_FORMAT'), wins=self.wins, losses=self.losses, score=self.score, rank=self.rank, join_date=date_format(self.join_date, 'SHORT_DATE_FORMAT'), winrate=self.winrate, total_games=self.total_games, bnet_profile_url=self.bnet_profile_url, twitch_username=self.twitch_username, twitch_url=self.twitch_url, rankedftw_url=self.rankedftw_url, rankedftw_graph_url=self.rankedftw_graph_url )
def nicevalue(value): if isinstance(value,datetime): return '%s %s' % (date_format(value.date()),time_format(value.time())) elif isinstance(value,date): return date_format(value) else: return value
def editdevice(request,id): if request.method =='GET' : if request.user.is_authenticated(): now = datetime.now() now = formats.date_format(now,"SHORT_DATETIME_FORMAT") data = DeviceProfile.objects.get(device_id=id) dv = {'device_name':data.device_name,'openTime':data.openTime,'closeTime':data.closeTime} form = EditDeviceForm(dv) return render(request, 'deviceprofile_edit.html', {'form': form,"date":str(now)}) else: return redirect('/authen/') elif request.method == 'POST' : now = datetime.now() now = formats.date_format(now,"SHORT_DATETIME_FORMAT") data = DeviceProfile.objects.get(device_id=id) if request.POST.get('updatedevice'): #request.POST.owner = request.user form = EditDeviceForm(request.POST) if form.is_valid(): DeviceProfile.objects.filter(device_id=id).update(**form.cleaned_data) return redirect('/deviceprofile/') elif request.POST.get('cancelupdatedevice'): return redirect('/deviceprofile/')
def get_last_activity(idtopic): ''' This method return last activity of topic ''' try: comment = Comment.objects.filter( topic_id=idtopic).order_by("-date") except Exception: comment = None if comment: # Get timezone for datetime d_timezone = timezone.localtime(comment[0].date) # Format data date = formats.date_format(d_timezone, "SHORT_DATETIME_FORMAT") # Return format data more user with tag <a> html = "" html += get_path_profile(comment[0].user) html += " <p>"+str(date)+"</p>" return html else: topic = Topic.objects.get(idtopic=idtopic) # Get timezone for datetime d_timezone = timezone.localtime(topic.date) # Format data date = formats.date_format(d_timezone, "SHORT_DATETIME_FORMAT") # Return format data more user with tag <a> html = "" html += get_path_profile(topic.user) html += " <p>"+str(date)+"</p>" return html
def format_col(self, field, obj): # first see if view subclass has a formatter defined formatter = getattr(self, field, None) if formatter: return formatter(obj) if callable(formatter) else formatter # fk property if "__" in field: return utils.lookup_dunder_prop(obj, field) try: return getattr(obj, 'get_{0}_display'.format(field))() except AttributeError: pass try: attr = getattr(obj, field) except AttributeError: raise AttributeError("'%s' is not a valid format specifier" % (field)) if callable(attr): return attr() elif isinstance(attr, datetime.datetime): return formats.date_format(attr, "SHORT_DATETIME_FORMAT") elif isinstance(attr, datetime.date): return formats.date_format(attr, "SHORT_DATE_FORMAT") elif attr is None: return "" return str(attr)
def test_view_review(self): """ Should have individual review pages for every review with all required information. """ for review in Review.objects.all(): resp = self.client.get(reverse("review", args=[review.id])) self.assertEqual(resp.status_code, 200) self.assertIn("review", resp.context) content = resp.content.decode() # check for all professor details self.assertIn(review.target.last_name, content) self.assertIn(review.target.first_name, content) self.assertIn(review.course.name, content) self.assertIn(str(review.course.number), content) self.assertIn(review.course.department.name, content) # Check for reviewer details self.assertIn(review.owner.first_name, content) self.assertIn(review.owner.last_name, content) self.assertIn(review.owner.username, content) self.assertIn(formats.date_format(review.created_ts, "DATETIME_FORMAT"), content) if review.updated_ts: self.assertIn(formats.date_format(review.updated_ts, "DATETIME_FORMAT"), content)
def post(self, request, *args, **kwargs): if request.is_ajax(): image = get_object_or_404(Image, pk = kwargs.get('pk')) ret = None try: # Only delete it if it's in the future and from the same # judge. iotd = Iotd.objects.get(image = image) if iotd.date <= datetime.now().date(): ret = { 'iotd': iotd.pk, 'date': formats.date_format(iotd.date, "SHORT_DATE_FORMAT"), 'used_today': iotd_elections_today(request.user), 'error': ugettext("You cannot unelect a past or current IOTD."), } elif iotd.judge != request.user: ret = { 'iotd': iotd.pk, 'date': formats.date_format(iotd.date, "SHORT_DATE_FORMAT"), 'used_today': iotd_elections_today(request.user), 'error': ugettext("You cannot unelect an IOTD elected by another judge."), } else: iotd.delete() ret = { 'used_today': iotd_elections_today(request.user), } except Iotd.DoesNotExist: max_days = settings.IOTD_JUDGEMENT_MAX_FUTURE_DAYS for date in (datetime.now().date() + timedelta(n) for n in range(max_days)): try: iotd = Iotd.objects.get(date = date) except Iotd.DoesNotExist: may, reason = may_elect_iotd(request.user, image) if may: iotd = Iotd.objects.create( judge = request.user, image = image, date = date) ret = { 'iotd': iotd.pk, 'date': formats.date_format(iotd.date, "SHORT_DATE_FORMAT"), 'used_today': iotd_elections_today(request.user), } else: ret = { 'error': reason, } break if not ret: ret = { 'error': ugettext("All IOTD slots for the next %(days)s days are already filled.") % { 'days': max_days, }, } return self.render_json_response(ret) return HttpResponseForbidden()
def interval_display(self): if self.end: diff_dates = self.naive_start.date() != self.naive_end.date() if self.has_specific_time: if diff_dates: return " - ".join([self.l10n_start, self.l10n_end]) else: return " - ".join([self.l10n_start, self.l10n_end_time]) else: if diff_dates: return " - ".join([ formats.date_format( self.naive_start, "SHORT_DATE_FORMAT" ), formats.date_format( self.naive_end - datetime.timedelta(days=1), "SHORT_DATE_FORMAT" ), ]) else: return formats.date_format( self.naive_start, "SHORT_DATE_FORMAT" ), else: if self.start: if self.has_specific_time: return self.l10n_start else: return formats.date_format( self.naive_start, "SHORT_DATE_FORMAT" ), else: return unicode(_(u"<Intet tidspunkt angivet>"))
def search_cohorts_viz(request): if debug: print >> sys.stderr,'Called '+sys._getframe().f_code.co_name q = request.GET.get('q', None) result_obj = { 'q': q } if q: cohort_results = Cohort.objects.search(q) list = [] for cohort in cohort_results: list.append({ 'id': cohort.id, 'name': cohort.name, 'last_date_saved': formats.date_format(cohort.last_date_saved, 'DATETIME_FORMAT'), 'owner': cohort.get_owner().email, 'samples': len(cohort.samples_set.all()) }) result_obj['cohorts'] = list list = [] viz_results = SavedViz.objects.search(q) for viz in viz_results: list.append({ 'id': viz.id, 'name': viz.name, 'last_date_saved': formats.date_format(viz.last_date_saved, 'DATETIME_FORMAT'), 'plots': len(viz.plot_set.all()), 'owner': viz.get_owner().email }) result_obj['visualizations'] = list return HttpResponse(json.dumps(result_obj), status=200)
def formatfooter(self, previous_month, next_month): """ Return a footer for a previous and next month. """ footer = '<tfoot><tr>' \ '<td colspan="3" class="prev">%s</td>' \ '<td class="pad"> </td>' \ '<td colspan="3" class="next">%s</td>' \ '</tr></tfoot>' if previous_month: previous_content = '<a href="%s" class="previous-month">%s</a>' % ( reverse('zinnia_entry_archive_month', args=[ previous_month.strftime('%Y'), previous_month.strftime('%m')]), date_format(previous_month, 'YEAR_MONTH_FORMAT')) else: previous_content = ' ' if next_month: next_content = '<a href="%s" class="next-month">%s</a>' % ( reverse('zinnia_entry_archive_month', args=[ next_month.strftime('%Y'), next_month.strftime('%m')]), date_format(next_month, 'YEAR_MONTH_FORMAT')) else: next_content = ' ' return footer % (previous_content, next_content)
def one_has_access(self, students, when=None): """ Checks if any of the users can submit taking the granted extra time in consideration. """ timing,d = self.get_timing(students, when or timezone.now()) if timing == self.TIMING.OPEN: return True,[] if timing == self.TIMING.LATE: # xgettext:no-python-format return True,[_("Deadline for the exercise has passed. Late submissions are allowed until {date} but points are only worth {percent:d}% of normal.").format( date=date_format(d), percent=self.course_module.get_late_submission_point_worth(), )] if timing == self.TIMING.UNOFFICIAL: return True,[_("Deadline for the exercise has passed ({date}). You may still submit unofficially to receive feedback.").format( date=date_format(d) )] if timing == self.TIMING.CLOSED_BEFORE: return False,[_("The exercise opens {date} for submissions.").format( date=date_format(d) )] if timing == self.TIMING.CLOSED_AFTER: return False,[_("Deadline for the exercise has passed ({date}).").format( date=date_format(d) )] if timing == self.TIMING.ARCHIVED: return False,[_("This course has been archived ({date}).").format( date=date_format(d) )] return False,["ERROR"]
def get_value_converted(value, bool_textual=False): import datetime if hasattr(value, 'all'): values = [] for val_item in value.all(): values.append(six.text_type(val_item)) return "{[br/]}".join(values) elif isinstance(value, datetime.datetime): return formats.date_format(value, "DATETIME_FORMAT") elif isinstance(value, datetime.date): return formats.date_format(value, "DATE_FORMAT") elif isinstance(value, datetime.time): return formats.date_format(value, "TIME_FORMAT") elif isinstance(value, bool): if bool_textual: if value: return _("Yes") else: return _("No") else: if value: return six.text_type("1") else: return six.text_type("0") elif value is None: return six.text_type("---") elif isinstance(value, LucteriosModel): return value.get_final_child() else: return value
def edit_event(request, event_id): user_agent = get_user_agent(request) if request.method == 'POST': form = EventEditForm(request.POST) if form.is_valid(): event_id = form.cleaned_data['event_id'] if event_id == 0: event = Event(time_start=timezone.now(), time_end=timezone.now()) else: event = Event.objects.get(pk=event_id) event.title = form.cleaned_data['title'] event.ingress_content = form.cleaned_data['ingress_content'] event.main_content = form.cleaned_data['main_content'] event.thumbnail = form.cleaned_data['thumbnail'] event.place = form.cleaned_data['place'] event.place_href = form.cleaned_data['place_href'] hour_start = int(form.cleaned_data['time_start'][:2]) minute_start = int(form.cleaned_data['time_start'][-2:]) hour_end = int(form.cleaned_data['time_end'][:2]) minute_end = int(form.cleaned_data['time_end'][-2:]) day = int(form.cleaned_data['date'][:2]) month = int(form.cleaned_data['date'][3:5]) year = int(form.cleaned_data['date'][-4:]) event.time_start = event.time_start.replace(hour=hour_start, minute=minute_start) event.time_start = event.time_start.replace(day=day, month=month, year=year) event.time_end = event.time_end.replace(hour=hour_end, minute=minute_end) event.time_end = event.time_end.replace(day=day, month=month, year=year) event.save() log_changes.change(request, event) return HttpResponseRedirect('/news/event/'+str(event.id)+'/') else: if int(event_id) == 0: form = EventEditForm(initial={ 'event_id': 0, 'time_start': '00:00', 'time_end': '00:00', 'date': formats.date_format(timezone.now(), 'd/m/Y'), }) else: requested_event = Event.objects.get(pk=event_id) form = EventEditForm(initial={ 'title': requested_event.title, 'event_id': event_id, 'ingress_content': requested_event.ingress_content, 'main_content': requested_event.main_content, 'thumbnail': requested_event.thumbnail, 'place': requested_event.place, 'place_href': requested_event.place_href, 'time_start': formats.date_format(requested_event.time_start, 'H:i'), 'time_end': formats.date_format(requested_event.time_end, 'H:i'), 'date': formats.date_format(requested_event.time_start, 'd/m/Y'), }) context = { 'form': form, 'event_id': event_id, 'mobile': user_agent.is_mobile, } return render(request, 'edit_event.html', context)
def test_readonly(self): current_date = create_doc(self.factory.user) self.factory.xfer = DocumentShow() self.calljson('/lucterios.documents/documentShow', {"document": "2"}, False) self.assert_observer('core.custom', 'lucterios.documents', 'documentShow') self.assertEqual(self.json_meta['title'], "Afficher le document") self.assert_count_equal('', 9) self.assert_comp_equal(('LABELFORM', 'name'), "doc2.png", (1, 0, 2, 1)) self.assert_comp_equal(('LABELFORM', 'folder'), ">truc1", (1, 1, 2, 1)) self.assert_comp_equal(('LABELFORM', 'description'), "doc 2", (1, 2, 2, 1)) self.assert_comp_equal(('LABELFORM', 'modifier'), '---', (1, 3, 1, 1)) self.assert_comp_equal(('LABELFORM', 'date_modification'), formats.date_format(current_date, "DATETIME_FORMAT"), (2, 3, 1, 1)) self.assert_comp_equal(('LABELFORM', 'creator'), "empty", (1, 4, 1, 1)) self.assert_comp_equal(('LABELFORM', 'date_creation'), formats.date_format(current_date, "DATETIME_FORMAT"), (2, 4, 1, 1)) self.assertEqual(len(self.json_actions), 2) self.factory.xfer = DocumentAddModify() self.calljson('/lucterios.documents/documentAddModify', {"document": "2"}, False) self.assert_observer('core.exception', 'lucterios.documents', 'documentAddModify') self.assert_json_equal('', 'message', "Écriture non autorisée !") self.factory.xfer = DocumentDel() self.calljson('/lucterios.documents/documentDel', {"document": "2"}, False) self.assert_observer('core.exception', 'lucterios.documents', 'documentDel') self.assert_json_equal('', 'message', "Écriture non autorisée !")
def ajax_obot_response(request): """ Simple regex-based response kit returns: HTML """ #some helpful variables: now = datetime.datetime.now() formatted_now = formats.date_format(now, "TIME_FORMAT") formatted_date = formats.date_format(now, "DATE_FORMAT") req = request.GET.get('msg', '') #regex preps for fun and profit greet = re.compile('[Hh](i|ey|ello)') name = re.compile('(.*)([Yy]our ){0,1}name') #this is tricky but could be radically improved... time = re.compile('(([Ww]hat ){0,1}time is it(\?){0,4})') date = re.compile("((.*)(('|i)s ){0,1}the date(\?){0,4})") if name.match(req): return HttpResponse('My name is John') if greet.match(req): return HttpResponse('Hi there') if time.match(req): resp = "It is now %s" % formatted_now return HttpResponse(resp) if date.match(req): resp = "It's %s" % formatted_date return HttpResponse(resp) else: resp = Response.objects.order_by('?')[0] return HttpResponse(resp.response)
def extract_conversation_summary(self, target_username): result = self.get_user_related_messages(target_username, visibility_reasons=None, archived=None) conversations = self.sort_messages_by_conversations(result) context_list = [] for conversation in conversations: messages_count = len(conversation) subject = conversation[-1]["subject"] first_message_date = conversation[-1]["sent_at"] last_message_date = conversation[0]["sent_at"] participants = set() # set of EMAIL ADDRESSES for message in conversation: participants.add(message["sender_email"]) participants.update(message["recipient_emails"]) participants = sorted(participants) context = {"subject": subject, "messages_count": messages_count, "participants": ", ".join(participants), "first_message_date": django_formats.date_format(first_message_date, "SHORT_DATE_FORMAT"), "last_message_date": django_formats.date_format(last_message_date, "SHORT_DATE_FORMAT")} context_list.append(context) return context_list
def get_employee_bisy(request, employee_id): try: date = parse_date(request.GET.get('date', str(datetime.date.today()))) start_week = date - datetime.timedelta(date.weekday()) end_week = start_week + datetime.timedelta(6) # подготовка структурированного словаря с рабочими сменами work_shifts = WorkShift.objects.filter( date__range=[start_week, end_week], employee=employee_id, special_config=WorkShift.SPECIAL_CONFIG_EMPLOYEE ).order_by('date') work_shifts_struct = {} for work_day in work_shifts: date_format = formats.date_format(work_day.date, "d.m.Y") if date_format not in work_shifts_struct: work_shifts_struct[date_format] = [] work_shifts_struct[date_format].append(work_day.club.name) grid = [] week_cursor = start_week while week_cursor <= end_week: date_cursor = formats.date_format(week_cursor, "d.m.Y") names = '' if date_cursor in work_shifts_struct: names = "\n".join(work_shifts_struct[date_cursor]) grid.append(names) week_cursor += datetime.timedelta(1) table = render_to_string('calendar/_employee_bisy.html', {'grid': grid}) return JsonResponse({'complete': table}) except Exception as e: print(e) return JsonResponse({'complete': 0})
def edit_profile(request,id): if request.method =='GET' : if request.user.is_authenticated(): now = timezone.make_aware(datetime.now(),timezone.get_default_timezone()) now = formats.date_format(now,"SHORT_DATETIME_FORMAT") data = User.objects.get(pk=id) form = EditProfileForm() dv = {'first_name':data.first_name,'last_name':data.last_name,'email':data.email} form = EditProfileForm(dv) return render(request, 'userprofile_edit.html', {'form':form,'timezones':pytz.common_timezones,"date":str(now)}) else: return redirect('/authen/') elif request.method == 'POST' : now = timezone.make_aware(datetime.now(),timezone.get_default_timezone()) now = formats.date_format(now,"SHORT_DATETIME_FORMAT") data = User.objects.get(pk=id) if request.POST.get('updateuser'): user = request.user time = request.POST['timezone'] form = EditProfileForm(request.POST) time_user = UserProfile.objects.filter(pk=id).update(user_timezone=time) request.session['django_timezone'] = request.POST['timezone'] if form.is_valid(): user.first_name = request.POST['first_name'] user.last_name = request.POST['last_name'] user.email = request.POST['email'] user.save() return redirect('/userprofile/') elif request.POST.get('canceledituser'): return redirect('/userprofile/')
def adddevice(request): if request.method =='GET' : if request.user.is_authenticated(): now = datetime.now() now = formats.date_format(now,"SHORT_DATETIME_FORMAT") form = DeviceProfileForm(initial={'owner':request.user}) form.fields['owner'].widget.attrs['readonly'] = 'True' return render(request, 'deviceprofile_add.html', {'form': form,"date":str(now)}) else: return redirect('/authen/') elif request.method =='POST' : if request.user.is_authenticated(): now = datetime.now() now = formats.date_format(now,"SHORT_DATETIME_FORMAT") if request.POST.get('adddevice'): form = DeviceProfileForm(request.POST) if form.is_valid(): new_deviceprofile = DeviceProfile.objects.create(**form.cleaned_data) new_deviceprofile.save() return redirect('/deviceprofile/') elif request.POST.get('canceladddevice'): return redirect('/deviceprofile/') else: return redirect('/authen/')
def values(self): """ Returns a list of values for this field for this instance. It's a list so we can accomodate many-to-many fields. """ # This import is deliberately inside the function because it causes # some settings to be imported, and we don't want to do that at the # module level. if self.field.rel: if isinstance(self.field.rel, models.ManyToOneRel): objs = getattr(self.instance.instance, self.field.name) elif isinstance(self.field.rel, models.ManyToManyRel): # ManyToManyRel return list(getattr(self.instance.instance, self.field.name).all()) elif self.field.choices: objs = dict(self.field.choices).get(self.raw_value, EMPTY_VALUE) elif isinstance(self.field, models.DateField) or isinstance(self.field, models.TimeField): if self.raw_value: if isinstance(self.field, models.DateTimeField): objs = capfirst(formats.date_format(self.raw_value, 'DATETIME_FORMAT')) elif isinstance(self.field, models.TimeField): objs = capfirst(formats.time_format(self.raw_value, 'TIME_FORMAT')) else: objs = capfirst(formats.date_format(self.raw_value, 'DATE_FORMAT')) else: objs = EMPTY_VALUE elif isinstance(self.field, models.BooleanField) or isinstance(self.field, models.NullBooleanField): objs = {True: 'Yes', False: 'No', None: 'Unknown'}[self.raw_value] else: objs = self.raw_value return [objs]
def change_to_readonly(self, cmp_name): old_obj = self.get_components(cmp_name) value = old_obj.value if isinstance(old_obj, XferCompSelect): if isinstance(old_obj.select_list, dict) and (value in old_obj.select_list.keys()): value = old_obj.select_list[value] if isinstance(old_obj.select_list, list): for key, sel_val in old_obj.select_list: if value == key: value = sel_val break elif isinstance(old_obj, XferCompDate): value = formats.date_format(value, "DATE_FORMAT") elif isinstance(old_obj, XferCompDateTime): value = formats.date_format(value, "DATETIME_FORMAT") elif isinstance(old_obj, XferCompTime): value = formats.date_format(value, "TIME_FORMAT") elif isinstance(old_obj, XferCompFloat) and (value is not None): value = ("%%.%df" % old_obj.prec) % value if value is None: value = "---" self.remove_component(cmp_name) self.tab = old_obj.tab new_lbl = XferCompLabelForm(cmp_name) new_lbl.set_value(value) new_lbl.col = old_obj.col new_lbl.row = old_obj.row new_lbl.vmin = old_obj.vmin new_lbl.hmin = old_obj.hmin new_lbl.colspan = old_obj.colspan new_lbl.rowspan = old_obj.rowspan self.add_component(new_lbl)
def full_description(self): return '{name}\n{description}\n{start} to {end}'.format( name=self.name, description=self.description, start=formats.date_format(self.start_time, 'SHORT_DATE_FORMAT'), end=formats.date_format(self.end_time, 'SHORT_DATE_FORMAT'), )
def parse_date(self, message , msg_key, response): d = self.get_header('Date', message) date_tuple = parsedate_tz(d) timestamp = mktime_tz(date_tuple) date = datetime.datetime.fromtimestamp(timestamp) response['date'] = formats.date_format(date, 'DATE_FORMAT') response['time'] = formats.date_format(date, 'TIME_FORMAT') response['timestamp'] = timestamp
def get_human_duration(self): """ Returns the start_date and end_date of the ophase as human readable e.g. vom 3. April 2014 bis 6. April 2016 """ return _('vom %(begin)s bis %(end)s') % { 'begin': formats.date_format(self.start_date, 'DATE_FORMAT'), 'end': formats.date_format(self.end_date, 'DATE_FORMAT'),}
def test_l10n_disabled(self): """ Catalan locale with format i18n disabled translations will be used, but not formats """ settings.USE_L10N = False activate('ca') try: self.assertEqual('N j, Y', get_format('DATE_FORMAT')) self.assertEqual(0, get_format('FIRST_DAY_OF_WEEK')) self.assertEqual('.', get_format('DECIMAL_SEPARATOR')) self.assertEqual(u'10:15 a.m.', time_format(self.t)) self.assertEqual(u'des. 31, 2009', date_format(self.d)) self.assertEqual(u'desembre 2009', date_format(self.d, 'YEAR_MONTH_FORMAT')) self.assertEqual(u'12/31/2009 8:50 p.m.', date_format(self.dt, 'SHORT_DATETIME_FORMAT')) self.assertEqual('No localizable', localize('No localizable')) self.assertEqual(decimal.Decimal('66666.666'), localize(self.n)) self.assertEqual(99999.999, localize(self.f)) self.assertEqual(datetime.date(2009, 12, 31), localize(self.d)) self.assertEqual(datetime.datetime(2009, 12, 31, 20, 50), localize(self.dt)) self.assertEqual(u'66666.666', Template('{{ n }}').render(self.ctxt)) self.assertEqual(u'99999.999', Template('{{ f }}').render(self.ctxt)) self.assertEqual(u'2009-12-31', Template('{{ d }}').render(self.ctxt)) self.assertEqual(u'2009-12-31 20:50:00', Template('{{ dt }}').render(self.ctxt)) self.assertEqual(u'66666.67', Template('{{ n|floatformat:2 }}').render(self.ctxt)) self.assertEqual(u'100000.0', Template('{{ f|floatformat }}').render(self.ctxt)) self.assertEqual(u'10:15 a.m.', Template('{{ t|time:"TIME_FORMAT" }}').render(self.ctxt)) self.assertEqual(u'12/31/2009', Template('{{ d|date:"SHORT_DATE_FORMAT" }}').render(self.ctxt)) self.assertEqual(u'12/31/2009 8:50 p.m.', Template('{{ dt|date:"SHORT_DATETIME_FORMAT" }}').render(self.ctxt)) form = I18nForm({ 'decimal_field': u'66666,666', 'float_field': u'99999,999', 'date_field': u'31/12/2009', 'datetime_field': u'31/12/2009 20:50', 'time_field': u'20:50', 'integer_field': u'1.234', }) self.assertEqual(False, form.is_valid()) self.assertEqual([u'Introdu\xefu un n\xfamero.'], form.errors['float_field']) self.assertEqual([u'Introdu\xefu un n\xfamero.'], form.errors['decimal_field']) self.assertEqual([u'Introdu\xefu una data v\xe0lida.'], form.errors['date_field']) self.assertEqual([u'Introdu\xefu una data/hora v\xe0lides.'], form.errors['datetime_field']) self.assertEqual([u'Introdu\xefu un n\xfamero sencer.'], form.errors['integer_field']) form2 = SelectDateForm({ 'date_field_month': u'12', 'date_field_day': u'31', 'date_field_year': u'2009' }) self.assertEqual(True, form2.is_valid()) self.assertEqual(datetime.date(2009, 12, 31), form2.cleaned_data['date_field']) self.assertEqual( u'<select name="mydate_month" id="id_mydate_month">\n<option value="1">gener</option>\n<option value="2">febrer</option>\n<option value="3">mar\xe7</option>\n<option value="4">abril</option>\n<option value="5">maig</option>\n<option value="6">juny</option>\n<option value="7">juliol</option>\n<option value="8">agost</option>\n<option value="9">setembre</option>\n<option value="10">octubre</option>\n<option value="11">novembre</option>\n<option value="12" selected="selected">desembre</option>\n</select>\n<select name="mydate_day" id="id_mydate_day">\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31" selected="selected">31</option>\n</select>\n<select name="mydate_year" id="id_mydate_year">\n<option value="2009" selected="selected">2009</option>\n<option value="2010">2010</option>\n<option value="2011">2011</option>\n<option value="2012">2012</option>\n<option value="2013">2013</option>\n<option value="2014">2014</option>\n<option value="2015">2015</option>\n<option value="2016">2016</option>\n<option value="2017">2017</option>\n<option value="2018">2018</option>\n</select>', SelectDateWidget(years=range(2009, 2019)).render('mydate', datetime.date(2009, 12, 31)) ) finally: deactivate()
def date_hierarchy(cl): """ Displays the date hierarchy for date drill-down functionality. """ if cl.date_hierarchy: field_name = cl.date_hierarchy year_field = "%s__year" % field_name month_field = "%s__month" % field_name day_field = "%s__day" % field_name field_generic = "%s__" % field_name year_lookup = cl.params.get(year_field) month_lookup = cl.params.get(month_field) day_lookup = cl.params.get(day_field) link = lambda d: cl.get_query_string(d, [field_generic]) if year_lookup and month_lookup and day_lookup: day = datetime.date(int(year_lookup), int(month_lookup), int(day_lookup)) return { "show": True, "back": { "link": link({year_field: year_lookup, month_field: month_lookup}), "title": capfirst(formats.date_format(day, "YEAR_MONTH_FORMAT")), }, "choices": [{"title": capfirst(formats.date_format(day, "MONTH_DAY_FORMAT"))}], } elif year_lookup and month_lookup: days = cl.query_set.filter(**{year_field: year_lookup, month_field: month_lookup}).dates(field_name, "day") return { "show": True, "back": {"link": link({year_field: year_lookup}), "title": str(year_lookup)}, "choices": [ { "link": link({year_field: year_lookup, month_field: month_lookup, day_field: day.day}), "title": capfirst(formats.date_format(day, "MONTH_DAY_FORMAT")), } for day in days ], } elif year_lookup: months = cl.query_set.filter(**{year_field: year_lookup}).dates(field_name, "month") return { "show": True, "back": {"link": link({}), "title": _("All dates")}, "choices": [ { "link": link({year_field: year_lookup, month_field: month.month}), "title": capfirst(formats.date_format(month, "YEAR_MONTH_FORMAT")), } for month in months ], } else: years = cl.query_set.dates(field_name, "year") return { "show": True, "choices": [{"link": link({year_field: str(year.year)}), "title": str(year.year)} for year in years], }
def MonthGraph(request): if request.method =='GET' : if request.user.is_authenticated(): now = datetime.now() now = formats.date_format(now,"SHORT_DATETIME_FORMAT") #data = DeviceUsage.objects.values('date').annotate(sumusage=Sum('usage'))# Group by date y = [0,0,0,0,0,0,0,0,0,0 ,0,0,0,0,0,0,0,0,0,0 ,0,0,0,0,0,0,0,0,0,0,0,0] print "Don't select data" head="" plot = Bar(y,title=head, xlabel='date', ylabel='Unit', width=800, height=400) plot.toolbar_location = None plot.outline_line_color = None script, div = components(plot, CDN) return render(request, "monthgraph.html", {"the_script": script, "the_div": div,'devices': DeviceProfile.objects.filter(owner=request.user),"date":str(now)}) else: return redirect('/authen/') elif request.method == 'POST': now = datetime.now() now = formats.date_format(now,"SHORT_DATETIME_FORMAT") #data = DeviceUsage.objects.values('date').annotate(sumusage=Sum('usage'))# Group by date y = [0,0,0,0,0,0,0,0,0,0 ,0,0,0,0,0,0,0,0,0,0 ,0,0,0,0,0,0,0,0,0,0,0,0] head="" if request.POST.get('deviceid') is not None: id = request.POST.get('deviceid') if request.POST.get('month') is not None: month = request.POST.get('month') do = DeviceProfile.objects.get(device_id=id) data = DeviceUsage.objects.filter(device_id=do,date__month=month).values('date').annotate(sumusage=Sum('usage'),sumtime=Sum('time')) #print data # data[0].get('date').strftime("%d") get only date from year-month-date for d in data: hr = (float(d.get('sumtime'))/3600) kw = float(d.get('sumusage')) y[int(d.get('date').strftime("%d"))] = kw * hr head = "usage of device name: "+ do.device_name +" at "+request.POST.get('month')+"th Month" else: print "Don't select data" head="" plot = Bar(y,title=head, xlabel='date', ylabel='Unit', width=800, height=400) plot.toolbar_location = None plot.outline_line_color = None script, div = components(plot, CDN) return render(request, "monthgraph.html", {"the_script": script, "the_div": div,'devices': DeviceProfile.objects.filter(owner=request.user),"date":str(now)})
def date_hierarchy(cl): if cl.date_hierarchy: field_name = cl.date_hierarchy year_field = '%s__year' % field_name month_field = '%s__month' % field_name day_field = '%s__day' % field_name field_generic = '%s__' % field_name year_lookup = cl.params.get(year_field) month_lookup = cl.params.get(month_field) day_lookup = cl.params.get(day_field) link = lambda d: cl.get_query_string(d, [field_generic]) if year_lookup and month_lookup and day_lookup: day = datetime.date(int(year_lookup), int(month_lookup), int(day_lookup)) return { 'show': True, 'back': { 'link': link({year_field: year_lookup, month_field: month_lookup}), 'title': capfirst(formats.date_format(day, 'YEAR_MONTH_FORMAT')) }, 'choices': [{'title': capfirst(formats.date_format(day, 'MONTH_DAY_FORMAT'))}] } elif year_lookup and month_lookup: days = cl.query_set.filter(**{year_field: year_lookup, month_field: month_lookup}).dates(field_name, 'day') return { 'show': True, 'back': { 'link': link({year_field: year_lookup}), 'title': year_lookup }, 'choices': [{ 'link': link({year_field: year_lookup, month_field: month_lookup, day_field: day.day}), 'title': capfirst(formats.date_format(day, 'MONTH_DAY_FORMAT')) } for day in days] } elif year_lookup: months = cl.query_set.filter(**{year_field: year_lookup}).dates(field_name, 'month') return { 'show' : True, 'back': { 'link' : link({}), 'title': _('All dates') }, 'choices': [{ 'link': link({year_field: year_lookup, month_field: month.month}), 'title': capfirst(formats.date_format(month, 'YEAR_MONTH_FORMAT')) } for month in months] } else: years = cl.query_set.dates(field_name, 'year') return { 'show': True, 'choices': [{ 'link': link({year_field: str(year.year)}), 'title': str(year.year), } for year in years] }
def __str__(self): return date_format(self.value, "SHORT_DATE_FORMAT")
def __str__(self): at_end_of_day = self.value.hour == 23 and self.value.minute == 59 and self.value.second >= 59 if at_end_of_day: return date_format(self.value, "SHORT_DATE_FORMAT") else: return date_format(self.value, "SHORT_DATETIME_FORMAT")
def test_show_last_update_date_if_post_is_published(self): response = self.get('post_detail', pk=self.published_post.pk) expected = formats.date_format(self.published_post.published_at) self.assertContains(response, expected)
def getServicesData(request): # Session data os = request.os # We look for services for this authenticator groups. User is logged in in just 1 authenticator, so his groups must coincide with those assigned to ds groups = list(request.user.getGroups()) availServices = DeployedService.getDeployedServicesForGroups(groups) availMetas = MetaPool.getForGroups(groups) # Information for administrators nets = '' validTrans = '' logger.debug('OS: {0}'.format(os['OS'])) if request.user.isStaff(): nets = ','.join([n.name for n in Network.networksFor(request.ip)]) tt = [] for t in Transport.objects.all(): if t.validForIp(request.ip): tt.append(t.name) validTrans = ','.join(tt) logger.debug('Checking meta pools: %s', availMetas) services = [] # Add meta pools data first for meta in availMetas: # Check that we have access to at least one transport on some of its children hasUsablePools = False in_use = False for pool in meta.pools.all(): # if pool.isInMaintenance(): # continue for t in pool.transports.all(): typeTrans = t.getType() if t.getType() and t.validForIp( request.ip) and typeTrans.supportsOs( os['OS']) and t.validForOs(os['OS']): hasUsablePools = True break if not in_use: assignedUserService = UserServiceManager.manager( ).getExistingAssignationForUser(pool, request.user) if assignedUserService: in_use = assignedUserService.in_use # Stop when 1 usable pool is found if hasUsablePools: break # If no usable pools, this is not visible if hasUsablePools: group = meta.servicesPoolGroup.as_dict if meta.servicesPoolGroup else ServicesPoolGroup.default( ).as_dict services.append({ 'id': 'M' + meta.uuid, 'name': meta.name, 'visual_name': meta.visual_name, 'description': meta.comments, 'group': group, 'transports': [{ 'id': 'meta', 'name': 'meta', 'link': html.udsMetaLink(request, 'M' + meta.uuid), 'priority': 0 }], 'imageId': meta.image and meta.image.uuid or 'x', 'show_transports': False, 'allow_users_remove': False, 'allow_users_reset': False, 'maintenance': meta.isInMaintenance(), 'not_accesible': not meta.isAccessAllowed(), 'in_use': in_use, 'to_be_replaced': None, 'to_be_replaced_text': '', }) # Now generic user service for svr in availServices: # Skip pools that are part of meta pools if svr.is_meta: continue trans = [] for t in svr.transports.all().order_by('priority'): typeTrans = t.getType() if typeTrans is None: # This may happen if we "remove" a transport type but we have a transport of that kind on DB continue if t.validForIp(request.ip) and typeTrans.supportsOs( os['OS']) and t.validForOs(os['OS']): if typeTrans.ownLink is True: link = reverse('TransportOwnLink', args=('F' + svr.uuid, t.uuid)) else: link = html.udsAccessLink(request, 'F' + svr.uuid, t.uuid) trans.append({ 'id': t.uuid, 'name': t.name, 'link': link, 'priority': t.priority }) # If empty transports, do not include it on list if not trans: continue if svr.image is not None: imageId = svr.image.uuid else: imageId = 'x' # Locate if user service has any already assigned user service for this ads = UserServiceManager.manager().getExistingAssignationForUser( svr, request.user) if ads is None: in_use = False else: in_use = ads.in_use group = svr.servicesPoolGroup.as_dict if svr.servicesPoolGroup else ServicesPoolGroup.default( ).as_dict tbr = svr.toBeReplaced(request.user) if tbr: tbr = formats.date_format(tbr, "SHORT_DATETIME_FORMAT") tbrt = ugettext( 'This service is about to be replaced by a new version. Please, close the session before {} and save all your work to avoid loosing it.' ).format(tbr) else: tbrt = '' services.append({ 'id': 'F' + svr.uuid, 'name': svr.name, 'visual_name': svr.visual_name, 'description': svr.comments, 'group': group, 'transports': trans, 'imageId': imageId, 'show_transports': svr.show_transports, 'allow_users_remove': svr.allow_users_remove, 'allow_users_reset': svr.allow_users_reset, 'maintenance': svr.isInMaintenance(), 'not_accesible': not svr.isAccessAllowed(), 'in_use': in_use, 'to_be_replaced': tbr, 'to_be_replaced_text': tbrt, }) logger.debug('Services: {0}'.format(services)) # Sort services and remove services with no transports... services = [ s for s in sorted(services, key=lambda s: s['name'].upper()) if len(s['transports']) > 0 ] autorun = False if len(services) == 1 and GlobalConfig.AUTORUN_SERVICE.getBool( True) and len(services[0]['transports']) > 0: if request.session.get('autorunDone', '0') == '0': request.session['autorunDone'] = '1' autorun = True # return redirect('uds.web.views.service', idService=services[0]['id'], idTransport=services[0]['transports'][0]['id']) return { 'services': services, 'ip': request.ip, 'nets': nets, 'transports': validTrans, 'autorun': autorun }
def get_context_data(self, **kwargs): context = super(UserAboutPage, self).get_context_data(**kwargs) ratings = context['ratings'] = self.object.ratings.order_by('-contest__end_time').select_related('contest') \ .defer('contest__description') context['rating_data'] = mark_safe( json.dumps([{ 'label': rating.contest.name, 'rating': rating.rating, 'ranking': rating.rank, 'link': '%s#!%s' % (reverse('contest_ranking', args=(rating.contest.key, )), self.object.user.username), 'timestamp': (rating.contest.end_time - EPOCH).total_seconds() * 1000, 'date': date_format(rating.contest.end_time, _('M j, Y, G:i')), 'class': rating_class(rating.rating), 'height': '%.3fem' % rating_progress(rating.rating), } for rating in ratings])) if ratings: user_data = self.object.ratings.aggregate(Min('rating'), Max('rating')) global_data = Rating.objects.aggregate(Min('rating'), Max('rating')) min_ever, max_ever = global_data['rating__min'], global_data[ 'rating__max'] min_user, max_user = user_data['rating__min'], user_data[ 'rating__max'] delta = max_user - min_user ratio = (max_ever - max_user) / ( max_ever - min_ever) if max_ever != min_ever else 1.0 context['max_graph'] = max_user + ratio * delta context['min_graph'] = min_user + ratio * delta - delta user_timezone = settings.DEFAULT_USER_TIME_ZONE if self.request is not None and self.request.profile is not None: user_timezone = user_timezone or self.request.profile.timezone timezone_offset = pytz.timezone(user_timezone).utcoffset( datetime.utcnow()).seconds submissions = (self.object.submission_set.annotate(date_only=Cast( F('date') + timedelta(seconds=timezone_offset), DateField())).values('date_only').annotate(cnt=Count('id'))) context['submission_data'] = mark_safe( json.dumps({ date_counts['date_only'].isoformat(): date_counts['cnt'] for date_counts in submissions })) context['submission_metadata'] = mark_safe( json.dumps({ 'min_year': (self.object.submission_set.annotate( year_only=ExtractYear('date')).aggregate( min_year=Min('year_only'))['min_year']), })) return context
def __unicode__(self): return u'{} | {}'.format( self.course.title, formats.date_format(self.start_date, 'SHORT_DATETIME_FORMAT'))
}), ("event_date", { "label": _("Event date"), "editor_sample": _("May 31st, 2017"), "evaluate": lambda op, order, ev: ev.get_date_from_display(show_times=False) }), ("event_date_range", { "label": _("Event date range"), "editor_sample": _("May 31st – June 4th, 2017"), "evaluate": lambda op, order, ev: ev.get_date_range_display(force_show_end=True) }), ("event_begin", { "label": _("Event begin date and time"), "editor_sample": _("2017-05-31 20:00"), "evaluate": lambda op, order, ev: date_format( ev.date_from.astimezone(timezone(ev.settings.timezone)), "SHORT_DATETIME_FORMAT" ) if ev.date_from else "" }), ("event_begin_date", { "label": _("Event begin date"), "editor_sample": _("2017-05-31"), "evaluate": lambda op, order, ev: date_format( ev.date_from.astimezone(timezone(ev.settings.timezone)), "SHORT_DATE_FORMAT" ) if ev.date_from else "" }), ("event_begin_time", { "label": _("Event begin time"), "editor_sample": _("20:00"), "evaluate": lambda op, order, ev: ev.get_time_from_display() }),
def value(self, value): if value: return date_format(value, format="SHORT_DATETIME_FORMAT") return None
def get_context_data(self, **kwargs): """ called by the template system to get the context data for the template """ context = super().get_context_data(**kwargs) context['nieuwe_accounts'] = (AccountEmail.objects.select_related( 'account').all().order_by('-account__date_joined')[:50]) nieuwste = context['nieuwe_accounts'][ 0].account # kost losse database access jaar = nieuwste.date_joined.year maand = nieuwste.date_joined.month deze_maand = make_aware( datetime.datetime(year=jaar, month=maand, day=1)) context['deze_maand_count'] = ( Account.objects.order_by('-date_joined').filter( date_joined__gte=deze_maand).count()) context['deze_maand'] = deze_maand context['totaal'] = Account.objects.count() context['recente_activiteit'] = (AccountEmail.objects.filter( account__last_login__isnull=False).select_related( 'account').order_by('-account__last_login')[:50]) context['inlog_pogingen'] = ( AccountEmail.objects.select_related('account').filter( account__laatste_inlog_poging__isnull=False).filter( account__last_login__lt=F('account__laatste_inlog_poging') ).order_by('-account__laatste_inlog_poging')[:50]) # hulp nodig now = timezone.now() account_pks = list() for functie in (Functie.objects.prefetch_related( 'accounts', 'accounts__vhpg', 'accounts__accountemail_set').annotate( aantal=Count('accounts')).filter(aantal__gt=0)): for account in functie.accounts.all(): try: vhpg = account.vhpg except VerklaringHanterenPersoonsgegevens.DoesNotExist: add = True else: # elke 11 maanden moet de verklaring afgelegd worden # dit is ongeveer (11/12)*365 == 365-31 = 334 dagen opnieuw = vhpg.acceptatie_datum + datetime.timedelta( days=334) add = (opnieuw < now) if not account.otp_is_actief: add = True if add: if account.pk not in account_pks: account_pks.append(account.pk) # for # for hulp = list() for account in (Account.objects.prefetch_related( 'vhpg', 'functie_set').filter(pk__in=account_pks).order_by( 'last_login', 'unaccented_naam')): try: vhpg = account.vhpg except VerklaringHanterenPersoonsgegevens.DoesNotExist: account.vhpg_str = 'Nee' else: # elke 11 maanden moet de verklaring afgelegd worden # dit is ongeveer (11/12)*365 == 365-31 = 334 dagen opnieuw = vhpg.acceptatie_datum + datetime.timedelta(days=334) if opnieuw < now: account.vhpg_str = 'Verlopen' else: account.vhpg_str = 'Ja' if account.otp_is_actief: account.tweede_factor_str = 'Ja' else: account.tweede_factor_str = 'Nee' totaal_level = 0 functies = list() for functie in account.functie_set.all(): level = self.sort_level[functie.rol] tup = (level, functie.rol) functies.append(tup) totaal_level += level # for functies.sort(reverse=True) account.functies_str = ", ".join([tup[1] for tup in functies]) tup = (totaal_level, account.pk, account) hulp.append(tup) # for hulp.sort(reverse=True) context['hulp'] = [tup[2] for tup in hulp] context['hulp_testserver'] = settings.IS_TEST_SERVER # zoekformulier context['zoek_url'] = reverse('Overig:activiteit') context['zoekform'] = form = ZoekAccountForm(self.request.GET) form.full_clean() # vult form.cleaned_data try: zoekterm = form.cleaned_data['zoekterm'] except KeyError: # hier komen we als het form field niet valide was, bijvoorbeeld veel te lang zoekterm = "" context['zoekterm'] = zoekterm sporters = list() if len(zoekterm) >= 2: # minimaal twee tekens van de naam/nummer try: lid_nr = int(zoekterm[:6]) sporter = ( Sporter.objects.select_related('account').prefetch_related( 'account__functie_set', 'account__vhpg').get(lid_nr=lid_nr)) sporters.append(sporter) except (ValueError, Sporter.DoesNotExist): sporters = ( Sporter.objects.select_related('account').prefetch_related( 'account__functie_set', 'account__vhpg').filter( unaccented_naam__icontains=zoekterm).order_by( 'unaccented_naam'))[:50] to_tz = get_default_timezone() context['zoek_leden'] = list(sporters) for sporter in sporters: sporter.lid_nr_str = str(sporter.lid_nr) sporter.inlog_naam_str = 'Nog geen account aangemaakt' sporter.email_is_bevestigd_str = '-' sporter.tweede_factor_str = '-' sporter.vhpg_str = '-' sporter.laatste_inlog_str = '-' if sporter.bij_vereniging: sporter.ver_str = str(sporter.bij_vereniging) else: sporter.ver_str = 'Geen' if sporter.account: account = sporter.account sporter.inlog_naam_str = account.username email = account.accountemail_set.all()[0] if email.email_is_bevestigd: sporter.email_is_bevestigd_str = 'Ja' else: sporter.email_is_bevestigd_str = 'Nee' if account.last_login: sporter.laatste_inlog_str = date_format( account.last_login.astimezone(to_tz), 'j F H:i') do_vhpg = True if account.otp_is_actief: sporter.tweede_factor_str = 'Ja' elif account.functie_set.count() == 0: sporter.tweede_factor_str = 'n.v.t.' do_vhpg = False else: sporter.tweede_factor_str = 'Nee' if do_vhpg: sporter.vhpg_str = 'Nee' try: vhpg = account.vhpg except VerklaringHanterenPersoonsgegevens.DoesNotExist: sporter.vhpg_str = 'n.v.t.' else: # elke 11 maanden moet de verklaring afgelegd worden # dit is ongeveer (11/12)*365 == 365-31 = 334 dagen opnieuw = vhpg.acceptatie_datum + datetime.timedelta( days=334) opnieuw = opnieuw.astimezone(to_tz) now = timezone.now() if opnieuw < now: sporter.vhpg_str = 'Verlopen (geaccepteerd op %s)' % date_format( vhpg.acceptatie_datum, 'j F H:i') else: sporter.vhpg_str = 'Ja (op %s)' % date_format( vhpg.acceptatie_datum.astimezone(to_tz), 'j F H:i') sporter.functies = account.functie_set.order_by('beschrijving') # for # toon sessies # accses = (AccountSessions # .objects # .select_related('account', 'session') # .order_by('account', 'session__expire_date')) # for obj in accses: # # niet goed: onderstaande zorgt voor losse database hits voor elke sessie # session = SessionStore(session_key=obj.session.session_key) # # try: # obj.mag_wisselen_str = session[SESSIONVAR_ROL_MAG_WISSELEN] # except KeyError: # pragma: no cover # obj.mag_wisselen_str = '?' # # try: # obj.laatste_rol_str = rol2url[session[SESSIONVAR_ROL_HUIDIGE]] # except KeyError: # pragma: no cover # obj.laatste_rol_str = '?' # # for # context['accses'] = accses age_group_counts = dict() # [groep] = aantal for group in (1, 10, 20, 30, 40, 50, 60, 70, 80): age_group_counts[int(group / 10)] = 0 # for afgelopen_maand = timezone.now() - datetime.timedelta(days=30) jaar = timezone.now().year total = 0 for geboorte_datum in (Sporter.objects.exclude(account=None).filter( account__last_login__gte=afgelopen_maand).values_list( 'geboorte_datum', flat=True)): leeftijd = jaar - geboorte_datum.year leeftijd = min(leeftijd, 89) group = int(leeftijd / 10) age_group_counts[group] += 1 total += 1 # for if total > 0: age_groups = [((age * 10), (age * 10) + 9, count, int((count * 100) / total)) for age, count in age_group_counts.items()] age_groups.sort() context['age_groups'] = age_groups menu_dynamics(self.request, context) return context
def get_context_data(self, **kwargs): ctx = super(LabelEvidenceOnDocumentView, self).get_context_data(**kwargs) title = "Labeling Evidence for Relation {0}".format(self.relation) subtitle = 'For Document "{0}"'.format(self.document.human_identifier) segments_with_rich_tokens = [] for segment in self.get_text_segments(only_with_evidences=True): segment.hydrate() segments_with_rich_tokens.append({ 'id': segment.id, 'rich_tokens': list(segment.get_enriched_tokens()) }) if not segments_with_rich_tokens: ctx = { 'title': title, 'document': self.document, 'relation': self.relation, 'eos_propperties': {}, 'relations_list': [], 'forms_values': [], 'draw_navigation': True, } return ctx other_judges_labels = defaultdict(list) for formset in ctx["formset"]: instance = formset.instance evidence = instance.evidence_candidate for label in evidence.labels.filter(~Q(id=instance.id)): other_judges_labels[label.judge].append([ evidence.left_entity_occurrence.id, evidence.right_entity_occurrence.id, label.label ]) forms_values = {} eos_propperties = {} relations_list = [] formset = ctx['formset'] for form_idx, form in enumerate(formset): lbl_evidence = form.instance evidence = lbl_evidence.evidence_candidate left_eo_id = evidence.left_entity_occurrence.pk right_eo_id = evidence.right_entity_occurrence.pk info = "Labeled as {} by {} on {}".format( lbl_evidence.label, lbl_evidence.judge if lbl_evidence.judge else "unknown", formats.date_format(lbl_evidence.modification_date, "SHORT_DATETIME_FORMAT")) relations_list.append({ "relation": [left_eo_id, right_eo_id], "form_id": form.prefix, "info": info, }) forms_values[form.prefix] = lbl_evidence.label for eo_id in [left_eo_id, right_eo_id]: if eo_id not in eos_propperties: eos_propperties[eo_id] = { 'selectable': True, 'selected': False, } form_toolbox = EvidenceToolboxForm(prefix='toolbox') question_options = [x[0] for x in form_toolbox.fields["label"].choices] ctx.update({ 'title': title, 'subtitle': subtitle, 'document': self.document, 'segments': segments_with_rich_tokens, 'relation': self.relation, 'form_for_others': EvidenceForm(prefix='for_others'), 'form_toolbox': form_toolbox, 'initial_tool': EvidenceLabel.YESRELATION, 'eos_propperties': json.dumps(eos_propperties), 'relations_list': json.dumps(relations_list), 'forms_values': json.dumps(forms_values), 'question_options': question_options, 'other_judges_labels': json.dumps(other_judges_labels), 'other_judges': list(other_judges_labels.keys()), "draw_navigation": True, }) return ctx
def form_valid(self, form): qs = Order.objects.filter(event=self.request.event) statusq = Q(status__in=form.cleaned_data['sendto']) if 'overdue' in form.cleaned_data['sendto']: statusq |= Q(status=Order.STATUS_PENDING, expires__lt=now()) orders = qs.filter(statusq) tz = pytz.timezone(self.request.event.settings.timezone) failures = [] self.output = {} if not orders: messages.error(self.request, _('There are no orders matching this selection.')) return self.get(self.request, *self.args, **self.kwargs) for o in orders: if self.request.POST.get("action") == "preview": for l in self.request.event.settings.locales: with language(l): self.output[l] = [] self.output[l].append(_('Subject: {subject}').format(subject=form.cleaned_data['subject'].localize(l))) message = form.cleaned_data['message'].localize(l) preview_text = message.format( order='ORDER1234', event=self.request.event.name, order_date=date_format(now(), 'SHORT_DATE_FORMAT'), due_date=date_format(now() + timedelta(days=7), 'SHORT_DATE_FORMAT'), order_url=build_absolute_uri(self.request.event, 'presale:event.order', kwargs={ 'order': 'ORDER1234', 'secret': 'longrandomsecretabcdef123456' })) self.output[l].append(preview_text) return self.get(self.request, *self.args, **self.kwargs) else: try: with language(o.locale): mail(o.email, form.cleaned_data['subject'], form.cleaned_data['message'], { 'event': o.event, 'order': o.code, 'order_date': date_format(o.datetime.astimezone(tz), 'SHORT_DATETIME_FORMAT'), 'due_date': date_format(o.expires, 'SHORT_DATE_FORMAT'), 'order_url': build_absolute_uri(o.event, 'presale:event.order', kwargs={ 'order': o.code, 'secret': o.secret })}, self.request.event, locale=o.locale, order=o) o.log_action( 'pretix.plugins.sendmail.order.email.sent', user=self.request.user, data={ 'subject': form.cleaned_data['subject'], 'message': form.cleaned_data['message'], 'recipient': o.email } ) except SendMailException: failures.append(o.email) self.request.event.log_action('pretix.plugins.sendmail.sent', user=self.request.user, data=dict(form.cleaned_data)) if failures: messages.error(self.request, _('Failed to send mails to the following users: {}'.format(' '.join(failures)))) else: messages.success(self.request, _('Your message has been queued to be sent to the selected users.')) return redirect( 'plugins:sendmail:send', event=self.request.event.slug, organizer=self.request.event.organizer.slug )
def search(translation, request): ''' Performs search or returns cached search results. ''' # Already performed search if 'sid' in request.GET: # Grab from session storage search_id = 'search_%s' % request.GET['sid'] # Check if we know the search if search_id not in request.session: messages.error(request, _('Invalid search string!')) return redirect(translation) return request.session[search_id] # Possible new search search_form = SearchForm(request.GET) review_form = ReviewForm(request.GET) search_query = None if 'date' in request.GET: if review_form.is_valid(): # Review allunits = translation.unit_set.review( review_form.cleaned_data['date'], request.user) formatted_date = formats.date_format( review_form.cleaned_data['date'], 'SHORT_DATE_FORMAT') name = _('Review of translations since %s') % formatted_date else: show_form_errors(request, review_form) # Filtering by type allunits = translation.unit_set.all() name = _('All strings') elif search_form.is_valid(): # Apply search conditions allunits = translation.unit_set.search( translation, search_form.cleaned_data, ) search_query = search_form.cleaned_data['q'] name = search_form.get_name() else: # Error reporting show_form_errors(request, search_form) # Filtering by type allunits = translation.unit_set.all() name = _('All strings') # Grab unit IDs unit_ids = list(allunits.values_list('id', flat=True)) # Check empty search results if len(unit_ids) == 0: messages.warning(request, _('No string matched your search!')) return redirect(translation) # Checksum unit access offset = 0 if 'checksum' in request.GET: try: unit = allunits.filter(checksum=request.GET['checksum'])[0] offset = unit_ids.index(unit.id) except (Unit.DoesNotExist, IndexError): messages.warning(request, _('No string matched your search!')) return redirect(translation) # Remove old search results cleanup_session(request.session) # Store in cache and return search_id = str(uuid.uuid1()) search_result = { 'query': search_query, 'name': force_text(name) if name else None, 'ids': unit_ids, 'search_id': search_id, 'ttl': int(time.time()) + 86400, 'offset': offset, } request.session['search_%s' % search_id] = search_result return search_result
def get_contract_start_date(self, pos365): return formats.date_format(pos365.contract_start_date, "SHORT_DATE_FORMAT") \ if pos365.contract_start_date else ''
def __str__(self): #date_format default format is 'DATE_FORMAT' return '%s - %s%s' % (date_format(self.start), date_format( self.end), ", GROUP_SOURCE" if self.cancelled == None else "")
def __unicode__(self): return u'{} | {}'.format( self.meeting_type.title, formats.date_format(self.start_date, "SHORT_DATETIME_FORMAT"))
def form_valid(self, form): tz = pytz.timezone(self.request.event.settings.timezone) order = Order.objects.get(event=self.request.event, code=self.kwargs['code'].upper()) self.preview_output = {} try: invoice_name = order.invoice_address.name invoice_company = order.invoice_address.company except InvoiceAddress.DoesNotExist: invoice_name = "" invoice_company = "" with language(order.locale): email_context = { 'event': order.event, 'code': order.code, 'date': date_format(order.datetime.astimezone(tz), 'SHORT_DATETIME_FORMAT'), 'expire_date': date_format(order.expires, 'SHORT_DATE_FORMAT'), 'url': build_absolute_uri(order.event, 'presale:event.order', kwargs={ 'order': order.code, 'secret': order.secret }), 'invoice_name': invoice_name, 'invoice_company': invoice_company, } email_content = form.cleaned_data['message'].format_map(email_context) if self.request.POST.get('action') == 'preview': self.preview_output = [] self.preview_output.append( _('Subject: {subject}').format( subject=form.cleaned_data['subject'])) self.preview_output.append(email_content) return self.get(self.request, *self.args, **self.kwargs) else: try: with language(order.locale): email_template = LazyI18nString( form.cleaned_data['message']) mail(order.email, form.cleaned_data['subject'], email_template, email_context, self.request.event, locale=order.locale, order=order) order.log_action('pretix.event.order.mail_sent', user=self.request.user, data={ 'subject': form.cleaned_data['subject'], 'message': email_content, 'recipient': form.cleaned_data['sendto'], }) messages.success( self.request, _('Your message has been queued and will be sent to {}.'. format(order.email))) except SendMailException: messages.error( self.request, _('Failed to send mail to the following user: {}'.format( order.email))) return super(OrderSendMail, self).form_valid(form)
def _get_story(self, doc): has_taxes = any(il.tax_value for il in self.invoice.lines.all()) story = [ NextPageTemplate('FirstPage'), Paragraph((pgettext('invoice', 'Tax Invoice') if str( self.invoice.invoice_from_country) == 'AU' else pgettext( 'invoice', 'Invoice')) if not self.invoice.is_cancellation else pgettext('invoice', 'Cancellation'), self.stylesheet['Heading1']), Spacer(1, 5 * mm), NextPageTemplate('OtherPages'), ] story += self._get_intro() taxvalue_map = defaultdict(Decimal) grossvalue_map = defaultdict(Decimal) tstyledata = [ ('ALIGN', (1, 0), (-1, -1), 'RIGHT'), ('VALIGN', (0, 0), (-1, -1), 'TOP'), ('FONTNAME', (0, 0), (-1, 0), self.font_bold), ('FONTNAME', (0, -1), (-1, -1), self.font_bold), ('LEFTPADDING', (0, 0), (0, -1), 0), ('RIGHTPADDING', (-1, 0), (-1, -1), 0), ] if has_taxes: tdata = [( pgettext('invoice', 'Description'), pgettext('invoice', 'Qty'), pgettext('invoice', 'Tax rate'), pgettext('invoice', 'Net'), pgettext('invoice', 'Gross'), )] else: tdata = [( pgettext('invoice', 'Description'), pgettext('invoice', 'Qty'), pgettext('invoice', 'Amount'), )] total = Decimal('0.00') for line in self.invoice.lines.all(): if has_taxes: tdata.append(( Paragraph(line.description, self.stylesheet['Normal']), "1", localize(line.tax_rate) + " %", money_filter(line.net_value, self.invoice.event.currency), money_filter(line.gross_value, self.invoice.event.currency), )) else: tdata.append(( Paragraph(line.description, self.stylesheet['Normal']), "1", money_filter(line.gross_value, self.invoice.event.currency), )) taxvalue_map[line.tax_rate, line.tax_name] += line.tax_value grossvalue_map[line.tax_rate, line.tax_name] += line.gross_value total += line.gross_value if has_taxes: tdata.append([ pgettext('invoice', 'Invoice total'), '', '', '', money_filter(total, self.invoice.event.currency) ]) colwidths = [a * doc.width for a in (.50, .05, .15, .15, .15)] else: tdata.append([ pgettext('invoice', 'Invoice total'), '', money_filter(total, self.invoice.event.currency) ]) colwidths = [a * doc.width for a in (.65, .05, .30)] if self.invoice.event.settings.invoice_show_payments and not self.invoice.is_cancellation and \ self.invoice.order.status == Order.STATUS_PENDING: pending_sum = self.invoice.order.pending_sum if pending_sum != total: tdata.append([pgettext('invoice', 'Received payments')] + (['', '', ''] if has_taxes else ['']) + [ money_filter(pending_sum - total, self.invoice.event.currency) ]) tdata.append( [pgettext('invoice', 'Outstanding payments')] + (['', '', ''] if has_taxes else ['']) + [money_filter(pending_sum, self.invoice.event.currency)]) tstyledata += [ ('FONTNAME', (0, len(tdata) - 3), (-1, len(tdata) - 3), self.font_bold), ] table = Table(tdata, colWidths=colwidths, repeatRows=1) table.setStyle(TableStyle(tstyledata)) story.append(table) story.append(Spacer(1, 15 * mm)) if self.invoice.payment_provider_text: story.append( Paragraph(self.invoice.payment_provider_text, self.stylesheet['Normal'])) if self.invoice.payment_provider_text and self.invoice.additional_text: story.append(Spacer(1, 3 * mm)) if self.invoice.additional_text: story.append( Paragraph(self.invoice.additional_text, self.stylesheet['Normal'])) story.append(Spacer(1, 15 * mm)) tstyledata = [ ('ALIGN', (1, 0), (-1, -1), 'RIGHT'), ('LEFTPADDING', (0, 0), (0, -1), 0), ('RIGHTPADDING', (-1, 0), (-1, -1), 0), ('FONTSIZE', (0, 0), (-1, -1), 8), ('FONTNAME', (0, 0), (-1, -1), self.font_regular), ] thead = [ pgettext('invoice', 'Tax rate'), pgettext('invoice', 'Net value'), pgettext('invoice', 'Gross value'), pgettext('invoice', 'Tax'), '' ] tdata = [thead] for idx, gross in grossvalue_map.items(): rate, name = idx if rate == 0: continue tax = taxvalue_map[idx] tdata.append([ localize(rate) + " % " + name, money_filter(gross - tax, self.invoice.event.currency), money_filter(gross, self.invoice.event.currency), money_filter(tax, self.invoice.event.currency), '' ]) def fmt(val): try: return vat_moss.exchange_rates.format( val, self.invoice.foreign_currency_display) except ValueError: return localize( val) + ' ' + self.invoice.foreign_currency_display if len(tdata) > 1 and has_taxes: colwidths = [a * doc.width for a in (.25, .15, .15, .15, .3)] table = Table(tdata, colWidths=colwidths, repeatRows=2, hAlign=TA_LEFT) table.setStyle(TableStyle(tstyledata)) story.append(Spacer(5 * mm, 5 * mm)) story.append( KeepTogether([ Paragraph(pgettext('invoice', 'Included taxes'), self.stylesheet['FineprintHeading']), table ])) if self.invoice.foreign_currency_display and self.invoice.foreign_currency_rate: tdata = [thead] for idx, gross in grossvalue_map.items(): rate, name = idx if rate == 0: continue tax = taxvalue_map[idx] gross = round_decimal(gross * self.invoice.foreign_currency_rate) tax = round_decimal(tax * self.invoice.foreign_currency_rate) net = gross - tax tdata.append([ localize(rate) + " % " + name, fmt(net), fmt(gross), fmt(tax), '' ]) table = Table(tdata, colWidths=colwidths, repeatRows=2, hAlign=TA_LEFT) table.setStyle(TableStyle(tstyledata)) story.append( KeepTogether([ Spacer(1, height=2 * mm), Paragraph( pgettext( 'invoice', 'Using the conversion rate of 1:{rate} as published by the European Central Bank on ' '{date}, this corresponds to:'). format(rate=localize( self.invoice.foreign_currency_rate), date=date_format( self.invoice.foreign_currency_rate_date, "SHORT_DATE_FORMAT")), self.stylesheet['Fineprint']), Spacer(1, height=3 * mm), table ])) elif self.invoice.foreign_currency_display and self.invoice.foreign_currency_rate: foreign_total = round_decimal(total * self.invoice.foreign_currency_rate) story.append(Spacer(1, 5 * mm)) story.append( Paragraph( pgettext( 'invoice', 'Using the conversion rate of 1:{rate} as published by the European Central Bank on ' '{date}, the invoice total corresponds to {total}.'). format(rate=localize(self.invoice.foreign_currency_rate), date=date_format( self.invoice.foreign_currency_rate_date, "SHORT_DATE_FORMAT"), total=fmt(foreign_total)), self.stylesheet['Fineprint'])) return story
def render(self, form_data: dict): output = io.StringIO() writer = csv.writer(output, quoting=csv.QUOTE_NONNUMERIC, delimiter=",") cl = self.event.checkin_lists.get(pk=form_data['list']) questions = list( Question.objects.filter(event=self.event, id__in=form_data['questions'])) cqs = Checkin.objects.filter( position_id=OuterRef('pk'), list_id=cl.pk).order_by().values('position_id').annotate( m=Max('datetime')).values('m') qs = OrderPosition.objects.filter(order__event=self.event, ).annotate( last_checked_in=Subquery(cqs)).prefetch_related( 'answers', 'answers__question').select_related('order', 'item', 'variation', 'addon_to') if not cl.all_products: qs = qs.filter( item__in=cl.limit_products.values_list('id', flat=True)) if cl.subevent: qs = qs.filter(subevent=cl.subevent) if form_data['sort'] == 'name': qs = qs.order_by( Coalesce('attendee_name', 'addon_to__attendee_name')) elif form_data['sort'] == 'code': qs = qs.order_by('order__code') headers = [ _('Order code'), _('Attendee name'), _('Product'), _('Price'), _('Checked in') ] if form_data['paid_only']: qs = qs.filter(order__status=Order.STATUS_PAID) else: qs = qs.filter(order__status__in=(Order.STATUS_PAID, Order.STATUS_PENDING)) headers.append(_('Paid')) if form_data['secrets']: headers.append(_('Secret')) if self.event.settings.attendee_emails_asked: headers.append(_('E-mail')) if self.event.has_subevents: headers.append(pgettext('subevent', 'Date')) for q in questions: headers.append(str(q.question)) writer.writerow(headers) for op in qs: last_checked_in = None if isinstance(op.last_checked_in, str): # SQLite last_checked_in = dateutil.parser.parse(op.last_checked_in) elif op.last_checked_in: last_checked_in = op.last_checked_in if last_checked_in and not is_aware(last_checked_in): last_checked_in = make_aware(last_checked_in, UTC) row = [ op.order.code, op.attendee_name or (op.addon_to.attendee_name if op.addon_to else ''), str(op.item.name) + (" – " + str(op.variation.value) if op.variation else ""), op.price, date_format(last_checked_in.astimezone(self.event.timezone), 'SHORT_DATETIME_FORMAT') if last_checked_in else '' ] if not form_data['paid_only']: row.append( _('Yes') if op.order.status == Order.STATUS_PAID else _('No')) if form_data['secrets']: row.append(op.secret) if self.event.settings.attendee_emails_asked: row.append(op.attendee_email or (op.addon_to.attendee_email if op.addon_to else '')) if self.event.has_subevents: row.append(str(op.subevent)) acache = {} for a in op.answers.all(): acache[a.question_id] = str(a) for q in questions: row.append(acache.get(q.pk, '')) writer.writerow(row) return 'checkin.csv', 'text/csv', output.getvalue().encode("utf-8")
def __unicode__(self): return u'%s - %s (%s)' % (self.deadline.assignment_group, self.number, date_format(self.time_of_delivery, "DATETIME_FORMAT"))
def get(self, request): # noqa: C901 capabilities = dsmr_backend.services.backend.get_capabilities() frontend_settings = FrontendSettings.get_solo() selected_datetime = timezone.make_aware( timezone.datetime.strptime( self.request.GET['date'], formats.get_format('DSMR_STRFTIME_DATE_FORMAT'))) selected_level = self.request.GET['level'] data = defaultdict(list) response = { 'merge_electricity_tariffs': frontend_settings.merge_electricity_tariffs, } x_format_callback = None FIELDS = ('electricity1', 'electricity2', 'electricity1_returned', 'electricity2_returned', 'electricity_merged', 'electricity_returned_merged', 'gas') # Zoom to hourly data. if selected_level == 'days': hours_in_day = dsmr_backend.services.backend.hours_in_day( day=selected_datetime.date()) source_data = HourStatistics.objects.filter( hour_start__gte=selected_datetime, hour_start__lte=selected_datetime + timezone.timedelta(hours=hours_in_day)).order_by('hour_start') x_format = 'DSMR_GRAPH_SHORT_TIME_FORMAT' x_axis = 'hour_start' x_format_callback = timezone.localtime # Zoom to daily data. elif selected_level == 'months': start_of_month = timezone.datetime(year=selected_datetime.year, month=selected_datetime.month, day=1) end_of_month = timezone.datetime.combine( start_of_month + relativedelta(months=1), time.min) source_data = DayStatistics.objects.filter( day__gte=start_of_month, day__lt=end_of_month).order_by('day') x_format = 'DSMR_GRAPH_SHORT_DATE_FORMAT' x_axis = 'day' # Zoom to monthly data. elif selected_level == 'years': source_data = [] start_of_year = timezone.datetime(year=selected_datetime.year, month=1, day=1) for increment in range(0, 12): current_month = start_of_year + relativedelta(months=increment) current_month_stats = dsmr_stats.services.month_statistics( current_month.date()) current_month_stats['month'] = current_month.date() source_data.append(current_month_stats) x_format = 'DSMR_DATEPICKER_MONTH' x_axis = 'month' for current_item in source_data: try: x_value = getattr(current_item, x_axis) except AttributeError: x_value = current_item[x_axis] if x_format_callback: x_value = x_format_callback(x_value) data['x'].append(formats.date_format(x_value, x_format)) for current_field in FIELDS: try: y_value = getattr(current_item, current_field) or 0 except AttributeError: y_value = current_item[current_field] or 0 data[current_field].append(float(y_value)) if frontend_settings.merge_electricity_tariffs: response['electricity'] = { 'x': data['x'], 'electricity_merged': data['electricity_merged'], } else: response['electricity'] = { 'x': data['x'], 'electricity1': data['electricity1'], 'electricity2': data['electricity2'], } if capabilities['electricity_returned']: if frontend_settings.merge_electricity_tariffs: response['electricity_returned'] = { 'x': data['x'], 'electricity_returned_merged': data['electricity_returned_merged'], } else: response['electricity_returned'] = { 'x': data['x'], 'electricity1_returned': data['electricity1_returned'], 'electricity2_returned': data['electricity2_returned'], } if capabilities['gas']: response['gas'] = { 'x': data['x'], 'gas': data['gas'], } return JsonResponse(response)
def title_type(self): return '%s nº _____ %s' % (self.tipo, formats.date_format( self.data_envio if self.data_envio else timezone.now(), "\d\e d \d\e F \d\e Y"))
def date_hierarchy(cl): """ Displays the date hierarchy for date drill-down functionality. """ if cl.date_hierarchy: field_name = cl.date_hierarchy year_field = '%s__year' % field_name month_field = '%s__month' % field_name day_field = '%s__day' % field_name field_generic = '%s__' % field_name year_lookup = cl.params.get(year_field) month_lookup = cl.params.get(month_field) day_lookup = cl.params.get(day_field) link = lambda d: cl.get_query_string(d, [field_generic]) if not (year_lookup or month_lookup or day_lookup): # select appropriate start level date_range = cl.query_set.aggregate(first=models.Min(field_name), last=models.Max(field_name)) if date_range['first'] and date_range['last']: if date_range['first'].year == date_range['last'].year: year_lookup = date_range['first'].year if date_range['first'].month == date_range['last'].month: month_lookup = date_range['first'].month if year_lookup and month_lookup and day_lookup: day = datetime.date(int(year_lookup), int(month_lookup), int(day_lookup)) return { 'show': True, 'back': { 'link': link({year_field: year_lookup, month_field: month_lookup}), 'title': capfirst(formats.date_format(day, 'YEAR_MONTH_FORMAT')) }, 'choices': [{'title': capfirst(formats.date_format(day, 'MONTH_DAY_FORMAT'))}] } elif year_lookup and month_lookup: days = cl.query_set.filter(**{year_field: year_lookup, month_field: month_lookup}).dates(field_name, 'day') return { 'show': True, 'back': { 'link': link({year_field: year_lookup}), 'title': str(year_lookup) }, 'choices': [{ 'link': link({year_field: year_lookup, month_field: month_lookup, day_field: day.day}), 'title': capfirst(formats.date_format(day, 'MONTH_DAY_FORMAT')) } for day in days] } elif year_lookup: months = cl.query_set.filter(**{year_field: year_lookup}).dates(field_name, 'month') return { 'show' : True, 'back': { 'link' : link({}), 'title': _('All dates') }, 'choices': [{ 'link': link({year_field: year_lookup, month_field: month.month}), 'title': capfirst(formats.date_format(month, 'YEAR_MONTH_FORMAT')) } for month in months] } else: years = cl.query_set.dates(field_name, 'year') return { 'show': True, 'choices': [{ 'link': link({year_field: str(year.year)}), 'title': str(year.year), } for year in years] }
def __unicode__(self): return date_format(self.day, "DATE_FORMAT")
def edit_date_choice(request, poll_url): """ :param request: :param poll_url: url of poll Takes several dates as the user's input und checks the validity. If the input is valid, for every given date a choice is created and saved. The user is directed to the poll's site. If the input is not valid, the user is directed back for correction. """ current_poll = get_object_or_404(Poll, url=poll_url) if not current_poll.can_edit(request.user, request): return redirect('poll', poll_url) tz_activate('UTC') initial = { 'dates': ','.join(set(list( date_format(localtime(c.date), format='Y-m-d') for c in current_poll.choice_set.order_by('sort_key')))), } if request.method == 'POST': form = DateChoiceCreationForm(request.POST, initial=initial) if form.is_valid(): choices = current_poll.choice_set.all() # List of the Old Ids, used for detection what has to be deleted old_choices_ids = [c.pk for c in choices] new_choices = [] old_choices = [] dates = [] error = False # clean the data for choice in form.cleaned_data['dates'].split(","): try: tz = timezone('UTC') parsed_date = parse_datetime('{} 0:0'.format(choice)) if parsed_date: date = tz.localize(parsed_date) dates.append(date) else: error = True messages.error(_("There was en error interpreting the provided dates and times")) except ValueError: # This will most likely only happen with users turning of JS error = True messages.error(_("There was en error interpreting the provided dates and times")) if not error: for i, datum in enumerate(sorted(dates)): choice_objs = Choice.objects.filter(poll=current_poll, date=datum) if choice_objs: choice_obj = choice_objs[0] old_choices_ids.remove(choice_obj.pk) choice_obj.sort_key = i choice_obj.deleted = False old_choices.append(choice_obj) else: new_choices.append(Choice(text="", date=datum, poll=current_poll, sort_key=i)) with transaction.atomic(): Choice.objects.bulk_create(new_choices) for choice in old_choices: choice.save() Choice.objects.filter(pk__in=old_choices_ids).update(deleted=True) return redirect('poll', poll_url) else: form = DateChoiceCreationForm(initial=initial) return TemplateResponse(request, "poll/choice_creation_date.html", { 'poll': current_poll, 'new_choice': form, 'page': 'Choices', 'is_dt_choice': False, })
def getServicesData(request: 'HttpRequest') -> typing.Dict[str, typing.Any]: # pylint: disable=too-many-locals, too-many-branches, too-many-statements """Obtains the service data dictionary will all available services for this request Arguments: request {HttpRequest} -- request from where to xtract credentials Returns: typing.Dict[str, typing.Any] -- Keys has this: 'services': services, 'ip': request.ip, 'nets': nets, 'transports': validTrans, 'autorun': autorun """ # Session data os: typing.Dict[str, str] = request.os # We look for services for this authenticator groups. User is logged in in just 1 authenticator, so his groups must coincide with those assigned to ds groups = list(request.user.getGroups()) availServicePools = list( ServicePool.getDeployedServicesForGroups( groups, request.user)) # Pass in user to get "number_assigned" to optimize availMetaPools = list(MetaPool.getForGroups( groups, request.user)) # Pass in user to get "number_assigned" to optimize now = getSqlDatetime() # Information for administrators nets = '' validTrans = '' logger.debug('OS: %s', os['OS']) if request.user.isStaff(): nets = ','.join([n.name for n in Network.networksFor(request.ip)]) tt = [] t: Transport for t in Transport.objects.all().prefetch_related('networks'): if t.validForIp(request.ip): tt.append(t.name) validTrans = ','.join(tt) logger.debug('Checking meta pools: %s', availMetaPools) services = [] meta: MetaPool # Preload all assigned user services for this user # Add meta pools data first for meta in availMetaPools: # Check that we have access to at least one transport on some of its children hasUsablePools = False in_use = meta.number_in_use > 0 # False for pool in meta.pools.all(): # if pool.isInMaintenance(): # continue for t in pool.transports.all(): typeTrans = t.getType() if t.getType() and t.validForIp( request.ip) and typeTrans.supportsOs( os['OS']) and t.validForOs(os['OS']): hasUsablePools = True break # if not in_use and meta.number_in_use: # Only look for assignation on possible used # assignedUserService = userServiceManager().getExistingAssignationForUser(pool, request.user) # if assignedUserService: # in_use = assignedUserService.in_use # Stop when 1 usable pool is found if hasUsablePools: break # If no usable pools, this is not visible if hasUsablePools: group = meta.servicesPoolGroup.as_dict if meta.servicesPoolGroup else ServicePoolGroup.default( ).as_dict services.append({ 'id': 'M' + meta.uuid, 'name': meta.name, 'visual_name': meta.visual_name, 'description': meta.comments, 'group': group, 'transports': [{ 'id': 'meta', 'name': 'meta', 'link': html.udsMetaLink(request, 'M' + meta.uuid), 'priority': 0 }], 'imageId': meta.image and meta.image.uuid or 'x', 'show_transports': False, 'allow_users_remove': False, 'allow_users_reset': False, 'maintenance': meta.isInMaintenance(), 'not_accesible': not meta.isAccessAllowed(now), 'in_use': in_use, 'to_be_replaced': None, 'to_be_replaced_text': '', 'custom_calendar_text': meta.calendar_message, }) # Now generic user service svr: ServicePool for svr in availServicePools: # Skip pools that are part of meta pools if svr.is_meta: continue use = str(svr.usage(svr.usage_count)) + '%' trans = [] for t in sorted( svr.transports.all(), key=lambda x: x.priority ): # In memory sort, allows reuse prefetched and not too big array try: typeTrans = t.getType() except Exception: continue if t.validForIp(request.ip) and typeTrans.supportsOs( os['OS']) and t.validForOs(os['OS']): if typeTrans.ownLink: link = reverse('TransportOwnLink', args=('F' + svr.uuid, t.uuid)) else: link = html.udsAccessLink(request, 'F' + svr.uuid, t.uuid) trans.append({ 'id': t.uuid, 'name': t.name, 'link': link, 'priority': t.priority }) # If empty transports, do not include it on list if not trans: continue if svr.image: imageId = svr.image.uuid else: imageId = 'x' # Locate if user service has any already assigned user service for this. Use "pre cached" number of assignations in this pool to optimize in_use = svr.number_in_use > 0 # if svr.number_in_use: # Anotated value got from getDeployedServicesForGroups(...). If 0, no assignation for this user # ads = userServiceManager().getExistingAssignationForUser(svr, request.user) # if ads: # in_use = ads.in_use group = svr.servicesPoolGroup.as_dict if svr.servicesPoolGroup else ServicePoolGroup.default( ).as_dict # Only add toBeReplaced info in case we allow it. This will generate some "overload" on the services toBeReplaced = svr.toBeReplaced( request.user ) if svr.pubs_active > 0 and GlobalConfig.NOTIFY_REMOVAL_BY_PUB.getBool( False) else None # tbr = False if toBeReplaced: toBeReplaced = formats.date_format(toBeReplaced, "SHORT_DATETIME_FORMAT") toBeReplacedTxt = ugettext( 'This service is about to be replaced by a new version. Please, close the session before {} and save all your work to avoid loosing it.' ).format(toBeReplaced) else: toBeReplacedTxt = '' datator = lambda x: x.replace('{use}', use).replace( '{total}', str(svr.max_srvs)) services.append({ 'id': 'F' + svr.uuid, 'name': datator(svr.name), 'visual_name': datator( svr.visual_name.replace('{use}', use).replace('{total}', str(svr.max_srvs))), 'description': svr.comments, 'group': group, 'transports': trans, 'imageId': imageId, 'show_transports': svr.show_transports, 'allow_users_remove': svr.allow_users_remove, 'allow_users_reset': svr.allow_users_reset, 'maintenance': svr.isInMaintenance(), 'not_accesible': not svr.isAccessAllowed(now), 'in_use': in_use, 'to_be_replaced': toBeReplaced, 'to_be_replaced_text': toBeReplacedTxt, 'custom_calendar_text': svr.calendar_message, }) # logger.debug('Services: %s', services) # Sort services and remove services with no transports... services = [ s for s in sorted(services, key=lambda s: s['name'].upper()) if s['transports'] ] autorun = False if len(services) == 1 and GlobalConfig.AUTORUN_SERVICE.getBool( False) and services[0]['transports']: if request.session.get('autorunDone', '0') == '0': request.session['autorunDone'] = '1' autorun = True # return redirect('uds.web.views.service', idService=services[0]['id'], idTransport=services[0]['transports'][0]['id']) return { 'services': services, 'ip': request.ip, 'nets': nets, 'transports': validTrans, 'autorun': autorun }
def iterate_list(self, form_data): cl = self.event.checkin_lists.get(pk=form_data['list']) questions = list(Question.objects.filter(event=self.event, id__in=form_data['questions'])) qs = self._get_queryset(cl, form_data) name_scheme = PERSON_NAME_SCHEMES[self.event.settings.name_scheme] headers = [ _('Order code'), _('Attendee name'), ] if len(name_scheme['fields']) > 1: for k, label, w in name_scheme['fields']: headers.append(_('Attendee name: {part}').format(part=label)) headers += [ _('Product'), _('Price'), _('Checked in'), _('Automatically checked in') ] if not cl.include_pending: qs = qs.filter(order__status=Order.STATUS_PAID) else: qs = qs.filter(order__status__in=(Order.STATUS_PAID, Order.STATUS_PENDING)) headers.append(_('Paid')) if form_data['secrets']: headers.append(_('Secret')) headers.append(_('E-mail')) if self.event.has_subevents: headers.append(pgettext('subevent', 'Date')) headers.append(_('Start date')) headers.append(_('End date')) for q in questions: headers.append(str(q.question)) headers.append(_('Company')) headers.append(_('Voucher code')) headers.append(_('Order date')) headers.append(_('Requires special attention')) headers.append(_('Comment')) yield headers for op in qs: try: ia = op.order.invoice_address except InvoiceAddress.DoesNotExist: ia = InvoiceAddress() last_checked_in = None if isinstance(op.last_checked_in, str): # SQLite last_checked_in = dateutil.parser.parse(op.last_checked_in) elif op.last_checked_in: last_checked_in = op.last_checked_in if last_checked_in and not is_aware(last_checked_in): last_checked_in = make_aware(last_checked_in, UTC) row = [ op.order.code, op.attendee_name or (op.addon_to.attendee_name if op.addon_to else '') or ia.name, ] if len(name_scheme['fields']) > 1: for k, label, w in name_scheme['fields']: row.append( ( op.attendee_name_parts or (op.addon_to.attendee_name_parts if op.addon_to else {}) or ia.name_parts ).get(k, '') ) row += [ str(op.item) + (" – " + str(op.variation.value) if op.variation else ""), op.price, date_format(last_checked_in.astimezone(self.event.timezone), 'SHORT_DATETIME_FORMAT') if last_checked_in else '', _('Yes') if op.auto_checked_in else _('No'), ] if cl.include_pending: row.append(_('Yes') if op.order.status == Order.STATUS_PAID else _('No')) if form_data['secrets']: row.append(op.secret) row.append(op.attendee_email or (op.addon_to.attendee_email if op.addon_to else '') or op.order.email or '') if self.event.has_subevents: row.append(str(op.subevent.name)) row.append(date_format(op.subevent.date_from.astimezone(self.event.timezone), 'SHORT_DATETIME_FORMAT')) if op.subevent.date_to: row.append( date_format(op.subevent.date_to.astimezone(self.event.timezone), 'SHORT_DATETIME_FORMAT') ) else: row.append('') acache = {} if op.addon_to: for a in op.addon_to.answers.all(): # We do not want to localize Date, Time and Datetime question answers, as those can lead # to difficulties parsing the data (for example 2019-02-01 may become Février, 2019 01 in French). if a.question.type in Question.UNLOCALIZED_TYPES: acache[a.question_id] = a.answer else: acache[a.question_id] = str(a) for a in op.answers.all(): # We do not want to localize Date, Time and Datetime question answers, as those can lead # to difficulties parsing the data (for example 2019-02-01 may become Février, 2019 01 in French). if a.question.type in Question.UNLOCALIZED_TYPES: acache[a.question_id] = a.answer else: acache[a.question_id] = str(a) for q in questions: row.append(acache.get(q.pk, '')) row.append(ia.company) row.append(op.voucher.code if op.voucher else "") row.append(op.order.datetime.astimezone(self.event.timezone).strftime('%Y-%m-%d')) row.append(_('Yes') if op.order.checkin_attention or op.item.checkin_attention else _('No')) row.append(op.order.comment or "") yield row
def admin_publish_date(self, obj): if obj.publish_date: return date_format(obj.publish_date) else: return ''
def admin_unsubscribe_date(self, obj): if obj.unsubscribe_date: return date_format(obj.unsubscribe_date) else: return ''
def _get_text_content(self, op: OrderPosition, order: Order, o: dict): ev = op.subevent or order.event if o['content'] == 'other': return o['text'].replace("\n", "<br/>\n") elif o['content'].startswith('meta:'): return ev.meta_data.get(o['content'][5:]) elif o['content'] == 'order': return order.code elif o['content'] == 'item': return str(op.item) elif o['content'] == 'item_description': return str(op.item.description) elif o['content'] == 'organizer': return str(order.event.organizer.name) elif o['content'] == 'organizer_info_text': return str(order.event.settings.organizer_info_text) elif o['content'] == 'secret': return op.secret elif o['content'] == 'variation': return str(op.variation) if op.variation else '' elif o['content'] == 'itemvar': return '{} - {}'.format( op.item, op.variation) if op.variation else str(op.item) elif o['content'] == 'price': return '{} {}'.format(order.event.currency, localize(op.price)) elif o['content'] == 'attendee_name': return op.attendee_name or (op.addon_to.attendee_name if op.addon_to else '') elif o['content'] == 'event_name': return str(ev.name) elif o['content'] == 'event_location': return str(ev.location).replace("\n", "<br/>\n") elif o['content'] == 'event_date': return ev.get_date_from_display(show_times=False) elif o['content'] == 'event_date_range': return ev.get_date_range_display() elif o['content'] == 'event_begin': return ev.get_date_from_display(show_times=True) elif o['content'] == 'event_begin_time': return ev.get_time_from_display() elif o['content'] == 'event_admission': if ev.date_admission: tz = timezone(order.event.settings.timezone) return date_format(ev.date_admission.astimezone(tz), "SHORT_DATETIME_FORMAT") elif o['content'] == 'event_admission_time': if ev.date_admission: tz = timezone(order.event.settings.timezone) return date_format(ev.date_admission.astimezone(tz), "TIME_FORMAT") elif o['content'] == 'invoice_name': try: return order.invoice_address.name except: return "" elif o['content'] == 'invoice_company': try: return order.invoice_address.company except: return "" elif o['content'] == 'addons': return "<br/>".join([ '{} - {}'.format(p.item, p.variation) if p.variation else str(p.item) for p in op.addons.select_related('item', 'variation') ]) return ''
def read_at_end_formatted(self, obj): return formats.date_format(timezone.localtime(obj.read_at_end), 'DSMR_VERBOSE_DATETIME_FORMAT')