Présentation de l'entreprise
Nom : Codial
Secteur : Éditeur ERP pour le bâtiment
Codial est un ERP modulaire permettant aux entreprises du bâtiment de gérer efficacement leurs devis, achats, chantiers, interventions, factures et suivi budgétaire.
(ERP = Enterprise Resource Planning➜ C’est un système informatique qui centralise et automatise toutes les fonctions principales d’une entreprise : comptabilité, ventes, achats, stocks, production, RH, gestion de projet, etc.)
Le logiciel est utilisé par plus de 10 000 entreprises en France, avec une interface intuitive et des fonctionnalités adaptées aux métiers du bâtiment.
Codial propose également des options de personnalisation pour répondre aux besoins spécifiques de chaque entreprise cliente.
Le stage s'est déroulé dans le cadre de la formation BTS SIO, option SLAM (Solutions Logicielles et Applications Métiers).
Le logiciel Codial est développé en WLanguage, un langage propriétaire de l'éditeur PC SOFT. Il utilise le moteur de base de données HFSQL.
Objectif et missions
Le stage avait pour objectif de développer une fiche personnalisée de gestion budgétaire de chantier, directement intégrée à Codial. Elle permet un suivi précis des postes de dépenses, comparé aux budgets initiaux.
- Formation tronc commun sur les modules Codial
- Analyse fonctionnelle des besoins chantier
- Création de la fiche avec affichage des ventes, achats, écarts et prévisions
- Développement de macros avec WLanguage
- Utilisation de requêtes SQL via HFSQL
À quoi sert la fiche personnalisée Codial ?
La fiche personnalisée de gestion budgétaire développée dans Codial est un outil central pour le suivi de chantier. Elle permet de :
- Visualiser en temps réel tous les postes de dépenses (fournitures, main d’œuvre, sous-traitance, matériel, etc.)
- Comparer les montants engagés, réalisés et prévus à terme avec les budgets initiaux
- Suivre les écarts, les marges, les restes à engager et à facturer
- Automatiser les calculs grâce à des macros WLanguage (écarts, marges, taux d’avancement, etc.)
- Centraliser toutes les informations financières du chantier sur une seule fiche, accessible et lisible par tous les intervenants
Évolution de la fiche personnalisée : de la création à la finalité
Ce processus d’évolution montre comment la fiche passe d’un simple gabarit à un outil complet de pilotage budgétaire, grâce à l’intégration progressive des données et des automatisations développées durant le stage.
Développement et présentation des macros WLanguage
Le langage utilisé est WLanguage, un langage propriétaire intégré dans l’environnement WinDev, particulièrement adapté au développement d’applications de gestion et d’ERP. Durant mon stage, j’ai été amené à concevoir et implémenter de nombreuses macros permettant d’automatiser les calculs budgétaires, la gestion des achats, le suivi des prévisions et l’analyse des écarts dans Codial.
Ces macros facilitent la centralisation et la fiabilisation des données, tout en offrant une interface claire et dynamique pour les utilisateurs. Elles permettent d’automatiser des tâches complexes, de réduire les risques d’erreur humaine et d’accélérer la prise de décision sur le chantier.
Ci-dessous, un exemple représentatif d'une macro développée pour automatiser le suivi budgétaire dans Codial.
Macro Achat
Voir le code
// Formatage numérique
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 2
f.SéparateurMilliers = " "
// Initialisation
total est un réel = 0
Four, PNA, MO, SST, DIV, MAT sont des réels
// --- Requête Commandes directes (HT) ---
req_cof est une requête sql =
[
select sum(LIGNECOM.MONTANTT) as MNTCOF, LIGNECOM.IDCOD_RUBRIQUE
from LIGNECOM
where LIGNECOM.COCLEUNIK in (
select COD_SYNTHESE_DOC.ID_DOC from COD_SYNTHESE_DOC
where COD_SYNTHESE_DOC.TYPE_DOC = 1
and COD_SYNTHESE_DOC.IDCOD_PROJET = {idprojet}
)
and LIGNECOM.IDCOD_RUBRIQUE <> 0
group by LIGNECOM.IDCOD_RUBRIQUE
]
req_cof.idprojet = cod_projet.IDCOD_PROJET
// --- Requête BL non transférés (ni en commande ni en facture) ---
req_blf est une requête sql =
[
select sum(LIGNEBLF.MONTANTT) as MNTBLF, LIGNEBLF.IDCOD_RUBRIQUE
from LIGNEBLF
where LIGNEBLF.BFCLEUNIK in (
select COD_SYNTHESE_DOC.ID_DOC
from COD_SYNTHESE_DOC
where COD_SYNTHESE_DOC.TYPE_DOC = 16
and COD_SYNTHESE_DOC.IDCOD_PROJET = {idprojet}
and COD_SYNTHESE_DOC.NUM_DOC not in (
select FA4_DOC_AUDIT_TRANSF.NUMDOC_SOURCE
from FA4_DOC_AUDIT_TRANSF
where FA4_DOC_AUDIT_TRANSF.TYPEDOC_SOURCE = 16 and FA4_DOC_AUDIT_TRANSF.TYPEDOC_CIBLE = 17
)
and COD_SYNTHESE_DOC.NUM_DOC not in (
select FA4_DOC_AUDIT_TRANSF.NUMDOC_CIBLE
from FA4_DOC_AUDIT_TRANSF
where FA4_DOC_AUDIT_TRANSF.TYPEDOC_SOURCE = 1 and FA4_DOC_AUDIT_TRANSF.TYPEDOC_CIBLE = 16
)
)
group by LIGNEBLF.IDCOD_RUBRIQUE
]
req_blf.idprojet = cod_projet.IDCOD_PROJET
// --- Requête main d'œuvre suivie ---
req_mat_suiviop est une requête sql =
[
SELECT SUM(SUIVIOP.NBRHEURE * SUIVIOP.COUT_HORAIRE) AS MAT
FROM SUIVIOP
WHERE SUIVIOP.NUMCOM = {idprojet}
AND SUIVIOP.DOCUMENT = 'PROJET'
AND SUIVIOP.NATURE = 1
]
req_mat_suiviop.idprojet = cod_projet.IDCOD_PROJET
SI PAS HExécuteRequêteSQL(req_mat_suiviop) ALORS
erreur(HErreurInfo())
SINON
SI req_mat_suiviop.MAT <> Null ALORS
MAT += req_mat_suiviop.MAT
Total += req_mat_suiviop.MAT
FIN
FIN
// --- Exécution Commandes directes ---
si pas HExécuteRequêteSQL(req_cof) alors
erreur(herreurinfo())
sinon
pour tout req_cof
selon req_cof.IDCOD_RUBRIQUE
cas 2 : PNA += req_cof.MNTCOF; total += req_cof.MNTCOF
cas 3 : MO += req_cof.MNTCOF; total += req_cof.MNTCOF
cas 4 : Four += req_cof.MNTCOF; total += req_cof.MNTCOF
cas 5 : SST += req_cof.MNTCOF; total += req_cof.MNTCOF
cas 6 : MAT += req_cof.MNTCOF; total += req_cof.MNTCOF
cas 7 : DIV += req_cof.MNTCOF; total += req_cof.MNTCOF
fin
fin
FIN
// --- Exécution BL non transférés ---
si pas HExécuteRequêteSQL(req_blf) alors
erreur(herreurinfo())
sinon
pour tout req_blf
selon req_blf.IDCOD_RUBRIQUE
cas 2 : PNA += req_blf.MNTBLF; total += req_blf.MNTBLF
cas 4 : Four += req_blf.MNTBLF; total += req_blf.MNTBLF
cas 6 : MAT += req_blf.MNTBLF; total += req_blf.MNTBLF
cas 7 : DIV += req_blf.MNTBLF; total += req_blf.MNTBLF
fin
fin
FIN
// --- Affichage final ---
RUB_E_FOUR = NumériqueVersChaîne(Four, f) + " €"
RUB_E_PNA = NumériqueVersChaîne(PNA, f) + " €"
RUB_E_MO = NumériqueVersChaîne(MO, f) + " €"
RUB_E_STT = NumériqueVersChaîne(SST, f) + " €"
RUB_E_DIV = NumériqueVersChaîne(DIV, f) + " €"
RUB_E_MAT = NumériqueVersChaîne(MAT, f) + " €"
RUB_E_TOTAL = NumériqueVersChaîne(total, f) + " €"
// --- Requête factures non transférées ---
req_fact_non_transf est une requête SQL =
[
SELECT SUM(LIGNEFAF.MONTANTT) AS MNTFF, LIGNEFAF.IDCOD_RUBRIQUE
FROM LIGNEFAF
WHERE LIGNEFAF.FFCLEUNIK IN (
SELECT COD_SYNTHESE_DOC.ID_DOC
FROM COD_SYNTHESE_DOC
WHERE COD_SYNTHESE_DOC.TYPE_DOC = 17
AND COD_SYNTHESE_DOC.IDCOD_PROJET = {idprojet}
AND COD_SYNTHESE_DOC.NUM_DOC NOT IN (
SELECT NUMDOC_CIBLE
FROM FA4_DOC_AUDIT_TRANSF
WHERE TYPEDOC_SOURCE IN (1, 16) AND TYPEDOC_CIBLE = 17
)
)
GROUP BY LIGNEFAF.IDCOD_RUBRIQUE
]
req_fact_non_transf.idprojet = cod_projet.IDCOD_PROJET
// Initialisation des variables supplémentaires
FactFour, FactPNA, FactMO, FactSST, FactDIV, FactMAT sont des réels = 0
si pas HExécuteRequêteSQL(req_fact_non_transf) alors
erreur(herreurinfo())
sinon
pour tout req_fact_non_transf
selon req_fact_non_transf.IDCOD_RUBRIQUE
cas 2 : FactPNA += req_fact_non_transf.MNTFF
//CAS 3 : FactMO += req_fact_non_transf.MNTFF
cas 4 : FactFour += req_fact_non_transf.MNTFF
cas 5 : FactSST += req_fact_non_transf.MNTFF
cas 6 : FactMAT += req_fact_non_transf.MNTFF
cas 7 : FactDIV += req_fact_non_transf.MNTFF
fin
fin
FIN
// --- Affectation des FE_* = RUB_E_* + Factures non transférées ---
FE_FOUR = NumériqueVersChaîne(Four + FactFour, f) + " €"
FE_PNA = NumériqueVersChaîne(PNA + FactPNA, f) + " €"
//FE_MO = NumériqueVersChaîne(MO + FactMO, f) + " €"
FE_STT = NumériqueVersChaîne(SST + FactSST, f) + " €"
FE_DIV = NumériqueVersChaîne(DIV + FactDIV, f) + " €"
FE_MAT = NumériqueVersChaîne(MAT + FactMAT, f) + " €"
// --- Total FE
FE_TOTAL = NumériqueVersChaîne(Four + PNA + MO + SST + DIV + MAT + FactFour + FactPNA + FactMO + FactSST + FactDIV + FactMAT, f) + " €"
RUB_E_MO = RUB_M_MO
FE_MO = RUB_M_MO
Cette macro "Achat" en WLanguage permet de calculer et d'afficher le total des achats par rubrique (fournitures, main d'œuvre, matériel, etc.) pour un projet donné dans Codial.
Elle utilise plusieurs requêtes SQL pour agréger les montants selon leur type (commandes, bons de livraison, factures non transférées), puis affiche les résultats formatés pour chaque poste budgétaire.
Ce traitement automatisé facilite le suivi budgétaire précis et la gestion des écarts dans l’ERP.
Macro principale : BUDGET
Voir le code
// Formatage numérique
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 2
f.SéparateurMilliers = " "
Total est un reel = 0
req_lignes est une requête SQL =
[
select sum(LIGNEDEV.QTEU * LIGNEDEV.PRIX_ACHAT) as TOTAL, sum(LIGNEDEV.QTEU) As heures, cod_rubrique.LIBELLE
from devis
join LIGNEDEV on LIGNEDEV.D0CLEUNIK = DEVIS.D0CLEUNIK
join cod_rubrique on cod_rubrique.IDCOD_RUBRIQUE = lignedev.IDCOD_RUBRIQUE
where devis.INT_DEVIS_EXECUTION = 1 and devis.IDCOD_PROJET = {idprojet}
group by cod_rubrique.LIBELLE
]
req_lignes.idprojet = cod_projet.IDCOD_PROJET
si pas HExécuteRequêteSQL(req_lignes) alors
erreur(herreurinfo())
sinon
pour tout req_lignes
selon req_lignes.LIBELLE
CAS "FOURNITURE" : RUB_FOUR = NumériqueVersChaîne(req_lignes.TOTAL,f) + " €"
Total += req_lignes.TOTAL
CAS "PIECE NON AFFECTEE" : RUB_PIECE = NumériqueVersChaîne(req_lignes.TOTAL,f)+ " €"
Total += req_lignes.TOTAL
CAS "MAIN D'OEUVRE" : RUB_MO = NumériqueVersChaîne(req_lignes.TOTAL,f)+ " €"
Total += req_lignes.TOTAL
RUB_H = NumériqueVersChaîne(req_lignes.heures,f)+ " h"
CAS "SOUS-TRAITANCE" : RUB_SST = NumériqueVersChaîne(req_lignes.TOTAL,f)+ " €"
Total += req_lignes.TOTAL
Cas "DIVERS" : RUB_DIVERS = NumériqueVersChaîne(req_lignes.TOTAL,f)+ " €"
Total += req_lignes.TOTAL
CAS "MATERIEL" : RUB_MAT = NumériqueVersChaîne(req_lignes.TOTAL,f)+ " €"
Total += req_lignes.TOTAL
fin
fin
RUB_TOTAL = NumériqueVersChaîne(Total,f)+ " €"
FIN
//################################################################################################################################ PV THEO ################################################################################################################################################################
pMacFPFacture()
pMacFPAchat()
pMacFPResteEngager()
pMacFPCalculeRAE()
pMacFPPrevisionTerme()
pMacFPEcart()
pMacFPCouleurEcart()
pMacFPMargePAT()
pMacFPMargePrevue()
pMacFPMargeCourante()
pMacFPMontantMarch()
pMacFPMontantFacture()
pMacFPResteFActure()
pMacFPMontantTTC()
pMacFPAvancement()
pMacFPCouleurMarge()
pMacFPEncaissement()
pMacFPSSTFOUR()
pMacFPSSTFOUR2()
Cette macro principale "BUDGET" regroupe toutes les sous-macros nécessaires au calcul et à l'affichage du budget d'un projet dans Codial.
Elle effectue une agrégation des montants par rubrique (fourniture, main d'œuvre, sous-traitance, etc.) à partir des devis, puis appelle en cascade toutes les autres macros spécialisées pour gérer les factures, achats, prévisions, marges, avancements, etc.
Ce fonctionnement centralisé permet d'obtenir une vision complète et dynamique du suivi budgétaire du chantier.
Macro Calcule Reste à Engager
Voir le code
// Définition du format
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 2
f.SéparateurMilliers = " "
// Récupération des valeurs pour le calcul du prix unitaire
MO_Totale est un réel = ChaîneVersNumérique(remplace(RUB_MO," ",""))
NbHeures est un réel = ChaîneVersNumérique(remplace(RUB_H," ",""))
// Calcul du prix unitaire de la main d'œuvre
PrixUnitaireMO est un réel
SI NbHeures <> 0 ALORS
PrixUnitaireMO = MO_Totale / NbHeures
SINON
PrixUnitaireMO = 0
FIN
// Récupération du nombre de main d’œuvre (RAE_N_MO1)
NbMO est un réel = ChaîneVersNumérique(remplace(RAE_N_MO1," ",""))
// Calcul du montant main d’œuvre
MO est un réel = PrixUnitaireMO * NbMO
// Récupération des autres montants
FOUR est un réel = ChaîneVersNumérique(remplace(RAE_M_FOUR1," ",""))
PNA est un réel = ChaîneVersNumérique(remplace(RAE_M_PNA1," ",""))
SST est un réel = ChaîneVersNumérique(remplace(RAE_M_SST1," ",""))
DIVERS est un réel = ChaîneVersNumérique(remplace(RAE_M_DIVERS1," ",""))
MAT est un réel = ChaîneVersNumérique(remplace(RAE_M_MAT2," ",""))
// Calcul du total
TOTAL est un réel = FOUR + PNA + MO + SST + DIVERS + MAT
// Mise à jour des champs avec formatage
RAE_M_MO1 = NumériqueVersChaîne(MO, f) + " €"
RAE_M_FOUR1 = NumériqueVersChaîne(FOUR, f) + " €"
RAE_M_PNA1 = NumériqueVersChaîne(PNA, f) + " €"
RAE_M_SST1 = NumériqueVersChaîne(SST, f) + " €"
RAE_M_DIVERS1 = NumériqueVersChaîne(DIVERS, f) + " €"
RAE_M_MAT2 = NumériqueVersChaîne(MAT, f) + " €"
RAE_M_TOTAL = NumériqueVersChaîne(TOTAL, f) + " €"
RAE_N_MO1 = NumériqueVersChaîne(ChaîneVersNumérique(remplace(RAE_N_MO1," ","")), f) + " h"
Cette macro "Calcule reste à engager" permet de calculer le montant restant à engager pour chaque poste (main d'œuvre, fournitures, sous-traitance, etc.) en fonction des quantités et des prix unitaires.
Elle met à jour dynamiquement les champs de la fiche avec les valeurs calculées et formatées, facilitant ainsi le suivi précis des engagements restants sur le chantier.
Macro CouleurEcart
Voir le code
E est un réel
// FOURNITURE
E = ChaîneVersNumérique(remplace(ECART_FOUR, " €", ""))
SI E < 0 ALORS
ECART_FOUR..Couleur = RGB(255, 0, 0)
SINON SI E > 0 ALORS
ECART_FOUR..Couleur = RGB(0, 153, 0)
SINON
ECART_FOUR..Couleur = RGB(0, 0, 0)
FIN
// PIÈCE NON AFFECTÉE
E = ChaîneVersNumérique(remplace(ECART_PNA, " €", ""))
SI E < 0 ALORS
ECART_PNA..Couleur = RGB(255, 0, 0)
SINON SI E > 0 ALORS
ECART_PNA..Couleur = RGB(0, 153, 0)
SINON
ECART_PNA..Couleur = RGB(0, 0, 0)
FIN
// MAIN D’ŒUVRE
E = ChaîneVersNumérique(remplace(ECART_MO, " €", ""))
SI E < 0 ALORS
ECART_MO..Couleur = RGB(255, 0, 0)
SINON SI E > 0 ALORS
ECART_MO..Couleur = RGB(0, 153, 0)
SINON
ECART_MO..Couleur = RGB(0, 0, 0)
FIN
// SOUS-TRAITANCE
E = ChaîneVersNumérique(remplace(ECART_SST, " €", ""))
SI E < 0 ALORS
ECART_SST..Couleur = RGB(255, 0, 0)
SINON SI E > 0 ALORS
ECART_SST..Couleur = RGB(0, 153, 0)
SINON
ECART_SST..Couleur = RGB(0, 0, 0)
FIN
// DIVERS
E = ChaîneVersNumérique(remplace(ECART_DIVERS, " €", ""))
SI E < 0 ALORS
ECART_DIVERS..Couleur = RGB(255, 0, 0)
SINON SI E > 0 ALORS
ECART_DIVERS..Couleur = RGB(0, 153, 0)
SINON
ECART_DIVERS..Couleur = RGB(0, 0, 0)
FIN
// MATÉRIEL
E = ChaîneVersNumérique(remplace(ECART_MAT, " €", ""))
SI E < 0 ALORS
ECART_MAT..Couleur = RGB(255, 0, 0)
SINON SI E > 0 ALORS
ECART_MAT..Couleur = RGB(0, 153, 0)
SINON
ECART_MAT..Couleur = RGB(0, 0, 0)
FIN
// TOTAL
E = ChaîneVersNumérique(remplace(ECART_TOTAL, " €", ""))
SI E < 0 ALORS
ECART_TOTAL..Couleur = RGB(255, 0, 0)
SINON SI E > 0 ALORS
ECART_TOTAL..Couleur = RGB(0, 153, 0)
SINON
ECART_TOTAL..Couleur = RGB(0, 0, 0)
FIN
Cette macro "CouleurEcart" applique automatiquement une couleur aux champs d'écart selon leur valeur : rouge si négatif, vert si positif, noir si nul.
Cela permet de visualiser rapidement les postes en dépassement ou en économie sur la fiche chantier.
Macro CouleurMarge
Voir le code
E est un réel
F est un réel
G est un réel
// Marge courante
E = ChaîneVersNumérique(remplace(RUB_MC, " %", ""))
F = ChaîneVersNumérique(remplace(RUB_MP, " %", ""))
SI E < F ALORS
RUB_MC..Couleur = RGB(255, 0, 0)
SINON SI E > F ALORS
RUB_MC..Couleur = RGB(0, 153, 0)
FIN
// Marge PAT
F = ChaîneVersNumérique(remplace(RUB_MP, " %", ""))
G = ChaîneVersNumérique(remplace(RUB_PAT, " %", ""))
SI G < F ALORS
RUB_PAT..Couleur = RGB(255, 0, 0)
SINON SI G > F ALORS
RUB_PAT..Couleur = RGB(0, 153, 0)
FIN
Cette macro "CouleurMarge" applique une couleur aux champs de marge selon leur comparaison : rouge si la marge courante ou PAT est inférieure à la marge prévue, vert si elle est supérieure.
Cela permet de visualiser rapidement les marges en alerte ou favorables sur la fiche chantier.
Macro Ecart
Voir le code
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 2
f.SéparateurMilliers = " "
// FOURNITURE
AA est un réel = ChaîneVersNumérique(remplace(RUB_FOUR, " ", ""))
B est un réel = ChaîneVersNumérique(remplace(PAT_M_FOUR, " ", ""))
ECART_FOUR = NumériqueVersChaîne(AA - B, f) + " €"
// PIÈCE NON AFFECTÉE
AA = ChaîneVersNumérique(remplace(RUB_PIECE, " ", ""))
B = ChaîneVersNumérique(remplace(PAT_M_PNA, " ", ""))
ECART_PNA = NumériqueVersChaîne(AA - B, f) + " €"
// MAIN D’ŒUVRE
AA = ChaîneVersNumérique(remplace(RUB_MO, " ", ""))
B = ChaîneVersNumérique(remplace(PAT_M_MO, " ", ""))
ECART_MO = NumériqueVersChaîne(AA - B, f) + " €"
// SOUS-TRAITANCE
AA = ChaîneVersNumérique(remplace(RUB_SST, " ", ""))
B = ChaîneVersNumérique(remplace(PAT_M_SST, " ", ""))
ECART_SST = NumériqueVersChaîne(AA - B, f) + " €"
// DIVERS
AA = ChaîneVersNumérique(remplace(RUB_DIVERS, " ", ""))
B = ChaîneVersNumérique(remplace(PAT_M_DIVERS, " ", ""))
ECART_DIVERS = NumériqueVersChaîne(AA - B, f) + " €"
// MATÉRIEL
AA = ChaîneVersNumérique(remplace(RUB_MAT, " ", ""))
B = ChaîneVersNumérique(remplace(PAT_M_MAT, " ", ""))
ECART_MAT = NumériqueVersChaîne(AA - B, f) + " €"
// TOTAL
AA = ChaîneVersNumérique(remplace(RUB_TOTAL, " ", ""))
B = ChaîneVersNumérique(remplace(PAT_M_TOTAL, " ", ""))
ECART_TOTAL = NumériqueVersChaîne(AA - B, f) + " €
Cette macro "Ecart" calcule la différence entre le réalisé et le prévisionnel pour chaque poste budgétaire (fourniture, main d'œuvre, sous-traitance, etc.) ainsi que le total.
Elle permet d'afficher instantanément les écarts financiers sur la fiche chantier, facilitant le suivi et l'analyse des dépassements ou économies.
Macro Facture Fournisseur
Voir le code
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 2
f.SéparateurMilliers = " "
Total est un reel = 0
MAT est un reel
req_lignes est une requête SQL =
[
select sum(LIGNEFAF.MONTANTT) as TOTAL, cod_rubrique.LIBELLE
from FACTUREF
join LIGNEFAF on LIGNEFAF.FFCLEUNIK = FACTUREF.FFCLEUNIK
join cod_rubrique on cod_rubrique.IDCOD_RUBRIQUE = LIGNEFAF.IDCOD_RUBRIQUE
join COD_SYNTHESE_DOC on COD_SYNTHESE_DOC.NUM_DOC = FACTUREF.NUMERO
WHERE COD_SYNTHESE_DOC.TYPE_DOC = 17 AND COD_SYNTHESE_DOC.idcod_projet = {idprojet}
group by cod_rubrique.LIBELLE
]
req_lignes.idprojet = cod_projet.IDCOD_PROJET
si pas HExécuteRequêteSQL(req_lignes) alors
erreur(herreurinfo())
sinon
pour tout req_lignes
selon req_lignes.LIBELLE
CAS "FOURNITURE" : RUB_M_FOUR = NumériqueVersChaîne(req_lignes.TOTAL,f) + " €"
Total += req_lignes.TOTAL
CAS "PIECE NON AFFECTEE" : RUB_M_PNA = NumériqueVersChaîne(req_lignes.TOTAL,f)+ " €"
Total += req_lignes.TOTAL
CAS "MAIN D'OEUVRE" : RUB_M_MO = NumériqueVersChaîne(req_lignes.TOTAL,f)+ " €"
Total += req_lignes.TOTAL
CAS "SOUS-TRAITANCE" : RUB_M_STT = NumériqueVersChaîne(req_lignes.TOTAL,f)+ " €"
Total += req_lignes.TOTAL
Cas "DIVERS" : RUB_M_DIV = NumériqueVersChaîne(req_lignes.TOTAL,f)+ " €"
Total += req_lignes.TOTAL
CAS "MATERIEL" : MAT = req_lignes.TOTAL
Total += req_lignes.TOTAL
fin
fin
// -------------------------------------- Realisé ---------------------------------
// MO
reqmo est une requête SQL = [
select sum(SUIVIOP.NBRHEURE * SUIVIOP.COUT_HORAIRE) as MO, sum(SUIVIOP.NBRHEURE) AS NB
from SUIVIOP
where SUIVIOP.NUMCOM = {id} and SUIVIOP.DOCUMENT = 'PROJET' and SUIVIOP.EMCLEUNIK <> 0
]
reqmo.id = cod_projet.IDCOD_PROJET
si pas HExécuteRequêteSQL(reqmo) alors
erreur(herreurinfo())
sinon
pour tout reqmo
si reqmo.MO < 0 alors
RUB_M_MO = "0,00 €"
sinon
RUB_M_MO = NumeriqueVersChaine(reqmo.MO,f) + " €"
RUB_N_MO = NumeriqueVersChaine(reqmo.NB,f)
Total += reqmo.MO
fin
fin
fin
// Mat
reqmat est une requête SQL = [
select sum(SUIVIOP.NBRHEURE * SUIVIOP.COUT_HORAIRE) as MAT
from SUIVIOP
where SUIVIOP.NUMCOM = {id} and SUIVIOP.DOCUMENT = 'PROJET' and SUIVIOP.EMCLEUNIK = 0
]
reqmat.id = cod_projet.IDCOD_PROJET
si pas HExécuteRequêteSQL(reqmat) alors
erreur(herreurinfo())
sinon
pour tout reqmat
MAT += reqmat.MAT > 0 ? reqmat.MAT sinon 0
RUB_M_MAT = NumeriqueVersChaine(MAT,f) + " €"
Total += reqmat.MAT > 0 ? reqmat.MAT sinon 0
fin
fin
RUB_M_TOTAL = NumériqueVersChaîne(Total,f)+ " €"
fin
Cette macro "Facture Fournisseur" agrège les montants des factures fournisseurs par rubrique et ajoute les montants réalisés (main d'œuvre et matériel) pour obtenir le total réalisé sur le chantier.
Elle permet de suivre précisément les dépenses engagées auprès des fournisseurs et d'afficher le détail par poste sur la fiche chantier.
Macro Encaissement
Voir le code
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 2
f.SéparateurMilliers = " "
TotalEncaissee est un réel = 0
// Requête SQL correcte avec alias
req_totalencaisse est une requête SQL =
[
SELECT SUM(suifac.paye) AS total_vente
FROM SUIFAC
JOIN cod_synthese_doc ON cod_synthese_doc.num_doc = suifac.numfac
WHERE cod_synthese_doc.type_doc = 4
AND cod_synthese_doc.idcod_projet = {idprojet}
]
req_totalencaisse.idprojet = cod_projet.IDCOD_PROJET
SI pas HEXécuteRequêteSQL(req_totalencaisse) ALORS
erreur(ErreurInfo())
SINON
POUR TOUT req_totalencaisse
TotalEncaissee = req_totalencaisse.total_vente
FIN
// Affichage formaté du montant encaissé
RUB_FE = NumériqueVersChaîne(TotalEncaissee, f) + " €"
FIN
// Conversion en numérique
TotalE est un réel = ChaîneVersNumérique(remplace(RUB_FTTC," ","") )
TotalRAE est un réel = ChaîneVersNumérique(remplace(RUB_FE," ","") )
// Calcul du reste à facturer
MontantRestant est un réel = TotalE - TotalRAE
// Affichage formaté final
RUB_RAE = NumériqueVersChaîne(MontantRestant, f) + " €"
// Nettoyage brut de RUB_F (montant TTC)
sBF est une chaîne = RUB_F
sBF = Remplace(sBF, "€", "")
sBF = Remplace(sBF, " ", "")
sBF = Remplace(sBF, ",", ".")
// Nettoyage brut de RUB_FE (encaissé)
sC est une chaîne = RUB_FE
sC = Remplace(sC, "€", "")
sC = Remplace(sC, " ", "")
sC = Remplace(sC, ",", ".")
// Conversion
BF est un réel = ChaîneVersNumérique(sBF)
C est un réel = ChaîneVersNumérique(sC)
// Calcul du taux d'encaissement
Encaissement est un réel = BF <> 0 ? (C / BF) * 100 SINON 0
// Affichage
RUB_E = NumériqueVersChaîne(Encaissement, f) + " %"
Cette macro "Encaissement" calcule le montant encaissé, le reste à facturer et le taux d'encaissement du projet à partir des écritures de facturation et des paiements.
Elle permet de suivre précisément l'avancement des règlements clients et d'afficher le pourcentage d'encaissement sur la fiche chantier.
Macro Marge Courante
Voir le code
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 0
f.SéparateurMilliers = " "
TotalFacturé est un réel = 0
Budget est un réel = 0
// Création de la requête SQL
req_totalfac est une requête SQL =
[
select sum(1 * FACTURE.TOTAL) as totalfac
from FACTURE
join COD_SYNTHESE_DOC on COD_SYNTHESE_DOC.NUM_DOC = FACTURE.NUMERO
where COD_SYNTHESE_DOC.TYPE_DOC = 4
AND COD_SYNTHESE_DOC.IDCOD_PROJET = {idprojet}
]
// Passage du projet courant
req_totalfac.idprojet = cod_projet.IDCOD_PROJET
// Exécution
SI pas HEXécuteRequêteSQL(req_totalfac) ALORS
erreur(ErreurInfo())
SINON
POUR TOUT req_totalfac
TotalFacturé = req_totalfac.totalfac
FIN
// Conversion du budget en numérique
Budget = ChaîneVersNumérique(remplace(RUB_M_TOTAL, " ", ""))
// Calcul de la marge
SI Budget > 0 ALORS
RUB_MC = NumériqueVersChaîne(((TotalFacturé - Budget) / TotalFacturé) * 100, f) + " %"
SINON
RUB_MC = "0 %"
FIN
FIN
Cette macro "Marge courante" calcule le pourcentage de marge réalisé sur le projet en comparant le total facturé au budget réalisé.
Elle permet de visualiser rapidement la rentabilité effective du chantier à chaque instant.
Macro Marge PAT
Voir le code
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 0
f.SéparateurMilliers = " "
TotalVente est un réel = 0
Budget est un réel = 0
// Création de la requête SQL
req_totalvente est une requête SQL =
[
SELECT SUM(COMMANDC.TOTAL) AS totalcom
FROM COMMANDC
JOIN COD_SYNTHESE_DOC ON COD_SYNTHESE_DOC.NUM_DOC = COMMANDC.NUMEROC
WHERE COD_SYNTHESE_DOC.IDCOD_PROJET = {idprojet}
AND COD_SYNTHESE_DOC.TYPE_DOC = 7
]
// Passage du projet courant
req_totalvente.idprojet = cod_projet.IDCOD_PROJET
// Exécution
SI pas HEXécuteRequêteSQL(req_totalvente) ALORS
erreur(ErreurInfo())
SINON
POUR TOUT req_totalvente
TotalVente = req_totalvente.totalcom
FIN
// Budget (texte -> numérique)
Budget = ChaîneVersNumérique(remplace(PAT_M_TOTAL, " ", ""))
// Marge prévue
SI Budget > 0 ALORS
RUB_PAT = NumériqueVersChaîne(((TotalVente - Budget) / TotalVente) * 100, f) + " %"
SINON
RUB_PAT = "0 %"
FIN
FIN
Cette macro "Marge PAT" calcule la marge prévue à terminaison en pourcentage, en comparant le total des ventes prévues au budget prévisionnel.
Elle permet d’anticiper la rentabilité finale du chantier selon les prévisions à date.
Macro Marge Prévue
Voir le code
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 0
f.SéparateurMilliers = " "
TotalVente est un réel = 0
Budget est un réel = 0
// Création de la requête SQL
req_totalvente est une requête SQL =
[
SELECT SUM(COMMANDC.TOTAL) AS totalcom
FROM COMMANDC
JOIN COD_SYNTHESE_DOC ON COD_SYNTHESE_DOC.NUM_DOC = COMMANDC.NUMEROC
WHERE COD_SYNTHESE_DOC.IDCOD_PROJET = {idprojet}
AND COD_SYNTHESE_DOC.TYPE_DOC = 7
]
// Passage du projet courant
req_totalvente.idprojet = cod_projet.IDCOD_PROJET
// Exécution
SI pas HEXécuteRequêteSQL(req_totalvente) ALORS
erreur(ErreurInfo())
SINON
POUR TOUT req_totalvente
TotalVente = req_totalvente.totalcom
FIN
// Budget (texte -> numérique)
Budget = ChaîneVersNumérique(remplace(RUB_TOTAL, " ", ""))
// Marge prévue
SI Budget > 0 ALORS
RUB_MP = NumériqueVersChaîne(((TotalVente - Budget) / TotalVente) * 100, f) + " %"
SINON
RUB_MP = "0 %"
FIN
FIN
Cette macro "Marge prévue" calcule la marge prévisionnelle en pourcentage, en comparant le total des ventes prévues au budget global.
Elle permet d’anticiper la rentabilité attendue du chantier avant son lancement.
Macro Montant Facturé
Voir le code
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 2
f.SéparateurMilliers = " "
TotalVente est un réel = 0
req_totalvente est une requête SQL =
[
select sum(1 * FACTURE.TOTAL) as total_vente
from FACTURE
join COD_SYNTHESE_DOC on COD_SYNTHESE_DOC.NUM_DOC = FACTURE.NUMERO
where COD_SYNTHESE_DOC.TYPE_DOC = 4
AND COD_SYNTHESE_DOC.IDCOD_PROJET = {idprojet}
]
req_totalvente.idprojet = cod_projet.IDCOD_PROJET
SI pas HEXécuteRequêteSQL(req_totalvente) ALORS
erreur(ErreurInfo())
SINON
POUR TOUT req_totalvente
TotalVente = req_totalvente.total_vente
FIN
// Affichage formaté avec texte
RUB_F = NumériqueVersChaîne(TotalVente, f) + " €"
FIN
Cette macro "Montant Facturé" calcule le total des ventes facturées pour le projet et affiche le montant formaté en euros.
Elle permet de visualiser rapidement le chiffre d'affaires déjà facturé sur le chantier.
Macro Montant Marché
Voir le code
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 2
f.SéparateurMilliers = " "
TotalCommercial est un réel = 0
req_totalcom est une requête SQL = [
SELECT SUM(COMMANDC.TOTAL) AS totalcom
FROM COMMANDC
JOIN COD_SYNTHESE_DOC ON COD_SYNTHESE_DOC.NUM_DOC = COMMANDC.NUMEROC
WHERE COD_SYNTHESE_DOC.IDCOD_PROJET = {idprojet}
AND COD_SYNTHESE_DOC.TYPE_DOC = 7
]
req_totalcom.idprojet = cod_projet.IDCOD_PROJET
SI pas HEXécuteRequêteSQL(req_totalcom) ALORS
erreur(ErreurInfo())
SINON
POUR TOUT req_totalcom
TotalCommercial = req_totalcom.totalcom
FIN
// Affichage formaté dans la rubrique cible
RUB_MM = NumériqueVersChaîne(TotalCommercial, f) + " €"
FIN
Cette macro "Montant Marché" calcule le total du marché commercialisé pour le projet et affiche le montant formaté en euros.
Elle permet de visualiser rapidement le montant total du contrat ou du marché signé pour le chantier.
Macro Montant Facture TTC
Voir le code
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 2
f.SéparateurMilliers = " "
TotalFacture est un réel = 0
req_totalvente est une requête SQL =
[
SELECT SUM(COD_SYNTHESE_DOC.TOTAL_TTC) AS total_vente
FROM COD_SYNTHESE_DOC
WHERE COD_SYNTHESE_DOC.TYPE_DOC = 4
AND COD_SYNTHESE_DOC.IDCOD_PROJET = {idprojet}
]
req_totalvente.idprojet = cod_projet.IDCOD_PROJET
SI pas HEXécuteRequêteSQL(req_totalvente) ALORS
erreur(ErreurInfo())
SINON
POUR TOUT req_totalvente
TotalFacture = req_totalvente.total_vente
FIN
// Affichage formaté dans la rubrique cible
RUB_FTTC = NumériqueVersChaîne(TotalFacture, f) + " €"
FIN
Cette macro "Montant Facture TTC" calcule le total TTC des factures du projet et affiche le montant formaté en euros.
Elle permet de visualiser rapidement le chiffre d'affaires TTC déjà facturé sur le chantier.
Macro Reste à Engager (partie 2)
Voir le code
// Récupération des valeurs saisies dans les champs et conversion en réel
RAE_M_FOUR1 est un réel = Val(RAE_M_FOUR1)
RAE_M_PNA1 est un réel = Val(RAE_M_PNA1)
RAE_M_MO1 est un réel = Val(RAE_M_MO1)
RAE_M_SST1 est un réel = Val(RAE_M_SST1)
RAE_M_DIVERS1 est un réel = Val(RAE_M_DIVERS1)
RAE_M_MAT2 est un réel = Val(RAE_M_MAT2)
// Calcul du total
RAE_M_TOTAL est un réel = RAE_M_FOUR1 + RAE_M_PNA1 + RAE_M_MO1 + RAE_M_SST1 + RAE_M_DIVERS1 + RAE_M_MAT2
// Affectation du résultat dans le champ total
RAE_M_TOTAL = RAE_M_TOTAL
Cette macro additionne les montants saisis pour chaque poste du reste à engager et met à jour le champ total correspondant.
Elle garantit que le total affiché reflète la somme exacte des postes renseignés.
Macro Reste à Facturer
Voir le code
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 2
f.SéparateurMilliers = " "
// Conversion en réels
TotalMarché est un réel = ChaîneVersNumérique(Remplace(RUB_MM," ",""))
TotalFacturé est un réel = ChaîneVersNumérique(Remplace(RUB_F," ",""))
// Calcul
MontantRestant est un réel = TotalMarché - TotalFacturé
// Affichage
RUB_RAF = NumériqueVersChaîne(MontantRestant, f) + " €"
Cette macro "Reste à Facturer" calcule la différence entre le montant du marché et le montant déjà facturé.
Elle affiche le solde restant à facturer pour le projet, permettant un suivi précis de l'avancement de la facturation.
Macro Marge Sous-Traitance
Voir le code
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 0
f.SéparateurMilliers = " "
// --- SOUS-TRAITANCE ---
// Extraction et conversion du budget (colonne VENTES)
Budget est un réel = ChaîneVersNumérique(Remplace(RUB_MM, " ", ""))
SSTBudget est un réel = ChaîneVersNumérique(Remplace(RUB_SST, " ", ""))
// Extraction et conversion de l'engagé (colonne ACHATS)
EnCours est un réel = ChaîneVersNumérique(Remplace(RUB_M_STT, " ", ""))
// Extraction et conversion du PAT (colonne PREVISION A TERME)
PAT est un réel = ChaîneVersNumérique(remplace(PAT_M_SST, " ", ""))
// Montant facturé fixe (selon la valeur de référence fournie)
Facturé est un réel = ChaîneVersNumérique(Remplace(RUB_F, " ", ""))
// Sécurité anti-division
si Facturé = 0 alors
SSTB = "0 %"
SSTEC = "0 %"
SSTPAT = "0 %"
sinon
SSTB = NumériqueVersChaîne((SSTBudget / Budget) * 100, f) + " %"
SSTEC = NumériqueVersChaîne((EnCours / Facturé) * 100, f) + " %"
SSTPAT = NumériqueVersChaîne((PAT / Budget) * 100, f) + " %"
fin
Cette macro "Marge Sous-Traitance" calcule les ratios de sous-traitance par rapport au budget, au facturé et au prévisionnel à terme.
Elle permet de suivre précisément la part de la sous-traitance dans le projet et d’anticiper les écarts sur ce poste clé.
Macro Marge Fourniture
Voir le code
f est un FormatNumerique
f.Notation = fnnDécimal
f.Signe = fnsMoinsSiNégatif
f.ChiffresAprèsVirgule = 0
f.SéparateurMilliers = " "
// Extraction et conversion du budget (colonne VENTES)
Budget est un réel = ChaîneVersNumérique(Remplace(RUB_MM, " ", ""))
FOURBudget est un réel = ChaîneVersNumérique(Remplace(RUB_FOUR, " ", ""))
// Extraction et conversion de l'engagé (colonne ACHATS)
EnCours est un réel = ChaîneVersNumérique(Remplace(RUB_M_FOUR, " ", ""))
// Extraction et conversion du PAT (colonne PREVISION A TERME)
PAT est un réel = ChaîneVersNumérique(remplace(PAT_M_FOUR, " ", ""))
// Montant facturé fixe (selon la valeur de référence fournie)
Facturé est un réel = ChaîneVersNumérique(Remplace(RUB_F, " ", ""))
// Sécurité anti-division
SI Facturé = 0 ALORS
FOURB = "0 %"
FOUREC = "0 %"
FOURPAT = "0 %"
SINON
FOURB = NumériqueVersChaîne((FOURBudget / Budget) * 100, f) + " %"
FOUREC = NumériqueVersChaîne((EnCours / Facturé) * 100, f) + " %"
FOURPAT = NumériqueVersChaîne((PAT / Budget) * 100, f) + " %"
FIN
Cette macro "Marge Fourniture" calcule les ratios de fourniture par rapport au budget, au facturé et au prévisionnel à terme.
Elle permet de suivre précisément la part des fournitures dans le projet et d’anticiper les écarts sur ce poste.
Conclusion
Ce stage chez Codial a été une expérience professionnelle et humaine très enrichissante. J’ai pu découvrir le fonctionnement d’un ERP métier, comprendre les enjeux de la gestion budgétaire dans le secteur du bâtiment, et contribuer concrètement à l’amélioration d’un outil utilisé quotidiennement par de nombreux professionnels.
La réalisation de la fiche personnalisée et de ses nombreuses macros m’a permis de développer des compétences avancées en WLanguage, SQL et en conception de requêtes complexes. J’ai appris à analyser des besoins métiers, à structurer des traitements automatisés et à garantir la fiabilité des résultats affichés à l’utilisateur. Ce travail m’a également sensibilisé à l’importance de l’ergonomie, de la clarté des interfaces et de la documentation technique pour assurer la pérennité et la maintenabilité des solutions développées.
Sur le plan personnel, ce stage m’a permis de gagner en autonomie, en rigueur et en capacité d’adaptation. J’ai pu échanger avec des utilisateurs finaux, comprendre leurs attentes et ajuster mes développements en conséquence. J’ai également appris à travailler en équipe, à gérer les priorités et à respecter des délais parfois serrés, tout en maintenant un haut niveau de qualité dans le code produit.
En conclusion, cette expérience a été une étape clé dans mon parcours de formation. Elle m’a permis de consolider mes acquis, de découvrir de nouveaux outils et méthodes, et de prendre conscience de l’impact concret que peut avoir le développement logiciel sur l’organisation et la performance d’une entreprise. Je ressors de ce stage motivé, confiant dans mes compétences et déterminé à poursuivre dans la voie du développement d’applications métiers et de la gestion de projets informatiques.