////////////////////////////////////////////////////////
public string GetStringAvance(CFiltreDataAvance filtre)
{
CComposantFiltre composant = filtre.ComposantPrincipal;
if (composant == null)
{
return("");
}
//remplace chaque champ par sa valeur
for (int nParametre = filtre.Parametres.Count; nParametre > 0; nParametre--)
{
if (filtre.Parametres[nParametre - 1] is IList)
{
composant.RemplaceVariableParConstante("@" + nParametre, filtre.Parametres[nParametre - 1]);
filtre.Parametres[nParametre - 1] = "";
//Renomme les variables suivantes (qui sont déjà renommées en @PARAM)
for (int nSuivant = nParametre + 1; nSuivant <= filtre.Parametres.Count; nSuivant++)
{
composant.RenommeVariable("@PARAM" + (nSuivant), "@PARAM" + (nSuivant - 1));
}
filtre.Parametres.RemoveAt(nParametre - 1);
}
else
{
composant.RenommeVariable("@" + nParametre, "@PARAM" + (nParametre));
}
}
return(GetStringExpression(composant, filtre));
}
//-----------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="strQowisioId"></param>
/// <param name="contexte"></param>
/// <returns></returns>
public static CResultAErreur GetEquipementLogiqueFromQowisioId(string strQowisioId, CContexteDonnee contexte)
{
CResultAErreur result = CResultAErreur.True;
CFiltreData filtre = new CFiltreDataAvance(
CEquipementLogique.c_nomTable,
CRelationEquipementLogique_ChampCustom.c_nomTable + "." +
CChampCustom.c_nomTable + "." + CChampCustom.c_champId + " = @1 AND " +
CRelationEquipementLogique_ChampCustom.c_nomTable + "." +
CRelationEquipementLogique_ChampCustom.c_champValeurString + " = @2",
c_nIdChampTimosQowisioId,
strQowisioId);
try
{
CEquipementLogique equipementLogiqueQowisio = new CEquipementLogique(contexte);
if (equipementLogiqueQowisio.ReadIfExists(filtre))
{
result.Data = equipementLogiqueQowisio;
return(result);
}
}
catch (Exception e)
{
C2iEventLog.WriteErreur("Error in GetEquipementLogiqueFromQowisioId : " + e.Message);
result.EmpileErreur(e.Message);
return(result);
}
return(result);
}
//-------------------------------------------------------------------------
public void ShowMenuAjout(Point pt)
{
if (!m_lnkAjouter.Visible)
{
return;
}
CObjetDonneeAIdNumerique element = m_elementsAAgenda[0];
//cherche les entrées qui collent avec des acteurs
CListeObjetsDonnees liste = new CListeObjetsDonnees(element.ContexteDonnee, typeof(CTypeEntreeAgenda));
CFiltreDataAvance filtre = new CFiltreDataAvance(CTypeEntreeAgenda.c_nomTable,
CRelationTypeEntreeAgenda_TypeElementAAgenda.c_nomTable + "." +
CRelationTypeEntreeAgenda_TypeElementAAgenda.c_champTypeElement + "=@1 and " +
CRelationTypeEntreeAgenda_TypeElementAAgenda.c_nomTable + "." +
CRelationTypeEntreeAgenda_TypeElementAAgenda.c_champLienMaitre + "=@2",
element.GetType().ToString(),
true);
liste.Filtre = filtre;
if (liste.Count == 0)
{
CFormAlerte.Afficher(I.T("No Agenda entry type can be applied on this element type|30080"), EFormAlerteType.Exclamation);
return;
}
m_menuAjouterAgenda.MenuItems.Clear();
foreach (CTypeEntreeAgenda typeEntree in liste)
{
CMenuItemATypeEntreeAgenda item = new CMenuItemATypeEntreeAgenda(typeEntree);
item.Text = typeEntree.Libelle;
item.Click += new EventHandler(OnMenuAjouterAgenda);
m_menuAjouterAgenda.MenuItems.Add(item);
}
pt = PointToClient(pt);
m_menuAjouterAgenda.Show(this, pt);
}
//--------------------------------------------------------------
private void FillListe()
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(m_objet.ContexteDonnee, typeof(CVersionDonneesObjet));
CFiltreData filtre = new CFiltreDataAvance(CVersionDonneesObjet.c_nomTable,
CVersionDonnees.c_nomTable + "." +
CVersionDonnees.c_champTypeVersion + "=@1",
(int)CTypeVersion.TypeVersion.Archive);
if (m_bInclureEtiquettes)
{
filtre = CFiltreData.GetOrFiltre(filtre,
new CFiltreDataAvance(
CVersionDonneesObjet.c_nomTable,
CVersionDonnees.c_nomTable + "." +
CVersionDonnees.c_champTypeVersion + "=@1",
(int)CTypeVersion.TypeVersion.Etiquette));
}
if (m_modeFiltre == ModeFiltre.VoirPourElement)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(
CVersionDonneesObjet.c_champIdElement + "=@1 and " +
CVersionDonneesObjet.c_champTypeElement + "=@2",
m_objet.Id,
m_objet.GetType().ToString()));
}
liste.Filtre = filtre;
m_panelListe.InitFromListeObjets(liste,
typeof(CVersionDonneesObjet),
null,
null,
"");
}
private void InitSelectTypeEquipement(
CDonneesActeurFournisseur fournisseur)
{
CFiltreData filtreEquipement = null;
CFiltreData filtreConsommable = null;
if (fournisseur != null)
{
filtreEquipement = new CFiltreDataAvance(CTypeEquipement.c_nomTable,
CRelationTypeEquipement_Fournisseurs.c_nomTable + "." +
CDonneesActeurFournisseur.c_champId + "=@1", fournisseur.Id);
filtreConsommable = new CFiltreDataAvance(CTypeConsommable.c_nomTable,
CConditionnementConsommable.c_nomTable + "." +
CDonneesActeurFournisseur.c_champId + "=@1",
fournisseur.Id);
}
m_selectTypeEquipement.InitMultiple(
new CConfigTextBoxFiltreRapide[] {
new CConfigTextBoxFiltreRapide(
typeof(CTypeEquipement),
filtreEquipement,
"Libelle"),
new CConfigTextBoxFiltreRapide(
typeof(CTypeConsommable),
filtreConsommable,
"Libelle")
},
fournisseur != m_lastFournisseurFiltre);
m_lastFournisseurFiltre = fournisseur;
}
//------------------------------------------------------------------------------------------------
public CListeObjetsDonnees GetToutesLesRessourcesLevant(CFiltreDataAvance filtreDeBaseAAppliquer)
{
try
{
int[] listeIds = ((IContrainteServeur)GetLoader()).GetIdsRessourcesLevant(this.Id, filtreDeBaseAAppliquer);
if (listeIds.Length == 0)
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonnee, typeof(CRessourceMaterielle));
liste.Filtre = new CFiltreDataImpossible();
return(liste);
}
string strIds = "";
foreach (int nId in listeIds)
{
strIds += nId + ",";
}
strIds = strIds.Substring(0, strIds.Length - 1);
CFiltreData filtre = new CFiltreData(CRessourceMaterielle.c_champId + " in (" + strIds + ")");
CListeObjetsDonnees lst = new CListeObjetsDonnees(ContexteDonnee, typeof(CRessourceMaterielle), filtre);
return(lst);
}
catch
{
return(new CListeObjetsDonnees(ContexteDonnee, typeof(CRessourceMaterielle), new CFiltreDataImpossible()));
}
}
public void Init(CConditionnementConsommable conditionnement)
{
if (conditionnement == null)
{
return;
}
m_conditionnement = conditionnement;
m_txtReference.Text = conditionnement.Reference;
m_numNombreUnite.IntValue = conditionnement.NombreUnites;
m_lblDynamicUnit.Text = conditionnement.TypeConsommable.UniteString;
CFiltreData filtre = new CFiltreDataAvance(
CActeur.c_nomTable,
"Has(" + CDonneesActeurFournisseur.c_nomTable + "." +
CDonneesActeurFournisseur.c_champId + ")");
m_selectFournisseur.InitAvecFiltreDeBase <CActeur>(
"Nom",
filtre,
true);
if (m_conditionnement.Fournisseur != null)
{
m_selectFournisseur.ElementSelectionne = conditionnement.Fournisseur.Acteur;
}
}
public override CResultAErreur VerifieDonnees(bool bAuMomentDeLaSauvegarde)
{
CResultAErreur result = CResultAErreur.True;
foreach (CRelationRoleActeur_GroupeActeur relRole in RelationsRoles)
{
if (relRole.IsNew())
{
CRoleActeur role = (CRoleActeur)relRole.RoleActeur;
CStructureTable structure = CStructureTable.GetStructure(role.TypeDonneeActeur);
CFiltreData filtre1 = new CFiltreData(
CGroupeActeur.c_champId + " = " + Id);
CFiltreDataAvance filtre2 = new CFiltreDataAvance(
structure.NomTable,
"Acteur.RelationsGroupes." + CGroupeActeur.c_champId + "=" + Id);
CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonnee, typeof(CRelationActeur_GroupeActeur));
liste.Filtre = filtre1;
int nb1 = liste.CountNoLoad;
liste = new CListeObjetsDonnees(ContexteDonnee, relRole.RoleActeur.TypeDonneeActeur);
liste.Filtre = filtre2;
int nb2 = liste.CountNoLoad;
if (nb1 != nb2)
{
result.EmpileErreur(new CErreurValidation(I.T("This Group is related to '@1' Member(s) who does not have this Role. The Role will be applied to all these Members|283", (nb1 - nb2).ToString()), true));
}
}
}
if (!result)
{
return(result);
}
return(base.VerifieDonnees(bAuMomentDeLaSauvegarde));
}
public CResultAErreur MAJ_Champs()
{
CResultAErreur result = CResultAErreur.True;
if (m_preferenceEditee != null && m_gestionnaireModeEdition.ModeEdition)
{
if (m_txtFiltre.Text == "")
{
m_preferenceEditee.FiltrePrefere = null;
}
else
{
string strNomTable = CContexteDonnee.GetNomTableForType(m_preferenceEditee.TypeObjets);
result = CAnalyseurSyntaxiqueFiltre.AnalyseFormule(m_txtFiltre.Text, strNomTable);
if (!result)
{
return(result);
}
CFiltreDataAvance filtre = new CFiltreDataAvance(strNomTable, "");
filtre.ComposantPrincipal = result.Data as CComposantFiltre;
m_panelParametres.AffecteToFiltre(filtre);
m_preferenceEditee.FiltrePrefere = filtre;
}
}
return(result);
}
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
try
{
C2iExpression[] parametresFiltre = new C2iExpression[Parametres.Count - 2];
for (int nIndex = 2; nIndex < Parametres.Count; nIndex++)
{
parametresFiltre[nIndex - 2] = Parametres2i[nIndex];
}
result = GetFiltre(ctx, Parametres2i[0], Parametres2i[1], parametresFiltre);
if (!result)
{
return(result);
}
if (!(ctx.ObjetSource is CObjetDonnee))
{
result.EmpileErreur(I.T("SelectSql cannot be applied here|229"));
return(result);
}
CFiltreDataAvance filtre = (CFiltreDataAvance)result.Data;
CListeObjetsDonnees liste = new CListeObjetsDonnees(((CObjetDonnee)ctx.ObjetSource).ContexteDonnee,
CContexteDonnee.GetTypeForTable(filtre.TablePrincipale));
liste.Filtre = filtre;
result.Data = liste;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in SelectSql|228"));
}
return(result);
}
//------------------------------------------------------------------------------------
public CFiltreDataAvance GetFiltreForRechercheRessourcesSurAttributs()
{
//Crée le filtre sur les types de ressource qui lèvent le type de contrainte
CFiltreDataAvance filtreFinal = new CFiltreDataAvance(
CRessourceMaterielle.c_nomTable,
CTypeRessource.c_nomTable + "." +
CRelationTypeContrainte_TypeRessource.c_nomTable + "." +
CTypeContrainte.c_champId + "=@1",
TypeContrainte.Id);
CFiltreData filtreAttributs = GetFiltreSurAttributsRessource();
if (filtreAttributs != null && !(filtreAttributs is CFiltreDataAvance))
{
filtreAttributs = CFiltreDataAvance.ConvertFiltreToFiltreAvance(CAttributRessource.c_nomTable, filtreAttributs);
}
if (filtreAttributs != null)
{
CFiltreDataAvance filtreAv = (CFiltreDataAvance)filtreAttributs;
filtreAv.ChangeTableDeBase(CRessourceMaterielle.c_nomTable, CAttributRessource.c_nomTable);
}
filtreFinal = (CFiltreDataAvance)CFiltreData.GetAndFiltre(filtreAttributs, filtreFinal);
return(filtreFinal);
}
//-------------------------------------------------------------------
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);
}
//-------------------------------------------------------------------------
protected override CResultAErreur MyInitChamps()
{
CResultAErreur result = base.MyInitChamps();
AffecterTitre(I.T("Workflow @1|20622", Workflow.Libelle));
m_panelStart.Visible = !Workflow.IsRunning || Workflow.Etapes.Count == 0;
CFiltreData filtre =
new CFiltreDataAvance(
CActeur.c_nomTable,
"HAs(" + CDonneesActeurUtilisateur.c_nomTable + "." + CDonneesActeurUtilisateur.c_champId + ")");
m_txtSelectManager.InitAvecFiltreDeBase <CActeur> (
"IdentiteComplete",
filtre,
false);
m_txtSelectTypeWorkflow.Init <CTypeWorkflow>(
"Libelle",
false);
m_txtSelectTypeWorkflow.ElementSelectionne = Workflow.TypeWorkflow;
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(Workflow.ContexteDonnee);
CActeur acteur = null;
//TESTDBKEYOK
if (user.ReadIfExists(Workflow.KeyManager))
{
acteur = user.Acteur;
}
user = CUtilSession.GetUserForSession(Workflow.ContexteDonnee);
if (acteur == null && user != null)
{
acteur = user.Acteur;
}
m_txtSelectManager.ElementSelectionne = acteur;
if (Workflow.Etapes.Count > 0)
{
m_txtSelectTypeWorkflow.LockEdition = true;
m_gestionnaireModeEdition.SetModeEdition(m_txtSelectTypeWorkflow, TypeModeEdition.Autonome);
}
else
{
m_txtSelectTypeWorkflow.LockEdition = !m_gestionnaireModeEdition.ModeEdition;
m_gestionnaireModeEdition.SetModeEdition(m_txtSelectTypeWorkflow, TypeModeEdition.EnableSurEdition);
}
m_panelDessinWorkflow.Enabled = !ModeEdition;
return(result);
}
//-------------------------------------------------------------------------
private void CFormDeplacerRessource_Load(object sender, EventArgs e)
{
sc2i.win32.common.CWin32Traducteur.Translate(this);
m_selectSite.Init <CSite>(
"Libelle",
false);
m_selectActeur.Init <CActeur>(
"IdentiteComplete",
false);
if (m_ressource.TypeRessource != null)
{
m_radioSite.Enabled = m_ressource.TypeRessource.EmplacementSitePossible;
m_selectSite.LockEdition = !m_ressource.TypeRessource.EmplacementSitePossible;
m_radioActeur.Enabled = m_ressource.TypeRessource.EmplacementActeurPossible;
m_selectActeur.LockEdition = !m_ressource.TypeRessource.EmplacementActeurPossible;
}
if (m_ressource.EmplacementSite != null)
{
m_radioSite.Checked = true;
m_selectSite.Focus();
}
else
{
m_radioActeur.Checked = true;
m_selectActeur.Focus();
}
m_selectSite.ElementSelectionne = m_ressource.EmplacementSite;
m_selectActeur.ElementSelectionne = m_ressource.EmplacementActeur;
m_dtMouvement.Value = DateTime.Now;
CFiltreData filtre = new CFiltreDataAvance(CActeur.c_nomTable,
"Has(" + CDonneesActeurUtilisateur.c_nomTable + "." +
CDonneesActeurUtilisateur.c_champId + ")");
m_selectUser.InitAvecFiltreDeBase <CActeur>("IdentiteComplete", filtre, true);
CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(m_ressource.ContexteDonnee);
if (user != null)
{
m_selectUser.ElementSelectionne = user.Acteur;
}
}
//------------------------------------------------------------------------------------------------
public CResultAErreur GetIdsRessourcesLevant(CFiltreDataAvance filtreDeBaseAAppliquer)
{
CResultAErreur result = CResultAErreur.True;
try
{
int[] listeIds = ((IContrainteServeur)GetLoader()).GetIdsRessourcesLevant(this.Id, filtreDeBaseAAppliquer);
result.Data = listeIds;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//----------------------------------------------------------------------------
private void InitDetailTicket()
{
CFiltreData filtre = new CFiltreDataAvance(
CActeur.c_nomTable,
"Has(" + CDonneesActeurClient.c_nomTable + "." +
CDonneesActeurClient.c_champId + ")");
m_txtSelectClient.InitAvecFiltreDeBase <CActeur>(
"Nom",
filtre,
false);
if (m_ticketEdite.Client != null)
{
m_txtSelectClient.ElementSelectionne = m_ticketEdite.Client.Acteur;
}
InitListeContrats(false);
m_cmbxSelectContrat.ElementSelectionne = m_ticketEdite.Contrat;
InitListeTypesTickets(false);
m_cmbxSelectTypeTicket.ElementSelectionne = m_ticketEdite.TypeTicket;
InitSelectUrgenceTicket(false);
m_cmbxSelectUrgence.ElementSelectionne = m_ticketEdite.Urgence;
InitSelectOrigineTicket(false);
m_cmbxSelectOrigineTicket.ElementSelectionne = m_ticketEdite.OrigineTicket;
CListeObjetsDonnees listeClients = new CListeObjetsDonnees(m_ticketEdite.ContexteDonnee, typeof(CDonneesActeurClient));
if (listeClients.Count == 1)
{
CDonneesActeurClient client = (CDonneesActeurClient)listeClients[0];
m_txtSelectClient.ElementSelectionne = client.Acteur;
}
m_panelEditionPhase.Visible = false;
InitPanelChampsCustom();
InitPanelFormulaireSurOrigine();
InitListePhases();
m_controlEditDependances.Init(m_ticketEdite);
m_controlEditionEntitesLiees.Init(m_ticketEdite);
m_panelListeHistorique.InitFromListeObjets(
m_ticketEdite.HistoriquesTicket,
typeof(CHistoriqueTicket),
null,
m_ticketEdite,
"Ticket");
}
public void FillListe()
{
CFiltreDataAvance filtre = new CFiltreDataAvance(CVersionDonnees.c_nomTable,
CVersionDonneesObjet.c_nomTable + "." +
CVersionDonneesObjet.c_champIdElement + "=@1 and " +
CVersionDonneesObjet.c_champTypeElement + "=@2",
m_objet.Id,
m_objet.GetType().ToString());
CListeObjetsDonnees liste = new CListeObjetsDonnees(m_objet.ContexteDonnee,
typeof(CVersionDonnees));
m_panelListeVersions.InitFromListeObjets(liste,
typeof(CVersionDonneesObjet),
null,
null,
"");
}
////////////////////////////////////////////////////////////////////////
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);
}
//-------------------------------------------------------------------
public void AppliquerFiltre()
{
string strFiltre = "";
CFiltreDataAvance tempFiltre = new CFiltreDataAvance(CActeur.c_nomTable, strFiltre);
int nNumParam = 1;
AddToFiltre(ref strFiltre, m_txtNom, CActeur.c_champNom);
AddToFiltre(ref strFiltre, m_txtCodePostal, CActeur.c_champCodePostal);
AddToFiltre(ref strFiltre, m_txtVille, CActeur.c_champVille);
if (m_cmbGroupes.SelectedValue != null)
{
if (strFiltre != "")
{
strFiltre += " AND ";
}
strFiltre += "RelationsGroupes.GroupeActeur." + CGroupeActeur.c_champId + " = @" + nNumParam;
tempFiltre.Parametres.Add(((CGroupeActeur)m_cmbGroupes.SelectedValue).Id);
nNumParam++;
}
if (m_cmbRoles.SelectedValue != null)
{
CRoleActeur role = (CRoleActeur)m_cmbRoles.SelectedValue;
string strNomtable = CContexteDonnee.GetNomTableForType(role.TypeDonneeActeur);
if (strFiltre != "")
{
strFiltre += " AND ";
}
strFiltre += strNomtable + "." + CActeur.c_champId + " >= 0";
nNumParam++;
}
if (strFiltre == "")
{
strFiltre = "1 = 1";
}
tempFiltre.Filtre = strFiltre;
Filtre = tempFiltre;;
OnAppliqueFiltre(new object(), null);
}
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
try
{
C2iExpression[] parametresFiltre = new C2iExpression[Parametres.Count - 3];
for (int nIndex = 3; nIndex < Parametres.Count; nIndex++)
{
parametresFiltre[nIndex - 3] = Parametres2i[nIndex];
}
result = GetFiltre(ctx, Parametres2i[0], Parametres2i[2], parametresFiltre);
if (!result)
{
return(result);
}
if (!(ctx.ObjetSource is CObjetDonnee))
{
result.EmpileErreur(I.T("CalculSql cannot be applied here|204"));
return(result);
}
CObjetDonnee objet = (CObjetDonnee)ctx.ObjetSource;
CFiltreDataAvance filtre = (CFiltreDataAvance)result.Data;
Type tpInterroge = CContexteDonnee.GetTypeForTable(filtre.TablePrincipale);
result = Parametres2i[1].Eval(ctx);
if (!result)
{
return(result);
}
result = GetClauseSelect(result.Data.ToString(), tpInterroge);
IObjetServeur serveur = objet.ContexteDonnee.GetTableLoader(filtre.TablePrincipale);
result = serveur.ExecuteScalar((string)result.Data, filtre);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in calculSql|205"));
}
return(result);
}
//-----------------------------------------------------------------
public void AppliquerFiltre()
{
CFiltreData filtre = null;
if (m_cmbCategorie.ElementSelectionne is CCategorieGED)
{
CCategorieGED cat = (CCategorieGED)m_cmbCategorie.ElementSelectionne;
filtre = new CFiltreDataAvance(CDocumentGED.c_nomTable,
CRelationDocumentGED_Categorie.c_nomTable + "." +
CCategorieGED.c_nomTable + "." +
CCategorieGED.c_champCodeSystemeComplet + " LIKE @1",
cat.CodeSystemeComplet + "%");
}
if (m_dateDebutCreation.Value != null)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(CDocumentGED.c_champDateCreation + ">=@1",
m_dateDebutCreation.Value.DateTimeValue));
}
if (m_dateFinCreation.Value != null)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(CDocumentGED.c_champDateCreation + "<@1",
CUtilDate.SetTime0(m_dateFinCreation.Value.DateTimeValue.AddDays(1))));
}
if (m_dateDebutModification.Value != null)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(CDocumentGED.c_champDateMAJ + ">=@1",
m_dateDebutModification.Value.DateTimeValue));
}
if (m_dateFinModification.Value != null)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(CDocumentGED.c_champDateMAJ + "<@1",
CUtilDate.SetTime0(m_dateFinModification.Value.DateTimeValue.AddDays(1))));
}
Filtre = filtre;
OnAppliqueFiltre(new object(), null);
}
////////////////////////////////////////////////////////
public string GetStringAvance(CFiltreDataAvance filtre)
{
CComposantFiltre composant = filtre.ComposantPrincipal;
if (composant == null)
{
return("");
}
//remplace chaque champ par sa valeur
for (int nParametre = filtre.Parametres.Count; nParametre > 0; nParametre--)
{
if (filtre.Parametres[nParametre - 1] is IList)
{
composant.RemplaceVariableParConstante("@" + nParametre, filtre.Parametres[nParametre - 1]);
filtre.Parametres[nParametre - 1] = "";
}
composant.RenommeVariable("@" + nParametre, "@PARAM" + nParametre);
}
return(GetStringExpression(composant, filtre));
}
//------------------------------------------------------------------------------
private void FillCategoriesForElement(IObjetDonneeAIdNumerique element)
{
CFiltreData filtreCategories;
if (element != null && !m_chkToutesCategories.Checked)
{
filtreCategories = new CFiltreDataAvance(
CCategorieGED.c_nomTable,
CRelationDocumentGED_Categorie.c_nomTable + "." +
CDocumentGED.c_nomTable + "." +
CRelationElementToDocument.c_nomTable + "." +
CRelationElementToDocument.c_champIdElement + " = @1 AND " +
CRelationDocumentGED_Categorie.c_nomTable + "." +
CDocumentGED.c_nomTable + "." +
CRelationElementToDocument.c_nomTable + "." +
CRelationElementToDocument.c_champTypeElement + " = @2",
element.Id,
element.GetType().ToString()
);
}
else
{
filtreCategories = null;
}
m_arbreCategories.AddRootForAll = true;
m_arbreCategories.RootLabel = I.T("All categories|20246");
CTreeViewNodeKeeper keeper = new CTreeViewNodeKeeper(m_arbreCategories);
m_arbreCategories.Init(
typeof(CCategorieGED),
"CategoriesFilles",
CCategorieGED.c_champIdParent,
"Libelle",
filtreCategories,
null);
m_arbreCategories.CheckBoxes = false;
keeper.Apply(m_arbreCategories);
}
private void m_arbreCategories_AfterSelect(object sender, TreeViewEventArgs e)
{
// Quand on selectionne une catégorie de GED il faut filtrer la liste de documents sur la Categorie
CCategorieGED categorieSelectionnee = m_arbreCategories.GetObjetInNode(e.Node) as CCategorieGED;
if (categorieSelectionnee != null)
{
CFiltreData filtreSurCategorie = new CFiltreDataAvance(CDocumentGED.c_nomTable,
CRelationDocumentGED_Categorie.c_nomTable + "." +
CCategorieGED.c_nomTable + "." +
CCategorieGED.c_champCodeSystemeComplet + " LIKE @1",
categorieSelectionnee.CodeSystemeComplet + "%");
m_filtreCategories = filtreSurCategorie;
InitPanelList(m_elementSelectionne);
}
else
{
m_filtreCategories = null;
InitPanelList(m_elementSelectionne);
}
}
public CFiltreData GetFiltreForType(Type tp)
{
CFiltreData filtre = null;
if (
m_ArbreModules.SelectedNode != null &&
m_chkAppliquerFiltre.Checked &&
m_contexte != null &&
typeof(IObjetDonneeAIdNumerique).IsAssignableFrom(tp))
{
CModuleParametrage module = m_ArbreModules.SelectedNode.Tag as CModuleParametrage;
if (module != null)
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(m_contexte, typeof(CRelationElement_ModuleParametrage));
lst.Filtre = new CFiltreDataAvance(
CRelationElement_ModuleParametrage.c_nomTable,
CRelationElement_ModuleParametrage.c_champTypeElement + "=@1 and " +
CModuleParametrage.c_nomTable + "." + CModuleParametrage.c_champCodeSystemeComplet + " like @2",
tp.ToString(),
module.CodeSystemeComplet + "%");
if (lst.Count != 0)
{
StringBuilder bl = new StringBuilder();
foreach (CRelationElement_ModuleParametrage rel in lst)
{
bl.Append(rel.IdElement);
bl.Append(';');
}
bl.Remove(bl.Length - 1, 1);
DataTable table = m_contexte.GetTableSafe(CContexteDonnee.GetNomTableForType(tp));
filtre = new CFiltreDataAvance(
CContexteDonnee.GetNomTableForType(tp),
table.PrimaryKey[0].ColumnName + " in {" +
bl.ToString() + "}");
}
}
}
return(filtre);
}
//----------------------------------------------------------------------------
private void InitListesPlannifieurs(bool bMajChamps)
{
CFiltreData filtrePlanifieurs = new CFiltreDataAvance(CActeur.c_nomTable,
"HAS(" + CDonneesActeurUtilisateur.c_nomTable + "." +
CDonneesActeurUtilisateur.c_champId + ")");
CFiltreData filtrePrePlanifieurs = filtrePlanifieurs.GetClone();
bool bAppliquerProfils = true;
if (bAppliquerProfils)
{
CTypeIntervention typeIntervention = (CTypeIntervention)m_cmbTypeIntervention.ElementSelectionne;
if (typeIntervention != null && typeIntervention.ProfilPlanifieur != null)
{
CListeObjetsDonnees lstTmp = typeIntervention.ProfilPlanifieur.GetElementsForSource(Intervention, null);
CFiltreDataAvance filtreTmp = CFiltreDataAvance.ConvertFiltreToFiltreAvance(CDonneesActeurUtilisateur.c_nomTable, lstTmp.FiltrePrincipal);
filtreTmp.ChangeTableDeBase(CActeur.c_nomTable, CDonneesActeurUtilisateur.c_nomTable);
filtrePlanifieurs = CFiltreData.GetAndFiltre(filtrePlanifieurs, filtreTmp);
}
if (typeIntervention != null && typeIntervention.ProfilPreplanifieur != null)
{
CListeObjetsDonnees lstTmp = typeIntervention.ProfilPreplanifieur.GetElementsForSource(Intervention, null);
CFiltreDataAvance filtreTmp = CFiltreDataAvance.ConvertFiltreToFiltreAvance(CDonneesActeurUtilisateur.c_nomTable, lstTmp.FiltrePrincipal);
filtreTmp.ChangeTableDeBase(CActeur.c_nomTable, CDonneesActeurUtilisateur.c_nomTable);
filtrePrePlanifieurs = CFiltreData.GetAndFiltre(filtrePrePlanifieurs, filtreTmp);
}
}
m_txtSelectPreplanificateur.InitAvecFiltreDeBase <CActeur>(
"IdentiteComplete",
filtrePrePlanifieurs,
true);
m_txtSelectPlanificateur.InitAvecFiltreDeBase <CActeur>(
"IdentiteComplete",
filtrePlanifieurs,
true);
}
//------------------------------------------------------------------------
public static DataSet GetSites(
C2iSessionWeb sessionWeb,
int[] nIdSites)
{
using (CContexteDonnee ctx = new CContexteDonnee(sessionWeb.Session.IdSession, true, false))
{
CMemoryDb db = new CMemoryDb();
db.EnforceConstraints = false;
if (nIdSites != null && nIdSites.Length > 0)
{
StringBuilder bl = new StringBuilder();
foreach (int nIdSite in nIdSites)
{
bl.Append(nIdSite);
bl.Append(';');
}
bl.Remove(bl.Length - 1, 1);
CFiltreDataAvance filtre = new CFiltreDataAvance(CSite.c_nomTable,
CSite.c_champId + " in {" + bl.ToString() + "}");
filtre.IntegrerFilsHierarchiques = true;
CListeObjetDonneeGenerique <CSite> lstSites = new CListeObjetDonneeGenerique <CSite>(ctx);
lstSites.Filtre = filtre;
lstSites.AssureLectureFaite();
lstSites.ReadDependances("SitesFils");
lstSites.Filtre = new CFiltreData(CSite.c_champIdParent + " is null");
lstSites.InterditLectureInDB = true;
foreach (CSite site in lstSites)
{
AddDetailSiteToDb(site, null, db);
}
}
return(db);
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
try
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte.ContexteDonnee, typeof(CActeur));
CFiltreData filtre = new CFiltreDataAvance(
CActeur.c_nomTable,
"Has(" + CEOplanifiee_Acteur.c_nomTable + "." + CEOplanifiee_Acteur.c_champId + ")");
liste.Filtre = filtre;
foreach (CActeur acteur in liste)
{
//Il suffit de modifier l'acteur pour qu'on recalcule ces eos
CUtilElementAEO.UpdateEOSInCurrentContext(acteur);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
protected override void InitPanel()
{
//N'affiche que les éléments avec catégorie et non liés à un
//élément.
if (m_filtreDeBaseOriginal == null)
{
m_filtreDeBaseOriginal = FiltreDeBase;
}
CFiltreData filtreDeBase = m_filtreDeBaseOriginal;
if (m_objetForSuivi != null)
{
filtreDeBase =
CFiltreData.GetAndFiltre(filtreDeBase,
new CFiltreData(
CDossierSuivi.c_champTypeElementLie + "=@1 and " +
CDossierSuivi.c_champIdElementLie + "=@2",
m_objetForSuivi.GetType().ToString(),
m_objetForSuivi.Id));
}
if (ContexteUtilisation.Trim() != "")
{
m_chkOnlyPrincipaux.Visible = false;
m_chkOnlyPrincipaux.Checked = false;
}
if (m_chkOnlyPrincipaux.Checked)
{
CFiltreData filtre = new CFiltreDataAvance(
CDossierSuivi.c_nomTable,
"hasno(" + CDossierSuivi.c_champIdDossierParent + ")");
filtreDeBase = CFiltreData.GetAndFiltre(filtre, filtreDeBase);
}
bool bOldVal = m_panelListe.FiltreDeBaseEnAjout;
m_panelListe.FiltreDeBaseEnAjout = false;
m_panelListe.FiltreDeBase = filtreDeBase;
m_panelListe.FiltreDeBaseEnAjout = bOldVal;
//m_panelListe.ControlFiltreStandard = new CPanelFiltreDocumentGed();
m_panelListe.InitFromListeObjets(
m_listeObjets,
typeof(CDossierSuivi),
null, "");
//S'il n'existe aucun type de dossier pour le type de l'élément, le bouton
//AJoute est masqué.
CListeObjetsDonnees liste = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, typeof(CTypeDossierSuivi));
if (m_objetForSuivi != null)
{
liste.Filtre = new CFiltreData(CTypeDossierSuivi.c_champTypeSuivi + "=@1",
m_objetForSuivi.GetType().ToString());
}
else
{
liste.Filtre = new CFiltreData(CTypeDossierSuivi.c_champTypeSuivi + "=@1",
"");
}
m_panelListe.BoutonAjouterVisible = liste.Count > 0 && m_panelListe.BoutonAjouterVisible;
m_panelListe.RemplirGrille();
if (m_objetForSuivi == null)
{
m_lnkElement.Visible = false;
}
else
{
m_lnkElement.Visible = true;
m_lnkElement.Text = m_objetForSuivi.DescriptionElement;
}
}
private CResultAErreur ImputeDureeSurActivite(CFractionIntervention fraction)
{
CResultAErreur result = CResultAErreur.True;
if (fraction.DateDebut == null ||
fraction.DateFin == null)
{
return(result);
}
if (fraction.TempsDeTravail == null)
{
return(result);
}
Hashtable tableToDelete = new Hashtable();
//Stocke la liste des relations qui étaient présentes avant le travail
//et les note comme étant à supprimer
foreach (CIntervention_ActiviteActeur rel in fraction.RelationsActivite)
{
tableToDelete[rel] = true;
}
CTypeActiviteActeur typeActivite = fraction.Intervention.TypeIntervention.TypeActiviteActeur;
bool bAvecSite = typeActivite.SiteObligatoire;
if (typeActivite != null)
{
//Evalue les valeurs des champs custom pour l'activite
CParametreRemplissageActiviteParIntervention parametreRemplissage = fraction.Intervention.TypeIntervention.ParametreRemplissageActivite;
Dictionary <CChampCustom, object> valeursChamps = new Dictionary <CChampCustom, object>();
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(fraction);
if (parametreRemplissage != null)
{
foreach (CRemplisssageChampActiviteActeur remplissage in parametreRemplissage.ListeRemplissage)
{
CChampCustom champ = new CChampCustom(fraction.ContexteDonnee);
if (champ.ReadIfExists(remplissage.IdChampCustom))
{
C2iExpression formule = remplissage.Formule;
if (formule != null)
{
result = formule.Eval(ctxEval);
if (result)
{
valeursChamps[champ] = result.Data;
}
}
}
}
}
foreach (CIntervention_Intervenant relIntervenant in fraction.Intervention.RelationsIntervenants)
{
DateTime dt = ((DateTime)fraction.DateDebut).Date;
//Attention, si on est sur une fraction sur plusieurs jours, le
//pb est que la durée saisie (retenue pour l'intervention) peut
//ne pas être égale aux différents jours d'imputation,
//on réparti donc la durée de manière homogène sur les différents
//Jour en faisant un prorata de chaque jour
double fDureeAImputer = (double)fraction.TempsDeTravail;
double fDureeReelle = (double)fraction.DureeReelle;
while (dt < (DateTime)fraction.DateFin && fDureeAImputer > 0)
{
//Cherche pour l'intervention ses activités du bon type
CFiltreData filtre = new CFiltreDataAvance(CActiviteActeur.c_nomTable,
CTypeActiviteActeur.c_champId + "=@1 and " +
CActiviteActeur.c_champDate + ">=@2 and " +
CActiviteActeur.c_champDate + "<@3 and " +
"Has(" + CIntervention_ActiviteActeur.c_nomTable + "." +
CIntervention_ActiviteActeur.c_champId + ") and " +
CActeur.c_champId + "=@4",
typeActivite.Id,
dt,
dt.AddDays(1),
relIntervenant.Intervenant.Id);
if (bAvecSite)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(CSite.c_champId + "=@1",
fraction.Intervention.Site.Id));
}
CListeObjetsDonnees listeActivites = new CListeObjetsDonnees(fraction.ContexteDonnee, typeof(CActiviteActeur));
listeActivites.Filtre = filtre;
listeActivites.ReadDependances("RelationsInterventions");
CActiviteActeur activiteRetenue = null;
CIntervention_ActiviteActeur relRetenue = null;
foreach (CActiviteActeur activite in listeActivites)
{
bool bPrendre = true;
foreach (KeyValuePair <CChampCustom, object> chpValeur in valeursChamps)
{
object valDeAct = activite.GetValeurChamp(chpValeur.Key.Id);
if (valDeAct == null && chpValeur.Value != null)
{
bPrendre = false;
break;
}
else if (chpValeur.Value == null && valDeAct != null)
{
bPrendre = false;
break;
}
else if (chpValeur.Value != null && !chpValeur.Value.Equals(valDeAct))
{
bPrendre = false;
break;
}
}
if (bPrendre)
{
activiteRetenue = activite;
relRetenue = null;
foreach (CIntervention_ActiviteActeur relInter in activiteRetenue.RelationsInterventions)
{
//Si l'activité est directement liée à cette fraction, prend celle ci de préférence
if (relInter.FractionIntervention.Id == fraction.Id)
{
relRetenue = relInter;
break;
}
}
}
}
if (activiteRetenue == null)
{
//Création de l'activite
activiteRetenue = new CActiviteActeur(fraction.ContexteDonnee);
activiteRetenue.CreateNewInCurrentContexte();
activiteRetenue.TypeActiviteActeur = typeActivite;
activiteRetenue.Acteur = relIntervenant.Intervenant;
activiteRetenue.Date = dt;
activiteRetenue.Duree = 0;
if (bAvecSite)
{
activiteRetenue.Site = fraction.Intervention.Site;
}
foreach (KeyValuePair <CChampCustom, object> valChamp in valeursChamps)
{
activiteRetenue.SetValeurChamp(valChamp.Key.Id, valChamp.Value);
}
}
if (relRetenue == null)
{
//Création de la relation à l'interventation
relRetenue = new CIntervention_ActiviteActeur(fraction.ContexteDonnee);
relRetenue.ActiviteActeur = activiteRetenue;
relRetenue.DureeImputee = 0;
relRetenue.FractionIntervention = fraction;
}
//Note que cette relation ne doit pas être supprimée
tableToDelete[relRetenue] = false;
double fDureeForThis = 0;
if (dt == fraction.DateFin.Value.Date)
{
fDureeForThis = fDureeAImputer; //On affecte le reste
}
else
{
if (dt == fraction.DateDebut.Value.Date)
{
//On est sur le premier jour,
//Utilise comme référence le temps qui sépare la date
//de début de minuit
TimeSpan sp = dt.AddDays(1) - fraction.DateDebut.Value;
double fRatio = sp.TotalHours / fDureeReelle;
fDureeForThis = fRatio * fraction.TempsDeTravail.Value;
}
else
{
fDureeForThis = 24.0 / fDureeReelle * fraction.TempsDeTravail.Value;
}
//Arrondi la durée calculé à la minute
fDureeForThis = (int)fDureeForThis + (int)((fDureeForThis - (int)fDureeForThis) * 60.0 + .5) / 60.0;
}
fDureeAImputer -= fDureeForThis;
if (relRetenue.DureeImputee != fDureeForThis)
{
//Impute la durée de la fraction sur l'activité
relRetenue.ActiviteActeur.Duree -= relRetenue.DureeImputee;
relRetenue.DureeImputee = (double)fDureeForThis;
relRetenue.ActiviteActeur.Duree += fDureeForThis;
}
dt = dt.AddDays(1);
}
}
}
foreach (DictionaryEntry entry in tableToDelete)
{
if ((bool)entry.Value)
{
//Supprime la relation
CIntervention_ActiviteActeur relToDelete = (CIntervention_ActiviteActeur)entry.Key;
if (relToDelete.Row.RowState != DataRowState.Deleted)
{
CActiviteActeur activiteAncienne = relToDelete.ActiviteActeur;
//SC 10/3/2014 : La désimputation du temps de l'activité se fait dans CIntervention_activiteActeurServeur.TraitementAvantSauvegardee
//activiteAncienne.Duree -= relToDelete.DureeImputee;
result = relToDelete.Delete(true);
/*if ( result && activiteAncienne.Duree == 0 )
* result = activiteAncienne.Delete();
* if ( !result )
* return result;*/
}
}
}
return(result);
}