예제 #1
0
def create_event(request, calendar_id=None, calendar_slug=None, year=None, month=None, day=None, hour=None, minute=None, redirect=None):
    if calendar_id:
        calendar = get_object_or_404(Calendar, id=calendar_id)
    elif calendar_slug:
        calendar = get_object_or_404(Calendar, slug=calendar_slug)
    starttime = datetime.datetime(year=int(year),month=int(month),day=int(day),hour=int(hour),minute=int(minute))
    endtime = starttime + datetime.timedelta(minutes=30)
    end_recur = endtime + datetime.timedelta(days=8)
    init_values = {
        'start' : starttime,
        'end' : endtime,
        'end_recurring_period' : end_recur
    }
    form = EventForm(data=request.POST or None, initial=init_values)
    if form.is_valid():
        event = form.save(commit=False)
        event.creator = request.user
        event.save()
        calendar.events.add(event)
        next = redirect or reverse('s_event', args=[event.id])
        if 'next' in request.GET:
            next = _check_next_url(request.GET['next']) or next
        return HttpResponseRedirect(next)
    return render_to_response('schedule/create_event.html', {
        "form": form,
        "calendar": calendar
    }, context_instance=RequestContext(request))
예제 #2
0
def showDashboard(request):

    # user not logged in
    try:
        user_email = request.session['outlook_user_email']
        access_token = request.session['outlook_access_token']
    except KeyError:
        pass

    if request.user.is_anonymous():
        return redirect('home')

    else: #logged in
        context = RequestContext(request)

        redirect_uri = request.build_absolute_uri(reverse('gettoken'))
        signin_url = get_signin_url(redirect_uri)

        if request.method == 'POST':
            profile = UserProfile.objects.get(user=request.user)
            user_calendar = Calendar.objects.get_calendar_for_object(profile)
            
            event_form = EventForm(data=request.POST)

            if event_form.is_valid:
                #save event in db
                event = event_form.save()
                #add the event to the users calendar
                user_calendar.events.add(event)
            else:
                HttpResponse(event_form.errors)
        else:
            event_form = EventForm()
        return render(request, 'dashboard/main_dashboard.html', {'event_form' : event_form,'signin_url' : signin_url,})
예제 #3
0
    def test_event_form(self):
        now = datetime.datetime.now()
        data = {'start_0': now.strftime('%Y-%m-%d'),
                'start_1': '00:00',
                'end_0': (now + datetime.timedelta(days=1)).strftime('%Y-%m-%d'),
                'end_1': '00:00',
                'title': u'some title'}
        form = EventForm(data=data)
        validated = form.is_valid()
        self.assertTrue(validated)

        data['end_0'] = (now - datetime.timedelta(days=1)).strftime('%Y-%m-%d')
        form = EventForm(data=data)
        validated = form.is_valid()
        self.assertFalse(validated)
        self.assertEqual(len(form.non_field_errors()), 1)
        self.assertEqual(form.non_field_errors()[0], u"The end time must be later than start time.")

        del data['end_0']
        del data['end_1']
        del data['start_0']
        del data['start_1']
        form = EventForm(data=data)
        validated = form.is_valid()
        self.assertFalse(validated)
        self.assertEqual(len(form.non_field_errors()), 0)
        self.assertEqual(len(form.errors), 2)
        self.assertEqual(len(form.errors['end']), 1)
        self.assertEqual(form.errors['end'][0], u"This field is required.")
        self.assertEqual(len(form.errors['start']), 1)
        self.assertEqual(form.errors['start'][0], u"This field is required.")
예제 #4
0
def today(request):
    """
        This view has to get all the events from today onwards for the current
        user, up to a point (for now its a week), it then must generate two
        event lists: today, and upcoming and send those lists back to the today
        template.
    """
    user = request.user
    print "User is authenticated: " + str(user.is_authenticated())
    print "Getting events for user " + user.username

    if request.method == 'POST':
        print "POST data detected "
        if 'confirm_remove' in request.POST:
            print "Remove request detected"
            event_id = request.POST['event_id']
            event = Event.objects.get(pk=event_id)
            event.delete()
        if 'add_event' in request.POST:
            print "Add request detected"
            event_form = EventForm(request.POST)
            if event_form.is_valid():
                print "Its valid"
                new_event = event_form.save(commit=False)
                new_event.owner = request.user
                new_event.save()
                del event_form
                print "Saved"
            else:
                print "Its not valid"

    try:
        event_form
    except:
        event_form = EventForm()

    today = datetime.now().date()
    today_plus_7 = today + timedelta(days=7)

    events = Event.objects.filter(owner=user.pk, date__gte=today, date__lte=today_plus_7).order_by('date', 'begin_time')

    print "Total number of events: " + str(events.count())

    todays_events = events.filter(date=today)
    incoming_events = events.exclude(date=today)
    return render_to_response('today.templ',
                              {'todays_events': todays_events,
                               'incoming_events': incoming_events,
                               'event_form': event_form},
                              context_instance=RequestContext(request))
예제 #5
0
def ajax_create_event(request, calendar_slug):
    if not request.is_ajax() or not request.POST:
        return HttpResponseBadRequest()
    form = EventForm(data=request.POST)
    if form.is_valid():
        event = form.save(commit=False)
        import pdb; pdb.set_trace()
        event.creator = request.user
        calendar = get_object_or_404(Calendar, slug=calendar_slug)
        event.calendar = calendar
        event.save()
        return HttpResponse()
    else:
        return HttpResponseBadRequest(json.dumps(form.errors), content_type="application/json")
예제 #6
0
def create_or_edit_event(request, calendar_id=None, event_id=None, redirect=None):
    """
    This function, if it recieves a GET request or if given an invalid form in a
    POST request it will generate the following response

    * Template: schedule/create_event.html
    * Context:
        * form: an instance of EventForm
        * calendar: a Calendar with id=calendar_id

    If this form recieves an event_id it will edit the event with that id, if it
    recieves a calendar_id and it is creating a new event it will add that event
    to the calendar with the id calendar_id

    If it is given a valid form in a POST request it will redirect with one of
    three options, in this order

    # Try to find a 'next' GET variable
    # If the key word argument redirect is set
    # Lastly redirect to the event detail of the recently create event
    """
    instance = None
    if event_id:
        instance = get_object_or_404(Event, id=event_id)
    calendar = None
    if calendar_id is not None:
        calendar = get_object_or_404(Calendar, id=calendar_id)
    if instance:
        form = EventForm(data=request.POST or None, instance=instance)
    else:
        starttime = datetime.datetime.now()
        endtime = starttime + datetime.timedelta(minutes=60)
        end_recur = endtime + datetime.timedelta(days=8)
        init_values = {"start": starttime, "end": endtime, "end_recurring_period": end_recur}
        form = EventForm(data=request.POST or None, initial=init_values)
    if form.is_valid():
        event = form.save(commit=False)
        if instance is None:
            event.creator = request.user
        event.save()
        if calendar is not None and instance is None:
            calendar.events.add(event)
        next = redirect or reverse("s_event", args=[event.id])
        if "next" in request.GET:
            next = _check_next_url(request.GET["next"]) or next
        return HttpResponseRedirect(next)
    return render_to_response(
        "schedule/create_event.html", {"form": form, "calendar": calendar}, context_instance=RequestContext(request)
    )
예제 #7
0
def create_event(request):
    if request.method not in ['POST', 'GET']:
        return Error.http405()
    elif request.method == 'GET':
        form = EventForm()
        return render(request, 'event.htm', {'form': form})
    elif request.method == 'POST':
        form = EventForm(request.POST)
        if form.is_valid():
            try:
                e = Event(name=form.cleaned_data['name'],
                          color=form.cleaned_data['color'],
                          count=form.cleaned_data['count'],
                          created=datetime.now())
                e.save()
                return Message.object_created(e.id)
            except Exception as e:
                return Error.debug(str(e))
예제 #8
0
def create_or_edit_event(request, calendar_id=None, event_id=None, redirect=None):
    """
    This function, if it receives a GET request or if given an invalid form in a
    POST request it will generate the following response

    * Template: schedule/create_event.html
    * Context:
        * form: an instance of EventForm
        * calendar: a Calendar with id=calendar_id

    If this form receives an event_id it will edit the event with that id, if it
    recieves a calendar_id and it is creating a new event it will add that event
    to the calendar with the id calendar_id

    If it is given a valid form in a POST request it will redirect with one of
    three options, in this order

    # Try to find a 'next' GET variable
    # If the key word argument redirect is set
    # Lastly redirect to the event detail of the recently create event
    """
    instance = None
    if event_id:
        instance = get_object_or_404(Event, id=event_id)
    calendar = None
    if calendar_id is not None:
        calendar = get_object_or_404(Calendar, id=calendar_id)
    form = EventForm(data=request.POST or None, instance=instance, hour24=True)
    if form.is_valid():
        event = form.save(commit=False)
        if instance is None:
            event.creator = request.user
        event.save()
        if calendar is not None and instance is None:
            calendar.events.add(event)
        next = redirect or reverse('s_event', args=[event.id])
        if 'next' in request.GET:
            next = _check_next_url(request.GET['next']) or next
        return HttpResponseRedirect(next)
    return render_to_response('schedule/create_event.html', {
        "form": form,
        "calendar": calendar
    }, context_instance=RequestContext(request))
예제 #9
0
def create_or_edit_event(request,
                         calendar_id=None,
                         event_id=None,
                         redirect=None):
    """
    This function, if it recieves a GET request or if given an invalid form in a
    POST request it will generate the following response

    * Template: schedule/create_event.html
    * Context:
        * form: an instance of EventForm
        * calendar: a Calendar with id=calendar_id

    If this form recieves an event_id it will edit the event with that id, if it
    recieves a calendar_id and it is creating a new event it will add that event
    to the calendar with the id calendar_id

    If it is given a valid form in a POST request it will redirect with one of
    three options, in this order

    # Try to find a 'next' GET variable
    # If the key word argument redirect is set
    # Lastly redirect to the event detail of the recently create event
    """
    instance = None
    if event_id:
        instance = get_object_or_404(Event, id=event_id)
    calendar = None
    if calendar_id is not None:
        calendar = get_object_or_404(Calendar, id=calendar_id)
    if instance:
        form = EventForm(data=request.POST or None, instance=instance)
    else:
        starttime = datetime.datetime.now()
        endtime = starttime + datetime.timedelta(minutes=60)
        end_recur = endtime + datetime.timedelta(days=8)
        init_values = {
            'start': starttime,
            'end': endtime,
            'end_recurring_period': end_recur
        }
        form = EventForm(data=request.POST or None, initial=init_values)
    if form.is_valid():
        event = form.save(commit=False)
        if instance is None:
            event.creator = request.user
        event.save()
        if calendar is not None and instance is None:
            calendar.events.add(event)
        next = redirect or reverse('s_event', args=[event.id])
        if 'next' in request.GET:
            next = _check_next_url(request.GET['next']) or next
        return HttpResponseRedirect(next)
    return render_to_response('schedule/create_event.html', {
        "form": form,
        "calendar": calendar
    },
                              context_instance=RequestContext(request))
예제 #10
0
def calendar_initialize(request):
 
    today = time_zone_user(request.user)
    if request.user.is_teacher:
        teacher = Teacher.objects.get(user=request.user)
        relationships = Relationship.objects.filter(parcours__teacher=teacher, date_limit__gte=today).exclude(date_limit=None)
        parcourses = Parcours.objects.filter(teacher=teacher,is_trash=0)
        calendars = Calendar.objects.filter(user=request.user)
        form = EventForm(request.user, request.POST or None)        
        nb_teacher_level = teacher.levels.count()
        communications = Communication.objects.values('id', 'subject', 'texte').filter(active=1)
        context = {'form': form, 'relationships': relationships, 'parcourses': parcourses, 'calendars': calendars,'nb_teacher_level' :nb_teacher_level , 'communications' :  communications ,
                   'teacher': teacher}

    else:
        student = Student.objects.get(user=request.user.id)

 
        relationships = Relationship.objects.filter(Q(is_publish = 1)|Q(start__lte=today), students=student, date_limit__gte=today).order_by("date_limit")
        exercise_tab = []
        for r in relationships:
            if r not in exercise_tab:
                exercise_tab.append(r.exercise)
        num = 0
        for e in exercise_tab :
            if Studentanswer.objects.filter(student=student, exercise = e).count() > 0 :
                num += 1

        exercises = []
        studentanswers = Studentanswer.objects.filter(student = student)
        for studentanswer in studentanswers:
            if not studentanswer.exercise in exercises:
                exercises.append(studentanswer.exercise)
      
        relationships_in_late = Relationship.objects.filter(Q(is_publish = 1)|Q(start__lte=today), students=student, is_evaluation=0, date_limit__lt=today).exclude(exercise__in=exercises).order_by("date_limit")

        nb_relationships = Relationship.objects.filter(Q(is_publish = 1)|Q(start__lte=today), students=student,  date_limit__gte=today).count()


        try :
            ratio = int(num/nb_relationships*100)
        except :
            ratio = 0

        ratiowidth = int(0.9*ratio)
        student = Student.objects.get(user=request.user)
        parcours = Parcours.objects.filter(students = student,is_trash=0)
        context = {'student' : student ,    'relationships' : relationships ,    'ratio' : ratio ,  'ratiowidth' : ratiowidth ,       'relationships_in_late' : relationships_in_late ,    } 

    return render(request, "schedule/base.html" , context )
예제 #11
0
def create_event(request,
                 calendar_id,
                 year,
                 month,
                 day,
                 hour,
                 minute,
                 redirect=None):
    calendar = get_object_or_404(Calendar, id=calendar_id)
    starttime = datetime.datetime(year=int(year),
                                  month=int(month),
                                  day=int(day),
                                  hour=int(hour),
                                  minute=int(minute))
    endtime = starttime + datetime.timedelta(minutes=30)
    end_recur = endtime + datetime.timedelta(days=8)
    init_values = {
        'start': starttime,
        'end': endtime,
        'end_recurring_period': end_recur
    }
    form = EventForm(data=request.POST or None, initial=init_values)
    if form.is_valid():
        event = form.save(commit=False)
        event.creator = request.user
        event.save()
        calendar.events.add(event)
        next = redirect or reverse('s_event', args=[event.id])
        if 'next' in request.GET:
            next = _check_next_url(request.GET['next']) or next
        return HttpResponseRedirect(next)
    return render_to_response('schedule/create_event.html', {
        "form": form,
        "calendar": calendar
    },
                              context_instance=RequestContext(request))
예제 #12
0
def today(request):
    """
        This view has to get all the events from today onwards for the current
        user, up to a point (for now its a week), it then must generate two
        event lists: today, and upcoming and send those lists back to the today
        template.
    """
    user = request.user
    print "User is authenticated: " + str(user.is_authenticated())
    print "Getting events for user " + user.username

    if request.method == 'POST':
        print "POST data detected "
        if 'confirm_remove' in request.POST:
            print "Remove request detected"
            event_id = request.POST['event_id']
            event = Event.objects.get(pk=event_id)
            event.delete()
        if 'add_event' in request.POST:
            print "Add request detected"
            event_form = EventForm(request.POST)
            if event_form.is_valid():
                print "Its valid"
                new_event = event_form.save(commit=False)
                new_event.owner = request.user
                new_event.save()
                del event_form
                print "Saved"
            else:
                print "Its not valid"

    try:
        event_form
    except:
        event_form = EventForm()

    today = datetime.now().date()
    today_plus_7 = today + timedelta(days=7)

    events = Event.objects.filter(owner=user.pk,
                                  date__gte=today,
                                  date__lte=today_plus_7).order_by(
                                      'date', 'begin_time')

    print "Total number of events: " + str(events.count())

    todays_events = events.filter(date=today)
    incoming_events = events.exclude(date=today)
    return render_to_response('today.templ', {
        'todays_events': todays_events,
        'incoming_events': incoming_events,
        'event_form': event_form
    },
                              context_instance=RequestContext(request))
예제 #13
0
def create_or_edit_event(request, calendar_slug, event_id=None, next=None,
    template_name='schedule/create_event.html'):
    """
    This function, if it receives a GET request or if given an invalid form in a
    POST request it will generate the following response

    Template:
        schedule/create_event.html
    
    Context Variables:
        
    form:
        an instance of EventForm
    
    calendar: 
        a Calendar with id=calendar_id

    if this function gets a GET request with ``year``, ``month``, ``day``,
    ``hour``, ``minute``, and ``second`` it will auto fill the form, with
    the date specifed in the GET being the start and 30 minutes from that
    being the end.

    If this form receives an event_id it will edit the event with that id, if it
    recieves a calendar_id and it is creating a new event it will add that event
    to the calendar with the id calendar_id

    If it is given a valid form in a POST request it will redirect with one of
    three options, in this order

    # Try to find a 'next' GET variable
    # If the key word argument redirect is set
    # Lastly redirect to the event detail of the recently create event
    """
    date = coerce_date_dict(request.GET)
    initial_data = None
    if date:
        try:
            start = datetime.datetime(**date)
            initial_data = {
                "start": start,
                "end": start + datetime.timedelta(minutes=30)
            }
        except TypeError:
            raise Http404
        except ValueError:
            raise Http404
    
    instance = None
    if event_id is not None:
        instance = get_object_or_404(Event, id=event_id)
    
    calendar = get_object_or_404(Calendar, slug=calendar_slug)
    
    form = EventForm(data=request.POST or None, instance=instance, 
        hour24=True, initial=initial_data)
    
    if form.is_valid():
        event = form.save(commit=False)
        if instance is None:
            event.creator = request.user
            event.calendar = calendar
        event.save()
        next = next or reverse('event', args=[event.id])
        if 'next' in request.GET:
            next = check_next_url(request.GET['next']) or next
        return HttpResponseRedirect(next)
    
    return render_to_response(template_name, {
        "form": form,
        "calendar": calendar
    }, context_instance=RequestContext(request))
예제 #14
0
    def test_event_form(self):
        now = datetime.datetime.now()
        data = {
            "start_0": now.strftime("%Y-%m-%d"),
            "start_1": "00:00",
            "end_0": (now + datetime.timedelta(days=1)).strftime("%Y-%m-%d"),
            "end_1": "00:00",
            "title": "some title",
        }
        form = EventForm(data=data)
        validated = form.is_valid()
        self.assertTrue(validated)

        data["end_0"] = (now - datetime.timedelta(days=1)).strftime("%Y-%m-%d")
        form = EventForm(data=data)
        validated = form.is_valid()
        self.assertFalse(validated)
        self.assertEqual(len(form.non_field_errors()), 1)
        self.assertEqual(
            form.non_field_errors()[0], "The end time must be later than start time."
        )

        del data["end_0"]
        del data["end_1"]
        del data["start_0"]
        del data["start_1"]
        form = EventForm(data=data)
        validated = form.is_valid()
        self.assertFalse(validated)
        self.assertEqual(len(form.non_field_errors()), 0)
        self.assertEqual(len(form.errors), 2)
        self.assertEqual(len(form.errors["end"]), 1)
        self.assertEqual(form.errors["end"][0], "This field is required.")
        self.assertEqual(len(form.errors["start"]), 1)
        self.assertEqual(form.errors["start"][0], "This field is required.")
예제 #15
0
def create_or_edit_event(request, calendar_slug, event_id=None, next=None):

    date = coerce_date_dict(request.GET)
    initial_data = None
    if date:
        try:
            start = datetime.datetime(**date)
            initial_data = {
                "start": start,
                "end": start + datetime.timedelta(minutes=30)
            }
        except TypeError:
            raise Http404
        except ValueError:
            raise Http404

    instance = None
    if event_id is not None:
        instance = get_object_or_404(Event, id=event_id)

    calendar = get_object_or_404(Calendar, slug=calendar_slug)
    data = request.POST.copy()
    if data:
        data["title"] = data["oncall"] + "," + data["fallback"]
    form = EventForm(data=data or None,
                     instance=instance,
                     initial=initial_data)
    users = User.objects.all()
    groups = Group.objects.all()
    if request.method == 'POST':
        if form.is_valid():
            event = form.save(commit=False)
            if instance is None:
                event.creator = request.user
                event.calendar = calendar
            event.save()
            return HttpResponseRedirect(
                reverse('calendar_details',
                        kwargs={'calendar_slug': calendar.slug}))
    if instance is not None:
        officers = instance.title.split(",")
        data["oncall"] = officers[0]
        data["fallback"] = officers[1]
        data["start_ymd"] = instance.start.date().isoformat()
        data["start_hour"] = instance.start.time().strftime("%H:%M")
        data["end_ymd"] = instance.end.date().isoformat()
        data["end_hour"] = instance.end.time().strftime("%H:%M")
        if instance.end_recurring_period:
            data["recurr_ymd"] = instance.end_recurring_period.date(
            ).isoformat()
        data["description"] = instance.description
        data["rule"] = (instance.rule and instance.rule.id) or ""

    next = get_next_url(request, next)
    context = {
        "data": data,
        "calendar": calendar,
        "next": next,
        "users": users,
        "groups": groups,
        "form": form
    }
    template = 'event/edit.html'

    return render(request, template, context)
예제 #16
0
    def test_event_form(self):
        now = datetime.datetime.now()
        data = {
            'start_0': now.strftime('%Y-%m-%d'),
            'start_1': '00:00',
            'end_0': (now + datetime.timedelta(days=1)).strftime('%Y-%m-%d'),
            'end_1': '00:00',
            'title': 'some title'
        }
        form = EventForm(data=data)
        validated = form.is_valid()
        self.assertTrue(validated)

        data['end_0'] = (now - datetime.timedelta(days=1)).strftime('%Y-%m-%d')
        form = EventForm(data=data)
        validated = form.is_valid()
        self.assertFalse(validated)
        self.assertEqual(len(form.non_field_errors()), 1)
        self.assertEqual(form.non_field_errors()[0],
                         "The end time must be later than start time.")

        del data['end_0']
        del data['end_1']
        del data['start_0']
        del data['start_1']
        form = EventForm(data=data)
        validated = form.is_valid()
        self.assertFalse(validated)
        self.assertEqual(len(form.non_field_errors()), 0)
        self.assertEqual(len(form.errors), 2)
        self.assertEqual(len(form.errors['end']), 1)
        self.assertEqual(form.errors['end'][0], "This field is required.")
        self.assertEqual(len(form.errors['start']), 1)
        self.assertEqual(form.errors['start'][0], "This field is required.")