void itemDocument_MouseUp(object sender, MouseEventArgs e)
{
ToolStripMenuItem item = sender as ToolStripMenuItem;
CDocumentGED document = item != null ? item.Tag as CDocumentGED : null;
if (document == null)
{
return;
}
if (LockEdition || !m_bAvecDelete)
{
if (document.IsNew())
{
return;
}
CTimosApp.Navigateur.EditeElement(document, false, "");
}
else
{
if (CFormAlerte.Afficher(I.T("Delete document @1?|20761", document.Libelle),
EFormAlerteBoutons.OuiNon, EFormAlerteType.Question) == DialogResult.Yes)
{
m_listeDocsToRemove.Add(document);
m_listeDocuments.Remove(document);
foreach (CNouveauDoc nouveau in m_listeNouveauxDocs.ToArray())
{
if (nouveau.Document == document)
{
m_listeNouveauxDocs.Remove(nouveau);
}
}
UpdateVisuel();
}
}
}
//--------------------------------------------------------------------
private void itemHistorique_Click(object sender, EventArgs e)
{
if (sender is CMenuItemAHistorique)
{
CHistoriqueDocumentGencod historique = ((CMenuItemAHistorique)sender).Historique;
CDocumentGED doc = new CDocumentGED(CSc2iWin32DataClient.ContexteCourant);
if (!doc.ReadIfExists(historique.IdDocumentGed))
{
CFormAlerte.Afficher(
I.T("The document|866") + " "
+ historique.LibelleDocument + " " +
I.T("does not exist any more|867"), EFormAlerteType.Erreur);
return;
}
doc.BeginEdit();
doc.AssocieA((CObjetDonneeAIdNumerique)m_objetForGED);
CResultAErreur result = doc.CommitEdit();
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
InitPanel();
}
}
//----------------------------------------------------------------------------------------------------
public CResultAErreur FillDataSet(DataSet ds)
{
CResultAErreur result = CResultAErreur.True;
if (m_caracteristic == null || CategorieGED == null)
{
return(result);
}
int nIdCategorie = CategorieGED.Id;
CDocumentGED[] listeGED = CDocumentGED.GetListeDocumentsForElement(m_caracteristic).ToArray <CDocumentGED>();
foreach (CDocumentGED ged in listeGED)
{
bool bOK = false;
foreach (CRelationDocumentGED_Categorie relCat in ged.RelationsCategories)
{
if (relCat.Categorie.Id == nIdCategorie)
{
bOK = true;
break;
}
}
if (bOK)
{
CFichierAttache fichier = new CFichierAttache(ds, ged);
fichier.DocumentId = m_caracteristic.Id;
}
}
return(result);
}
//-------------------------------------------------------------------------
private CResultAErreur MAJ_Modele()
{
CResultAErreur result = CResultAErreur.True;
if (m_proxyReport != null && m_proxyReport.HasChange())
{
result = m_proxyReport.UpdateGed();
if (result)
{
CDocumentGED doc = Rapport.DocumentGED;
if (doc == null)
{
doc = new CDocumentGED(Rapport.ContexteDonnee);
doc.CreateNewInCurrentContexte();
doc.Descriptif = "";
doc.DateCreation = DateTime.Now;
Rapport.DocumentGED = doc;
}
doc.Libelle = I.T("Report Model @1|30228", Rapport.Libelle);
doc.ReferenceDoc = (CReferenceDocument)result.Data;
doc.DateMAJ = DateTime.Now;
doc.NumVersion++;
doc.IsFichierSysteme = true;
}
}
return(result);
}
//----------------------------------------------------------------------
public CFormVisualisationRapport(CDocumentGED document, DataSet ds)
{
// Cet appel est requis par le Concepteur Windows Form.
InitializeComponent();
m_document = document;
m_dataset = ds;
}
private void InitPanelList(IObjetDonneeAIdNumerique element)
{
m_elementSelectionne = element;
if (element == null)
{
m_lnkDissocierElementEnCours.Visible = false;
m_lblDragExisting.Visible = false;
m_listeDocuments = new CListeObjetsDonnees(CSc2iWin32DataClient.ContexteCourant, typeof(CDocumentGED));
if (!m_chkTousDocuments.Checked)
{
m_labelElementSelectionne.Text = I.T("Documents not related to any Element|10331");
m_panelListDocumentsGED.FiltreDeBase = new CFiltreDataAvance(
CDocumentGED.c_nomTable,
"hasno(" + CRelationElementToDocument.c_nomTable + "." +
CRelationElementToDocument.c_champId + ")");
}
else
{
m_labelElementSelectionne.Text = I.T("All documents|10332");
m_panelListDocumentsGED.FiltreDeBase = null;
}
m_chkTousDocuments.Visible = true;
}
else
{
m_lnkDissocierElementEnCours.Visible = true;
m_lblDragExisting.Visible = true;
m_labelElementSelectionne.Text = element.DescriptionElement;
m_listeDocuments = CDocumentGED.GetListeDocumentsForElement(element);
m_panelListDocumentsGED.FiltreDeBase = CDocumentGED.GetListeDocumentsForElement(element).Filtre;
m_chkTousDocuments.Visible = false;
}
CFiltreData filtre = m_filtreCategories;
m_listeDocuments.FiltrePrincipal = CFiltreData.GetAndFiltre(m_listeDocuments.FiltrePrincipal, m_filtreCategories);
/*
*
* if (filtre != null)
* {
* m_panelListDocumentsGED.FiltreDeBase = CFiltreData.GetAndFiltre(
* m_panelListDocumentsGED.FiltreDeBase,
* filtreSpplementaire);
* }*/
m_panelListDocumentsGED.ControlFiltreStandard = new CPanelFiltreDocumentGed();
m_panelListDocumentsGED.InitFromListeObjets(
m_listeDocuments,
typeof(CDocumentGED),
typeof(CFormEditionDocumentGED),
null,
"");
m_panelListDocumentsGED.RemplirGrille();
}
private void UpdateVisuel()
{
m_picDocument.Visible = !m_wndDocuments.HideHeader;
this.SuspendDrawing();
bool bPreviewVisible = false;
if (m_listeDocuments.Count == 1 && m_wndDocuments.DisplayDocuments)
{
CDocumentGED doc = m_listeDocuments[0];
if (m_proxyVisu != null)
{
m_proxyVisu.Dispose();
m_proxyVisu = null;
}
m_proxyVisu = new CProxyGED(doc.ContexteDonnee.IdSession, doc.ReferenceDoc);
if (!m_proxyVisu.CopieFichierEnLocal())
{
m_proxyVisu.Dispose();
m_proxyVisu = null;
}
else
{
if (m_visualiseurGed.ShowDocument(m_proxyVisu.NomFichierLocal))
{
m_lblDocument.Visible = false;
m_visualiseurGed.Dock = DockStyle.Fill;
m_visualiseurGed.Visible = true;
bPreviewVisible = true;
}
}
}
if (!bPreviewVisible)
{
m_visualiseurGed.Visible = false;
m_lblDocument.Visible = true;
bool bShowLabel = m_listeDocuments.Count == 1 && m_listeDocuments[0].Libelle.Length > 0;
if (bShowLabel)
{
m_lblDocument.Text = m_listeDocuments[0].Libelle;
}
else
{
if (m_listeDocuments.Count == 0)
{
m_lblDocument.Text = I.T("No document|20758");
}
else
{
m_lblDocument.Text = I.T("@1 document(s)|20759", m_listeDocuments.Count.ToString());
}
}
}
this.ResumeDrawing();
}
//-------------------------------------------------------------------------
private void m_arbreCategories_DragDrop(object sender, DragEventArgs e)
{
if (DragDataHasDocGed(e.Data))
{
using (CContexteDonnee ctx = CSc2iWin32DataClient.ContexteCourant.GetContexteEdition())
{
bool bAddCategorie = (e.KeyState & 8) == 8;
TreeViewHitTestInfo info = m_arbreCategories.HitTest(m_arbreCategories.PointToClient(new Point(e.X, e.Y)));
TreeNode node = info.Node;
if (info != null && info.Node != null && m_arbreCategories.GetObjetInNode(info.Node) is CCategorieGED)
{
CCategorieGED categorie = m_arbreCategories.GetObjetInNode(info.Node) as CCategorieGED;
foreach (CReferenceObjetDonnee refDoc in (CReferenceObjetDonnee[])e.Data.GetData(typeof(CReferenceObjetDonnee[])))
{
CDocumentGED doc = refDoc.GetObjet(ctx) as CDocumentGED;
if (doc != null)
{
if (!bAddCategorie)//Supprime les anciennes catégories
{
CListeObjetsDonnees lst = doc.RelationsCategories;
CObjetDonneeAIdNumerique.Delete(lst, true);
}
bool bDedans = false;
foreach (CRelationDocumentGED_Categorie rel in doc.RelationsCategories)
{
if (rel.Categorie.Id == categorie.Id)
{
bDedans = true;
break;
}
}
if (!bDedans)
{
CRelationDocumentGED_Categorie newRel = new CRelationDocumentGED_Categorie(ctx);
newRel.CreateNewInCurrentContexte();
newRel.Categorie = categorie;
newRel.Document = doc;
}
}
}
}
CResultAErreur result = ctx.CommitEdit();
if (!result)
{
CFormAfficheErreur.Show(result.Erreur);
}
else
{
InitPanelList(m_elementSelectionne);
}
}
}
HightlightCategorie(null);
}
private CResultAErreur CopyToFtp(
int nIdSession,
CDocumentGED document,
string strNomFichierDest,
string strUser,
string strPassword)
{
CResultAErreur result = CResultAErreur.True;
if (!strNomFichierDest.ToUpper().StartsWith("FTP://"))
{
result.EmpileErreur(I.T("Bad file name '@1' for ftp transfert|20252", strNomFichierDest));
return(result);
}
try
{
using (CProxyGED proxy = new CProxyGED(nIdSession, document.ReferenceDoc))
{
result = proxy.CopieFichierEnLocal();
if (!result)
{
return(result);
}
FtpWebRequest req = (FtpWebRequest)WebRequest.Create(strNomFichierDest);
req.Method = WebRequestMethods.Ftp.UploadFile;
if (strUser.Length > 0 || strPassword.Length > 0)
{
req.Credentials = new NetworkCredential(strUser, strPassword);
}
FileStream reader = new FileStream(proxy.NomFichierLocal, FileMode.Open, FileAccess.Read);
byte[] buff = new byte[1024];
Stream requestStream = req.GetRequestStream();
int nSize = 0;
int nSizeTotal = 0;
while ((nSize = reader.Read(buff, 0, 1024)) > 0)
{
nSizeTotal += nSizeTotal;
requestStream.Write(buff, 0, nSize);
}
req.ContentLength = nSizeTotal;
requestStream.Close();
reader.Close();
FtpWebResponse reponse = (FtpWebResponse)req.GetResponse();
reponse.Close();
}
}
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_objetForGED == null)
{
if (!m_chkTousDocuments.Checked)
{
m_panelListe.FiltreDeBase = new CFiltreDataAvance(
CDocumentGED.c_nomTable,
/*"has("+CRelationDocumentGED_Categorie.c_nomTable+"."+
* CRelationDocumentGED_Categorie.c_champId+") and "+*/
"hasno(" + CRelationElementToDocument.c_nomTable + "." +
CRelationElementToDocument.c_champId + ")");
}
else
{
m_panelListe.FiltreDeBase = null;
}
m_chkTousDocuments.Visible = true;
}
else
{
m_chkTousDocuments.Visible = false;
m_panelListe.FiltreDeBase = CDocumentGED.GetListeDocumentsForElement(m_objetForGED).Filtre;
}
m_panelListe.ControlFiltreStandard = new CPanelFiltreDocumentGed();
m_panelListe.InitFromListeObjets(
m_listeObjets,
typeof(CDocumentGED),
typeof(CFormEditionDocumentGED),
null, "");
m_lnkDocRecent.Visible = m_objetForGED != null;
m_panelListe.RemplirGrille();
if (m_objetForGED == null)
{
m_lnkElement.Visible = false;
}
else
{
m_lnkElement.Visible = true;
m_lnkElement.Text = m_objetForGED.DescriptionElement;
}
}
private void DragDropFiles(string[] strFichiers, CObjetDonneeAIdNumerique objet, CCategorieGED categorie)
{
CContexteDonnee ctxAppli = CSc2iWin32DataClient.ContexteCourant;
using (CContexteDonnee contexte = ctxAppli.GetContexteEdition())
{
if (MessageBox.Show(m_lblInfoDragDrop.Text, "", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
foreach (string strFichier in strFichiers)
{
if (File.Exists(strFichier))
{
string strTitre = Path.GetFileName(strFichier);
string strExt = Path.GetExtension(strFichier);
if (strExt.Length > 0)
{
strTitre = strTitre.Remove(strTitre.Length - strExt.Length);
}
CDocumentGED document = new CDocumentGED(contexte);
document.CreateNewInCurrentContexte();
document.Libelle = strTitre;
if (objet != null)
{
document.AssocieA(objet);
}
if (categorie != null)
{
CRelationDocumentGED_Categorie rel = new CRelationDocumentGED_Categorie(contexte);
rel.CreateNewInCurrentContexte();
rel.Categorie = categorie;
rel.Document = document;
}
CTypeReferenceDocument typeRef = m_cmbModeStockage.SelectedValue as CTypeReferenceDocument;
if (typeRef == null)
{
typeRef = new CTypeReferenceDocument(CTypeReferenceDocument.TypesReference.Fichier);
}
CProxyGED proxy = new CProxyGED(contexte.IdSession, typeRef.Code);
proxy.AttacheToLocal(strFichier);
CResultAErreur result = proxy.UpdateGed();
document.ReferenceDoc = result.Data as CReferenceDocument;
}
}
contexte.CommitEdit();
Init(m_elementEdite);
}
}
m_lblInfoDragDrop.Visible = false;
}
//-------------------------------------------------------------------------
protected override CResultAErreur MAJ_Champs()
{
CResultAErreur result = base.MAJ_Champs();
if (!result)
{
return(result);
}
CConsultationAlarmesEnCours param = Consultation.Parametres;
param.FormuleFiltre = m_txtFormuleFiltre.Formule;
m_PanelListChampsExport.MajChamps();
param.ListeColonnes = m_PanelListChampsExport.ListeChamps;
param.DelaiMasquageTerminnees = (m_txtDelaiMasquage.Text.Length > 0)? Convert.ToInt32(m_txtDelaiMasquage.Text) :0;
Consultation.Parametres = param;
if (File.Exists(m_strNomFichierLocal))
{
Consultation.SoundFile = m_txtFichierSonnerie.Text;
CDocumentGED doc = Consultation.DocumentGEDSoundFile;
CProxyGED proxy = new CProxyGED(Consultation.ContexteDonnee.IdSession,
doc == null ? null : doc.ReferenceDoc);
proxy.AttacheToLocal(Consultation.SoundFile);
result = proxy.UpdateGed();
if (result)
{
if (doc == null)
{
doc = new CDocumentGED(Consultation.ContexteDonnee);
doc.CreateNewInCurrentContexte();
doc.Descriptif = "";
doc.DateCreation = DateTime.Now;
Consultation.DocumentGEDSoundFile = doc;
}
doc.Libelle = I.T("Alarm sound file|50065");
doc.ReferenceDoc = (CReferenceDocument)result.Data;
doc.DateMAJ = DateTime.Now;
doc.NumVersion++;
doc.IsFichierSysteme = true;
Consultation.DocumentGEDSoundFile = doc;
}
}
Consultation.ActiverEMail = m_chkActiver.Checked;
return(result);
}
//-----------------------------------------------------------------------------------
private CResultAErreur EnregistrePieceJointeEnGED(MessagePart pieceJointe)
{
CResultAErreur result = CResultAErreur.True;
if (pieceJointe != null && pieceJointe.IsAttachment)
{
int nIndex = pieceJointe.FileName.LastIndexOf(".");
string strExtension = "";
if (nIndex > 0)
{
strExtension = pieceJointe.FileName.Substring(nIndex + 1);
}
else
{
strExtension = "dat";
}
byte[] contenuPj = pieceJointe.Body;
Stream fluxPJ = new MemoryStream(contenuPj);
if (fluxPJ.Length == 0)
{
return(result);
}
CSourceDocument srcDoc = new CSourceDocumentStream(fluxPJ, strExtension);
CDocumentGED documentAttache = new CDocumentGED(ContexteDonnee);
documentAttache.CreateNewInCurrentContexte();
documentAttache.AssocieA(this);
documentAttache.Libelle = pieceJointe.FileName;
result = CDocumentGED.SaveDocument(
ContexteDonnee.IdSession,
srcDoc,
new CTypeReferenceDocument(CTypeReferenceDocument.TypesReference.Fichier),
null,
false);
srcDoc.Dispose();
if (!result)
{
return(result);
}
documentAttache.ReferenceDoc = result.Data as CReferenceDocument;
}
return(result);
}
//-------------------------------------------------------------------------------------
public static void AfficheAlarmes(CMemoryDb database, CParametrageAffichageListeAlarmes paramConsultation, CFormNavigateur nav)
{
CFormConsultationAlarmesEnCours form = new CFormConsultationAlarmesEnCours();
form.Text = paramConsultation.Libelle;
form.m_dataBase = database;
form.m_navigateur = nav;
form.TopMost = false;
CParametreAffichageListeAlarmes parametre = paramConsultation.ParametreAffichageAlarmes;
if (parametre == null)
{
parametre = CParametreAffichageListeAlarmes.ParametreParDefaut;
}
form.m_parametreAffichage = parametre;
CDocumentGED docSonnerie = paramConsultation.DocumentFichierSon;
if (docSonnerie != null && docSonnerie.ReferenceDoc != null)
{
CProxyGED proxySonnerie = new CProxyGED(paramConsultation.ContexteDonnee.IdSession, docSonnerie.ReferenceDoc);
if (proxySonnerie.CopieFichierEnLocal())
{
form.m_proxySonnerie = proxySonnerie;
}
else
{
proxySonnerie.Dispose();
proxySonnerie = null;
}
}
form.m_dicImages.Clear();
CListeObjetsDonnees listTypesAlarmes = new CListeObjetsDonnees(paramConsultation.ContexteDonnee, typeof(CTypeAlarme));
foreach (CTypeAlarme typeAlarme in listTypesAlarmes)
{
if (typeAlarme.Image != null)
{
form.m_dicImages.Add(typeAlarme.Id.ToString(), typeAlarme.Image);
}
}
form.Show();
}
public void Init(IObjetDonneeAIdNumerique element)
{
m_elementEdite = element;
m_cmbModeStockage.NullAutorise = false;
m_cmbModeStockage.ProprieteAffichee = "Libelle";
CDocumentGED dummyDoc = new CDocumentGED(CSc2iWin32DataClient.ContexteCourant);
m_cmbModeStockage.ListDonnees = dummyDoc.TypesAutorisesPourLesUtilisateurs;
m_cmbModeStockage.SelectedValue = dummyDoc.TypesAutorisesPourLesUtilisateurs[0];
m_panelModeStockage.Visible = dummyDoc.TypesAutorisesPourLesUtilisateurs.Length > 1;
ReactualiserArbre();
FillCategoriesForElement(m_elementEdite);
InitPanelList();
}
//--------------------------------------------------------------------------------
private void AddDoc(string strNomFichier, IEnumerable <CCategorieGED> lstCats)
{
CDocumentGED doc = new CDocumentGED(m_contexteDonnee);
doc.CreateNewInCurrentContexte();
doc.Libelle = Path.GetFileName(strNomFichier);
foreach (CObjetDonneeAIdNumerique objet in m_wndDocuments.GetListeAssociations(m_source))
{
doc.AssocieA(objet);
}
foreach (CCategorieGED categorie in lstCats)
{
doc.AddCategory(categorie);
}
C2iWndDocumentsGed.CInfoAffectationDocumentToGed info = new C2iWndDocumentsGed.CInfoAffectationDocumentToGed(strNomFichier, m_source);
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(info);
foreach (CAffectationsProprietes aff in m_wndDocuments.Affectations)
{
CResultAErreur result = CResultAErreur.True;
result.Data = true;
if (aff.FormuleCondition != null)
{
result = aff.FormuleCondition.Eval(ctx);
}
if (result && result.Data is bool && (bool)result.Data)
{
result = aff.AffecteProprietes(doc, info, m_fournisseurProprietes);
if (!result)
{
result.EmpileErreur(I.T("Some values cannot be assigned to EDM Document"));
CFormAfficheErreur.Show(result.Erreur);
}
}
}
CNouveauDoc nouveauDoc = new CNouveauDoc(doc, strNomFichier);
m_listeDocuments.Add(doc);
m_listeNouveauxDocs.Add(nouveauDoc);
UpdateVisuel();
}
public CFichierAttache(DataSet ds, CDocumentGED docGED)
{
m_doc_GED = docGED;
DataTable dt = ds.Tables[c_nomTable];
if (dt == null)
{
return;
}
DataRow row = dt.NewRow();
row[c_champKey] = docGED.Cle != "" ? docGED.Cle : docGED.IdUniversel;
row[c_champNomFichier] = docGED.Libelle;
row[c_champDateUpload] = docGED.DateCreation;
row[c_champDateDocument] = docGED.DateMAJ;
row[c_champCommentaire] = docGED.Descriptif;
row[c_champCheminTemporaire] = "";
m_row = row;
dt.Rows.Add(row);
}
//-------------------------------------------------------------------
public override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CDocumentGED doc = (CDocumentGED)objet;
///Stef, le 16/10/2009 : le nom d'un doc n'est plus unique
/*if (!CObjetDonneeAIdNumerique.IsUnique(doc, CDocumentGED.c_champLibelle, doc.Libelle))
* {
* result.EmpileErreur(I.T("Another document with this label already exist|114"));
* return result;
* }*/
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//--------------------------------------------------------------------------
private void m_lblDragExisting_DragDrop(object sender, DragEventArgs e)
{
if (m_elementEdite != null)
{
CReferenceObjetDonnee[] refs = e.Data.GetData(typeof(CReferenceObjetDonnee[])) as CReferenceObjetDonnee[];
CReferenceObjetDonnee ref1 = e.Data.GetData(typeof(CReferenceObjetDonnee)) as CReferenceObjetDonnee;
if (ref1 != null)
{
List <CReferenceObjetDonnee> lst = new List <CReferenceObjetDonnee>();
lst.Add(ref1);
refs = lst.ToArray();
}
CObjetDonneeAIdNumerique obj = m_elementEdite as CObjetDonneeAIdNumerique;
if (obj != null && refs != null)
{
using (CContexteDonnee ctx = new CContexteDonnee(obj.ContexteDonnee.IdSession, true, false))
{
obj = obj.GetObjetInContexte(ctx) as CObjetDonneeAIdNumerique;
foreach (CReferenceObjetDonnee refObj in refs)
{
CDocumentGED doc = refObj.GetObjet(ctx) as CDocumentGED;
if (doc != null)
{
doc.AssocieA(obj);
}
}
CResultAErreur result = ctx.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
else
{
Init(m_elementEdite);
}
}
}
}
}
/// ///////////////////////////////////////////
public override sc2i.common.CResultAErreur RunService(object parametre)
{
CResultAErreur result = CResultAErreur.True;
CActionCopieDocumentGed.CParametreCopierLocalDansGed parametreCopie = parametre as CActionCopieDocumentGed.CParametreCopierLocalDansGed;
if (parametreCopie == null)
{
result.EmpileErreur(I.T("Bad parameter value for service SetLocalFile|20125"));
return(result);
}
using (CContexteDonnee contexte = new CContexteDonnee(CTimosApp.SessionClient.IdSession, true, false))
{
CDocumentGED document = new CDocumentGED(contexte);
if (!document.ReadIfExists(parametreCopie.IdDocumentGed))
{
result.EmpileErreur(I.T("Document @1 doesn't exists|20126"));
return(result);
}
try
{
using (CProxyGED proxy = new CProxyGED(CTimosApp.SessionClient.IdSession, document.ReferenceDoc))
{
result = proxy.CopieFichierEnLocal();
if (!result)
{
return(result);
}
File.Copy(proxy.NomFichierLocal, parametreCopie.NomFichier, true);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
}
return(result);
}
private CResultAErreur ImportNode(TreeNode node, bool bOnlyNonFaits)
{
CResultAErreur result = CResultAErreur.True;
if (node != null && node.Tag is CRepertoire)
{
CRepertoire repertoire = node.Tag as CRepertoire;
if (!bOnlyNonFaits || !repertoire.ImportDone)
{
CProjet projetNominal = null;
if (m_dicNominalCodeToProjet.TryGetValue(repertoire.Nom, out projetNominal))
{
CImporteurGED importeur = new CImporteurGED();
projetNominal.BeginEdit();
CDocumentGED.DesactiverControleDocumentsALaSauvegarde(projetNominal.ContexteDonnee, true);
result = importeur.ImporteDossierProjet(
projetNominal,
repertoire,
"2014\\8\\IMPORT\\" + repertoire.Nom);
if (result)
{
result = projetNominal.CommitEdit();
}
Invoke((MethodInvoker) delegate
{
RefreshNode(node);
});
if (!result)
{
projetNominal.CancelEdit();
return(result);
}
}
}
}
return(result);
}
public CFormListeAlarmeEnCours(CConsultationAlarmesEnCoursInDb consultation, CFormNavigateur navigateur)
{
c_nBaseControleRetombee = 15000 / c_nTimeClignote;
List <string> strNomColonnes;
string st;
TimeSpan duree;
DateTime start, stop;
m_consultationEnCours = consultation;
m_navigateur = navigateur;
start = DateTime.Now;
InitializeComponent();
this.Text = consultation.Libelle;
m_timerVoyant.Enabled = true;
stop = DateTime.Now;
duree = stop - start; //test duree = 8 sec !!!!!!!
m_recepteurNotifications = new CRecepteurNotification(CSc2iWin32DataClient.ContexteCourant.IdSession, typeof(CDonneeNotificationAlarmes));
m_recepteurNotifications.OnReceiveNotification += new NotificationEventHandler(OnReceiveNotificationAlarmEnCours);
/* m_recepteurNotificationsStop = new CRecepteurNotification(CSc2iWin32DataClient.ContexteCourant.IdSession, typeof(CDonneeNotificationAlarmesStop));
* m_recepteurNotificationsStop.OnReceiveNotification += new NotificationEventHandler(OnReceiveNotificationStop);
*
* m_recepteurNotificationsMask = new CRecepteurNotification(CSc2iWin32DataClient.ContexteCourant.IdSession, typeof(CDonneeNotificationAlarmesMask));
* m_recepteurNotificationsMask.OnReceiveNotification += new NotificationEventHandler(OnReceiveNotificationMask);
*
* m_recepteurNotificationsAcknowledge = new CRecepteurNotification(CSc2iWin32DataClient.ContexteCourant.IdSession, typeof(CDonneeNotificationAlarmesAcknowledge));
* m_recepteurNotificationsAcknowledge.OnReceiveNotification += new NotificationEventHandler(OnReceiveNotificationAcknowledge);*/
List <CInfoAlarmeAffichee> lstEnCours = new List <CInfoAlarmeAffichee>();
List <CInfoAlarmeAffichee> lstRetombe = new List <CInfoAlarmeAffichee>();
m_lstViewEnCours.OnGetDonneesObjet += new GetDonneesLigneEventHandler(GetDonneesObjetEnCours);
m_lstViewRetombe.OnGetDonneesObjet += new GetDonneesLigneEventHandler(GetDonneesObjetRetombe);
m_lstViewEnCours.DoubleClick += new EventHandler(OnLstViewEnCoursDoubleClick);
m_lstViewRetombe.DoubleClick += new EventHandler(OnLstViewRetombeDoubleClick);
lstEnCours = GetAlarmsInfoFromDB();
strNomColonnes = m_consultationEnCours.Parametres.GetColumnNames();
m_lstViewEnCours.Init(strNomColonnes.ToArray(), lstEnCours.ToArray());
st = I.T("End date|60023");
strNomColonnes.Add(st);
st = I.T("Duration|60022");
strNomColonnes.Add(st);
m_lstViewRetombe.Init((string[])strNomColonnes.ToArray(), lstRetombe.ToArray());
m_strMaskAdminButtonText = I.T("Alarms masked by Administrator|60016") + " : ";
m_strMaskBrigButtonText = I.T("Alarms masked by Operating agent|60017") + " : ";
m_strFrequentButtonText = I.T("Current frequent alarms|60018") + " : ";
InitButtonsInfo();
MAJFrequentButtonText();
MAJAdminButtonText();
MAJBrigButtonText();
m_btnMaskedOnCreation.Text = I.T("Alarms masked on creation|60047") + " : " + m_NbMasqCreat.ToString();
label1.Text = I.T("Current alarms|60014");
label2.Text = I.T("Cleared alarms|60015");
CDocumentGED docSonnerie = consultation.DocumentGEDSoundFile;
if (docSonnerie != null && docSonnerie.ReferenceDoc != null)
{
m_proxySonnerie = new CProxyGED(consultation.ContexteDonnee.IdSession, docSonnerie.ReferenceDoc);
if (!m_proxySonnerie.CopieFichierEnLocal())
{
m_proxySonnerie.Dispose();
m_proxySonnerie = null;
}
}
//SetVoyantAlarme();
Type tpVar = GetType();
Type tpGeneric = typeof(List <>);
tpGeneric = tpGeneric.MakeGenericType(tpVar);
object liste = Activator.CreateInstance(tpGeneric);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CProxyGED proxy = null;
try
{
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(Process);
if (FormuleFichierSource == null)
{
result.EmpileErreur(I.T("Incorrect source file formula|506"));
return(result);
}
result = FormuleFichierSource.Eval(ctxEval);
if (!result)
{
return(result);
}
string strFichier = "";
if (result.Data is CDocumentGED)
{
CDocumentGED doc = result.Data as CDocumentGED;
proxy = new CProxyGED(contexte.IdSession, doc.ReferenceDoc);
result = proxy.CopieFichierEnLocal();
if (!result)
{
return(result);
}
strFichier = proxy.NomFichierLocal;
}
else
{
strFichier = result.Data.ToString();
}
if (!File.Exists(strFichier))
{
result.EmpileErreur(I.T("Source file @1 doesn't exist |508", result.Data.ToString()));
return(result);
}
if (FormuleTableAImporter == null)
{
result.EmpileErreur(I.T("Incorrect destination table formula|505"));
return(result);
}
result = FormuleTableAImporter.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluating destination table formula|510"));
return(result);
}
if (!(result.Data is CTableParametrable))
{
result.EmpileErreur(I.T("Destination table formula doesn't return a table|511"));
return(result);
}
CTableParametrable tableParametrable = (CTableParametrable)result.Data;
if (tableParametrable.TypeTable.ParametrageCSV == null)
{
result.EmpileErreur(I.T("Table type @1 doesn't contains import setup|20002", tableParametrable.TypeTable.Libelle));
return(result);
}
// Sélectionne le type de fichier Excel ou CSV (texte)
IParametreLectureFichier parametre;
int nPositionduPoint = strFichier.LastIndexOf('.');
string strExtension = strFichier.Substring(nPositionduPoint + 1, strFichier.Length - nPositionduPoint - 1);
if (strExtension.ToUpper() == "XLS" || strExtension.ToUpper() == "XLSX")
{
parametre = tableParametrable.TypeTable.ParametrageXLS;
}
else
{
parametre = tableParametrable.TypeTable.ParametrageCSV;
}
result = parametre.LectureFichier(strFichier);
if (!result || !(result.Data is DataTable))
{
result.EmpileErreur(I.T("Error while reading text file|509"));
return(result);
}
DataTable tableSource = (DataTable)result.Data;
Dictionary <DataColumn, CColonneTableParametrable> mappage = new Dictionary <DataColumn, CColonneTableParametrable>();
int nNbChamps = Math.Min(parametre.Mappage.StringsA.Count, parametre.Mappage.StringsB.Count);
for (int nChamp = 0; nChamp < nNbChamps; nChamp++)
{
DataColumn col = tableSource.Columns[parametre.Mappage.StringsA[nChamp]];
if (col != null)
{
CColonneTableParametrable colRetenue = null;
foreach (CColonneTableParametrable colonne in tableParametrable.TypeTable.Colonnes)
{
if (colonne.Libelle == parametre.Mappage.StringsB[nChamp])
{
colRetenue = colonne;
break;
}
}
if (colRetenue != null)
{
mappage[col] = colRetenue;
}
}
}
// Réalise l'import
result = tableParametrable.ImportTable(tableSource, mappage, m_modeImport);
if (!result)
{
return(result);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (proxy != null)
{
proxy.Dispose();
}
}
return(result);
}
/// ////////////////////////////////////////////////////////////////
public CResultAErreur SendMail(CMailSC2I mail)
{
CResultAErreur result = CResultAErreur.True;
MailMessage message = new MailMessage();
message.From = new MailAddress(mail.Expediteur);
message.Subject = mail.Sujet;
message.Body = mail.Message;
message.IsBodyHtml = mail.IsFormatHTML;
// Destinataires To
if (mail.Destinataires != null)
{
foreach (string strDest in mail.Destinataires)
{
message.To.Add(new MailAddress(strDest));
}
}
// Destinataires CC
if (mail.DestinatairesCC != null)
{
foreach (string strDest in mail.DestinatairesCC)
{
message.CC.Add(new MailAddress(strDest));
}
}
// Destinataires BCC
if (mail.DestinatairesBCC != null)
{
foreach (string strDest in mail.DestinatairesBCC)
{
message.Bcc.Add(new MailAddress(strDest));
}
}
ArrayList lstProxy = new ArrayList();
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
foreach (int nIdDoc in mail.DocumentsGED)
{
CDocumentGED doc = new CDocumentGED(contexte);
if (doc.ReadIfExists(nIdDoc) && doc.ReferenceDoc != null)
{
CProxyGED proxy = new CProxyGED(IdSession, doc.ReferenceDoc);
// Ajouter un paramètre optionnel CopieFichierEnLocal(doc.Libelle)
if (proxy.CopieFichierEnLocal(mail.UseDocLabelAsFileName ? doc.Libelle : ""))
{
lstProxy.Add(proxy);
Attachment att = new Attachment(proxy.NomFichierLocal);
message.Attachments.Add(att);
}
}
}
}
try
{
string strServeur = "";
string strUser = "";
string strPass = "";
int nPort = 0;
if (mail.SMTPServer != String.Empty)
{
strServeur = mail.SMTPServer;
nPort = mail.SMTPPort;
strUser = mail.SMTPUser;
strPass = mail.SMTPPassword;
}
else
{
strServeur = CTimosServeurRegistre.SMTPServer;
nPort = CTimosServeurRegistre.SMTPPort;
strUser = CTimosServeurRegistre.SMTPUser;
strPass = CTimosServeurRegistre.SMTPPassword;
}
using (SmtpClient clientSmtp = new SmtpClient())
{
clientSmtp.Host = strServeur;
if (nPort > 0)
{
clientSmtp.Port = nPort;
}
if (strUser != "" || strPass != "")
{
clientSmtp.Credentials = new NetworkCredential(strUser, strPass);
}
else
{
clientSmtp.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
}
clientSmtp.Send(message);
}
}
catch (Exception e)
{
result.EmpileErreur(e.ToString());
result.EmpileErreur(I.T("Error while sending mail|30000"));
}
finally
{
message.Dispose();
}
foreach (CProxyGED proxy in lstProxy)
{
proxy.Dispose();
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceSelectMultiForGed);
CServiceSurClient serviceGetFile = sessionClient.GetServiceSurClient(CActionCopierLocalDansGed.c_idServiceClientGetFichier);
if (service != null && serviceGetFile != null)
{
sponsor.Register(service);
sponsor.Register(serviceGetFile);
//Calcule la liste des ids de catégories à gérer
List <int> lstIds = new List <int>();
if (FormuleListeCategories != null)
{
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = FormuleListeCategories.Eval(contexteEval);
if (!result)
{
return(result);
}
IEnumerable lst = result.Data as IEnumerable;
if (lst != null)
{
foreach (object obj in lst)
{
if (obj is int)
{
lstIds.Add((int)obj);
}
if (obj is CCategorieGED)
{
lstIds.Add(((CCategorieGED)obj).Id);
}
}
}
}
result = service.RunService(lstIds);
if (result && result.Data is IEnumerable)
{
List <CDocumentGED> lstDocs = new List <CDocumentGED>();
foreach (object obj in (IEnumerable)result.Data)
{
CInfoFichierToGed info = obj as CInfoFichierToGed;
if (info != null)
{
string strContenu = info.FileFullName;
CSourceDocument sourceDoc = null;
result = serviceGetFile.RunService(strContenu);
if (!result)
{
return(result);
}
sourceDoc = result.Data as CSourceDocument;
if (sourceDoc == null)
{
result.EmpileErreur(I.T("Error while retrieving file @1|20020", strContenu));
return(result);
}
//On a notre fichier en local, création du document
string strCle = "";
string strLibelle = "";
info.ActiveProcess = contexte.Branche.Process;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(info);
if (FormuleCle != null)
{
result = FormuleCle.Eval(ctxEval);
if (result && result.Data != null)
{
strCle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document key could not be computed|30050"));
return(result);
}
}
if (FormuleLibelleDocument != null)
{
result = FormuleLibelleDocument.Eval(ctxEval);
if (result && result.Data != null)
{
strLibelle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document label could not be computed|30051"));
return(result);
}
}
if (strLibelle.Length == 0)
{
strLibelle = info.FileName;
}
CObjetDonneeAIdNumerique associeA = null;
if (FormuleElementAssocie != null)
{
result = FormuleElementAssocie.Eval(ctxEval);
if (result)
{
associeA = result.Data as CObjetDonneeAIdNumerique;
}
}
CDocumentGED doc = new CDocumentGED(contexte.ContexteDonnee);
//Si la clé n'est pas nulle, cherche un document avec cette clé
if (strCle.Trim() != "")
{
CFiltreData filtre = new CFiltreData(CDocumentGED.c_champCle + "=@1", strCle);
if (!doc.ReadIfExists(filtre))
{
doc.CreateNew();
}
else
{
doc.BeginEdit();
}
}
else
{
doc.CreateNew();
}
doc.Libelle = strLibelle;
doc.Cle = strCle;
ArrayList lstToCreate = new ArrayList();
lstToCreate.Add(info.EDMCategoryId);
ArrayList lstToDelete = new ArrayList();
//Affecte les catégories
CListeObjetsDonnees listeCategoriesExistantes = CRelationDocumentGED_Categorie.GetRelationsCategoriesForDocument(doc);
foreach (CRelationDocumentGED_Categorie rel in listeCategoriesExistantes)
{
if (!lstToCreate.Contains(rel.Categorie.Id))
{
lstToDelete.Add(rel);
}
lstToCreate.Remove(rel.Categorie.Id);
}
foreach (CRelationDocumentGED_Categorie rel in lstToDelete)
{
rel.Delete();
}
foreach (int nId in lstToCreate)
{
CCategorieGED cat = new CCategorieGED(doc.ContexteDonnee);
if (cat.ReadIfExists(nId))
{
CRelationDocumentGED_Categorie rel = new CRelationDocumentGED_Categorie(doc.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.Categorie = cat;
rel.Document = doc;
}
}
result = CDocumentGED.SaveDocument(contexte.IdSession, sourceDoc, sourceDoc.TypeReference, doc.ReferenceDoc, true);
if (!result)
{
return(result);
}
CReferenceDocument refDoc = result.Data as CReferenceDocument;
doc.ReferenceDoc = refDoc;
if (associeA != null)
{
doc.AssocieA(associeA);
}
result = doc.CommitEdit();
if (!result)
{
return(result);
}
lstDocs.Add(doc);
}
}
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, lstDocs.ToArray());
}
return(result);
}
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientGetFichier);
CParametresCopierLocalDansGed parametreService = new CParametresCopierLocalDansGed();
CFichierLocalTemporaire fichierLocal = null;
FileStream localStream = null;
if (service != null)
{
sponsor.Register(service);
//Calcule le contenu
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
result = ExpressionContenu.Eval(contexteEval);
if (!result)
{
return(result);
}
parametreService.NomFichierLocal = result.Data as string;
if (ExpressionUser != null && (result = ExpressionUser.Eval(contexteEval)))
{
if (result.Data != null)
{
parametreService.User = result.Data.ToString();
}
}
if (ExpressionPassword != null && (result = ExpressionPassword.Eval(contexteEval)))
{
if (result.Data != null)
{
parametreService.Password = result.Data.ToString();
}
}
CSourceDocument sourceDoc = null;
if (parametreService.NomFichierLocal.ToUpper().StartsWith("FTP://"))
{
CResultAErreurType <CFichierLocalTemporaire> resFic = GetFileFromFtp(
parametreService);
if (!resFic)
{
result.EmpileErreur(resFic.Erreur);
return(result);
}
fichierLocal = resFic.DataType;
localStream = new FileStream(fichierLocal.NomFichier, FileMode.Open, FileAccess.Read);
sourceDoc = new CSourceDocumentStream(localStream, "txt");
}
else if (!m_bCreerFichierTexteAPartirDeLaFormuleContenu)
{
result = service.RunService(parametreService);
if (!result)
{
return(result);
}
sourceDoc = result.Data as CSourceDocument;
if (sourceDoc == null)
{
result.EmpileErreur(I.T("Error while retrieving file @1|20020", parametreService.NomFichierLocal));
return(result);
}
}
else
{
fichierLocal = new CFichierLocalTemporaire("txt");
localStream = new FileStream(fichierLocal.NomFichier, FileMode.CreateNew, FileAccess.Write);
StreamWriter writer = new StreamWriter(localStream);
writer.Write(parametreService.NomFichierLocal);
writer.Close();
localStream.Close();
localStream = new FileStream(fichierLocal.NomFichier, FileMode.Open, FileAccess.Read);
sourceDoc = new CSourceDocumentStream(localStream, "txt");
}
//On a notre fichier en local, création du document
string strCle = "";
string strDescriptif = "";
string strLibelle = "";
result = ExpressionCle.Eval(contexteEval);
if (result)
{
strCle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document key could not be computed|30050"));
return(result);
}
result = ExpressionLibelle.Eval(contexteEval);
if (result)
{
strLibelle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document label could not be computed|30051"));
return(result);
}
result = ExpressionDescriptif.Eval(contexteEval);
if (result)
{
strDescriptif = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document description could not be computed|30052"));
return(result);
}
CDocumentGED doc = new CDocumentGED(contexte.ContexteDonnee);
//Si la clé n'est pas nulle, cherche un document avec cette clé
if (strCle.Trim() != "")
{
CFiltreData filtre = new CFiltreData(CDocumentGED.c_champCle + "=@1", strCle);
if (!doc.ReadIfExists(filtre))
{
doc.CreateNew();
}
else
{
doc.BeginEdit();
}
}
else
{
doc.CreateNew();
}
doc.Libelle = strLibelle;
doc.Descriptif = strDescriptif;
doc.Cle = strCle;
List <CDbKey> lstToCreate = new List <CDbKey>(ListeDbKeysCategoriesStockage);
List <CRelationDocumentGED_Categorie> lstToDelete = new List <CRelationDocumentGED_Categorie>();
//Affecte les catégories
CListeObjetsDonnees listeCategoriesExistantes = CRelationDocumentGED_Categorie.GetRelationsCategoriesForDocument(doc);
foreach (CRelationDocumentGED_Categorie rel in listeCategoriesExistantes)
{
if (!lstToCreate.Contains(rel.Categorie.DbKey))
{
lstToDelete.Add(rel);
}
lstToCreate.Remove(rel.Categorie.DbKey);
}
foreach (CRelationDocumentGED_Categorie rel in lstToDelete)
{
rel.Delete();
}
foreach (CDbKey dbKey in lstToCreate)
{
CCategorieGED cat = new CCategorieGED(doc.ContexteDonnee);
if (cat.ReadIfExists(dbKey))
{
CRelationDocumentGED_Categorie rel = new CRelationDocumentGED_Categorie(doc.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.Categorie = cat;
rel.Document = doc;
}
}
result = CDocumentGED.SaveDocument(contexte.IdSession, sourceDoc, sourceDoc.TypeReference, doc.ReferenceDoc, true);
if (sourceDoc != null)
{
sourceDoc.Dispose();
}
if (localStream != null)
{
localStream.Dispose();
}
if (fichierLocal != null)
{
fichierLocal.Dispose();
}
if (!result)
{
return(result);
}
CReferenceDocument refDoc = result.Data as CReferenceDocument;
doc.ReferenceDoc = refDoc;
result = doc.CommitEdit();
if (!result)
{
return(result);
}
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, doc);
}
return(result);
}
}
}
}
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
try
{
// Récupère la structure par formule ou structure propore
m_structureUtiliseeAExecution = StructureExport;
IVariableDynamique variableProcess = AssureVariableProcessDansStructure();
m_structureUtiliseeAExecution.SetValeurChamp(variableProcess.IdVariable, Process);
m_structureUtiliseeAExecution.ContexteDonnee = contexte.ContexteDonnee;
// Si la structure possede un formulaire il faut lancer le service sur le poste client
if (m_structureUtiliseeAExecution != null && m_structureUtiliseeAExecution.Formulaire != null && m_structureUtiliseeAExecution.Formulaire.Childs.Length > 0)
{
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (sessionClient != null)
{
//TESTDBKEYOK
if (sessionClient.GetInfoUtilisateur().KeyUtilisateur == contexte.Branche.KeyUtilisateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
CServiceSurClient service = sessionClient.GetServiceSurClient(c_idServiceClientExporterDonnees);
if (service != null)
{
sponsor.Register(service);
result = service.RunService(this);
E2iDialogResult dResult = (E2iDialogResult)result.Data;
if (dResult == E2iDialogResult.Cancel)
{
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienFromDialog &&
((CLienFromDialog)lien).ResultAssocie == dResult)
{
result.Data = lien;
return(result);
}
}
}
}
else
{
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
}
}
}
}
else
{
//Utilisateur pas accessible
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienUtilisateurAbsent)
{
result.Data = lien;
return(result);
}
}
}
}
result = m_structureUtiliseeAExecution.GetDataSet(Exporteur.ExporteStructureOnly);
if (!result)
{
result.EmpileErreur(I.T("Error while exporting data|405"));
return(result);
}
DataSet ds = (DataSet)result.Data;
// Fichier d'export retourné
CFichierLocalTemporaire fichierExport = new CFichierLocalTemporaire(Exporteur.ExtensionParDefaut);
fichierExport.CreateNewFichier();
CDestinationExportFile dest = new CDestinationExportFile(fichierExport.NomFichier);
result = Exporteur.Export(ds, dest);
if (!result)
{
result.EmpileErreur(I.T("Error while creating export file|406"));
return(result);
}
#region Stockage dans la ged
CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(Process);
//On a notre fichier export, création du document
string strCle = "";
string strDescriptif = "";
string strLibelle = "";
result = ExpressionCle.Eval(contexteEvaluation);
if (result)
{
strCle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("The document key could not be calculated|407"));
return(result);
}
result = ExpressionLibelle.Eval(contexteEvaluation);
if (result)
{
strLibelle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("The document label could not be calculated|408"));
return(result);
}
result = ExpressionDescriptif.Eval(contexteEvaluation);
if (result)
{
strDescriptif = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("The document description could not be calculated|409"));
return(result);
}
CDocumentGED doc = new CDocumentGED(contexte.ContexteDonnee);
//Si la clé n'est pas nulle, cherche un document avec cette clé
if (strCle.Trim() != "")
{
CFiltreData filtre = new CFiltreData(CDocumentGED.c_champCle + "=@1", strCle);
if (!doc.ReadIfExists(filtre))
{
doc.CreateNew();
}
else
{
doc.BeginEdit();
}
}
else
{
doc.CreateNew();
}
doc.Libelle = strLibelle;
doc.Descriptif = strDescriptif;
doc.Cle = strCle;
ArrayList lstToCreate = (ArrayList)ListeIdsCategoriesStockage.Clone();
ArrayList lstToDelete = new ArrayList();
//Affecte les catégories
CListeObjetsDonnees listeCategoriesExistantes = CRelationDocumentGED_Categorie.GetRelationsCategoriesForDocument(doc);
foreach (CRelationDocumentGED_Categorie rel in listeCategoriesExistantes)
{
if (!lstToCreate.Contains(rel.Categorie.Id))
{
lstToDelete.Add(rel);
}
lstToCreate.Remove(rel.Categorie.Id);
}
foreach (CRelationDocumentGED_Categorie rel in lstToDelete)
{
rel.Delete();
}
foreach (int nId in lstToCreate)
{
CCategorieGED cat = new CCategorieGED(doc.ContexteDonnee);
if (cat.ReadIfExists(nId))
{
CRelationDocumentGED_Categorie rel = new CRelationDocumentGED_Categorie(doc.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.Categorie = cat;
rel.Document = doc;
}
}
CProxyGED proxy = new CProxyGED(Process.IdSession, doc.IsNew() ? null : doc.ReferenceDoc);
proxy.AttacheToLocal(fichierExport.NomFichier);
result = proxy.UpdateGed();
if (!result)
{
return(result);
}
doc.ReferenceDoc = (CReferenceDocument)result.Data;
result = doc.CommitEdit();
fichierExport.Dispose();
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, doc);
}
#endregion
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienFromDialog &&
((CLienFromDialog)lien).ResultAssocie != E2iDialogResult.Cancel)
{
result.Data = lien;
return(result);
}
}
result.Data = null;
return(result);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
//Préparation du filtre
C2iRapportCrystal rapport = new C2iRapportCrystal(contexte.ContexteDonnee);
if (!rapport.ReadIfExists(IdEtatCrystal))
{
result.EmpileErreur(I.T("The report @1 does not exist|30046", IdEtatCrystal.ToString()));
return(result);
}
CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(Process);
CMultiStructureExport multiStructure = rapport.MultiStructure;
if (multiStructure == null)
{
result.EmpileErreur(I.T("The report does not have a data structure|30044"));
return(result);
}
foreach (IVariableDynamique variable in multiStructure.ListeVariables)
{
if (variable.IsChoixUtilisateur())
{
C2iExpression expressionVariable = GetExpressionForVariableFiltre(variable.IdVariable);
if (expressionVariable != null)
{
result = expressionVariable.Eval(contexteEvaluation);
if (!result)
{
result.EmpileErreur(I.T("Error in variable '@1' assignment|30047", variable.Nom));
return(result);
}
multiStructure.SetValeurChamp(variable, result.Data);
}
}
}
ReportDocument report = null;
try
{
result = rapport.CreateFichierExport(multiStructure, m_formatExport, ref report);
if (!result)
{
result.EmpileErreur(I.T("Error while creating the report|30048"));
return(result);
}
CFichierLocalTemporaire fichierPDF = (CFichierLocalTemporaire)result.Data;
#region Impression de l'état
if (m_bImprimerEtat)
{
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
CConfigurationsImpression configuration = sessionClient.ConfigurationsImpression;
if (configuration.NomImprimanteSurServeur != "")
{
report.PrintOptions.PrinterName = configuration.NomImprimanteSurServeur;
}
try
{
report.PrintToPrinter(1, false, 0, 0);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Printing error|30049"));
return(result);
}
/*if ( sessionClient != null )
* {
* if ( sessionClient.GetInfoUtilisateur().IdUtilisateur == contexte.Branche.IdUtilisateur )
* {
* if ( sessionClient.ConfigurationsImpression.NomImprimanteSurClient != "" )
* report.PrintOptions.PrinterName = sessionClient.ConfigurationsImpression.NomImprimanteSurClient;
* CServiceSurClient service = sessionClient.GetServiceSurClient ( CActionImprimerEtat.c_idServiceClientImprimerEtat );
* if ( service != null )
* {
* result = service.RunService ( report );
* }
* }
* }*/
/*
* using ( CFichierLocalTemporaire fichierRpt = new CFichierLocalTemporaire("rpt") )
* {
* fichierRpt.CreateNewFichier();
* try
* {
* report.Refresh();
* report.SaveAs (fichierRpt.NomFichier, ReportFileFormat.VSNetFileFormat );
* }
* catch ( Exception e )
* {
* result.EmpileErreur ( new CErreurException ( e ) );
* }
* if ( result )
* {
* //Stocke le fichier dans la ged pour pouvoir l'envoyer sur le client
* using ( CProxyGED proxy = new CProxyGED ( Process.IdSession, null ) )
* {
* proxy.CreateNewFichier();
* proxy.AttacheToLocal ( fichierRpt.NomFichier );
*
* proxy.UpdateGed();
*
* CReferenceDocument refDoc = proxy.ReferenceAttachee;
* result = service.RunService ( refDoc );
* if ( !result )
* {
* result.EmpileErreur("Erreur à l'impression du document");
* return result;
* }
* }
* }
* }
* }
* }
* }*/
}
#endregion
#region Stockage dans la ged
if (m_bStockerGed)
{
//On a notre fichier PDF, création du document
string strCle = "";
string strDescriptif = "";
string strLibelle = "";
result = ExpressionCle.Eval(contexteEvaluation);
if (result)
{
strCle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document key could not be evaluated|30050"));
return(result);
}
result = ExpressionLibelle.Eval(contexteEvaluation);
if (result)
{
strLibelle = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document label could not be evaluated|30051"));
return(result);
}
result = ExpressionDescriptif.Eval(contexteEvaluation);
if (result)
{
strDescriptif = result.Data.ToString();
}
else
{
result.EmpileErreur(I.T("Document description could not be evaluated|30052"));
return(result);
}
CDocumentGED doc = new CDocumentGED(contexte.ContexteDonnee);
//Si la clé n'est pas nulle, cherche un document avec cette clé
if (strCle.Trim() != "")
{
CFiltreData filtre = new CFiltreData(CDocumentGED.c_champCle + "=@1", strCle);
if (!doc.ReadIfExists(filtre))
{
doc.CreateNew();
}
else
{
doc.BeginEdit();
}
}
else
{
doc.CreateNew();
}
doc.Libelle = strLibelle;
doc.Descriptif = strDescriptif;
doc.Cle = strCle;
ArrayList lstToCreate = (ArrayList)ListeIdsCategoriesStockage.Clone();
ArrayList lstToDelete = new ArrayList();
//Affecte les catégories
CListeObjetsDonnees listeCategoriesExistantes = CRelationDocumentGED_Categorie.GetRelationsCategoriesForDocument(doc);
foreach (CRelationDocumentGED_Categorie rel in listeCategoriesExistantes)
{
if (!lstToCreate.Contains(rel.Categorie.Id))
{
lstToDelete.Add(rel);
}
lstToCreate.Remove(rel.Categorie.Id);
}
foreach (CRelationDocumentGED_Categorie rel in lstToDelete)
{
rel.Delete();
}
foreach (int nId in lstToCreate)
{
CCategorieGED cat = new CCategorieGED(doc.ContexteDonnee);
if (cat.ReadIfExists(nId))
{
CRelationDocumentGED_Categorie rel = new CRelationDocumentGED_Categorie(doc.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.Categorie = cat;
rel.Document = doc;
}
}
CProxyGED proxy = new CProxyGED(Process.IdSession, doc.IsNew()?null:doc.ReferenceDoc);
proxy.AttacheToLocal(fichierPDF.NomFichier);
result = proxy.UpdateGed();
if (!result)
{
return(result);
}
doc.ReferenceDoc = (CReferenceDocument)result.Data;
result = doc.CommitEdit();
fichierPDF.Dispose();
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, doc);
}
}
#endregion
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (report != null)
{
report.Close();
}
}
return(result);
}
//----------------------------------------------------------------------------------
private void InitAffectations(CDocumentGED document)
{
}
//-------------------------------------------
public CNouveauDoc(CDocumentGED document, string strNomFichier)
{
Document = document;
NomFichier = strNomFichier;
}
