public CCamusatQowisioData(CContexteDonnee context) : base(context) { }
//------------------------------------------------------------------- public CRelationGroupeActeur_ChampCustom(CContexteDonnee ctx) : base(ctx) { }
/// ////////////////////////////////////////////////// public override CResultAErreur GetComposantFiltreData(CFiltreDynamique filtre, CFiltreData filtreData) { CResultAErreur result = CResultAErreur.True; //Vérifie que l'expression condition est OK CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(filtre); result = ConditionApplication.Eval(contexteEvaluation); if (!result) { result.EmpileErreur(I.T("Error while evaluation of @1|143", ConditionApplication.GetString())); return(result); } if (result.Data == null || !((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1")) { result.Data = null; return(result); } CComposantFiltreOperateur opPrincipal = null; string strNomChamp = m_champTeste.NomPropriete; if (m_champTeste is CDefinitionProprieteDynamiqueChampCustom) { CDbKey dbKeyChamp = ((CDefinitionProprieteDynamiqueChampCustom)m_champTeste).DbKeyChamp; strNomChamp = m_champTeste.NomPropriete; string strAcces = ""; //Trouve le nom du champ et le chemin d'accès int nPos = strNomChamp.LastIndexOf("."); if (nPos != -1) { strAcces = strNomChamp.Substring(0, nPos + 1); strNomChamp = strNomChamp.Substring(nPos + 1); } strAcces += "RelationsChampsCustom."; CComposantFiltreOperateur operateurIdChamp = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEgal); operateurIdChamp.Parametres.Add(new CComposantFiltreChamp(strAcces + CChampCustom.c_champId, CContexteDonnee.GetNomTableForType(filtre.TypeElements))); operateurIdChamp.Parametres.Add(new CComposantFiltreConstante(dbKeyChamp)); opPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt); opPrincipal.Parametres.Add(operateurIdChamp); Type typeChamp = m_champTeste.TypeDonnee.TypeDotNetNatif; if (typeChamp == typeof(double)) { strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDouble; } else if (typeChamp == typeof(int)) { strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurInt; } else if (typeChamp == typeof(DateTime) || typeChamp == typeof(CDateTimeEx)) { strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDate; } else if (typeChamp == typeof(bool)) { strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurBool; } else { strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurString; } strNomChamp = strAcces + strNomChamp; } CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements)); CComposantFiltreSousFiltre composantSousFiltre = IsNotInTest ? new CComposantFiltreNotInSousFiltre() as CComposantFiltreSousFiltre : new CComposantFiltreInSousFiltre() as CComposantFiltreSousFiltre; m_sousFiltre.ElementAVariablesExterne = filtre; result = m_sousFiltre.GetFiltreData(); CFiltreDataAvance filtreAvance = null; if (result && result.Data is CFiltreDataAvance) { filtreAvance = result.Data as CFiltreDataAvance; } else { return(result); } filtreAvance.RenumerotteParameters(filtreData.Parametres.Count + 1); foreach (object parametre in filtreAvance.Parametres) { filtreData.Parametres.Add(parametre); } CComposantFiltreChamp champDeSousFiltre = new CComposantFiltreChamp(m_champRetourneParSousFiltre.NomPropriete, filtreAvance.TablePrincipale); composantSousFiltre.InitComposant(composantChamp, filtreAvance.TablePrincipale, champDeSousFiltre, filtreAvance); composantSousFiltre.Parametres.Add(composantChamp); composantSousFiltre.Parametres.Add(new CComposantFiltreConstante(CContexteDonnee.GetTypeForTable(filtreAvance.TablePrincipale).ToString())); composantSousFiltre.Parametres.Add(new CComposantFiltreConstante(champDeSousFiltre.ChaineInitiale)); composantSousFiltre.Parametres.Add(new CComposantFiltreConstante(filtreAvance.ComposantPrincipal.GetString())); CComposantFiltre composantRecherche = composantSousFiltre; if (opPrincipal != null) { opPrincipal.Parametres.Add(composantRecherche); composantRecherche = opPrincipal; } result.Data = composantRecherche; return(result); }
/// ////////////////////////////////////////// ///<summary> ///Charge les données de la table qui vont devoir être mise à jour ///à partir des données modifiées dans la table source ///</summary> public CResultAErreur ChargeDonneesAMettreAJour(DataSet donneesSources) { CResultAErreur result = CResultAErreur.True; ArrayList lstTables = CContexteDonnee.GetTablesOrderInsert(donneesSources); foreach (DataTable table in lstTables) { DataTable tableDest = null; //S'assure que la table est bien chargée try { tableDest = GetTableSafe(table.TableName); } catch { //La table n'existe pas } if (tableDest != null && m_mappeurTablesToClass.IsSynchronisable(table.TableName) && table.Rows.Count != 0) { IObjetServeur serveur = CContexteDonnee.GetTableLoader(tableDest.TableName, null, IdSession); string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(tableDest.TableName); if (serveur.CountRecords(strNomTableInDb, new CFiltreData("1=1")) != 0) //Première maj : copie complète { string strColPrim = table.PrimaryKey[0].ColumnName; string strFiltre = ""; foreach (DataRow row in table.Rows) { strFiltre += row[strColPrim].ToString() + ","; } if (strFiltre.Length != 0) { //Supprime la dernière virgule; strFiltre = strFiltre.Substring(0, strFiltre.Length - 1); strFiltre = strColPrim += " in (" + strFiltre + ")"; IObjetServeur loader = GetTableLoader(table.TableName); DataTable tableNew = loader.Read(new CFiltreData(strFiltre)); if (table == null) { result.EmpileErreur(I.T("Error while reading table @1|128", table.TableName)); return(result); } IntegreTable(tableNew, false); } } } } //Charge les éléments à supprimer CContexteDonnee contexteForListe = new CContexteDonnee(IdSession, true, false); DataTable tableSync = donneesSources.Tables[CEntreeLogSynchronisation.c_nomTable]; DataTable tableCopie = CUtilDataSet.AddTableCopie(donneesSources.Tables[CEntreeLogSynchronisation.c_nomTable], contexteForListe); foreach (DataRow row in tableSync.Rows) { tableCopie.ImportRow(row); } CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteForListe, typeof(CEntreeLogSynchronisation)); liste.InterditLectureInDB = true; liste.Filtre = new CFiltreData(CEntreeLogSynchronisation.c_champType + "=@1", (int)CEntreeLogSynchronisation.TypeModifLogSynchro.tDelete); foreach (CEntreeLogSynchronisation entree in liste) { DataTable table = GetTableSafe(entree.TableConcernee); CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)GetNewObjetForTable(table); objet.ReadIfExists(entree.IdElement); } return(result); }
//------------------------------------------------------------------- public CRelationEntiteSnmp_ChampCustom(CContexteDonnee ctx) : base(ctx) { }
/// <summary> /// Retourne les informations de modification pour l'objet demandé /// </summary> /// <param name="row"></param> /// <returns></returns> public CVersionDonneesObjet GetVersionObjetAvecCreation(DataRow row) { lock (typeof(CLockerOptim)) { if (m_lastRow != null && row.Equals(m_lastRow) && m_lastVersionObjet != null) { return(m_lastVersionObjet); } } CListeObjetsDonnees liste = VersionsObjets; Type typeElement = CContexteDonnee.GetTypeForTable(row.Table.TableName); if (typeElement == null || !typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(typeElement)) { return(null); } DataRowVersion versionToReturn = DataRowVersion.Current; if (row.RowState == DataRowState.Deleted) { versionToReturn = DataRowVersion.Original; } int nIdElement = (int)row[row.Table.PrimaryKey[0], versionToReturn]; liste.Filtre = new CFiltreData(CVersionDonneesObjet.c_champTypeElement + "=@1 and " + CVersionDonneesObjet.c_champIdElement + "=@2", typeElement.ToString(), nIdElement); liste.InterditLectureInDB = true; CVersionDonneesObjet valeurDeRetour = null; if (liste.Count != 0) { valeurDeRetour = (CVersionDonneesObjet)liste[0]; } if (valeurDeRetour == null) { CVersionDonneesObjet versionObjet = new CVersionDonneesObjet(ContexteDonnee); versionObjet.CreateNewInCurrentContexte(); versionObjet.StringTypeElement = typeElement.ToString(); versionObjet.IdElement = nIdElement; versionObjet.VersionDonnees = this; switch (row.RowState) { case DataRowState.Added: versionObjet.CodeTypeOperation = (int)CTypeOperationSurObjet.TypeOperation.Ajout; break; case DataRowState.Modified: versionObjet.CodeTypeOperation = (int)CTypeOperationSurObjet.TypeOperation.Modification; break; case DataRowState.Deleted: versionObjet.CodeTypeOperation = (int)CTypeOperationSurObjet.TypeOperation.Suppression; break; case DataRowState.Unchanged: versionObjet.CodeTypeOperation = (int)CTypeOperationSurObjet.TypeOperation.Aucune; break; } valeurDeRetour = versionObjet; } lock (typeof(CLockerOptim)) { m_lastVersionObjet = valeurDeRetour; m_lastRow = row; } return(valeurDeRetour); }
/// ////////////////////////////////////////////////// public override void AfterRead() { base.AfterRead(); CContexteDonnee.ChangeRowSansDetectionModification(Row.Row, c_champCacheFormule, DBNull.Value); }
private void m_arbreConsultation_DragDrop(object sender, DragEventArgs e) { if (DragDataHasDocGed(e.Data)) { using (CContexteDonnee ctx = CSc2iWin32DataClient.ContexteCourant.GetContexteEdition()) { bool bAddElement = (e.KeyState & 8) == 8; TreeViewHitTestInfo info = m_arbreConsultation.HitTest(m_arbreConsultation.PointToClient(new Point(e.X, e.Y))); TreeNode node = info.Node; if (info != null && info.Node != null && info.Node.Tag is CNodeConsultationHierarchique && ((CNodeConsultationHierarchique)info.Node.Tag).ObjetLie is CObjetDonneeAIdNumerique) { CObjetDonneeAIdNumerique objetAId = ((CNodeConsultationHierarchique)info.Node.Tag).ObjetLie as CObjetDonneeAIdNumerique; foreach (CReferenceObjetDonnee refDoc in (CReferenceObjetDonnee[])e.Data.GetData(typeof(CReferenceObjetDonnee[]))) { CDocumentGED doc = refDoc.GetObjet(ctx) as CDocumentGED; if (doc != null) { if (!bAddElement)//Supprime les anciennes catégories { StringBuilder bl = new StringBuilder(); foreach (CRelationElementToDocument rel in doc.RelationsElements) { if (rel.ElementLie != null) { bl.Append("-"); bl.Append(rel.ElementLie.DescriptionElement); bl.Append(System.Environment.NewLine); } } if (bl.Length > 0) { if (CFormAlerte.Afficher(I.T("This operation will remove association to \r\n@1 and add an association to @2. Continue ?|20475", bl.ToString(), objetAId.DescriptionElement), EFormAlerteType.Question) == DialogResult.No) { HightlightElementDeArbre(null); e.Effect = DragDropEffects.None; return; } } CListeObjetsDonnees lst = doc.RelationsElements; CObjetDonneeAIdNumerique.Delete(lst, true); } doc.AssocieA(objetAId); } } } CResultAErreur result = ctx.CommitEdit(); if (!result) { CFormAlerte.Afficher(result.Erreur); } else { InitPanelList(m_elementSelectionne); } } } HightlightElementDeArbre(null); }
//--------------------------------------------------- public void InitChamps( CFolderConsultationHierarchique folderRoot, CContexteDonnee contexteDonnee) { InitChamps(folderRoot, contexteDonnee, false); }
//------------------------------------------------------------------- public CRelationTypeCaracteristiqueEntite_ChampCustom(CContexteDonnee ctx) : base(ctx) { }
/// ///////////////////////////////////////////// public CFractionIntervention(CContexteDonnee contexte) : base(contexte) { }
/////////////////////////////////////////////////////////////// public CSpvMibobj(CContexteDonnee ctx) : base(ctx) { }
/// /////////////////////////////////////////////////////////// public object GetValue(object objetInterroge, CDefinitionProprieteDynamique propriete) { //Récupère l'objet à interroger string strProp = propriete.NomPropriete; object valeur = m_cache.GetValeurCache(objetInterroge, strProp); if (valeur != null) { return(valeur); } CContexteDonnee contexteForObjets = ContexteDonneeCache; if (objetInterroge is IObjetAContexteDonnee) { contexteForObjets = ((IObjetAContexteDonnee)objetInterroge).ContexteDonnee; } if (contexteForObjets == null) { contexteForObjets = ContexteDonneeCache; } object objetFinal = objetInterroge; int nPos = strProp.LastIndexOf('.'); if (nPos > 0 && !(propriete is CDefinitionProprieteDynamiqueDonneeCumulee) && !(propriete is CDefinitionProprieteDynamiqueChampCustom) && !(propriete is CDefinitionProprieteDynamiqueChampCustomFils) && !(propriete is CDefinitionProprieteDynamiqueFormule)) { string strPropDebut; strPropDebut = strProp.Substring(0, nPos); strProp = strProp.Substring(nPos + 1); objetFinal = m_cache.GetValeurCache(objetInterroge, strPropDebut); if (objetFinal == null) { objetFinal = GetValue(objetInterroge, strPropDebut); /*object objetAInterroger = null; * MemberInfo membre = null; * CInterpreteurTexteProptVariete.GetObjetFinalEtMemberInfo ( objetInterroge, strPropDebut, ref objetAInterroger, ref membre ); * if ( membre != null ) * { * objetFinal = CInterpreteurTextePropriete.GetValue ( objetAInterroger, membre ); * } * else * { * //On n'a pas trouvé le membre, il s'agit donc d'autre chose, il faut donc décomposer * //Le champ * }*/ //objetFinal = CInterpreteurTextePropriete.GetValue(objetInterroge, strPropDebut); m_cache.StockeValeurEnCache(objetInterroge, strPropDebut, objetFinal); } if (objetFinal == null) { return(null); } valeur = m_cache.GetValeurCache(objetFinal, strProp); if (valeur != null) { return(valeur); } } if (propriete is CDefinitionProprieteDynamiqueChampCustom) { if (!(objetFinal is IElementAChamps)) { valeur = null; } else { //TESTDBKEYTODO qui ne peut pas marche valeur = ((IElementAChamps)objetFinal).GetValeurChamp(((CDefinitionProprieteDynamiqueChampCustom)propriete).DbKeyChamp.InternalIdNumeriqueANeJamaisUtiliserSaufDansCDbKeyAddOn.Value, System.Data.DataRowVersion.Default); /*if (m_bValeurAfficheeDeChampsCustom) * { * CChampCustom champ = new CChampCustom(ContexteDonneeCache); * if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCustom)propriete).IdChamp)) * { * object valTmp = champ.DisplayFromValue(valeur); * if (valTmp != null) * valeur = valTmp; * } * }*/ } } else if (propriete is CDefinitionProprieteDynamiqueChampCustomFils && objetInterroge is CObjetDonneeAIdNumerique) { CChampCustom champ = new CChampCustom(ContexteDonneeCache); if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCustomFils)propriete).KeyChamp)) { Type tp = champ.Role.TypeAssocie; try { IObjetDonneeAChamps elt = (IObjetDonneeAChamps)Activator.CreateInstance(tp, new object[] { contexteForObjets }); CRelationElementAChamp_ChampCustom rel = elt.GetNewRelationToChamp(); CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteForObjets, tp); liste.Filtre = new CFiltreDataAvance( elt.GetNomTable(), rel.GetNomTable() + "." + CRelationElementAChamp_ChampCustom.c_champValeurString + "=@1 and " + rel.GetNomTable() + "." + CRelationElementAChamp_ChampCustom.c_champValeurInt + "=@2 and " + rel.GetNomTable() + "." + CChampCustom.c_champId + "=@3", objetInterroge.GetType().ToString(), ((CObjetDonneeAIdNumerique)objetInterroge).Id, champ.Id); valeur = liste.ToArray(tp); } catch { valeur = null; } } } else if (propriete is CDefinitionProprieteDynamiqueListeEntites) { CListeEntites liste = new CListeEntites(contexteForObjets); try { if (liste.ReadIfExists(((CDefinitionProprieteDynamiqueListeEntites)propriete).DbKeyListeEntite)) { CListeObjetsDonnees resultListe = liste.GetElementsLiesFor(objetInterroge); if (resultListe != null) { valeur = resultListe.ToArray(liste.TypeElements); } } } catch { valeur = null; } } else if (propriete is CDefinitionProprieteDynamiqueRelationTypeId) { if (!(objetFinal is CObjetDonneeAIdNumerique)) { valeur = null; } else { CDefinitionProprieteDynamiqueRelationTypeId defRel = (CDefinitionProprieteDynamiqueRelationTypeId)propriete; return(((CObjetDonneeAIdNumerique)objetFinal).GetDependancesRelationTypeId( defRel.Relation.TableFille, defRel.Relation.ChampType, defRel.Relation.ChampId, false)); } } else if (propriete is CDefinitionProprieteDynamiqueDonneeCumulee) { if (!(objetFinal is CObjetDonneeAIdNumerique)) { valeur = null; } else { CDefinitionProprieteDynamiqueDonneeCumulee defType = (CDefinitionProprieteDynamiqueDonneeCumulee)propriete; CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)objetFinal; CTypeDonneeCumulee type = new CTypeDonneeCumulee(contexteForObjets); if (type.ReadIfExists(defType.DbKeyTypeDonnee)) { valeur = type.GetDonneesCumuleesForObjet(objet); } else { valeur = null; } } } else if (propriete is CDefinitionProprieteDynamiqueChampCalcule) { CChampCalcule champ = new CChampCalcule(contexteForObjets); if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCalcule)propriete).DbKeyChamp)) { valeur = champ.Calcule(objetFinal, new CFournisseurPropDynStd(true)); } else { valeur = null; } } else if (propriete is CDefinitionProprieteDynamiqueFormule) { CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(objetInterroge); contexte.AttacheObjet(typeof(CContexteDonnee), contexteForObjets); CResultAErreur result = ((CDefinitionProprieteDynamiqueFormule)propriete).Formule.Eval(contexte); if (result) { return(result.Data); } } else if (propriete is CDefinitionProprieteDynamiqueVariableDynamique && objetFinal is IElementAVariables) { valeur = ((IElementAVariables)objetFinal).GetValeurChamp(((CDefinitionProprieteDynamiqueVariableDynamique)propriete).IdChamp); } else { valeur = CInterpreteurTextePropriete.GetValue(objetFinal, strProp); } m_cache.StockeValeurEnCache(objetInterroge, propriete.Nom, valeur); if (objetFinal != objetInterroge) { m_cache.StockeValeurEnCache(objetFinal, strProp, valeur); } return(valeur); }
//////////////////////////////////////////////////////// public string GetStringExpression(IExpression expression, CFiltreData filtre) { string strRetour = ""; if (expression is CComposantFiltre) { expression = ((CComposantFiltre)expression).GetComposantFiltreFinal(filtre); } if (expression is CComposantFiltreChamp) { CComposantFiltreChamp champ = (CComposantFiltreChamp)expression; if (champ.Alias != "") { strRetour += champ.Alias + "."; } strRetour += champ.NomChamp; } else if (expression is CComposantFiltreVariable) { strRetour = ((CComposantFiltreVariable)expression).GetString(); } else if (expression is CComposantFiltreConstante) { CComposantFiltreConstante constante = (CComposantFiltreConstante)expression; strRetour = CConvertisseurObjetToSqlServeur.ConvertToSql(constante.Valeur); } else if (expression is CComposantFiltreHasNo) { strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre); strRetour += " is null"; } else if (expression is CComposantFiltreHas) { strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre); strRetour += " is not null"; } else if (expression is CComposantFiltreListe) { CComposantFiltreListe liste = (CComposantFiltreListe)expression; strRetour = ""; foreach (IExpression expInListe in liste.Liste) { strRetour += GetStringExpression(expInListe, filtre) + ","; } if (strRetour.Length > 0) { strRetour = strRetour.Substring(0, strRetour.Length - 1); } strRetour = "(" + strRetour + ")"; } else if (expression is CComposantFiltreSousFiltre && m_connexion != null) { CComposantFiltreSousFiltre compo = (CComposantFiltreSousFiltre)expression; CResultAErreur result = compo.InterpreteParametres(); if (result) { string strWhere = ""; string strJoin = ""; string strPrefixFrom = ""; bool bDistinct = false; compo.Filtre.Parametres.Clear(); compo.Filtre.AddChampAAjouterAArbreTable(compo.ChampSousFiltre); foreach (object parametre in filtre.Parametres) { compo.Filtre.Parametres.Add(parametre); } CComposantFiltreOperateur compoEt = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt); compoEt.Parametres.Add(compo.Filtre.ComposantPrincipal); CComposantFiltreHas compoNotNull = new CComposantFiltreHas(); compoNotNull.Parametres.Add(compo.ChampSousFiltre); compoEt.Parametres.Add(compoNotNull); compo.Filtre.ComposantPrincipal = compoEt; IEnumerable <C2iDbDatabaseConnexion.CParametreRequeteDatabase> parametres = null; result = m_connexion.PrepareRequeteFromFiltre( compo.Filtre, ref strWhere, ref strJoin, ref bDistinct, ref strPrefixFrom, ref parametres); if (result) { strRetour += " "; if (compo.ChampTeste.Alias != "") { strRetour += compo.ChampTeste.Alias + "."; } strRetour += compo.ChampTeste.NomChamp; if (compo is CComposantFiltreInSousFiltre) { strRetour += " in ("; } else { strRetour += " not in ("; } string strSelect = "select "; if (compo.ChampSousFiltre.Alias != "") { strSelect += compo.ChampSousFiltre.Alias + "."; } strSelect += compo.ChampSousFiltre.NomChamp; strSelect += " from " + CContexteDonnee.GetNomTableInDbForNomTable(compo.TableSousFiltre); strRetour += m_connexion.GetSql(strSelect, strPrefixFrom, strJoin, strWhere); strRetour += ")"; } } } else if (expression is CComposantFiltreOperateur) { COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur; string strTexteOperateur = operateur.Texte; if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT") { strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3); } if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains) { strTexteOperateur = "like"; } if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout) { strTexteOperateur = "not like"; } if (operateur.Niveau > 0 && operateur.Niveau != 4) { string str1, str2, str3; str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre); str2 = strTexteOperateur; str3 = GetStringExpression((IExpression)expression.Parametres[1], filtre); string[] valeurs = new string[] { str3 }; if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains || operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout) { str3 = "'%'+" + str3 + "+'%'"; } if (operateur.Niveau >= 4) { str1 = "(" + str1 + ")"; str3 = "(" + str3 + ")"; } bool bChercheVide = false; if (strTexteOperateur.ToUpper() == "LIKE") { bChercheVide = str3 == "%%"; if (!bChercheVide && str3.Contains("@")) { try { int nParam = Int32.Parse(str3.Substring("@PARAM".Length)); if (filtre.Parametres[nParam - 1].ToString() == "%%") { bChercheVide = true; } } catch { } } } if (bChercheVide) { strRetour += str3 + "=" + str3; } else { strRetour = str1 + " " + str2 + " " + str3; if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurLike || operateur.Id == CComposantFiltreOperateur.c_IdOperateurNotLike) { strRetour += " ESCAPE '\\'"; } } } else { strRetour = strTexteOperateur + "("; foreach (IExpression exp in expression.Parametres) { strRetour += GetStringExpression(exp, filtre) + ","; } if (expression.Parametres.Count > 0) { strRetour = strRetour.Substring(0, strRetour.Length - 1); } strRetour += ")"; } } return(strRetour); }
//------------------------------------- /// <summary> /// Retourne tous les fils qui étaient affecté à l'objet à l'époque /// </summary> /// <param name="objet"></param> /// <param name="relationFille"></param> /// <returns></returns> public int[] GetIdsChildsHistoriques(CObjetDonneeAIdNumerique objet, CInfoRelation relationFille) { Type tpFils = CContexteDonnee.GetTypeForTable(relationFille.TableFille); if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpFils)) { return(new int[0]); } CChampPourVersionInDb champFille = new CChampPourVersionInDb(relationFille.ChampsFille[0], ""); //Recherche toutes les modifications de la propriété fille CListeObjetsDonnees listeModifsFilles = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CVersionDonneesObjetOperation)); listeModifsFilles.Filtre = new CFiltreDataAvance( CVersionDonneesObjetOperation.c_nomTable, CVersionDonneesObjetOperation.c_champChamp + "=@1 and " + CVersionDonneesObjetOperation.c_champTypeChamp + "=@2 and " + CVersionDonneesObjet.c_nomTable + "." + CVersionDonneesObjet.c_champTypeElement + "=@3 and " + CVersionDonneesObjet.c_nomTable + "." + CVersionDonnees.c_nomTable + "." + CVersionDonnees.c_champTypeVersion + "=@4 and " + CVersionDonneesObjet.c_nomTable + "." + CVersionDonnees.c_champId + ">=@5", champFille.FieldKey, champFille.TypeChampString, tpFils.ToString(), (int)CTypeVersion.TypeVersion.Archive, Id); listeModifsFilles.Tri = CVersionDonneesObjetOperation.c_champId + " desc"; listeModifsFilles.ReadDependances("VersionObjet"); ArrayList lstFils = new ArrayList(); //Remplit la liste des fils avec les fils actuels //Récupère la liste de tous les fils actuels //et supprimés depuis. En effet, un element supprimé depuis cette version mais qui est //toujours lié à l'objet était donc lié à l'objet à l'époque C2iRequeteAvancee requete = new C2iRequeteAvancee(-1); requete.TableInterrogee = relationFille.TableFille; C2iChampDeRequete champDeRequete = new C2iChampDeRequete("ID", new CSourceDeChampDeRequete(objet.ContexteDonnee.GetTableSafe(relationFille.TableFille).PrimaryKey[0].ColumnName), typeof(int), OperationsAgregation.None, true); requete.ListeChamps.Add(champDeRequete); CFiltreData filtre = new CFiltreData(relationFille.ChampsFille[0] + "=@1 and (" + CSc2iDataConst.c_champIdVersion + " is null or " + CSc2iDataConst.c_champIdVersion + ">=@2)", objet.Id, Id); filtre.IgnorerVersionDeContexte = true; requete.FiltreAAppliquer = filtre; CResultAErreur result = requete.ExecuteRequete(objet.ContexteDonnee.IdSession); if (result) { foreach (DataRow row in ((DataTable)result.Data).Rows) { lstFils.Add(row[0]); } } foreach (CVersionDonneesObjetOperation data in listeModifsFilles) { if (data.GetValeur() is int && (int)data.GetValeur() == objet.Id) { if (!lstFils.Contains(data.VersionObjet.IdElement)) { lstFils.Add(data.VersionObjet.IdElement); } } else { lstFils.Remove(data.VersionObjet.IdElement); } } //Toutes les entités créées après la version ont également été ajoutées, //Donc n'y étaient pas if (lstFils.Count > 0) { StringBuilder builder = new StringBuilder(); foreach (int nId in lstFils) { builder.Append(nId.ToString()); builder.Append(","); } string strIds = builder.ToString(); strIds = strIds.Substring(0, strIds.Length - 1); requete = new C2iRequeteAvancee(-1); requete.TableInterrogee = CVersionDonneesObjet.c_nomTable; requete.FiltreAAppliquer = new CFiltreData( CVersionDonneesObjet.c_champIdElement + " in (" + strIds + ") and " + CVersionDonneesObjet.c_champTypeElement + "=@1 and " + CVersionDonneesObjet.c_champTypeOperation + "=@2 and " + CVersionDonnees.c_champId + ">=@3", tpFils.ToString(), CTypeOperationSurObjet.TypeOperation.Ajout, Id); requete.FiltreAAppliquer.IgnorerVersionDeContexte = true; requete.ListeChamps.Add(new C2iChampDeRequete("Id", new CSourceDeChampDeRequete(CVersionDonneesObjet.c_champIdElement), typeof(int), OperationsAgregation.None, true)); result = requete.ExecuteRequete(ContexteDonnee.IdSession); if (result) { foreach (DataRow row in ((DataTable)result.Data).Rows) { lstFils.Remove(row[0]); } } } return((int[])lstFils.ToArray(typeof(int))); }
//----------------------------------------------------------------------------------------------- private static void SetModeCalculProjet(CContexteDonnee contexte) { contexte.ExtendedProperties[c_ModeCalculProjetsAsynchrone] = true; }
public CVersionDonnees(CContexteDonnee contexte) : base(contexte) { }
/// ////////////////////////////////////////////////// ///Lance le calcul public static void DoCalc(CElementsProjetARecalculer lstElements) { CResultAErreur result = CResultAErreur.True; CDbKey keyUser = null; //Attend la fin des transactions en cours pour la session principale IDatabaseConnexion cnx = null; do { CSessionClient session = CSessionClient.GetSessionForIdSession(lstElements.IdSession); if (session != null && session.IsConnected) { IInfoUtilisateur info = session.GetInfoUtilisateur(); //TESTDBKEYOK if (info != null) { keyUser = info.KeyUtilisateur; } try { cnx = CSc2iDataServer.GetInstance().GetDatabaseConnexion(lstElements.IdSession, typeof(CProjet)); } catch //En cas d'erreur, c'est probablement que la session a été fermée, du coup, on peut y aller ! { cnx = null; } System.Threading.Thread.Sleep(50); } else { cnx = null; } }while (cnx != null && cnx.IsInTrans()); lock (typeof(CLockerStartEtape))//S'assure que deux étapes ne démarrent pas en même temps ! { CAuthentificationSessionProcess auth = new CAuthentificationSessionProcess(); using (CSessionClient sousSession = CSessionClient.CreateInstance()) { try { sousSession.OpenSession(auth, "Projet asynchronous calc ", ETypeApplicationCliente.Process); if (keyUser != null) { sousSession.ChangeUtilisateur(keyUser); } using (CContexteDonnee ctx = new CContexteDonnee(sousSession.IdSession, true, true)) { SetModeCalculProjet(ctx); foreach (int nIdProjet in lstElements.IdsProjets) { CProjet projet = new CProjet(ctx); if (projet.ReadIfExists(nIdProjet)) { projet.RecalculateDates(false); } } foreach (int nIdMetaProjet in lstElements.IdsMetaProjets) { CMetaProjet meta = new CMetaProjet(ctx); if (meta.ReadIfExists(nIdMetaProjet)) { meta.UpdateDateDebutPlanifieeFromChilds(false); meta.UpdateDateFinPlanifieeFromChilds(false); meta.UpdateDateDebutReelleFromChilds(false); meta.UpdateDateFinReelleFromChilds(false); meta.CalcProgress(false); } } result = ctx.SaveAll(false); } } catch (Exception e) { } finally { sousSession.CloseSession(); } } } }
public static CResultAErreur Purger(DateTime dateLimite, int nIdSession) { IVersionDonneesServeur serveur = (IVersionDonneesServeur)CContexteDonnee.GetTableLoader(c_nomTable, null, nIdSession); return(serveur.PurgerHistorique(dateLimite)); }
//----------------------------------------------------------------------------------------------- public static bool IsModeCalculProjet(CContexteDonnee contexte) { object val = contexte.ExtendedProperties[c_ModeCalculProjetsAsynchrone]; return(val is bool && (bool)val == true); }
/// <summary> /// ////////////////////////////////////////////////// /// </summary> /// <param name="ctx"></param> public CChampCalcule(CContexteDonnee ctx) : base(ctx) { }
//---------------------------------------------------------------------------------- public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte) { CResultAErreur result = base.TraitementAvantSauvegarde(contexte); if (!result) { return(result); } DataTable dt = contexte.Tables[CEquipement.c_nomTable]; ArrayList rows = new ArrayList(dt.Rows); CResultAErreur resultloc = CResultAErreur.True; foreach (DataRow row in rows) { if (row.RowState == DataRowState.Modified || row.RowState == DataRowState.Added || row.RowState == DataRowState.Deleted) { CEquipement eqpt = new CEquipement(row); /*if (eqpt.ParametrageCoordonneesApplique == null) * eqpt.Coordonnee = "";*/ CStock stockApres = null; if (row.RowState != DataRowState.Deleted) { stockApres = eqpt.EmplacementStock; } if (row.HasVersion(DataRowVersion.Original)) { DataRowVersion currentVersion = eqpt.VersionToReturn; eqpt.VersionToReturn = DataRowVersion.Original; CTypeEquipement typeAvant = eqpt.TypeEquipement; CStock stockAvant = eqpt.EmplacementStock; eqpt.VersionToReturn = currentVersion; if (stockAvant == stockApres) { return(result); } if (stockAvant != null && stockAvant.IsValide()) { // Descrémente le nombre en stock CRelationTypeEquipement_Stock rel = stockAvant.GetRelationTypeEquipemetStock(typeAvant); if (rel != null && rel.NombreEnStock > 0) { int nbAvant = rel.NombreEnStock; rel.Row[CRelationTypeEquipement_Stock.c_champNombreEnStock] = rel.NombreEnStock - 1; } } } if (stockApres != null && stockApres.IsValide()) { // Incrémente le nombre en stock CRelationTypeEquipement_Stock rel = stockApres.GetRelationTypeEquipemetStock(eqpt.TypeEquipement); if (rel != null) { rel.Row[CRelationTypeEquipement_Stock.c_champNombreEnStock] = rel.NombreEnStock + 1; } } result = SObjetAFilsACoordonneeServeur.TraitementAvantSauvegarde(eqpt); if (!result) { return(result); } } } return(result); }
/////////////////////////////////////////////////////////////// public override CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte) { CResultAErreur result = base.TraitementAvantSauvegarde(contexte); if (!result) { return(result); } DataTable table = contexte.Tables[GetNomTable()]; if (table == null) { return(result); } ArrayList lstRows = new System.Collections.ArrayList(table.Rows); CSpvTypeAccesAlarme spvType; foreach (DataRow row in lstRows) { if (row.RowState == DataRowState.Added || row.RowState == DataRowState.Modified) { spvType = new CSpvTypeAccesAlarme(row); //spvType.CalculeUnicite(); CSpvTypeq spvTypeq = spvType.SpvTypeq; if (spvTypeq != null) { if (row.RowState == DataRowState.Added) { result = spvType.GenAccesAlarmeEquips(); } else { result = spvType.MajAccesAlarmeEquips(); } } /* if (spvType.AlarmeGeree == null) * { * CSpvAlarmGeree spvAlarmGeree = new CSpvAlarmGeree(contexte); * spvAlarmGeree.CreateNewInCurrentContexte(); * spvAlarmGeree.TypeAccesAlarme = spvType; * } * if (spvType.AlarmeGeree != null) * { * spvType.AlarmeGeree.Alarmgeree_Name = spvType.NomAcces; * //spvType.AlarmeGeree.AlarmgereeUnicity = spvType.UniciteAcces; * }*/ CSpvAlarmGeree spvAlarmGeree = spvType.GetAlarmeGereeAvecCreationSuppression(); if (spvAlarmGeree != null) { spvAlarmGeree.Alarmgeree_Name = spvType.NomAcces; } // Calcul de l'unicité //spvType.CalculeUnicite(); } else if (row.RowState == DataRowState.Deleted) { spvType = new CSpvTypeAccesAlarme(row); result = spvType.TraitementDelete(); } } return(result); }
////////////////////////////////////////////////////////////////////////// public CRelationTypeEquipement_Constructeurs(CContexteDonnee contexte) : base(contexte) { }
/// ///////////////////////////////////////////// public CDependanceTicket(CContexteDonnee contexte) : base(contexte) { }
//------------------------------------------------------------------- public CRelationCategorieGED_Formulaire(CContexteDonnee ctx) : base(ctx) { }
/////////////////////////////////////////////////////////////// public CSpvClient(CContexteDonnee ctx) : base(ctx) { }
public void Init(CContexteDonnee contexte) { m_contexte = contexte; FillArbre(); }
/// ///////////////////////////////////////////// public CLigneCommande(CContexteDonnee contexte) : base(contexte) { }
public static CResultAErreurType <CCamusatQowisioData> StaticTraiteDataRowFromCsv(CContexteDonnee contexte, string strCsvRow) { CResultAErreurType <CCamusatQowisioData> result = new CResultAErreurType <CCamusatQowisioData>(); result.Result = true; CCamusatQowisioData newData = new CCamusatQowisioData(contexte); newData.CreateNewInCurrentContexte(); CResultAErreur resTmp = CResultAErreur.True; resTmp = newData.TraiteDataRowFromCsv(strCsvRow); if (!resTmp && newData.IsNew()) { newData.CancelCreate(); } if (!resTmp) { result.Erreur = resTmp.Erreur; } else { result.DataType = newData; } return(result); }