imio-teleservices-templatetags/imio_teleservices_templatetags/templatetags/imio_teleservices.py

import datetime
import re
from decimal import Decimal

import requests
from dateutil.relativedelta import relativedelta
from django import template
from django.utils.safestring import SafeText
from wcs.qommon import misc
from wcs.qommon.templatetags.qommon import unlazy
from wcs.variables import LazyDateObject

register = template.Library()


def unlazy_date(fdate):
    if isinstance(fdate, LazyDateObject):
        return str(unlazy(fdate))
    else:
        return fdate


@register.filter
def clean_string(value):
    return value.replace(" ", "").replace(".", "").replace("-", "")


@register.filter
def check_class(value):
    return str(type(value))


@register.filter
def retour_chariot(value):
    return f"{value}\n"


@register.filter
def is_valid_belgian_nrn(value):
    return misc.validate_belgian_nrn(unlazy(value))


@register.filter
def is_strong_authentication(session_user):
    """
    Anciennement town.py is_strong_authentication
    session_user : session_user
    return : (bool) True si le user est connecté avec une authentification forte
    """
    return bool("_niss" in session_user.verified_fields)


@register.filter
def is_agent(session_user):
    """
    Anciennement town.py is_agent
    session_user : session_user
    return : (bool) True si le user est autorisé à aller dans le backoffice.
    """
    return session_user.can_go_in_backoffice()


@register.filter
def get_roles(session_user):
    return session_user.get_roles()


@register.filter
def diff_dates(oldest_date, newest_date):
    """
    Anciennement town.py diff_dates
    oldest_date : datetime ou SafeText sous la forme "jj/mm/aaaa" ou "aaaa-mm-jj" ou "jj-mm-aaaa"
    newest_date : datetime ou SafeText sous la forme "jj/mm/aaaa" ou "aaaa-mm-jj" ou "jj-mm-aaaa"
    return : (str) nombre de jours de différence entre les 2 dates
    """

    def transform_date(fdate):
        if type(fdate) == LazyDateObject:
            fdate = unlazy(fdate)
        fdate = fdate[:10]
        if "/" in fdate:
            return datetime.datetime.strptime(fdate, "%d/%m/%Y")
        if "-" in fdate:
            if len(fdate.split("-")[0]) == 4:
                return datetime.datetime.strptime(fdate, "%Y-%m-%d")
            if len(fdate.split("-")[0]) == 2:
                return datetime.datetime.strptime(fdate, "%d-%m-%Y")

    oldest_date = unlazy_date(oldest_date)
    newest_date = unlazy_date(newest_date)

    if type(oldest_date) in (SafeText, str):
        oldest_date = transform_date(oldest_date)
    if type(newest_date) in (SafeText, str):
        newest_date = transform_date(newest_date)
    diff = abs((oldest_date - newest_date).days)
    return str(diff)


@register.filter
def get_birthday_from_nn(numero_national):
    """
    numero_national : (str) numero national peut contenir espace . et -
    return : (datetime) la date de naissance
    """
    numero_national = clean_string(unlazy(numero_national))
    date = numero_national[:6]
    birthday = datetime.datetime.strptime(date, "%y%m%d")
    if birthday > datetime.datetime.now():
        birthday -= relativedelta(years=100)
    return birthday


@register.filter
def is_valid_tva_number(tva_number, formatage=True):
    """
    tva_number : (str) numéro de tva BE0000000097
    formatage : (bool) True/False
    return : (bool) True si le numéro est valide
    """
    # si formatage alors enlève les espaces, points et tirets
    if formatage:
        tva_number = clean_string(tva_number)

    if not tva_number[:2].upper() == "BE":
        return False
    if not len(tva_number) == 12:
        if len(tva_number) == 11:
            tva_number = tva_number[:2] + "0" + tva_number[2:]
        else:
            return False
    if re.match(r"^\d{10}$", tva_number[2:]):
        int_value = int(tva_number[2:10])
        check_digit = int(int_value / 97) * 97
        if (97 - (int_value - check_digit)) == int(tva_number[10:12]):
            return True
        else:
            return False


@register.filter
def liste_type_rdv_plusieurs_personnes(value):
    """
    Anciennement liste_type_general_rdv.py
    value : (str) url api liste des types de rendez-vous
    return : (list[str]) liste des différent type de rendez-vous sans - x personnes
    """
    headers = {"Accept": "application/json"}
    liste = requests.get(value, headers=headers).json()
    return list(set([re.sub(r" (pour|-) [0-9]+ personne(s)?$", "", x["text"]) for x in liste["data"]]))


@register.filter
def liste_type_rdv_nombres_personnes(value, arg):
    """
    Anciennement liste_type_rdv.py
    value : (str) url api liste des type de rendez-vous
    arg : (str) type de rendez-vous
    return : (list[str]) liste des rendez-vous de type arg
    """
    headers = {"Accept": "application/json"}
    liste = requests.get(value, headers=headers).json()

    return [x for x in liste["data"] if arg in x["text"]]


@register.filter
def calcul_total_abonnement_stationnement(fields_bloc):
    """
    Anciennement fields_bloc.py
    fields_bloc : (list[dict]) Bloc de champ Abonnements de stationnement données bénéficiaires
    return : (Decimal) addition des entrées price
    """
    total = 0

    for field in fields_bloc:
        for value in field.values():
            if isinstance(value, dict):
                total += Decimal(value.get("price"))

    return total


@register.filter
def autorisation_voyage_enfants_concernes(lst_enfants_concernes):
    """
    Anciennement autorisation_voyage_enfants_concernes.py
    lst_enfants_concernes : (list)
    return : (str)
    """
    enfants_concernes = ""
    if lst_enfants_concernes is not None:
        for e in lst_enfants_concernes:
            enfants_concernes = enfants_concernes + "-  " + e[0] + " né(e) à " + e[1] + " le " + e[2] + "\r\n"

    return enfants_concernes