Example #1
0
    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]]
Example #2
0
    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)
Example #3
0
 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
     )
Example #4
0
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
Example #5
0
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/')
Example #6
0
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
Example #7
0
    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)
Example #9
0
    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>"))
Example #11
0
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)
Example #12
0
    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">&nbsp;</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 = '&nbsp;'

        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 = '&nbsp;'

        return footer % (previous_content, next_content)
Example #13
0
 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"]
Example #14
0
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
Example #15
0
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)
Example #16
0
    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 !")
Example #17
0
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
Example #19
0
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})
Example #20
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/')
Example #21
0
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]
Example #23
0
 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)
Example #24
0
 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'),
     )
Example #25
0
 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
Example #26
0
 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'),}
Example #27
0
    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()
Example #28
0
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],
            }
Example #29
0
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)})
Example #30
0
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]
            }
Example #31
0
 def __str__(self):
     return date_format(self.value, "SHORT_DATE_FORMAT")
Example #32
0
 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")
Example #33
0
 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)
Example #34
0
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
    }
Example #35
0
    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
Example #36
0
 def __unicode__(self):
     return u'{} | {}'.format(
         self.course.title,
         formats.date_format(self.start_date, 'SHORT_DATETIME_FORMAT'))
Example #37
0
 }),
 ("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()
 }),
Example #38
0
 def value(self, value):
     if value:
         return date_format(value, format="SHORT_DATETIME_FORMAT")
     return None
Example #39
0
    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
Example #40
0
    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
Example #41
0
    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
        )
Example #42
0
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 ''
Example #44
0
 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 "")
Example #45
0
 def __unicode__(self):
     return u'{} | {}'.format(
         self.meeting_type.title,
         formats.date_format(self.start_date, "SHORT_DATETIME_FORMAT"))
Example #46
0
    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)
Example #47
0
    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
Example #48
0
    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")
Example #49
0
 def __unicode__(self):
     return u'%s - %s (%s)' % (self.deadline.assignment_group, self.number,
                               date_format(self.time_of_delivery,
                                           "DATETIME_FORMAT"))
Example #50
0
    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)
Example #51
0
 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"))
Example #52
0
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]
            }
Example #53
0
 def __unicode__(self):
     return date_format(self.day, "DATE_FORMAT")
Example #54
0
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,
    })
Example #55
0
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
    }
Example #56
0
    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
Example #57
0
 def admin_publish_date(self, obj):
     if obj.publish_date:
         return date_format(obj.publish_date)
     else:
         return ''
Example #58
0
 def admin_unsubscribe_date(self, obj):
     if obj.unsubscribe_date:
         return date_format(obj.unsubscribe_date)
     else:
         return ''
Example #59
0
 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 ''
Example #60
0
 def read_at_end_formatted(self, obj):
     return formats.date_format(timezone.localtime(obj.read_at_end),
                                'DSMR_VERBOSE_DATETIME_FORMAT')