/// //////////////////////////////
///
public CResultAErreur Init(
CListeObjetsDonnees liste,
string strProprieteAffiche,
string strChampFiltre,
Type typeFormEditionStandard
)
{
m_filtrePrincipal = liste.Filtre;
m_listeObjets = liste;
m_listeObjets.AssureLectureFaite();
m_listeObjets.InterditLectureInDB = true;
m_strProprieteAffichee = strProprieteAffiche;
m_strChampFiltre = strChampFiltre;
m_typeFormEdition = typeFormEditionStandard;
return(m_combo.Init(liste, strProprieteAffiche, typeFormEditionStandard, true));
}
/// ////////////////////////////////////////////////////////////////////
private void InitMenuFiltres()
{
CListeObjetsDonnees lstFiltres = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, typeof(CFiltreDynamiqueInDb));
lstFiltres.Filtre = new CFiltreData(CFiltreDynamiqueInDb.c_champTypeElements + "=@1", m_type.ToString());
m_menuFiltres.MenuItems.Clear();
MenuItem menu = new MenuItem(I.T("Temporary filter|1313"));
m_menuFiltres.MenuItems.Add(menu);
m_menuFiltres.MenuItems.Add(new MenuItem("----------------"));
foreach (CFiltreDynamiqueInDb filtre in lstFiltres)
{
CMenuItemAFiltre item = new CMenuItemAFiltre(filtre);
item.Click += new EventHandler(OnSelectFiltre);
m_menuFiltres.MenuItems.Add(item);
}
}
//----------------------------------------------------------------
/// <summary>
/// Retourne la liste des Sites du Contrat, qu'ils soient définis par Profil ou par une liste de relations "manuelle"
/// </summary>
/// <returns></returns>
public IList <CSite> GetTousLesSitesDuContrat()
{
IList <CSite> listeSites = new List <CSite>();
StringBuilder bl = new StringBuilder();
if (this.TypeContrat != null && this.TypeContrat.GestionSitesManuel)
{
// Ajout des Sites par relation
RelationsSites.ReadDependances("Site");
foreach (CContrat_Site rel in RelationsSites)
{
listeSites.Add(rel.Site);
bl.Append(rel.Site.Id);
bl.Append(",");
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
}
CFiltreData filtre;
if (bl.Length > 0)
{
filtre = new CFiltreData(CSite.c_champId + " in (" + bl.ToString() + ")");
CListeObjetDonneeGenerique <CSite> lst = new CListeObjetDonneeGenerique <CSite>(ContexteDonnee, filtre);
return(lst);
}
else
{
return(new List <CSite>());
}
}
else
{
CProfilElement profil = ProfilSite;
if (profil != null)
{
CListeObjetsDonnees liste = profil.GetElementListForSource(this);
foreach (CSite site in liste)
{
listeSites.Add(site);
}
}
return(listeSites);
}
}
/// ////////////////////////////////////////////
private void RefreshListe()
{
CFiltreData filtre = null;
if (m_txtRecherche.Text != null)
{
filtre = m_filtreRechercheRapide;
if (filtre != null)
{
if (filtre.Parametres.Count == 0)
{
filtre.Parametres.Add(m_txtRecherche.Text);
}
else
{
filtre.Parametres[0] = "%" + m_txtRecherche.Text + "%";
}
}
}
filtre = CFiltreData.GetAndFiltre(filtre, m_filtre);
if (m_listeObjets == null)
{
m_listeObjets = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, m_typeObjets);
m_listeObjets.Filtre = filtre;
m_listeObjets.RemplissageProgressif = true;
}
else
{
m_listeObjets.Filtre = filtre;
}
if (!typeof(IObjetHierarchiqueACodeHierarchique).IsAssignableFrom(m_typeObjets))
{
m_wndListeElements.ListeSource = m_listeObjets;
m_wndListeElements.Refresh();
}
else
{
m_arbre.Init(m_typeObjets, m_strProprieteListeFils, m_strChampParent, m_strProprieteAffichee, filtre, null);
}
if (m_listeObjets.Count == 1)
{
m_objetSelectionne = (CObjetDonnee)m_listeObjets[0];
}
}
//------------------------------------------------------------
public CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
CObjetDonnee objetDonnee = objet as CObjetDonnee;
if (objetDonnee == null)
{
return(result);
}
int nIdListe = -1;
try
{
nIdListe = Int32.Parse(strPropriete);
}
catch
{
result.EmpileErreur(I.T("Bad entity list property format (@1)|20028", strPropriete));
return(result);
}
CListeEntites liste = new CListeEntites(objetDonnee.ContexteDonnee);
try
{
if (liste.ReadIfExists(nIdListe))
{
CListeObjetsDonnees resultListe = liste.GetElementsLiesFor(objetDonnee);
if (resultListe != null)
{
result.Data = resultListe.ToArray(liste.TypeElements);
}
}
else
{
result.EmpileErreur(I.T("Entity list @1 doesn't exists|20029", strPropriete));
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// ////////////////////////////////////////////////////////////////////////
public void InitPanel
(
IDefinisseurChampCustomRelationObjetDonnee definisseur,
Type typeFormGererChamps,
Type typeFormGererFormulaires
)
{
m_definisseur = definisseur;
m_typeFormGererChamps = typeFormGererChamps;
m_typeFormGererFormulaires = typeFormGererFormulaires;
if (m_bAvecAffectationDirecteDesChamps)
{
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(definisseur.ContexteDonnee, typeof(CChampCustom));
listeChamps.Filtre = CChampCustom.GetFiltreChampsForRole(definisseur.RoleChampCustomDesElementsAChamp.CodeRole);
m_panelListeChampsCustom.Init(
listeChamps,
m_definisseur.RelationsChampsCustomListe,
(CObjetDonneeAIdNumeriqueAuto)definisseur,
"Definisseur",
"ChampCustom"
);
}
CListeObjetsDonnees listeFormulaires = new CListeObjetsDonnees(definisseur.ContexteDonnee, typeof(CFormulaire));
listeFormulaires.Filtre = CFormulaire.GetFiltreFormulairesForRole(definisseur.RoleChampCustomDesElementsAChamp.CodeRole);
//listeFormulaires.Filtre = new CFiltreData(CFormulaire.c_champCodeRole + "=@1", definisseur.RoleChampCustomDesElementsAChamp.CodeRole);
m_panelListeFormulaires.Init(
listeFormulaires,
m_definisseur.RelationsFormulairesListe,
(IObjetAContexteDonnee)definisseur,
"Definisseur",
"Formulaire"
);
m_panelListeChampsCustom.RemplirGrille();
m_panelListeFormulaires.RemplirGrille();
if (!m_bAvecAffectationDirecteDesChamps)
{
m_panelConteneurGererChamps.Visible = false;
}
}
/// ///////////////////////////////////////////
public object GetValeur(IElementAVariablesDynamiquesAvecContexteDonnee elementInterroge)
{
if (m_filtreDynamique == null)
{
return(null);
}
m_filtreDynamique.ElementAVariablesExterne = elementInterroge;
CResultAErreur result = m_filtreDynamique.GetFiltreData();
if (!result)
{
return(null);
}
CListeObjetsDonnees liste = new CListeObjetsDonnees(elementInterroge.ContexteDonnee, m_filtreDynamique.TypeElements);
liste.Filtre = (CFiltreData)result.Data;
return(liste.ToArray(m_filtreDynamique.TypeElements));
}
public void SetElementsLies(IEnumerable elements, string strCode)
{
if (elements == null)
{
return;
}
ArrayList lst = new ArrayList();
CListeObjetsDonnees liste = TypeEntree.RelationsTypeElementsAAgenda;
liste.Filtre = new CFiltreData(CRelationTypeEntreeAgenda_TypeElementAAgenda.c_champCode + "=@1", strCode);
if (liste.Count == 0)
{
return;
}
CRelationTypeEntreeAgenda_TypeElementAAgenda relType = (CRelationTypeEntreeAgenda_TypeElementAAgenda)liste[0];
SetElementsLies(elements, relType);
}
////////////////////////////////////////////////////////////////////////
public static CListeObjetsDonnees GetListeDocumentsForElement(IObjetDonneeAIdNumerique objet)
{
if (objet == null)
{
return(null);
}
CFiltreData filtre = new CFiltreDataAvance(
CDocumentGED.c_nomTable,
CRelationElementToDocument.c_nomTable + "." + CRelationElementToDocument.c_champIdElement + "=@1 and " +
CRelationElementToDocument.c_nomTable + "." + CRelationElementToDocument.c_champTypeElement + "=@2",
objet.Id,
objet.GetType().ToString());
CListeObjetsDonnees liste = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CDocumentGED));
liste.RemplissageProgressif = true;
liste.Filtre = filtre;
return(liste);
}
private void InitComboTypeEquipement()
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonnee, typeof(CSpvTypeq));
m_cmbTypeEquipement.Fill(liste, "Libelle", false);
if (TableSnmp.TypeEquipementAttache != null)
{
m_cmbTypeEquipement.SelectedValue = TableSnmp.TypeEquipementAttache;
}
/*
* m_SelectTypeEquipement.Init(
* typeof(CFormListeTypesEquipements),
* "Libelle",
* CFournisseurFiltreRapide.GetFiltreRapideForType(typeof(CTypeEquipement)));
* m_SelectTypeEquipement.ElementSelectionne = TableSnmpEdite.TypeEquipementAttache;*/
}
//---------------------------------------------
public void AddSelectedEntity(CObjetDonneeAIdNumerique objet)
{
if (objet != null && (objet.GetType() == TypeEntiteAssocie || TypeEntiteAssocie == null))
{
TypeEntiteAssocie = objet.GetType();
//Vérifie que l'entité n'est pas déjà associée
CListeObjetsDonnees lst = RelationsElementsSelectionnes;
lst.Filtre = new CFiltreData(CRelationBesoinQuantite_Element.c_champIdElement + "=@1",
objet.Id);
if (lst.Count == 0)
{
CRelationBesoinQuantite_Element rel = new CRelationBesoinQuantite_Element(ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.BesoinQuantite = this;
rel.Element = objet;
}
}
}
public bool AddElementLie(CObjetDonneeAIdNumerique element, string strCode)
{
if (element == null)
{
return(false);
}
ArrayList lst = new ArrayList();
CListeObjetsDonnees liste = TypeEntree.RelationsTypeElementsAAgenda;
liste.Filtre = new CFiltreData(CRelationTypeEntreeAgenda_TypeElementAAgenda.c_champCode + "=@1", strCode);
if (liste.Count == 0)
{
return(false);
}
CRelationTypeEntreeAgenda_TypeElementAAgenda relType = (CRelationTypeEntreeAgenda_TypeElementAAgenda)liste[0];
return(AddElementLieSurType(element, relType));
}
/// /////////////////////////////////////////////////////////////
private void UpdateLiensChampsCustom(C2iWnd fenetre)
{
CListeObjetsDonnees listeRelations = RelationsChamps;
Hashtable tableRelations = new Hashtable();
Hashtable tableToDelete = new Hashtable();
foreach (CRelationFormulaireChampCustom rel in listeRelations)
{
tableRelations[rel.Champ.Id] = rel;
tableToDelete[rel.Champ.Id] = rel;
}
if (fenetre != null)
{
ArrayList lst = fenetre.AllChilds();
foreach (object obj in lst)
{
if (obj is C2iWndChampCustom)
{
C2iWndChampCustom fenChamp = (C2iWndChampCustom)obj;
CChampCustom champ = fenChamp.ChampCustom;
if (champ != null)
{
CRelationFormulaireChampCustom rel = (CRelationFormulaireChampCustom)tableRelations[champ.Id];
if (rel == null)
{
rel = new CRelationFormulaireChampCustom(ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.Champ = champ;
rel.Formulaire = this;
tableRelations[champ.Id] = rel;
}
tableToDelete.Remove(champ.Id);
rel.NumWeb = fenChamp.WebNumOrder;
rel.LibelleWeb = fenChamp.WebLabel;
}
}
}
}
foreach (CRelationFormulaireChampCustom rel in tableToDelete.Values)
{
rel.Delete();
}
}
public static void AddToMenuParent(ToolStripMenuItem menu, string strContexte, object objet)
{
if (objet == null)
{
return;
}
CModeleTexte modeleSel = CTimosAppRegistre.GetModeleTexteForType(strContexte, objet.GetType());
CListeObjetsDonnees liste = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, typeof(CModeleTexte));
liste.Filtre = new CFiltreData(CModeleTexte.c_champTypeAssocie + "=@1",
objet.GetType().ToString());
foreach (CModeleTexte modele in liste)
{
CMenuModeleTexte menuModele = new CMenuModeleTexte(modele, strContexte, objet);
if (modeleSel != null && modele.Id == modeleSel.Id)
{
menuModele.Checked = true;
}
menuModele.MouseUp += new MouseEventHandler(menuModele.menuModele_MouseUp);
menu.DropDownItems.Add(menuModele);
}
CSessionClient session = CSessionClient.GetSessionForIdSession(CSc2iWin32DataClient.ContexteCourant.IdSession);
if (session != null)
{
IInfoUtilisateur info = session.GetInfoUtilisateur();
if (info != null && info.GetDonneeDroit(CDroitDeBaseSC2I.c_droitAdministration) != null)
{
menu.DropDownItems.Add(new ToolStripSeparator());
CMenuModeleTexte menuModeleAdd = new CMenuModeleTexte(null, strContexte, objet);
menuModeleAdd.Text = I.T("Add|124");
menuModeleAdd.Click += new EventHandler(menuModeleAdd.itemAddMenu_Click);
menu.DropDownItems.Add(menuModeleAdd);
}
}
if (menu.DropDownItems.Count == 0)
{
menu.Visible = false;
}
}
private void CArbreConsultationHierarchique_BeforeExpand(object sender, TreeViewCancelEventArgs e)
{
using (sc2i.win32.common.CWaitCursor waiter = new sc2i.win32.common.CWaitCursor())
{
TreeNode node = e.Node;
if (node.Nodes.Count == 1 && node.Nodes[0].Tag == null)
{
node.Nodes.Clear();
CNodeConsultationHierarchique data = node.Tag as CNodeConsultationHierarchique;
IObjetDonneeAutoReference objetAutoRef = data.ObjetLie as IObjetDonneeAutoReference;
CFolderConsultationFolder folderParent = null;
folderParent = ((CNodeConsultationHierarchique)node.Tag).Folder as CFolderConsultationFolder;
if (objetAutoRef != null && (folderParent == null))
{
string strProp = objetAutoRef.ProprieteListeFils;
PropertyInfo prop = objetAutoRef.GetType().GetProperty(strProp);
if (prop != null)
{
MethodInfo methode = prop.GetGetMethod();
if (methode != null)
{
CListeObjetsDonnees listeFils = methode.Invoke(objetAutoRef, new object[0]) as CListeObjetsDonnees;
if (listeFils != null)
{
foreach (CObjetDonnee objet in listeFils)
{
CNodeConsultationHierarchique dataFils = new CNodeConsultationHierarchique(
objet,
data.Folder,
node.Tag as CNodeConsultationHierarchique);
TreeNode newNode = CreateNode(dataFils);
node.Nodes.Add(newNode);
}
}
}
}
}
foreach (CFolderConsultationHierarchique folderFils in data.Folder.SousFolders)
{
CreateNodes(data.ObjetLie, folderFils, node);
}
}
}
}
//-------------------------------------------------------------------------
private void CFormNommageEntite_Load(object sender, EventArgs e)
{
sc2i.win32.common.CWin32Traducteur.Translate(this);
if (m_objet != null)
{
m_lblEntite.Text = m_objet.DescriptionElement;
}
else
{
m_lblEntite.Text = I.T("None|915");
}
// Recherche la liste des CNommageEntite existants sur cet élément
CListeObjetsDonnees lstNommages = new CListeObjetsDonnees(m_contexteLocal, typeof(CNommageEntite));
//TESTDBKEYOK
lstNommages.Filtre = new CFiltreData(
CNommageEntite.c_champTypeEntite + " = @1 and " +
CNommageEntite.c_champCleEntite + " = @2",
m_objet.TypeString,
m_objet.DbKey.StringValue);
// Vide la liste des Controles
foreach (Control ctrl in m_panelControlsSaisie.Controls)
{
if (ctrl is CControlSaisieNomEntite)
{
ctrl.Visible = false;
ctrl.Parent = null;
m_panelControlsSaisie.Controls.Remove(ctrl);
ctrl.Dispose();
}
}
// Remplie le liste des controles
m_nIndex = 0;
foreach (CNommageEntite nom in lstNommages)
{
if (nom.NomFort != String.Empty)
{
AjouterControlSaisieNommage(nom, m_nIndex++);
}
}
}
//---------------------------------------------
/// <summary>
/// Génère un mouvement qui annule celui-ci
/// </summary>
/// <returns></returns>
public CResultAErreur AnnuleDeplacement()
{
CResultAErreur result = CResultAErreur.True;
CMouvementEquipement mouvement = this;
mouvement.BeginEdit();
try
{
CListeObjetsDonnees mvts = EquipementDeplace.Mouvements;
mvts.Tri = c_champDateMouvement;
if (!mvts[mvts.Count - 1].Equals(mouvement))
{
result.EmpileErreur(I.T("Impossible to cancel the movement of the equipment '@1' because it is not the last movement of this equipment|30036", EquipementDeplace.Libelle));
return(result);
}
result = EquipementDeplace.DeplaceEquipement(
"Annulation du mouvement précédent",
EmplacementOrigine,
EquipementOrigine,
CoordonneeOrigine,
OccupationOrigine,
null,
DateTime.Now,
"");
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (result)
{
result = mouvement.CommitEdit();
}
else
{
mouvement.CancelEdit();
}
}
return(result);
}
public CResultAErreur Execute(int nIdSession, Hashtable valeursParametres)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
{
try
{
CHandlerEvenementServeur.SuspendGestionnaire(true);
// Supprimer les interventions SANS DEPLACEMENT
CListeObjetsDonnees listeIntersASupprimer = new CListeObjetsDonnees(contexte, typeof(CIntervention));
listeIntersASupprimer.Filtre = new CFiltreDataAvance(
CIntervention.c_nomTable,
//CIntervention.c_champId + " > @1 AND " + // DEBUG
CFractionIntervention.c_nomTable + "." +
COperation.c_nomTable + "." +
CTypeOperation.c_champId + " = @1",
//8900, // DEBUG
30); // 30 = Id du type d'opération SANS DEPLACEMENT
//int nbASupprimer = listeIntersASupprimer.CountNoLoad;
CObjetDonneeAIdNumerique.DeleteAvecCascadeSansControleDoncIlFautEtreSurDeSoi(listeIntersASupprimer);
result = contexte.SaveAll(true);
if (!result)
{
result.EmpileErreur("Erreur de sauvegarde des données");
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
CHandlerEvenementServeur.SuspendGestionnaire(false);
}
}
return(result);
}
/// <summary>
/// Retourne tous les comportements génériques induits par un définisseur
/// </summary>
/// <param name="definisseur"></param>
/// <returns></returns>
public static CComportementGenerique[] GetComportementsInduits(IDefinisseurEvenements definisseur)
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(((CObjetDonnee)definisseur).ContexteDonnee, typeof(CRelationDefinisseurComportementInduit));
liste.Filtre = new CFiltreData(
CRelationDefinisseurComportementInduit.c_champTypeDefinisseur + "=@1 and " +
CRelationDefinisseurComportementInduit.c_champIdDefinisseur + "=@2",
definisseur.GetType().ToString(),
definisseur.Id);
CComportementGenerique[] lst = new CComportementGenerique[liste.Count];
int nIndex = 0;
foreach (CRelationDefinisseurComportementInduit rel in liste)
{
lst[nIndex++] = rel.Comportement;
}
return(lst);
}
/// /////////////////////////////////////////////
public DataTable GetNewDataTable(string strNomTable)
{
DataTable dt = new DataTable(strNomTable);
dt.Columns.Add("ID");
dt.Columns[0].AutoIncrement = true;
CListeObjetsDonnees lstcol = Colonnes;
for (int i = 0; i < lstcol.Count; i++)
{
foreach (CColonneTableParametrable col in lstcol)
{
if (col.Position == i)
{
dt.Columns.Add(col.GetDataColumn());
break;
}
}
}
lstcol = ColonnesClePrimaires;
if (lstcol.Count > 0)
{
List <DataColumn> colPks = new List <DataColumn>();
foreach (CColonneTableParametrable col in lstcol)
{
foreach (DataColumn c in dt.Columns)
{
if (c.ColumnName == col.Libelle)
{
colPks.Add(c);
break;
}
}
}
dt.PrimaryKey = colPks.ToArray();
}
CTableParametrable.PrepareToForUse(dt, null);
return(dt);
}
public static string[] GetSrongNames(this CObjetDonneeAIdNumerique objet)
{
List <string> strNames = new List <string>();
CListeObjetsDonnees lstNommages = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CNommageEntite));
//TESTDBKEYOK
lstNommages.Filtre = new CFiltreData(
CNommageEntite.c_champTypeEntite + " = @1 and " +
CNommageEntite.c_champCleEntite + " = @2",
objet.TypeString,
objet.DbKey.StringValue);
foreach (CNommageEntite nom in lstNommages)
{
strNames.Add(nom.NomFort);
}
return(strNames.ToArray());
}
//-----------------------------------------------------------------------------------------------
public IEnumerable <CDefinitionProprieteDynamique> GetDefinitionsFonctionsSupplementaires(CObjetPourSousProprietes objet)
{
List <CDefinitionProprieteDynamique> lstProps = new List <CDefinitionProprieteDynamique>();
if (objet == null)
{
return(lstProps.ToArray());
}
Type tp = objet.TypeAnalyse;
if (tp == null)
{
return(lstProps.ToArray());
}
if (!C2iFactory.IsInit())
{
return(lstProps.ToArray());
}
CContexteDonnee contexte = CContexteDonneeSysteme.GetInstance();
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CFonctionDynamiqueInDb));
liste.Filtre = new CFiltreData(CFonctionDynamiqueInDb.c_champTypeObjets + "=@1", tp.ToString());
foreach (CFonctionDynamiqueInDb fonctionInDb in liste)
{
CFonctionDynamique fonction = fonctionInDb.Fonction;
if (fonction != null)
{
CDefinitionFonctionDynamique def = new CDefinitionFonctionDynamique(fonction);
if (fonctionInDb.Categorie.Length == 0)
{
def.Rubrique = I.T("Methods|58");
}
else
{
def.Rubrique = fonctionInDb.Categorie;
}
lstProps.Add(def);
}
}
return(lstProps.ToArray());
}
/// ////////////////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CRelationTypeEquipement_TypeRemplacement relation = (CRelationTypeEquipement_TypeRemplacement)objet;
if (relation.TypeRemplacable == null)
{
result.EmpileErreur(I.T("The Replaceable Type must be defined|131"));
}
if (relation.TypeRemplacant == null)
{
result.EmpileErreur(I.T("The Substitute Type must be defined|132"));
}
// La relation entre deux types d'équipements doit être unique
CListeObjetsDonnees listeRel = new CListeObjetsDonnees(relation.ContexteDonnee,
typeof(CRelationTypeEquipement_TypeRemplacement));
listeRel.Filtre = new CFiltreData("(" +
"(" +
CRelationTypeEquipement_TypeRemplacement.c_champIdTypeRemplacable + " = @1 AND " +
CRelationTypeEquipement_TypeRemplacement.c_champIdTypeRemplacant + " = @2) OR (" +
CRelationTypeEquipement_TypeRemplacement.c_champIdTypeRemplacable + " = @2 AND " +
CRelationTypeEquipement_TypeRemplacement.c_champIdTypeRemplacant + " = @1)) and " +
CRelationTypeEquipement_TypeRemplacement.c_champId + "<>@3",
relation.TypeRemplacable.Id,
relation.TypeRemplacant.Id,
relation.Id);
listeRel.InterditLectureInDB = true;
if (listeRel.Count != 0)
{
result.EmpileErreur(I.T("This relation already exists in the Relation List|133"));
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// <summary>
/// Vérifie qu'une dataRow vérifie ses règles d'unicité
/// </summary>
/// <param name="row"></param>
/// <returns></returns>
private static CResultAErreur VerifieUnicite(DataRow row, List <CInfoFiltreUnique> listeFiltres, Type typeObjet)
{
CResultAErreur result = CResultAErreur.True;
if (row.RowState == DataRowState.Detached ||
row.RowState == DataRowState.Deleted)
{
return(result);
}
foreach (CInfoFiltreUnique info in listeFiltres)
{
CFiltreData filtre = new CFiltreData(info.Filtre.Filtre);
filtre.Parametres.Add(row[row.Table.PrimaryKey[0]]);
int nIndex = 2;
List <string> lstValeurs = new List <String>();
foreach (string strChamp in info.Attribute.Champs)
{
if (!row.Table.Columns.Contains(strChamp))
{
return(result);
}
if (row[strChamp] == DBNull.Value)
{
filtre.Filtre.Replace("=@" + nIndex, " is null");
filtre.Parametres.Add("");
}
else
{
filtre.Parametres.Add(row[strChamp]);
}
lstValeurs.Add(row[strChamp].ToString());
}
CListeObjetsDonnees liste = new CListeObjetsDonnees((CContexteDonnee)row.Table.DataSet, typeObjet);
liste.Filtre = filtre;
if (liste.Count > 0)
{
result.EmpileErreur(I.TT(typeObjet, info.Attribute.Message, lstValeurs.ToArray()));
return(result);
}
}
return(result);
}
/// <summary>
/// Force l'appartenance des groupes comme définit dans la base AD
/// </summary>
/// <returns></returns>
public CResultAErreur SynchroniseGroupesAD( )
{
CResultAErreur result = CResultAErreur.True;
CAdGroup[] adGroups = CAdGroup.GetGroups(IdSession);
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
contexte.BeginModeDeconnecte();
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CGroupeActeur));
CFiltreData filtre = new CFiltreData(CGroupeActeur.c_champGroupeWindowsCorrespondant + "<>@1", "");
liste.Filtre = filtre;
if (result)
{
contexte.CommitModifsDeconnecte();
}
}
return(result);
}
//-------------------------------------------------------------
private void CFormTestSpvGraph_Load(object sender, EventArgs e)
{
m_arbre.Nodes.Clear();
CListeObjetsDonnees lst = m_spvSchema.ElementsDeGraphe;
CSpvElementDeGraphe elt = new CSpvElementDeGraphe(m_spvSchema.ContexteDonnee);
if (!elt.ReadIfExists(new CFiltreData(CSpvElementDeGraphe.c_champSensReseau + "=@1 and " +
CSpvElementDeGraphe.c_champParentId + " is null",
(int)ESensAllerRetourLienReseau.Forward)))
{
return;
}
elt = elt.GetElementDuBonType();
if (elt != null)
{
TreeNode node = CreateNode(elt);
m_arbre.Nodes.Add(node);
}
}
//-------------------------------------------------------------------------
private void InitTypesEos()
{
m_arbreEO.Nodes.Clear();
Hashtable tableCorrespondances = new Hashtable();
foreach (COptionCorrespondanceEO option in Profil.OptionsPropres)
{
tableCorrespondances[option.TypeEO] = option.ModeComparaison;
}
CListeObjetsDonnees listeTypesEo = new CListeObjetsDonnees(Profil.ContexteDonnee, typeof(CTypeEntiteOrganisationnelle));
listeTypesEo.Filtre = new CFiltreData(CTypeEntiteOrganisationnelle.c_champIdParent + " is null");
foreach (CTypeEntiteOrganisationnelle tp in listeTypesEo)
{
TreeNode node = new TreeNode();
FillItemTypeEO(node, tp, tableCorrespondances);
m_arbreEO.Nodes.Add(node);
}
}
//--------------------------------------------------------------------
public void Init(CBesoin besoin)
{
CurrentItemIndex = null;
Items = new CCustomizableListItem[0];
m_besoin = besoin;
if (m_besoin != null)
{
List <CCustomizableListItem> items = new List <CCustomizableListItem>();
CListeObjetsDonnees lstQuantites = m_besoin.Quantites;
lstQuantites.Filtre = new CFiltreData(CBesoinQuantite.c_champIdQteParente + " is null");
foreach (CBesoinQuantite q in lstQuantites)
{
AddItemQuantiteEtFils(null, q, items);
}
Items = items.ToArray();
}
Refresh();
}
//-------------------------------------------------------------------
private static void AlloueCode(CObjetHierarchique objet, ref int nLastCodeAlloue)
{
CFiltreData filtre = null;
if (objet.ObjetParent != null)
{
filtre = new CFiltreData(objet.ChampIdParent + "=@1",
objet.ObjetParent.Id);
}
else
{
filtre = new CFiltreData(objet.ChampIdParent + " is null and " +
objet.ChampCodeSystemePartiel + ">@1", GetCle(nLastCodeAlloue, objet.NbCarsParNiveau));
}
CListeObjetsDonnees listeSoeurs = new CListeObjetsDonnees(objet.ContexteDonnee, objet.GetType(), filtre);
listeSoeurs.AssureLectureFaite();
listeSoeurs.InterditLectureInDB = true;
Hashtable tableCodesUtilises = new Hashtable();
foreach (CObjetHierarchique obj in listeSoeurs)
{
tableCodesUtilises[obj.CodeSystemePartiel] = true;
}
//Cherche le prochain numéro libre
int nCpt = nLastCodeAlloue;
string strCle = "";
do
{
nCpt++;
strCle = GetCle(nCpt, objet.NbCarsParNiveau);
/*listeSoeurs.Filtre = new CFiltreData(objet.ChampCodeSystemePartiel + "=@1",
* strCle);*/
}while (tableCodesUtilises.ContainsKey(strCle));
nLastCodeAlloue = nCpt;
objet.ChangeCodePartiel(strCle);
}
/////////////////////////////////////////////////////////////////
public override sealed CResultAErreur Delete(bool bDansContexteCourant)
{
CResultAErreur result = CResultAErreur.True;
if (Row.RowState == DataRowState.Deleted)
{
return(CResultAErreur.True);
}
if (Row.RowState == DataRowState.Detached)
{
result.EmpileErreur(I.T("Cannot delete a detached object|191"));
return(result);
}
CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonnee, GetType(), false);
liste.Filtre = new CFiltreData(GetChampId() + "=@1", Id);
liste.Filtre.IgnorerVersionDeContexte = true;
return(Delete(liste, bDansContexteCourant));
}
