//----------------------------------------------------------------------
private void CFormVisualisationRapport_Load(object sender, System.EventArgs e)
{
if (m_document != null)
{
ReportDocument doc = new ReportDocument();
m_proxyGED = new CProxyGED(m_document.ContexteDonnee.IdSession, m_document.ReferenceDoc);
if (!m_proxyGED.IsFichierRappatrie())
{
CResultAErreur result = m_proxyGED.CopieFichierEnLocal();
if (!result)
{
return;
}
}
doc.Load(m_proxyGED.NomFichierLocal);
doc.Refresh();
doc.SetDataSource(m_dataset);
m_viewer.ReportSource = doc;
return;
}
if (!m_bRapportLoadInViewer)
{
m_lblReport.Text = "";
if (m_rapport == null)
{
return;
}
m_lblReport.Text = m_rapport.Libelle;
try
{
m_proxyGED = new CProxyGED(m_rapport.ContexteDonnee.IdSession, m_rapport.DocumentGED.ReferenceDoc);
}
catch
{
CFormAlerte.Afficher(I.T("The Report model is not defined|1008"), EFormAlerteType.Erreur);
return;
}
CResultAErreur result = m_proxyGED.CopieFichierEnLocal();
if (!result)
{
return;
}
m_viewer.DisplayGroupTree = false;
ChargerPanelFiltre();
if (!m_panelFiltre.Visible)
{
Filtrer();
}
m_bRapportLoadInViewer = true;
}
}
//-------------------------------------------------------------------------
protected override CResultAErreur MyInitChamps()
{
CResultAErreur result = base.MyInitChamps();
if (!result)
{
return(result);
}
result = InitComboBoxCategorie(false);
if (result)
{
result = InitComboBoxStructure(false);
}
if (!result)
{
return(result);
}
m_cmbCategorie.SelectedValue = Rapport.CategorieRapport;
m_cmbModeleStructure.ElementSelectionne = Rapport.ModeleDonnees;
AffecterTitre(I.T("Crystal Report|469") + " " + Rapport.Libelle);
if (m_proxyReport != null)
{
m_proxyReport.Dispose();
m_proxyReport = null;
}
if (Rapport.DocumentGED != null)
{
m_proxyReport = new CProxyGED(Rapport.ContexteDonnee.IdSession, Rapport.DocumentGED.ReferenceDoc);
}
else
{
m_proxyReport = new CProxyGED(Rapport.ContexteDonnee.IdSession, null);
m_proxyReport.CreateNewFichier();
}
if (Rapport.MultiStructure != null)
{
m_panelMultiStructure.Init(Rapport.MultiStructure);
}
else
{
m_panelMultiStructure.Init(new CMultiStructureExport(Rapport.ContexteDonnee));
}
UpdateDispoControles();
return(result);
}
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 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);
}
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);
}
//-------------------------------------------------------------------------------------
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 CResultAErreur MajChamps()
{
CResultAErreur result = CResultAErreur.True;
foreach (CNouveauDoc nouveau in m_listeNouveauxDocs.ToArray())
{
CProxyGED proxy = new CProxyGED(nouveau.Document.ContexteDonnee.IdSession, CTypeReferenceDocument.TypesReference.Fichier);
proxy.AttacheToLocal(nouveau.NomFichier);
result = proxy.UpdateGed();
if (!result)
{
return(result);
}
CReferenceDocument refDoc = result.Data as CReferenceDocument;
nouveau.Document.ReferenceDoc = refDoc;
m_listeNouveauxDocs.Remove(nouveau);
}
foreach (CDocumentGED doc in m_listeDocsToRemove)
{
doc.Delete(true);
}
return(result);
}
/// ///////////////////////////////////////////
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);
}
/// ////////////////////////////////////////////////////////
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);
}
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);
}
/// ////////////////////////////////////////////////////////////////
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 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;
if (ExpressionListeDocuments == null)
{
result.EmpileErreur(I.T("Document list formula is null|20051"));
return(result);
}
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(contexte.Branche.Process);
result = ExpressionListeDocuments.Eval(contexteEval);
if (!result)
{
return(result);
}
IEnumerable enDocs = result.Data as IEnumerable;
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);
}
if (enDocs == null)
{
result.EmpileErreur(I.T("Document list formul returns an incorrect value|20052"));
return(result);
}
List <CDocumentGED> lstDocs = new List <CDocumentGED>();
try
{
foreach (CDocumentGED doc in enDocs)
{
if (doc.Cle != strCle)
{
lstDocs.Add(doc);
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in document list|20053"));
}
MemoryStream stream = new MemoryStream();
ZipOutputStream zipStream = new ZipOutputStream(stream);
zipStream.SetLevel(9);
HashSet <string> lstNomsDocuments = new HashSet <string>();
foreach (CDocumentGED doc in lstDocs)
{
CContexteEvaluationExpression ctxDoc = new CContexteEvaluationExpression(doc);
string strNomFichier = "";
if (ExpressionNomsFichiers != null)
{
result = ExpressionNomsFichiers.Eval(ctxDoc);
if (result && result.Data != null)
{
strNomFichier = result.Data.ToString();
}
}
if (strNomFichier == "")
{
strNomFichier = I.T("File|20054");
}
foreach (char c in "\"/\\*?<>|:")
{
if (strNomFichier.Contains(c.ToString()))
{
strNomFichier = strNomFichier.Replace(c, '_');
}
}
if (lstNomsDocuments.Contains(strNomFichier.ToUpper()))
{
int nIndex = 1;
string strTmp = strNomFichier + "_" + nIndex;
while (lstNomsDocuments.Contains(strTmp.ToUpper()))
{
nIndex++;
strTmp = strNomFichier + "_" + nIndex;
}
strNomFichier = strTmp.ToUpper();
}
lstNomsDocuments.Add(strNomFichier.ToUpper());
strNomFichier += "." + doc.ReferenceDoc.GetExtension();
using (CProxyGED proxy = new CProxyGED(contexte.IdSession, doc.ReferenceDoc))
{
result = proxy.CopieFichierEnLocal();
if (result)
{
ZipEntry entry = new ZipEntry(ZipEntry.CleanName(strNomFichier));
try
{
FileStream fstream = new FileStream(proxy.NomFichierLocal, FileMode.Open, FileAccess.Read);
entry.DateTime = DateTime.Now;
entry.Size = fstream.Length;
int nBufLength = 1024 * 1024;
byte[] buffer = new byte[nBufLength];
int nRead = 0;
zipStream.PutNextEntry(entry);
while ((nRead = fstream.Read(buffer, 0, nBufLength)) != 0)
{
zipStream.Write(buffer, 0, nRead);
}
fstream.Close();
zipStream.CloseEntry();
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
}
}
}
zipStream.Finish();
stream.Seek(0, SeekOrigin.Begin);
CSourceDocumentStream sourceDoc = new CSourceDocumentStream(stream, "zip");
//On a notre stream zippé, création du document
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 docZip = 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 (!docZip.ReadIfExists(filtre))
{
docZip.CreateNew();
}
else
{
docZip.BeginEdit();
}
}
else
{
docZip.CreateNew();
}
docZip.Libelle = strLibelle;
docZip.Descriptif = strDescriptif;
docZip.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(docZip);
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(docZip.ContexteDonnee);
if (cat.ReadIfExists(dbKey))
{
CRelationDocumentGED_Categorie rel = new CRelationDocumentGED_Categorie(docZip.ContexteDonnee);
rel.CreateNewInCurrentContexte();
rel.Categorie = cat;
rel.Document = docZip;
}
}
result = CDocumentGED.SaveDocument(contexte.IdSession, sourceDoc, sourceDoc.TypeReference, docZip.ReferenceDoc, true);
if (sourceDoc != null)
{
sourceDoc.Dispose();
}
zipStream.Close();
zipStream.Dispose();
stream.Dispose();
if (!result)
{
return(result);
}
CReferenceDocument refDoc = result.Data as CReferenceDocument;
docZip.ReferenceDoc = refDoc;
result = docZip.CommitEdit();
if (!result)
{
return(result);
}
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, docZip);
}
return(result);
}
/// ////////////////////////////////////////////////////////
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);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
if (FormuleDocument == null)
{
result.EmpileErreur(I.T("Incorrect document formula|363"));
return(result);
}
result = FormuleDocument.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during Document evaluation|367"));
return(result);
}
if (!(result.Data is CDocumentGED))
{
result.EmpileErreur(I.T("The document formula must return an EDM document|364"));
return(result);
}
CDocumentGED document = (CDocumentGED)result.Data;
if (FormuleNomFichier == null)
{
result.EmpileErreur(I.T("Incorrect file name formula|365"));
return(result);
}
result = FormuleNomFichier.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the destination file name of document evaluation|368"));
return(result);
}
if (!(result.Data is string))
{
result.EmpileErreur(I.T("File name formula doesn't return a file name string|369"));
return(result);
}
string strNomFichier = result.Data.ToString();
if (strNomFichier.ToUpper().StartsWith("FTP://"))
{
string strUser = "";
string strPassword = "";
if (FormuleUser != null)
{
result = FormuleUser.Eval(contexteEval);
}
if (!result)
{
result.EmpileErreur(I.T("Error in User formula|20250"));
return(result);
}
else
{
strUser = result.Data != null?result.Data.ToString() : "";
}
if (FormulePassword != null)
{
result = FormulePassword.Eval(contexteEval);
}
if (!result)
{
result.EmpileErreur(I.T("Error in password formula|20250"));
return(result);
}
else
{
strPassword = result.Data != null?result.Data.ToString() : "";
}
return(CopyToFtp(contexte.IdSession, document, strNomFichier, strUser, strPassword));
}
else if (CopierDepuisLePosteClient)
{
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_idServiceClientSetFichier);
if (service != null)
{
sponsor.Register(service);
CParametreCopierLocalDansGed parametre = new CParametreCopierLocalDansGed(
document.Id,
strNomFichier);
result = service.RunService(parametre);
return(result);
}
}
}
}
}
if (File.Exists(strNomFichier))
{
#region renommage du fichier existant
if (FormuleNomFichierRenommage != null)
{
result = FormuleNomFichierRenommage.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error in the renaming file name|370"));
return(result);
}
if (!(result.Data is string))
{
result.EmpileErreur(I.T("The renaming formula doesn't return text|371"));
return(result);
}
int nIndex = 0;
string strRename = result.Data.ToString();
string strExt = "";
nIndex = strNomFichier.LastIndexOf('.');
string strNom = strRename;
if (nIndex >= 0)
{
strNom = strRename.Substring(0, nIndex);
strExt = strRename.Substring(nIndex);
strRename = strNom;
}
nIndex = 0;
while (File.Exists(strNom + strExt))
{
nIndex++;
strNom = strRename + "_" + nIndex;
}
try
{
if (strExt != "")
{
strNom = strNom + strExt;
}
File.Copy(strNomFichier, strNom, true);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("New name : '@1'|372", strNom));
result.EmpileErreur(I.T("Error during file renaming|373"));
return(result);
}
}
#endregion
}
try
{
using (CProxyGED proxy = new CProxyGED(contexte.IdSession, document.ReferenceDoc))
{
result = proxy.CopieFichierEnLocal();
if (!result)
{
return(result);
}
//Si le fichier existe, il est renommé
File.Copy(proxy.NomFichierLocal, strNomFichier, true);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
return(result);
}
///////////////////////////////////////////////////////////////
public CResultAErreur Compile(int nIdMibModule)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CSpvMibmodule mibModule = new CSpvMibmodule(contexte);
if (!mibModule.ReadIfExists(nIdMibModule))
{
result.EmpileErreur(I.T("Mib module @1 doesn't exists|20000", nIdMibModule.ToString()));
return(result);
}
CDocumentGED doc = mibModule.DocumentGEDModuleMib;
if (doc == null)
{
result.EmpileErreur(I.T("Mib module @1 should be associated to a mib file|20001", mibModule.NomModuleOfficiel));
return(result);
}
using (CProxyGED proxy = new CProxyGED(m_nIdSession, doc.ReferenceDoc))
{
result = proxy.CopieFichierEnLocal();
if (!result)
{
return(result);
}
CMibModuleWrapper mibModuleWrapper = new CMibModuleWrapper();
IDatabaseConnexion connexion = CSc2iDataServer.GetInstance().GetDatabaseConnexion(m_nIdSession, GetType());
string strConnexion = connexion.ConnexionString;
string strDatabase = "";
string strUser = "";
string strPassword = "";
string[] strRubriques = strConnexion.Split(';');
foreach (string strRubrique in strRubriques)
{
string[] strData = strRubrique.Split('=');
if (strData.Length == 2)
{
string strCle = strData[0].ToUpper().Trim();
if (strCle == "DATA SOURCE")
{
strDatabase = strData[1].Trim();
}
if (strCle == "USER ID")
{
strUser = strData[1].Trim();
}
if (strCle == "PASSWORD")
{
strPassword = strData[1].Trim();
}
}
}
if (strDatabase == "" || strUser == "" || strPassword == "")
{
result.EmpileErreur(I.T("Can not parse connexion string|20002"));
return(result);
}
string strConnexionOracle = strUser + "/" + strPassword + "@" + strDatabase;
mibModuleWrapper.Init(strConnexionOracle, proxy.NomFichierLocal,
mibModule.NomModuleUtilisateur, Convert.ToInt32(mibModule.Id));
int nResult = mibModuleWrapper.Compile();
if (nResult < 0)
{
result.EmpileErreur(I.T("Failed to compile mib module @1|20003", mibModule.NomModuleOfficiel));
string strMess;
while ((strMess = mibModuleWrapper.GetNextErrMess()) != "")
{
result.EmpileErreur(strMess);
}
if (mibModuleWrapper.AreCompileErrors())
{
result.EmpileErreur(mibModuleWrapper.GetCompileErrors());
}
if (mibModuleWrapper.AreCompileLogs())
{
result.EmpileErreur(mibModuleWrapper.GetCompileLogs());
}
return(result);
}
else
{
List <IDonneeNotification> notifs = new List <IDonneeNotification>();
notifs.Add(new CDonneeNotificationAjoutEnregistrement(m_nIdSession, CSpvMibmodule.c_nomTable));
notifs.Add(new CDonneeNotificationAjoutEnregistrement(m_nIdSession, CSpvMibobj.c_nomTable));
CEnvoyeurNotification.EnvoieNotifications(notifs.ToArray());
}
}
}
return(result);
}
public void InsérerMibEnGed(int nModuleId)
{
CSpvMibmodule module = new CSpvMibmodule(m_contexteDonnees);
Console.WriteLine("Lecture du module MIB");
Assert.IsTrue(module.ReadIfExists(nModuleId));
CResultAErreur result = CResultAErreur.True;
if (File.Exists(module.FichierModule))
{
Console.WriteLine("le fichier existe");
CDocumentGED doc = module.DocumentGEDModuleMib;
CProxyGED proxy = new CProxyGED(m_contexteDonnees.IdSession,
doc == null ? null : doc.ReferenceDoc);
proxy.AttacheToLocal(module.FichierModule);
result = proxy.UpdateGed();
if (result)
{
if (doc == null)
{
Console.WriteLine("doc null :création d'un nouveau document GED");
doc = new CDocumentGED(m_contexteDonnees);
doc.CreateNewInCurrentContexte();
doc.Descriptif = "";
doc.DateCreation = DateTime.Now;
doc.Libelle = "MIB file " + module.NomModuleUtilisateur;
doc.ReferenceDoc = (CReferenceDocument)result.Data;
doc.DateMAJ = DateTime.Now;
doc.NumVersion++;
doc.IsFichierSysteme = true;
module.DocumentGEDModuleMib = doc;
}
}
Console.WriteLine("vérification des donnéees");
result = module.VerifieDonnees(false);
if (!result)
{
System.Console.WriteLine(result.MessageErreur);
}
Assert.IsTrue(result.Result);
Console.WriteLine("enregistrement des donnéées");
m_contexteDonnees.SaveAll(true);
if (!result)
{
System.Console.WriteLine(result.MessageErreur);
}
Assert.IsTrue(result.Result);
int nDocId = doc.Id;
CDocumentGED doctest = new CDocumentGED(m_contexteDonnees);
Console.WriteLine("lecture du document GED");
Assert.IsTrue(doctest.ReadIfExists(nDocId));
Console.WriteLine(doctest.Id);
Console.WriteLine(doctest.Libelle);
}
}
