Beispiel #1
0
    def test_create_from_import_person(self):
        ip = ImportPerson(vorname='Brian', nachname='Cohen')
        p = Person.create_from_import_person(ip)
        self.assertEqual(p, self.p1)

        ip.vorname = 'Eric'
        p = Person.create_from_import_person(ip)
        self.assertNotEqual(p, self.p1)
Beispiel #2
0
    def test_create_from_import_person(self):
        ip = ImportPerson(vorname='Brian', nachname='Cohen')
        p = Person.create_from_import_person(ip)
        self.assertEqual(p, self.p)

        ip.vorname='Eric'
        p = Person.create_from_import_person(ip)
        self.assertNotEqual(p, self.p)
Beispiel #3
0
    def test_replace_veranstalter(self):
        # when
        Person.replace_veranstalter(self.p4, self.p3)

        # then
        self.assertFalse(Person.veranstaltungen(self.p4).exists())
        self.assertEqual(Person.veranstaltungen(self.p3).count(), 1)
        self.assertEqual(AlternativVorname.objects.get().vorname, self.p4.vorname)
        self.assertEqual(AlternativVorname.objects.get().person, self.p3)
Beispiel #4
0
    def post(self, request, *args, **kwargs):
        id_old = request.POST['id_old']
        id_new = request.POST['id_new']

        old_person = Person.objects.get(pk=id_old)
        new_person = Person.objects.get(pk=id_new)

        Person.replace_veranstalter(new_person, old_person)
        if not Person.is_veranstalter(new_person):
            new_person.delete()

        return HttpResponseRedirect(reverse('import_vv_edit_users'))
Beispiel #5
0
    def get_id(self):
        try:
            next_id = Person.persons_to_edit().filter(
                id__gt=self.object.id).order_by("id")[0].id
        except (Person.DoesNotExist, IndexError):
            next_id = None
        try:
            prev_id = Person.persons_to_edit().filter(
                id__lt=self.object.id).order_by("-id")[0].id
        except (Person.DoesNotExist, IndexError):
            prev_id = None

        return next_id, prev_id
Beispiel #6
0
    def get_context_data(self, **kwargs):
        context = super(SimilarNamesView, self).get_context_data(**kwargs)
        context['new_vorname'] = self.object.vorname
        context['new_nachname'] = self.object.nachname

        vorname = context['new_vorname'].split(' ')[0]
        nachname = context['new_nachname']

        context['similar_person'] = Person.persons_with_similar_names(
            vorname, nachname)
        context['old_veranstaltungen'] = Person.veranstaltungen(
            context['similar_person'])
        context['new_veranstaltungen'] = Person.veranstaltungen(
            context['person_new'])
        return context
Beispiel #7
0
    def has_similar_name(self):
        vorname = self.object.vorname.split(' ')[0]
        nachname = self.object.nachname
        similar_persons = Person.persons_with_similar_names(vorname, nachname)

        if similar_persons.exists():
            if self.object == similar_persons.get():
                return False
            else:
                return similar_persons.count() > 0
Beispiel #8
0
def import_vv_edit(request):
    data = {}

    if request.method in ('HEAD', 'GET'):
        # VV zur Auswahl von Vorlesungen anzeigen
        data['semester'] = Semester.objects.all()
        try:
            data['vv'] = ImportCategory.objects.get(parent=None)
        except ImportCategory.DoesNotExist:
            messages.error(request, 'Bevor zu importierende Veranstaltungen ausgewählt werden ' +
                           'können, muss zunächst eine VV-XML-Datei hochgeladen werden.')
            return HttpResponseRedirect(reverse('import_vv'))
        return render(request, 'intern/import_vv_edit.html', data)

    else:
        # gewählte Veranstaltungen übernehmen und Personen zuordnen

        # Liste der ausgewählten Veranstaltungen holen
        v_str = [ele[1] for ele in request.POST.lists() if ele[0] == 'v']
        if not len(v_str):
            messages.warning(request, u'Es wurden keine Veranstaltungen für den Import ausgewählt!')
            return HttpResponseRedirect(reverse('import_vv_edit'))
        v_ids = [int(ele) for ele in v_str[0]] # IDs von unicode nach int konvertieren

        # ausgewähltes Semester holen
        try:
            semester = Semester.objects.get(semester=request.POST['semester'])
        except (Semester.DoesNotExist, KeyError):
            return HttpResponseRedirect(reverse('import_vv_edit'))

        # Veranstaltungen übernehmen
        data['v'] = []
        for iv in ImportVeranstaltung.objects.filter(id__in=v_ids):
            try:
                v = Veranstaltung.objects.create(typ=iv.typ, name=iv.name, semester=semester,
                                                 lv_nr=iv.lv_nr, grundstudium=False, evaluieren=True)
            except IntegrityError:
                # Veranstaltung wurde bereits importiert (kann vorkommen, wenn sie im VV in
                # mehreren Kategorien vorkommt)
                continue

            # Accounts für Veranstalter erstellen, falls nötig
            for ip in iv.veranstalter.all():
                p = Person.create_from_import_person(ip)
                v.veranstalter.add(p)

        # temporäre Daten löschen
        vv_parser.parse_vv_clear()
        return HttpResponseRedirect(reverse('import_vv_edit_users'))
Beispiel #9
0
def import_vv_edit(request):
    """Zuständig für die Bearbeitung des importierten XMLs."""
    data = {}

    if request.method in ('HEAD', 'GET'):
        # VV zur Auswahl von Vorlesungen anzeigen
        data['semester'] = Semester.objects.all()
        category_tree = ImportCategory.objects.all().prefetch_related('ivs')

        # prüfen, ob die Liste leer ist
        if category_tree:
            # erste root-Kategorie ignorieren
            data['vv'] = category_tree[1:]

            remaining_close_tags = ImportCategory.objects.all().aggregate(
                sum_lvl=Sum('rel_level'))
            if remaining_close_tags['sum_lvl'] is None:
                data['remaining_close_tags'] = 0
            else:
                data['remaining_close_tags'] = remaining_close_tags['sum_lvl']
            return render(request, 'intern/import_vv_edit.html', data)

        else:
            messages.error(
                request,
                'Bevor zu importierende Veranstaltungen ausgewählt werden ' +
                'können, muss zunächst eine VV-XML-Datei hochgeladen werden.')

            return HttpResponseRedirect(reverse('import_vv'))
    else:
        # gewählte Veranstaltungen übernehmen und Personen zuordnen
        # Liste der ausgewählten Veranstaltungen holen
        v_str = [ele[1] for ele in request.POST.lists() if ele[0] == 'v']
        if not len(v_str):
            messages.warning(
                request,
                'Es wurden keine Veranstaltungen für den Import ausgewählt!')
            return HttpResponseRedirect(reverse('import_vv_edit'))

        # IDs von unicode nach int konvertieren
        v_ids = [int(ele) for ele in v_str[0]]

        # ausgewähltes Semester holen
        try:
            semester = Semester.objects.get(semester=request.POST['semester'])
        except (Semester.DoesNotExist, KeyError):
            return HttpResponseRedirect(reverse('import_vv_edit'))

        # Veranstaltungen übernehmen
        data['v'] = []
        for iv in ImportVeranstaltung.objects.filter(id__in=v_ids):
            try:
                v = Veranstaltung.objects.create(
                    typ=iv.typ,
                    name=iv.name,
                    status=Veranstaltung.STATUS_ANGELEGT,
                    semester=semester,
                    lv_nr=iv.lv_nr,
                    grundstudium=False,
                    evaluieren=True)
            except IntegrityError:
                # Veranstaltung wurde bereits importiert (kann vorkommen, wenn sie in mehreren Kategorien auftaucht.)
                continue

            # Accounts für Veranstalter erstellen, falls nötig
            for ip in iv.veranstalter.all():
                p = Person.create_from_import_person(ip)
                v.veranstalter.add(p)

        # temporäre Daten löschen
        vv_parser.parse_vv_clear()
        return HttpResponseRedirect(reverse('import_vv_edit_users'))
Beispiel #10
0
 def get_queryset(self):
     return Person.persons_to_edit()
Beispiel #11
0
    def has_similar_name(self):
        vorname = self.object.vorname.split(' ')[0]
        nachname = self.object.nachname
        similar_persons = Person.persons_with_similar_names(vorname, nachname)

        return similar_persons.count() > 0
Beispiel #12
0
    def test_is_veranstalter(self):
        is_veranstalter1 = Person.is_veranstalter(self.p1)
        is_veranstalter2 = Person.is_veranstalter(self.p2)

        self.assertTrue(is_veranstalter1)
        self.assertFalse(is_veranstalter2)
Beispiel #13
0
 def test_veranstaltungen(self):
     veranstaltungen = Person.veranstaltungen(self.p1)
     veranstalter_name = veranstaltungen.filter(veranstalter=self.p1)[0].veranstalter.get().full_name()
     self.assertEqual(veranstaltungen.count(), 1)
     self.assertEqual(self.p1.full_name(), veranstalter_name)
Beispiel #14
0
 def test_persons_with_similar_names(self):
     similar_persons = Person.persons_with_similar_names('Test', 'Tester')
     self.assertEqual(similar_persons.count(), 1)
     self.assertTrue(similar_persons.filter(vorname='Test').exists())
Beispiel #15
0
 def test_all_edited_persons(self):
     edited_persons = Person.all_edited_persons()
     self.assertEqual(edited_persons.count(), 1)
     self.assertTrue(edited_persons.filter(email='[email protected]', geschlecht='m').exists())
Beispiel #16
0
 def test_persons_to_edit(self):
     to_edit_persons = Person.persons_to_edit(semester=self.s1)
     self.assertEqual(to_edit_persons.count(), 1)
     self.assertTrue(to_edit_persons.filter(vorname='Brian').exists())