//----------------------------------------------------------------------
public CResultAErreur SetParametres(Dictionary <string, object> dicParametres)
{
CResultAErreur result = CResultAErreur.True;
object obj = null;
if (dicParametres.TryGetValue(m_cParametreReportId, out obj))
{
if (obj is int)
{
m_rapport = new C2iRapportCrystal(CSc2iWin32DataClient.ContexteCourant);
if (!m_rapport.ReadIfExists((int)obj))
{
result.EmpileErreur(I.T("There is no Crystal Report Model corresponding to the Id: @1|10006", ((int)obj).ToString()));
}
}
else if (obj is string)
{
m_rapport = new C2iRapportCrystal(CSc2iWin32DataClient.ContexteCourant);
if (!m_rapport.ReadIfExists(CDbKey.CreateFromStringValue((string)obj)))
{
result.EmpileErreur(I.T("There is no Crystal Report Model corresponding to the Universal : @1", (string)obj));
}
}
else
{
result.EmpileErreur(I.T("The Report ID parameter must be an integer value|10007"));
}
}
return(result);
}
public void AddProprietesAccedees(
CArbreDefinitionsDynamiques arbre,
Type typeSource,
string strPropriete)
{
//TESTDBKEYOK
CDbKey key = CDbKey.CreateFromStringValue(strPropriete);
/*int nIdChamp = -1;
* try
* {
* nIdChamp = Int32.Parse ( strPropriete );
* }
* catch
* {
* }*/
CChampCalcule champCalcule = new CChampCalcule(CContexteDonneeSysteme.GetInstance());
C2iExpression formule = null;
if (champCalcule.ReadIfExists(key))
{
formule = champCalcule.Formule;
formule.GetArbreProprietesAccedees(arbre);
CDefinitionProprieteDynamiqueChampCalcule.DetailleSousArbres(arbre, CContexteDonneeSysteme.GetInstance());
}
}
//---------------------------------------------------------------------------------
public static object GetValeurChamp(IObjetDonneeAChamps objet, string strIdChamp)
{
CChampCustom champ = new CChampCustom(objet.ContexteDonnee);
if (champ.ReadIfExists(CDbKey.CreateFromStringValue(strIdChamp)))
{
return(GetValeurChamp(objet, champ.Id, DataRowVersion.Default));
}
return(null);
}
//------------------------------------------------------------
public override CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
result.Data = null;
string strIdChamp = null;
bool bEntiteToChamp = false;
if (
/*Pour compatibilité, avant modifs de décembre 2015, le nom du champ était en fait le même qu'une propriété champ custom.
* En décembre 2015, ajout de la possiblité de retourner les valeurs display de champ custom dans les requêtes,
* ce qui a changé le nom de la propriétés
* */
CInfoRelationEntiteToValeurChampCustom.DecomposeNomPropriete(strPropriete, ref strIdChamp) ||
/*fin pour compatiblité*/
CInfoRelationComposantFiltreEntiteToChampEntite.DecomposeNomPropriete(strPropriete, ref strIdChamp, ref bEntiteToChamp))
{
IElementAChamps eltAChamps = objet as IElementAChamps;
if (eltAChamps == null)
{
return(result);
}
result.Data = eltAChamps.GetValeurChamp(strIdChamp);
CChampCustom champ = new CChampCustom(CContexteDonneeSysteme.GetInstance());
if (result.Data != null && champ.ReadIfExists(CDbKey.CreateFromStringValue(strIdChamp)))
{
if (!champ.IsChoixParmis())
{
result.Data = result.Data.ToString();
}
else
{
foreach (CValeurChampCustom valeur in champ.ListeValeurs)
{
if (valeur.Value.Equals(result.Data))
{
result.Data = valeur.Display;
return(result);
}
}
}
}
}
else if (CInfoRelationEValeurChampCustomToDisplay.DecomposeNomPropriete(strPropriete, ref strIdChamp))
{
//Rien de spécial, il s'agit de la navigation vers la valeur du champ qui a déjà été reprise par le composant filtre to champ entité
//car la propriété complète d'un definitionDisplayValue est donnée par GetKeyChamp qui ajoute un composant Element->ValeurChamp + ValeurChamp->Display value
result.Data = objet;
}
return(result);
}
public static bool EditeNomVariable(ref string strNom, ref CTypeResultatExpression typeDonnee, ref CDbKey dbKeyInitial, bool bAvecIdInitial)
{
CFormEditNomVariable form = new CFormEditNomVariable();
form.m_txtNomVariable.Text = strNom;
form.InitComboBoxType(typeDonnee != null ? typeDonnee.TypeDotNetNatif : null);
if (typeDonnee != null)
{
form.m_panelType.LockEdition = true;
form.m_chkTableau.Checked = typeDonnee.IsArrayOfTypeNatif;
form.m_cmbTypeElements.SelectedValue = typeDonnee.TypeDotNetNatif;
form.m_txtKeyInitiale.Text = dbKeyInitial != null?dbKeyInitial.StringValue:"";
}
form.m_panelIdInitial.Visible = bAvecIdInitial;
bool bResult = form.ShowDialog() == DialogResult.OK;
if (bResult)
{
strNom = form.m_txtNomVariable.Text;
if (!form.m_panelType.LockEdition)
{
Type tp = (Type)form.m_cmbTypeElements.SelectedValue;
if (tp == null || tp == typeof(DBNull))
{
tp = null;
}
typeDonnee = new CTypeResultatExpression(
(Type)form.m_cmbTypeElements.SelectedValue,
form.m_chkTableau.Checked);
}
if (form.m_txtKeyInitiale != null)
{
int nId = -1;
if (int.TryParse(form.m_txtKeyInitiale.Text, out nId))
{
dbKeyInitial = CDbKey.GetNewDbKeyOnIdAUtiliserPourCeuxQuiNeGerentPasLeDbKey(nId);
}
else
{
dbKeyInitial = CDbKey.CreateFromStringValue(form.m_txtKeyInitiale.Text);
}
}
else
{
bResult = false;
}
}
form.Dispose();
return(bResult);
}
//---------------------------------------------------------------------------------
public static CResultAErreur SetValeurChamp(IObjetDonneeAChamps objet, string strIdChamp, object valeur)
{
CResultAErreur result = CResultAErreur.True;
CChampCustom champ = new CChampCustom(objet.ContexteDonnee);
if (champ.ReadIfExists(CDbKey.CreateFromStringValue(strIdChamp)))
{
return(SetValeurChamp(objet, champ.Id, valeur));
}
result.EmpileErreur("Invalid Custom Field Id in SetValeurChamps (Line 179)");
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
result = ExpressionUtilisateur.Eval(contexteEval);
if (!result)
{
return(result);
}
else
{
CDbKey keyUtilisateur = null;
try
{
//TESTDBKEYOK
int nId = Convert.ToInt32(result.Data);
keyUtilisateur = CDbKey.GetNewDbKeyOnIdAUtiliserPourCeuxQuiNeGerentPasLeDbKey(nId);
}
catch
{
//TESTDBKEYTODO
if (result.Data != null)
{
keyUtilisateur = CDbKey.CreateFromStringValue(result.Data.ToString());
}
else
{
result.EmpileErreur(I.T("The user expression doesn't return an integer number|381"));
return(result);
}
}
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte.ContexteDonnee);
if (!user.ReadIfExists(keyUtilisateur))
{
result.EmpileErreur(I.T("The user @1 doesn't exist|382", keyUtilisateur.StringValue));
return(result);
}
contexte.Branche.KeyUtilisateur = keyUtilisateur;
CSessionClient session = CSessionClient.GetSessionForIdSession(contexte.ContexteDonnee.IdSession);
if (session != null)
{
session.ChangeUtilisateur(keyUtilisateur);
}
}
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur SaveAll(CContexteSauvegardeObjetsDonnees contexteSauvegarde, System.Data.DataRowState etatsAPrendreEnCompte)
{
DataTable table = contexteSauvegarde.ContexteDonnee.Tables[GetNomTable()];
List <DataRow> rowsAdded = new List <DataRow>();
if (table != null)
{
foreach (DataRow row in new ArrayList(table.Rows))
{
if (row.RowState == DataRowState.Added || (row.RowState == DataRowState.Modified && !row[CSc2iDataConst.c_champIsDeleted].Equals(true)))
{
rowsAdded.Add(row);
}
if (row.RowState == DataRowState.Deleted || (row.RowState == DataRowState.Modified && row[CSc2iDataConst.c_champIsDeleted].Equals(true)))
{
//TESTDBKEYTODO
CDonneeNotificationBesoinIntervention notif = new CDonneeNotificationBesoinIntervention(
IdSession,
CDbKey.CreateFromStringValue((string)row[CBesoinInterventionProcess.c_champKeyUtilisateur,
DataRowVersion.Original]),
(int)row[CBesoinInterventionProcess.c_champId,
DataRowVersion.Original],
(string)row[CBesoinInterventionProcess.c_champLibelle,
DataRowVersion.Original],
true);
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { notif });
}
}
}
CResultAErreur result = base.SaveAll(contexteSauvegarde, etatsAPrendreEnCompte);
if (result)
{
foreach (DataRow row in rowsAdded)
{
//TESTDBKEYTODO
CDonneeNotificationBesoinIntervention notif = new CDonneeNotificationBesoinIntervention(
IdSession,
CDbKey.CreateFromStringValue((string)row[CBesoinInterventionProcess.c_champKeyUtilisateur]),
(int)row[CBesoinInterventionProcess.c_champId],
(string)row[CBesoinInterventionProcess.c_champLibelle],
false);
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { notif });
}
}
return(result);
}
/// ////////////////////////////////////////////////////////////////
public static void FindRelation(string strTable, Type type, ref CInfoRelationComposantFiltre relationTrouvee)
{
//TESTDBKEYTODO
if (relationTrouvee != null)
{
return;
}
string strKeyChamp = "";
if (DecomposeNomPropriete(strTable, ref strKeyChamp))
{
string strTableEntite = CContexteDonnee.GetNomTableForType(type);
//Si strKeyChamp est un int, il s'agit d'un id de champ custom
//ce cas peut se présenter lors de la relecture d'un filtre sous forme de
//test par exemple dans une fonction ObjectList
relationTrouvee = new CInfoRelationEValeurChampCustomToDisplay(CDbKey.CreateFromStringValue(strKeyChamp), strTableEntite);
}
//relationTrouvee = new CInfoRelationEValeurChampCustomToDisplay(relToChamp.DbKeyChamp, relToChamp.TableFille);
}
public IOptimiseurGetValueDynamic GetOptimiseur(Type tp, string strPropriete)
{
//TESTDBKEYOK
CDbKey key = CDbKey.CreateFromStringValue(strPropriete);
/*int nIdChamp = -1;
* try
* {
* nIdChamp = Int32.Parse ( strPropriete );
* }
* catch
* {
* }*/
CChampCalcule champCalcule = new CChampCalcule(CContexteDonneeSysteme.GetInstance());
C2iExpression formule = null;
if (champCalcule.ReadIfExists(key))
{
formule = champCalcule.Formule;
}
return(new CInterpreteurProprieteDynamiqueFormule.COptimiseurProprieteDynamiqueFormule(formule));
}
//------------------------------------------------------------
public CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
CObjetDonnee objetDonnee = objet as CObjetDonnee;
if (objetDonnee == null)
{
result.Data = null;
return(result);
}
//TESTDBKEYOK
CDbKey key = CDbKey.CreateFromStringValue(strPropriete);
CContexteDonnee contexte = objetDonnee.ContexteDonnee;
CChampCalcule champCalcule = new CChampCalcule(contexte);
if (!champCalcule.ReadIfExists(key))
{
result.EmpileErreur(I.T("Calculated field @1 doesn't exists|200023", strPropriete));
return(result);
}
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objet);
return(champCalcule.Formule.Eval(ctx));
}
//------------------------------------------------------------------------------------------
public void ReadArbre(CListeObjetsDonnees listeSource, CListeObjetsDonnees.CArbreProps arbre, List <string> lstPaquetsALire)
{
string strIdChamp = "";
string strPropriete = "";
string strCle = "";
if (listeSource.Count == 0)
{
return;
}
bool bFromEntiteToChamp = false;
if (!CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(arbre.ProprietePrincipale, ref strCle, ref strPropriete))
{
return;
}
if (!CInfoRelationComposantFiltreEntiteToChampEntite.DecomposeNomPropriete(strPropriete, ref strIdChamp, ref bFromEntiteToChamp))
{
//c'est une relation vers des valeurs de champ qui pointent sur cette valeur.
//Ignore, et traite tout dans le composant suivant qui est un Entité to champ à l'envers
listeSource.ReadDependances(arbre);
return;
}
//On a affaire à une liste source qui contient des valeurs qui sont pointées
//par des valeurs de champs, et on veut les éléments qui pointent sur ces valeurs de champs
CChampCustom champ = new CChampCustom(listeSource.ContexteDonnee);
CDbKey dbKeyChamp = CDbKey.CreateFromStringValue(strIdChamp);
if (!champ.ReadIfExists(dbKeyChamp))
{
return;
}
//Vérifie que la liste source est bien du type de données du champ custom
if (champ.TypeDonnee.TypeDotNetNatif != listeSource.TypeObjets)
{
return;
}
IObjetDonneeAIdNumerique obj = listeSource[0] as IObjetDonneeAIdNumerique;
if (obj == null)
{
return;
}
string strChampId = obj.GetChampId();
if (lstPaquetsALire == null)
{
lstPaquetsALire = listeSource.GetPaquetsPourLectureFils(strChampId, null);
}
//Trouve le type des éléments à champs
Type typeElementsFinaux = champ.Role.TypeAssocie;
//Trouve le type des relations aux elementAchamp_ChampCustom
IObjetDonneeAChamps elt = Activator.CreateInstance(typeElementsFinaux, new object[] { listeSource.ContexteDonnee }) as IObjetDonneeAChamps;
if (elt == null)
{
return;
}
string strNomTableRelToChamp = elt.GetNomTableRelationToChamps();
Type tpRelToChamp = CContexteDonnee.GetTypeForTable(strNomTableRelToChamp);
if (tpRelToChamp == null)
{
return;
}
foreach (string strPaquet in lstPaquetsALire)
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(listeSource.ContexteDonnee, typeElementsFinaux);
//TESTDBKEYTODO
string strChampCustomId = dbKeyChamp.IsNumericalId() ? CChampCustom.c_champId : CObjetDonnee.c_champIdUniversel;
lst.Filtre = new CFiltreDataAvance(
CContexteDonnee.GetNomTableForType(typeElementsFinaux),
strNomTableRelToChamp + "." + strChampCustomId + "=@1 and " +
strNomTableRelToChamp + "." + CRelationElementAChamp_ChampCustom.c_champValeurInt + " in " +
strPaquet,
dbKeyChamp.GetValeurInDb());
lst.AssureLectureFaite();
lst.ReadDependances(arbre);
}
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] listeParametres)
{
CResultAErreur result = CResultAErreur.True;
try
{
CDbKey dbKeyIdChamp = null;
object valeurRetournee = null;
//TESTDBKEYOK : le premier paramètre peut être un Id ou un UniversalId de champ
if (listeParametres.Length == 2)
{
if (listeParametres[0] is int)
{
int nIdChamp = (int)listeParametres[0];
dbKeyIdChamp = CDbKey.GetNewDbKeyOnIdAUtiliserPourCeuxQuiNeGerentPasLeDbKey(nIdChamp);
}
else
{
dbKeyIdChamp = CDbKey.CreateFromStringValue((string)listeParametres[0]);
}
valeurRetournee = listeParametres[1];
}
if (listeParametres.Length == 1)
{
//1 seul paramètre, ce doit être une expression variable avec une variable champ
C2iExpressionChamp exChamp = Parametres2i[0] as C2iExpressionChamp;
if (exChamp != null)
{
CDefinitionProprieteDynamiqueChampCustom def = exChamp.DefinitionPropriete as CDefinitionProprieteDynamiqueChampCustom;
if (def != null)
{
dbKeyIdChamp = def.DbKeyChamp;
}
}
valeurRetournee = listeParametres[0];
}
if (valeurRetournee == null || dbKeyIdChamp == null)
{
result.Data = "";
return(result);
}
CContexteDonnee contexteDonnee = (CContexteDonnee)ctx.GetObjetAttache(typeof(CContexteDonnee));
if (contexteDonnee == null)
{
contexteDonnee = new CContexteDonnee(CSessionClient.GetSessionUnique().IdSession, true, false);
ctx.AttacheObjet(typeof(CContexteDonnee), contexteDonnee);
}
CChampCustom champ = new CChampCustom(contexteDonnee);
if (champ.ReadIfExists(dbKeyIdChamp))
{
if (!champ.IsChoixParmis())
{
result.Data = valeurRetournee.ToString();
}
else
{
foreach (CValeurChampCustom valeur in champ.ListeValeurs)
{
if (valeur.Value.Equals(valeurRetournee))
{
result.Data = valeur.Display;
return(result);
}
}
}
}
result.Data = "";
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// ///////////////////////////////////////////////////////////
public object GetValue(object objetInterroge, string strPropriete)
{
CFournisseurPropDynStd fournisseur = new CFournisseurPropDynStd(false);
if (objetInterroge == null)
{
return(null);
}
//Est-ce une propriété simple ?(majorité des cas )
object objetAInterroger = null;
MemberInfo membre = null;
if (CInterpreteurTextePropriete.GetObjetFinalEtMemberInfo(objetInterroge, strPropriete, ref objetAInterroger, ref membre) && membre != null)
{
return(CInterpreteurTextePropriete.GetValue(objetAInterroger, membre));
}
//Bon pas de bol, c'est autre chose, il faut donc chercher ce que c'est
Type tp = objetInterroge.GetType();
string strPropDebut = strPropriete.Split('.')[0];
object objetPremier = CInterpreteurTextePropriete.GetValue(objetInterroge, strPropDebut);
if (objetPremier == null)
{
string strIdChamp = CDefinitionProprieteDynamiqueChampCustom.GetIdPropriete(strPropDebut);
foreach (CDefinitionProprieteDynamique def in fournisseur.GetDefinitionsChamps(tp, 0))
{
if (def.NomPropriete == strPropDebut ||
(strIdChamp != "" && def is CDefinitionProprieteDynamiqueChampCustom) &&
((CDefinitionProprieteDynamiqueChampCustom)def).DbKeyChamp == CDbKey.CreateFromStringValue(strIdChamp))
{
objetPremier = GetValue(objetInterroge, def);
//Si la suite est une relation de la valeur champ vers l'objet, il ne faut pas
//traier la suite
if (strPropDebut != strPropriete)
{
string strSuiteTmp = strPropriete.Substring(strPropDebut.Length + 1);
if (CInfoRelationComposantFiltreChampToEntite.IsRelationFromChampToEntite(strSuiteTmp))
{
//On a déjà traité ce lien par GetValeurPropriété (qui retourne la valeur
//et nom pas le lien vers la valeur)
strPropDebut += "." + strPropriete.Split('.')[1];
}
}
break;
}
}
}
if (objetPremier == null)
{
return(null);
}
if (strPropDebut == strPropriete)
{
return(objetPremier);
}
string strSuite = strPropriete.Substring(strPropDebut.Length + 1);
return(GetValue(objetPremier, strSuite));
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Calcule le message
string strMessage = "";
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleMessage.Eval(contexteEval);
if (!result)
{
result = CResultAErreur.True;
strMessage = FormuleMessage.GetString();
}
else
{
strMessage = result.Data == null?"":result.Data.ToString();
}
string strCodeAttente = "";
if (FormuleCodeAttente != null)
{
result = FormuleCodeAttente.Eval(contexteEval);
if (!result || result.Data == null)
{
strCodeAttente = "";
}
else
{
strCodeAttente = result.Data.ToString();
}
}
//TESTDBKEYOK (SC)
CDbKey keyUtilisateur = contexte.Branche.KeyUtilisateur;
if (m_formuleIdUtilisateur != null)
{
//TESTDBKEYOK
result = m_formuleIdUtilisateur.Eval(contexteEval);
if (result)
{
if (result.Data is int)
{
keyUtilisateur = CUtilInfosUtilisateur.GetKeyUtilisateurFromId((int)result.Data);
}
if (result.Data is string)
{
keyUtilisateur = CDbKey.CreateFromStringValue((string)result.Data);
}
if (result.Data is CDbKey)
{
keyUtilisateur = (CDbKey)result.Data;
}
if (keyUtilisateur != null)
{
contexte.Branche.KeyUtilisateur = keyUtilisateur;
}
}
}
//Si le code d'attente n'est pas null et qu'il y a déjà une attente,
//il faut la supprimer
if (strCodeAttente != null && strCodeAttente.Trim() != "")
{
CFiltreData filtre = new CFiltreData(
CBesoinInterventionProcess.c_champCodeAttente + "=@1",
strCodeAttente);
CListeObjetsDonnees listeToDelete = new CListeObjetsDonnees(contexte.ContexteDonnee, typeof(CBesoinInterventionProcess));
listeToDelete.Filtre = filtre;
if (listeToDelete.Count != 0)
{
CObjetDonneeAIdNumerique.Delete(listeToDelete);
}
}
CBesoinInterventionProcess intervention = new CBesoinInterventionProcess(contexte.ContexteDonnee);
intervention.CreateNewInCurrentContexte();
intervention.ProcessEnExecution = contexte.ProcessEnExecution;
//TESTDBKEYOK
intervention.KeyUtilisateur = keyUtilisateur;
intervention.DateDemande = DateTime.Now;
intervention.CodeAttente = strCodeAttente;
intervention.Libelle = strMessage;
CLienAction[] liens = GetLiensSortantHorsErreur();
if (liens.Length == 1)
{
intervention.IdAction = liens[0].ActionArrivee.IdObjetProcess;
}
else
{
intervention.IdAction = -1;
}
//Mise du process en pause !
result.Data = new CMetteurDeProcessEnPause( );
return(result);
}
//-------------------------------------------------------------------
public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee ds)
{
CResultAErreur result = base.TraitementAvantSauvegarde(ds);
CDonneesActeurUtilisateur userConnecte = CDonneesActeurUtilisateur.GetUserForSession(ds.IdSession, ds);
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
// Un utilisateur ne peut pas affecter un Profil de Licence à un autre utilisateur,
// si ce profil est plus fort que le sien
CInfoLicenceUserProfil profil = (CInfoLicenceUserProfil)session.GetPropriete(CInfoLicenceUserProfil.c_nomIdentification);
//envoie les notifications sur modification de données utilisateur
DataTable table = ds.Tables[GetNomTable()];
foreach (DataRow row in table.Rows)
{
if (row.RowState != DataRowState.Unchanged)
{
if (userConnecte != null)
{
// Vérifie premièrement que l'utilisateur connecté à le droit de gestion de utilisateurs
if (userConnecte.GetDonneeDroit(CDroitDeBase.c_droitBaseGestionUtilisateurs) == null)
{
result.EmpileErreur(I.T("You don't have System Right to Manage Application Users|10012"));
return(result);
}
}
}
if (row.RowState == DataRowState.Added || row.RowState == DataRowState.Modified)
{
if (userConnecte != null)
{
// Verifie ensuite que l'utilisteur connecté tente de donner un droit qu'il n'a pas !
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(row);
foreach (CRelationActeurUtilisateur_Droit relDroit in user.RelationsDroits)
{
if (userConnecte.GetDonneeDroit(relDroit.Droit.Code) == null)
{
result.EmpileErreur(I.T("You don't have right to affect this system Right : @1|10019", relDroit.Droit.Libelle));
return(result);
}
}
// Vérifie que l'utilisateur connecté ne tente pas d'affecter un profil de licence supérieur au sien
string strIdProfil = user.IdProfilLicence;
CInfoLicenceUserProfil profilModifie = CGestionnaireProfilLicenceSurClient.GetProfil(strIdProfil);
if (profil == null || profilModifie != null && profilModifie.Priorite > profil.Priorite)
{
result.EmpileErreur(I.T("You can not affect a Licence Profile greater than your Profile : @1|20140", profilModifie.Nom));
}
}
//TESTDBKEYOK
CDonneeNotificationChangementDroitUtilisateur notDroit = new CDonneeNotificationChangementDroitUtilisateur(IdSession, CDbKey.CreateFromStringValue((string)row[CDonneesActeurUtilisateur.c_champIdUniversel]));
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { notDroit });
}
}
return(result);
}
public CResultAErreur UnfreezeStep(DateTime endDate, string strComment, string strKeyMember)
{
return(Degeler(endDate, strComment, CDbKey.CreateFromStringValue(strKeyMember)));
}
public CResultAErreur FreezeStep(DateTime startDate, CCauseGel freezeCause, string strComment, string strKeyMember)
{
return(Geler(startDate, freezeCause, strComment, CDbKey.CreateFromStringValue(strKeyMember)));
}
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteType(ref m_typeCible);
int nTmp = (int)m_typeEvenement;
serializer.TraiteInt(ref nTmp);
m_typeEvenement = (TypeEvenement)nTmp;
I2iSerializable objet = m_proprieteASurveiller;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_proprieteASurveiller = (CDefinitionProprieteDynamique)objet;
objet = m_formuleValeurAvant;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleValeurAvant = (C2iExpression)objet;
objet = m_formuleValeurApres;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleValeurApres = (C2iExpression)objet;
objet = m_formuleConditionDeclenchement;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleConditionDeclenchement = (C2iExpression)objet;
objet = m_formuleDateProgramme;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleDateProgramme = (C2iExpression)objet;
serializer.TraiteString(ref m_strCodeHandler);
if (nVersion >= 1)
{
serializer.TraiteString(ref m_strMenuManuel);
if (nVersion < 6 && serializer.Mode == ModeSerialisation.Lecture)
{
//TESTDBKEYOK les groupes pour exécution manuelle ne sont plus exploités (Avril 2014)
IList lst = new ArrayList();
serializer.TraiteListeObjetsSimples(ref lst);
List <CDbKey> lstIdsTemp = new List <CDbKey>();
foreach (int nId in lst)
{
lstIdsTemp.Add(CDbKey.GetNewDbKeyOnIdAUtiliserPourCeuxQuiNeGerentPasLeDbKey(nId));
}
m_lstKeysGroupesManuels = lstIdsTemp.ToArray();
}
else
{
//TESTDBKEYTODO
IList lstKeysString = new ArrayList();
foreach (CDbKey key in m_lstKeysGroupesManuels)
{
if (key != null)
{
lstKeysString.Add(key.StringValue);
}
}
serializer.TraiteListeObjetsSimples(ref lstKeysString);
if (serializer.Mode == ModeSerialisation.Lecture)
{
List <CDbKey> lstKeys = new List <CDbKey>();
foreach (string strKey in lstKeysString)
{
int nId;
if (int.TryParse(strKey, out nId))
{
lstKeys.Add(CDbKey.GetNewDbKeyOnIdAUtiliserPourCeuxQuiNeGerentPasLeDbKey(nId));
}
else
{
lstKeys.Add(CDbKey.CreateFromStringValue(strKey));
}
m_lstKeysGroupesManuels = lstKeys.ToArray();
}
}
}
}
if (nVersion >= 2)
{
serializer.TraiteInt(ref m_nOrdreExecution);
}
if (nVersion >= 3)
{
serializer.TraiteString(ref m_strIdEvenementSpecifique);
}
if (nVersion >= 4)
{
serializer.TraiteBool(ref m_bHideProgress);
}
else
{
m_bHideProgress = false;
}
if (nVersion >= 5)
{
int nNbContextes = m_contextesException.Count;
serializer.TraiteInt(ref nNbContextes);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (string strContexte in m_contextesException)
{
string strCtx = strContexte;
serializer.TraiteString(ref strCtx);
}
break;
case ModeSerialisation.Lecture:
m_contextesException = new HashSet <string>();
for (int i = 0; i < nNbContextes; i++)
{
string strCtx = "";
serializer.TraiteString(ref strCtx);
m_contextesException.Add(strCtx);
}
break;
}
}
return(result);
}
