[auf_rh_dae.git] / project / legacy / management / commands / rh_import_legacy.py

# coding: utf-8

from decimal import Decimal

from django.contrib.auth.models import User
from django.core.management.base import BaseCommand
from django.db import connection
from django.db.models import Q

from project.legacy import models as legacy
from project.rh import models as rh


class Command(BaseCommand):
    help = 'Importe les données du système RH legacy'

    def handle(self, *args, **options):
        self.stdout.write("Import de rh_classement...\n")
        sync_classement()
        self.stdout.write("Import de rh_employe...\n")
        sync_employe()
        self.stdout.write("Import de rh_familleemploi...\n")
        sync_familleemploi()
        self.stdout.write("Import de rh_typeposte...\n")
        sync_typeposte()
        self.stdout.write("Import de rh_service...\n")
        sync_service()
        self.stdout.write("Import de rh_poste...\n")
        sync_poste()
        self.stdout.write("Import de rh_organismebstg...\n")
        sync_organismebstg()
        self.stdout.write("Import de rh_statut...\n")
        sync_statut()
        self.stdout.write("Import de rh_tauxchange...\n")
        sync_tauxchange()
        self.stdout.write("Import de rh_valeurpoint...\n")
        sync_valeurpoint()
        self.stdout.write("Import de rh_typecontrat...\n")
        sync_typecontrat()
        self.stdout.write("Import de rh_typerevalorisation...\n")
        sync_typerevalorisation()
        self.stdout.write("Import de rh_typeremuneration...\n")
        sync_typeremuneration()
        self.stdout.write("Import de rh_dossier...\n")
        sync_dossier()
        self.stdout.write("Import de rh_ayantdroit...\n")
        sync_ayantdroit()


def sync_classement():
    connection.cursor().execute('TRUNCATE rh_classement')
    for classement in legacy.Classement.objects.all():
        rh.Classement.objects.create(
            id=classement.id_classement,
            type=classement.type_classement,
            echelon=classement.echelon or 0,
            degre=classement.degre or 0,
            coefficient=classement.coefficient,
            commentaire=classement.commentaire,
            date_modification=classement.date_modif,
            actif=classement.actif
        )

def sync_employe():
    cursor = connection.cursor()
    cursor.execute('TRUNCATE rh_employe')
    cursor.execute('TRUNCATE rh_employecommentaire')
    odette = User.objects.get(username='odette.tremblay')
    for fiche in legacy.Fiches.objects.all():
        employe = rh.Employe.objects.create(
            id=fiche.no_employe,
            nom=fiche.nom,
            prenom=fiche.prenom,
            nationalite_id=fiche.nationalite,
            date_naissance=fiche.date_naissance if fiche.date_naissance else None,
            genre=fiche.sexe.upper(),
            situation_famille=None if fiche.situation_famille == '-1' else fiche.situation_famille,
            date_entree=fiche.date_entree,
            tel_domicile=fiche.tel_domicile,
            tel_cellulaire=fiche.tel_cellulaire,
            adresse=fiche.no_rue,
            ville=fiche.ville,
            province=fiche.etat_province,
            code_postal=fiche.code_postal_cedex,
            pays_id=fiche.pays_iso2,
            date_creation=fiche.date_ouverture,
            date_modification=fiche.date_maj,
            actif=True,
            supprime=False
        )
        if fiche.remarque:
            rh.EmployeCommentaire.objects.create(
                employe=employe,
                texte=fiche.remarque,
                owner=odette
            )

def sync_familleemploi():
    cursor = connection.cursor()
    cursor.execute('TRUNCATE rh_familleemploi')
    for famille in legacy.FamilleEmploi.objects.all():
        rh.FamilleEmploi.objects.create(
            id=famille.id_famille_emploi,
            nom=famille.famille_emploi,
            actif=famille.actif
        )

def sync_typeposte():
    cursor = connection.cursor()
    cursor.execute('TRUNCATE rh_typeposte')
    for type in legacy.Postes.objects.all():
        rh.TypePoste.objects.create(
            id=type.id_poste,
            nom=type.titre_poste_m,
            nom_feminin=type.titre_poste_f,
            is_responsable=bool(int(type.poste_responsable)),
            famille_emploi_id=type.id_famille_emploi,
            date_modification = type.datemaj,
            actif=bool(int(type.actif))
        )

def sync_service():
    cursor = connection.cursor()
    cursor.execute('TRUNCATE rh_service')
    for service in legacy.DirectionService.objects.all():
        rh.Service.objects.create(
            id=service.id_direction_service,
            nom=service.direction_service,
            actif=bool(service.actif)
        )

def sync_poste():
    cursor = connection.cursor()
    cursor.execute('TRUNCATE rh_poste')
    for poste in legacy.ImplantationPostes.objects.select_related('type_poste'):

        # Aller chercher certaines informations dans le dernier dossier
        # associé à ce poste
        dossiers = legacy.Dossiers.objects.filter(
            Q(poste_1=poste.id_implantation_postes) | Q(poste_2=poste.id_implantation_postes)
        ).order_by('-id_dossier')
        poste_du_responsable = 149
        service = 1
        complement = ''
        if dossiers.count() > 0:
            dossier = dossiers[0]

            # Déterminer le service
            services = dossier.ids_direction_service
            service = int(services.split('|')[0]) if services else 1
            if poste.id_implantation_postes == dossier.poste_1:
                complement = dossier.complement_1
            else:
                complement = dossier.complement_2
            complement = ' ' + complement if complement else ''

            # Déterminer le poste du responsable
            try:
                responsable = dossier.responsable
            except legacy.Fiches.DoesNotExist:
                pass
            else:
                dossiers_du_responsable = responsable.dossiers.order_by('-id_dossier')
                if dossiers_du_responsable.count() > 0:
                    poste_du_responsable = dossiers_du_responsable[0].poste_1

        # Créer le poste
        rh.Poste.objects.create(
            id=poste.id_implantation_postes,
            nom=poste.type_poste.titre_poste_m + complement,
            nom_feminin=poste.type_poste.titre_poste_f + complement,
            implantation_id=poste.id_implantation,
            type_poste_id=poste.type_poste_id,
            date_modification=poste.date_maj,
            actif=poste.actif,
            service_id=service,
            supprime=False,
            responsable_id=poste_du_responsable
        )

def sync_organismebstg():
    connection.cursor().execute('TRUNCATE rh_organismebstg')
    for organisme in legacy.OrganismesBstg.objects.all():
        rh.OrganismeBstg.objects.create(
            id=organisme.id_bstg,
            nom=organisme.organisme_nom,
            type=organisme.bstg_type,
            actif=bool(organisme.actif)
        )

def sync_statut():
    connection.cursor().execute('TRUNCATE rh_statut')
    for statut in legacy.Statut.objects.all():
        rh.Statut.objects.create(
            id=statut.id_statut,
            code=statut.statut_contractuel,
            nom=statut.description_statut_contractuel,
            actif=bool(statut.actif)
        )

def sync_tauxchange():
    connection.cursor().execute('TRUNCATE rh_tauxchange')
    connection.cursor().execute('TRUNCATE rh_devise')

    # Certaines devises ont besoin d'un id spécifique (#2581)
    rh.Devise.objects.create(id=1, code='AMD', nom='Dram arménien')
    rh.Devise.objects.create(id=2, code='CAD', nom='Dollar canadien')
    rh.Devise.objects.create(id=3, code='CAN', nom='Dollar canadien')
    rh.Devise.objects.create(id=4, code='DZD', nom='Dinar algérien')
    rh.Devise.objects.create(id=5, code='EUR', nom='Euro')
    rh.Devise.objects.create(id=6, code='GNF', nom='Franc Guinéen')
    rh.Devise.objects.create(id=7, code='KMF', nom='Franc comorien')
    rh.Devise.objects.create(id=8, code='LBP', nom='Livre libanaise')
    rh.Devise.objects.create(id=9, code='MAD', nom='Dirham marocain')
    rh.Devise.objects.create(id=10, code='MGF', nom='Franc Malgache')
    rh.Devise.objects.create(id=11, code='MRO', nom='Ouguiya')
    rh.Devise.objects.create(id=12, code='MUR', nom='Roupie mauricienne')
    rh.Devise.objects.create(id=13, code='SYP', nom='Livre syrienne')
    rh.Devise.objects.create(id=14, code='TND', nom='Dinar tunisien')
    rh.Devise.objects.create(id=15, code='US ', nom='Dollar américain')
    rh.Devise.objects.create(id=16, code='USD', nom='Dollar américain')
    rh.Devise.objects.create(id=17, code='VUV', nom='Vatu')
    rh.Devise.objects.create(id=18, code='XAF', nom='Franc CFA')
    rh.Devise.objects.create(id=19, code='XOF', nom='Franc CFA')

    for taux in legacy.TauxChangeAnnuel.objects.exclude(taux_annuel=None):

        # Créer la devise
        devise, created = rh.Devise.objects.get_or_create(code=taux.code_devise)
        if created:
            devise.nom=taux.nom_devise
            devise.save()

        # Créer le taux de change
        rh.TauxChange.objects.get_or_create(
            devise=devise,
            annee=taux.annee,
            taux=taux.taux_annuel,
            actif=True
        )

def sync_valeurpoint():
    connection.cursor().execute('TRUNCATE rh_valeurpoint')
    for vp in legacy.ValeurPoint.objects.all():

        # Trouver la devise associée à cette implantation
        try:
            taux = legacy.TauxChangeAnnuel.objects.get(annee='2011', id_implantation=vp.id_implantation)
        except legacy.TauxChangeAnnuel.DoesNotExist:
            devise = None
        else:
            devise = rh.Devise.objects.get(code=taux.code_devise)

        rh.ValeurPoint.objects.create(
            id=vp.id_valeur_point,
            valeur=vp.valeur_point,
            implantation_id=vp.id_implantation,
            annee=vp.date_actif[:4],
            actif=True,
            devise=devise
        )

def sync_typecontrat():
    connection.cursor().execute('TRUNCATE rh_typecontrat')
    for type in legacy.TypeContrat.objects.all():
        rh.TypeContrat.objects.create(
            id=type.id_type_contrat,
            nom=type.nom_contrat,
            nom_long=type.description_contrat,
            actif=bool(type.actif_contrat)
        )

def sync_typerevalorisation():
    connection.cursor().execute('TRUNCATE rh_typerevalorisation')
    for type in legacy.TypeRevalorisation.objects.all():
        rh.TypeRevalorisation.objects.create(
            id=type.id_type_revalorisation,
            nom=type.type_revalorisation,
            actif=bool(type.actif)
        )

def sync_typeremuneration():
    connection.cursor().execute('TRUNCATE rh_typeremuneration')
    for type in legacy.TypeRemuneration.objects.all():
        rh.TypeRemuneration.objects.create(
            id=type.id_type_remuneration,
            nom=type.type_remuneration,
            type_paiement=type.type_paiement,
            nature_remuneration=type.nature_remuneration,
            actif=bool(type.actif)
        )

def sync_dossier():

    def clean_date(date):
        if date == '2003-06-31': # date inexistante (dossier 791-1)
            return '2003-06-30'
        elif date:
            return date
        else:
            return None

    taux_cache = {}
    def get_taux(annee, devise):
        taux = taux_cache.get((annee, devise))
        if taux is not None:
            return taux
        taux = rh.TauxChange.objects.filter(annee__gte=annee).order_by('annee')[0].taux
        taux_cache[(annee, devise)] = taux
        return taux

    cursor = connection.cursor()
    cursor.execute('TRUNCATE rh_contrat')
    cursor.execute('TRUNCATE rh_dossier')
    cursor.execute('TRUNCATE rh_remuneration')
    cursor.execute('TRUNCATE rh_dossiercommentaire')
    odette = User.objects.get(username='odette.tremblay')
    type_contrat_inconnu = rh.TypeContrat.objects.create(
        nom='Inconnu',
        nom_long='Inconnu',
        actif=False
    )
    for dossier in legacy.Dossiers.objects.all():
        dossier1 = rh.Dossier.objects.create(
            employe_id=dossier.employe_id,
            poste_id=dossier.poste_1,
            statut_id=dossier.id_statut,
            organisme_bstg_id=dossier.id_bstg,
            statut_residence='expat' if dossier.id_local_expatrie == 1 else 'local',
            classement_id=dossier.id_classement,
            regime_travail=dossier.regime_travail,
            date_debut=clean_date(dossier.date_debut_mandat),
            date_fin=clean_date(dossier.date_fin_mandat),
            remplacement=False,
            actif=True,
            supprime=False
        )
        if dossier.remarque:
            rh.DossierCommentaire.objects.create(
                dossier=dossier1,
                texte=dossier.remarque,
                owner=odette
            )
        rh.Contrat.objects.create(
            dossier=dossier1,
            type_contrat_id=dossier.id_type_contrat or type_contrat_inconnu.id,
            date_debut=clean_date(dossier.date_debut_contrat),
            date_fin=clean_date(dossier.date_fin_contrat),
            actif=True,
            supprime=False
        )


        remuns_precedentes = {}
        charges_precedentes = None
        pourcentage_charges = 0
        devise_charges = rh.Devise.objects.get(code='EUR')
        for remun in legacy.HistoRemuneration.objects.filter(no_dossier=dossier.no_dossier) \
                     .order_by('id_histo_remuneration'):

            # Calcul de la période
            date_debut = remun.date_effective
            if date_debut == '200-08-09':
                date_debut = '2000-08-09'
            elif date_debut == '2003-06-31':
                date_debut = '2003-06-30'
            if remun.type_remuneration.type_paiement == 'Ponctuel':
                date_fin = date_debut
            else:
                date_fin = None
                remun_precedente = remuns_precedentes.get(remun.type_remuneration_id)
                if remun_precedente:
                    if str(remun_precedente.date_debut) == str(date_debut):
                        remun_precedente.delete()
                    else:
                        remun_precedente.date_fin = date_debut
                        remun_precedente.save()

            # Création de la ligne de rémunération
            if remun.type_remuneration.nature_remuneration != 'Charges' and remun.montant != 0:
                devise, created = rh.Devise.objects.get_or_create(code=remun.code_devise)

                rh_remun = rh.Remuneration.objects.create(
                    actif=True,
                    dossier=dossier1,
                    type_id=remun.type_remuneration_id,
                    type_revalorisation_id=remun.id_type_revalorisation,
                    montant=remun.montant,
                    devise=devise,
                    supprime=False,
                    date_debut=date_debut,
                    date_fin=date_fin
                )

                # Se souvenir de ce type de rémunération
                if remun.type_remuneration.type_paiement == u'Régulier':
                    remuns_precedentes[remun.type_remuneration_id] = rh_remun

            # Charges patronales
            if remun.type_remuneration.nature_remuneration == 'Charges':
                pourcentage_charges = remun.pourcentage

            if remun.type_remuneration.nature_remuneration == 'Traitement':
                devise_charges = rh.Devise.objects.get(code=remun.code_devise)

            if remun.type_remuneration.type_paiement == u'Régulier':
                charges = 0
                annee_charges = int(date_debut[:4])
                taux2 = get_taux(annee_charges, devise_charges)
                if pourcentage_charges:
                    for remun_precedente in remuns_precedentes.values():
                        montant = remun_precedente.montant
                        devise = remun_precedente.devise
                        if devise != devise_charges:
                            taux1 = get_taux(annee_charges, devise)
                            montant = montant * Decimal(str(taux1)) / Decimal(str(taux2))
                        if remun_precedente.type.nature_remuneration == 'Traitement':
                            montant = montant * remun_precedente.dossier.regime_travail / 100
                        montant = montant * pourcentage_charges / 100
                        montant.quantize(remun_precedente.montant)
                        charges += montant
                    charges = charges * pourcentage_charges / 100
                    if charges_precedentes:
                        if str(charges_precedentes.date_debut) == str(date_debut):
                            charges_precedentes.delete()
                        else:
                            charges_precedentes.date_fin = date_debut
                            charges_precedentes.save()
                    if charges > 0 and \
                       (not charges_precedentes or charges_precedentes.montant != charges or
                        str(charges_precedentes.date_debut) == str(date_debut)):
                        charges_precedentes = rh.Remuneration.objects.create(
                            actif=True,
                            dossier=dossier1,
                            type_id=17,
                            type_revalorisation_id=None,
                            montant=charges,
                            devise=devise_charges,
                            supprime=False,
                            date_debut=date_debut,
                            commentaire=u'Charges patronales: %s%%' % pourcentage_charges
                        )

        # Dossier différent pour le deuxième poste
        if dossier.poste_2:
            dossier2 = rh.Dossier.objects.create(
                employe_id=dossier.employe_id,
                poste_id=dossier.poste_2,
                statut_id=dossier.id_statut,
                organisme_bstg_id=dossier.id_bstg,
                statut_residence='expat' if dossier.id_local_expatrie == 1 else 'local',
                classement_id=dossier.id_classement,
                regime_travail=dossier.regime_travail,
                date_debut=clean_date(dossier.date_debut_mandat),
                date_fin=clean_date(dossier.date_fin_mandat),
                remplacement=False,
                actif=True,
                supprime=False
            )
        if dossier.remarque:
            rh.DossierCommentaire.objects.create(
                dossier=dossier2,
                texte=dossier.remarque,
                owner=odette
            )
        rh.Contrat.objects.create(
            dossier=dossier2,
            type_contrat_id=dossier.id_type_contrat or type_contrat_inconnu.id,
            date_debut=clean_date(dossier.date_debut_contrat),
            date_fin=clean_date(dossier.date_fin_contrat),
            actif=True,
            supprime=False
        )

def sync_ayantdroit():
    connection.cursor().execute('TRUNCATE rh_ayantdroit')
    odette = User.objects.get(username='odette.tremblay')
    for ad in legacy.AyantDroit.objects.all():
        rh_ad = rh.AyantDroit.objects.create(
            id=ad.id_ayant_droit,
            nom=ad.nom_ayant_droit,
            prenom=ad.prenom_ayant_droit,
            employe_id=ad.no_employe,
            lien_parente=None if ad.lien_parente == 'Autre' else ad.lien_parente,
            actif=bool(ad.actif)
        )
        if ad.commentaire_ayant_droit:
            rh.AyantDroitCommentaire.objects.create(
                ayant_droit=rh_ad,
                texte=ad.commentaire_ayant_droit,
                owner=odette
            )
Commit	Line	Data
ca1a7b76 EMS	1	# coding: utf-8
	2
	3	from decimal import Decimal
	4
	5	from django.contrib.auth.models import User
	6	from django.core.management.base import BaseCommand
	7	from django.db import connection
	8	from django.db.models import Q
	9
	10	from project.legacy import models as legacy
	11	from project.rh import models as rh
	12
	13
	14	class Command(BaseCommand):
	15	help = 'Importe les données du système RH legacy'
	16
	17	def handle(self, args, *options):
	18	self.stdout.write("Import de rh_classement...\n")
	19	sync_classement()
	20	self.stdout.write("Import de rh_employe...\n")
	21	sync_employe()
	22	self.stdout.write("Import de rh_familleemploi...\n")
	23	sync_familleemploi()
	24	self.stdout.write("Import de rh_typeposte...\n")
	25	sync_typeposte()
	26	self.stdout.write("Import de rh_service...\n")
	27	sync_service()
	28	self.stdout.write("Import de rh_poste...\n")
	29	sync_poste()
	30	self.stdout.write("Import de rh_organismebstg...\n")
	31	sync_organismebstg()
	32	self.stdout.write("Import de rh_statut...\n")
	33	sync_statut()
	34	self.stdout.write("Import de rh_tauxchange...\n")
	35	sync_tauxchange()
	36	self.stdout.write("Import de rh_valeurpoint...\n")
	37	sync_valeurpoint()
	38	self.stdout.write("Import de rh_typecontrat...\n")
	39	sync_typecontrat()
	40	self.stdout.write("Import de rh_typerevalorisation...\n")
	41	sync_typerevalorisation()
	42	self.stdout.write("Import de rh_typeremuneration...\n")
	43	sync_typeremuneration()
	44	self.stdout.write("Import de rh_dossier...\n")
	45	sync_dossier()
	46	self.stdout.write("Import de rh_ayantdroit...\n")
	47	sync_ayantdroit()
	48
	49
	50	def sync_classement():
	51	connection.cursor().execute('TRUNCATE rh_classement')
	52	for classement in legacy.Classement.objects.all():
	53	rh.Classement.objects.create(
	54	id=classement.id_classement,
	55	type=classement.type_classement,
	56	echelon=classement.echelon or 0,
	57	degre=classement.degre or 0,
	58	coefficient=classement.coefficient,
	59	commentaire=classement.commentaire,
	60	date_modification=classement.date_modif,
	61	actif=classement.actif
	62	)
	63
	64	def sync_employe():
65	cursor = connection.cursor()
66	cursor.execute('TRUNCATE rh_employe')
67	cursor.execute('TRUNCATE rh_employecommentaire')
68	odette = User.objects.get(username='odette.tremblay')
69	for fiche in legacy.Fiches.objects.all():
70	employe = rh.Employe.objects.create(
71	id=fiche.no_employe,
72	nom=fiche.nom,
73	prenom=fiche.prenom,
74	nationalite_id=fiche.nationalite,
75	date_naissance=fiche.date_naissance if fiche.date_naissance else None,
76	genre=fiche.sexe.upper(),
77	situation_famille=None if fiche.situation_famille == '-1' else fiche.situation_famille,
78	date_entree=fiche.date_entree,
79	tel_domicile=fiche.tel_domicile,
80	tel_cellulaire=fiche.tel_cellulaire,
81	adresse=fiche.no_rue,
82	ville=fiche.ville,
83	province=fiche.etat_province,
84	code_postal=fiche.code_postal_cedex,
85	pays_id=fiche.pays_iso2,
86	date_creation=fiche.date_ouverture,
87	date_modification=fiche.date_maj,
88	actif=True,
89	supprime=False
90	)
91	if fiche.remarque:
92	rh.EmployeCommentaire.objects.create(
93	employe=employe,
94	texte=fiche.remarque,
95	owner=odette
96	)
97
98	def sync_familleemploi():
99	cursor = connection.cursor()
100	cursor.execute('TRUNCATE rh_familleemploi')
101	for famille in legacy.FamilleEmploi.objects.all():
102	rh.FamilleEmploi.objects.create(
103	id=famille.id_famille_emploi,
104	nom=famille.famille_emploi,
105	actif=famille.actif
106	)
107
108	def sync_typeposte():
109	cursor = connection.cursor()
110	cursor.execute('TRUNCATE rh_typeposte')
111	for type in legacy.Postes.objects.all():
112	rh.TypePoste.objects.create(
113	id=type.id_poste,
114	nom=type.titre_poste_m,
115	nom_feminin=type.titre_poste_f,
116	is_responsable=bool(int(type.poste_responsable)),
117	famille_emploi_id=type.id_famille_emploi,
118	date_modification = type.datemaj,
119	actif=bool(int(type.actif))
120	)
121
122	def sync_service():
123	cursor = connection.cursor()
124	cursor.execute('TRUNCATE rh_service')
125	for service in legacy.DirectionService.objects.all():
126	rh.Service.objects.create(
127	id=service.id_direction_service,
128	nom=service.direction_service,
129	actif=bool(service.actif)
130	)
131
132	def sync_poste():
133	cursor = connection.cursor()
134	cursor.execute('TRUNCATE rh_poste')
135	for poste in legacy.ImplantationPostes.objects.select_related('type_poste'):
136
137	# Aller chercher certaines informations dans le dernier dossier
138	# associé à ce poste
139	dossiers = legacy.Dossiers.objects.filter(
140	Q(poste_1=poste.id_implantation_postes) \| Q(poste_2=poste.id_implantation_postes)
141	).order_by('-id_dossier')
142	poste_du_responsable = 149
143	service = 1
144	complement = ''
145	if dossiers.count() > 0:
146	dossier = dossiers[0]
147
148	# Déterminer le service
149	services = dossier.ids_direction_service
150	service = int(services.split('\|')[0]) if services else 1
151	if poste.id_implantation_postes == dossier.poste_1:
152	complement = dossier.complement_1
153	else:
154	complement = dossier.complement_2
155	complement = ' ' + complement if complement else ''
156
157	# Déterminer le poste du responsable
158	try:
159	responsable = dossier.responsable
160	except legacy.Fiches.DoesNotExist:
161	pass
162	else:
163	dossiers_du_responsable = responsable.dossiers.order_by('-id_dossier')
164	if dossiers_du_responsable.count() > 0:
165	poste_du_responsable = dossiers_du_responsable[0].poste_1
166
167	# Créer le poste
168	rh.Poste.objects.create(
169	id=poste.id_implantation_postes,
170	nom=poste.type_poste.titre_poste_m + complement,
171	nom_feminin=poste.type_poste.titre_poste_f + complement,
172	implantation_id=poste.id_implantation,
173	type_poste_id=poste.type_poste_id,
174	date_modification=poste.date_maj,
175	actif=poste.actif,
176	service_id=service,
177	supprime=False,
178	responsable_id=poste_du_responsable
179	)
180
181	def sync_organismebstg():
182	connection.cursor().execute('TRUNCATE rh_organismebstg')
183	for organisme in legacy.OrganismesBstg.objects.all():
184	rh.OrganismeBstg.objects.create(
185	id=organisme.id_bstg,
186	nom=organisme.organisme_nom,
187	type=organisme.bstg_type,
188	actif=bool(organisme.actif)
189	)
190
191	def sync_statut():
192	connection.cursor().execute('TRUNCATE rh_statut')
193	for statut in legacy.Statut.objects.all():
194	rh.Statut.objects.create(
195	id=statut.id_statut,
196	code=statut.statut_contractuel,
197	nom=statut.description_statut_contractuel,
198	actif=bool(statut.actif)
199	)
200
201	def sync_tauxchange():
202	connection.cursor().execute('TRUNCATE rh_tauxchange')
203	connection.cursor().execute('TRUNCATE rh_devise')
6c1ea828 EMS	204
	205	# Certaines devises ont besoin d'un id spécifique (#2581)
	206	rh.Devise.objects.create(id=1, code='AMD', nom='Dram arménien')
	207	rh.Devise.objects.create(id=2, code='CAD', nom='Dollar canadien')
	208	rh.Devise.objects.create(id=3, code='CAN', nom='Dollar canadien')
	209	rh.Devise.objects.create(id=4, code='DZD', nom='Dinar algérien')
	210	rh.Devise.objects.create(id=5, code='EUR', nom='Euro')
	211	rh.Devise.objects.create(id=6, code='GNF', nom='Franc Guinéen')
	212	rh.Devise.objects.create(id=7, code='KMF', nom='Franc comorien')
	213	rh.Devise.objects.create(id=8, code='LBP', nom='Livre libanaise')
	214	rh.Devise.objects.create(id=9, code='MAD', nom='Dirham marocain')
	215	rh.Devise.objects.create(id=10, code='MGF', nom='Franc Malgache')
	216	rh.Devise.objects.create(id=11, code='MRO', nom='Ouguiya')
	217	rh.Devise.objects.create(id=12, code='MUR', nom='Roupie mauricienne')
	218	rh.Devise.objects.create(id=13, code='SYP', nom='Livre syrienne')
	219	rh.Devise.objects.create(id=14, code='TND', nom='Dinar tunisien')
	220	rh.Devise.objects.create(id=15, code='US ', nom='Dollar américain')
	221	rh.Devise.objects.create(id=16, code='USD', nom='Dollar américain')
	222	rh.Devise.objects.create(id=17, code='VUV', nom='Vatu')
	223	rh.Devise.objects.create(id=18, code='XAF', nom='Franc CFA')
	224	rh.Devise.objects.create(id=19, code='XOF', nom='Franc CFA')
	225
ca1a7b76 EMS	226	for taux in legacy.TauxChangeAnnuel.objects.exclude(taux_annuel=None):
	227
	228	# Créer la devise
	229	devise, created = rh.Devise.objects.get_or_create(code=taux.code_devise)
	230	if created:
	231	devise.nom=taux.nom_devise
	232	devise.save()
	233
	234	# Créer le taux de change
	235	rh.TauxChange.objects.get_or_create(
	236	devise=devise,
	237	annee=taux.annee,
	238	taux=taux.taux_annuel,
	239	actif=True
	240	)
	241
	242	def sync_valeurpoint():
	243	connection.cursor().execute('TRUNCATE rh_valeurpoint')
	244	for vp in legacy.ValeurPoint.objects.all():
	245
	246	# Trouver la devise associée à cette implantation
	247	try:
	248	taux = legacy.TauxChangeAnnuel.objects.get(annee='2011', id_implantation=vp.id_implantation)
	249	except legacy.TauxChangeAnnuel.DoesNotExist:
	250	devise = None
	251	else:
	252	devise = rh.Devise.objects.get(code=taux.code_devise)
	253
	254	rh.ValeurPoint.objects.create(
	255	id=vp.id_valeur_point,
	256	valeur=vp.valeur_point,
	257	implantation_id=vp.id_implantation,
	258	annee=vp.date_actif[:4],
	259	actif=True,
	260	devise=devise
	261	)
	262
	263	def sync_typecontrat():
	264	connection.cursor().execute('TRUNCATE rh_typecontrat')
	265	for type in legacy.TypeContrat.objects.all():
	266	rh.TypeContrat.objects.create(
	267	id=type.id_type_contrat,
	268	nom=type.nom_contrat,
	269	nom_long=type.description_contrat,
	270	actif=bool(type.actif_contrat)
	271	)
	272
	273	def sync_typerevalorisation():
	274	connection.cursor().execute('TRUNCATE rh_typerevalorisation')
	275	for type in legacy.TypeRevalorisation.objects.all():
	276	rh.TypeRevalorisation.objects.create(
	277	id=type.id_type_revalorisation,
	278	nom=type.type_revalorisation,
	279	actif=bool(type.actif)
	280	)
	281
	282	def sync_typeremuneration():
	283	connection.cursor().execute('TRUNCATE rh_typeremuneration')
	284	for type in legacy.TypeRemuneration.objects.all():
	285	rh.TypeRemuneration.objects.create(
	286	id=type.id_type_remuneration,
	287	nom=type.type_remuneration,
	288	type_paiement=type.type_paiement,
	289	nature_remuneration=type.nature_remuneration,
290	actif=bool(type.actif)
291	)
292
293	def sync_dossier():
294
295	def clean_date(date):
296	if date == '2003-06-31': # date inexistante (dossier 791-1)
297	return '2003-06-30'
298	elif date:
299	return date
300	else:
301	return None
302
303	taux_cache = {}
304	def get_taux(annee, devise):
305	taux = taux_cache.get((annee, devise))
306	if taux is not None:
307	return taux
308	taux = rh.TauxChange.objects.filter(annee__gte=annee).order_by('annee')[0].taux
309	taux_cache[(annee, devise)] = taux
310	return taux
311
312	cursor = connection.cursor()
313	cursor.execute('TRUNCATE rh_contrat')
314	cursor.execute('TRUNCATE rh_dossier')
315	cursor.execute('TRUNCATE rh_remuneration')
316	cursor.execute('TRUNCATE rh_dossiercommentaire')
317	odette = User.objects.get(username='odette.tremblay')
318	type_contrat_inconnu = rh.TypeContrat.objects.create(
319	nom='Inconnu',
320	nom_long='Inconnu',
321	actif=False
322	)
323	for dossier in legacy.Dossiers.objects.all():
324	dossier1 = rh.Dossier.objects.create(
325	employe_id=dossier.employe_id,
326	poste_id=dossier.poste_1,
327	statut_id=dossier.id_statut,
328	organisme_bstg_id=dossier.id_bstg,
329	statut_residence='expat' if dossier.id_local_expatrie == 1 else 'local',
330	classement_id=dossier.id_classement,
331	regime_travail=dossier.regime_travail,
332	date_debut=clean_date(dossier.date_debut_mandat),
333	date_fin=clean_date(dossier.date_fin_mandat),
334	remplacement=False,
335	actif=True,
336	supprime=False
337	)
338	if dossier.remarque:
339	rh.DossierCommentaire.objects.create(
340	dossier=dossier1,
341	texte=dossier.remarque,
342	owner=odette
343	)
344	rh.Contrat.objects.create(
345	dossier=dossier1,
346	type_contrat_id=dossier.id_type_contrat or type_contrat_inconnu.id,
347	date_debut=clean_date(dossier.date_debut_contrat),
348	date_fin=clean_date(dossier.date_fin_contrat),
349	actif=True,
350	supprime=False
351	)
352
353
354	remuns_precedentes = {}
355	charges_precedentes = None
356	pourcentage_charges = 0
357	devise_charges = rh.Devise.objects.get(code='EUR')
358	for remun in legacy.HistoRemuneration.objects.filter(no_dossier=dossier.no_dossier) \
359	.order_by('id_histo_remuneration'):
360
361	# Calcul de la période
362	date_debut = remun.date_effective
363	if date_debut == '200-08-09':
364	date_debut = '2000-08-09'
365	elif date_debut == '2003-06-31':
366	date_debut = '2003-06-30'
367	if remun.type_remuneration.type_paiement == 'Ponctuel':
368	date_fin = date_debut
369	else:
370	date_fin = None
371	remun_precedente = remuns_precedentes.get(remun.type_remuneration_id)
372	if remun_precedente:
373	if str(remun_precedente.date_debut) == str(date_debut):
374	remun_precedente.delete()
375	else:
376	remun_precedente.date_fin = date_debut
377	remun_precedente.save()
378
379	# Création de la ligne de rémunération
380	if remun.type_remuneration.nature_remuneration != 'Charges' and remun.montant != 0:
381	devise, created = rh.Devise.objects.get_or_create(code=remun.code_devise)
382
383	rh_remun = rh.Remuneration.objects.create(
384	actif=True,
385	dossier=dossier1,
386	type_id=remun.type_remuneration_id,
387	type_revalorisation_id=remun.id_type_revalorisation,
388	montant=remun.montant,
389	devise=devise,
390	supprime=False,
391	date_debut=date_debut,
392	date_fin=date_fin
393	)
394
395	# Se souvenir de ce type de rémunération
396	if remun.type_remuneration.type_paiement == u'Régulier':
397	remuns_precedentes[remun.type_remuneration_id] = rh_remun
398
399	# Charges patronales
400	if remun.type_remuneration.nature_remuneration == 'Charges':
401	pourcentage_charges = remun.pourcentage
402
403	if remun.type_remuneration.nature_remuneration == 'Traitement':
404	devise_charges = rh.Devise.objects.get(code=remun.code_devise)
405
406	if remun.type_remuneration.type_paiement == u'Régulier':
407	charges = 0
408	annee_charges = int(date_debut[:4])
409	taux2 = get_taux(annee_charges, devise_charges)
410	if pourcentage_charges:
411	for remun_precedente in remuns_precedentes.values():
412	montant = remun_precedente.montant
413	devise = remun_precedente.devise
414	if devise != devise_charges:
415	taux1 = get_taux(annee_charges, devise)
416	montant = montant * Decimal(str(taux1)) / Decimal(str(taux2))
417	if remun_precedente.type.nature_remuneration == 'Traitement':
418	montant = montant * remun_precedente.dossier.regime_travail / 100
419	montant = montant * pourcentage_charges / 100
420	montant.quantize(remun_precedente.montant)
421	charges += montant
422	charges = charges * pourcentage_charges / 100
423	if charges_precedentes:
424	if str(charges_precedentes.date_debut) == str(date_debut):
425	charges_precedentes.delete()
426	else:
427	charges_precedentes.date_fin = date_debut
428	charges_precedentes.save()
429	if charges > 0 and \
430	(not charges_precedentes or charges_precedentes.montant != charges or
431	str(charges_precedentes.date_debut) == str(date_debut)):
432	charges_precedentes = rh.Remuneration.objects.create(
433	actif=True,
434	dossier=dossier1,
435	type_id=17,
436	type_revalorisation_id=None,
437	montant=charges,
438	devise=devise_charges,
439	supprime=False,
440	date_debut=date_debut,
441	commentaire=u'Charges patronales: %s%%' % pourcentage_charges
442	)
443
444	# Dossier différent pour le deuxième poste
445	if dossier.poste_2:
446	dossier2 = rh.Dossier.objects.create(
447	employe_id=dossier.employe_id,
448	poste_id=dossier.poste_2,
449	statut_id=dossier.id_statut,
450	organisme_bstg_id=dossier.id_bstg,
451	statut_residence='expat' if dossier.id_local_expatrie == 1 else 'local',
452	classement_id=dossier.id_classement,
453	regime_travail=dossier.regime_travail,
454	date_debut=clean_date(dossier.date_debut_mandat),
455	date_fin=clean_date(dossier.date_fin_mandat),
456	remplacement=False,
457	actif=True,
458	supprime=False
459	)
460	if dossier.remarque:
461	rh.DossierCommentaire.objects.create(
462	dossier=dossier2,
463	texte=dossier.remarque,
464	owner=odette
465	)
466	rh.Contrat.objects.create(
467	dossier=dossier2,
468	type_contrat_id=dossier.id_type_contrat or type_contrat_inconnu.id,
469	date_debut=clean_date(dossier.date_debut_contrat),
470	date_fin=clean_date(dossier.date_fin_contrat),
471	actif=True,
472	supprime=False
473	)
474
475	def sync_ayantdroit():
476	connection.cursor().execute('TRUNCATE rh_ayantdroit')
477	odette = User.objects.get(username='odette.tremblay')
478	for ad in legacy.AyantDroit.objects.all():
479	rh_ad = rh.AyantDroit.objects.create(
480	id=ad.id_ayant_droit,
481	nom=ad.nom_ayant_droit,
482	prenom=ad.prenom_ayant_droit,
483	employe_id=ad.no_employe,
484	lien_parente=None if ad.lien_parente == 'Autre' else ad.lien_parente,
485	actif=bool(ad.actif)
486	)
487	if ad.commentaire_ayant_droit:
488	rh.AyantDroitCommentaire.objects.create(
489	ayant_droit=rh_ad,
490	texte=ad.commentaire_ayant_droit,
491	owner=odette
492	)