periodeInfos = periodes.collect {
new PeriodeInfo(
- idPeriode: it.id,
+ periodeId: it.id,
libelle: getTypePeriodeLibelle(it.typePeriode)
)
}
periodeInfos = periodes.collect {
new PeriodeInfo(
- idPeriode: it.id,
+ periodeId: it.id,
libelle: getTypePeriodeLibelle(it.typePeriode)
)
}
periode = periodes.find {it.isPeriodeEnCours() && it.isPeriodeXmestre()}
periodeInfos = periodes.collect {
- new PeriodeInfo(idPeriode: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
+ new PeriodeInfo(periodeId: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
}
if ((eleve == null) && (eleves != null) && (eleves.size() > 0)) {
List<Periode> periodes = classe.periodes.toList().sort()
periodeInfos = periodes.collect {
- new PeriodeInfo(idPeriode: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
+ new PeriodeInfo(periodeId: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
}
List<Periode> periodes = classe.periodes.toList().sort()
periode = periodes.find {it.isPeriodeEnCours() && it.isPeriodeXmestre()}
periodeInfos = periodes.collect {
- new PeriodeInfo(idPeriode: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
+ new PeriodeInfo(periodeId: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
}
if ((eleve == null) && (eleves != null) && (eleves.size() > 0)) {
List<Periode> periodes = classe.periodes.toList().sort()
Periode periode = periodes.find {it.isPeriodeEnCours() && it.isPeriodeXmestre()}
List<Periode> periodeInfos = periodes.collect {
- new PeriodeInfo(idPeriode: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
+ new PeriodeInfo(periodeId: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
}
List<Long> eleveInactifIds = eleveAnnuaireService.
result = tryCatch {
verifieDroitFonctionnalite(NotesFonctionnalite.NOTES_SAISIE_SYNTH)
- Periode periode = Periode.get(command.idPeriode)
+ Periode periode = Periode.get(command.periodeId)
Map mapEleveAppreciation = command.getMapEleveAppreciation()
notesDroitService.verifieDroitModifierSynthese(securiteSession, periode.classe)
*/
class AppreciationsElevesPeriodeCommand {
- Long idPeriode
+ Long periodeId
def appreciation
static constraints = {
- idPeriode nullable: false
+ periodeId nullable: false
appreciation nullable:false
}
* @author msan
*/
class ClassePeriodeInfo {
- Long idPeriode
- Long idTypePeriode
+ Long periodeId
+ Long typePeriodeId
String libelle
public String toString() {
- return "libelle: $libelle idTypePriode: $idTypePeriode"
+ return "libelle: $libelle idTypePriode: $typePeriodeId"
}
}
* @author bper
*/
class PeriodeCommand {
- Long idTypePeriode
- Long idPeriode
- Long idClasse
+ Long typePeriodeId
+ Long periodeId
+ Long classeId
Date dateDebutPeriode
Date dateFinPeriode
Date dateFinSaisie
Date datePublicationReleves
static constraints = {
- idTypePeriode nullable: true
- idPeriode nullable:true
- idClasse nullable:false
+ typePeriodeId nullable: true
+ periodeId nullable:true
+ classeId nullable:false
dateDebutPeriode nullable:true
dateFinPeriode nullable:true,
}
StructureEnseignement getClasse() {
- return StructureEnseignement.get(this.idClasse)
+ return StructureEnseignement.get(this.classeId)
}
Periode getPeriode() {
- return Periode.get(this.idPeriode)
+ return Periode.get(this.periodeId)
}
TypePeriode getTypePeriode() {
- return TypePeriode.get(this.idTypePeriode)
+ return TypePeriode.get(this.typePeriodeId)
}
Boolean valideSuperieurDateDebut(newVal, oldVal, obj, periode) {
verifieDroitFonctionnalite(NotesFonctionnalite.NOTES_PARAM)
- Map result = getResultIfNullParams(['idClasse'])
+ Map result = getResultIfNullParams(['classeId'])
if (!result) {
result = tryCatch {
- Long idClasse = Long.valueOf(params.idClasse)
- StructureEnseignement classe = StructureEnseignement.get(idClasse)
+ Long classeId = Long.valueOf(params.classeId)
+ StructureEnseignement classe = StructureEnseignement.get(classeId)
verifieDroitAccesObjetDomaine(classe)
periodeInfo.supprimable = true
break
}
- periodeInfo.idPeriode = periode.id
+ periodeInfo.periodeId = periode.id
periodeInfo.libelle = getTypePeriodeLibelle(periode.typePeriode)
- periodeInfo.idTypePeriode = periode.typePeriodeId
+ periodeInfo.typePeriodeId = periode.typePeriodeId
periodeInfo.ordre = periode.ordre
periodeInfo.dateDebutPeriode = periode.dateDebut
periodeInfo.dateFinPeriode = periode.dateFin
def result = tryCatch {
verifieDroitFonctionnalite(NotesFonctionnalite.NOTES_PARAM)
- Long idPeriode = Long.valueOf(params.idPeriode)
- Periode periode = Periode.get(idPeriode)
+ Long periodeId = Long.valueOf(params.periodeId)
+ Periode periode = Periode.get(periodeId)
if (notesPeriodeService.periodeHasNotes(periode) ||
notesPeriodeService.periodeHasAppreciations(periode)) {
return [deleted: false]
}
private def supprimePeriode(def params) {
- Long idPeriode = Long.valueOf(params.idPeriode)
- Periode periode = Periode.get(idPeriode)
+ Long periodeId = Long.valueOf(params.periodeId)
+ Periode periode = Periode.get(periodeId)
verifieDroitAccesObjetDomaine(periode.classe.etablissement)
verifieDroitFonctionnalite(NotesFonctionnalite.NOTES_PARAM)
// get classe
- Long idClasse = params.idClasse?.toLong()
+ Long classeId = params.classeId?.toLong()
- if (idClasse == null) {
- throw new IllegalArgumentException("Param manquant: idClasse")
+ if (classeId == null) {
+ throw new IllegalArgumentException("Param manquant: classeId")
}
- StructureEnseignement classe = StructureEnseignement.get(idClasse)
+ StructureEnseignement classe = StructureEnseignement.get(classeId)
verifieDroitAccesObjetDomaine(classe)
*/
class PeriodeInfo {
String libelle
- Long idPeriode
- Long idTypePeriode
+ Long periodeId
+ Long typePeriodeId
Integer ordre
Date dateDebutPeriode
Date dateFinPeriode
Long idMatiere
List<Long> enseignants
Long idStructure
- Map<Long, BigDecimal> coeffs // <idTypePeriode: coeff>
+ Map<Long, BigDecimal> coeffs // <typePeriodeId: coeff>
Boolean option
Boolean evaluable
String nature
- Long idTypePeriode
- Long idClasse
+ Long typePeriodeId
+ Long classeId
// utilisé seulement pour les Modalité Matières
Long servicePerentId
option = json?.option
evaluable = json?.evaluable
nature = json.nature
- idTypePeriode = getLong(json?.idTypePeriode)
- idClasse = getLong(json?.idClasse)
+ typePeriodeId = getLong(json?.typePeriodeId)
+ classeId = getLong(json?.classeId)
List<Long> enseignantIDs = []
json.enseignants?.each {
}
enseignants = enseignantIDs
- coeffs = [:]// <idTypePeriode: coeff>
+ coeffs = [:]// <typePeriodeId: coeff>
json.coeffs?.each { JSONObject coeffInfo ->
- Long idTypePeriode = getLong(coeffInfo.idTypePeriode)
+ Long typePeriodeId = getLong(coeffInfo.typePeriodeId)
BigDecimal coeff = getBigDecimal(coeffInfo.coeff)
- coeffs.put(idTypePeriode, coeff)
+ coeffs.put(typePeriodeId, coeff)
}
servicePerentId = getLong(json?.serviceParentId)
* Classe séléctionnée
*/
StructureEnseignement getClasse() {
- return (idClasse!=null ? StructureEnseignement.get(idClasse) : null)
+ return (classeId!=null ? StructureEnseignement.get(classeId) : null)
}
}
/**
* Retourne les informations des services d'une classe de ses groupes,
* utilisée pour le paramètrage des services
- * @param idClasse id de la classe et idPeriode de la periode
+ * @param classeId id de la classe et periodeId de la periode
* @author msan
*/
def listeServicesPourClasse = {
Map result = tryCatch {
verifieDroitFonctionnalite(NotesFonctionnalite.NOTES_PARAM)
- Long classeId = params.idClasse ? params.idClasse.toLong() : null
+ Long classeId = params.classeId ? params.classeId.toLong() : null
if (classeId == null) {
- throw new IllegalArgumentException("le parametre idClasse est nulle")
+ throw new IllegalArgumentException("le parametre classeId est nulle")
}
StructureEnseignement classe = StructureEnseignement.get(classeId)
verifieDroitAccesObjetDomaine(classe)
String natureStr = params.nature
- Long idTypePeriode = params.idTypePeriode ? params.idTypePeriode.toLong() : null
+ Long typePeriodeId = params.typePeriodeId ? params.typePeriodeId.toLong() : null
- TypePeriode typePeriode = idTypePeriode != null ? TypePeriode.get(idTypePeriode) : null
+ TypePeriode typePeriode = typePeriodeId != null ? TypePeriode.get(typePeriodeId) : null
NaturePeriode nature = natureStr != null ?
NaturePeriode.valueOf(NaturePeriode.class, natureStr) :
NaturePeriode.NOTATION
if (serviceSaveParams.periodeParams.nature == NaturePeriode.EXAMEN &&
serviceSaveParams.periodeParams.typePeriode == null) {
throw new IllegalArgumentException(
- "TypePeriode (id: ${command.idTypePeriode}) n'est pas fourni "+
+ "TypePeriode (id: ${command.typePeriodeId}) n'est pas fourni "+
"ou n'existe pas dans la bdd")
}
if (!creation && serviceSaveParams.serviceParams.service == null) {
ordre: command.ordre,
option: command.option,
evaluable: command.evaluable,
- typePeriode: command.idTypePeriode ? TypePeriode.
- get(command.idTypePeriode) : null,
+ typePeriode: command.typePeriodeId ? TypePeriode.
+ get(command.typePeriodeId) : null,
nature: NaturePeriode.valueOf(NaturePeriode.class, command.nature),
- classeCible: StructureEnseignement.get(command.idClasse)
+ classeCible: StructureEnseignement.get(command.classeId)
)
Map<TypePeriode, BigDecimal> coeffs = [:]
coeffs.put(TypePeriode.get(typePeriodeId), coeff)
}
paramsDto.coeffs = coeffs
- paramsDto.typePeriode = command.idTypePeriode ? TypePeriode.get(command.idTypePeriode) : null
+ paramsDto.typePeriode = command.typePeriodeId ? TypePeriode.get(command.typePeriodeId) : null
paramsDto.nature = NaturePeriode.valueOf(NaturePeriode.class, command.nature)
paramsDto.evaluable = command.evaluable
Map result = tryCatch {
verifieDroitFonctionnalite(NotesFonctionnalite.NOTES_PARAM)
- Long idClasse = Long.valueOf(params.idClasse)
- StructureEnseignement classe = StructureEnseignement.get(idClasse)
+ Long classeId = Long.valueOf(params.classeId)
+ StructureEnseignement classe = StructureEnseignement.get(classeId)
verifieDroitAccesObjetDomaine(classe)
getTypePeriodesExamenNonAffectes(classe)
// Récupère le TypePeriode actuallement selectinné
- if (params.idTypePeriode) {
- TypePeriode typePeriode = TypePeriode.get(Long.valueOf(params.idTypePeriode))
+ if (params.typePeriodeId) {
+ TypePeriode typePeriode = TypePeriode.get(Long.valueOf(params.typePeriodeId))
if (typePeriode) {
typePeriodes << typePeriode
}
// Crée la liste des typePeriodeInfos
List<TypePeriodeInfo> typePeriodeInfos = typePeriodes.collect {
TypePeriodeInfo typePeriodeInfo = new TypePeriodeInfo()
- typePeriodeInfo.idTypePeriode = it.id
+ typePeriodeInfo.typePeriodeId = it.id
typePeriodeInfo.libelle = getTypePeriodeLibelle(it)
return typePeriodeInfo
}
etablissementCourant(),
params.libelle
)
- return [idTypePeriode: typePeriode.id]
+ return [typePeriodeId: typePeriode.id]
}
render result as JSON
* @author bper
*/
class TypePeriodeInfo {
- Long idTypePeriode //TOREFACT à supprimer
+ Long typePeriodeId //TOREFACT à supprimer
Long id
String libelle
Boolean isPeriodeEnCours
Map model = prepareBaseModele(Page.PARAMETRAGES_SERVICES)
- String idClasse = params.idClasse
+ String classeId = params.classeId
String nature = params.nature
NaturePeriode natureChoisie = null
model['classes'] = classesUtilisateur.collect {[id: it.id, code: it.code]}
- if (idClasse != null) {
+ if (classeId != null) {
- StructureEnseignement classe = StructureEnseignement.get(idClasse as Long)
+ StructureEnseignement classe = StructureEnseignement.get(classeId as Long)
if (!classe || !classe.isClasse()) {
throw new IllegalArgumentException(
- "Le parametre idClasse=${idClasse} ne correspond pas à l'identifiant d'une classe")
+ "Le parametre classeId=${classeId} ne correspond pas à l'identifiant d'une classe")
}
verifieDroitAccesObjetDomaine(classe)
periodesNot.each { Periode periode ->
periodesNotation << new ClassePeriodeInfo(
- idTypePeriode: periode.typePeriodeId,
+ typePeriodeId: periode.typePeriodeId,
libelle: getTypePeriodeLibelle(periode.typePeriode, PeriodeLibelleMode.ABREGE)
)
}
}
- model['idClasse'] = idClasse
+ model['classeId'] = classeId
model['natures'] = natures
model['nature'] = natureChoisie.toString()
model['periodesNotation'] = periodesNotation
private ClassePeriodeInfo creeClassePeriodeInfo(Periode periode) {
return new ClassePeriodeInfo(
- idTypePeriode: periode.typePeriodeId,
+ typePeriodeId: periode.typePeriodeId,
libelle: getTypePeriodeLibelle(periode.typePeriode)
)
}
// Converteur JSON pour PeriodeInfo
cfg.registerObjectMarshaller(PeriodeInfo) {PeriodeInfo periodeInfo ->
- return [idPeriode: periodeInfo.idPeriode, libelle: periodeInfo.libelle]
+ return [periodeId: periodeInfo.periodeId, libelle: periodeInfo.libelle]
}
// Converteur JSON pour Personne
List<Periode> periodes = classe.periodes.toList().sort()
periodeInfos = periodes.collect {
- new PeriodeInfo(idPeriode: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
+ new PeriodeInfo(periodeId: it.id, libelle: getTypePeriodeLibelle(it.typePeriode))
}
// Période sélectionnée
periode = periodeId != null ? periodes.find {it.id == periodeId} :
periodeInfos = periodes.collect {
new PeriodeInfo(
- idPeriode: it.id,
+ periodeId: it.id,
libelle: getTypePeriodeLibelle(it.typePeriode)
)
}
List<Service> services = getServicesEtModaliteMatieres(classe)
// Crée la liste des périodes affichées
- // Périodes de notation pour NOTATION (idPeriode pas enseigné)
- // Période d'examen pour EXAMEN (idPeriode enseigné)
+ // Périodes de notation pour NOTATION (periodeId pas enseigné)
+ // Période d'examen pour EXAMEN (periodeId enseigné)
List<Periode> periodesChoisies = []
if (typePeriode == null) {
periodesChoisies = notesPeriodeService.getPeriodesPourClasse(classe)?.findAll { Periode p ->
}
// Récupère les id des Types de Periode déjà affectés à la classe
- List<Long> idTypePeriodesAffectes = Periode.withCriteria {
+ List<Long> typePeriodeIdsAffectes = Periode.withCriteria {
eq('classe', classe)
typePeriode {
eq('nature', NaturePeriode.EXAMEN)
List<TypePeriode> typePeriodesNonAffectes = TypePeriode.withCriteria {
eq('etablissement.id', classe.etablissementId)
eq('nature', NaturePeriode.EXAMEN)
- if (idTypePeriodesAffectes.size() > 0) {
+ if (typePeriodeIdsAffectes.size() > 0) {
not {
- 'in'('id', idTypePeriodesAffectes)
+ 'in'('id', typePeriodeIdsAffectes)
}
}
cache false
// Liste des classes
<g:each var="classe" in="${classes}">
- <g:if test="${idClasse?.equals(classe?.id?.toString())}">
+ <g:if test="${classeId?.equals(classe?.id?.toString())}">
eliot.notes.parametrages.services.ConfigServeur.data.classe = {
id: ${classe?.id ?: 'undefined'},
code: '${classe?.code?.encodeAsJavaScript() ?: 'undefined'}'
// Liste des périodes d'examen
<g:each var="periode" in="${periodesExamen}">
- <g:if test="${periodeExamen?.idTypePeriode == periode?.idTypePeriode}">
+ <g:if test="${periodeExamen?.typePeriodeId == periode?.typePeriodeId}">
eliot.notes.parametrages.services.ConfigServeur.data.periodeExamen = {
- id: ${periode?.idTypePeriode ?: 'undefined'},
+ id: ${periode?.typePeriodeId ?: 'undefined'},
libelle: '${periode?.libelle.encodeAsJavaScript() ?: 'undefined'}'
};
</g:if>
eliot.notes.parametrages.services.ConfigServeur.data.periodesExamen.push({
- id: ${periode?.idTypePeriode ?: 'undefined'},
+ id: ${periode?.typePeriodeId ?: 'undefined'},
libelle: '${periode?.libelle.encodeAsJavaScript() ?: 'undefined'}'
});
</g:each>
// Liste des periodes de notation
<g:each var="periode" in="${periodesNotation}">
eliot.notes.parametrages.services.ConfigServeur.data.periodesNotation.push({
- id: ${periode.idTypePeriode ?: 'undefined'},
+ id: ${periode.typePeriodeId ?: 'undefined'},
libelle: '${periode.libelle.encodeAsJavaScript() ?: 'undefined'}'
});
</g:each>
autoLoad: false,
reader: new Ext.data.JsonReader({
root: 'periodeInfos',
- idProperty: 'idPeriode',
+ idProperty: 'periodeId',
fields:[
- {name:'idPeriode', type:'string'},
+ {name:'periodeId', type:'string'},
{name:'libelle', type:'string'}
]
}),
triggerAction:'all',
selectOnFocus:true,
mode:'local',
- valueField:'idPeriode',
+ valueField:'periodeId',
displayField:'libelle',
editable:false
});
this.comboPeriode.addListener({
select:{
fn:function (combo, record) {
- this.fireEvent(this.Constantes.eventId.actionChangePeriode, record.data.idPeriode);
+ this.fireEvent(this.Constantes.eventId.actionChangePeriode, record.data.periodeId);
},
scope:this
}
autoLoad: false,
reader: new Ext.data.JsonReader({
root: 'periodeInfos',
- idProperty: 'idPeriode',
+ idProperty: 'periodeId',
fields:[
- {name:'idPeriode', type:'string'},
+ {name:'periodeId', type:'string'},
{name:'libelle', type:'string'}
]
}),
triggerAction:'all',
selectOnFocus:true,
mode:'local',
- valueField:'idPeriode',
+ valueField:'periodeId',
displayField:'libelle',
editable:false
});
this.comboPeriode.addListener({
select:{
fn:function (combo, record) {
- this.fireEvent(this.Constantes.eventId.actionChangePeriode, record.data.idPeriode);
+ this.fireEvent(this.Constantes.eventId.actionChangePeriode, record.data.periodeId);
},
scope:this
}
var url = this.ConfigServeur.url.urlImprimerBulletin +
'?eleveId=' + eleve.get('eleveId') +
'&classeId=' + classe.get('id') +
- '&periodeId=' + periode.get('idPeriode');
+ '&periodeId=' + periode.get('periodeId');
if (templateDocumentId != null) {
url += '&templateDocumentId=' + templateDocumentId;
params: {
classeId: classe.get('id'),
eleveId: eleve.get('eleveId'),
- periodeId: periode.get('idPeriode')
+ periodeId: periode.get('periodeId')
},
success: function(reponse) {
autoLoad: false,
reader: new Ext.data.JsonReader({
root: 'periodeInfos',
- idProperty: 'idPeriode',
+ idProperty: 'periodeId',
fields:[
- {name:'idPeriode',type:'string'},
+ {name:'periodeId',type:'string'},
{name:'libelle', type:'string'}
]
})
triggerAction: 'all',
selectOnFocus:true,
mode:'local',
- valueField:'idPeriode',
+ valueField:'periodeId',
displayField:'libelle',
editable: false
});
url: this.ConfigServeur.url.urlGraph,
params: {
eleveId: eleve.get('eleveId'),
- periodeId: periode.get('idPeriode')
+ periodeId: periode.get('periodeId')
},
success: function(reponse) {
autoLoad: false,
reader: new Ext.data.JsonReader({
root: 'periodeInfos',
- idProperty: 'idPeriode',
+ idProperty: 'periodeId',
fields:[
- {name:'idPeriode',type:'string'},
+ {name:'periodeId',type:'string'},
{name:'libelle', type:'string'}
]
})
triggerAction: 'all',
selectOnFocus:true,
mode:'local',
- valueField:'idPeriode',
+ valueField:'periodeId',
displayField:'libelle',
editable: false
});
var url = this.ConfigServeur.url.urlImprimerReleve +
'?eleveId=' + eleve.get('eleveId') +
- '&periodeId=' + periode.get('idPeriode');
+ '&periodeId=' + periode.get('periodeId');
if (templateDocumentId != null) {
url += '&templateDocumentId=' + templateDocumentId;
url: this.ConfigServeur.url.urlReleveDeNotes,
params: {
eleveId: eleve.get('eleveId'),
- periodeId: periode.get('idPeriode')
+ periodeId: periode.get('periodeId')
},
success: function(reponse) {
},
composantId:{
idComboClasse : 'idComboClasse',
- idGridPeriode : 'idGridPeriode',
+ idGrperiodeId : 'idGrperiodeId',
idToolBar : 'idToolBar',
idBoutonCreer : 'idBoutonCreer',
idBoutonMdification : 'idBoutonMdification',
reader: new Ext.data.JsonReader({
root: 'periodeInfos',
- idProperty: 'idPeriode',
+ idProperty: 'periodeId',
fields:[
- {name: 'idPeriode'},
+ {name: 'periodeId'},
{name: 'libelle'},
- {name: 'idTypePeriode'},
+ {name: 'typePeriodeId'},
{name: 'ordre'},
{name: 'groupOrdre'},
{name: 'dateDebutPeriode', type: 'date', dateFormat: 'c'},
reader: new Ext.data.JsonReader({
root: 'typePeriodeInfos',
fields:[
- {name: 'idTypePeriode', type:'string'},
+ {name: 'typePeriodeId', type:'string'},
{name: 'libelle', type:'string'}
]
})
function(index) {
var donnees = this.storePeriode.getAt(index);
if (donnees) {
- if (!donnees.data.idPeriode) {
+ if (!donnees.data.periodeId) {
this.storePeriode.removeAt(index);
this.periodeSelectionne = undefined;
reloadStorePeriode: function() {
// Recharge la liste des périodes
this.storePeriode.reload({
- params: {idClasse: this.classe.id}
+ params: {classeId: this.classe.id}
});
},
/**
* Recharge le store des types de période
- * @param idTypePeriode
+ * @param typePeriodeId
*/
- reloadStoreTypePeriode: function(idTypePeriode) {
+ reloadStoreTypePeriode: function(typePeriodeId) {
// Recharge la liste des types de période pour cette classe
this.storeTypePeriode.load({
params: {
- idClasse: this.classe.id,
- idTypePeriode: idTypePeriode
+ classeId: this.classe.id,
+ typePeriodeId: typePeriodeId
}
});
},
* @param periodeInfoModifie information modifié
*/
executeModifierPeriode : function(periode, periodeInfoModifie) {
- periodeInfoModifie.idPeriode = periode.data.idPeriode;
- periodeInfoModifie.idClasse = this.classe.id;
+ periodeInfoModifie.periodeId = periode.data.periodeId;
+ periodeInfoModifie.classeId = this.classe.id;
periodeInfoModifie.libelle = Encoder.htmlEncode(periodeInfoModifie.libelle);
if (this.valideDatesPeriode(periode)) {
- var url = (periodeInfoModifie.idPeriode != null) ?
+ var url = (periodeInfoModifie.periodeId != null) ?
eliot.notes.parametrages.periodes.Modele.url.urlModifierPeriode :
eliot.notes.parametrages.periodes.Modele.url.urlCreerPeriode;
- var maskText = (periodeInfoModifie.idPeriode != null) ?
+ var maskText = (periodeInfoModifie.periodeId != null) ?
this.ConfigServeur.messages.periodeModifieEnCours :
this.ConfigServeur.messages.periodeCreeEnCours;
eliot.commun.AjaxHelper.request({
url: url,
- // periodeInfoModifie qui contient info obligatoire: idPeriode
+ // periodeInfoModifie qui contient info obligatoire: periodeId
// infos optionnels : coeff et evaluable
params: periodeInfoModifie,
success:function() {
- var message = (periodeInfoModifie.idPeriode != null) ?
+ var message = (periodeInfoModifie.periodeId != null) ?
eliot.notes.parametrages.periodes.Modele.messages.periodeModifieSucces :
eliot.notes.parametrages.periodes.Modele.messages.periodeCreeSucces;
}
else {
- var message = (periodeInfoModifie.idPeriode != null) ?
+ var message = (periodeInfoModifie.periodeId != null) ?
eliot.notes.parametrages.periodes.Modele.messages.periodeModifieEchou :
eliot.notes.parametrages.periodes.Modele.messages.periodeCreeEchou;
executeSupprimerPeriode : function(periode) {
var periodeInfoSupprime = {
- idPeriode: periode.id
+ periodeId: periode.id
};
eliot.commun.AjaxHelper.request({
executerSupprimer : function(periode) {
var periodeInfoSupprime = {
- idPeriode: periode.id
+ periodeId: periode.id
};
eliot.commun.AjaxHelper.request({
executePasserEnTrimestreOuSemestre : function() {
eliot.commun.AjaxHelper.request({
url:eliot.notes.parametrages.periodes.Modele.url.urlPasserEnTrimestreOuSemestre,
- params: {'idClasse': this.classe.id},
+ params: {'classeId': this.classe.id},
timeout: 300000, // 5 minutes (le traitement est lourds)
success:function() {
params: {
libelle: libelle,
- idClasse: this.classe.id
+ classeId: this.classe.id
},
maskText: eliot.notes.parametrages.periodes.Modele.messages.enCoursCreationLibelle,
scope: this,
success: function(reponse) {
// Id du type de période crée
- this.idNouveauTypePeriode = reponse.idTypePeriode;
+ this.idNouveauTypePeriode = reponse.typePeriodeId;
// Recharge la liste des types de période pour cette classe
this.reloadStoreTypePeriode();
});
// Construction de la combo-box
- this.idTypePeriodeEditor = new Ext.form.ComboBox({
+ this.typePeriodeIdEditor = new Ext.form.ComboBox({
id:'TESTDECOMBOID',
store:periodeController.storeTypePeriode,
- valueField:'idTypePeriode',
+ valueField:'typePeriodeId',
displayField:'libelle',
editable:false,
allowBlank:false,
hidden:true
},
{
- id:'idTypePeriode',
+ id:'typePeriodeId',
header:this.ConfigServeur.libelle.libelle,
- dataIndex:'idTypePeriode',
+ dataIndex:'typePeriodeId',
width:150,
- editor:this.idTypePeriodeEditor,
+ editor:this.typePeriodeIdEditor,
renderer:function (value, metaData, record) {
return Encoder.htmlEncode(record.data.libelle);
}
// Construction du grid(periode)
this.periodeGrid = new Ext.grid.GridPanel({
- id:this.Constantes.composantId.idGridPeriode,
+ id:this.Constantes.composantId.idGrperiodeId,
store:periodeController.storePeriode,
enableColumnMove:false,
autoSize:false,
// Observe les différents éléments
this.observePeriodeGrid();
- this.observeIdTypePeriodeEditor();
+ this.observetypePeriodeIdEditor();
this.observeEditor();
this.observeStoreTypePeriode();
this.observeDatesEditors();
function (store) {
// Ajoute la ligne Nouveau
- var RecordType = Ext.data.Record.create(['idTypePeriode', 'libelle']);
+ var RecordType = Ext.data.Record.create(['typePeriodeId', 'libelle']);
var recordNouveau = new RecordType({
- "idTypePeriode":undefined,
+ "typePeriodeId":undefined,
"libelle":this.ConfigServeur.libelle.nouveauTypePeriode
});
store.add(recordNouveau);
var periode = this.periodeController.storePeriode.data.items[this.rowIndexAModifier];
// type de période nouvellement crée
- var idTypePeriode = this.periodeController.idNouveauTypePeriode;
+ var typePeriodeId = this.periodeController.idNouveauTypePeriode;
this.periodeController.idNouveauTypePeriode = undefined;
// ou type initial de la période
- if (idTypePeriode === undefined) {
- idTypePeriode = periode.data.idTypePeriode;
+ if (typePeriodeId === undefined) {
+ typePeriodeId = periode.data.typePeriodeId;
}
- if ((idTypePeriode !== undefined) &&
- (this.idTypePeriodeEditor.store.find('idTypePeriode', idTypePeriode) !== -1)) {
- this.idTypePeriodeEditor.setValue(idTypePeriode);
+ if ((typePeriodeId !== undefined) &&
+ (this.typePeriodeIdEditor.store.find('typePeriodeId', typePeriodeId) !== -1)) {
+ this.typePeriodeIdEditor.setValue(typePeriodeId);
}
else {
- this.idTypePeriodeEditor.setValue('');
+ this.typePeriodeIdEditor.setValue('');
}
var libelleEditable = periode.data.libelleEditable;
if (libelleEditable === true) {
- this.idTypePeriodeEditor.enable();
+ this.typePeriodeIdEditor.enable();
}
/*
// Sélectionne la bonne ligne
- if (this.periodeController.idTypePeriode !== undefined) {
- this.idTypePeriodeEditor.setValue(this.periodeController.idTypePeriode);
+ if (this.periodeController.typePeriodeId !== undefined) {
+ this.typePeriodeIdEditor.setValue(this.periodeController.typePeriodeId);
}
*/
var combo = Ext.getCmp('TESTDECOMBOID');
combo.setValue(periode.data.libelle);
- this.idTypePeriodeEditor.disable();
+ this.typePeriodeIdEditor.disable();
// Recharge le store type de période
- this.periodeController.reloadStoreTypePeriode(periode.data.idTypePeriode);
+ this.periodeController.reloadStoreTypePeriode(periode.data.typePeriodeId);
this.fireEvent(
* Observe la sélection du libellé de la période pour détecter l'item
* "Nouveau" et ouvrir la popup pour créer un nouvel item
*/
- observeIdTypePeriodeEditor:function () {
- this.idTypePeriodeEditor.addListener({
+ observetypePeriodeIdEditor:function () {
+ this.typePeriodeIdEditor.addListener({
select:{
fn:function (combo, record) {
- if (record.data.idTypePeriode === undefined) {
+ if (record.data.typePeriodeId === undefined) {
this.actionCreerLibelle();
}
},
}
});
- /* this.idTypePeriodeEditor.addListener({
+ /* this.typePeriodeIdEditor.addListener({
show: {
fn: function(combo) {
var periode = this.periodeController.storePeriode.data.items[this.rowIndexAModifier];
combo.setValue(periode.data.libelle);
- this.idTypePeriodeEditor.disable();
+ this.typePeriodeIdEditor.disable();
// Recharge le store type de période
- this.periodeController.reloadStoreTypePeriode(periode.data.idTypePeriode);
+ this.periodeController.reloadStoreTypePeriode(periode.data.typePeriodeId);
},
scope: this
anulleCreerLibelle:function () {
this.editor.setDisabled(false);
if (this.periodeController.periodeSelectionne) {
- this.idTypePeriodeEditor.setValue(
- this.periodeController.periodeSelectionne.data.idTypePeriode
+ this.typePeriodeIdEditor.setValue(
+ this.periodeController.periodeSelectionne.data.typePeriodeId
);
} else {
- this.idTypePeriodeEditor.setValue('');
+ this.typePeriodeIdEditor.setValue('');
}
},
localClasses.push(classe);
}, this);
- this.gridClassesWindowAppliqueA.store.loadData({
+ this.grclasseIdsWindowAppliqueA.store.loadData({
classes:localClasses
});
this.windowAppliqueA.show();
- this.gridClassesWindowAppliqueA.getSelectionModel().selectRow(0);
+ this.grclasseIdsWindowAppliqueA.getSelectionModel().selectRow(0);
this.checkBoxNotation.setValue(true);
this.checkBoxExamen.setValue(true);
*/
initWindowAppliqueA:function (classe) {
- this.gridClassesWindowAppliqueA = new Ext.grid.GridPanel({
+ this.grclasseIdsWindowAppliqueA = new Ext.grid.GridPanel({
store:new Ext.data.Store({
autoDestroy:true,
reader:new Ext.data.JsonReader({
cls:'portal-default_table',
listeners:{
viewready:function () {
- this.gridClassesWindowAppliqueA.getSelectionModel().selectRow(0);
+ this.grclasseIdsWindowAppliqueA.getSelectionModel().selectRow(0);
},
scope:this
}
var options = this.checkBoxOptions.getValue();
var classes = [];
- var records = this.gridClassesWindowAppliqueA.getSelectionModel().getSelections();
+ var records = this.grclasseIdsWindowAppliqueA.getSelectionModel().getSelections();
Ext.each(records, function (record) {
scope:this
});
- this.gridClassesWindowAppliqueA.getSelectionModel().addListener(
+ this.grclasseIdsWindowAppliqueA.getSelectionModel().addListener(
'selectionchange',
function () {
this.gereAffichageBoutonOk();
border:false,
style:'margin-left: 25px;',
width:130,
- items:[this.gridClassesWindowAppliqueA]
+ items:[this.grclasseIdsWindowAppliqueA]
}
]
}
disabled = true;
}
- if (this.gridClassesWindowAppliqueA.getSelectionModel().getSelections().length === 0) {
+ if (this.grclasseIdsWindowAppliqueA.getSelectionModel().getSelections().length === 0) {
disabled = true;
}
observerClasseController : function(classeController) {
classeController.addListener(
eliot.notes.parametrages.periodes.Constantes.eventId.classeChange,
- function(idClasse) {
- if (idClasse != null) {
+ function(classeId) {
+ if (classeId != null) {
this.btnCreer.enable();
this.btnPlusDActions.enable();
this.btnOptionsDePublication.enable();
view.addListener(
this.Constantes.eventId.actionChangeClasse,
- function(idClasse) {
- this.rechargePage(idClasse);
+ function(classeId) {
+ this.rechargePage(classeId);
},
this
);
/**
* Recharge la page
- * @param idClasse
+ * @param classeId
*/
- rechargePage: function(idClasse) {
+ rechargePage: function(classeId) {
window.location = this.ConfigServeur.url.urlPage +
- '?idClasse=' + idClasse;
+ '?classeId=' + classeId;
}
});
\ No newline at end of file
/**
* @event actionChangeClasse déclenché lorsque une classe
* sélectionnée
- * @param idClasse classe sélectionnée
+ * @param classeId classe sélectionnée
*/
this.Constantes.eventId.actionChangeClasse
);
*/
rechargePage: function(nature) {
- var idClasse = '';
+ var classeId = '';
if (this.ConfigServeur.data.classe !== undefined) {
- idClasse = this.ConfigServeur.data.classe.id;
+ classeId = this.ConfigServeur.data.classe.id;
}
var idNature = '';
}
window.location = this.ConfigServeur.url.urlPage +
- '?idClasse=' + idClasse +
+ '?classeId=' + classeId +
'&nature=' + idNature;
}
});
\ No newline at end of file
else {
- // Liste des coeffs par période 'coeff{idPeriode}'
+ // Liste des coeffs par période 'coeff{periodeId}'
var periodes = this.ConfigServeur.data.periodesNotation;
for (var i = 0; i < periodes.length; i = i + 1) {
this.storeService.reload({
params:{
- idClasse: this.ConfigServeur.data.classe.id,
+ classeId: this.ConfigServeur.data.classe.id,
nature: this.ConfigServeur.data.nature.id,
- idTypePeriode: undefined
+ typePeriodeId: undefined
}
});
this.storeService.reload({
params:{
- idClasse: this.ConfigServeur.data.classe.id,
+ classeId: this.ConfigServeur.data.classe.id,
nature: this.ConfigServeur.data.nature.id,
- idTypePeriode: periodeExamen.id
+ typePeriodeId: periodeExamen.id
}
});
}
var periodeExamen = this.periodeModel.getPeriodeExamen();
// Informations sur le contexte
- infoModifier.idClasse = this.ConfigServeur.data.classe.id;
+ infoModifier.classeId = this.ConfigServeur.data.classe.id;
infoModifier.nature = this.ConfigServeur.data.nature.id;
- infoModifier.idTypePeriode = undefined;
+ infoModifier.typePeriodeId = undefined;
if (periodeExamen !== undefined) {
- infoModifier.idTypePeriode = periodeExamen.id;
+ infoModifier.typePeriodeId = periodeExamen.id;
}
// Liste des ensignants
if (coeffValue !== undefined) {
infoModifier.coeffs.push({
- idTypePeriode: periode.id,
+ typePeriodeId: periode.id,
coeff: coeffValue
});
}
coeffValue = infoModifier.coeff;
if (coeffValue !== undefined) {
infoModifier.coeffs.push({
- idTypePeriode: periodeExamen.id,
+ typePeriodeId: periodeExamen.id,
coeff: coeffValue
});
}
}
window.location = this.ConfigServeur.url.urlPage
- + '?idClasse=' + this.ConfigServeur.data.classe.id
+ + '?classeId=' + this.ConfigServeur.data.classe.id
+ '&nature=' + this.ConfigServeur.data.nature.id
+ typePeriodeIdParam;
}
window.location = this.ConfigServeur.url.urlPage
- + '?idClasse=' + this.ConfigServeur.data.classe.id
+ + '?classeId=' + this.ConfigServeur.data.classe.id
+ '&nature=' + this.ConfigServeur.data.nature.id
+ typePeriodeIdParam;
columns.push(this.nouvelEditeurCoeff(this.ConfigServeur.libelle.coeff, 'coeff'));
}
else {
- // Liste des colonnes de coeffs par période 'coeff{idPeriode}'
+ // Liste des colonnes de coeffs par période 'coeff{periodeId}'
var periodes = this.ConfigServeur.data.periodesNotation;
for (var i = 0; i < periodes.length; i = i + 1) {
columns.push(this.nouvelEditeurCoeff(periodes[i].libelle, 'coeff_' + periodes[i].id));
localClasses.push(classe);
}, this);
- this.gridClassesWindowAppliqueA.store.loadData({
+ this.grclasseIdsWindowAppliqueA.store.loadData({
classes: localClasses
});
this.windowAppliqueA.show();
- this.gridClassesWindowAppliqueA.getSelectionModel().selectRow(0);
+ this.grclasseIdsWindowAppliqueA.getSelectionModel().selectRow(0);
this.checkBoxOrdre.setValue(false);
this.checkBoxCoefficients.setValue(false);
this.checkBoxSousMatieres.setValue(false);
*/
initWindowAppliqueA: function(classe) {
- this.gridClassesWindowAppliqueA = new Ext.grid.GridPanel({
+ this.grclasseIdsWindowAppliqueA = new Ext.grid.GridPanel({
store: new Ext.data.Store({
autoDestroy: true,
reader: new Ext.data.JsonReader({
cls: 'portal-default_table',
listeners: {
viewready: function() {
- this.gridClassesWindowAppliqueA.getSelectionModel().selectRow(0);
+ this.grclasseIdsWindowAppliqueA.getSelectionModel().selectRow(0);
},
scope: this
}
var sousMatieres = this.checkBoxSousMatieres.getValue();
var classes = [];
- var records = this.gridClassesWindowAppliqueA.getSelectionModel().getSelections();
+ var records = this.grclasseIdsWindowAppliqueA.getSelectionModel().getSelections();
Ext.each(records, function(record) {
scope: this
});
- this.gridClassesWindowAppliqueA.getSelectionModel().addListener(
+ this.grclasseIdsWindowAppliqueA.getSelectionModel().addListener(
'selectionchange',
function() {
this.gereAffichageBoutonOk();
border: false,
style: 'margin-left: 25px;',
width: 130,
- items: [this.gridClassesWindowAppliqueA]
+ items: [this.grclasseIdsWindowAppliqueA]
},
{
xtype: 'panel',
disabled = true;
}
- if (this.gridClassesWindowAppliqueA.getSelectionModel().getSelections().length === 0) {
+ if (this.grclasseIdsWindowAppliqueA.getSelectionModel().getSelections().length === 0) {
disabled = true;
}
}
window.location = this.ConfigServeur.url.urlPage
- + '?idClasse=' + this.ConfigServeur.data.traitementEnCours.classeId
+ + '?classeId=' + this.ConfigServeur.data.traitementEnCours.classeId
+ '&nature=' + this.ConfigServeur.data.traitementEnCours.naturePeriodeId
+ typePeriodeIdParam;
this.classeModel.addListener(
this.Constantes.eventId.classeChange,
function(classe) {
- eliot.notes.Messages.resetMessages();
this.enregistre();
this.rechargeListeEleveEtPeriode(classe);
+ this.rechargeConseilDeClasse();
},
this
);
this.eleveModel.addListener(
this.Constantes.eventId.eleveChange,
function() {
- eliot.notes.Messages.resetMessages();
this.enregistre(this.eleveModel.getEleveOld());
this.rechargeConseilDeClasse();
},
this.periodeModel.addListener(
this.Constantes.eventId.periodeChange,
function() {
- eliot.notes.Messages.resetMessages();
this.enregistre(undefined, this.periodeModel.getPeriodeOld());
this.rechargeConseilDeClasse();
},
params: {
classeId: classe.get('id'),
eleveId: eleve.get('eleveId'),
- periodeId: periode.get('idPeriode')
+ periodeId: periode.get('periodeId')
},
success: function(reponse) {
params: {
classeId: classe.get('id'),
eleveId: eleve.get('eleveId'),
- periodeId: periode.get('idPeriode'),
+ periodeId: periode.get('periodeId'),
chargePeriodesPrecedentes:
this.view.periodesPrecedentesCheckbox.getValue()
},
var periode = this.periodeModel.getPeriode();
if (periode !== undefined)
- location += '&periodeId=' + periode.get('idPeriode');
+ location += '&periodeId=' + periode.get('periodeId');
}
params: {
eleveId: eleve.get('eleveId'),
- periodeId: periode.get('idPeriode'),
+ periodeId: periode.get('periodeId'),
appreciation: record.get('appreciation'),
avisType1Id: record.get('avisType1Id'),
avisType2Id: record.get('avisType2Id')
success: function(reponse) {
// Affiche les valeurs saisies dans le tableau de récap
- var appreciationRecord = this.storeAppreciation.getById(periode.get('idPeriode'));
+ var appreciationRecord = this.storeAppreciation.getById(periode.get('periodeId'));
if ((appreciationRecord !== undefined) && (appreciationRecord !== null)) {
appreciationRecord.set('appreciation', record.get('appreciation'));
this.Constantes.eventId.eleveChange,
function(eleve) {
if (eleve !== undefined) {
-
- this.fireEvent(this.Constantes.eventId.listeEleveChange,
- this.eleveModel.eleve.get('eleveId'));
-
+ this.fireEvent(
+ this.Constantes.eventId.listeEleveChange,
+ this.eleveModel.eleve.get('eleveId')
+ );
}
},
this);
this.Constantes.eventId.listeEleveChange,
function(eleves, eleveSelectionneId) {
- eliot.notes.Messages.resetMessages();
-
this.storeEleve.loadData({
eleveInfos: eleves
});
this.eleveModel.eleves = this.storeEleve.getRange();
- this.eleveModel.setEleve(this.storeEleve.getById(eleveSelectionneId));
+ this.eleveModel.setEleve(this.storeEleve.getById(eleveSelectionneId), true);
this.fireEvent(this.Constantes.eventId.listeEleveChange, eleveSelectionneId);
},
* Setter
* @param eleve
*/
- setEleve: function(eleve) {
+ setEleve: function(eleve, silent) {
this.eleveOld = this.eleve;
this.eleve = eleve;
- this.fireEvent(this.Constantes.eventId.eleveChange, eleve);
+ if (silent !== true) {
+ this.fireEvent(this.Constantes.eventId.eleveChange, eleve);
+ }
},
/**
scope: this
}
});
-
-
- this.comboEleve.addListener({
- beforeselect: {
- fn: function(combo, eleve) {
- var saisie = this.saisieModel.getValue();
- if (saisie) {
- this.afficheMessageSaisieEnCours();
- return false;
- }
- },
- scope: this
- }
- });
},
/**
function(eleveSelectionneId) {
this.comboEleve.setValue(eleveSelectionneId);
this.actualiseEtatBoutons(eleveSelectionneId);
- //this.eleveCompositeField.syncSize();
+
+ if (eleveSelectionneId === undefined) {
+ this.seletionnePrimierEleve();
+ }
},
this
);
break;
}
}
-
}
}
-
- if ((eleves.length > 0) && (eleveSelectionneId == undefined)) {
- this.fireEvent(this.Constantes.eventId.actionEleveSuivant);
- }
},
- afficheMessageSaisieEnCours: function() {
- eliot.notes.Messages.showErreur(this.ConfigServeur.messages.nonEnregistrees);
- }
+ seletionnePrimierEleve: function() {
+ var eleves = this.comboEleve.getStore().getRange();
+ if (eleves !== undefined && eleves.length > 0) {
+ var eleve = eleves[0];
+ this.eleveModel.setEleve(eleves[0], true);
+ this.comboEleve.setValue(eleve.get('eleveId'));
+ }
+ }
});
\ No newline at end of file
autoLoad: false,
reader: new Ext.data.JsonReader({
root: 'periodeInfos',
- idProperty: 'idPeriode',
+ idProperty: 'periodeId',
fields:[
- {name:'idPeriode',type:'string'},
+ {name:'periodeId',type:'string'},
{name:'libelle', type:'string'}
]
})
this.Constantes.eventId.listePeriodeChange,
function(periodes, periodeSelectionneeId) {
- eliot.notes.Messages.resetMessages();
-
this.storePeriode.loadData({
periodeInfos: periodes
});
- this.periodeModel.setPeriode(this.storePeriode.getById(periodeSelectionneeId));
+ this.periodeModel.setPeriode(this.storePeriode.getById(periodeSelectionneeId), true);
this.fireEvent(this.Constantes.eventId.listePeriodeChange, periodeSelectionneeId);
},
* Setter
* @param periode
*/
- setPeriode: function(periode) {
+ setPeriode: function(periode, silent) {
this.periodeOld = this.periode;
this.periode = periode;
- this.fireEvent(this.Constantes.eventId.periodeChange, periode);
+ if (silent !== true) {
+ this.fireEvent(this.Constantes.eventId.periodeChange, periode);
+ }
},
/**
triggerAction: 'all',
selectOnFocus:true,
mode: 'local',
- valueField: 'idPeriode',
+ valueField: 'periodeId',
displayField: 'libelle',
editable: false
});
impressionController: this.impressionController
});
- // Une liste qui contient un grid(note) quand idService et idPeriode
+ // Une liste qui contient un grid(note) quand idService et periodeId
// sélectionnés, si non la liste est vide
var headerItems = [];
var contentItems = [];
/**
* Recharge la page
- * @param idClasse
+ * @param classeId
*/
rechargePage: function(classeId) {
window.location = eliot.notes.saisie.Modele.url.urlSynthese +
autoLoad: false,
reader: new Ext.data.JsonReader({
root: 'periodeInfos',
- idProperty: 'idPeriode',
+ idProperty: 'periodeId',
fields:[
- {name:'idPeriode', type:'string'},
+ {name:'periodeId', type:'string'},
{name:'libelle', type:'string'}
]
}),
/**
* Recharge la page
- * @param idPeriode
+ * @param periodeId
*/
rechargePage: function(periodeId) {
window.location = eliot.notes.saisie.Modele.url.urlSynthese +
triggerAction: 'all',
selectOnFocus:true,
mode:'local',
- valueField:'idPeriode',
+ valueField:'periodeId',
displayField:'libelle',
editable : false
});
this.comboPeriode.addListener({
select: {
fn: function(combo, record) {
- this.fireEvent(this.Constantes.eventId.actionChangePeriode, record.data.idPeriode);
+ this.fireEvent(this.Constantes.eventId.actionChangePeriode, record.data.periodeId);
},
scope: this
}
url:this.ConfigServeur.url.urlSaveAppreciationGenerale,
params:{
- idPeriode:this.ConfigServeur.data.periodeId,
+ periodeId:this.ConfigServeur.data.periodeId,
appreciation:Ext.encode(this.listeAppreciationModifiee)
},
// EvaluationController
this.evaluationController = new ns.EvaluationController();
- // Une liste qui contient un grid(note) quand idService et idPeriode
+ // Une liste qui contient un grid(note) quand idService et periodeId
// sélectionnés, si non la liste est vide
var contentItems = [];
var moyenneClasse = [];
root : 'typePeriodeInfos',
idProperty: 'id',
fields:[
- {name:'idPeriode',type:'string', mapping: 'id'},
+ {name:'periodeId',type:'string', mapping: 'id'},
{name:'libelle', type:'string'},
{name:'isPeriodeEnCours', type:'boolean'}
]
triggerAction: 'all',
selectOnFocus:true,
mode:'local',
- valueField:'idPeriode',
+ valueField:'periodeId',
displayField:'libelle',
editable : false
});
fn: function(combo, record) {
this.fireEvent(
this.Constantes.eventId.actionChangePeriode,
- record.data.idPeriode
+ record.data.periodeId
);
},
scope: this