public ActionResult Upload(UploadedExcelSheetViewModel viewmodel)
{
if (ModelState.IsValid) // validate file exist
{
if (viewmodel.ExcelFile != null && viewmodel.ExcelFile.ContentLength > 0)
{
var fileName = Path.GetFileName(viewmodel.ExcelFile.FileName);
var path = Path.Combine(Server.MapPath("~/Uploads/PaySources/"), DateTime.Now.GetTimeStamp() + "_" + fileName);
List <PaySource> addedPaySources = new List <PaySource>();
viewmodel.ExcelFile.SaveAs(path); // save a copy of the uploaded file.
// convert the uploaded file into datatable, then add/update db entities.
var dtServers = ImportUtils.ImportXlsxToDataTable(viewmodel.ExcelFile.InputStream, true);
int numOfPaySourcesUpdated = 0;
foreach (var row in dtServers.AsEnumerable().ToList())
{
var entityViewModel = new PaySourceAddViewModel()
{
VendorId = int.Parse(row["PaySourceId"].ToString()),
// some columns does not have ',' separater.
Description = row["Description"].ToString(),
//Active = row["active"].ToString() == "Y" ? true : false,
};
//check if paysource does not exist
if (!string.IsNullOrWhiteSpace(row["PaySourceId"].ToString()))
{
var existedEntity = _paySourceService.GetByVendorId(entityViewModel.VendorId);
if (existedEntity == null)
{
var entity = Mapper.Map <PaySourceAddViewModel, PaySource>(entityViewModel);
addedPaySources.Add(entity);
}
else
{
Mapper.Map(entityViewModel, existedEntity);
_paySourceService.UpdatePaySource(existedEntity);
numOfPaySourcesUpdated++;
}
}
}
if (addedPaySources.Any())
{
_paySourceService.AddPaySources(addedPaySources);
}
Success($"<strong>{addedPaySources.Count}</strong> PaySources have been successfully added. <br\\>"
+ $"<strong>{numOfPaySourcesUpdated}</strong> PaySources have been successfully updated.");
}
return(RedirectToAction("Index"));
}
return(View(viewmodel));
}
public static void ImportSelected()
{
if (!ImportUtils.TryFilterExcelFilesInSelection(out var filePaths))
{
return;
}
var exporterNames = ExtractExporterNames(filePaths);
var exporterTypes = ImportUtils.FindImporterTypes()
.Where(e => exporterNames.Contains(e.Name))
.ToArray();
ImportUtils.RunImporters(exporterTypes);
}
public async Task <IActionResult> ImportMedicamentos([FromServices] ITDeveloperDbContext context)
{
var filePath = ImportUtils.GetFilePath("Csv", "Medicamentos", ".CSV"); // DELEGUEI
/// Não importa para esta classe saber como é implementada a leitura e gravação - DELEGUEI
ReadWriteFile rwf = new ReadWriteFile();
if (!await rwf.ReadAndWriteCsvAsync(filePath, context))
{
return(View("JaTemMedicamento", context.Medicamento.AsNoTracking().OrderBy(o => o.Codigo)));
}
return(View("ListaMedicamentos", context.Medicamento.AsNoTracking().OrderBy(o => o.Codigo)));
}
private ImportUtils.PersonLineRet ParsePersonLine(string str)
{
switch (NumbersType)
{
case PersonNumbersType.pnDAboville:
return(ImportUtils.ParsePersonLine_DAboville(str));
case PersonNumbersType.pnKonovalov:
return(ImportUtils.ParsePersonLine_Konovalov(str));
default:
return(null);
}
}
private bool IsGenerationLine(string str)
{
switch (GenerationFormat)
{
case GenerationFormat.gfRome:
return(ImportUtils.IsRomeLine(str));
case GenerationFormat.gfGenWord:
return(str.StartsWith("Поколение ", StringComparison.InvariantCultureIgnoreCase));
default:
return(false);
}
}
private void CheckSpouses(StringList buffer, GEDCOMIndividualRecord curPerson)
{
int num2 = buffer.Count;
for (int i = 0; i < num2; i++)
{
string line = buffer[i];
if (string.IsNullOrEmpty(line))
{
continue;
}
try
{
var slRet = ImportUtils.ParseSpouseLine(line);
if (slRet != null)
{
// define sex
string spSex = slRet.Spouse;
GEDCOMSex sx = (spSex[0] == 'М') ? GEDCOMSex.svMale : GEDCOMSex.svFemale;
// extract name
line = line.Substring(slRet.Pos).Trim();
if (!string.IsNullOrEmpty(line))
{
GEDCOMIndividualRecord spouse = DefinePerson(line, sx);
GEDCOMFamilyRecord family = GetFamilyByNum(curPerson, slRet.MarrNum);
family.AddSpouse(spouse);
// extract marriage date
if (!string.IsNullOrEmpty(slRet.ExtData))
{
string marrDate = slRet.ExtData.Substring(1, slRet.ExtData.Length - 2).Trim();
if (marrDate != "")
{
SetEvent(family, "MARR", marrDate);
}
}
}
}
}
catch (Exception ex)
{
Logger.LogWrite("Importer.CheckSpouses(): " + ex.Message);
}
}
}
private static IWorkbook LoadWorkbook(string path)
{
if (!ImportUtils.IsExcelFile(path))
{
throw new ArgumentException($"Not an Excel file: {path}");
}
IWorkbook workbook;
using (var stream = File.Open(path, FileMode.Open, FileAccess.Read))
{
workbook = new XSSFWorkbook(stream);
}
return(workbook);
}
/// <summary>
/// Funzione per la creazione dell'oggetto protocollo in entrata
/// </summary>
/// <param name="rowData">L'oggetto con le informazioni sul documento da creare</param>
/// <param name="registrySyd">Il system id del registo in cui protocollare</param>
/// <param name="rfSyd">Il system id dell'rf in cui protocollare</param>
/// <param name="administrationSyd">Il system id dell'amministrazione incui creare il documento</param>
/// <param name="isSmistamentoEnabled">True se, da configurazione, è abilitato lo smistamento</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo dell'utente che ha lanciato la procedura</param>
/// <returns>L'oggetto Protocollo con le informazioni sul protocollo in ingresso da creare</returns>
protected override Protocollo CreateProtocolObject(DocumentRowData rowData, string registrySyd, string rfSyd, string administrationSyd, bool isSmistamentoEnabled, InfoUtente userInfo, Ruolo role)
{
// Creazione dell'oggetto ProtocolloEntrata
ProtocolloEntrata inProto = new ProtocolloEntrata();
// Calcolo del mittente del protocollo
// Se è valorizzata la proprietà CorrDesc della rowData, significa che
// il corrispondente è di tipo occasionale
if (rowData.CorrDesc != null && rowData.CorrDesc.Count > 0)
{
// Creazione del corrispondente
inProto.mittente = new Corrispondente();
// Impostazione della descrizione del corrispondente
inProto.mittente.descrizione = rowData.CorrDesc[0];
// Impostazione dell'id amministrazione
inProto.mittente.idAmministrazione = administrationSyd;
// Impostazione del tipo corrispondente ad O
inProto.mittente.tipoCorrispondente = "O";
}
if (rowData.CorrCode != null && rowData.CorrCode.Count > 0)
{
// Altrimenti si procede con il caricamento delle informazioni sul
// corrispondente
inProto.mittente = ImportUtils.GetCorrispondenteByCode(
ParametriRicercaRubrica.CallType.CALLTYPE_PROTO_IN,
rowData.CorrCode[0].Trim(),
role,
userInfo,
registrySyd,
rfSyd,
isSmistamentoEnabled,
TipoUtente.GLOBALE);
}
// Se non è stato ptrovato il corrispondente, eccezione
if (inProto.mittente == null)
{
throw new Exception("Impossibile recuperare le informazioni sul mittente del protocollo.");
}
// Restituzione dell'oggetto con le informazioni sul protocollo
return(inProto);
}
public static IEnumerable <WarrantsInterestSheetInputItem> Parse(Stream inputStream, int sheetIndex, List <MonthlyImportFundExceptionRule> exceptionRules)
{
var results = new List <WarrantsInterestSheetInputItem>();
var columnsToParse = new[] { "Fund", "Name", "Warrant Int" };
var sheetData = ImportUtils.ImportXlsxToDataTable(inputStream, sheetIndex, columnsToParse);
sheetData.AsEnumerable().ForEachWithIndex((row, index) =>
{
var fundResult = StringUtils.ApplyMonthlyImportExceptionRuleOnFund(row["Fund"].ToString(), exceptionRules);
results.Add(new WarrantsInterestSheetInputItem()
{
RowIndex = index + 2, // 2 => one for table header and one for zero-indexed loop
FundId = fundResult.Item2,
IsExceptionRuleMatched = fundResult.Item1,
Name = row["Name"].ToString(),
WarrantInterest = StringUtils.ParseNegativeValue(row["Warrant Int"].ToString()),
});
});
return(results);
}
/// <summary>
/// Funzione per l'estrazione dei dati sui documenti RDE
/// da importare leggendo i dati da foglio Excel
/// </summary>
/// <param name="modelRootPath">Il path in cui andare a salvare il file temporaneo</param>
/// <param name="provider">Il provider dati da utilizzare per la connessione al file Excel</param>
/// <param name="extendedProperties">Le proprietà estese da utilizzare per la connessione al file Excel</param>
/// <param name="fileName">Il nome da attribuire al file temporaneo</param>
/// <param name="content">Il contenuto del file</param>
/// <param name="versionNumber">Il numero di versione dell'importer da utilizzare:
/// - 1 per la versione che non contempla i protocolli interni ed i corrispondenti identificati tramite codice
/// - 2 per la versione che contempla i protocolli interni ed i corrispondenti identificati tramite codice</param>
/// <returns>Il contenitore dei dati estratti dal foglio</returns>
public static DocumentRowDataContainer ReadDataFromExcel(
string modelRootPath,
string provider,
string extendedProperties,
string fileName,
byte[] content,
int versionNumber)
{
// Il path in cui è stato creato il file temportaneo
string completePath;
// L'oggetto da restituire
DocumentRowDataContainer toReturn;
// 1. Creazione del file temporaneo in cui poggiare il foglio
// excel contenente i dati sui documenti da importare
completePath = ImportUtils.CreateTemporaryFile(content, modelRootPath, fileName);
// 2. Lettura metadati
try
{
toReturn = ReadDataFromExcel(
provider,
extendedProperties,
completePath,
versionNumber);
}
catch (Exception e)
{
throw e;
}
finally
{
// 3. Cancellazione file temporaneo
ImportUtils.DeleteTemporaryFile(completePath);
}
// Restituzione del risultato
return(toReturn);
}
public static List <ImportResult> ImportElencoNote(byte[] content, string fileName, string modelPath, DocsPaVO.utente.InfoUtente userInfo)
{
// Il path completo in cui è posizionato il file excel contente le note da importare
string completePath = String.Empty;
// Il risultato dell'elaborazione
List <ImportResult> result = new List <ImportResult>();
try
{
// 1. Creazione del file temporaneo
fileName = fileName.Substring(fileName.LastIndexOf("\\") + 1);
completePath = ImportUtils.CreateTemporaryFile(content, modelPath, fileName);
// 2. Creazione delle note
ArrayList listaRF = BusinessLogic.Utenti.RegistriManager.getListaRegistriRfRuolo(userInfo.idCorrGlobali, "1", "");
result = CreateNote(completePath, listaRF);
// 3. Cancellazione file temporaneo
ImportUtils.DeleteTemporaryFile(completePath);
}
catch (Exception e)
{
// Se il file è stato creato, cancellazione
if (!String.IsNullOrEmpty(completePath))
{
ImportUtils.DeleteTemporaryFile(completePath);
}
// Creazione di un nuovo risultato con i dettagli dell'eccezione
result.Add(new ImportResult()
{
Outcome = ImportResult.OutcomeEnumeration.KO,
Message = e.Message
});
}
// 4. Restituzione del risultato
return(result);
}
/// <summary>
/// Funzione per l'estrazione di dati da una sorgente dati excel
/// </summary>
/// <param name="content">Il contenuto del foglio excel</param>
/// <param name="modelPath">Il path in cui andare a salvare il file temporaneo</param>
/// <param name="fileName">Il nome da associare al file temporaneo</param>
/// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <returns>Un oggetto con le informazioni estratte dalla cartella excel relativi a tutte le tipologie di documenti</returns>
public static DocumentRowDataContainer ReadDataFromExcelFile(
byte[] content,
string modelPath,
string fileName,
InfoUtente userInfo,
Ruolo role,
bool isEnabledPregressi,
bool isStampaUnione,
String provider,
String extendedProperty)
{
// Il path in cui è stato creato il file temportaneo
string completePath;
// L'oggetto da restituire
DocumentRowDataContainer toReturn;
// 1. Creazione del file temporaneo in cui poggiare il foglio
// excel contenente i dati sui documenti da importare
completePath = ImportUtils.CreateTemporaryFile(content, modelPath, fileName);
// 2. Lettura metadati
try
{
toReturn = ReadMetadata(completePath, userInfo, role, isEnabledPregressi, isStampaUnione, provider, extendedProperty);
}
catch (Exception e)
{
throw e;
}
finally
{
// 3. Cancellazione file temporaneo
ImportUtils.DeleteTemporaryFile(completePath);
}
// Restituzione del risultato
return(toReturn);
}
public ActionResult MonthlyReport(MonthlyReportGenerateViewModel viewmodel)
{
if (ModelState.IsValid) // validate file exist
{
if (viewmodel.ExcelFile != null && viewmodel.ExcelFile.ContentLength > 0)
{
SaveUploadedFile(viewmodel.ExcelFile, Server.MapPath("~/Uploads/MonthlyReport/"));
// convert the uploaded file into datatable, then add/update db entities.
var dtBarsHours = ImportUtils.ImportXlsxToDataTable(viewmodel.ExcelFile.InputStream, true, 1);
var excelData = dtBarsHours.AsEnumerable().Select(row =>
{
string account = row["Account"].ToString();
if (account.StartsWith("-"))
{
account = account.Remove(0, 1);
}
return(new MonthlyReportDataViewModel()
{
AccountNumber = account,
Date = DateTime.Parse(row["Date"].ToString()),
Amount = decimal.Parse(row["Amount"].ToString()),
Description = row["Description"].ToString(),
Category = row["Category"].ToString(),
});
}).ToList();
viewmodel.Data = excelData;
ViewBag.DisplayResults = true;
}
}
else
{
ViewBag.DisplayResults = false;
}
return(View(viewmodel));
}
public ActionResult Upload(BarsUploadViewModel viewmodel)
{
if (ModelState.IsValid) // validate file exist
{
if (viewmodel.ExcelFile != null && viewmodel.ExcelFile.ContentLength > 0)
{
var fileName = Path.GetFileName(viewmodel.ExcelFile.FileName);
var path = Path.Combine(Server.MapPath("~/Uploads/Bars/"), DateTime.Now.GetTimeStamp() + "_" + fileName);
List <Bar> addedEntities = new List <Bar>();
viewmodel.ExcelFile.SaveAs(path); // save a copy of the uploaded file.
// convert the uploaded file into datatable, then add/update db entities.
var dtBarsHours = ImportUtils.ImportXlsxToDataTable(viewmodel.ExcelFile.InputStream, true, 1);
var excelData = dtBarsHours.AsEnumerable().Select(row => new BarUploadEntity()
{
Year = int.Parse(row["Year"].ToString()),
BarNumber = row["State BARS Number"].ToString(),
MapToBarNumber = row["Map to"].ToString(),
DisplayName = row["Display Name"].ToString(),
Period = string.IsNullOrWhiteSpace(row["Period"].ToString()) ? (int?)null : int.Parse(row["Period"].ToString()),
IsActive = string.IsNullOrWhiteSpace(row["Is Active"].ToString()) ? false : row["Is Active"].ToString() == "1" ? true : false
}).ToList();
excelData = excelData.GroupBy(x => x.BarNumber).Select(y => y.First()).ToList();
int numOfAddedEntities = 0, numOfUpdatedEntities = 0;
_barService.UploadBars(viewmodel.BarsYear.Value, excelData, out numOfAddedEntities, out numOfUpdatedEntities);
Success($"<strong>{numOfAddedEntities}</strong> records have been successfully added. <br\\>"
+ $"<strong>{numOfUpdatedEntities}</strong> records have been successfully updated.");
}
}
return(RedirectToAction("Index", new
{
year = viewmodel.BarsYear.Value
}));
}
public static void TestInternalChecksumVsExternal()
{
var result = SuperFamiCheckTool.Run(RomFileName);
result.Complement.Should().Be(0x8773);
result.Checksum.Should().Be(0x788c);
(result.Complement + result.Checksum).Should().Be(0xFFFF);
const uint expected4ByteChecksums = 0x788C8773;
result.AllCheckBytes.Should().Be(expected4ByteChecksums);
var project = ImportUtils.ImportRomAndCreateNewProject(RomFileName);
project.Should().NotBeNull("project should have loaded successfully");
project.Data.GetRomByte(0xFFDC).Should().Be(0x73); // complement 1
project.Data.GetRomByte(0xFFDD).Should().Be(0x87); // complement 2
project.Data.GetRomByte(0xFFDE).Should().Be(0x8C); // checksum 1
project.Data.GetRomByte(0xFFDF).Should().Be(0x78); // checksum 2
var complement = project.Data.GetRomWord(0xFFDC);
complement.Should().Be(0x8773); // complement 16bit
var checksum = project.Data.GetRomWord(0xFFDE);
checksum.Should().Be(0x788c); // checksum 16bit
(complement + checksum).Should().Be(0xFFFF);
project.Data.GetRomDoubleWord(0xFFDC).Should().Be((int)expected4ByteChecksums); // complement 16bit
project.Data.RomCheckSumsFromRomBytes.Should().Be(expected4ByteChecksums);
project.InternalCheckSum.Should().Be(expected4ByteChecksums);
result.Complement.Should().Be((uint)complement);
result.Checksum.Should().Be((uint)checksum);
project.Data.ComputeChecksum().Should().Be((ushort)checksum);
project.Data.ComputeIsChecksumValid().Should().Be(true);
var firstByte = project.Data[0x00];
firstByte.Should().NotBe(0);
project.Data[0x00] = 0;
project.Data.ComputeIsChecksumValid().Should().Be(false);
project.Data.FixChecksum();
project.Data.ComputeIsChecksumValid().Should().Be(true);
project.Data[0x00] = firstByte;
project.Data.ComputeIsChecksumValid().Should().Be(false);
project.Data.FixChecksum();
project.Data.ComputeIsChecksumValid().Should().Be(true);
// SNES docs dictate:
// 15. Complement Check (0xFFDC, 0xFFDD)
// 16. Check Sum (0xFFDE, 0xFFDF)
// in the actual ROM file, it appears like this (remember: little endian for SNES)
// complement checksum
// 73 87 8C 78
}
/// <summary>
/// Funzione per la lettura dei dati relativi ad un documenti di emergenza da importare
/// </summary>
/// <param name="dataReader">L'oggetto da cui leggere i dati</param>
/// <param name="protoType">Il tipo di protocollo di emergenza da importare (I, P, A)</param>
/// <param name="versionNumber">Numero di versione dell'importer da utilizzare.
/// - La versione 1 non contempla i protocolli interni ed i codici per mittenti e destinatari
/// - La versione 2 contempla i protocolli interni ed i codici per mittenti e destinatari</param>
/// <returns>La lista dei dati relativi ai documenti da creare</returns>
private static List <DocumentRowData> ReadDocumentData(OleDbDataReader dataReader, string protoType, int versionNumber)
{
// L'oggetto da restituire
List <DocumentRowData> toReturn;
// Oggetto in cui contenere temporaneamente i dati
RDEDocumentRowData temporaryData;
// La data di protocollazione
DateTime protoDate;
// Creazione della lista da restituire
toReturn = new List <DocumentRowData>();
// Estrazione dei dati relativi ai protocollo di emergenza da importare
while (dataReader.Read())
{
// Creazione oggetto temporaneo
temporaryData = new RDEDocumentRowData();
// Creazione array codici modelli trasmissione
temporaryData.TransmissionModelCode = new string[0];
// Lettura codice amministrazione
temporaryData.AdminCode = dataReader["Codice Amministrazione"].ToString();
// Parsing della data di protocollazione
if (!String.IsNullOrEmpty(dataReader["Data protocollo emergenza"].ToString()))
{
protoDate = DateTime.Parse(dataReader["Data protocollo emergenza"].ToString());
temporaryData.EmergencyProtocolDate = protoDate.ToString("dd/MM/yyyy");
}
// Parsing dell'ora di protocollazione
if (!String.IsNullOrEmpty(dataReader["Ora protocollo emergenza"].ToString()))
{
protoDate = ImportUtils.ReadDate(dataReader["Ora protocollo emergenza"].ToString());
temporaryData.EmergencyProtocolTime = protoDate.ToString("HH.mm.ss");
}
// Lettura del numero del protocollo di emergenza
temporaryData.OrdinalNumber = dataReader["Numero protocollo emergenza"].ToString();
// Lettura della segnatura del protocollo di emergenza
temporaryData.EmergencyProtocolSignature = dataReader["Stringa protocollo emergenza"].ToString();
// Lettura dell'oggetto del protocollo
temporaryData.Obj = dataReader["Oggetto"].ToString();
// Lettura della data del protocollo mittente
temporaryData.SenderProtocolDate = dataReader["Data protocollo mittente"].ToString();
// Lettura del numero protocollo mittente
temporaryData.SenderProtocolNumber = dataReader["Numero protocollo mittente"].ToString();
// Lettura della data di arrivo se è valorizzato almeno il campo Data arrivo
if (!String.IsNullOrEmpty(dataReader["Data arrivo"].ToString()))
{
temporaryData.ArrivalDate = DateTime.Parse(dataReader["Data arrivo"].ToString()).ToString("dd/MM/yyyy");
// parserizzo l'orario prima di utilizzarlo per verificare la formattazione e sollevare un messaggio di cortesia
if (!String.IsNullOrEmpty(dataReader["Ora arrivo"].ToString()))
{
//DateTime time;
//DateTime.TryParse(dataReader["Ora arrivo"].ToString(), out time);
TimeSpan time;
TimeSpan.TryParse(dataReader["Ora arrivo"].ToString().Replace(".", ":"), out time);
if (time != null)
{
temporaryData.ArrivalTime = time.ToString();
}
}
}
// Lettura del codice di classifica
if (!String.IsNullOrEmpty(dataReader["Codice classifica"].ToString()))
{
temporaryData.ProjectCodes = dataReader["Codice classifica"].ToString().Split(';');
}
// Lettura del codice RF
temporaryData.RFCode = dataReader["Codice RF"].ToString();
// Lettura del codice del registro
temporaryData.RegCode = dataReader["Codice Registro"].ToString();
// A seconda del tipo di protocollo bisogna trattare in modo differente
// i campi relativi ai corrispondenti
switch (protoType.ToUpper())
{
case "A": // Arrivo
// In questo caso i campi da prendere in considerazione sono Mittente e
// Cod_Mittente
if (!String.IsNullOrEmpty(dataReader["Mittente"].ToString()))
{
temporaryData.CorrDesc = new List <string>(
dataReader["Mittente"].ToString().Trim().Split(';'));
}
if (versionNumber != 1 &&
!String.IsNullOrEmpty(dataReader["Cod_Mittente"].ToString()))
{
temporaryData.CorrCode = new List <string>(
dataReader["Cod_Mittente"].ToString().Trim().Split(';'));
}
break;
case "P": // Partenza
case "I": // Interno
// In questi casi bisogna considerare i campi Mittente, Cod_Mittente,
// Destinatari, Cod_Destinari, Destinatari_CC e Cod_Destinatari_CC
if (!String.IsNullOrEmpty(dataReader["Mittente"].ToString()) ||
!String.IsNullOrEmpty(dataReader["Destinatari"].ToString()) ||
!String.IsNullOrEmpty(dataReader["Destinatari_CC"].ToString()))
{
temporaryData.CorrDesc = new List <string>();
}
if (versionNumber != 1 && (
!String.IsNullOrEmpty(dataReader["Cod_Mittente"].ToString()) ||
!String.IsNullOrEmpty(dataReader["Cod_Destinatari"].ToString()) ||
!String.IsNullOrEmpty(dataReader["Cod_Destinatari_CC"].ToString())))
{
temporaryData.CorrCode = new List <string>();
}
if (!String.IsNullOrEmpty(dataReader["Mittente"].ToString()))
{
foreach (string mitt in dataReader["Mittente"].ToString().Trim().Split(';'))
{
temporaryData.CorrDesc.Add(mitt.Trim() + "#M#");
}
}
if (versionNumber != 1 &&
!String.IsNullOrEmpty(dataReader["Cod_Mittente"].ToString()))
{
foreach (string mitt in dataReader["Cod_Mittente"].ToString().Trim().Split(';'))
{
temporaryData.CorrCode.Add(mitt.Trim() + "#M#");
}
}
if (!String.IsNullOrEmpty(dataReader["Destinatari"].ToString()))
{
foreach (string mitt in dataReader["Destinatari"].ToString().Trim().Split(';'))
{
temporaryData.CorrDesc.Add(mitt.Trim() + "#D#");
}
}
if (versionNumber != 1 &&
!String.IsNullOrEmpty(dataReader["Cod_Destinatari"].ToString()))
{
foreach (string mitt in dataReader["Cod_Destinatari"].ToString().Trim().Split(';'))
{
temporaryData.CorrCode.Add(mitt.Trim() + "#D#");
}
}
if (!String.IsNullOrEmpty(dataReader["Destinatari_CC"].ToString()))
{
foreach (string mitt in dataReader["Destinatari_CC"].ToString().Trim().Split(';'))
{
temporaryData.CorrDesc.Add(mitt.Trim() + "#CC#");
}
}
if (versionNumber != 1 &&
!String.IsNullOrEmpty(dataReader["Cod_Destinatari_CC"].ToString()))
{
foreach (string mitt in dataReader["Cod_Destinatari_CC"].ToString().Trim().Split(';'))
{
temporaryData.CorrCode.Add(mitt.Trim() + "#CC#");
}
}
break;
}
// Aggiunta dell'oggetto alla lista degli oggetti da restituire
toReturn.Add(temporaryData);
}
// Restituzione risultato dell'elaborazione
return(toReturn);
}
/// <summary>
/// Funzione per la creazione dell'oggetto protocollo in Ingresso
/// </summary>
/// <param name="rowData">L'oggetto con le informazioni sul documenti interno da creare</param>
/// <param name="registrySyd">Il system id del registro</param>
/// <param name="rfSyd">Il system id dell'RF</param>
/// <param name="administrationSyd">Il system id dell'amministrazione</param>
/// <param name="isSmistamentoEnabled">True se è abilitato lo smistamento</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
/// <returns>L'oggetto con le informazioni sul protocollo da creare</returns>
protected override Protocollo CreateProtocolObject(DocumentRowData rowData, string registrySyd, string rfSyd, string administrationSyd, bool isSmistamentoEnabled, InfoUtente userInfo, Ruolo role)
{
// Creazione dell'oggetto ProtocolloInterno
ProtocolloInterno ownProto = new ProtocolloInterno();
// Il corrispondente da inserire
Corrispondente corr;
// Il codice corrispondente da analizzare
// Questo array dovrà contenere due elementi: Il codice corrispondente
// e la tipologia (M, D, CC)
string[] corrToAdd;
// Creazione lista destinatari e destinatari conoscenza
ownProto.destinatari = new ArrayList();
ownProto.destinatariConoscenza = new ArrayList();
// Per ogni codice corrispondente in CorrCode...
foreach (string corrDesc in rowData.CorrCode)
{
// Spezzettamento dei dati sul corrispondente
corrToAdd = corrDesc.Split('#');
// Se non ci sono più tre elementi, eccezione
// Tre elementi poiché il formato con cui è scritto il codice è
// <Codice>#D|CC#
if (corrToAdd.Length != 3)
{
throw new Exception(String.Format(
"Specifica corrispondente non valida: {0}",
corrDesc));
}
// A seconda del tipo di corrispondente bisogna intraprendere
// azioni differenti
switch (corrToAdd[1].ToUpper().Trim())
{
case "M": // Mittente del protocollo
// Reperimento del corrispondente
corr = ImportUtils.GetCorrispondenteByCode(
ParametriRicercaRubrica.CallType.CALLTYPE_PROTO_INT_MITT,
corrToAdd[0].Trim(),
role,
userInfo,
registrySyd,
rfSyd,
isSmistamentoEnabled,
DocsPaVO.addressbook.TipoUtente.GLOBALE);
// Impostazione del mittente, se individuato
if (corr != null)
{
ownProto.mittente = corr;
}
break;
case "D": // Destinatario principale
// Reperimento del corrispondente
corr = ImportUtils.GetCorrispondenteByCode(
ParametriRicercaRubrica.CallType.CALLTYPE_PROTO_INT_DEST,
corrToAdd[0].Trim(),
role,
userInfo,
registrySyd,
rfSyd,
isSmistamentoEnabled,
DocsPaVO.addressbook.TipoUtente.GLOBALE);
// Aggiunta del corrispondente alla lista dei destinatari, se individuato
if (corr != null)
{
ownProto.destinatari.Add(corr);
}
break;
case "CC": // Destinatario in copia
// Reperimento del corrispondente
corr = ImportUtils.GetCorrispondenteByCode(
ParametriRicercaRubrica.CallType.CALLTYPE_PROTO_INT_DEST,
corrToAdd[0].Trim(),
role,
userInfo,
registrySyd,
rfSyd,
isSmistamentoEnabled,
DocsPaVO.addressbook.TipoUtente.GLOBALE);
// Aggiunta del corrispondente alla lista dei destinatari, se individuato
if (corr != null)
{
ownProto.destinatariConoscenza.Add(corr);
}
break;
}
}
// Aggiornamento di destinatari, mittenti e destinatari in conoscenza
ownProto.daAggiornareDestinatari = true;
ownProto.daAggiornareMittente = true;
ownProto.daAggiornareDestinatariConoscenza = true;
// Restituzione dell'oggetto con le informazioni sul protocollo
return(ownProto);
}
/// <summary>
/// Funzione per la validazione dei dati letti da un foglio excel
/// </summary>
/// <param name="rowData">L'oggetto con i dati da validare</param>
/// <param name="isProfilationRequired">True se è obbligatoria la profilazione del documento</param>
/// <param name="isRapidClassificationRequired">True se è richiesta la classificazione rapida</param>
/// <param name="validationProblems">La lista dei problemi rilevati in fase di verifica dati</param>
/// <returns>True se la validazione passa</returns>
protected override bool CheckDataValidity(DocumentRowData rowData, bool isProfilationRequired, bool isRapidClassificationRequired, out List <string> validationProblems)
{
#region Dichiarazione variabili
// Il risultato della validazione
bool validationResult = true;
// L'oggetto a cui richiedere le informaizoni sull'amministrazione
DocsPaDB.Query_DocsPAWS.Amministrazione administrationManager = null;
// Valore booleano che indica se è obbligatorio specificare l'RF
bool rfRequired = false;
// L'id dell'amministrazione
string administrationSyd = String.Empty;
// Valore booleano utilizzato per verificare se solo uno dei due campi
// Codice Corrispondenti e Corrispondenti è valorizzata
bool corrOk = true;
// Valore utilizzato per indicare se è stato trovato un destinatario
// principale
bool primCorrFound;
// Variabile utilizzata per contare il numero di mittenti specificati
int sendersNum;
#endregion
// Creazione della lista dei problemi
validationProblems = new List <string>();
// L'ordinale è obbligatorio
if (String.IsNullOrEmpty(rowData.OrdinalNumber))
{
validationResult = false;
if (rowData is RDEDocumentRowData)
{
validationProblems.Add("Campo 'Numero protocollo emergenza.");
}
else
{
validationProblems.Add("Campo 'Ordinale' obbligatorio.");
}
}
// Il codice amministrazione è obbligatorio
if (String.IsNullOrEmpty(rowData.AdminCode))
{
validationResult = false;
validationProblems.Add("Campo 'Codice amministrazione' obbligatorio.");
}
// Il codice registro è obbligatorio
if (String.IsNullOrEmpty(rowData.RegCode))
{
validationResult = false;
validationProblems.Add("Campo 'Codice Registro' obbligatorio.");
}
// Il codice RF deve essere obbligatorio se richiesto dalla segnatura
// Creazione dell'oggetto a cui richiedere le informazioni sull'amministrazione
administrationManager = new DocsPaDB.Query_DocsPAWS.Amministrazione();
try
{
administrationSyd = ImportUtils.GetAdministrationId(rowData.AdminCode);
}
catch (Exception e)
{
validationResult = false;
validationProblems.Add(String.Format(
"Impossibile recuperare le informazioni sull'amministrazione {0}",
rowData.AdminCode));
}
// Se non è stato possibile ricavare l'id dell'amministrazione, problema
if (!String.IsNullOrEmpty(administrationSyd))
{
// Si procede con la verifica
// Verifica dell'obbligatorietà della specifica dell'RF
rfRequired = administrationManager.AmmGetListAmministrazioni().Where(
e => e.IDAmm == administrationSyd).FirstOrDefault().
Segnatura.Contains("COD_RF_PROT");
// Se l'RF è richiesto ma non è specificato, la validazione non passa
if (rfRequired && String.IsNullOrEmpty(rowData.RFCode))
{
validationResult = false;
validationProblems.Add("Campo 'Codice RF' obbligatorio in quanto richiesto dalla segnatura.");
}
}
// Se entrambi i campi 'Oggetto' e 'Codice Oggetto' non
// sono valorizzati, la validazione non passa
if (String.IsNullOrEmpty(rowData.ObjCode) &&
String.IsNullOrEmpty(rowData.Obj))
{
validationResult = false;
if (rowData is RDEDocumentRowData)
{
validationProblems.Add("Il campo 'Oggetto' è obbligatorio.");
}
else
{
validationProblems.Add("Non risultano valorizzati nè il campo 'Codice Oggetto' nè il campo 'Oggetto'. Valorizzare uno dei due.");
}
}
// Se entrambi i campi 'Oggetto' e 'Codice oggetto' sono valorizzati, errore
if (!String.IsNullOrEmpty(rowData.ObjCode) &&
!String.IsNullOrEmpty(rowData.Obj))
{
validationResult = false;
validationProblems.Add("Risultano valorizzati entrambi i campi 'Codice Oggetto' e 'Oggetto'. Valorizzare solamente uno.");
}
primCorrFound = false;
sendersNum = 0;
// Se il campo 'Codice Corrispondenti' è valorizzato ma non contiene #D#,
// significa che non è stato specificato un destinatario principale e di
// conseguenza la validazione non passa.
// Se contine più di un #M#, significa che sono stati specificati più mittenti
// e di conseguenza la validazione non passa.
// Se il campo 'Codice Corrispondenti' è valorizzato...
if (rowData.CorrCode != null)
{
// Per ogni codice corrispondente contenuto nella lista...
foreach (string corrCode in rowData.CorrCode)
{
// ...se contiene #M#, si incrementa il contatore di mittenti
if (corrCode.ToUpper().Contains("#M#"))
{
sendersNum++;
}
// ...se contiene #D#, significa che esiste almeno un corrispondente
// principale
if (corrCode.ToUpper().Contains("#D#") &&
corrCode.Trim().Length > 3)
{
primCorrFound = true;
}
}
}
// Se la validazione dei campi corrispondenti è passata, si procede con
// la verifica della correttezza dei dati in essi contenuti
if (corrOk)
{
// Se non sono stati individuati mittenti, errore
if (sendersNum == 0)
{
validationResult = false;
validationProblems.Add(
"Il campo 'Codice Corrispondenti' non contiene codici per i mittenti. Specificarne uno.");
}
// Se sono stati trovati più mittenti, la validazione non passa
if (sendersNum > 1)
{
validationResult = false;
validationProblems.Add(String.Format(
"Il campo 'Codice Corrispondenti' contiene {0} mittenti. Specificarne solo uno.",
sendersNum));
}
// Se non è stato individuato alcun destinatario primario, errore
if (!primCorrFound)
{
validationResult = false;
validationProblems.Add("Nessun destinatario primario specificato nel campo 'Codice Corrispondenti'.");
}
}
// Se il campo 'Codice Fascicolo' del foglio excel è valorizzato, ed
// è valorizzata anche la profilazione del fascicolo, errore in quanto non è possibile
// valorizzarli entrambi
if (rowData.ProjectCodes != null && rowData.ProjectCodes.Length > 0 &&
(!String.IsNullOrEmpty(rowData.ProjectDescription) ||
!String.IsNullOrEmpty(rowData.FolderDescrition) ||
!String.IsNullOrEmpty(rowData.NodeCode) ||
!String.IsNullOrEmpty(rowData.ProjectTipology)))
{
validationResult = false;
validationProblems.Add("Risultano valorizzati sia i campi 'Codice Fascicolo' che i campi riguardanti la specifica del fascicolo. Non è possibile specificarli entambi.");
}
// Se è richiesta profilazione del documento obbligatoria
// ma non è valorizzato il campo 'Tipologia Documento', la validazione
// non deve passare
if (isProfilationRequired && String.IsNullOrEmpty(rowData.DocumentTipology) && !(rowData is RDEDocumentRowData))
{
validationResult = false;
validationProblems.Add("La profilazione del documento è obbligatoria ma non risulta valorizzato il campo 'Tipologia Documento'");
}
// Se è richiesta fascicolazione rapida obbligatoria ma non sono specificati
// dati in 'Codice Fascicolo' o nei campi dedicati al fascicolo
if (isRapidClassificationRequired &&
rowData.ProjectCodes == null &&
String.IsNullOrEmpty(rowData.ProjectDescription) &&
String.IsNullOrEmpty(rowData.FolderDescrition) &&
String.IsNullOrEmpty(rowData.NodeCode) &&
String.IsNullOrEmpty(rowData.ProjectTipology))
{
validationResult = false;
if (rowData is RDEDocumentRowData)
{
validationProblems.Add("Campo 'Codice Classifica' obbligatorio.");
}
else
{
validationProblems.Add("La classificazione è obbligatoria ma non risultano valorizzati nè il campo 'Codice Fascicolo' nè i campi dedicati alla classificazione.");
}
}
// Se il campo Stringa protocollo emergenza non è valorizzato, non si può procedere
// (Solo nel caso di RDE)
if (rowData is RDEDocumentRowData && String.IsNullOrEmpty("Stringa protocollo emergenza"))
{
validationResult = false;
validationProblems.Add("Campo 'Stringa protocollo emergenza' obbligatorio.");
}
// Se il campo Data protocollo emergenza non è valorizzato, non si può procedere
// (Solo nel caso di RDE)
if (rowData is RDEDocumentRowData &&
String.IsNullOrEmpty(((RDEDocumentRowData)rowData).EmergencyProtocolDate))
{
validationResult = false;
validationProblems.Add("Campo 'Data protocollo emergenza' obbligatorio.");
}
// Se il campo Data protocollo emergenza non è valorizzato, non si può procedere
// (Solo nel caso di RDE)
if (rowData is RDEDocumentRowData &&
String.IsNullOrEmpty(((RDEDocumentRowData)rowData).EmergencyProtocolTime))
{
validationResult = false;
validationProblems.Add("Campo 'Ora protocollo emergenza' obbligatorio.");
}
if (rowData is RDEDocumentRowData)
{
RDEDocumentRowData converted = rowData as RDEDocumentRowData;
// Il campo Data protocollo emergenza deve essere minore della data di protocollazione, che
// si suppone uguale alla data odierna. visto che il protocolla in giallo è stata dismessa
// nel senso che non la usa più nessuno.
if (!String.IsNullOrEmpty(converted.EmergencyProtocolDate) &&
!String.IsNullOrEmpty(converted.EmergencyProtocolTime))
{
//l'excel è formattato un modo tale che la data e l'ora possono solo arrivare nel formato valido.
string dataEmerg = converted.EmergencyProtocolDate + " " + converted.EmergencyProtocolTime;
DateTime dataEmergOut;
if (isDate(dataEmerg))
{
dataEmergOut = DateTime.ParseExact(dataEmerg, formati, ci.DateTimeFormat, DateTimeStyles.AllowWhiteSpaces);
if (dataEmergOut > System.DateTime.Now)
{
validationResult = false;
validationProblems.Add("Campo 'Data protocollo emergenza' deve essere minore della data di protocollazione.");
}
}
else
{
validationResult = false;
validationProblems.Add("Il campo data o il campo ora emergenza non contiengo un formato valido.");
}
}
}
// Retituzione del risultato di validazione
return(validationResult);
}
public static void ImportAll()
{
var importers = ImportUtils.FindImporterTypes();
ImportUtils.RunImporters(importers);
}
public void ShouldGenerateWorkbookName(string filePath, string expected)
{
var actual = ImportUtils.GenerateImporterNameFromFilePath(filePath);
Assert.AreEqual(expected, actual);
}
public void Test_InvalidCases()
{
string pid;
pid = ImportUtils.IsPersonLine_Konovalov("-1. Ivan");
Assert.AreEqual(null, pid);
pid = ImportUtils.IsPersonLine_Konovalov("1 Ivan");
Assert.AreEqual(null, pid);
pid = ImportUtils.IsPersonLine_Konovalov("1-. Ivan");
Assert.AreEqual(null, pid);
pid = ImportUtils.IsPersonLine_Konovalov("11-11 Ivan");
Assert.AreEqual(null, pid);
//res = ImpUtils.IsPersonLine_Konovalov("1.2. Ivan", out pid); // now false-positive
//Assert.AreEqual(null, pid, "[i1]");
//res = ImpUtils.IsPersonLine_Konovalov("1.1.1. Ivan", out pid); // now false-positive
//Assert.AreEqual(null, pid, "[i2]");
pid = ImportUtils.IsPersonLine_Konovalov("11-21/. Ivan");
Assert.AreEqual(null, pid);
pid = ImportUtils.IsPersonLine_Konovalov("11-21-31. Ivan");
Assert.AreEqual(null, pid);
pid = ImportUtils.IsPersonLine_Konovalov("11-21-31 (. Ivan");
Assert.AreEqual(null, pid);
pid = ImportUtils.IsPersonLine_Konovalov("11-21-31 (test) Ivan");
Assert.AreEqual(null, pid);
pid = ImportUtils.IsPersonLine_DAboville("-1. Ivan");
Assert.AreEqual(null, pid, "[i2-1]");
pid = ImportUtils.IsPersonLine_DAboville("1-1. Ivan");
Assert.AreEqual(null, pid, "[i2-2]");
pid = ImportUtils.IsPersonLine_DAboville(".1. Ivan");
Assert.AreEqual(null, pid, "[i2-3]");
pid = ImportUtils.IsPersonLine_DAboville("1710 (80), 1727 (80).");
Assert.AreEqual(null, pid, "[i2-4]");
var slRet = ImportUtils.ParseSpouseLine("Жена Ivanova");
Assert.IsNull(slRet, "[i3-1]");
slRet = ImportUtils.ParseSpouseLine("Ж2 Ivanova");
Assert.IsNull(slRet, "[i3-2]");
slRet = ImportUtils.ParseSpouseLine("Ж Ivanova");
Assert.IsNull(slRet, "[i3-3]");
slRet = ImportUtils.ParseSpouseLine("Ж3 (test2 - Ivanova");
Assert.IsNull(slRet, "[i3-4]");
}
public void Test_Other()
{
Assert.IsTrue(ImportUtils.IsRomeLine("XIV"));
Assert.IsFalse(ImportUtils.IsRomeLine("XVA"));
Assert.IsFalse(ImportUtils.IsRomeLine(""));
}
public ActionResult Upload(UploadedExcelSheetViewModel viewmodel)
{
if (ModelState.IsValid) // validate file exist
{
if (viewmodel.ExcelFile != null && viewmodel.ExcelFile.ContentLength > 0)
{
var fileName = Path.GetFileName(viewmodel.ExcelFile.FileName);
var path = Path.Combine(Server.MapPath("~/Uploads/ServerTimeEntries/"), DateTime.Now.GetTimeStamp() + "_" + fileName);
List <ServerTimeEntry> timeEntries = new List <ServerTimeEntry>();
viewmodel.ExcelFile.SaveAs(path); // save a copy of the uploaded file.
// convert the uploaded file into datatable, then add/update db entities.
var columnsToImport = new string[] { "Server ID", "Current Pay Source", "Begin Date", "Duration" };
var dtServers = ImportUtils.ImportXlsxToDataTable(viewmodel.ExcelFile.InputStream, true, columnsToImport);
var invalidServers = new List <int>();
var invalidPaysources = new List <int>();
foreach (var row in dtServers.AsEnumerable().ToList())
{
var timeEntryViewModel = new ServerTimeEntryAddViewModel()
{
ServerId = int.Parse(row["Server ID"].ToString()),
PaySourceId = int.Parse(row["Current Pay Source"].ToString()),
BeginDate = DateTime.Parse(row["Begin Date"].ToString()),
Duration = TimeSpan.Parse(row["Duration"].ToString())
};
var existedServer = _serverService.GetByVendorId(timeEntryViewModel.ServerId);
if (existedServer == null)
{
if (!invalidServers.Any(t => t == timeEntryViewModel.ServerId))
{
invalidServers.Add(timeEntryViewModel.ServerId);
}
}
var existedPaySource = _paySourceService.GetByVendorId(timeEntryViewModel.PaySourceId);
if (existedPaySource == null)
{
if (!invalidPaysources.Any(t => t == timeEntryViewModel.PaySourceId))
{
invalidPaysources.Add(timeEntryViewModel.PaySourceId);
}
}
if (existedServer != null && existedPaySource != null)
{
// check if entity already exists.
var entity = Mapper.Map <ServerTimeEntryAddViewModel, ServerTimeEntry>(timeEntryViewModel);
entity.ServerId = existedServer.Id;
entity.PaySourceId = existedPaySource.Id;
entity.ProgramId = existedPaySource.Programs.Any() ? existedPaySource.Programs.ToList()[0].Id : (int?)null;
if (!_serverTimeEntryService.TimeEntryExists(entity))
{
timeEntries.Add(entity);
}
}
}
if (invalidServers.Any() || invalidPaysources.Any())
{
invalidServers.ForEach(invalidServerId => { ModelState.AddModelError("", $"Invalid Server Id with value ={invalidServerId}"); });
invalidPaysources.ForEach(invalidPaysource => { ModelState.AddModelError("", $"Invalid PaySource Id with value ={invalidPaysource}"); });
return(View(viewmodel));
}
else
{
_serverTimeEntryService.AddServerTimeEntries(timeEntries);
}
Success($"<strong>{timeEntries.Count}</strong> Time Entries have been successfully added. <br\\>"
+ $"<strong>{dtServers.Rows.Count - timeEntries.Count}</strong> Time Entries are duplicated and have been skipped.");
}
return(RedirectToAction("Index"));
}
return(View(viewmodel));
}
public void Test_ValidCases()
{
string pid;
pid = ImportUtils.IsPersonLine_Konovalov("1. Ivan");
Assert.AreEqual("1.", pid, "[v1]");
pid = ImportUtils.IsPersonLine_Konovalov("2-1. Ivan");
Assert.AreEqual("2-1.", pid);
pid = ImportUtils.IsPersonLine_Konovalov("11-21. Ivan");
Assert.AreEqual("11-21.", pid);
pid = ImportUtils.IsPersonLine_Konovalov("11-21/1. Ivan");
Assert.AreEqual("11-21/1.", pid);
pid = ImportUtils.IsPersonLine_Konovalov("11-21/?. Ivan");
Assert.AreEqual("11-21/?.", pid, "[v2]");
pid = ImportUtils.IsPersonLine_Konovalov("11-21/1 (test+2, test). Ivan");
Assert.AreEqual("11-21/1 (test+2, test).", pid);
var plRet = ImportUtils.ParsePersonLine_Konovalov("11-21/1 (test+2, test). Ivan");
Assert.AreEqual("11", plRet.PersId);
Assert.AreEqual("21", plRet.ParentId);
Assert.AreEqual("1", plRet.MarNum);
Assert.AreEqual("(test+2, test)", plRet.ExtData);
Assert.IsNotNull(plRet);
plRet = ImportUtils.ParsePersonLine_Konovalov("11-21/?. Ivan");
Assert.AreEqual("11", plRet.PersId);
Assert.AreEqual("21", plRet.ParentId);
Assert.AreEqual("?", plRet.MarNum);
Assert.AreEqual("", plRet.ExtData);
Assert.IsNotNull(plRet);
pid = ImportUtils.IsPersonLine_DAboville("1. Ivan");
Assert.AreEqual("1.", pid, "[v2-1]");
pid = ImportUtils.IsPersonLine_DAboville("1.1. Ivan");
Assert.AreEqual("1.1.", pid, "[v2-2]");
pid = ImportUtils.IsPersonLine_DAboville("11.21.31.11. Ivan");
Assert.AreEqual("11.21.31.11.", pid, "[v2-3]");
plRet = ImportUtils.ParsePersonLine_DAboville("1. Ivan");
Assert.AreEqual("1.", plRet.PersId);
Assert.AreEqual("", plRet.ParentId);
Assert.AreEqual("", plRet.MarNum);
Assert.AreEqual("", plRet.ExtData);
Assert.IsNotNull(plRet);
plRet = ImportUtils.ParsePersonLine_DAboville("11.21.31.11. Ivan");
Assert.AreEqual("11.21.31.11.", plRet.PersId);
Assert.AreEqual("11.21.31.", plRet.ParentId);
Assert.AreEqual("", plRet.MarNum);
Assert.AreEqual("", plRet.ExtData);
Assert.IsNotNull(plRet);
var slRet = ImportUtils.ParseSpouseLine("Ж: Ivanova");
Assert.AreEqual("Ж", slRet.Spouse, "[v3-1]");
Assert.AreEqual(1, slRet.MarrNum, "[v3-1]");
Assert.AreEqual("", slRet.ExtData);
Assert.IsNotNull(slRet, "[v3-1]");
slRet = ImportUtils.ParseSpouseLine("Ж2 (test): Ivanova");
Assert.AreEqual("Ж", slRet.Spouse, "[v3-2]");
Assert.AreEqual(2, slRet.MarrNum, "[v3-2]");
Assert.AreEqual("(test)", slRet.ExtData, "[v3-2]");
Assert.IsNotNull(slRet, "[v3-2]");
slRet = ImportUtils.ParseSpouseLine("Ж - Ivanova");
Assert.AreEqual("Ж", slRet.Spouse, "[v3-3]");
Assert.AreEqual(1, slRet.MarrNum, "[v3-3]");
Assert.AreEqual("", slRet.ExtData);
Assert.IsNotNull(slRet, "[v3-3]");
slRet = ImportUtils.ParseSpouseLine("Ж3 (test2) - Ivanova");
Assert.AreEqual("Ж", slRet.Spouse, "[v3-4]");
Assert.AreEqual(3, slRet.MarrNum, "[v3-4]");
Assert.AreEqual("(test2)", slRet.ExtData, "[v3-4]");
Assert.IsNotNull(slRet, "[v3-4]");
}
/// <summary>
/// Funzione per l'acquisizione del file da associare ad un allegato
/// </summary>
/// <param name="path">Il path relativo del file da caricare</param>
/// <param name="administrationCode">Il codice dell'amministrazione</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="ftpAddress">L'indirizzo a cui è possibile recuperare le informazioni sul file</param>
/// <param name="attachment">L'allegato a cui associare il file</param>
protected void AcquireFile(string path, string administrationCode, InfoUtente userInfo, string ftpAddress, Allegato attachment, String ftpUsername, String ftpPassword, DocumentRowData rowData)
{
#region Dichiarazione Variabili
// Il contenuto del file
byte[] fileContent;
// L'oggetto fileRequest
FileRequest fileRequest;
// L'oggetto fileDocumento
FileDocumento fileDocumento;
#endregion
#region Lettura file documento
try
{
// Apertura, lettura e chiusura del file
//fileContent = ImportUtils.DownloadFileFromFTP(
// ftpAddress,
// String.Format("{0}/{1}/{2}",
// administrationCode,
// userInfo.userId,
// path),
// ftpUsername,
// ftpPassword);
// nuova versione, i file vengono presi in locale e caricati dagli utenti in locale nella procedura di import
fileContent = ImportUtils.DounloadFileFromUserTempFolder(rowData, userInfo, true);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
#endregion
#region Creazione dell'oggetto fileDocumento
// Creazione dell'oggetto fileDocumento
fileDocumento = new FileDocumento();
// Impostazione del nome del file
fileDocumento.name = Path.GetFileName(path);
// Impostazione del full name
fileDocumento.fullName = path;
// Impostazione del path
fileDocumento.path = Path.GetPathRoot(path);
// Impostazione della grandezza del file
fileDocumento.length = fileContent.Length;
// Impostazione del content del documento
fileDocumento.content = fileContent;
#endregion
#region Creazione dell'oggetto fileRequest
fileRequest = (FileRequest)attachment;
#endregion
#region Acquisizione del file
try
{
FileManager.putFile(fileRequest, fileDocumento, userInfo);
}
catch (Exception e)
{
// Aggiunta del problema alla lista dei problemi
throw new Exception("Errore durante l'upload del file.");
}
#endregion
}
public ActionResult Upload(UploadedExcelSheetViewModel viewmodel)
{
if (ModelState.IsValid) // validate file exist
{
if (viewmodel.ExcelFile != null && viewmodel.ExcelFile.ContentLength > 0)
{
var fileName = Path.GetFileName(viewmodel.ExcelFile.FileName);
var path = Path.Combine(Server.MapPath("~/Uploads/Servers/"), DateTime.Now.GetTimeStamp() + "_" + fileName);
List <Server> addedServers = new List <Server>();
viewmodel.ExcelFile.SaveAs(path); // save a copy of the uploaded file.
// convert the uploaded file into datatable, then add/update db entities.
var dtServers = ImportUtils.ImportXlsxToDataTable(viewmodel.ExcelFile.InputStream, true);
int numOfServersUpdated = 0;
foreach (var row in dtServers.AsEnumerable().ToList())
{
var entityViewModel = new ServerAddViewModel()
{
VendorId = int.Parse(row["Staff"].ToString()),
// some columns does not have ',' separater.
FirstName = row["Sort Name"].ToString().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries)[1],
LastName = row["Sort Name"].ToString().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries)[0],
GpEmpNumber = !string.IsNullOrWhiteSpace(row["Gp Emp #"].ToString()) ? row["Gp Emp #"].ToString() : null,
ElementId = !string.IsNullOrWhiteSpace(row["Element"].ToString()) ? int.Parse(row["Element"].ToString()) : (int?)null,
Active = row["active"].ToString() == "Y" ? true : false,
CategoryId = CategoryConverter.ConvertFromCategoryNameToId(row["Category"].ToString())
};
//check if server does not exist
if (entityViewModel.VendorId != 0)
{
if (entityViewModel.ElementId.HasValue)
{
var existedElement = _elementService.GetByVendorId(entityViewModel.ElementId.Value);
if (existedElement == null)
{
Danger($"Invalid Element Id with value ={entityViewModel.ElementId.Value}");
continue;
}
else
{
entityViewModel.ElementId = existedElement.Id;
}
}
var existedEntity = _serverService.GetByVendorId(entityViewModel.VendorId);
if (existedEntity == null)
{
var entity = Mapper.Map <ServerAddViewModel, Server>(entityViewModel);
addedServers.Add(entity);
}
else
{
Mapper.Map(entityViewModel, existedEntity);
_serverService.UpdateServer(existedEntity);
numOfServersUpdated++;
}
}
}
if (addedServers.Any())
{
_serverService.AddServers(addedServers);
}
Success($"<strong>{addedServers.Count}</strong> servers have been successfully added. <br\\>"
+ $"<strong>{numOfServersUpdated}</strong> servers have been successfully updated.");
}
return(RedirectToAction("Index"));
}
return(View(viewmodel));
}
/// <summary>
/// Funzione per la lettura dei metadati da un foglio excel
/// </summary>
/// <param name="completePath">Il path in cui reprire il file excel</param>
/// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
/// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
/// <param name="isEnabledPregressi">True se è abilitato l'import dei documenti pregressi</param>
/// <returns>L'oggetto con i metadati estratti dal foglio excel</returns>
private static DocumentRowDataContainer ReadMetadata(
string completePath,
InfoUtente userInfo,
Ruolo role,
bool isEnabledPregressi,
bool isStampaUnione,
String provider,
String extendedProperty)
{
#region Dichiarazione variabili
// La stringa di connessione al foglio excel
string connectionString = String.Empty;
// L'oggetto utilizzato per connettersi al foglio excel
OleDbConnection oleConnection = null;
// L'oggetto utilizzato per eseguire un comando sul file excel
OleDbCommand oleCommand = null;
// L'oggetto utilizzato per leggere i dati dal file excel
OleDbDataReader dataReader = null;
// L'oggetto da restituire
DocumentRowDataContainer toReturn;
#endregion
#region Connessione al foglio excel
try
{
// Creazione dell'oggetto per la connessione al foglio excel
oleConnection = ImportUtils.ConnectToFile(provider, extendedProperty, completePath);
}
catch (Exception e)
{
// Viene rilanciata un'eccezione al livello superiore
throw new Exception("Errore durante la connessione al file excel. Dettagli: " + e.Message);
}
#endregion
// Creazione dell'oggetto da restituire
toReturn = new DocumentRowDataContainer();
#endregion
#region Selezione dei dati sui documenti in partenza da importare e importazione
try
{
// Creazione della query per la selezione dei dati sui documenti in partenza da importare
oleCommand = new OleDbCommand("SELECT * FROM [Partenza$]", oleConnection);
// Esecuzione della query per il recupero dei dati
dataReader = oleCommand.ExecuteReader();
}
catch (Exception e)
{
dataReader.Close();
throw new Exception("Errore durante il recupero dei dati sui documenti in uscita da importare. Dettagli: " + e.Message);
}
// Se il recupero dei dati è andato a buon fine, si procede con la loro importazione
try
{
if (dataReader != null)
{
toReturn.OutDocument = new OutDocument().ReadMetaData(dataReader, userInfo, role, isEnabledPregressi);
}
}
catch (Exception e)
{
dataReader.Close();
throw e;
}
#endregion
#region Selezione dei dati sui documenti interni da importare e importazione
try
{
// Creazione della query per la selezione dei dati sui documenti interni da importare
oleCommand = new OleDbCommand("SELECT * FROM [Interni$]", oleConnection);
// Esecuzione della query per il recupero dei dati
dataReader = oleCommand.ExecuteReader();
}
catch (Exception e)
{
dataReader.Close();
throw new Exception("Errore durante il recupero dei dati sui documenti interni da importare. Dettagli: " + e.Message);
}
// Se il recupero dei dati è andato a buon fine, si procede con la loro importazione
try
{
if (dataReader != null)
{
toReturn.OwnDocument = new OwnDocument().ReadMetaData(dataReader, userInfo, role, isEnabledPregressi);
}
}
catch (Exception e)
{
dataReader.Close();
throw e;
}
#endregion
#region Selezione dei dati sui documenti non protocollati da importare e importazione
try
{
// Creazione della query per la selezione dei dati sui documenti non protocollati da importare
oleCommand = new OleDbCommand("SELECT * FROM [Non protocollati$]", oleConnection);
// Esecuzione della query per il recupero dei dati
dataReader = oleCommand.ExecuteReader();
}
catch (Exception e)
{
dataReader.Close();
throw new Exception("Errore durante il recupero dei dati sui documenti non protocollati da importare. Dettagli: " + e.Message);
}
// Se il recupero dei dati è andato a buon fine, si procede con la loro importazione
try
{
if (dataReader != null)
{
toReturn.GrayDocument = new GrayDocument().ReadMetaData(dataReader, userInfo, role, isEnabledPregressi);
}
}
catch (Exception e)
{
dataReader.Close();
throw e;
}
#endregion
#region Selezione dei dati sui documenti allegati da importare e importazione
if (isStampaUnione)
{
try
{
// Creazione della query per la selezione dei dati sui documenti allegati da importare
oleCommand = new OleDbCommand("SELECT * FROM [Allegati$]", oleConnection);
// Esecuzione della query per il recupero dei dati
dataReader = oleCommand.ExecuteReader();
}
catch (Exception e)
{
dataReader.Close();
throw new Exception("Errore durante il recupero dei dati sugli allegati da importare. Dettagli: " + e.Message);
}
// Se il recupero dei dati è andato a buon fine, si procede con la loro importazione
try
{
if (dataReader != null)
{
toReturn.AttachmentDocument = new Attachment().ReadMetaData(dataReader, userInfo, role, isEnabledPregressi);
}
}
catch (Exception e)
{
dataReader.Close();
throw e;
}
#region Selezione dei dati sui documenti in arrivo da importare e importazione
try
{
// Creazione della query per la selezione dei dati sui documenti in arrivo da importare
oleCommand = new OleDbCommand("SELECT * FROM [Arrivo$]", oleConnection);
// Esecuzione della query per il recupero dei dati
dataReader = oleCommand.ExecuteReader();
}
catch (Exception e)
{
dataReader.Close();
throw new Exception("Errore durante il recupero dei dati sui documenti in arrivo da importare. Dettagli: " + e.Message);
}
// Se il recupero dei dati è andato a buon fine, si procede con la loro importazione
try
{
if (dataReader != null)
{
toReturn.InDocument = new InDocument().ReadMetaData(dataReader, userInfo, role, isEnabledPregressi);
}
}
catch (Exception e)
{
dataReader.Close();
throw e;
}
}
else
{
toReturn.AttachmentDocument = new List <DocumentRowData>();
toReturn.InDocument = new List <DocumentRowData>();
}
#endregion
#region Chiusura connessione
try
{
// Chiusura della connessione
oleConnection.Close();
}
catch (Exception e)
{ }
#endregion
// Restituzione del risultato dell'importazione
return(toReturn);
}
public void ShouldRecognizeExcelFiles(string filePath, bool expected)
{
var actual = ImportUtils.IsExcelFile(filePath);
Assert.AreEqual(expected, actual);
}
private bool AnalyseRaw()
{
if (SourceType == SourceType.stTable)
{
return(false);
}
try
{
IProgressController progress = AppHost.Progress;
try
{
int[] numberStats = new int[3];
int num = fRawContents.Count;
progress.ProgressInit(fLangMan.LS(ILS.LSID_Analysis), num);
for (int i = 0; i < num; i++)
{
string txt = fRawContents[i].Trim();
RawLine rawLine = (RawLine)fRawContents.GetObject(i);
if (!string.IsNullOrEmpty(txt))
{
if (IsGenerationLine(txt))
{
rawLine.Type = RawLineType.rltRomeGeneration;
}
else
{
PersonNumbersType numbType = PersonNumbersType.pnUndefined;
if (!string.IsNullOrEmpty(ImportUtils.IsPersonLine_DAboville(txt)))
{
rawLine.Type = RawLineType.rltPerson;
numbType = PersonNumbersType.pnDAboville;
numberStats[1]++;
}
else if (!string.IsNullOrEmpty(ImportUtils.IsPersonLine_Konovalov(txt)))
{
rawLine.Type = RawLineType.rltPerson;
numbType = PersonNumbersType.pnKonovalov;
numberStats[2]++;
}
rawLine.NumbersType = numbType;
}
}
else
{
rawLine.Type = RawLineType.rltEOF;
}
progress.ProgressStep(i + 1);
}
if (numberStats[1] > numberStats[2])
{
CanNumbersType = PersonNumbersType.pnDAboville;
}
else
{
CanNumbersType = PersonNumbersType.pnKonovalov;
}
return(true);
}
finally
{
progress.ProgressDone();
}
}
catch (Exception ex)
{
Logger.LogWrite("Importer.AnalyseRaw(): " + ex.Message);
return(false);
}
}
/// <summary>
/// 导入整个文件夹的mono
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void imporDirectoryToolStripMenuItem_Click(object sender, EventArgs e)
{
if (!AssetUtils.AllDependenciesLoaded(helper, currentFile))
{
MessageBox.Show("未加载依赖文件");
return;
}
IEManager.InputStr = fileIDTextBox.Text;
OpenFileDialog ofd = new OpenFileDialog();
ofd.Title = "选择要覆盖的Aseets";
string targetFileName = "";
if (ofd.ShowDialog() == DialogResult.OK)
{
if (currentFile == null)
{
return;
}
if (assetList.SelectedCells.Count > 0)
{
var selRow = assetList.SelectedRows[0];
string typeName = (string)selRow.Cells[2].Value;
if (typeName == "Folder")
{
string dirName = (string)selRow.Cells[1].Value;
ChangeDirectory(dirName);
return;
}
else
{
targetFileName = ofd.FileName;
}
}
}
else
{
return;
}
OpenFileDialog ofd2 = new OpenFileDialog
{
CheckFileExists = false,
FileName = "[选择文件夹]",
Title = "选择要导入的文件夹"
};
if (ofd2.ShowDialog() == DialogResult.OK)
{
string dirName = Path.GetDirectoryName(ofd2.FileName);
if (Directory.Exists(dirName))
{
ImportUtils.ImportAssets(dirName, targetFileName);
MessageBox.Show("导入成功");
}
else
{
MessageBox.Show("文件夹不存在.", "Assets View");
}
}
}
