//------------------------------------------------------------------------+
// buttonbuttonAzzeraValori_Click |
//------------------------------------------------------------------------+
private void buttonbuttonAzzeraValori_Click(object sender, RoutedEventArgs e)
{
//_xTXP.Save();
foreach (XmlNode item in _xTXP.Document.SelectNodes("//Node"))
{
if (item.Attributes["Checked"] == null)
{
XmlAttribute attr = _xTXP.Document.CreateAttribute("Checked");
item.Attributes.Append(attr);
}
item.Attributes["Checked"].Value = "False";
if (item.Attributes["NotaTDL"] == null)
{
XmlAttribute attr = _xTXP.Document.CreateAttribute("NotaTDL");
item.Attributes.Append(attr);
}
item.Attributes["NotaTDL"].Value = "";
StaticUtilities.MarkNodeAsModified(item, App.OBJ_MOD); _isModified = true;
}
RevisoftApplication.XmlManager x = new XmlManager();
x.TipoCodifica = RevisoftApplication.XmlManager.TipologiaCodifica.Normale;
_xTXP.isModified = _isModified; _xTXP.Save(_isModified);
_isModified = false;
TreeXmlProvider.Document = x.LoadEncodedFile(_xTXP.File);
TreeXmlProvider.Refresh();
LoadDataSource();
}
public void LoadTreeSource()
{
//Titolo attivita
Utilities u = new Utilities();
txtTitoloAttivita.Text = u.TitoloAttivita(_TipoAttivita);
//carico dati
RevisoftApplication.XmlManager x = new XmlManager();
x.TipoCodifica = RevisoftApplication.XmlManager.TipologiaCodifica.Normale;
TreeXmlProvider.Document = x.LoadEncodedFile(SelectedTreeSource);
if (!u.CheckXmlDocument(TreeXmlProvider.Document, ((App.TipoFile)(Convert.ToInt32(IDTree))), "Tree"))
{
this.Close();
return;
}
if (firsttime)
{
firsttime = false;
foreach (XmlNode item in TreeXmlProvider.Document.SelectNodes("//Node"))
{
if (item.ParentNode.Name == "Tree")
{
item.Attributes["Expanded"].Value = "True";
}
else
{
item.Attributes["Expanded"].Value = "False";
}
item.Attributes["Selected"].Value = "False";
if (item.Attributes["HighLighted"] == null)
{
XmlAttribute attr = item.OwnerDocument.CreateAttribute("HighLighted");
attr.Value = "Black";
item.Attributes.Append(attr);
}
item.Attributes["HighLighted"].Value = "Black";
}
}
TreeXmlProvider.Refresh();
LoadDataSource();
}
//----------------------------------------------------------------------------+
// Open |
//----------------------------------------------------------------------------+
private void Open_old()
{
if (Check())
{
//carico file
try
{
document = x.LoadEncodedFile(filebackup);
Utilities u = new Utilities();
if (!u.CheckXmlDocument(document, App.TipoFile.BackUp))
{
throw new Exception("Documento non valido. ID diverso da standard TipoFile");
}
}
catch (Exception ex)
{
string log = ex.Message;
Error(WindowGestioneMessaggi.TipologieMessaggiErrore.ErroreInCaricamentoFileBackUp);
}
}
}
public void LoadTreeSource()
{
RevisoftApplication.XmlManager x = new XmlManager();
x.TipoCodifica = RevisoftApplication.XmlManager.TipologiaCodifica.Normale;
TreeXmlProvider.Document = x.LoadEncodedFile(SelectedTreeSource);
Utilities u = new Utilities();
if (!u.CheckXmlDocument(TreeXmlProvider.Document, App.TipoFile.Formulario, "Tree"))
{
this.Close();
return;
}
if (firsttime)
{
firsttime = false;
foreach (XmlNode item in TreeXmlProvider.Document.SelectNodes("//Node"))
{
if (item.ParentNode.Name == "Tree")
{
item.Attributes["Expanded"].Value = "True";
}
else
{
item.Attributes["Expanded"].Value = "False";
}
item.Attributes["Selected"].Value = "False";
}
}
TreeXmlProvider.Refresh();
LoadDataSource();
}
private void ReloadNodi()
{
Hashtable htID = new Hashtable();
Hashtable htAliasAdditivo = new Hashtable();
ArrayList alCheckCompletezzaNodi = new ArrayList();
List <DateTime> dates = new List <DateTime>();
List <string> strings = new List <string>();
bool alldates = true;
htSessioni.Clear();
htSessioniAlias.Clear();
htSessioniID.Clear();
RevisoftApplication.XmlManager x = new XmlManager();
x.TipoCodifica = RevisoftApplication.XmlManager.TipologiaCodifica.Normale;
for (int i = 0; i < SessioneFile.Split('|').Count(); i++)
{
ht.Add(SessioneAlias.Split('|')[i], SessioneFile.Split('|')[i]);
htID.Add(SessioneAlias.Split('|')[i], SessioneID.Split('|')[i]);
try
{
htAliasAdditivo.Add(SessioneAlias.Split('|')[i], SessioneAliasAdditivo.Split('|')[i]);
}
catch (Exception ex)
{
cBusinessObjects.logger.Error(ex, "wWorkAreaTreeLimited.ReloadNodi1 exception");
string log = ex.Message;
htAliasAdditivo.Add(SessioneAlias.Split('|')[i], "");
}
string aliastmp = SessioneAlias.Split('|')[i];
strings.Add(aliastmp);
if (aliastmp == "")
{
aliastmp = "31/12/" + DateTime.Now.Year.ToString();
}
DateTime data;
try
{
data = Convert.ToDateTime(aliastmp);
dates.Add(data);
}
catch (Exception ex)
{
cBusinessObjects.logger.Error(ex, "wWorkAreaTreeLimited.ReloadNodi2 exception");
string log = ex.Message;
alldates = false;
}
}
if (alldates)
{
dates.Sort();
dates.Reverse();
}
for (int i = 0; i < strings.Count; i++)
{
string alias;
if (alldates)
{
alias = dates[i].ToShortDateString();
if (alias == "31/12" + DateTime.Now.Year.ToString())
{
alias = "";
}
}
else
{
alias = strings[i];
}
htSessioni.Add(i, ht[alias].ToString());
htSessioniID.Add(i, htID[alias].ToString());
XmlDocument tmpDoc = x.LoadEncodedFile(ht[alias].ToString());
foreach (XmlNode node in tmpDoc.SelectNodes("/Dati//Dato"))
{
if (!alCheckCompletezzaNodi.Contains(node.Attributes["ID"].Value))
{
alCheckCompletezzaNodi.Add(node.Attributes["ID"].Value);
}
}
}
for (int i = 0; i < strings.Count; i++)
{
string alias;
if (alldates)
{
alias = dates[i].ToShortDateString();
if (alias == "31/12" + DateTime.Now.Year.ToString())
{
alias = "";
}
}
else
{
alias = strings[i];
}
XmlDocument tmpDoc = x.LoadEncodedFile(ht[alias].ToString());
XmlNode nodeTree = TreeXmlProvider.Document.SelectSingleNode("/Tree");
if (nodeTree != null)
{
XmlNode nodeSessioni = nodeTree.SelectSingleNode("Sessioni");
if (i == 0 && nodeSessioni != null)
{
nodeSessioni.ParentNode.RemoveChild(nodeSessioni);
nodeSessioni = null;
}
if (nodeSessioni == null)
{
nodeSessioni = nodeTree.OwnerDocument.CreateNode(XmlNodeType.Element, "Sessioni", "");
nodeTree.AppendChild(nodeSessioni);
nodeSessioni = nodeTree.SelectSingleNode("Sessioni");
}
XmlNode nodeSessione = nodeTree.SelectSingleNode("Sessioni/Sessione[@Alias=\"" + alias + "\"]");
if (nodeSessione == null)
{
nodeSessione = nodeSessioni.OwnerDocument.CreateNode(XmlNodeType.Element, "Sessione", "");
XmlAttribute attr = nodeSessioni.OwnerDocument.CreateAttribute("Alias");
try
{
switch ((App.TipoFile)(System.Convert.ToInt32(IDTree)))
{
case App.TipoFile.Bilancio:
case App.TipoFile.Conclusione:
case App.TipoFile.Revisione:
attr.Value = ConvertDataToEsercizio(alias.Split('/')[2]);
htSessioniAlias.Add(i, ConvertDataToEsercizio(alias.Split('/')[2]));
break;
case App.TipoFile.Vigilanza:
case App.TipoFile.Verifica:
case App.TipoFile.Incarico:
case App.TipoFile.IncaricoCS:
case App.TipoFile.IncaricoSU:
case App.TipoFile.IncaricoREV:
attr.Value = alias.Split('/')[0] + "/" + alias.Split('/')[1] + "\r\n" + alias.Split('/')[2] + ((htAliasAdditivo[alias].ToString() == "") ? "" : "\r\n" + htAliasAdditivo[alias].ToString());
htSessioniAlias.Add(i, alias.Split('/')[0] + "/" + alias.Split('/')[1] + "/" + alias.Split('/')[2] + ((htAliasAdditivo[alias].ToString() == "") ? "" : " - " + htAliasAdditivo[alias].ToString()));
break;
case App.TipoFile.ISQC:
attr.Value = alias.Split('/')[0] + "/" + alias.Split('/')[1] + "/" + alias.Split('/')[2] + ((htAliasAdditivo[alias].ToString() == "") ? "" : "\r\n" + htAliasAdditivo[alias].ToString());
htSessioniAlias.Add(i, alias.Split('/')[0] + "/" + alias.Split('/')[1] + "/" + alias.Split('/')[2] + ((htAliasAdditivo[alias].ToString() == "") ? "" : " - " + htAliasAdditivo[alias].ToString()));
break;
case App.TipoFile.Licenza:
case App.TipoFile.Master:
case App.TipoFile.Info:
case App.TipoFile.Messagi:
case App.TipoFile.ImportExport:
case App.TipoFile.ImportTemplate:
case App.TipoFile.BackUp:
case App.TipoFile.Formulario:
case App.TipoFile.ModellPredefiniti:
case App.TipoFile.DocumentiAssociati:
default:
break;
}
}
catch (Exception ex)
{
cBusinessObjects.logger.Error(ex, "wWorkAreaTreeLimited.ReloadNodi3 exception");
string log = ex.Message;
attr.Value = strings[i];
}
nodeSessione.Attributes.Append(attr);
attr = nodeSessioni.OwnerDocument.CreateAttribute("Selected");
if (SelectedDataSource == ht[alias].ToString())
{
switch ((App.TipoFile)(System.Convert.ToInt32(IDTree)))
{
case App.TipoFile.Bilancio:
case App.TipoFile.Conclusione:
case App.TipoFile.Revisione:
selectedAliasCodificato = ConvertDataToEsercizio(alias.Split('/')[2]);
break;
case App.TipoFile.Vigilanza:
case App.TipoFile.Verifica:
case App.TipoFile.Incarico:
case App.TipoFile.IncaricoCS:
case App.TipoFile.IncaricoSU:
case App.TipoFile.IncaricoREV:
selectedAliasCodificato = alias.Split('/')[0] + "/" + alias.Split('/')[1] + "\r\n" + alias.Split('/')[2] + ((htAliasAdditivo[alias].ToString() == "") ? "" : "\r\n" + htAliasAdditivo[alias].ToString());
break;
case App.TipoFile.ISQC:
selectedAliasCodificato = alias.Split('/')[0] + "/" + alias.Split('/')[1] + "/" + alias.Split('/')[2] + ((htAliasAdditivo[alias].ToString() == "") ? "" : "\r\n" + htAliasAdditivo[alias].ToString());
break;
case App.TipoFile.Licenza:
case App.TipoFile.Master:
case App.TipoFile.Info:
case App.TipoFile.Messagi:
case App.TipoFile.ImportExport:
case App.TipoFile.ImportTemplate:
case App.TipoFile.BackUp:
case App.TipoFile.Formulario:
case App.TipoFile.ModellPredefiniti:
case App.TipoFile.DocumentiAssociati:
default:
break;
}
selectedAlias = alias;
attr.Value = "#AA" + YearColor[-1].ToString();
}
else
{
attr.Value = "White";
}
nodeSessione.Attributes.Append(attr);
nodeSessioni.AppendChild(nodeSessione);
}
}
foreach (string ID in alCheckCompletezzaNodi)
{
nodeTree = TreeXmlProvider.Document.SelectSingleNode("/Tree//Node[@ID=" + ID + "]");
if (nodeTree != null)
{
XmlNode node = tmpDoc.SelectSingleNode("/Dati//Dato[@ID='" + ID + "']");
if (node != null && !htStati.ContainsKey(node.Attributes["ID"].Value))
{
htStati.Add(node.Attributes["ID"].Value, node);
}
XmlNode nodeSessioni = nodeTree.SelectSingleNode("Sessioni");
if (i == 0 && nodeSessioni != null)
{
nodeSessioni.ParentNode.RemoveChild(nodeSessioni);
nodeSessioni = null;
}
if (nodeSessioni == null)
{
XmlNode newElemOut = nodeTree.OwnerDocument.CreateNode(XmlNodeType.Element, "Sessioni", "");
nodeTree.AppendChild(newElemOut);
nodeSessioni = nodeTree.SelectSingleNode("Sessioni");
}
XmlNode nodeSessione = nodeTree.SelectSingleNode("Sessioni/Sessione[@Alias=\"" + alias + "\"]");
if (nodeSessione == null)
{
nodeSessione = nodeSessioni.OwnerDocument.CreateNode(XmlNodeType.Element, "Sessione", "");
XmlAttribute attr = nodeSessioni.OwnerDocument.CreateAttribute("Alias");
try
{
switch ((App.TipoFile)(System.Convert.ToInt32(IDTree)))
{
case App.TipoFile.Bilancio:
case App.TipoFile.Conclusione:
case App.TipoFile.Revisione:
attr.Value = ConvertDataToEsercizio(alias.Split('/')[2]);
break;
case App.TipoFile.Vigilanza:
case App.TipoFile.Verifica:
case App.TipoFile.Incarico:
case App.TipoFile.IncaricoCS:
case App.TipoFile.IncaricoSU:
case App.TipoFile.IncaricoREV:
attr.Value = alias.Split('/')[0] + "/" + alias.Split('/')[1] + "\r\n" + alias.Split('/')[2] + ((htAliasAdditivo[alias].ToString() == "") ? "" : "\r\n" + htAliasAdditivo[alias].ToString());
break;
case App.TipoFile.ISQC:
attr.Value = alias.Split('/')[0] + "/" + alias.Split('/')[1] + "/" + alias.Split('/')[2] + ((htAliasAdditivo[alias].ToString() == "") ? "" : "\r\n" + htAliasAdditivo[alias].ToString());
break;
case App.TipoFile.Licenza:
case App.TipoFile.Master:
case App.TipoFile.Info:
case App.TipoFile.Messagi:
case App.TipoFile.ImportExport:
case App.TipoFile.ImportTemplate:
case App.TipoFile.BackUp:
case App.TipoFile.Formulario:
case App.TipoFile.ModellPredefiniti:
case App.TipoFile.DocumentiAssociati:
default:
break;
}
}
catch (Exception ex)
{
cBusinessObjects.logger.Error(ex, "wWorkAreaTreeLimited.ReloadNodi4 exception");
string log = ex.Message;
attr.Value = strings[i];
}
nodeSessione.Attributes.Append(attr);
attr = nodeSessioni.OwnerDocument.CreateAttribute("Selected");
if (SelectedDataSource == ht[alias].ToString())
{
attr.Value = "#AA" + YearColor[-1].ToString();
}
else
{
int anno = Convert.ToInt32(alias.Substring(alias.Length - 4, 4));
if (i % 2 == 0)
{
attr.Value = "#80" + YearColor[anno].ToString();
}
else
{
attr.Value = "#AA" + YearColor[anno].ToString();
}
}
nodeSessione.Attributes.Append(attr);
attr = nodeSessioni.OwnerDocument.CreateAttribute("Stato");
if (nodeTree != null && nodeTree.ParentNode != null && nodeTree.ParentNode.Name == "Tree")
{
if (SelectedDataSource == ht[alias].ToString() && nodeTree.Attributes["Osservazioni"] != null && nodeTree.Attributes["Osservazioni"].Value.Trim() != "")
{
attr.Value = (Convert.ToInt32(App.TipoTreeNodeStato.NodoFazzoletto)).ToString();
}
else
{
attr.Value = (Convert.ToInt32(App.TipoTreeNodeStato.Sconosciuto)).ToString();
}
}
else
{
attr.Value = getStato(nodeTree, tmpDoc);
if (nodeTree.Attributes["Report"].Value == "True")
{
attr.Value = (Convert.ToInt32(App.TipoTreeNodeStato.SolaLettura)).ToString();
}
}
nodeSessione.Attributes.Append(attr);
nodeSessioni.AppendChild(nodeSessione);
}
}
}
_x.Save();
}
}
public void VisualizzaMessaggio()
{
_ChuisuraRegolare = false;
string xKey = "/RevisoftMessageFile";
string errMsg = "Undefined";
switch (App.ErrorLevel)
{
case App.ErrorTypes.Segnalazione:
labelTitolo.Content = "Segnalazione";
labelTitolo.Foreground = Brushes.Gray;
xKey += "/Segnalazione/Nodo[@Key='" + _TipoMessaggioSegnalazione.ToString() + "']";
errMsg = _TipoMessaggioSegnalazione.ToString();
break;
case App.ErrorTypes.Avviso:
labelTitolo.Content = "Avviso";
labelTitolo.Foreground = App._arrBrushes[0];
xKey += "/Avvisi/Nodo[@Key='" + _TipoMessaggioAvviso.ToString() + "']";
errMsg = _TipoMessaggioAvviso.ToString();
break;
case App.ErrorTypes.Errore:
labelTitolo.Content = "Errore";
labelTitolo.Foreground = Brushes.Red;
xKey += "/Errori/Nodo[@Key='" + _TipoMessaggioErrore.ToString() + "']";
errMsg = _TipoMessaggioErrore.ToString();
break;
case App.ErrorTypes.ErroreBloccante:
labelTitolo.Content = "Errore Bloccante";
labelTitolo.Foreground = Brushes.Red;
xKey += "/ErroriBloccanti/Nodo[@Key='" + _TipoMessaggioErroreBloccante.ToString() + "']";
errMsg = _TipoMessaggioErroreBloccante.ToString();
break;
}
//andrea 2.9
//Verifico presenza file messaggio
if (!System.IO.File.Exists(App.AppMessageFile))
{
MessageBox.Show("Message File mancante. Installazione incompleta\n\n" + App.AppMessageFile + "\n\nErrore: " + errMsg);
RevisoftApplication.Utilities u = new Utilities();
u.ChiudiApplicazione();
}
//leggo file messaggi
RevisoftApplication.XmlManager x = new XmlManager();
XmlDocument f = new XmlDocument();
x.TipoCodifica = RevisoftApplication.XmlManager.TipologiaCodifica.Normale;
f = x.LoadEncodedFile(App.AppMessageFile);
XmlNode n = f.SelectSingleNode(xKey);
//nodo mancante
if (n == null)
{
//Abstract
textBlockAbstract.Text = "Messaggio non trovato";
//Descrizione
textBlockDescrizione.Text = "Tipo: " + App.ErrorLevel.ToString() + "\nCodice errore: " + errMsg;
}
else
{
//Abstract
textBlockAbstract.Text = n.Attributes["Titolo"].InnerText;
//Descrizione
textBlockDescrizione.Text = n.Attributes["Descrizione"].InnerText;
}
//apro finestra
base.ShowDialog();
}
private void buttonApri_Click(object sender, RoutedEventArgs e)
{
MasterFile mf = MasterFile.Create();
string selectedSession = "-1";
string selectedSessionTitle = "";
foreach (object item in stpSessioniISQC.Children)
{
if (item.GetType().Name == "RadioButton")
{
if (((RadioButton)(item)).IsChecked == true)
{
selectedSession = ((RadioButton)(item)).Tag.ToString();
selectedSessionTitle = ((RadioButton)(item)).Content.ToString();
}
}
}
if (selectedSession == "-1")
{
e.Handled = true;
return;
}
Hashtable ht = mf.GetISQC(selectedSession);
XmlDataProviderManager _xNew = new XmlDataProviderManager(App.AppDataDataFolder + "\\" + ht["FileData"].ToString());
WindowWorkArea wa = new WindowWorkArea(ref _xNew);
//Nodi
wa.NodeHome = 0;
RevisoftApplication.XmlManager xt = new XmlManager();
xt.TipoCodifica = RevisoftApplication.XmlManager.TipologiaCodifica.Normale;
XmlDataProvider TreeXmlProvider = new XmlDataProvider();
TreeXmlProvider.Document = xt.LoadEncodedFile(App.AppDataDataFolder + "\\" + ht["File"].ToString());
if (TreeXmlProvider.Document != null && TreeXmlProvider.Document.SelectSingleNode("/Tree") != null)
{
foreach (XmlNode item in TreeXmlProvider.Document.SelectNodes("/Tree//Node"))
{
switch (((App.TipoAttivita)(Convert.ToInt32(_IDTree))))
{
case App.TipoAttivita.Revisione:
if (item.Attributes["ID"].Value == "181")
{
wa.Nodes.Add(0, item);
}
break;
case App.TipoAttivita.Bilancio:
if (item.Attributes["ID"].Value == "182")
{
wa.Nodes.Add(0, item);
}
break;
case App.TipoAttivita.Conclusione:
if (item.Attributes["ID"].Value == "183")
{
wa.Nodes.Add(0, item);
}
break;
case App.TipoAttivita.Verifica:
if (item.Attributes["ID"].Value == "185")
{
wa.Nodes.Add(0, item);
}
break;
default:
e.Handled = true;
return;
}
}
}
if (wa.Nodes.Count == 0)
{
e.Handled = true;
return;
}
wa.NodeNow = wa.NodeHome;
wa.Owner = Window.GetWindow(this);
//posizione e dimensioni finestra
wa.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen;
wa.Height = System.Windows.SystemParameters.PrimaryScreenHeight * 90.0 / 100.0;
wa.Width = System.Windows.SystemParameters.PrimaryScreenWidth * 90.0 / 100.0;
wa.MaxHeight = System.Windows.SystemParameters.PrimaryScreenHeight * 90.0 / 100.0;
wa.MaxWidth = System.Windows.SystemParameters.PrimaryScreenWidth * 90.0 / 100.0;
wa.MinHeight = System.Windows.SystemParameters.PrimaryScreenHeight * 90.0 / 100.0;
wa.MinWidth = System.Windows.SystemParameters.PrimaryScreenWidth * 90.0 / 100.0;
//Sessioni
wa.Sessioni.Clear();
wa.Sessioni.Add(0, App.AppDataDataFolder + "\\" + ht["FileData"].ToString());
wa.SessioniTitoli.Clear();
wa.SessioniTitoli.Add(0, selectedSessionTitle);
wa.SessioniID.Clear();
wa.SessioniID.Add(0, selectedSession);
wa.SessioneHome = 0;
wa.SessioneNow = 0;
//Variabili
wa.ReadOnly = true;
wa.ReadOnlyOLD = true;
wa.ApertoInSolaLettura = true;
//passaggio dati
wa.IDTree = "28";
wa.IDSessione = selectedSession;
wa.IDCliente = _IDCliente;
wa.Stato = App.TipoTreeNodeStato.Sconosciuto;
wa.OldStatoNodo = wa.Stato;
//apertura
wa.Load();
App.MessaggioSolaScrittura = "Carta in sola lettura, premere tasto ESCI";
App.MessaggioSolaScritturaStato = "Carta in sola lettura, premere tasto ESCI";
wa.ShowDialog();
App.MessaggioSolaScrittura = "Occorre selezionare Sblocca Stato per modificare il contenuto.";
App.MessaggioSolaScritturaStato = "Sessione in sola lettura, impossibile modificare lo stato.";
base.Close();
}
public void SetBackUpFile(string nomefileBackUp)
{
#if (!DBG_TEST)
SetBackUpFile_old(nomefileBackUp); return;
#endif
try
{
FileInfo buf = new FileInfo(nomefileBackUp);
string cartellatmp = App.TMP_FOLDER + Guid.NewGuid().ToString();
DirectoryInfo di = new DirectoryInfo(cartellatmp);
if (di.Exists)
{
// errore directory già esistente aspettare processo terminato da parte
// di altro utente
return;
}
di.Create();
// nuove cartelle per i file necessari
DirectoryInfo d_rdf = new DirectoryInfo(cartellatmp + "\\" + App.DataFolder); // ex "\\RDF"
d_rdf.Create();
DirectoryInfo d_uuff = new DirectoryInfo(cartellatmp + "\\" + App.UserFileFolder); // ex "\\UserUF"
d_uuff.Create();
//----------------------------------------------------------------------------+
// lettura master file |
//----------------------------------------------------------------------------+
MasterFile mf = new MasterFile();
XmlDocument mfDoc = mf.GetDocument();
if (mfDoc == null)
{
return;
}
//----------------------------------------------------------------------------+
// scansione di tutti i nodi contenenti "FileData" e quindi anche "File" |
//----------------------------------------------------------------------------+
string fName;
XmlManager manager = new XmlManager();
XmlDocument doc;
string[] attrs = { "File", "FileData" };
foreach (XmlNode node in mfDoc.SelectNodes("//*[@FileData]"))
{
foreach (string s in attrs)
{
// salvataggio albero se esiste
if (node.Attributes[s] != null)
{
fName = node.Attributes[s].Value;
doc = manager.LoadEncodedFile(fName);
if (doc != null)
{
manager.SaveEncodedFile_old(
cartellatmp + @"\" + App.DataFolder + @"\" + fName, doc.OuterXml);
}
}
}
}
//----------------------------------------------------------------------------+
// copia di tutti i documenti |
//----------------------------------------------------------------------------+
foreach (string dir in Directory.GetDirectories(App.AppDocumentiFolder,
"*", SearchOption.AllDirectories))
{
Directory.CreateDirectory(dir.Replace(App.AppDocumentiFolder, d_uuff.FullName));
}
foreach (string item in Directory.GetFiles(App.AppDocumentiFolder,
"*.*", SearchOption.AllDirectories))
{
File.Copy(item, item.Replace(App.AppDocumentiFolder, d_uuff.FullName), true);
}
//----------------------------------------------------------------------------+
// scrittura master file |
//----------------------------------------------------------------------------+
manager.SaveEncodedFile_old(
cartellatmp + @"\" + App.AppMasterDataFile.Split('\\').Last(), mfDoc.OuterXml);
//----------------------------------------------------------------------------+
// scrittura file documenti |
//----------------------------------------------------------------------------+
fName = "revisoftapp.rdocf";
doc = manager.LoadEncodedFile(fName);
if (doc != null)
{
manager.SaveEncodedFile_old(cartellatmp + @"\" + fName, doc.OuterXml);
}
//creo lo zip
Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile();
zip.Password = App.ZipFilePassword;
zip.AddDirectory(di.FullName);
zip.MaxOutputSegmentSize = MaxOutputSegmentSize;
zip.Save(nomefileBackUp);
// cancello i dati temporanei
di.Delete(true);
}
catch (Exception ex)
{
string log = ex.ToString();
System.IO.File.WriteAllText(
System.IO.Path.Combine(App.AppLogFolder,
String.Format("{0:yyyyMMddHHmmss}_bklog.txt", DateTime.Now)), log);
Error(WindowGestioneMessaggi.TipologieMessaggiErrore.ErroreInSalvataggioFileMaster);
}
}
private void LoadDataSource()
{
_x = new XmlDataProviderManager(SelectedDataSource);
RevisoftApplication.XmlManager x = new XmlManager();
x.TipoCodifica = RevisoftApplication.XmlManager.TipologiaCodifica.Normale;
XmlDocument tmpDoc = x.LoadEncodedFile(SelectedDataSource);
Utilities u = new Utilities();
if (!u.CheckXmlDocument(tmpDoc, App.TipoFile.Formulario, "Data"))
{
this.Close();
return;
}
foreach (XmlNode node in tmpDoc.SelectNodes("/Dati//Dato"))
{
XmlNode nodeTree = TreeXmlProvider.Document.SelectSingleNode("/Tree//Node[@ID=" + node.Attributes["ID"].Value + "]");
if (nodeTree != null)
{
string estensione = "";
string file = "";
string image = ".\\Images\\icone\\Stato\\nothing.png";
try
{
estensione = node.SelectSingleNode("Valore").Attributes["NomeFile"].Value.Split('.').Last();
file = node.SelectSingleNode("Valore").Attributes["NomeFile"].Value.Replace("ruf\\", "");
string pathfile = App.AppFormularioFolder + "\\" + file;
if (!(new FileInfo(pathfile)).Exists)
{
estensione = "";
file = "";
}
}
catch (Exception ex)
{
cBusinessObjects.logger.Error(ex, "wFormulario.LoadDataSource exception");
string log = ex.Message;
}
switch (estensione)
{
case "doc":
case "docx":
image = ".\\Images\\icone\\Documenti\\word.png";
break;
case "pdf":
image = ".\\Images\\icone\\Documenti\\pdf.png";
break;
case "xls":
case "xlsx":
image = ".\\Images\\icone\\Documenti\\excel.png";
break;
case "zip":
image = ".\\Images\\icone\\Documenti\\zip.png";
break;
default:
image = ".\\Images\\icone\\Documenti\\nothing.png";
break;
}
try
{
nodeTree.Attributes["TipoDocumento"].Value = image;
}
catch (Exception ex)
{
cBusinessObjects.logger.Error(ex, "wFormulario.CreateAttributeTipoDocumento exception");
string log = ex.Message;
XmlAttribute attr = nodeTree.OwnerDocument.CreateAttribute("TipoDocumento");
attr.Value = image;
nodeTree.Attributes.Append(attr);
}
try
{
nodeTree.Attributes["NomeFile"].Value = file;
}
catch (Exception ex)
{
cBusinessObjects.logger.Error(ex, "wFormulario.CreateAttributeNomeFile exception");
string log = ex.Message;
XmlAttribute attr = nodeTree.OwnerDocument.CreateAttribute("NomeFile");
attr.Value = file;
nodeTree.Attributes.Append(attr);
}
}
}
}
//----------------------------------------------------------------------------+
// LoadTreeSource |
//----------------------------------------------------------------------------+
public void LoadTreeSource()
{
if (Data == "")
{
Data = DateTime.Now.ToShortDateString();
}
ArrayList pianificatehere = new ArrayList();
txtData.Text = Data;
RevisoftApplication.XmlManager x = new XmlManager();
x.TipoCodifica = RevisoftApplication.XmlManager.TipologiaCodifica.Normale;
MasterFile mf = MasterFile.Create();
ArrayList files = new ArrayList();
switch (TipoAttivita)
{
case App.TipoAttivita.Incarico:
SelectedTreeSource = App.AppTemplateTreeIncarico;
files = mf.GetIncarichi(IDCliente);
break;
case App.TipoAttivita.ISQC:
SelectedTreeSource = App.AppTemplateTreeISQC;
files = mf.GetISQCs(IDCliente);
break;
case App.TipoAttivita.Revisione:
SelectedTreeSource = App.AppTemplateTreeRevisione;
files = mf.GetRevisioni(IDCliente);
break;
case App.TipoAttivita.Bilancio:
SelectedTreeSource = App.AppTemplateTreeBilancio;
files = mf.GetBilanci(IDCliente);
break;
case App.TipoAttivita.Conclusione:
SelectedTreeSource = App.AppTemplateTreeConclusione;
files = mf.GetConclusioni(IDCliente);
break;
case App.TipoAttivita.Verifica:
files = mf.GetVerifiche(IDCliente);
SelectedTreeSource = App.AppTemplateTreeVerifica;
ArrayList al = mf.GetPianificazioniVerifiche(IDCliente);
foreach (Hashtable itemHT in al)
{
ALXTPP.Add(itemHT["ID"].ToString());
}
break;
case App.TipoAttivita.Vigilanza:
files = mf.GetVigilanze(IDCliente);
SelectedTreeSource = App.AppTemplateTreeVigilanza;
ArrayList al2 = mf.GetPianificazioniVigilanze(IDCliente);
foreach (Hashtable itemHT in al2)
{
ALXTPP.Add(itemHT["ID"].ToString());
}
break;
default:
return;
}
if (files.Count > 0)
{
string maxID = "0", id;
DateTime lastdate = Convert.ToDateTime("01/01/1900");
string tobeused = "";
foreach (Hashtable itemHT in files)
{
if (itemHT.Contains("ID"))
{
id = itemHT["ID"].ToString();
if (Convert.ToInt32(id) > Convert.ToInt32(maxID))
{
maxID = id; tobeused = itemHT["File"].ToString();
}
}
}
_xTXP = new XmlDataProviderManager(tobeused);
TreeXmlProvider.Document = x.LoadEncodedFile(tobeused);
}
else
{
_xTXP = new XmlDataProviderManager(SelectedTreeSource);
TreeXmlProvider.Document = x.LoadEncodedFile(SelectedTreeSource);
}
if (firsttime)
{
firsttime = false;
foreach (XmlNode item in _xTXP.Document.SelectNodes("//Node"))
{
if (item.Attributes["WidthNota"] == null)
{
XmlAttribute attr = _xTXP.Document.CreateAttribute("WidthNota");
item.Attributes.Append(attr);
}
if (item.SelectNodes("Node").Count > 0)
{
item.Attributes["WidthNota"].Value = "0";
}
else
{
item.Attributes["WidthNota"].Value = "Auto";
}
if (item.Attributes["Checked"] == null)
{
XmlAttribute attr = _xTXP.Document.CreateAttribute("Checked");
item.Attributes.Append(attr);
item.Attributes["Checked"].Value = "False";
}
if (item.Attributes["NotaTDL"] == null)
{
XmlAttribute attr = _xTXP.Document.CreateAttribute("NotaTDL");
item.Attributes.Append(attr);
item.Attributes["NotaTDL"].Value = "";
}
item.Attributes["Expanded"].Value = "True";
item.Attributes["Selected"].Value = "False";
if (item.Attributes["Pianificato"] == null)
{
XmlAttribute attr = item.OwnerDocument.CreateAttribute("Pianificato");
attr.Value = "";
item.Attributes.Append(attr);
}
DataTable pianificazione = null;
DataTable pianificazioneTestata = null;
foreach (string ALitemXTPP in ALXTPP)
{
bool donehere = false;
string IDPHERE = "";
string datac = "";
if (TipoAttivita == App.TipoAttivita.Verifica)
{
IDPHERE = "100013";
pianificazioneTestata = cBusinessObjects.GetData(int.Parse(IDPHERE), typeof(PianificazioneVerificheTestata), int.Parse(IDCliente), int.Parse(ALitemXTPP), 26);
pianificazione = cBusinessObjects.GetData(int.Parse(IDPHERE), typeof(PianificazioneVerifiche), int.Parse(IDCliente), int.Parse(ALitemXTPP), 26);
}
else
{
IDPHERE = "100003";
pianificazioneTestata = cBusinessObjects.GetData(int.Parse(IDPHERE), typeof(PianificazioneVerificheTestata), int.Parse(IDCliente), int.Parse(ALitemXTPP), 27);
pianificazione = cBusinessObjects.GetData(int.Parse(IDPHERE), typeof(PianificazioneVerifiche), int.Parse(IDCliente), int.Parse(ALitemXTPP), 27);
}
foreach (DataRow itemXPP in pianificazione.Rows)
{
if (itemXPP["NODE_ID"].ToString() != item.Attributes["ID"].Value)
{
continue;
}
foreach (DataRow dd in pianificazioneTestata.Rows)
{
if (dd["ID"].ToString() == itemXPP["PianificazioneID"].ToString())
{
datac = dd["Data"].ToString();
}
}
if (datac != Data)
{
continue;
}
if (itemXPP["Checked"].ToString() == "True")
{
item.Attributes["Pianificato"].Value = "P";
item.Attributes["Checked"].Value = "True";
StaticUtilities.MarkNodeAsModified(item, App.OBJ_MOD); _isModified = true;
pianificatehere.Add(item.Attributes["ID"].Value);
break;
}
}
if (donehere)
{
break;
}
}
}
_xTXP.Save();
foreach (XmlNode item in TreeXmlProvider.Document.SelectNodes("//Node"))
{
if (item.Attributes["NotaTDL"] == null)
{
XmlAttribute attr = TreeXmlProvider.Document.CreateAttribute("NotaTDL");
item.Attributes.Append(attr);
item.Attributes["NotaTDL"].Value = "";
}
if (item.Attributes["Checked"] == null)
{
XmlAttribute attr = TreeXmlProvider.Document.CreateAttribute("Checked");
item.Attributes.Append(attr);
item.Attributes["Checked"].Value = "False";
}
if (item.Attributes["Pianificato"] == null)
{
XmlAttribute attr = TreeXmlProvider.Document.CreateAttribute("Pianificato");
item.Attributes.Append(attr);
item.Attributes["Pianificato"].Value = "";
}
if (pianificatehere.Contains(item.Attributes["ID"].Value))
{
item.Attributes["Pianificato"].Value = "P";
}
if (item.Attributes["WidthNota"] == null)
{
XmlAttribute attr = TreeXmlProvider.Document.CreateAttribute("WidthNota");
item.Attributes.Append(attr);
}
if (item.SelectNodes("Node").Count > 0)
{
item.Attributes["WidthNota"].Value = "0";
}
else
{
item.Attributes["WidthNota"].Value = "Auto";
}
if (item.Attributes["Pianificato"].Value == "P")
{
item.Attributes["Checked"].Value = "True";
//item.Attributes["NotaTDL"].Value = "";
}
StaticUtilities.MarkNodeAsModified(item, App.OBJ_MOD); _isModified = true;
}
}
Utilities u = new Utilities();
labelAttivita.Content = u.TitoloAttivita(_TipoAttivita);
TreeXmlProvider.Refresh();
LoadDataSource();
}
