--- /dev/null
+package org.lilie.services.eliot.notes
+
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.utils.NoteFormateur
+
+/**
+ * Proprietes d'etablissements specifiques a eliot-notes
+ * @author msan
+ */
+class EtablissementNotes {
+
+ static final List<BigDecimal> PRECISIONS = [
+ new BigDecimal('1'),
+ new BigDecimal('0.5'),
+ new BigDecimal('0.25'),
+ new BigDecimal('0.1'),
+ new BigDecimal('0.01')
+ ]
+ static final BigDecimal PRECISION_PAR_DEFAUT = new BigDecimal('0.01')
+
+ Long id
+ BigDecimal precision = PRECISION_PAR_DEFAUT
+
+ static belongsTo = [etablissement: Etablissement]
+
+ static transients = ['noteFormateur']
+
+ static mapping = {
+ table 'entnotes.etablissement_notes'
+ id column: 'id', generator: 'sequence', params: [sequence: 'entnotes.etablissement_notes_id_seq']
+ cache usage: 'read-write'
+ etablissement column: 'etablissement_id'
+ precision column: 'precision'
+ version false
+ }
+
+ static constraints = {
+ precision(nullable: false, inList: PRECISIONS)
+ }
+
+ NoteFormateur getNoteFormateur(String decimalSeparator = ',') {
+ return new NoteFormateur(precision, decimalSeparator)
+ }
+}
import org.lilie.services.eliot.annuaire.PorteurEnt
import org.lilie.services.eliot.annuaire.AnnuaireEtablissement
-import org.lilie.services.eliot.utils.NoteFormateur
/**
* Représente un établissement
*/
class Etablissement implements AnnuaireEtablissement {
- static final List<BigDecimal> PRECISIONS = [
- new BigDecimal('1'),
- new BigDecimal('0.5'),
- new BigDecimal('0.25'),
- new BigDecimal('0.1'),
- new BigDecimal('0.01')
- ]
- static final BigDecimal PRECISION_PAR_DEFAUT = new BigDecimal('0.01')
-
Long id
String nomAffichage
String idExterne
String typeEtablissement
Etablissement etablissementRattachement
- BigDecimal precision = PRECISION_PAR_DEFAUT
-
PorteurEnt porteurEnt
/**
*/
Date dateImportSts = null
- static transients = ['noteFormateur']
-
static mapping = {
table 'ent.etablissement'
id column: 'id', generator: 'sequence', params: [sequence: 'ent.etablissement_id_seq']
porteurEnt(nullable: true)
academie(nullable: true, maxSize: 128)
typeEtablissement(nullable: true)
- precision(nullable: false, inList: PRECISIONS)
etablissementRattachement(nullable: true)
}
return "Etablissement{id=$id, nom=$nomAffichage}"
}
- NoteFormateur getNoteFormateur(String decimalSeparator = ',') {
- return new NoteFormateur(precision, decimalSeparator)
- }
}
import org.lilie.services.eliot.notes.breadcrumbs.MenuAideNotesService
import org.lilie.services.eliot.notes.notes.NoteTextuelleService
import grails.converters.JSON
+import org.lilie.services.eliot.notes.notes.EtablissementNotesService
/**
* classe abstraite pour définir les controlleurs de note
AnneeScolaireService anneeScolaireService
MenuAideNotesService menuAideNotesService
NoteTextuelleService noteTextuelleService
+ EtablissementNotesService etablissementNotesService
CodeComparator cc = new CodeComparator()
protected Map prepareBaseModele(Object page) {
Map model = super.prepareBaseModele(page)
- model.precision = etablissementCourant().precision
+ model.precision = etablissementNotesService.getPrecision(etablissementCourant())
return model
}
StructureEnseignement structureEnseignement =
tdn.enseignement.service.structureEnseignement
- NoteFormateur nf = structureEnseignement.etablissement.getNoteFormateur(',')
+ NoteFormateur nf = etablissementNotesService.getNoteFormateur(structureEnseignement.etablissement)
if (tdn.typePeriode.isAnnee()) {
// Pour la période "année" affiche les moyennes des périodes
import org.lilie.services.eliot.scolarite.Personne
import org.lilie.services.eliot.notes.appreciationclasse.AppreciationClasse
import org.lilie.services.eliot.utils.NoteFormateur
+import org.lilie.services.eliot.notes.notes.EtablissementNotesService
/**
* Les configs pour la vue Consultation -> Appreciations classes
// Converteur JSON pour SyntheseClasse
cfg.registerObjectMarshaller(AppreciationClasse) {AppreciationClasse appreciationClasse ->
- NoteFormateur nf = appreciationClasse.structureEnseignement.etablissement.getNoteFormateur('.')
return [
enseignant: appreciationClasse.enseignant?.nomAffichageInitiales(),
matiere: appreciationClasse.matiere?.libelleLong,
structureEnseignement: appreciationClasse.structureEnseignement?.code,
structureIsGroupe: appreciationClasse.structureEnseignement?.isGroupe(),
- moyenneClasse : nf.format(appreciationClasse.moyenneClasse),
- noteMax : nf.format(appreciationClasse.noteMax),
- noteMin : nf.format(appreciationClasse.noteMin),
+ moyenneClasse : appreciationClasse.moyenneClasseFormatee,
+ noteMax : appreciationClasse.noteMaxFormatee,
+ noteMin : appreciationClasse.noteMinFormatee,
appreciation: appreciationClasse.appreciation
]
}
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.notes.appreciationclasse.AppreciationClasseService
import org.lilie.services.eliot.notes.appreciationclasse.AppreciationClasse
+import org.lilie.services.eliot.utils.NoteFormateur
/**
* Cette classe représente le controleur de
Map result = prepareBaseModele(Page.CONSULTATION_APPRECIATION_CLASSE)
JSON.use(ConsultationAppreciationsClasseConfig.toString()) {
- result.appreciations = appreciations as JSON
+ result.appreciations = formateMoyennes(appreciations) as JSON
result.moyennesAjour = calcInfo?.moyennesAjour
result.dateDernierCalculMoyennes = calcInfo?.dateDernierCalculMoyennes
result.periodeId = periodeId
render(view: '/consultation/appreciationsclasse/index', model: result)
}
+ /**
+ * Formate les moyennes pour l'affichage
+ * @param appreciationClasses
+ * @return
+ */
+ List<AppreciationClasse> formateMoyennes(List<AppreciationClasse> appreciationClasses) {
+ NoteFormateur nf = etablissementNotesService.getNoteFormateur(etablissementCourant())
+
+ appreciationClasses.each {
+ it.moyenneClasseFormatee = nf.format(it.moyenneClasse)
+ it.noteMaxFormatee = nf.format(it.noteMax)
+ it.noteMinFormatee = nf.format(it.noteMin)
+ }
+ return appreciationClasses
+ }
+
/**
* paramètres : classeId, periodeId,
*/
-package org.lilie.services.eliot.notes.domaine\r
-\r
-import org.lilie.services.eliot.notes.ActionEnum\r
-import org.lilie.services.eliot.notes.NotesFonction\r
-import grails.converters.JSON\r
-import org.lilie.services.eliot.notes.AbstractNotesController\r
-import org.lilie.services.eliot.notes.NotesDroitService\r
-import org.lilie.services.eliot.notes.notes.NotesEtablissementService\r
-import org.lilie.services.eliot.scolarite.Etablissement\r
-\r
-/**\r
- * Etablissement controlleur\r
- * @author msan\r
- */\r
-class NotesEtablissementController extends AbstractNotesController {\r
-\r
- NotesDroitService notesDroitService\r
- NotesEtablissementService notesEtablissementService\r
-\r
- /**\r
- * Enregistre la precision d'etablissement courant\r
- * @author msan\r
- */\r
- def enregistrePrecision = {\r
-\r
- Map result = getResultIfNullParams(['precision'])\r
-\r
- if (!result) {\r
- result = tryCatch {\r
-\r
- notesDroitService.verifieAutorisationByEtablissement(\r
- securiteSession,\r
- etablissementCourant(),\r
- ActionEnum.CREATION,\r
- NotesFonction.DIRECTION_ASSIMILE\r
- )\r
-\r
- BigDecimal precision = new BigDecimal(params.precision)\r
-\r
- notesEtablissementService.internalSetPrecision(\r
- etablissementCourant(),\r
- precision\r
- )\r
-\r
- }\r
- }\r
- render result as JSON\r
- }\r
-\r
-}\r
+package org.lilie.services.eliot.notes.domaine
+
+import org.lilie.services.eliot.notes.ActionEnum
+import org.lilie.services.eliot.notes.NotesFonction
+import grails.converters.JSON
+import org.lilie.services.eliot.notes.AbstractNotesController
+import org.lilie.services.eliot.notes.NotesDroitService
+
+/**
+ * EtablissementNotes controlleur
+ * @author msan
+ */
+class EtablissementNotesController extends AbstractNotesController {
+
+ NotesDroitService notesDroitService
+
+ /**
+ * Enregistre la precision d'etablissement courant
+ * @author msan
+ */
+ def enregistrePrecision = {
+
+ Map result = getResultIfNullParams(['precision'])
+
+ if (!result) {
+ result = tryCatch {
+
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant(),
+ ActionEnum.CREATION,
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+
+ BigDecimal precision = new BigDecimal(params.precision)
+
+ etablissementNotesService.setPrecision(etablissementCourant(), precision)
+
+ }
+ }
+ render result as JSON
+ }
+
+}
-package org.lilie.services.eliot.notes.parametrages\r
-\r
-import org.lilie.services.eliot.notes.AbstractNotesController\r
-import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo\r
-import org.lilie.services.eliot.notes.ActionEnum\r
-import org.lilie.services.eliot.notes.NotesFonction\r
-import org.lilie.services.eliot.notes.page.Page\r
-import org.lilie.services.eliot.notes.NotesDroitService\r
-import org.lilie.services.eliot.notes.notes.NoteTextuelleService\r
-import grails.converters.JSON\r
-\r
-/**\r
- * Paranetrages generaux\r
- * @author msan\r
- */\r
-class ParametragesGenerauxController extends AbstractNotesController {\r
-\r
- NotesDroitService notesDroitService\r
- NoteTextuelleService noteTextuelleService\r
-\r
- def index = {\r
-\r
- notesDroitService.verifieAutorisationByEtablissement(\r
- securiteSession,\r
- etablissementCourant(),\r
- ActionEnum.CONSULTATION,\r
- NotesFonction.DIRECTION_ASSIMILE\r
- )\r
-\r
- Map model = prepareBaseModele(Page.PARAMETRAGES_GENERAUX)\r
-\r
- model.precision = etablissementCourant()?.precision\r
-\r
- model.annotations = noteTextuelleService.findAllNoteTextuelleAvecUtilisation(\r
- securiteSession,\r
- etablissementCourant()\r
- ).collect {\r
- [\r
- id: it.id,\r
- code: it.code,\r
- libelle: it.libelle,\r
- noteTextuelleUtilisee: it.estUtilisee\r
- ]\r
- }.sort { it.code } as JSON\r
-\r
- render(view: '/parametrages/generaux/index',\r
- model: model\r
- )\r
- }\r
- /**\r
- * Gestion du breadCrumbs\r
- * @return\r
- */\r
- protected List getBreadCrumbsInfo() {\r
- List breadCrumbsInfo = super.getBreadCrumbsInfo()\r
- breadCrumbsInfo << new BreadCrumbsItemInfo(\r
- codeLabel: 'notes.menu.parametrages.titrePrincipal'\r
- )\r
- breadCrumbsInfo << new BreadCrumbsItemInfo(\r
- codeLabel: 'notes.menu.parametrages.generaux.titrePrincipal'\r
- )\r
-\r
- return breadCrumbsInfo\r
- }\r
-\r
-}\r
+package org.lilie.services.eliot.notes.parametrages
+
+import org.lilie.services.eliot.notes.AbstractNotesController
+import org.lilie.services.eliot.urllabel.breadcrumbs.BreadCrumbsItemInfo
+import org.lilie.services.eliot.notes.ActionEnum
+import org.lilie.services.eliot.notes.NotesFonction
+import org.lilie.services.eliot.notes.page.Page
+import org.lilie.services.eliot.notes.NotesDroitService
+import org.lilie.services.eliot.notes.notes.NoteTextuelleService
+import grails.converters.JSON
+
+/**
+ * Paranetrages generaux
+ * @author msan
+ */
+class ParametragesGenerauxController extends AbstractNotesController {
+
+ NotesDroitService notesDroitService
+ NoteTextuelleService noteTextuelleService
+
+ def index = {
+
+ notesDroitService.verifieAutorisationByEtablissement(
+ securiteSession,
+ etablissementCourant(),
+ ActionEnum.CONSULTATION,
+ NotesFonction.DIRECTION_ASSIMILE
+ )
+
+ Map model = prepareBaseModele(Page.PARAMETRAGES_GENERAUX)
+
+
+ model.precision = null
+ if (etablissementCourant()) {
+ model.precision = etablissementNotesService.
+ getPrecision(etablissementCourant())
+ }
+
+
+ model.annotations = noteTextuelleService.findAllNoteTextuelleAvecUtilisation(
+ securiteSession,
+ etablissementCourant()
+ ).collect {
+ [
+ id: it.id,
+ code: it.code,
+ libelle: it.libelle,
+ noteTextuelleUtilisee: it.estUtilisee
+ ]
+ }.sort { it.code } as JSON
+
+ render(view: '/parametrages/generaux/index',
+ model: model
+ )
+ }
+ /**
+ * Gestion du breadCrumbs
+ * @return
+ */
+ protected List getBreadCrumbsInfo() {
+ List breadCrumbsInfo = super.getBreadCrumbsInfo()
+ breadCrumbsInfo << new BreadCrumbsItemInfo(
+ codeLabel: 'notes.menu.parametrages.titrePrincipal'
+ )
+ breadCrumbsInfo << new BreadCrumbsItemInfo(
+ codeLabel: 'notes.menu.parametrages.generaux.titrePrincipal'
+ )
+
+ return breadCrumbsInfo
+ }
+
+}
List<List> lignes = ligneMaps.collect {[it.nomAffichage]}
- NoteFormateur nf = classe.etablissement.getNoteFormateur()
+ NoteFormateur nf = etablissementNotesService.getNoteFormateur(classe.etablissement)
colonneMaps.each {col ->
// Crée l'entête
BigDecimal noteMin
String appreciation
+ String moyenneClasseFormatee // formatee pour l'affichage
+ String noteMaxFormatee // formatee pour l'affichage
+ String noteMinFormatee // formatee pour l'affichage
+
}
import org.codehaus.groovy.grails.web.context.ServletContextHolder
import org.lilie.services.eliot.CodeComparator
import org.lilie.services.eliot.utils.NoteFormateur
+import org.lilie.services.eliot.notes.notes.EtablissementNotesService
/**
* @author bper
*/
class ApbRapportHtmlBuilder {
+ EtablissementNotesService etablissementNotesService
private static final COMPARATOR = new CodeComparator()
ApbRapport rapport
ApbRapportHtmlBuilder(ApbRapport rapport) {
this.rapport = rapport
- this.noteFormateur = rapport.etablissement.getNoteFormateur('.')
+ this.noteFormateur = etablissementNotesService.getNoteFormateur(rapport.etablissement, '.')
}
void writeHtml(Writer writer) {
import org.lilie.services.eliot.impression.donnees.eleve.NoteTextuelleImpression
import org.lilie.services.eliot.notes.NoteTextuelle
import org.lilie.services.eliot.notes.TypeAvis
+import org.lilie.services.eliot.notes.notes.EtablissementNotesService
/**
* Récupération d'informations pour le publipostage des notes
PeriodeService periodeService
BulletinService bulletinService
ReleveService releveService
+ EtablissementNotesService etablissementNotesService
static final NoteFormateur COEFF_NF = new NoteFormateur(new BigDecimal('0.01'), ',', '#.##')
TableauImpressionInfo tab = new TableauImpressionInfo()
- NoteFormateur nf = bulletin.classe.etablissement.getNoteFormateur(',')
+ NoteFormateur nf = etablissementNotesService.getNoteFormateur(bulletin.classe.etablissement)
// moyennes generales
tab.moyenneGeneraleClasse = nf.format(bulletin.syntheseClasse.resultatClassePeriode?.moyenne)
import org.lilie.services.eliot.scolarite.StructureEnseignement
import org.lilie.services.eliot.scolarite.Periode
import org.lilie.services.eliot.utils.NoteFormateur
+import org.lilie.services.eliot.notes.notes.EtablissementNotesService
/**
* Module de requetage des données nécessaire à l'impression des appréciations
*/
class ImpressionRequetageAppreciationsService {
+ EtablissementNotesService etablissementNotesService
+
+
/**
* Permet de construire le DTO d'impression des appréciations
* @param etablissement
resultat.periode = libellePeriode
resultat.classe = classe.nomAffichage
- NoteFormateur noteFormateur = etablissement.getNoteFormateur()
+ NoteFormateur noteFormateur = etablissementNotesService.getNoteFormateur(etablissement)
appreciations.each {AppreciationClasse appreciationClasse ->
resultat.data << new AppreciationLigne(
import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleI18n
import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleTypePeriode
+import org.lilie.services.eliot.notes.notes.EtablissementNotesService
+
/**
* Ce service permet de convertir un objet Synthese en objet SyntheseImpression
* destiné à l'impression vers jasper
private static final POSITION_MOYENNE = 9999
LocalPersonneService localPersonneService
+ EtablissementNotesService etablissementNotesService
public SyntheseImpression construisTableauImpression(Synthese synthese) {
SyntheseImpression tab = new SyntheseImpression(
*/
private List<CelluleTableau> construitTableau(Synthese synthese) {
- NoteFormateur nf = synthese.classe.etablissement.getNoteFormateur()
+ NoteFormateur nf = etablissementNotesService.getNoteFormateur(synthese.classe.etablissement)
List<CelluleTableau> tableau = []
import org.lilie.services.eliot.notes.resultat.NoteInfo
import org.lilie.services.eliot.impression.donnees.tableauimpression.cellules.CelluleI18n
import org.lilie.services.eliot.resultat.Moyenne
+import org.lilie.services.eliot.notes.notes.EtablissementNotesService
/**
* Préparation des objets d'impression pour les tableaux de notes
LocalPersonneService localPersonneService
NotesTypePeriodeService notesTypePeriodeService
CalculationService calculationService
+ EtablissementNotesService etablissementNotesService
/**
* Prépare les données pour un tableau de note sur une année
StructureEnseignement structureEnseignement =
tdn.enseignement.service.structureEnseignement
- NoteFormateur nf = structureEnseignement.etablissement.getNoteFormateur()
+ NoteFormateur nf = etablissementNotesService.getNoteFormateur(structureEnseignement.etablissement)
TableauDeNotesImpression tab = new TableauDeNotesImpression(
classe: structureEnseignement.code,
StructureEnseignement structureEnseignement =
tdn.enseignement.service.structureEnseignement
- NoteFormateur nf = structureEnseignement.etablissement.getNoteFormateur()
+ NoteFormateur nf = etablissementNotesService.getNoteFormateur(structureEnseignement.etablissement)
TableauDeNotesImpression tab = new TableauDeNotesImpression(
classe: structureEnseignement.code,
--- /dev/null
+package org.lilie.services.eliot.notes.notes
+
+import org.lilie.services.eliot.notes.EtablissementNotes
+import org.lilie.services.eliot.scolarite.Etablissement
+import org.lilie.services.eliot.utils.NoteFormateur
+
+/**
+ * Proprietes d'etablissements specifiques a eliot-notes
+ * @author msan
+ */
+class EtablissementNotesService {
+
+ static transactional = true
+
+ /**
+ * Recupere etablisementNotes pour un etablissement donne
+ * @param etablissement
+ * @return
+ */
+ EtablissementNotes findByEtablissement(Etablissement etablissement) {
+ if (etablissement == null) {
+ throw new IllegalArgumentException("Etablissement est null")
+ }
+ return EtablissementNotes.findByEtablissement(etablissement)
+ }
+
+ /**
+ * Recupere la precision pour un etablissement donne
+ * @param etablissement
+ * @return
+ */
+ BigDecimal getPrecision(Etablissement etablissement) {
+ return this.findByEtablissement(etablissement)?.precision
+ }
+
+ /**
+ * Positionne la precision pour un etablissement donne
+ * @param etablissement
+ * @return
+ */
+ void setPrecision(Etablissement etablissement, BigDecimal precision) {
+ EtablissementNotes etablissementNotes = this.findByEtablissement(etablissement)
+ etablissementNotes.precision = precision
+ etablissementNotes.save(flush: true, failOnError: true)
+ }
+
+ /**
+ * Recupere le NoteFormateur pour un etablissement donne
+ * @param etablissement
+ * @return
+ */
+ NoteFormateur getNoteFormateur(Etablissement etablissement,
+ String separateurDecimal = ',') {
+ return this.findByEtablissement(etablissement).
+ getNoteFormateur(separateurDecimal)
+ }
+
+}
+++ /dev/null
-package org.lilie.services.eliot.notes.notes
-
-import org.lilie.services.eliot.scolarite.etablissement.EtablissementService
-import org.lilie.services.eliot.scolarite.Etablissement
-
-class NotesEtablissementService extends EtablissementService {
-
- static transactional = true
-
- /**
- * Positionne la precision de l'etablissement
- * @param etablissement
- * @param precision
- */
- void internalSetPrecision(Etablissement etablissement, BigDecimal precision) {
- etablissement.setPrecision(precision)
- etablissement.save(flush: true, failOnError: true)
- }
-}
// Url
<g:setJsVar value="ConfigServeur.url"/>
- <g:setJsValueLink name="enregistrePrecision" controller="notesEtablissement" action="enregistrePrecision"/>
+ <g:setJsValueLink name="enregistrePrecision" controller="etablissementNotes" action="enregistrePrecision"/>
<g:setJsValueLink name="enregistreAnnotation" controller="noteTextuelle" action="enregistreNoteTextuelle"/>
<g:setJsValueLink name="supprimeAnnotation" controller="noteTextuelle" action="supprimeNoteTextuelle"/>
import org.lilie.services.eliot.scolarite.structureenseignement.LocalStructureEnseignementService
import org.lilie.services.eliot.notes.avis.AvisService
import org.lilie.services.eliot.securite.impl.CompteUtilisateurEtat
+import org.lilie.services.eliot.notes.notes.EtablissementNotesService
/**
* tests:NotesImpressionServiceTests.
InfoCalculMoyennesClasseService infoCalculMoyennesClasseService
LocalStructureEnseignementService localStructureEnseignementService
AvisService avisService
+ EtablissementNotesService etablissementNotesService
Etablissement etablissement1 = null
StructureEnseignement classe1enTrimestres = null
//Recuperation de EleveImpressionInfo pour eleve1 , periodeT1_1
EleveImpressionInfo eleveImpressionInfo1 = eleveInfos.find {it.personne.id == eleve1.id}
- NoteFormateur nf = classe1enTrimestres.etablissement.getNoteFormateur(',')
+ NoteFormateur nf = etablissementNotesService.
+ getNoteFormateur(classe1enTrimestres.etablissement)
//Tester la bonne recuperation des données dans eleveImpressionInfo1
assertNotNull("Les données de l'eleve1 {eleve1} pour Notes ne sont pas recuperés",
localStructureEnseignementService.findClasseForEleve(
securiteSessionDicerteur,
eleve1)
- NoteFormateur nf = classe.etablissement.getNoteFormateur(',')
+ NoteFormateur nf = etablissementNotesService.getNoteFormateur(classe.etablissement)
EleveImpressionInfo eleveImpressionInfo = eleveInfos.find {it.personne.id == eleve1.id}
import org.lilie.services.eliot.test.LocalInitDonneesCommunesTestService
import org.lilie.services.eliot.scolarite.Etablissement
-class NotesEtablissementServiceTests extends GrailsUnitTestCase {
+class EtablissementNotesServiceTests extends GrailsUnitTestCase {
- NotesEtablissementService notesEtablissementService
+ EtablissementNotesService etablissementNotesService
LocalInitDonneesCommunesTestService localInitDonneesCommunesTestService
Etablissement etablissement
*/
void testSetPrecision() {
- notesEtablissementService.internalSetPrecision(etablissement, new BigDecimal('0.1'))
- etablissement.refresh()
+ etablissementNotesService.setPrecision(etablissement, new BigDecimal('0.1'))
assertEquals(
"Precision n'est pas comme attendu",
new BigDecimal('0.1'),
- etablissement.precision
+ etablissementNotesService.findByEtablissement(etablissement).precision
)
- notesEtablissementService.internalSetPrecision(etablissement, new BigDecimal('0.25'))
+ etablissementNotesService.setPrecision(etablissement, new BigDecimal('0.25'))
etablissement.refresh()
assertEquals(
"Precision n'est pas comme attendu",
new BigDecimal('0.25'),
- etablissement.precision
+ etablissementNotesService.findByEtablissement(etablissement).precision
)
- notesEtablissementService.internalSetPrecision(etablissement, new BigDecimal('1'))
+ etablissementNotesService.setPrecision(etablissement, new BigDecimal('1'))
etablissement.refresh()
assertEquals(
"Precision n'est pas comme attendu",
new BigDecimal('1'),
- etablissement.precision
+ etablissementNotesService.findByEtablissement(etablissement).precision
)
}