Ejemplo n.º 1
0
    def _maak_leden(self):
        """
            Maak voor elke vereniging een aantal leden aan: een mix van alle wedstrijdklassen en boogtypen.

            Aspirant <13, Aspirant 13-14, Cadet 15-17, Junior 18-20, Senior 21-49, Master 50-59, Veteraan 60+
        """

        huidige_jaar = timezone.now().year
        lid_sinds_datum = datetime.date(year=huidige_jaar - 1,
                                        month=11,
                                        day=12)

        soorten = [
            # wedstrijdleeftijd, geslacht, voornaam, boogtype, account
            (10, 'M', 'Asp10', 'R', False),
            (10, 'V', 'Asp10', 'R', False),
            (11, 'M', 'Asp11', 'R', False),
            (12, 'V', 'Asp12', 'R', False),
            (13, 'M', 'Asp13', 'R', False),
            (14, 'M', 'Cad14', 'R', False),
            (14, 'M', 'Cad14b', 'C', False),
            (14, 'M', 'Cad15', 'c',
             False),  # kleine letter: geen voorkeur voor de competitie
            (15, 'V', 'Cad15', 'R', False),
            (15, 'M', 'Cad15b', 'BB', False),
            (15, 'V', 'Cad15b', 'C', False),
            (16, 'M', 'Cad16', 'R', False),
            (16, 'M', 'Cad16b', 'C', False),
            (16, 'M', 'Cad16c', 'BB', False),
            (17, 'V', 'Cad17', 'R', True),  # account
            (17, 'V', 'Cad17b', 'C', False),
            (17, 'V', 'Cad17c', 'BB', False),
            (18, 'M', 'Jun18', 'R', False),
            (18, 'M', 'Jun18b', 'C', False),
            (18, 'M', 'Jun18c', 'BB', False),
            (18, 'V', 'Jun18', 'BB', False),
            (19, 'V', 'Jun19', 'R', False),
            (19, 'V', 'Jun19b', 'C', True),  # account
            (20, 'M', 'Jun20', 'R', False),
            (20, 'M', 'Jun20b', 'LB', False),
            (21, 'V', 'Sen21', 'R', False),
            (21, 'V', 'Sen21b', 'C', False),
            (22, 'M', 'Sen22', 'R', False),
            (22, 'M', 'Sen22b', 'C', False),
            (22, 'M', 'Sen23', 'r',
             False),  # kleine letter: geen voorkeur voor de competitie
            (31, 'V', 'Sen31', 'R', False),
            (32, 'M', 'Sen32', 'C', False),
            (32, 'M', 'Sen32b', 'BB', True),  # account
            (33, 'V', 'Sen33', 'R', False),
            (33, 'V', 'Sen33b', 'BB', False),
            (34, 'M', 'Sen34', 'LB', True),  # Sen34 = HWL
            (35, 'V', 'Sen35', 'R', False),
            (36, 'M', 'Sen36', 'C', False),
            (36, 'M', 'Sen36b', 'BB', False),
            (37, 'V', 'Sen37', 'R', False),
            (38, 'M', 'Sen38', 'LB', False),
            (39, 'V', 'Sen39', 'R', True),  # Sen39 = BKO/RKO/RCL
            (40, 'M', 'Sen40', 'C', False),
            (41, 'V', 'Sen41', 'R', False),
            (42, 'M', 'Sen42', 'R', False),
            (42, 'M', 'Sen42b', 'C', False),
            (49, 'V', 'Sen49', 'R', False),
            (49, 'V', 'Sen49b', 'BB', False),
            (50, 'M', 'Mas50', 'R', True),  # Mas50 = SEC
            (51, 'V', 'Mas51', 'R', True),  # account
            (51, 'V', 'Mas51b', 'C', False),
            (51, 'V', 'Mas52', 'r',
             False),  # kleine letter: geen voorkeur voor de competitie
            (59, 'M', 'Mas59', 'R', False),
            (59, 'M', 'Mas59b', 'LB', False),
            (60, 'V', 'Vet60', 'R', False),
            (60, 'V', 'Vet60b', 'C', False),
            (60, 'V', 'Vet60c', 'LB', True),  # account
            (61, 'M', 'Vet61', 'C', False),
            (61, 'M', 'Vet61b', 'C', False),
            (80, 'V', 'Vet80', 'R', False),
        ]

        geslacht_voornaam2boogtype = dict()
        for _, geslacht, voornaam, boogtype, _ in soorten:
            try:
                _ = geslacht_voornaam2boogtype[geslacht + voornaam]
            except KeyError:
                geslacht_voornaam2boogtype[geslacht + voornaam] = boogtype
            else:
                raise IndexError(
                    'TestData: combinatie geslacht %s + voornaam %s komt meerdere keren voor'
                    % (geslacht, voornaam))  # pragma: no cover
        # for

        # maak voor elke vereniging een paar accounts aan
        lid_nr = 300000
        bulk = list()
        for ver in self.vereniging.values():
            self.regio_ver_nrs[ver.regio.regio_nr] = ver.ver_nr

            for _, _, voornaam, _, maak_account in soorten:
                lid_nr += 1

                if maak_account:
                    account = Account(username=str(lid_nr),
                                      otp_code=self.OTP_CODE,
                                      otp_is_actief=True)
                    account.set_password(self.WACHTWOORD)
                    bulk.append(account)

                    if len(bulk) > 100:  # pragma: no branch
                        Account.objects.bulk_create(bulk)

                        # maak e-mails aan
                        bulk2 = list()
                        for account in bulk:
                            # let op: e-mailadres moet overeenkomen met het Sporter.email
                            email = AccountEmail(
                                account=account,
                                email_is_bevestigd=True,
                                bevestigde_email='*****@*****.**' %
                                account.username)
                            bulk2.append(email)
                        # for

                        AccountEmail.objects.bulk_create(bulk2)
                        del bulk2

                        bulk = list()
            # for
        # for

        if len(bulk) > 0:  # pragma: no branch
            Account.objects.bulk_create(bulk)

            # maak e-mails aan
            bulk2 = list()
            for account in bulk:
                email = AccountEmail(account=account,
                                     email_is_bevestigd=True,
                                     bevestigde_email='*****@*****.**' %
                                     account.username)
                bulk2.append(email)
            # for

            AccountEmail.objects.bulk_create(bulk2)
            del bulk2

        del bulk

        # cache de aangemaakte accounts
        lid_nr2account = dict()
        for account in Account.objects.all():
            lid_nr2account[account.username] = account
        # for

        lid_nr = 300000
        bulk = list()
        for ver in self.vereniging.values():

            self.ver_sporters[ver.ver_nr] = list()
            self.ver_sporters_met_account[ver.ver_nr] = list()

            for wleeftijd, geslacht, voornaam, _, _ in soorten:
                lid_nr += 1
                achternaam = "Lid%s van Club%s" % (ver.ver_nr, lid_nr)
                geboortedatum = datetime.date(year=huidige_jaar - wleeftijd,
                                              month=3,
                                              day=24)

                try:
                    account = lid_nr2account[str(lid_nr)]
                except KeyError:
                    account = None

                sporter = Sporter(lid_nr=lid_nr,
                                  voornaam=voornaam,
                                  achternaam=achternaam,
                                  unaccented_naam=voornaam + ' ' + achternaam,
                                  email='*****@*****.**' % lid_nr,
                                  geboorte_datum=geboortedatum,
                                  geslacht=geslacht,
                                  para_classificatie='',
                                  is_actief_lid=True,
                                  sinds_datum=lid_sinds_datum,
                                  bij_vereniging=ver,
                                  account=account,
                                  lid_tot_einde_jaar=huidige_jaar)
                bulk.append(sporter)

                if len(bulk) > 250:  # pragma: no branch
                    Sporter.objects.bulk_create(bulk)
                    bulk = list()
            # for
        # for

        if len(bulk) > 0:  # pragma: no branch
            Sporter.objects.bulk_create(bulk)
        del bulk
        del lid_nr2account

        # maak voor elke Sporter nu de SporterBoog records aan
        boogtypen = self.afkorting2boogtype.values()

        bulk_voorkeuren = list()
        bulk_sporter = list()
        for sporter in (Sporter.objects.select_related(
                'account', 'bij_vereniging').all()):

            ver_nr = sporter.bij_vereniging.ver_nr

            self.ver_sporters[ver_nr].append(sporter)
            if sporter.account:
                self.ver_sporters_met_account[ver_nr].append(sporter)

            gewenst_boogtype = geslacht_voornaam2boogtype[sporter.geslacht +
                                                          sporter.voornaam]

            # voorkeuren
            voorkeuren = SporterVoorkeuren(sporter=sporter)

            if gewenst_boogtype.islower():
                voorkeuren.voorkeur_meedoen_competitie = False
                gewenst_boogtype = gewenst_boogtype.upper()

            # alle junioren willen een eigen blazoen
            if gewenst_boogtype == 'R' and sporter.voornaam.startswith('Jun'):
                voorkeuren.voorkeur_eigen_blazoen = True

            bulk_voorkeuren.append(voorkeuren)
            if len(bulk_voorkeuren) > 100:
                SporterVoorkeuren.objects.bulk_create(bulk_voorkeuren)
                bulk_voorkeuren = list()

            # sporterboog
            for boogtype in boogtypen:
                sporterboog = SporterBoog(
                    sporter=sporter,
                    # heeft_interesse=True
                    # voor_wedstrijd=False
                    boogtype=boogtype)

                if boogtype.afkorting == gewenst_boogtype:
                    sporterboog.voor_wedstrijd = True

                bulk_sporter.append(sporterboog)

                if len(bulk_sporter) > 250:
                    SporterBoog.objects.bulk_create(bulk_sporter)
                    bulk_sporter = list()
            # for
        # for

        if len(bulk_voorkeuren):  # pragma: no branch
            SporterVoorkeuren.objects.bulk_create(bulk_voorkeuren)
        del bulk_voorkeuren

        if len(bulk_sporter):  # pragma: no branch
            SporterBoog.objects.bulk_create(bulk_sporter)
        del bulk_sporter
Ejemplo n.º 2
0
def aanvangsgemiddelden_vaststellen_voor_afstand(afstand: int):
    """ deze functie gooit de huidige aanvangsgemiddelden van alle sporters voor gegeven afstand weg
        en bepaalt daarna de nieuwe AG's aan de hand van de meest recente historische competitie uitslag
    """
    # zoek uit wat de meest recente HistComp is
    histcomps = (HistCompetitie
                 .objects
                 .filter(comp_type=afstand)
                 .order_by('-seizoen'))
    if len(histcomps) == 0:
        schrijf_in_logboek(None, 'Competitie',
                           'Geen historisch uitslag om aanvangsgemiddelden vast te stellen voor %sm' % afstand)
        return

    seizoen = histcomps[0].seizoen
    schrijf_in_logboek(None, 'Competitie',
                       'Aanvangsgemiddelden vaststellen voor de %sm met uitslag seizoen %s' % (afstand, seizoen))

    histcomps = histcomps.filter(seizoen=seizoen)

    # het eindjaar van de competitie was bepalend voor de klasse
    # daarmee kunnen we bepalen of de sporter aspirant was
    eindjaar = int(seizoen.split('/')[1])

    # maak een cache aan van boogtype
    boogtype_dict = dict()  # [afkorting] = BoogType
    for obj in BoogType.objects.all():
        boogtype_dict[obj.afkorting] = obj
    # for

    # maak een cache aan van nhb leden
    # we filteren hier niet op inactieve leden
    sporter_dict = dict()  # [lid_nr] = Sporter
    for obj in Sporter.objects.all():
        sporter_dict[obj.lid_nr] = obj
    # for

    # maak een cache aan van sporter-boog
    sporterboog_cache = dict()         # [lid_nr, boogtype_afkorting] = SporterBoog
    for sporterboog in SporterBoog.objects.select_related('sporter', 'boogtype'):
        tup = (sporterboog.sporter.lid_nr, sporterboog.boogtype.afkorting)
        sporterboog_cache[tup] = sporterboog
    # for

    # verwijder alle bestaande aanvangsgemiddelden
    Score.objects.filter(type=SCORE_TYPE_INDIV_AG, afstand_meter=afstand).all().delete()

    minimum_aantal_scores = {18: settings.COMPETITIE_18M_MINIMUM_SCORES_VOOR_AG,
                             25: settings.COMPETITIE_25M_MINIMUM_SCORES_VOOR_AG}

    # doorloop alle individuele histcomp records die bij dit seizoen horen
    bulk_score = list()
    for histcomp in histcomps:
        for obj in (HistCompetitieIndividueel
                    .objects
                    .select_related('histcompetitie')
                    .filter(histcompetitie=histcomp)):

            if (obj.gemiddelde > AG_NUL
                    and obj.boogtype in boogtype_dict
                    and obj.tel_aantal_scores() >= minimum_aantal_scores[afstand]):

                # haal het sporterboog record op, of maak een nieuwe aan
                try:
                    tup = (obj.schutter_nr, obj.boogtype)
                    sporterboog = sporterboog_cache[tup]
                except KeyError:
                    # nieuw record nodig
                    sporterboog = SporterBoog()
                    sporterboog.boogtype = boogtype_dict[obj.boogtype]
                    sporterboog.voor_wedstrijd = True

                    try:
                        sporterboog.sporter = sporter_dict[obj.schutter_nr]
                    except KeyError:
                        # geen lid meer - skip
                        sporterboog = None
                    else:
                        sporterboog.save()
                        # zet het nieuwe record in de cache, anders krijgen we dupes
                        tup = (sporterboog.sporter.lid_nr, sporterboog.boogtype.afkorting)
                        sporterboog_cache[tup] = sporterboog
                else:
                    if not sporterboog.voor_wedstrijd:
                        sporterboog.voor_wedstrijd = True
                        sporterboog.save(update_fields=['voor_wedstrijd'])

                if sporterboog:
                    # aspiranten schieten op een grotere kaart en altijd op 18m
                    # daarom AG van aspirant niet overnemen als deze cadet wordt
                    # aangezien er maar 1 klasse is, is het AG niet nodig
                    # voorbeeld: eindjaar = 2019
                    #       geboortejaar = 2006 --> leeftijd was 13, dus aspirant
                    #       geboortejaar = 2005 --> leeftijd was 14, dus cadet
                    was_aspirant = (eindjaar - sporterboog.sporter.geboorte_datum.year) <= MAXIMALE_WEDSTRIJDLEEFTIJD_ASPIRANT

                    # zoek het score record erbij
                    if not was_aspirant:
                        # aanvangsgemiddelde voor deze afstand
                        waarde = int(obj.gemiddelde * 1000)

                        score = Score(sporterboog=sporterboog,
                                      type=SCORE_TYPE_INDIV_AG,
                                      waarde=waarde,
                                      afstand_meter=afstand)
                        bulk_score.append(score)

                        if len(bulk_score) >= 500:
                            Score.objects.bulk_create(bulk_score)
                            bulk_score = list()

        # for
    # for

    if len(bulk_score) > 0:                         # pragma: no branch
        Score.objects.bulk_create(bulk_score)
    del bulk_score

    # maak nu alle ScoreHist entries in 1x aan
    # (dit kost de meeste tijd)

    # hiervoor hebben we Score.pk nodig en die kregen we niet uit bovenstaande Score.objects.bulk_create
    bulk_scorehist = list()
    notitie = "Uitslag competitie seizoen %s" % histcomp.seizoen
    for score in (Score
                  .objects
                  .filter(type=SCORE_TYPE_INDIV_AG,
                          afstand_meter=afstand)):

        scorehist = ScoreHist(score=score,
                              oude_waarde=0,
                              nieuwe_waarde=score.waarde,
                              door_account=None,
                              notitie=notitie)
        bulk_scorehist.append(scorehist)

        if len(bulk_scorehist) > 250:
            ScoreHist.objects.bulk_create(bulk_scorehist)
            bulk_scorehist = list()
    # for
    if len(bulk_scorehist) > 0:                             # pragma: no branch
        ScoreHist.objects.bulk_create(bulk_scorehist)