private void m_btnSave_Click(object sender, EventArgs e)
{
if (m_arbre.Nodes.Count == 0)
{
return;
}
CRepertoire dossier = m_arbre.Nodes[0].Tag as CRepertoire;
if (dossier != null)
{
SaveFileDialog dlg = new SaveFileDialog();
dlg.Filter = "External explorer file|*.extExp|All files|*.*";
if (dlg.ShowDialog() == DialogResult.OK)
{
CResultAErreur result = CSerializerObjetInFile.SaveToFile(dossier,
"EXTERNAL_EXPLORER",
dlg.FileName
);
if (result)
{
MessageBox.Show("Save ok");
}
else
{
MessageBox.Show(result.Erreur.ToString());
}
}
}
}
private void SearchThread(object state)
{
Regex regDir = CPatternMatch.Convert(m_strDirPattern);
Regex regFile = CPatternMatch.Convert(m_strFilePattern);
CRepertoire repSel = null;
CFichier ficSel = null;
CFichier fichierTrouve = null;
if (m_formMain != null)
{
repSel = m_formMain.GetRepertoireSel();
ficSel = m_formMain.GetFichierSel();
if (repSel != null)
{
fichierTrouve = repSel.FindNext(true, repSel, ficSel, regDir, regFile, m_indicateurProgression);
if (fichierTrouve != null)
{
m_formMain.SelectFichier(fichierTrouve);
}
}
}
CFormProgression.EndIndicateur(m_indicateurProgression);
m_threadSearch = null;
Invoke((MethodInvoker) delegate { UpdateVisuel(); });
if (fichierTrouve == null)
{
MessageBox.Show("Pattern not found");
}
}
private void FillLogs(CRepertoire repertoire, StringBuilder bl)
{
if (repertoire.InfoImport.Length > 0)
{
bl.Append(repertoire.FullName);
bl.Append("\t");
bl.Append(repertoire.InfoImport);
bl.Append(Environment.NewLine);
}
foreach (CFichier fichier in repertoire.GetChilds <CFichier>())
{
if (fichier.InfoImport.Length > 0)
{
bl.Append(repertoire.FullName);
bl.Append("/");
bl.Append(fichier.Nom);
bl.Append("\t");
bl.Append(fichier.InfoImport);
bl.Append(Environment.NewLine);
}
}
foreach (CRepertoire rep in repertoire.GetChilds <CRepertoire>())
{
FillLogs(rep, bl);
}
}
public void FillFrom(string strPathComplet)
{
Nom = Path.GetFileName(strPathComplet);
foreach (string strDir in Directory.GetDirectories(strPathComplet))
{
CRepertoire dossier = GetChilds <CRepertoire>().FirstOrDefault(d => d.Nom == Path.GetFileName(strDir));
if (dossier == null)
{
dossier = new CRepertoire();
}
dossier.FillFrom(strDir);
m_listeElements.Add(dossier);
}
foreach (string strFile in Directory.GetFiles(strPathComplet))
{
CFichier fichier = GetChilds <CFichier>().FirstOrDefault(fi => fi.Nom == Path.GetFileName(strFile));
if (fichier == null)
{
fichier = new CFichier();
}
fichier.Nom = Path.GetFileName(strFile);
FileInfo f = new FileInfo(strFile);
fichier.LastModifDate = f.LastWriteTime;
fichier.Size = f.Length;
m_listeElements.Add(fichier);
}
}
private void FillItem(ListViewItem item, CRepertoire dossier)
{
item.Text = dossier.Nom;
item.ImageIndex = GetIndexImageDossier(dossier);
item.StateImageIndex = item.ImageIndex;
item.Tag = dossier;
}
private void FillFichiers(CRepertoire dossier)
{
m_wndListeFichiers.BeginUpdate();
m_wndListeFichiers.Items.Clear();
List <CRepertoire> dossiers = new List <CRepertoire>(from e in dossier.ElementsContenus
where e is CRepertoire
select e as CRepertoire);
dossiers.Sort((x, y) => x.Nom.CompareTo(y.Nom));
foreach (CRepertoire dossierFils in dossiers)
{
if (ShoudSeeDossier(dossierFils))
{
ListViewItem item = new ListViewItem();
FillItem(item, dossierFils);
m_wndListeFichiers.Items.Add(item);
}
}
List <CFichier> fichiers = new List <CFichier>(from e in dossier.ElementsContenus
where e is CFichier
select e as CFichier);
fichiers.Sort((x, y) => x.Nom.CompareTo(y.Nom));
foreach (CFichier fichier in fichiers)
{
ListViewItem item = new ListViewItem();
FillItem(item, fichier);
m_wndListeFichiers.Items.Add(item);
}
m_wndListeFichiers.EndUpdate();
}
private void m_btnLoad_Click(object sender, EventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.Filter = "External explorer file|*.extExp|All files|*.*";
if (dlg.ShowDialog() == DialogResult.OK)
{
DateTime dt = DateTime.Now;
CRepertoire dossier = new CRepertoire();
CResultAErreur result = CSerializerObjetInFile.ReadFromFile(dossier,
"EXTERNAL_EXPLORER",
dlg.FileName);
TimeSpan sp = DateTime.Now - dt;
if (result)
{
m_dossierRacine = dossier;
FillTree();
}
else
{
MessageBox.Show(result.Erreur.ToString());
}
}
}
private TreeNode FindNode(CRepertoire rep, TreeNodeCollection nodes)
{
foreach (TreeNode child in nodes)
{
if (child.Tag == rep)
{
return(child);
}
}
return(null);
}
private void FillNode(TreeNode node, CRepertoire dossier)
{
node.Text = dossier.Nom;
node.ImageIndex = GetIndexImageDossier(dossier);
node.SelectedImageIndex = node.ImageIndex;
node.Tag = dossier;
if (node.Nodes.Count == 0 && dossier.GetChilds <CRepertoire>().Count() > 0)
{
node.Nodes.Add(new TreeNode());
}
}
private void m_btnBrowse_Click(object sender, EventArgs e)
{
FolderBrowserDialog dlg = new FolderBrowserDialog();
if (dlg.ShowDialog() == DialogResult.OK)
{
string strRepRacine = dlg.SelectedPath;
m_dossierRacine = new CRepertoire();
m_dossierRacine.FillFrom(strRepRacine);
FillTree();
}
}
//-----------------------------------------------------------------------------------------
public int GetIndexImageDossier(CRepertoire repertoire)
{
if (!repertoire.ImportDone)
{
return(0);
}
else if (repertoire.HasErreurImport())
{
return(4);
}
return(2);
}
public CRepertoire GetRepertoireSel()
{
CRepertoire rep = null;
Invoke((MethodInvoker) delegate
{
if (m_arbre.SelectedNode != null)
{
rep = m_arbre.SelectedNode.Tag as CRepertoire;
}
});
return(rep);
}
//-----------------------------------------------------------------------------------------
private void RefreshNode(TreeNode node)
{
CRepertoire dossier = node.Tag as CRepertoire;
if (dossier != null)
{
FillNode(node, dossier);
}
foreach (TreeNode child in node.Nodes)
{
RefreshNode(child);
}
}
private void ShowInfos(object obj)
{
if (obj == null)
{
m_panelInfo.Visible = false;
}
CRepertoire repertoire = obj as CRepertoire;
if (repertoire != null)
{
m_imageErreur.Image = m_imagesFichiers.Images[GetIndexImageDossier(repertoire)];
m_lblTitreErreur.Text = repertoire.Nom;
m_txtErreur.Text = repertoire.InfoImport;
}
CFichier fichier = obj as CFichier;
if (fichier != null)
{
m_imageErreur.Image = m_imagesFichiers.Images[GetIndexImageFichier(fichier)];
m_lblTitreErreur.Text = fichier.Nom;
if (fichier.KeyObjetAssocie != null && fichier.TypeObjetAssocie != null)
{
m_txtErreur.Text = "Imported to ";
CObjetDonneeAIdNumerique objet = null;
if (CImportMyanmarConst.ContexteDonnee != null)
{
try
{
objet = Activator.CreateInstance(fichier.TypeObjetAssocie, new object[] { CImportMyanmarConst.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (obj != null && objet.ReadIfExists(fichier.KeyObjetAssocie))
{
m_txtErreur.Text += objet.DescriptionElement;
}
}
catch { }
}
if (objet == null && fichier.TypeObjetAssocie != null)
{
m_txtErreur.Text += DynamicClassAttribute.GetNomConvivial(fichier.TypeObjetAssocie);
}
else
{
m_txtErreur.Text += " ? ";
}
}
else
{
m_txtErreur.Text = fichier.InfoImport;
}
}
}
public void Create(CRepertoire repertoireRacine)
{
foreach (CRepertoire repProjet in repertoireRacine.GetChilds <CRepertoire>())
{
foreach (CRepertoire repCandidat in repProjet.GetChilds <CRepertoire>())
{
CInfoProjet info = new CInfoProjet(repProjet.Nom, repCandidat.Nom);
foreach (CRepertoire repDetail in repCandidat.GetChilds <CRepertoire>())
{
FillDic(repDetail, info);
}
}
}
}
private bool ShoudSeeDossier(CRepertoire dossier)
{
bool bResult = true;
if (m_chkHideDirsWithoutFiles.Checked)
{
bResult &= dossier.HasFiles;
}
if (m_chkShowErrors.Checked)
{
bResult &= (dossier.HasErreurImport());
}
return(bResult);
}
private void ClearImportInformations(TreeNode node)
{
if (node == null)
{
return;
}
CRepertoire rep = node.Tag as CRepertoire;
if (rep == null)
{
return;
}
m_arbre.BeginUpdate();
rep.ClearDataImport();
RefreshNode(node);
m_arbre.EndUpdate();
}
private void FillDic(CRepertoire repertoire, CInfoProjet infoEnCours)
{
if (repertoire.GetChilds <CFichier>().Count() > 0)
{
List <CInfoProjet> lst = null;
if (!m_dicRepsToProjets.TryGetValue(repertoire.Nom.ToUpper(), out lst))
{
lst = new List <CInfoProjet>();
m_dicRepsToProjets[repertoire.Nom.ToUpper()] = lst;
}
lst.Add(infoEnCours);
}
foreach (CRepertoire sub in repertoire.GetChilds <CRepertoire>())
{
FillDic(sub, infoEnCours);
}
}
private CResultAErreur ImportRepCandidat(CProjet projetNominal,
CProjet projetCandidat,
CRepertoire repCandidat,
string strPathGed)
{
strPathGed += "\\" + repCandidat.Nom;
CResultAErreur result = CResultAErreur.True;
repCandidat.ImportDone = true;
foreach (CRepertoire repertoire in repCandidat.GetChilds <CRepertoire>())
{
result = ImportRep(projetNominal, projetCandidat, repertoire, strPathGed);
if (!result)
{
return(result);
}
}
return(result);
}
private void FillChildrens(TreeNode nodeToFill)
{
m_arbre.BeginUpdate();
nodeToFill.Nodes.Clear();
CRepertoire dossier = nodeToFill.Tag as CRepertoire;
List <CRepertoire> dossiers = new List <CRepertoire>(dossier.GetChilds <CRepertoire>());
dossiers.Sort((x, y) => x.Nom.CompareTo(y.Nom));
foreach (CRepertoire dossierFils in dossiers)
{
if (ShoudSeeDossier(dossierFils))
{
TreeNode node = new TreeNode();
FillNode(node, dossierFils);
nodeToFill.Nodes.Add(node);
}
}
m_arbre.EndUpdate();
}
/* public bool FindNext ( string strDirPattern, string strFilePattern )
* {
* TreeNode node = m_arbre.SelectedNode;
* if (node == null && m_arbre.Nodes.Count > 0)
* node = m_arbre.Nodes[0];
* if (node == null)
* return false;
* Regex regDir = CPatternMatch.Convert(strDirPattern);
* Regex regFile = CPatternMatch.Convert(strFilePattern);
* CRepertoire repertoireSel = node.Tag as CRepertoire;
* CFichier fichierSel = null;
* if ( m_wndListeFichiers.SelectedItems.Count > 0 )
* {
* fichierSel = m_wndListeFichiers.SelectedItems[0].Tag as CFichier;
* }
* CFichier fichier = repertoireSel.FindNext(true, null, fichierSel, regDir, regFile);
* if (fichier != null)
* {
* SelectFichier(fichier);
* return true;
* }
* else
* {
* MessageBox.Show("Pattern not found");
* return false;
* }
*
* }*/
public void SelectFichier(CFichier fichier)
{
Invoke((MethodInvoker) delegate
{
List <CRepertoire> lstReps = new List <CRepertoire>();
CRepertoire rep = fichier.RepertoireContenant;
while (rep != null)
{
lstReps.Add(rep);
rep = rep.RepertoireContenant;
}
lstReps.Reverse();
TreeNodeCollection nodes = m_arbre.Nodes;
TreeNode nodeParent = null;
foreach (CRepertoire childRep in lstReps)
{
nodeParent = FindNode(childRep, nodes);
if (nodeParent == null)
{
break;
}
nodeParent.Expand();
nodes = nodeParent.Nodes;
}
if (nodeParent != null)
{
m_arbre.SelectedNode = nodeParent;
nodeParent.EnsureVisible();
foreach (ListViewItem item in m_wndListeFichiers.Items)
{
if (item.Tag == fichier)
{
item.Selected = true;
item.EnsureVisible();
break;
}
}
}
});
}
private void m_wndListeFichiers_MouseDoubleClick(object sender, MouseEventArgs e)
{
ListViewHitTestInfo info = m_wndListeFichiers.HitTest(e.X, e.Y);
if (info.Item != null)
{
CRepertoire dossier = info.Item.Tag as CRepertoire;
TreeNode node = m_arbre.SelectedNode;
if (node != null)
{
node.Expand();
foreach (TreeNode child in node.Nodes)
{
if (child.Tag == dossier)
{
m_arbre.SelectedNode = child;
break;
}
}
}
}
}
public CResultAErreur ImporteDossierProjet(
CProjet projetNominal,
CRepertoire repertoire,
string strPathGed)
{
repertoire.ClearDataImport();
repertoire.ImportDone = true;
//Trouve le projet candidat
CProjet candidat = projetNominal.TousLesProjetsFils.FirstOrDefault(p => p.TypeProjet.Id == 14);
if (candidat == null)
{
repertoire.InfoImport = "No candidate for this directory";
return(CResultAErreur.True);
}
CResultAErreur result = CResultAErreur.True;
object numCandidate = candidat.GetValeurChamp(2589);
if (numCandidate == null)
{
repertoire.InfoImport = "Candidate " + candidat.Libelle + " has no candidate number";
return(result);
}
string strNomCandidat = "Candidate " + numCandidate.ToString().PadLeft(2, '0');
//Cherche le répertoire du candidat
foreach (CRepertoire rep in repertoire.GetChilds <CRepertoire>())
{
if (rep.Nom.ToUpper().Equals(strNomCandidat.ToUpper()))
{
result = ImportRepCandidat(projetNominal, candidat, rep, strPathGed);
return(result);
}
}
repertoire.InfoImport = "Can not find directory " + strNomCandidat;
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);
}
private CResultAErreur ImportRep(CProjet projetNominal,
CProjet projetCandidat,
CRepertoire rep,
string strPathGed)
{
CResultAErreur result = CResultAErreur.True;
rep.ImportDone = true;
strPathGed += "\\" + rep.Nom;
CMappingRepToDocSetup map = CMappingRepToDocSetup.GetMapping(rep.Nom);
foreach (CFichier fichier in rep.GetChilds <CFichier>())
{
if (map == null)
{
fichier.InfoImport = "No mapping for this directory";
}
else
{
CObjetDonneeAIdNumerique objet = map.GetObjet(projetNominal,
projetCandidat,
fichier.Nom);
if (objet == null)
{
fichier.InfoImport = "Can not find associated objet for this file";
}
else
{
CCategorieGED cat = map.GetCatégorie(projetNominal.ContexteDonnee);
if (cat == null)
{
fichier.InfoImport = "Can not find EDM category for this file";
}
else
{
string strCode = objet.IdUniversel + "/" + fichier.Nom;
CDocumentGED doc = new CDocumentGED(projetNominal.ContexteDonnee);
if (!doc.ReadIfExists(new CFiltreData(CDocumentGED.c_champCle + "=@1", strCode)))
{
doc.CreateNewInCurrentContexte();
}
doc.Libelle = fichier.Nom;
doc.Cle = strCode;
CReferenceDocument refDoc = new CReferenceDocument();
refDoc.TypeReference = new CTypeReferenceDocument(CTypeReferenceDocument.TypesReference.Fichier);
refDoc.NomFichier = strPathGed + "\\" + fichier.Nom;
doc.ReferenceDoc = refDoc;
doc.AddCategory(cat);
doc.AssocieA(objet);
fichier.SetObjetAssocie(objet);
}
}
}
}
foreach (CRepertoire child in rep.GetChilds <CRepertoire>())
{
result = ImportRep(projetNominal, projetCandidat, child, strPathGed);
if (!result)
{
return(result);
}
}
return(result);
}
public CFichier FindNext(bool bCanGoUp, CRepertoire repertoireStart, CFichier fichierStart, Regex regExRepertoire, Regex regExFichier, IIndicateurProgression indicateur)
{
bool bStartSearch = fichierStart == null;
if (repertoireStart != null && repertoireStart.RepertoireContenant == null)
{
repertoireStart = null;
}
if (regExRepertoire.IsMatch(Nom))
{
foreach (CFichier fichier in GetChilds <CFichier>())
{
if (fichier == fichierStart)
{
bStartSearch = true;
continue;
}
if (!bStartSearch)
{
continue;
}
if (regExFichier.IsMatch(fichier.Nom))
{
return(fichier);
}
}
}
if (RepertoireContenant == null && indicateur != null)
{
indicateur.SetBornesSegment(0, GetChilds <CRepertoire>().Count());
}
int nIndex = 0;
bStartSearch = repertoireStart == null;
foreach (CRepertoire rep in GetChilds <CRepertoire>())
{
if (RepertoireContenant == null)
{
indicateur.SetInfo(rep.Nom);
nIndex++;
indicateur.SetValue(nIndex);
}
if (rep == repertoireStart)
{
bStartSearch = true;
continue;
}
if (!bStartSearch)
{
continue;
}
CFichier trouve = rep.FindNext(false, null, null, regExRepertoire, regExFichier, indicateur);
if (trouve != null)
{
return(trouve);
}
if (indicateur.CancelRequest)
{
return(null);
}
}
if (RepertoireContenant != null && bCanGoUp)
{
return(RepertoireContenant.FindNext(true, this, null, regExRepertoire, regExFichier, indicateur));
}
return(null);
}
