//-------------------------------------------------------------------
public CResultAErreur AddRoleToActeurs(CRoleActeur role, CGroupeActeur groupe)
{
CResultAErreur result = CResultAErreur.True;
CListeObjetsDonnees listeActeurs = new CListeObjetsDonnees(groupe.ContexteDonnee, typeof(CActeur));
//Sélectionne tous les acteurs du groupe qui n'ont pas le rôle
CFiltreDataAvance filtre = new CFiltreDataAvance(CActeur.c_nomTable,
"(RelationsGroupes.GroupeActeur.Id = @1 or " +
"RelationsGroupes.GroupeActeur.RelationsTousGroupesContenants.GroupeActeurContenant.Id = @1) and " +
"hasno ( " + role.NomTableDonneesActeur + ".Id)",
groupe.Id);
listeActeurs.Filtre = filtre;
foreach (CActeur acteur in listeActeurs)
{
#if PDA
CDonneesActeur donnee = (CDonneesActeur)Activator.CreateInstance(role.TypeDonneeActeur);
donnee.ContexteDonnee = groupe.ContexteDonnee;
#else
CDonneesActeur donnee = (CDonneesActeur)Activator.CreateInstance(role.TypeDonneeActeur, new object[] { groupe.ContexteDonnee });
#endif
donnee.CreateNewInCurrentContexte();
donnee.Acteur = acteur;
donnee.IsDonneeActeurValide = donnee.VerifieDonnees(false);
}
return(result);
}
/// ///////////////////////////////////////////
public override object Invoke(object objetAppelle, params object[] parametres)
{
CEtapeWorkflow etape = objetAppelle as CEtapeWorkflow;
if (etape == null || parametres.Length > 0)
{
return(null);
}
List <CActeur> listeActeurs = new List <CActeur>();
List <IAffectableAEtape> listeAffectables = new List <IAffectableAEtape>(etape.Assignments);
foreach (IAffectableAEtape affectable in listeAffectables)
{
CActeur acteur = affectable as CActeur;
if (acteur != null)
{
listeActeurs.Add(acteur);
}
else
{
CGroupeActeur groupe = affectable as CGroupeActeur;
if (groupe != null)
{
foreach (CRelationActeur_GroupeActeur relation in groupe.RelationsActeur)
{
listeActeurs.Add(relation.Acteur);
}
}
else
{
CProfilUtilisateur profil = affectable as CProfilUtilisateur;
if (profil != null)
{
CListeObjetDonneeGenerique <CActeur> lstActeursDansProfil =
new CListeObjetDonneeGenerique <CActeur>(etape.ContexteDonnee);
lstActeursDansProfil.Filtre = new CFiltreDataAvance(
CActeur.c_nomTable,
CDonneesActeurUtilisateur.c_nomTable + "." +
CRelationUtilisateur_Profil.c_nomTable + "." +
CProfilUtilisateur.c_nomTable + "." +
CProfilUtilisateur.c_champId + " = @1",
profil.Id);
foreach (CActeur acteurProfil in lstActeursDansProfil)
{
listeActeurs.Add(acteurProfil);
}
}
}
}
}
return(listeActeurs.ToArray());
}
//----------------------------------------------------------------
private void AddNodeGroupe(CGroupeActeur groupe, TreeNodeCollection nodes)
{
TreeNode node = new TreeNode(groupe.Nom);
node.Tag = groupe;
nodes.Add(node);
foreach (CRelationGroupeActeurNecessite rel in groupe.RelationsGroupesNecessitants)
{
AddNodeGroupe(rel.GroupeActeurNecessitant, node.Nodes);
}
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CGroupeActeur groupe = (CGroupeActeur)objet;
if (groupe.Nom == "")
{
result.EmpileErreur(I.T("Member Group name cannot be empty|273"));
}
if (!CObjetDonneeAIdNumerique.IsUnique(groupe, CGroupeActeur.c_champNom, groupe.Nom))
{
result.EmpileErreur(I.T("Member Group name already exists|274"));
}
if (groupe.IdGroupeAd != "")
{
if (!CObjetDonneeAIdNumerique.IsUnique(groupe, CGroupeActeur.c_champGroupeWindowsCorrespondant, groupe.IdGroupeAd))
{
result.EmpileErreur(I.T("Another Member Group is already associated with this AD Group|275"));
}
}
int[] nIdsGroupesContenus = groupe.GetHierarchieGroupesContenus();
int[] nIdsGroupeContenants = groupe.GetHierarchieGroupesContenants();
foreach (int i in nIdsGroupeContenants)
{
foreach (int j in nIdsGroupesContenus)
{
if (i == j && i != groupe.Id && j != groupe.Id)
{
result.EmpileErreur(I.T("Incorrect Group hierarchy|276"));
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
protected bool CreateOrUpdateRelations(CGroupeActeur groupe, CAdGroup adGroupe, Hashtable tableElementsASupprimer, Hashtable tableEmpecheRecursInf)
{
if (tableEmpecheRecursInf[adGroupe.Id] != null)
{
return(false);
}
tableEmpecheRecursInf[adGroupe.Id] = true;
//Trouve le groupe correspondant au groupe AD
CGroupeActeur groupeCorrespondant = CGroupeActeur.FromAd(groupe.ContexteDonnee, adGroupe.Id);
if (groupeCorrespondant == null)
{
foreach (CAdGroup adParent in adGroupe.GroupesParents)
{
if (CreateOrUpdateRelations(groupe, adParent, tableElementsASupprimer, tableEmpecheRecursInf))
{
return(true);
}
}
}
else
{
//Le groupe correspondant existe. Existe-t-il la relation ?
CListeObjetsDonnees liste = groupe.RelationsGroupesContenantsDirects;
liste.Filtre = new CFiltreData(CRelationGroupeActeur_GroupeActeur.c_champIdGroupeContenant + "=@1", groupeCorrespondant.Id);
if (liste.Count == 1)
{
CRelationGroupeActeur_GroupeActeur rel = (CRelationGroupeActeur_GroupeActeur)liste[0];
tableElementsASupprimer.Remove(rel); //On ne supprime pas
}
else
{
//Crée la relation
CRelationGroupeActeur_GroupeActeur rel = new CRelationGroupeActeur_GroupeActeur(groupe.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.GroupeContenant = groupeCorrespondant;
rel.GroupeContenu = groupe;
}
return(true);
}
return(false);
}
//----------------------------------------------------------------
private void CheckNode(CGroupeActeur groupe, TreeNodeCollection nodes)
{
foreach (TreeNode node in nodes)
{
if (node.Tag.Equals(groupe))
{
node.Checked = true;
TreeNode parent = node.Parent;
while (parent != null)
{
parent.Expand();
parent = parent.Parent;
}
}
else
{
node.Checked = false;
}
CheckNode(groupe, node.Nodes);
}
}
/// ///////////////////////////////////////////
public override object Invoke(object objetAppelle, params object[] parametres)
{
CEtapeWorkflow etape = objetAppelle as CEtapeWorkflow;
if (etape == null || parametres.Length > 0)
{
return(null);
}
List <CGroupeActeur> listeGroupes = new List <CGroupeActeur>();
List <IAffectableAEtape> listeAffectables = new List <IAffectableAEtape>(etape.Assignments);
foreach (IAffectableAEtape affectable in listeAffectables)
{
CGroupeActeur groupe = affectable as CGroupeActeur;
if (groupe != null)
{
listeGroupes.Add(groupe);
}
}
return(listeGroupes.ToArray());
}
//-------------------------------------------------------------------------
public CFormEditionGroupeActeurs(CGroupeActeur groupe, CListeObjetsDonnees liste)
: base(groupe, liste)
{
// Cet appel est requis par le Concepteur Windows Form.
InitializeComponent();
}
/// ////////////////////////////////////////////////////////////////////
public CResultAErreur SerializeFiltre(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
InitCombos();
}
string strText = m_txtNom.Text;
serializer.TraiteString(ref strText);
m_txtNom.Text = strText;
strText = m_txtCodePostal.Text;
serializer.TraiteString(ref strText);
m_txtCodePostal.Text = strText;
strText = m_txtVille.Text;
serializer.TraiteString(ref strText);
m_txtVille.Text = strText;
string strCodeRole = "";
if (m_cmbRoles.SelectedValue is CRoleActeur)
{
strCodeRole = ((CRoleActeur)m_cmbRoles.SelectedValue).CodeRole;
}
serializer.TraiteString(ref strCodeRole);
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_cmbRoles.SelectedValue = CRoleActeur.GetRole(strCodeRole);
}
int nIdGroupe = -1;
if (m_cmbGroupes.SelectedValue is CGroupeActeur)
{
nIdGroupe = ((CGroupeActeur)m_cmbGroupes.SelectedValue).Id;
}
serializer.TraiteInt(ref nIdGroupe);
if (serializer.Mode == ModeSerialisation.Lecture)
{
if (nIdGroupe >= 0)
{
CGroupeActeur groupe = new CGroupeActeur(CSc2iWin32DataClient.ContexteCourant);
if (groupe.ReadIfExists(nIdGroupe))
{
m_cmbGroupes.SelectedValue = groupe;
}
}
}
return(result);
}
