Samuele Locatelli
897 lines
36 KiB
C#
897 lines
36 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Web;
|
|
using ETS_Data;
|
|
using NLog;
|
|
using System.Net.Mail;
|
|
using System.IO;
|
|
|
|
namespace ETS_WS
|
|
{
|
|
public class WebShipUtils
|
|
{
|
|
/// <summary>
|
|
/// componente logger
|
|
/// </summary>
|
|
protected Logger lg;
|
|
/// <summary>
|
|
/// oggetto singleton accesso classe
|
|
/// </summary>
|
|
public static WebShipUtils mng = new WebShipUtils();
|
|
/// <summary>
|
|
/// metodo di avvio protected
|
|
/// </summary>
|
|
protected WebShipUtils()
|
|
{
|
|
lg = LogManager.GetCurrentClassLogger();
|
|
}
|
|
/// <summary>
|
|
/// calcolo automatico path da metadati
|
|
/// </summary>
|
|
/// <param name="metaDati"></param>
|
|
/// <returns></returns>
|
|
public static string path(docMetaDataSet metaDati)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
// calcolo valori data e maxPathLenght
|
|
string aammgg = metaDati.dataDoc.ToString("yyMMdd");
|
|
int maxFullPathLenght = utils.obj.confReadInt("maxFullPathLenght");
|
|
int maxPathLenght = utils.obj.confReadInt("maxPathLenght");
|
|
// calcolo il path, ipotizzando di lasciare ad oggetto max 200 char - con pulizia eventuali doppie barre
|
|
answ = string.Format("/{0}/{1}/{2}/{3}/{4}_{5}/", utils.cleanPathName(metaDati.commessa), utils.cleanPathName(metaDati.fase), metaDati.InOut, utils.cleanPathName(metaDati.fonte), aammgg, utils.shrinkString(utils.cleanPathName(metaDati.oggetto), maxPathLenght)).Replace("//", "/").Replace("//", "/").Replace("//", "/");
|
|
// se la lungh totale è > maxPathLenght (restano 260-maxPathLenght char x nome file...) trimmo oggetto!
|
|
if (answ.Length > maxFullPathLenght)
|
|
{
|
|
// ricalcolo riducendo oggetto: maxPathLenght - (answ.Length - maxPathLenght) - con pulizia eventuali doppie barre
|
|
answ = string.Format("/{0}/{1}/{2}/{3}/{4}_{5}/", utils.cleanPathName(metaDati.commessa), utils.cleanPathName(metaDati.fase), metaDati.InOut, utils.cleanPathName(metaDati.fonte), aammgg, utils.shrinkString(utils.cleanPathName(metaDati.oggetto), maxPathLenght - (answ.Length - maxFullPathLenght))).Replace("//", "/").Replace("//", "/").Replace("//", "/");
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
// return!
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// path caricamento temporaneo utente
|
|
/// </summary>
|
|
public string UserTempPath
|
|
{
|
|
get
|
|
{
|
|
string path = "";
|
|
// prima il path
|
|
try
|
|
{
|
|
if (utils.obj.StringSessionObj("UserTempPath") != "")
|
|
{
|
|
path = utils.obj.StringSessionObj("UserTempPath");
|
|
}
|
|
else
|
|
{
|
|
path = string.Format("{0}/{1}", utils.obj.confReadString("tempUplDir"), utils.obj.currUser_FS);
|
|
utils.obj.setSessionVal("UserTempPath", path);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Info("errore check directory: {0}", exc);
|
|
}
|
|
return path;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// metadati documento attualmente in sessione
|
|
/// </summary>
|
|
public docMetaDataSet currMetaData
|
|
{
|
|
get
|
|
{
|
|
docMetaDataSet answ = new docMetaDataSet();
|
|
try
|
|
{
|
|
answ = (docMetaDataSet)utils.obj.objSessionObj("metaDatiDoc");
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
utils.obj.setSessionVal("metaDatiDoc", value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// inizializza e restituisce un oggetto metadati da un idxFile
|
|
/// </summary>
|
|
/// <param name="idxFile"></param>
|
|
/// <returns></returns>
|
|
public docMetaDataSet docMetaFromIdxFile(int idxFile)
|
|
{
|
|
docMetaDataSet currMeta = new docMetaDataSet();
|
|
try
|
|
{
|
|
DS_WebScip.tbDocumentiRow rigaDoc = utils.obj.taDoc.getByIdxFile(idxFile)[0];
|
|
// assegno valori meta!
|
|
currMeta.commessa = rigaDoc.Commessa;
|
|
currMeta.dataDoc = rigaDoc.DataDoc;
|
|
currMeta.dataRic = rigaDoc.DataRic;
|
|
currMeta.fase = rigaDoc.Fase;
|
|
currMeta.fonte = rigaDoc.Fonte;
|
|
currMeta.InOut = rigaDoc.InOut;
|
|
currMeta.isRed = rigaDoc.isRed;
|
|
currMeta.oggetto = rigaDoc.Oggetto;
|
|
currMeta.path = rigaDoc.fullPath.Replace(utils.obj.confReadString("archiveDirRed"), "").Replace(utils.obj.confReadString("archiveDir"), "");
|
|
currMeta.reqProto = (rigaDoc.Numero > 0);
|
|
// recupero tags!
|
|
DS_WebScip.Tags2DocDataTable tabTags = utils.obj.taTags2Doc.getByIdxFile(idxFile);
|
|
List<string> tags = new List<string>();
|
|
foreach (DS_WebScip.Tags2DocRow tag in tabTags)
|
|
{
|
|
tags.Add(tag.idxTag.ToString());
|
|
}
|
|
currMeta.tags = tags;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error("Errore creazione oggetot meta da idxFile: {0}", exc);
|
|
}
|
|
|
|
return currMeta;
|
|
}
|
|
/// <summary>
|
|
/// idxFile da editare (in sessione)
|
|
/// </summary>
|
|
public int idxFileEdit
|
|
{
|
|
get
|
|
{
|
|
return utils.obj.IntSessionObj("idxFileEdit");
|
|
}
|
|
set
|
|
{
|
|
utils.obj.setSessionVal("idxFileEdit", value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// calcola se i metadati NECESSARI siano compilati/presenti in session, ovvero
|
|
/// - commessa
|
|
/// - fase
|
|
/// - fonte
|
|
/// - oggetto
|
|
/// - in/out
|
|
/// - dataDoc
|
|
/// </summary>
|
|
public bool metaPresent
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = (currMetaData.commessa != "" && currMetaData.fase != "" && currMetaData.fonte != "" && currMetaData.oggetto != "" && currMetaData.InOut != "" && currMetaData.dataDoc.ToShortDateString() != "");
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// nome del file da idx DB
|
|
/// </summary>
|
|
/// <param name="idxFile"></param>
|
|
/// <returns></returns>
|
|
public static string nomeFileFromIdxFile(int idxFile)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = utils.obj.taDoc.getByIdxFile(idxFile)[0].NomeFile;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// nome del file da idx DB
|
|
/// </summary>
|
|
/// <param name="idxFile"></param>
|
|
/// <returns></returns>
|
|
public static string nomeFileFullFromIdxFile(int idxFile)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = utils.obj.taDoc.getByIdxFile(idxFile)[0].Nome;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// protocollo del file da idx DB
|
|
/// </summary>
|
|
/// <param name="idxFile"></param>
|
|
/// <returns></returns>
|
|
public static string protocolloFromIdxFile(int idxFile)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = string.Format("{0}-{1}", utils.obj.taDoc.getByIdxFile(idxFile)[0].Numero, utils.obj.taDoc.getByIdxFile(idxFile)[0].Anno);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// commessa del file da idx DB
|
|
/// </summary>
|
|
/// <param name="idxFile"></param>
|
|
/// <returns></returns>
|
|
public static string commessaFromIdxFile(int idxFile)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = string.Format("{0}", utils.obj.taDoc.getByIdxFile(idxFile)[0].Commessa);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// oggetto del file da idx DB
|
|
/// </summary>
|
|
/// <param name="idxFile"></param>
|
|
/// <returns></returns>
|
|
public static string oggettoFromIdxFile(int idxFile)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = string.Format("{0}", utils.obj.taDoc.getByIdxFile(idxFile)[0].Oggetto);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// fonte del file da idx DB
|
|
/// </summary>
|
|
/// <param name="idxFile"></param>
|
|
/// <returns></returns>
|
|
public static string fonteFromIdxFile(int idxFile)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = string.Format("{0}", utils.obj.taDoc.getByIdxFile(idxFile)[0].Fonte);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// statored/pubblico da idx DB
|
|
/// </summary>
|
|
/// <param name="idxFile"></param>
|
|
/// <returns></returns>
|
|
public static bool isRedFromIdxFile(int idxFile)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = utils.obj.taDoc.getByIdxFile(idxFile)[0].isRed;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// redattore da idx DB
|
|
/// </summary>
|
|
/// <param name="idxFile"></param>
|
|
/// <returns></returns>
|
|
public static string redattoreFromIdxFile(int idxFile)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = utils.obj.taDoc.getByIdxFile(idxFile)[0].Redattore;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// path da idx DB
|
|
/// </summary>
|
|
/// <param name="idxFile"></param>
|
|
/// <returns></returns>
|
|
public static string pathFromIdxFile(int idxFile)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = utils.obj.taDoc.getByIdxFile(idxFile)[0].fullPath;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// fornisce email dato codice fornitore
|
|
/// </summary>
|
|
/// <param name="codForn"></param>
|
|
/// <returns></returns>
|
|
public static string emailDaCodForn(string codForn)
|
|
{
|
|
string answ = codForn;
|
|
try
|
|
{
|
|
answ = utils.obj.taEmailForn.getByCodForn(codForn)[0].Email;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// converte una lista tags in una stringa unica con separatore
|
|
/// </summary>
|
|
/// <param name="tags"></param>
|
|
/// <param name="separatore"></param>
|
|
/// <returns></returns>
|
|
public static string stringFromList(List<string> tags, string separatore)
|
|
{
|
|
string answ = "";
|
|
if (tags.Capacity > 0)
|
|
{
|
|
foreach (string item in tags)
|
|
{
|
|
answ += string.Format("{0}{1}", item, separatore);
|
|
}
|
|
// tolgo ultimo separatore
|
|
answ = answ.Substring(0, answ.Length - separatore.Length);
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// converte una stringa unica con separatore in una lista tags
|
|
/// </summary>
|
|
/// <param name="elenco"></param>
|
|
/// <param name="separatore"></param>
|
|
/// <returns></returns>
|
|
public static List<string> listFromString(string elenco, string separatore)
|
|
{
|
|
List<string> answ = new List<string>();
|
|
if (elenco.Length > 0)
|
|
{
|
|
char sep = Convert.ToChar(separatore);
|
|
answ = elenco.Split(sep).ToList();
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Creates an eml file to be delivered with the default mail client
|
|
/// </summary>
|
|
/// <param name="from">address that sends the email</param>
|
|
/// <param name="to">address to which send the email</param>
|
|
/// <param name="subject">subject</param>
|
|
/// <param name="body">body</param>
|
|
/// <param name="attachments">list of attachments</param>
|
|
/// <param name="destFolder">destination folder to store the file</param>
|
|
/// <returns>The complete path of the newely generated EML file</returns>
|
|
public static string CreaEml(string from, string to, string subject, string body, IEnumerable<Attachment> attachments, string destFolder)
|
|
{
|
|
using (MailMessage mail = new MailMessage())
|
|
{
|
|
mail.From = new MailAddress(from);
|
|
mail.To.Add(to);
|
|
mail.Subject = subject;
|
|
mail.Body = body;
|
|
if (attachments != null)
|
|
foreach (var attachment in attachments)
|
|
mail.Attachments.Add(attachment);
|
|
|
|
SmtpClient smtpClient = new SmtpClient
|
|
{
|
|
PickupDirectoryLocation = destFolder,
|
|
DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory
|
|
};
|
|
smtpClient.Send(mail);
|
|
}
|
|
|
|
DirectoryInfo dir = new DirectoryInfo(destFolder);
|
|
FileInfo file = dir.GetFiles("*.eml", SearchOption.TopDirectoryOnly).OrderByDescending(m => m.CreationTimeUtc).First();
|
|
// hack: inserisco il campo "non inviato" nel file di testo della email... "X-Unsent: 1" va messo all'inizio x cui rileggo file e lo riscrivo!
|
|
string nomeFile = file.Name;
|
|
string contenutoEmail = "X-Unsent: 1";
|
|
contenutoEmail += Environment.NewLine;
|
|
StreamReader sr = file.OpenText();
|
|
contenutoEmail += sr.ReadToEnd();
|
|
sr.Close();
|
|
// scrivo nuovo testo!
|
|
StreamWriter sw = file.CreateText();
|
|
sw.Write(contenutoEmail);
|
|
sw.Flush();
|
|
return file.Name;
|
|
}
|
|
/// <summary>
|
|
/// effettua operazione di archiviazione file
|
|
/// </summary>
|
|
/// <param name="docsData">oggetto metadati documento</param>
|
|
/// <param name="pathOrig">path origine del file</param>
|
|
/// <param name="pathDest">path di destinazione del file</param>
|
|
/// <param name="nomeFile">nome del file da archiviare</param>
|
|
/// <param name="redattore">redattore</param>
|
|
/// <returns>restituisce valore INT del nuovo file archiviato</returns>
|
|
public static int archiviaFile(docMetaDataSet docsData, string pathOrig, string pathDest, string nomeFile, string redattore)
|
|
{
|
|
Logger lg = LogManager.GetCurrentClassLogger();
|
|
int answ = 0;
|
|
string autore = ""; // tolto!
|
|
string numComm = "";
|
|
string annoComm = "";
|
|
// ricavo num ed anno commessa...
|
|
try
|
|
{
|
|
numComm = docsData.commessa.Substring(0, docsData.commessa.IndexOf("-"));
|
|
annoComm = docsData.commessa.Substring(docsData.commessa.IndexOf("-") + 1);
|
|
}
|
|
catch
|
|
{ }
|
|
// salvo su db le info del file...
|
|
int? newIdxFile = 0;
|
|
utils.obj.taDoc.insertQuery(nomeFile, pathDest, utils.obj.currUserAD, docsData.reqProto, docsData.dataRic, docsData.dataDoc, numComm, annoComm, docsData.fase, docsData.fonte, docsData.oggetto, docsData.InOut, autore, redattore, docsData.isRed, ref newIdxFile);
|
|
// salvo i tags!
|
|
if (newIdxFile > 0)
|
|
{
|
|
// se ho tags...
|
|
if (docsData.tags.Count > 0)
|
|
{
|
|
foreach (string tag in docsData.tags)
|
|
{
|
|
try
|
|
{
|
|
utils.obj.taTags2Doc.Insert((int)newIdxFile, Convert.ToInt32(tag));
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
}
|
|
answ = (int)newIdxFile;
|
|
}
|
|
// ricalcolo nome file
|
|
string newFileName = WebShipUtils.nomeFileFullFromIdxFile((int)newIdxFile);
|
|
// verifico riesca a creare folder
|
|
DirectoryInfo _di = fileMover.checkDir(pathDest);
|
|
// controllo buon fine!
|
|
bool fatto = false;
|
|
if (_di != null)
|
|
{
|
|
string fullNameDest = string.Format("{0}/{1}", pathDest, newFileName).Replace("//", "/");
|
|
// controllo possa creare file...
|
|
if (fileMover.fileCouldExist(fullNameDest))
|
|
{
|
|
// sposto file
|
|
fatto = fileMover.obj.muoviFile(pathOrig, pathDest, nomeFile, newFileName, true);
|
|
}
|
|
else
|
|
{
|
|
lg.Error(string.Format("Impossibile creare file con questo nome: {0}", fullNameDest));
|
|
}
|
|
}
|
|
// restituisco idxFile...
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// aggiorna file archiviato (prendendo da temp utente!)
|
|
/// </summary>
|
|
/// <param name="nomeFile"></param>
|
|
public void aggiornaFileArchiviato(string nomeFile)
|
|
{
|
|
lg.Info("Caricato file {0} per sostituzione", nomeFile);
|
|
int idxFile = WebShipUtils.mng.idxFileEdit;
|
|
// effettuo operazioni sostituzione file!
|
|
docMetaDataSet docsData = WebShipUtils.mng.docMetaFromIdxFile(idxFile);
|
|
string path = docsData.path;
|
|
if (path != "")
|
|
{
|
|
// calcolo path
|
|
path = string.Format("{0}{1}", utils.obj.confReadString("archiveDir"), docsData.path);
|
|
// elimino file vecchio
|
|
fileMover.obj.eliminaFile(path, WebShipUtils.nomeFileFullFromIdxFile(idxFile));
|
|
// aggiorno su DB
|
|
utils.obj.taDoc.updateFile(idxFile, utils.obj.currUserAD, nomeFile, path);
|
|
lg.Info("Aggiornato in db nome file {0} per sostituzione", nomeFile);
|
|
// ricalcolo nome file
|
|
string newFileName = WebShipUtils.nomeFileFullFromIdxFile(idxFile);
|
|
// sposto file
|
|
fileMover.obj.muoviFile(WebShipUtils.mng.UserTempPath, path, nomeFile, newFileName, true);
|
|
lg.Info("Spostato file {0} per sostituzione", nomeFile);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// elimina il file archiviato e resetta metadati a empty
|
|
/// </summary>
|
|
/// <param name="nomeFile"></param>
|
|
public void deleteRecordAndFile(int idxFile)
|
|
{
|
|
string nomeFile = "ETS-Proto.docx";
|
|
lg.Info("Eliminato file {0} per svuotamento record", idxFile);
|
|
// effettuo operazioni sostituzione file!
|
|
docMetaDataSet docData = WebShipUtils.mng.docMetaFromIdxFile(idxFile);
|
|
docMetaDataSet docDataEmpty = emptyDocData(DateTime.Now);
|
|
string numComm = "";
|
|
string annoComm = "";
|
|
// ricavo num ed anno commessa...
|
|
try
|
|
{
|
|
numComm = docDataEmpty.commessa.Substring(0, docDataEmpty.commessa.IndexOf("-"));
|
|
annoComm = docDataEmpty.commessa.Substring(docDataEmpty.commessa.IndexOf("-") + 1);
|
|
}
|
|
catch
|
|
{ }
|
|
string path = docData.path;
|
|
string newPath = "";
|
|
if (path != "")
|
|
{
|
|
// calcolo path attuale
|
|
if (docData.isRed)
|
|
{
|
|
path = string.Format("{0}{1}", utils.obj.confReadString("archiveDirRed"), docData.path);
|
|
}
|
|
else
|
|
{
|
|
path = string.Format("{0}{1}", utils.obj.confReadString("archiveDir"), docData.path);
|
|
}
|
|
newPath = string.Format("{0}{1}", utils.obj.confReadString("archiveDirRed"), docDataEmpty.path);
|
|
// elimino file vecchio
|
|
fileMover.obj.eliminaFile(path, WebShipUtils.nomeFileFullFromIdxFile(idxFile));
|
|
// aggiorno su DB
|
|
utils.obj.taDoc.updateQuery(idxFile, utils.obj.currUserAD, docDataEmpty.dataRic, docDataEmpty.dataDoc, numComm, annoComm, docDataEmpty.fase, docDataEmpty.fonte, docDataEmpty.oggetto, docDataEmpty.InOut, docDataEmpty.isRed);
|
|
//utils.obj.taDoc.updateFile(idxFile, utils.obj.currUserAD, nomeFile, path);
|
|
utils.obj.taDoc.updateFile(idxFile, utils.obj.currUserAD, nomeFile, newPath);
|
|
lg.Info("Aggiornato in db nome file {0} per sostituzione causa svuotamento", nomeFile);
|
|
// ricalcolo nome file
|
|
string newFileName = WebShipUtils.nomeFileFullFromIdxFile(idxFile);
|
|
// sposto file
|
|
//fileMover.obj.muoviFile("~/DocTemplates/", path, nomeFile, newFileName, false);
|
|
fileMover.obj.muoviFile("~/DocTemplates/", newPath, nomeFile, newFileName, false);
|
|
lg.Info("Spostato file {0} per sostituzione causa svuotamento", nomeFile);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// salva su db il tempalte dei metadati correnti
|
|
/// </summary>
|
|
/// <param name="userId">user id (AD) univoco</param>
|
|
/// <param name="setName">nome del dataset</param>
|
|
/// <param name="docsData">metadati</param>
|
|
public void salvaTemplateMedatati(string userId, string setName, docMetaDataSet docsData)
|
|
{
|
|
string tagString = "";
|
|
try
|
|
{
|
|
if (docsData.tags.Capacity > 0)
|
|
{
|
|
tagString = stringFromList(docsData.tags.ToList(), "#");
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
utils.obj.taTMD.Insert(userId, setName, docsData.commessa, docsData.fase, docsData.fonte, docsData.oggetto, docsData.dataRic, docsData.dataDoc, docsData.path, docsData.InOut, docsData.reqProto, docsData.isRed, tagString);
|
|
}
|
|
/// <summary>
|
|
/// restituisce il tempalte metadati
|
|
/// </summary>
|
|
/// <param name="userId"></param>
|
|
/// <param name="setName"></param>
|
|
/// <returns></returns>
|
|
public docMetaDataSet recuperaTemplateMedatati(string userId, string setName)
|
|
{
|
|
docMetaDataSet answ = new docMetaDataSet();
|
|
DS_WebScip.tbMetaDataSetRow riga;
|
|
try
|
|
{
|
|
riga = utils.obj.taTMD.getByKey(userId, setName)[0];
|
|
answ.commessa = riga.Commessa;
|
|
answ.fase = riga.Fase;
|
|
answ.fonte = riga.Fonte;
|
|
answ.oggetto = riga.Oggetto;
|
|
answ.dataRic = riga.DataRic;
|
|
answ.dataDoc = riga.DataDoc;
|
|
answ.path = riga.path;
|
|
answ.InOut = riga.InOut;
|
|
answ.reqProto = riga.isProto;
|
|
answ.isRed = riga.isRed;
|
|
answ.tags = listFromString(riga.tags, "#");
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// elimina il tempalte dei metadati indicato
|
|
/// </summary>
|
|
/// <param name="userId"></param>
|
|
/// <param name="setName"></param>
|
|
public void eliminaTemplateMedatati(string userId, string setName)
|
|
{
|
|
utils.obj.taTMD.deleteQuery(userId, setName);
|
|
}
|
|
/// <summary>
|
|
/// determina se l'utente possa vedere records taggati Red
|
|
/// </summary>
|
|
public bool userCanSeeRed
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
// controllo se in sessione
|
|
if (utils.obj.isInSessionObject("userCanSeeRed"))
|
|
{
|
|
answ = utils.obj.BoolSessionObj("userCanSeeRed");
|
|
}
|
|
else
|
|
{
|
|
answ = (userIsUserRed || userIsPowerUserRed);
|
|
utils.obj.setSessionVal("userCanSeeRed", answ);
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// determina se l'utente sia poweruser
|
|
/// </summary>
|
|
public bool userIsPowerUser
|
|
{
|
|
get
|
|
{
|
|
bool answ = utils.obj.userHasRight(utils.obj.currUserAD, utils.obj.confReadString("CodModulo"), "PowerUser");
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// determina se l'utente sia poweruser
|
|
/// </summary>
|
|
public bool userIsUserRed
|
|
{
|
|
get
|
|
{
|
|
bool answ = utils.obj.userHasRight(utils.obj.currUserAD, utils.obj.confReadString("CodModulo"), "UserRed");
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// determina se l'utente sia poweruser Red
|
|
/// </summary>
|
|
public bool userIsPowerUserRed
|
|
{
|
|
get
|
|
{
|
|
bool answ = utils.obj.userHasRight(utils.obj.currUserAD, utils.obj.confReadString("CodModulo"), "PowerUserRed");
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// determina se la data sia coperta da almeno un record segnaposto isRed, altrimenti lo crea!
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <returns></returns>
|
|
public static void dateIsOk(DateTime data)
|
|
{
|
|
bool answ = false;
|
|
string searchAll = "*";
|
|
docMetaDataSet docsData = emptyDocData(data);
|
|
try
|
|
{
|
|
answ = utils.obj.taDoc.getBySearch(data.Date, data.Date.AddDays(1), docsData.commessa, docsData.fase, docsData.fonte, docsData.InOut, searchAll, docsData.isRed).Rows.Count > 0;
|
|
}
|
|
catch
|
|
{ }
|
|
// se non c'è doc hole quotidiano lo crea!
|
|
if (!answ)
|
|
{
|
|
string nomeFile = "ETS-Proto.docx";
|
|
WebShipUtils.mng.generaDocDaTemplate(nomeFile, docsData);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// restituisce un set di dati "empty" utile x reset
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <returns></returns>
|
|
public static docMetaDataSet emptyDocData(DateTime data)
|
|
{
|
|
docMetaDataSet docsData = new docMetaDataSet();
|
|
docsData.commessa = string.Format("0000-{0}", data.Year);
|
|
docsData.dataDoc = data;
|
|
docsData.dataRic = data;
|
|
docsData.fase = "ALTRE";
|
|
docsData.fonte = "ETS Engineering & Technical Services S.p.A.";
|
|
docsData.InOut = "Out";
|
|
docsData.oggetto = "n.d.";
|
|
docsData.isRed = true;
|
|
docsData.path = path(docsData);
|
|
docsData.reqProto = true;
|
|
docsData.tags = new List<string>();
|
|
return docsData;
|
|
}
|
|
/// <summary>
|
|
/// genera un doc da template, tramite
|
|
/// - salvataggio
|
|
/// - spostamento "dummy file"
|
|
/// - enter in modalità editing
|
|
/// </summary>
|
|
/// <param name="nomeTemplate">file TEMPLATE</param>
|
|
/// <param name="docsData">metadati</param>
|
|
public int generaDocDaTemplate(string nomeTemplate, docMetaDataSet docsData)
|
|
{
|
|
int idxFile = 0;
|
|
fileMover.obj.muoviFile("~/DocTemplates/", UserTempPath, nomeTemplate, false);
|
|
//check del path
|
|
string pathDest = docsData.path;
|
|
if (pathDest != "")
|
|
{
|
|
// ulteriore verifica del path sotto dimensione massima...
|
|
if (pathDest.Length > utils.obj.confReadInt("maxFullPathLenght"))
|
|
{
|
|
// loggo!
|
|
lg.Error("Errore: trovato path troppo lungo ({0} char): {1}", pathDest.Length, pathDest);
|
|
}
|
|
// verifico se è comunicazione red = riservata
|
|
string comPath = "";
|
|
if (!docsData.isRed)
|
|
{
|
|
comPath = utils.obj.confReadString("archiveDir");
|
|
}
|
|
else
|
|
{
|
|
comPath = utils.obj.confReadString("archiveDirRed");
|
|
}
|
|
// aggiunto al path cartella archivio corretta...
|
|
pathDest = string.Format("{0}{1}", comPath, docsData.path);
|
|
// fix redattore
|
|
string redattore = utils.obj.currUserNomeCognome; // usa utente corrente
|
|
idxFile = WebShipUtils.archiviaFile(docsData, UserTempPath, pathDest, nomeTemplate, redattore);
|
|
// recupero dati documento
|
|
docsData = docMetaFromIdxFile(idxFile);
|
|
// recupero full path del documento
|
|
string fullPath = HttpContext.Current.Server.MapPath(string.Format("{0}{1}", pathDest, WebShipUtils.nomeFileFullFromIdxFile(idxFile)));
|
|
string NumProt = WebShipUtils.protocolloFromIdxFile(idxFile);
|
|
string NumCommessa = WebShipUtils.commessaFromIdxFile(idxFile);
|
|
string OggettoDoc = WebShipUtils.oggettoFromIdxFile(idxFile);
|
|
string FonteDoc = WebShipUtils.fonteFromIdxFile(idxFile);
|
|
string FaxNum = "-"; //Il numero di fax del destinatario (desunto, se c’è, dal DB di TheBook)
|
|
try
|
|
{
|
|
DS_utils.v_selFonti_explDataTable tabVSFE = utils.obj.taVSFE.getByFonte(FonteDoc);
|
|
if (tabVSFE.Rows.Count > 0)
|
|
{
|
|
FaxNum = tabVSFE[0].Fax;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
// controllo se fax nullo lo intercetto...
|
|
if (FaxNum == "")
|
|
{
|
|
FaxNum = "-";
|
|
}
|
|
// se il nome contiene "docx" faccio sostituzioni...
|
|
if (nomeTemplate.IndexOf("docx") >= 0)
|
|
{
|
|
try
|
|
{
|
|
// prendo il nuovo file generato e sostituisco parte del nome con il codice protocollo // link: msdn.microsoft.com/en-us/library/bb508261.aspx
|
|
officeXmlMan.replaceDocxText(fullPath, "NumProt", NumProt);
|
|
officeXmlMan.replaceDocxText(fullPath, "DataDoc", docsData.dataDoc.ToShortDateString());
|
|
officeXmlMan.replaceDocxText(fullPath, "NumCommessa", NumCommessa);
|
|
officeXmlMan.replaceDocxText(fullPath, "OggettoDoc", OggettoDoc);
|
|
officeXmlMan.replaceDocxText(fullPath, "RedattoreDoc", utils.obj.currUserCognomeNome);
|
|
officeXmlMan.replaceDocxText(fullPath, "FaxNum", FaxNum);
|
|
officeXmlMan.replaceDocxText(fullPath, "FonteDoc", FonteDoc);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error("Errore replace testo: {0}", exc);
|
|
}
|
|
}
|
|
else if (nomeTemplate.IndexOf("eml") >= 0)
|
|
{
|
|
// creo un NUOVO file alla destinazione sostituendo l'esistente con apposita classe
|
|
string mittente = utils.obj.currUserEmail;
|
|
// controllo, se non è valida carico email "fuffa"
|
|
if (mittente.IndexOf("@") < 0)
|
|
{
|
|
mittente = utils.obj.confReadString("stdEmail");
|
|
}
|
|
// calcolo destinatario
|
|
string destinatario = WebShipUtils.emailDaCodForn(docsData.fonte);
|
|
// controllo email dest valida...
|
|
if (destinatario.IndexOf("@") < 0)
|
|
{
|
|
destinatario = mittente;
|
|
}
|
|
/* *************************************************************
|
|
* Struttura formato campi:
|
|
* {0} = newline
|
|
* {1} = oggetto
|
|
* {2} = numProtocollo (nnnn-aaaa)
|
|
* {3} = dataDoc
|
|
* {4} = commessa (nnnn-aaaa)
|
|
* {5} = redattore
|
|
* {6} = mittente
|
|
* *************************************************************/
|
|
string subject = string.Format(utils.obj.confReadString("mailSubject"), Environment.NewLine, docsData.oggetto, NumProt, docsData.dataDoc, docsData.commessa, redattore, mittente);
|
|
|
|
string body = "";
|
|
body += string.Format(utils.obj.confReadString("mailBody01"), Environment.NewLine, docsData.oggetto, NumProt, docsData.dataDoc, docsData.commessa, redattore, mittente);
|
|
body += string.Format(utils.obj.confReadString("mailBody02"), Environment.NewLine, docsData.oggetto, NumProt, docsData.dataDoc, docsData.commessa, redattore, mittente);
|
|
body += string.Format(utils.obj.confReadString("mailBody03"), Environment.NewLine, docsData.oggetto, NumProt, docsData.dataDoc, docsData.commessa, redattore, mittente);
|
|
body += string.Format(utils.obj.confReadString("mailBody04"), Environment.NewLine, docsData.oggetto, NumProt, docsData.dataDoc, docsData.commessa, redattore, mittente);
|
|
body += string.Format(utils.obj.confReadString("mailBody05"), Environment.NewLine, docsData.oggetto, NumProt, docsData.dataDoc, docsData.commessa, redattore, mittente);
|
|
// creo vera email!
|
|
string newFileName = WebShipUtils.CreaEml(mittente, destinatario, subject, body, null, HttpContext.Current.Server.MapPath(pathDest));
|
|
// sostituisco file appena creato con quello nuovo
|
|
fileMover.obj.muoviFile(pathDest, pathDest, newFileName, WebShipUtils.nomeFileFullFromIdxFile(idxFile), true);
|
|
}
|
|
}
|
|
return idxFile;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// set metadati x WebShip
|
|
/// </summary>
|
|
public struct docMetaDataSet
|
|
{
|
|
/// <summary>
|
|
/// commessa (formato nnnnnn-yyyy)
|
|
/// </summary>
|
|
public string commessa;
|
|
/// <summary>
|
|
/// fase
|
|
/// </summary>
|
|
public string fase;
|
|
/// <summary>
|
|
/// fonte (IN/OUT)
|
|
/// </summary>
|
|
public string fonte;
|
|
/// <summary>
|
|
/// oggetto
|
|
/// </summary>
|
|
public string oggetto;
|
|
/// <summary>
|
|
/// data documento
|
|
/// </summary>
|
|
public DateTime dataDoc;
|
|
/// <summary>
|
|
/// data ricevimento doc
|
|
/// </summary>
|
|
public DateTime dataRic;
|
|
/// <summary>
|
|
/// path su FS
|
|
/// </summary>
|
|
public string path;
|
|
/// <summary>
|
|
/// stringa In/Out
|
|
/// </summary>
|
|
public string InOut;
|
|
/// <summary>
|
|
/// boolean: richiesto protocollo
|
|
/// </summary>
|
|
public bool reqProto;
|
|
/// <summary>
|
|
/// boolean: comunicazioen RED (riservata)
|
|
/// </summary>
|
|
public bool isRed;
|
|
/// <summary>
|
|
/// elenco tags
|
|
/// </summary>
|
|
public List<string> tags;
|
|
}
|
|
} |