private void SupprimerClient(int id)
{
Console.WriteLine("suppression d'un client");
CActeur client = new CActeur(m_contexteDonnees);
CDonneesActeurClient donnees = new CDonneesActeurClient(m_contexteDonnees);
CSpvClient clientSpv = new CSpvClient(m_contexteDonnees);
CResultAErreur result;
Console.WriteLine("Lecture du client");
Assert.IsTrue(client.ReadIfExists(id));
donnees = client.Client;
int nIdClient = donnees.Id;
Console.WriteLine("lecture du client SPV");
Assert.IsTrue(clientSpv.ReadIfExists(new CFiltreData(CSpvClient.c_champSmtClient_Id + "=@1",
nIdClient)));
result = client.Delete();
Console.WriteLine("suppression du client");
Assert.IsTrue(result.Result);
CSpvClient clientSpvTest = new CSpvClient(m_contexteDonnees);
Console.WriteLine("vérification de la suppression");
Assert.IsFalse(clientSpvTest.ReadIfExists(new CFiltreData(CSpvClient.c_champSmtClient_Id + "=@1", nIdClient)));
}
private void DisplayActeur(CActeur acteur, params int[] nIdsVersions)
{
int? nOldVersion = acteur.ContexteDonnee.IdVersionDeTravail;
List <string> lstLabels = new List <string>();
acteur.ContexteDonnee.SetVersionDeTravail(null, false);
lstLabels.Add(acteur.Nom + " / " + acteur.Adresse);
foreach (int nVersion in nIdsVersions)
{
acteur.ContexteDonnee.SetVersionDeTravail(nVersion, false);
lstLabels.Add(acteur.Nom + " / " + acteur.Adresse);
}
StringBuilder bl = new StringBuilder();
int nVer = 0;
foreach (string strLib in lstLabels)
{
if (nVer == 0)
{
bl.Append("Ref : ");
}
else
{
bl.Append(nVer.ToString());
bl.Append(" : ");
}
bl.Append(strLib);
bl.Append("\r\n");
nVer++;
}
CFormAlerte.Afficher(bl.ToString());
acteur.ContexteDonnee.SetVersionDeTravail(nOldVersion, false);
}
//-------------------------------------------------------------------------
public CResultAErreur InitControl(CDataPlanning dataPlanning)
{
CResultAErreur result = CResultAErreur.True;
if (dataPlanning == null)
{
CActeur acteur = null;
dataPlanning = new CDataPlanning(typeof(CActeur), acteur);
}
m_dataPlanning = dataPlanning;
CFiltreData filtre = null;
if (m_dataGridView.Tag is CFiltreData)
{
filtre = (CFiltreData)m_dataGridView.Tag;
}
m_txtSelectElement.InitForSelectAvecFiltreDeBase(
dataPlanning.TypeElement,
"Libelle",
filtre,
true);
m_txtSelectElement.ElementSelectionne = (CObjetDonnee)dataPlanning.Element;
return(result);
}
public void ModifNomDansV1()
{
ResetModifs();
CActeur acteur = ActeurReferentiel;
DataRow row = acteur.Row.Row;
string strNomRef = "Nom ref";
string strNomV1 = "Acteur V1";
SetSituation(
new M(null, new CV(CActeur.c_champNom, strNomRef)),
new M(m_nIdsVersions[0], new CV(CActeur.c_champNom, strNomV1))
);
string[] strLibs = GetValeursActeurParVersion(acteur, CActeur.c_champNom);
//Ref = valeur d'origine
Assert.AreEqual(strLibs[0], strNomRef);
//V1 = valeur "Acteur V1"
Assert.AreEqual(strLibs[1], strNomV1);
//V2 = valeur du référentiel
Assert.AreEqual(strLibs[2], strNomRef);
//V3 = valeur de V1
Assert.AreEqual(strLibs[3], strNomV1);
}
public void ModifActeurDeV1DansV1()
{
ResetModifs();
CActeur acteur = AssureActeurV1();
string strNom1 = "NOM 1" + DateTime.Now.ToString("g");
SetSituation(acteur,
new M(m_nIdsVersions[0], new CV(CActeur.c_champNom, strNom1)));
string[] strLibs = GetValeursActeurParVersion(acteur, CActeur.c_champNom);
Assert.AreEqual(null, strLibs[0]);
Assert.AreEqual(null, strLibs[2]);
Assert.AreEqual(strNom1, strLibs[1]);
Assert.AreEqual(strNom1, strLibs[3]);
string strNom2 = "NOM V1 2";
SetSituation(acteur,
new M(m_nIdsVersions[0], new CV(CActeur.c_champNom, strNom2)));
strLibs = GetValeursActeurParVersion(acteur, CActeur.c_champNom);
Assert.AreEqual(null, strLibs[0]);
Assert.AreEqual(null, strLibs[2]);
Assert.AreEqual(strNom2, strLibs[1]);
Assert.AreEqual(strNom2, strLibs[3]);
}
private void ModifierClientSansValider(int id, string newNom, string newPrenom)
{
CActeur client = new CActeur(m_contexteDonnees);
Console.WriteLine("Modification du nom du client sans valider");
CDonneesActeurClient donnees = new CDonneesActeurClient(m_contexteDonnees);
string oldnom;
string oldprenom;
Assert.IsTrue(client.ReadIfExists(id));
oldnom = client.Nom;
oldprenom = client.Prenom;
client.Nom = newNom;
client.Prenom = newPrenom;
donnees = (CDonneesActeurClient)client.DonneesClient[0];
CSpvClient clientSpv = new CSpvClient(m_contexteDonnees);
Assert.IsTrue(clientSpv.ReadIfExists(new CFiltreData(CSpvClient.c_champSmtClient_Id + "=@1", donnees.Id)));
string nomclient = oldprenom + " " + oldnom;
Console.WriteLine("Vérification du nom du client");
Assert.IsTrue(clientSpv.CLIENT_NOM == nomclient);
}
public void SupprimeActeurDansV1()
{
ResetModifs();
CActeur acteur = ActeurReferentiel;
int nIdActeur = acteur.Id;
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[0], false);
CListeObjetsDonnees listeActeurs = new CListeObjetsDonnees(m_contexteDonnee, typeof(CActeur));
listeActeurs.Filtre = new CFiltreData(CActeur.c_champId + "=@1", nIdActeur);
Assert.IsTrue(acteur.Delete());
m_contexteDonnee.SetVersionDeTravail(null, false);
Assert.IsTrue(acteur.IsValide());
listeActeurs.Refresh();
Assert.AreEqual(1, listeActeurs.Count);
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[0], false);
Assert.IsFalse(acteur.IsValide());
listeActeurs.Refresh();
Assert.AreEqual(0, listeActeurs.Count);
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[1], false);
Assert.IsTrue(acteur.IsValide());
listeActeurs.Refresh();
Assert.AreEqual(1, listeActeurs.Count);
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[2], false);
Assert.IsFalse(acteur.IsValide());
listeActeurs.Refresh();
Assert.AreEqual(0, listeActeurs.Count);
}
//----------------------------------------------------------------
private void m_btnOk_Click(object sender, EventArgs e)
{
IPossesseurRessource emplacement = null;
if (m_radioSite.Checked)
{
emplacement = (CSite)m_selectSite.ElementSelectionne;
}
if (m_radioActeur.Checked)
{
emplacement = (CActeur)m_selectActeur.ElementSelectionne;
}
CActeur acteur = (CActeur)m_selectUser.ElementSelectionne;
CResultAErreur result = m_ressource.DeplaceRessource(
m_txtInfo.Text,
emplacement,
acteur == null?null:acteur.Utilisateur,
m_dtMouvement.Value);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
else
{
DialogResult = DialogResult.OK;
Close();
}
}
//-------------------------------------------------------------------------------------
public CResultAErreur Init(
CIntervention intervention,
CTypeIntervention_ProfilIntervenant profil,
CActeur acteur)
{
CResultAErreur result = CResultAErreur.True;
m_profil = profil;
m_intervention = intervention;
m_intervenant = acteur;
m_lblProfil.Text = profil.Libelle;
// Init la la TextBoxSelectionne avec le filtre par défaut des Intervenants et un filtre rapide
CFiltreData filtre = null;
if (m_intervention != null && m_intervention.TypeIntervention != null && m_intervention.TypeIntervention.FiltreDynamiqueIntervenants != null)
{
result = m_intervention.TypeIntervention.FiltreDynamiqueIntervenants.GetFiltreData();
if (result)
{
filtre = result.Data as CFiltreData;
}
}
m_txtSelectIntervenant.InitAvecFiltreDeBase <CActeur>("IdentiteComplete", filtre, true);
m_txtSelectIntervenant.ElementSelectionne = m_intervenant;
return(result);
}
//--------------------------------------------------------------
private void InitListeContrats(bool bForcerInit)
{
CActeur acteur = (CActeur)m_txtSelectClient.ElementSelectionne;
CListeObjetsDonnees listeContrats = new CListeObjetsDonnees(m_ticketEdite.ContexteDonnee, typeof(CContrat));
if (acteur != null)
{
CDonneesActeurClient client = acteur.Client;
if (client != null)
{
listeContrats.Filtre = new CFiltreData(
CDonneesActeurClient.c_champId + " = @1",
client.Id);
}
}
m_cmbxSelectContrat.Init(listeContrats, "Libelle", bForcerInit);
m_cmbxSelectContrat.AssureRemplissage();
if (listeContrats.Count == 1)
{
m_cmbxSelectContrat.SelectedIndex = 0;
}
if (acteur == null)
{
m_cmbxSelectContrat.ElementSelectionne = null;
}
InitListeTypesTickets(true);
}
public void CreateActeurDansV1EtsuppressionDansV3()
{
ResetModifs();
CActeur acteur = AssureActeurV1();
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[0], false);
Assert.IsTrue(acteur.IsValide());
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[2], false);
Assert.IsTrue(acteur.IsValide());
m_contexteDonnee.SetVersionDeTravail(null, false);
Assert.IsFalse(acteur.IsValide());
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[1], false);
Assert.IsFalse(acteur.IsValide());
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[2], false);
Assert.IsTrue(acteur.Delete().Result);
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[0], false);
Assert.IsTrue(acteur.IsValide());
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[2], false);
Assert.IsFalse(acteur.IsValide());
m_contexteDonnee.SetVersionDeTravail(null, false);
Assert.IsFalse(acteur.IsValide());
m_contexteDonnee.SetVersionDeTravail(m_nIdsVersions[1], false);
Assert.IsFalse(acteur.IsValide());
}
public void Init()
{
CResultAErreur result = CResultAErreur.True;
CTimosTestMetierApp.AssureInit();
m_contexteDonnee = new CContexteDonnee(CTimosTestMetierApp.SessionClient.IdSession, true, false);
using (CContexteDonnee contexte = new CContexteDonnee(CTimosTestMetierApp.SessionClient.IdSession, true, false))
{
CVersionDonnees version1 = null;
for (int nVersion = 0; nVersion < m_nIdsVersions.Length; nVersion++)
{
CVersionDonnees version = new CVersionDonnees(contexte);
if (version.ReadIfExists(new CFiltreData(CVersionDonnees.c_champLibelle + "=@1 and " +
CVersionDonnees.c_champTypeVersion + "=@2",
GetLibelleVersion(nVersion),
(int)CTypeVersion.TypeVersion.Previsionnelle)))
{
m_nIdsVersions[nVersion] = version.Id;
}
else
{
version.CreateNew();
version.Libelle = GetLibelleVersion(nVersion);
version.CodeTypeVersion = (int)CTypeVersion.TypeVersion.Previsionnelle;
version.Date = DateTime.Now;
if (nVersion == 2)
{
version.VersionParente = version1;
}
result = version.CommitEdit();
if (!result)
{
throw new CExceptionErreur(result.Erreur);
}
m_nIdsVersions[nVersion] = version.Id;
}
if (nVersion == 0)
{
version1 = version;
}
}
}
//Création de l'acteur de test
CActeur acteur = new CActeur(m_contexteDonnee);
if (!acteur.ReadIfExists(new CFiltreData(CActeur.c_champPrenom + "=@1",
"NUNIT ACTEUR")))
{
acteur.CreateNew();
acteur.Nom = "NUnit acteur";
acteur.Prenom = "NUNIT ACTEUR";
result = acteur.CommitEdit();
Assert.IsTrue(result.Result);
}
m_nIdActeur = acteur.Id;
//Remet le jeu de test à 0
ResetModifs();
}
/// /////////////////////////////
public void SetElementsAAgenda(CObjetDonneeAIdNumerique[] elements)
{
m_elementsAAgenda = elements;
if (m_controlAffichage != null)
{
((IControlAgenda)m_controlAffichage).SetElementsAAgenda(m_elementsAAgenda);
}
if (m_elementsAAgenda.Length > 1)
{
m_lnkAjouter.Visible = false;
return;
}
//Si l'élément est un acteur, possible de créer une entrée si
//c'est soi-même ou si c'est un acteur dont on gère l'agenda
if (elements.Length == 1 && elements[0] is CActeur)
{
CActeur part = (CActeur)elements[0];
m_lnkAjouter.Visible = false;
CDonneesActeurUtilisateur user = CUtilSession.GetUserForSession(elements[0].ContexteDonnee);
if (user.Acteur.Equals(part))
{
m_lnkAjouter.Visible = true;
}
else
{
/*foreach ( CRelationUtilisateur_AgendasGeres rel in user.RelationsUtilisateursAgendaGeres )
* if ( rel.UtilisateurGere.Acteur.Equals ( part ) )
* m_lnkAjouter.Visible = true;*/
}
}
}
//----------------------------------
private void SetSituation(CActeur acteur, params M[] modifications)
{
foreach (M modif in modifications)
{
modif.ModifieActeur(acteur);
}
}
public void TiagSetResponsableClotureKeys(object[] lstCles)
{
CActeur respCloture = new CActeur(ContexteDonnee);
if (respCloture.ReadIfExists(lstCles))
{
ResponsableClotureTechnique = respCloture;
}
}
public void TiagSetIntervenantKeys(object[] lstCles)
{
CActeur acteur = new CActeur(ContexteDonnee);
if (acteur.ReadIfExists(lstCles))
{
Intervenant = acteur;
}
}
public void TiagSeActeurKeys(object[] lstCles)
{
CActeur acteur = new CActeur(ContexteDonnee);
if (acteur.ReadIfExists(lstCles))
{
Acteur = acteur;
}
}
//-----------------------------------------------------------------
public void TiagSetMemberKeys(object[] keys)
{
CActeur acteur = new CActeur(ContexteDonnee);
if (acteur.ReadIfExists(keys))
{
Acteur = acteur;
}
}
private int CreerClient(string nom, string prenom)
{
//créer un client
CActeur client = new CActeur(m_contexteDonnees);
CDonneesActeurClient donneesClient = new CDonneesActeurClient(m_contexteDonnees);
if (!client.ReadIfExists(new CFiltreData(CActeur.c_champNom + "=@1",
nom)))
{
client.CreateNewInCurrentContexte();
client.Nom = nom;
client.Prenom = prenom;
donneesClient.CreateNewInCurrentContexte();
donneesClient.Acteur = client;
}
else
{
Console.WriteLine("le client existe déjà");
return(client.Id);
}
CResultAErreur result = m_contexteDonnees.SaveAll(true);
if (!result)
{
System.Console.WriteLine(result.MessageErreur);
}
//Assert.IsTrue(result.Result);
result = m_contexteDonnees.SaveAll(true);
if (!result)
{
System.Console.WriteLine(result.MessageErreur);
}
Assert.IsTrue(result.Result);
int nId = donneesClient.Id;
CSpvClient spvClient = new CSpvClient(m_contexteDonnees);
Assert.IsTrue(spvClient.ReadIfExists(new CFiltreData(CSpvClient.c_champSmtClient_Id + "=@1", nId)));
Console.WriteLine(spvClient.CLIENT_NOM);
return(nId);
}
//-------------------------------------------------------------------
public void AppliquerFiltre()
{
CFiltreData filtre = null;
CActeur acteur = m_txtActeur.ElementSelectionne as CActeur;
if (acteur != null)
{
CFiltreData filtreAss = new CFiltreData();
string[] strCodes = acteur.GetListeCodesAffectationEtape();
foreach (string strCode in strCodes)
{
filtreAss.Filtre += CEtapeWorkflow.c_champAffectations + " like @" +
(filtreAss.Parametres.Count + 1) + " or ";
filtreAss.Parametres.Add("%~" + strCode + "~%");
}
if (filtreAss.Filtre.Length > 0)
{
filtreAss.Filtre = filtreAss.Filtre.Remove(filtreAss.Filtre.Length - 4, 4);
filtre = CFiltreData.GetAndFiltre(filtre, filtreAss);
}
}
CEtatEtapeWorkflow etat = m_cmbEtats.SelectedValue as CEtatEtapeWorkflow;
if (etat != null)
{
CFiltreData filtreTmp = new CFiltreData(CEtapeWorkflow.c_champEtat + "=@1",
etat.CodeInt);
filtre = CFiltreData.GetAndFiltre(filtreTmp, filtre);
}
CTypeWorkflow type = m_txtTypeWorkflow.ElementSelectionne as CTypeWorkflow;
if (type != null)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreDataAvance(CEtapeWorkflow.c_nomTable,
CTypeEtapeWorkflow.c_nomTable + "." +
CTypeWorkflow.c_champId + "=@1", type.Id));
}
if (m_txtLabel.Text.Trim().Length > 0)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreDataAvance(CEtapeWorkflow.c_nomTable,
"(" + CEtapeWorkflow.c_champLibelle + " like @1) or (" +
CEtapeWorkflow.c_champLibelle + "=@2 and " +
CTypeEtapeWorkflow.c_nomTable + "." +
CTypeEtapeWorkflow.c_champLibelle + " like @1)",
"%" + m_txtLabel.Text.Trim() + "%", ""));
}
Filtre = filtre;
OnAppliqueFiltre(new object(), null);
}
public void Init(CActeur acteur, DateTime dateDebut, DateTime dateFin)
{
CWin32Traducteur.Translate(this);
m_bIsFilling = true;
m_panelControles.SuspendDrawing();
m_acteur = acteur;
foreach (Control ctrl in m_listeControlsUtiles)
{
ctrl.Visible = false;
((CControleSaisieUneActiviteActeur)ctrl).Activite = null;
}
///Préinitialise avec les valeurs planifiées
///comme ça, quand on clique sur check, la date est préinitialisée
m_dtDebutIntervention.Value = dateDebut;
m_dtFinIntervention.Value = dateFin;
TimeSpan sp = m_dtFinIntervention.Value - m_dtDebutIntervention.Value;
if (sp.TotalDays > 31)
{
CFormAlerte.Afficher(I.T("Display limited to 31 days|30189"), EFormAlerteType.Exclamation);
m_dtFinIntervention.Value = m_dtDebutIntervention.Value.AddDays(31);
}
m_listeControlesReserve.AddRange(m_listeControlsUtiles);
m_listeControlsUtiles.Clear();
CListeObjetsDonnees liste = acteur.Activites;
liste.Filtre = new CFiltreData(
CActiviteActeur.c_champDate + ">= @1 and " +
CActiviteActeur.c_champDate + " < @2",
m_dtDebutIntervention.Value.Date,
m_dtFinIntervention.Value.Date.AddDays(1).AddMinutes(-1));
if (m_gestionnaireModeEdition.ModeEdition)
{
liste.PreserveChanges = true;
}
int nIndex = 0;
foreach (CActiviteActeur activite in liste)
{
AddActivite(activite, ref nIndex, false);
}
if (m_listeControlsUtiles.Count == 0 && m_gestionnaireModeEdition.ModeEdition)
{
CControleSaisieUneActiviteActeur ctrl = GetNewControle(0);
ctrl.InitControle(null, 0, true);
}
ReordonneeTout();
m_bIsFilling = false;
//RecalcSize();
m_panelControles.ResumeDrawing();
Visible = true;
}
//-------------------------------------------------------------------------
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);
}
/// ///////////////////////////////////////////
public override object Invoke(object objetAppelle, params object[] parametres)
{
CEtapeWorkflow etape = objetAppelle as CEtapeWorkflow;
if (etape == null || parametres.Length > 0)
{
return(null);
}
List <CActeur> listeActeurs = new List <CActeur>();
List <IAffectableAEtape> listeAffectables = new List <IAffectableAEtape>(etape.Assignments);
foreach (IAffectableAEtape affectable in listeAffectables)
{
CActeur acteur = affectable as CActeur;
if (acteur != null)
{
listeActeurs.Add(acteur);
}
else
{
CGroupeActeur groupe = affectable as CGroupeActeur;
if (groupe != null)
{
foreach (CRelationActeur_GroupeActeur relation in groupe.RelationsActeur)
{
listeActeurs.Add(relation.Acteur);
}
}
else
{
CProfilUtilisateur profil = affectable as CProfilUtilisateur;
if (profil != null)
{
CListeObjetDonneeGenerique <CActeur> lstActeursDansProfil =
new CListeObjetDonneeGenerique <CActeur>(etape.ContexteDonnee);
lstActeursDansProfil.Filtre = new CFiltreDataAvance(
CActeur.c_nomTable,
CDonneesActeurUtilisateur.c_nomTable + "." +
CRelationUtilisateur_Profil.c_nomTable + "." +
CProfilUtilisateur.c_nomTable + "." +
CProfilUtilisateur.c_champId + " = @1",
profil.Id);
foreach (CActeur acteurProfil in lstActeursDansProfil)
{
listeActeurs.Add(acteurProfil);
}
}
}
}
}
return(listeActeurs.ToArray());
}
public void ModifieActeur(CActeur acteur)
{
acteur.ContexteDonnee.SetVersionDeTravail(m_nIdVersion, false);
acteur.BeginEdit();
Assert.AreEqual(acteur.ContexteDonnee.IdVersionDeTravail, m_nIdVersion);
foreach (CV valeur in m_valeurs)
{
acteur.Row[valeur.Champ] = valeur.Valeur;
}
Assert.IsTrue(acteur.CommitEdit());
}
//-------------------------------------------------------------------
/// <summary>
/// Indique si un acteur fait partie du groupe
/// </summary>
/// <param name="acteur"></param>
/// <returns>VRAI si l'Acteur est fait partie du groupe</returns>
public bool HasMembreActeur(CActeur acteur)
{
foreach (CRelationActeur_GroupeActeur rel in RelationsActeur)
{
if (rel.Acteur == acteur)
{
return(true);
}
}
return(false);
}
public void TentativeDeSupprimerUnElementUtiliseDansUneVersion()
{
ResetModifs();
CActeur acteur = ActeurReferentiel;
string strNom = "SUPP " + DateTime.Now.ToString();
SetSituation(new M(m_nIdsVersions[0], new CV(CActeur.c_champNom, strNom)));
m_contexteDonnee.SetVersionDeTravail(null, false);
Assert.IsFalse(acteur.CanDelete());
}
public static string[] GetCodesAffectationsEtapeConcernant(CContexteDonnee contexteDonnee)
{
CDonneesActeurUtilisateur user = GetUserForSession(contexteDonnee);
List <string> strCodes = new List <string>();
if (user != null)
{
CActeur acteur = user.Acteur;
strCodes.AddRange(acteur.GetListeCodesAffectationEtape());
}
return(strCodes.ToArray());
}
public void TestCalendrierTroisTranchesAvecRecouvrement()
{
try
{
CTimosTestMetierApp.SessionClient.BeginTrans();
using (CContexteDonnee contexte = new CContexteDonnee(CTimosTestMetierApp.SessionClient.IdSession, true, false))
{
// Création des tranches horaires
// Première tranche de Jour de 8h à 11 h
CHoraireJournalier_Tranche t1 = new CHoraireJournalier_Tranche(contexte);
t1.CreateNew();
t1.HoraireJournalier = (CHoraireJournalier)GetEntite(typeof(CHoraireJournalier), m_nIdHoraireJournalier, contexte);
t1.TypeOccupationHoraire = (CTypeOccupationHoraire)GetEntite(typeof(CTypeOccupationHoraire), m_nIdOccupationJour, contexte);
t1.HeureDebut = 8 * 60; // 8 heures
t1.HeureFin = 12 * 60; // 11 heures
Assert.IsTrue(t1.CommitEdit().Result);
// Deuxième tranche de Repos de 12h à 14 h
CHoraireJournalier_Tranche t2 = new CHoraireJournalier_Tranche(contexte);
t2.CreateNew();
t2.HoraireJournalier = (CHoraireJournalier)GetEntite(typeof(CHoraireJournalier), m_nIdHoraireJournalier, contexte);
t2.TypeOccupationHoraire = (CTypeOccupationHoraire)GetEntite(typeof(CTypeOccupationHoraire), m_nIdOccupationRepos, contexte);
t2.HeureDebut = 11 * 60; // 8 heures
t2.HeureFin = 15 * 60; // 11 heures
Assert.IsTrue(t2.CommitEdit().Result);
// Troisième tranche dont l'occupation est indéfinie de 15h à 19h
CHoraireJournalier_Tranche t3 = new CHoraireJournalier_Tranche(contexte);
t3.CreateNew();
t3.HoraireJournalier = (CHoraireJournalier)GetEntite(typeof(CHoraireJournalier), m_nIdHoraireJournalier, contexte);
t3.TypeOccupationHoraire = (CTypeOccupationHoraire)GetEntite(typeof(CTypeOccupationHoraire), m_nIdOccupationAstreinte, contexte);
t3.HeureDebut = 14 * 60; // 8 heures
t3.HeureFin = 19 * 60; // 11 heures
Assert.IsTrue(t3.CommitEdit().Result);
// On demande les Horaires à l'acteur de maintenant à demain même heure (24 heures)
CActeur acteur = (CActeur)GetEntite(typeof(CActeur), m_nIdActeur, contexte);
CTrancheHoraire[] listeTranches = acteur.GetHoraires(DateTime.Now.Date, DateTime.Now.Date.AddDays(1));
Assert.AreEqual(3, listeTranches.Length);
Assert.AreEqual(100, listeTranches[0].Priorite);
Assert.AreEqual(5, listeTranches[0].Duree);
Assert.AreEqual(50, listeTranches[1].Priorite);
Assert.AreEqual(4, listeTranches[1].Duree);
Assert.AreEqual(10, listeTranches[2].Priorite);
Assert.AreEqual(2, listeTranches[2].Duree);
}
}
finally
{
CTimosTestMetierApp.SessionClient.RollbackTrans();
}
}
//-------------------------------------------------------------------
public void FillContexte(CContexteFormNavigable ctx)
{
CActeur acteur = m_txtActeur.ElementSelectionne as CActeur;
ctx["FILTRE_ACTEUR"] = acteur != null ? (int?)acteur.Id : null;
CEtatEtapeWorkflow etat = m_cmbEtats.SelectedValue as CEtatEtapeWorkflow;
ctx["FILTRE_ETAT"] = etat;
CTypeWorkflow type = m_txtTypeWorkflow.ElementSelectionne as CTypeWorkflow;
ctx["FILTRE_TYPE_WKF"] = type != null ? (int?)type.Id : null;
ctx["FILTRE_LABEL"] = m_txtLabel.Text;
}
void itemActeur_Click(object sender, EventArgs e)
{
ToolStripMenuItem item = sender as ToolStripMenuItem;
CActeur acteur = item != null ? item.Tag as CActeur : null;
if (acteur != null)
{
if (Operation != null)
{
Operation.Acteur = acteur;
}
InitZoneActeur(acteur);
}
}
