def iter_heures_sup_annees_param(
iter_annees=db.bdd().iterAnneesDispo,
generateur_heures_sup_annees=gen_heures_sup_annee_a):
BOOL_ITER_ANNEES_DOMAINE_OK = (iter_annees in [db.bdd().iterAnneesDispo])
BOOL_GENE_HEURES_SUP_ANNEES_DOMAINE_OK = (generateur_heures_sup_annees in [
gen_heures_sup_annee_a, gen_heures_sup_annee2, gen_heures_sup_annee
])
if not BOOL_ITER_ANNEES_DOMAINE_OK:
raise ("iter annees pas dans bon domaine")
if not BOOL_GENE_HEURES_SUP_ANNEES_DOMAINE_OK:
raise ("gene heures sup domaine pas ok")
for a in iter_annees:
annee = int(a)
yield gen_heures_sup_annees(a)
def getCumulHeuresTravailleesSemaine(a,
s,
methode=db.bdd().
getCumulHeuresTravailleesSemaine):
try:
return int(methode(a, s))
except TypeError:
return int(methode)
def setBdd(self):
self.bdd = bdd()
def setBdd(self, bdd):
if bdd is not None:
self.bdd = bdd
else:
from db import bdd
self.bdd = bdd()
import constantes
from db import bdd
from itertools import islice
""" je veux une fonction pour mon larbin
- ouvrant un fichier texte,
- explosant chaque ligne,
- transformant chaque ligne explosee en un poste via:
* la creation d un horodatage de début
i. par la combinaison d une date et d une heure:
- la date etant annee mois et jour de début de poste
- le début de poste dépendant du type de poste:
* le type de poste est lu dans le fichier texte à destination du larbin
* la correspondance entre type de poste et heure de début
se fait à partir de la lecture de constantes.py
* la creation d un horodatage de fin
i . par l ajout à l horodatage de début de poste d une duree
- la duree dépend du type de poste:
* le type de poste est lu dans le fichier texte à destination du larbin
* la correspondance entre type de poste et duree se lit dans constantes.py
* la creation d un type d entree dans le planning lu dans constantes.py
* la création d une categorie d entree lu dans constantes.py: travail ou absence"""
with open(next(bdd().iterFichiersPostes())) as f:
for ligne in f:
for ligne_poste in xpld.xpld().xplode_ite(ligne):
print(ligne_poste)
## datetime_debutposte = datetime.datetime.combine(
## datetime.date(ligne_poste['year'], ligne_poste['month'], ligne_poste['day']),
## datetime.time(ligne_poste)
##
def prejudice():
"""hsrd = hss_effectuee - hsspayee.
les heures négatives ? c est le point le plus important:
trois positions possibles:
1) les heures sont perdues pour l employeur et le décompte se fait à la semaine, paiement au mois
2) les heures ne sont pas perdues pour l employeur et le cumul se fait algébriquement sur le mois
3) les heures ne sont pas perdues pour l employeur et le cumul se fait algébriquement sur l'année.
4) il n'y a jamais de perte pour l'employeur et le compteur n est jamais perdu pour l employeur.
je penche pour le type 3 pour l instant:
il s'agit d une CORRECTION DU PAIEMENT REEL PAR RAPPORT A UN PAIEMENT DU
pour qualifier un DOL
PAR CONTRE QUEL QUE SOIT LE RESULTAT, LE COMPTEUR DE DIFF25
EST REMIS A ZERO au 1er janvier
des exceptions sont à prendre en compte:
pendant certaines semaines de congés payées, on travaille.
on est à la fois en congés et au travail.
cela se résoud en considérant cela comme des heures supplémentaires:
en effet, les cp sont censées se substituer à des jours de travail
mais ils sont payés comme des jours de travail (les heures à poser
pour un jour de cp correspond à la moyenne des heures d une semaine
de travail normal)
"""
"""ALGO: pour chaque semaine du mois:
probleme | semaine à exclure | semaine à inclure
si semaine_travaillée et semaine_cp => probleme
si non semaine travaillee et semeaince cp => semaine a exclure
sinon semaine à inclure
pour chaque semaine à inclure du mois:
pour chaque type_d heures sup:
heure_sup_dues vs heures_sup_payees.
si heures sup_dues:
ajouter (typeheures_sup : + heures_sup_dues)
si heures_en_trop:
ajouter(typeheures_sup: cagnotte globale)
fin_du_mois :
pour chaque type_heures_sup:
pour chaque_semaine:
ajouter_type_heures_sup
ajouter_cagnotte
vider_cagnotte
si_heures_sup:
ajouter_heures_sup
renvoyer tableau_heures_sup_mensuellesje vex une methode restant_dues qui
permette de calculer le nombre d heures restant dues
à 25% .
mon employeur me paie effectivement 169 heures par mois
dont 4 bonifiées à 25 %:
il applique la l3121-31:
Article L3121-31 En savoir plus sur cet article...
Modifié par LOI n°2016-1088 du 8 août 2016 - art. 8 (V)
Dans les entreprises dont la durée collective hebdomadaire de travail est supérieure
à la durée légale hebdomadaire, la rémunération mensuelle due au salarié peut être calculée
en multipliant la rémunération horaire par les cinquante-deux douzièmes de cette durée hebdomadaire de travail,
en tenant compte des majorations de salaire correspondant aux heures supplémentaires accomplies.
cependant si dans mon contrat l'annualisaiont n'est pas valable,
alors les 39 non plus (pas un self service ou on prend une partie
et pas le reste)
le raisonnement de l'avocat est de partir des 35 heures sur la base
des art 3121-27 et 3121-28 et 29:
1) compter la qté d heures de chaque semaine travaillée.
si plus de 35 heures 25% dues.
2) cumuler ca à l'année.
Article L3121-27 En savoir plus sur cet article...
Modifié par LOI n°2016-1088 du 8 août 2016 - art. 8 (V)
La durée légale de travail effectif des salariés à temps complet est fixée à trente-cinq heures par semaine.
Article L3121-28 En savoir plus sur cet article...
Modifié par LOI n°2016-1088 du 8 août 2016 - art. 8 (V)
Toute heure accomplie au delà de la durée légale hebdomadaire
ou de la durée considérée comme équivalente est une heure supplémentaire
qui ouvre droit à une majoration salariale ou, le cas échéant,
à un repos compensateur équivalent.
Article L3121-29 En savoir plus sur cet article...
Modifié par LOI n°2016-1088 du 8 août 2016 - art. 8 (V)
Les heures supplémentaires se décomptent par semaine.
Article L3121-30 En savoir plus sur cet article...
Modifié par LOI n°2016-1088 du 8 août 2016 - art. 8 (V)
Des heures supplémentaires peuvent être accomplies
dans la limite d'un contingent annuel.
Les heures effectuées au delà de ce contingent annuel
ouvrent droit à une contrepartie obligatoire sous forme de repos.
Les heures prises en compte pour le calcul du contingent
annuel d'heures supplémentaires sont celles accomplies
au delà de la durée légale.
Les heures supplémentaires ouvrant droit
au repos compensateur équivalent mentionné à l'article L. 3121-28
et celles accomplies dans les cas de travaux urgents
énumérés à l'article L. 3132-4
ne s'imputent pas sur le contingent annuel d'heures supplémentaires.
AUTRE PT DE VUE:
les heures sup dues sur un mois somment les heures sup dues des semaines terminees
elles representent apres bonification un eqv heures trav
comparable à l eqv heures trav de la bonif payée effectivement.
elles permettent donc de déterminer un préjudice.
"""
anneesdispo = list(db.bdd().iterAnneesDispo())
moisannee = list(range(1, 13))
def eqv_trv_de_sup_paye_obsolete(mois, annee):
cste_h25_payee_mois = 17.33
return bonification25(cste_h25_payee_mois)
def eqv_trv_de_sup_sem_paye(semaine, annee):
heures_cp = getCumulHeuresCpSemaine(annee, semaine)
paye_semaine = sup25_deja_paye(heures_cp)
if heures_cp:
phrase_cp_non_nuls = "en semaine {}, {} heures de cp ramenent les hsup payéees de 4 à {}"
phrase_cp_non_nuls = phrase_cp_non_nuls.format(
semaine, annee, paye_semaine)
log.critical(phrase_cp_non_nuls)
else:
phrase_cp_nuls = "{} heures ont été payées à 25% au titre de la mens des heures de 35 à 39h"
phrase_cp_nuls = phrase_cp_nuls.format(paye_semaine)
log.debug(phrase_cp_nuls)
return bonification25(paye_semaine)
def eqv_trv_de_sup_paye(mois, annee):
eqv = 0
import utilitaireDates
semainesmois = list(utilitaireDates.iterSemaine(annee, mois))
for semaine in semainesmois:
eqv = eqv + eqv_trv_de_sup_sem_paye(semaine, annee)
phrase_debug = "eqv trv de paye vaut {} lors semaine {}"
phrase_debug = phrase_debug.format(
eqv_trv_de_sup_sem_paye(semaine, annee), semaine)
log.debug(phrase_debug)
return eqv
def bonification25(heures):
return heures * 1.25
def bonification50(heures):
return heures * 1.50
def bonification100(heures):
return heures * 2
def eqv_trv_de_sup_du(mois, annee):
## def eqv_trv_de_sup_sem_du(semaine, annee):
## e_s = eqv_trv_de_sup_sem_du_25(semaine,annee)
## + eqv_trv_de_sup_sem_du_50(semaine,annee)
## + eqv_trv_de_sup_sem_du_100(semaine,annee)
## return e_s
## def eqv_trv_de_sup_sem_du_25(semaine,annee):
## heures_effectuees_semaine = getCumulHeuresTravailleesSemaine(semaine,annee)
## return bonification25(
## heures_sup_25_effectuees(heures_effectuees_semaine)
## )
## def eqv_trv_de_sup_sem_du_50(semaine,annee):
## heures_effectuees_semaine = getCumulHeuresTravailleesSemaine(semaine,annee)
## return bonification50(
## heures_sup_50_effectuees(heures_effectuees_semaine)
## )
##
## def eqv_trv_de_sup_sem_du_100(semaine,annee):
## heures_effectuees_semaine = getCumulHeuresTravailleesSemaine(semaine,annee)
## return bonification100(
## heures_illegales_effectuees(heures_effectuees_semaine)
## )
eqv = 0
import utilitaireDates
semainesmois = list(utilitaireDates.iterSemaine(annee, mois))
for semaine in semainesmois:
eqv = eqv + eqv_trv_de_sup_sem_du(semaine, annee)
phrase_debug = "eqv vaut {} lors semaine {} (sem25: {} sem50: {} sem100: {}"
phrase_debug = phrase_debug.format(
eqv, semaine, eqv_trv_de_sup_sem_du_25(semaine, annee),
eqv_trv_de_sup_sem_du_50(semaine, annee),
eqv_trv_de_sup_sem_du_100(semaine, annee))
log.info(phrase_debug)
return eqv
cumul_total_posit = 0
cumul_total_neg = 0
cumul_total = 0
for annee in anneesdispo:
cumul_annuel_posit = 0
cumul_annuel_neg = 0
bilan_annuel = 0
for mois in moisannee:
cumul_mensuel_posit = 0
cumul_mensuel_neg = 0
p = eqv_trv_de_sup_paye(mois, annee)
d = eqv_trv_de_sup_du(mois, annee)
phrase_datation = "pour mois {} annee {}".format(mois, annee)
phrase_ok_ko = phrase_datation + "\n paye {} alors que du {}".format(
p, d)
phrase_cumul_mensuel = "cumul mensuel de {}".format(d - p)
if p >= d:
log.info(phrase_ok_ko)
cumul_mensuel_neg = d - p
log.info(phrase_cumul_mensuel)
else:
log.critical(phrase_ok_ko)
cumul_mensuel_posit = d - p
log.critical(phrase_cumul_mensuel)
log.critical(
"prejudice de {} pour le mois".format(cumul_mensuel_posit))
cumul_annuel_posit = cumul_annuel_posit + cumul_mensuel_posit
cumul_annuel_neg = cumul_annuel_neg + cumul_mensuel_neg
# fin de pour chaque mois de l'année
# debut de pour chaque année
log.critical(
"cumul_annuel_posit (le seul à prendre en ocmpte puisque les heures sup sont comptees à la semaine et payees au mois. on s arrete donc au décompte des mois positifs): {}"
.format(cumul_annuel_posit))
log.info("cumul_annuel_neg : {}".format(cumul_annuel_neg))
log.critical("prejudice annuel (prejudice si posit) {}".format(
cumul_annuel_posit + cumul_annuel_neg))
cumul_total_posit = cumul_annuel_posit + cumul_total_posit
cumul_total_neg = cumul_annuel_neg + cumul_total_neg
# fin de pour chaque annee
#debut de decompte final
log.critical(
"pour action: cumul total posit : {}".format(cumul_total_posit))
log.info("pour info : cumul total neg: {}".format(cumul_total_neg))
cumul_total = cumul_total_posit + cumul_total_neg
log.critical("prejudice si chiffre positif: {}".format(cumul_total))
def iter_heures_sup_annees_a():
for a in db.bdd().iterAnneesDispo():
annee = int(a)
yield gen_heures_sup_annee_a(a)
