/// <summary>
/// Confermo la serie documentale AVCP e bandi di gara
/// </summary>
private void ConfirmDraftAvcpSeriesItem(Resolution resolution)
{
//Se sto confermando Bandi di Gara ed ho una serie AVCP associata
if (HasAvcpSeriesToAutomaticConfirm(resolution))
{
ICollection <DocumentSeriesItem> seriesToComplete = FacadeFactory.Instance.ResolutionFacade.GetSeriesToComplete(resolution);
DocumentSeriesItem avcpSeriesItem = seriesToComplete.SingleOrDefault(s => s.DocumentSeries.Id == DocSuiteContext.Current.ProtocolEnv.AvcpDocumentSeriesId);
//Imposto la data di pubblicazione quando l'atto sarà ritirato
avcpSeriesItem.PublishingDate = resolution.PublishingDate.Value.AddDays(15);
if (DocSuiteContext.Current.ResolutionEnv.CompleteTransparencyExecutiveStepEnabled && resolution.EffectivenessDate.HasValue)
{
avcpSeriesItem.PublishingDate = resolution.EffectivenessDate;
}
BiblosChainInfo avcpChain = FacadeFactory.Instance.DocumentSeriesItemFacade.GetMainChainInfo(avcpSeriesItem);
FacadeFactory.Instance.DocumentSeriesItemFacade.UpdateDocumentSeriesItem(avcpSeriesItem, avcpChain, null, null, $"Pubblicata serie AVCP {avcpSeriesItem.Year:0000}/{avcpSeriesItem.Number:0000000} in data {avcpSeriesItem.PublishingDate:dd/MM/yyyy}");
bool hasInserted = avcpSeriesItem.Status == DocumentSeriesItemStatus.Active;
FacadeFactory.Instance.DocumentSeriesItemFacade.AssignNumber(avcpSeriesItem);
if (hasInserted)
{
FacadeFactory.Instance.DocumentSeriesItemFacade.SendUpdateDocumentSeriesItemCommand(avcpSeriesItem);
}
else
{
FacadeFactory.Instance.DocumentSeriesItemFacade.SendInsertDocumentSeriesItemCommand(avcpSeriesItem);
}
}
}
private void FlushDocuments(DocumentSeriesItem item)
{
// Documento presente, lo sostituisco
var toSave = FacadeFactory.Instance.DocumentSeriesItemFacade.GetAttributes(item);
var newChain = new BiblosChainInfo();
newChain.AddAttributes(toSave);
item.IdMain = newChain.ArchiveInBiblos(item.Location.ProtBiblosDSDB);
}
/// <summary>
/// Confermara e pubblica tutte le serie documentali, senza documento richiesto, associate all'atto attuale.
/// </summary>
public void ConfirmAndPublishSeries(Resolution resolution)
{
ICollection <DocumentSeriesItem> seriesItems = FacadeFactory.Instance.ResolutionFacade.GetSeriesByResolution(resolution);
if (seriesItems != null && seriesItems.Count > 0)
{
foreach (DocumentSeriesItem seriesItem in seriesItems)
{
bool isDocumentRequired = CurrentResolutionKindDocumentSeriesFacade.IsDocumentRequired(resolution.ResolutionKind.Id, seriesItem.DocumentSeries.Id);
BiblosChainInfo chain = FacadeFactory.Instance.DocumentSeriesItemFacade.GetMainChainInfo(seriesItem);
IEnumerable <BiblosDocumentInfo> docInfo = Factory.DocumentSeriesItemFacade.GetMainDocuments(seriesItem);
// Confermo e pubblico SOLO se il documento non è richiesto
if (!isDocumentRequired || (isDocumentRequired && docInfo != null && docInfo.Count() > 0))
{
if (DocSuiteContext.Current.ResolutionEnv.CompleteTransparencyExecutiveStepEnabled && resolution.EffectivenessDate.HasValue)
{
seriesItem.PublishingDate = resolution.EffectivenessDate;
}
if (resolution.PublishingDate.HasValue && !seriesItem.PublishingDate.HasValue)
{
seriesItem.PublishingDate = resolution.PublishingDate.Value.AddDays(15);
}
if (seriesItem.Status == DocumentSeriesItemStatus.Draft)
{
if (seriesItem.DocumentSeries.Id == DocSuiteContext.Current.ProtocolEnv.BandiGaraDocumentSeriesId)
{
ConfirmDraftAvcpSeriesItem(resolution);
}
else
{
bool hasInserted = seriesItem.Status == DocumentSeriesItemStatus.Active;
FacadeFactory.Instance.DocumentSeriesItemFacade.AssignNumber(seriesItem);
if (hasInserted)
{
FacadeFactory.Instance.DocumentSeriesItemFacade.SendUpdateDocumentSeriesItemCommand(seriesItem);
}
else
{
FacadeFactory.Instance.DocumentSeriesItemFacade.SendInsertDocumentSeriesItemCommand(seriesItem);
}
}
}
FacadeFactory.Instance.DocumentSeriesItemFacade.UpdateDocumentSeriesItem(seriesItem, chain, null, null, $"Pubblicata registrazione {seriesItem.Year:0000}/{seriesItem.Number:0000000} in data {seriesItem.PublishingDate:dd/MM/yyyy}");
}
}
}
}
public bool ProcessFile(string fileName, ref int rowImported, ref int totalRow)
{
bool res = true;
TaskInfo tInfo = TaskInfo.Load(fileName);
TaskHeader task = FacadeFactory.Instance.TaskHeaderFacade.GetById(tInfo.taskId);
DocSuiteWebAPI.DocumentSeriesItemDTO dto = Newtonsoft.Json.JsonConvert.DeserializeObject <DocSuiteWebAPI.DocumentSeriesItemDTO>(tInfo.taskCode);
FileLogger.Info(this.LoggerName, String.Format("Elaborazione file '{0}'", fileName));
TaskDetail taskDetail = new TaskDetail()
{
DetailType = DetailTypeEnum.Info, Title = String.Format("Elaborazione file '{0}'", fileName), TaskHeader = task
};
FacadeFactory.Instance.TaskDetailFacade.Save(ref taskDetail);
//informazioni sull'archivio
DocumentSeries docSeries = FacadeFactory.Instance.DocumentSeriesFacade.GetById(dto.IdDocumentSeries.Value);
IList <DocumentSeriesSubsection> docSeriesSubsections = FacadeFactory.Instance.DocumentSeriesSubsectionFacade.GetAll();
ArchiveInfo archInfo = GetSelectedArchiveInfo(docSeries);
List <string> columns = new List <string>(_basicFields);
columns.AddRange(archInfo.VisibleChainAttributes.Select(p => p.Name));
string excelVers = "";
if (Path.GetExtension(tInfo.documentFilename).ToLower() == ".xls")
{
excelVers = "Excel 8.0";
}
if (Path.GetExtension(tInfo.documentFilename).ToLower() == ".xlsx")
{
excelVers = "Excel 12.0";
}
rowImported = 0;
List <List <string> > righeErrore = new List <List <string> >();
string connStr = String.Format("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=\"{0}\";Extended Properties=\"{1};HDR=Yes;IMEX=1;\"", tInfo.documentFilename, excelVers);
using (OleDbConnection conn = new OleDbConnection(connStr))
{
conn.Open();
string sheetName = conn.GetSchema("Tables").Rows[0]["TABLE_NAME"].ToString();
//Gestione del file excel
IDbCommand command = conn.CreateCommand();
command.CommandText = string.Format("SELECT {0} FROM [{1}]", string.Format("[{0}]", string.Join("], [", columns)), sheetName);
command.CommandType = CommandType.Text;
using (IDataReader dr = command.ExecuteReader())
{
if (!dr.Read())
{
dr.Close();
taskDetail = new TaskDetail()
{
DetailType = DetailTypeEnum.ErrorType, Title = "Foglio excel vuoto.", TaskHeader = task
};
FacadeFactory.Instance.TaskDetailFacade.Save(ref taskDetail);
throw new DocSuiteException("Foglio excel vuoto.");
}
//Verifica delle colonne
DataTable dt = dr.GetSchemaTable();
if (dt.Select("ColumnName = 'Subject'").Length < 1)
{
taskDetail = new TaskDetail()
{
DetailType = DetailTypeEnum.ErrorType, Title = "Colonna [Subject] mancante.", TaskHeader = task
};
FacadeFactory.Instance.TaskDetailFacade.Save(ref taskDetail);
throw new DocSuiteException("Colonna [Subject] mancante.");
}
foreach (ArchiveAttribute attribute in archInfo.VisibleChainAttributes)
{
int columnIndex = dt.Select(string.Format("ColumnName = '{0}'", attribute.Name)).Length;
if (columnIndex < 1 & attribute.Required)
{
taskDetail = new TaskDetail()
{
DetailType = DetailTypeEnum.ErrorType, Title = string.Format("Colonna obbligatoria [{0}] mancante.", attribute.Name), TaskHeader = task
};
FacadeFactory.Instance.TaskDetailFacade.Save(ref taskDetail);
throw new DocSuiteException(string.Format("Colonna obbligatoria [{0}] mancante.", attribute.Name));
}
}
int currentRow = 0;
//import
while (true)
{
string rowId = string.Empty;
string message = string.Empty;
string subSection = string.Empty;
try
{
rowId = dr["Subject"].ToString();
if (tInfo.IsRowProcessed(rowId))
{
message = string.Format("Riga [{0}]: saltata poiché è già stato processato un elemento con campo oggetto '{1}'", currentRow + 2, rowId);
FileLogger.Info(LoggerName, message);
taskDetail = new TaskDetail()
{
DetailType = DetailTypeEnum.Info, Title = message, TaskHeader = task
};
FacadeFactory.Instance.TaskDetailFacade.Save(ref taskDetail);
//next
if (!dr.Read())
{
break;
}
continue;
}
// Catena Biblos per la gestione dei Metadati
BiblosChainInfo chain = new BiblosChainInfo();
List <DocumentInfo> mainDocs = new List <DocumentInfo>();
if (dt.Select("ColumnName = 'DOC_Main'").Length == 1)
{
mainDocs = ParseDocumentString(dr["DOC_Main"].ToString());
chain.AddDocuments(mainDocs);
}
// Recupero i metadati da EXCEL e li salvo nella catena
foreach (ArchiveAttribute attribute in archInfo.VisibleChainAttributes)
{
if (dt.Select(string.Format("ColumnName = '{0}'", attribute.Name)).Length < 1)
{
continue;
}
FileLogger.Debug(LoggerName, attribute.Name);
chain.AddAttribute(attribute.Name, string.Format(attribute.Format, dr[attribute.Name]));
}
// DocumentSeriesItem da salvare
DocumentSeriesItem item = new DocumentSeriesItem();
if (dt.Select("ColumnName = 'Subsection'").Length > 0)
{
subSection = dr["Subsection"].ToString();
if (!subSection.IsNullOrEmpty())
{
DocumentSeriesSubsection subSectionToAdd = docSeriesSubsections.FirstOrDefault(x => x.Description == subSection);
if (subSectionToAdd != null)
{
item.DocumentSeriesSubsection = subSectionToAdd;
}
else
{
message = string.Format("Sottosezione [{0}] della serie documentale [{1}] non caricata perchè non presente sul database", subSection, docSeries.Name);
FileLogger.Info(LoggerName, message);
}
}
}
item.DocumentSeries = docSeries;
item.Subject = dr["Subject"].ToString();
// Recupero e salvo i dati di classificazione
Category selectedCategory = FacadeFactory.Instance.CategoryFacade.GetById(dto.Category.Id.Value);
Category root = selectedCategory.Root;
if (selectedCategory.Equals(root))
{
item.Category = selectedCategory;
}
else
{
item.Category = root;
item.SubCategory = selectedCategory;
}
// Recupero e salvo l'evenatuale data di pubblicazione
if (dto.PublishingDate.HasValue)
{
item.PublishingDate = dto.PublishingDate.Value;
}
// Imposto la STATUS desiderato
DocumentSeriesItemStatus status = (DocumentSeriesItemStatus)dto.Status;
List <DocumentInfo> annexed = new List <DocumentInfo>();
if (dt.Select("ColumnName = 'DOC_Annexed'").Length == 1)
{
annexed.AddRange(ParseDocumentString(dr["DOC_Annexed"].ToString()));
}
List <DocumentInfo> unpublished = new List <DocumentInfo>();
if (dt.Select("ColumnName = 'DOC_UnpublishedAnnexed'").Length == 1)
{
unpublished.AddRange(ParseDocumentString(dr["DOC_UnpublishedAnnexed"].ToString()));
}
// Salvo l'Item in DB
FacadeFactory.Instance.DocumentSeriesItemFacade.SaveDocumentSeriesItem(item, chain, annexed, unpublished, status, "Registrazione importata da documento EXCEL.");
//A questo punto sono certo che la procedura ha salvato in BiblosDS i documenti,
//li rimuovo dalla sorgente.
RemoveProcessedFiles(mainDocs, annexed, unpublished);
message = string.Format("Riga [{0}]: Ok", currentRow + 2);
FileLogger.Info(LoggerName, message);
taskDetail = new TaskDetail()
{
DetailType = DetailTypeEnum.Info, Title = message, TaskHeader = task
};
FacadeFactory.Instance.TaskDetailFacade.Save(ref taskDetail);
tInfo.AddRowInfo(rowId, message, RowInfo.RowStatus.Processed);
// Incremento il counter
rowImported += 1;
}
catch (Exception ex)
{
int count = dr.FieldCount;
//genero la lista da inserire nella lista di errori
List <string> errorValues = new List <string>();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < count; i++)
{
errorValues.Add(dr.GetValue(i).ToString());
}
righeErrore.Add(errorValues);
FileLogger.Debug(LoggerName, "QRY su EXEL: " + command.CommandText);
message = string.Format("Riga [{0}]: Errore - {1}", currentRow + 2, ex.Message);
FileLogger.Error(LoggerName, message, ex);
taskDetail = new TaskDetail()
{
DetailType = DetailTypeEnum.ErrorType, Title = message, ErrorDescription = ex.StackTrace, TaskHeader = task
};
FacadeFactory.Instance.TaskDetailFacade.Save(ref taskDetail);
tInfo.AddRowInfo(rowId, message, RowInfo.RowStatus.Error);
res = false;
}
finally
{
currentRow += 1;
}
//next
if (!dr.Read())
{
break;
}
}
totalRow = currentRow;
}
// chiudo la conn oledb
conn.Close();
}
return(res);
}
/// <summary>
/// Aggiorna gli attributi della serie documentale per bandi di gara e contratti
/// </summary>
/// <param name="item"></param>
/// <param name="pub"></param>
/// <param name="archiveInfo"></param>
/// <param name="chain"></param>
/// <returns></returns>
public BiblosChainInfo UpdateAttributeBandiDiGara(DocumentSeriesItem item, pubblicazione pub, ArchiveInfo archiveInfo, BiblosChainInfo chain)
{
foreach (ArchiveAttribute attribute in archiveInfo.Attributes)
{
string valueString = string.Empty;
DynamicAttribute attr;
try
{
attr = EnumHelper.ParseDescriptionToEnum <DynamicAttribute>(attribute.Name);
}
catch (Exception)
{
continue;
}
switch (attr)
{
case DynamicAttribute.Aggiudicatario:
valueString = this.GetAziendeAggiudicatarie(pub);
break;
case DynamicAttribute.Lotti:
valueString = this.GetLotti(pub);
break;
case DynamicAttribute.Liquidato:
valueString = this.GetImportoSommeLiquidate(pub).ToString();
break;
case DynamicAttribute.DitteInvitate:
valueString = this.GetAziendeInvitate(pub);
break;
case DynamicAttribute.DittePartecipanti:
valueString = this.GetAziendePartecipanti(pub);
break;
case DynamicAttribute.ProceduraAggiudicazione:
valueString = this.GetSceltaContraente(pub);
break;
case DynamicAttribute.ImportoComplessivo:
valueString = this.GetImportoAggiudicazione(pub).ToString();
break;
case DynamicAttribute.StrutturaProponente:
valueString = this.GetStrutturaProponente(pub);
break;
}
if (!string.IsNullOrEmpty(valueString))
{
chain.AddAttribute(attribute.Name, valueString);
continue;
}
DateTime valueDatetime = DateTime.MinValue;
switch (EnumHelper.ParseDescriptionToEnum <DynamicAttribute>(attribute.Name))
{
case DynamicAttribute.DurataAl:
DateTime?endDate = this.GetDataFineLavori(pub);
if ((endDate.HasValue))
{
valueDatetime = endDate.Value;
}
break;
case DynamicAttribute.DurataDal:
DateTime?startDate = this.GetDataInizioLavori(pub);
if ((startDate.HasValue))
{
valueDatetime = startDate.Value;
}
break;
}
if (valueDatetime != DateTime.MinValue)
{
chain.AddAttribute(attribute.Name, valueDatetime.ToString());
}
}
return(chain);
}
public ProtocolInitializer GetProtocolInitializer(IReadOnlyCollection <TenantModel> tenantModels, ProtocolModel protocolModel,
Collaboration collaboration, WorkflowProperty dsw_p_CollaborationSignSummaryTemplateId, WorkflowProperty dsw_a_Collaboration_GenerateSignSummary,
WorkflowProperty dsw_p_ProposerRole, UDSDto udsDto)
{
ProtocolInitializer protInitializer = new ProtocolInitializer();
// Oggetto
protInitializer.Subject = protocolModel.Object;
// Protocol Type
protInitializer.ProtocolType = protocolModel.ProtocolType.EntityShortId;
//Note
protInitializer.Notes = protocolModel.Note;
//Protocollo
protInitializer.DocumentProtocol = protocolModel.DocumentProtocol;
//Date
protInitializer.DocumentDate = protocolModel.DocumentDate;
// Classificazione
if (protocolModel.Category != null && protocolModel.Category.IdCategory.HasValue)
{
protInitializer.Category = FacadeFactory.Instance.CategoryFacade.GetById(protocolModel.Category.IdCategory.Value);
}
if (protocolModel.Container != null && protocolModel.Container.IdContainer.HasValue)
{
protInitializer.Containers = new List <Data.Container> {
FacadeFactory.Instance.ContainerFacade.GetById(Convert.ToInt32(protocolModel.Container.IdContainer))
};
}
if (protocolModel.DocumentTypeCode != null)
{
protInitializer.DocumentTypeLabel = FacadeFactory.Instance.TableDocTypeFacade.GetByCode(protocolModel.DocumentTypeCode).Description;
}
string owner = DocSuiteContext.Current.User.UserName;
// Gestione documenti
if (protocolModel.MainDocument != null && !string.IsNullOrEmpty(protocolModel.MainDocument.FileName) &&
(protocolModel.MainDocument.ContentStream != null || protocolModel.MainDocument.DocumentId.HasValue))
{
protInitializer.MainDocument = SaveStream(owner, protocolModel.MainDocument);
}
// Allegati
IEnumerable <DocumentModel> results = null;
if (protocolModel.Attachments != null && (results = protocolModel.Attachments.Where(f => !string.IsNullOrEmpty(f.FileName) && (f.ContentStream != null || f.DocumentId.HasValue))).Any())
{
protInitializer.Attachments = SaveStream(owner, results);
}
if (collaboration != null && dsw_p_CollaborationSignSummaryTemplateId != null && dsw_a_Collaboration_GenerateSignSummary != null &&
dsw_a_Collaboration_GenerateSignSummary.ValueBoolean.HasValue && dsw_a_Collaboration_GenerateSignSummary.ValueBoolean.Value &&
dsw_p_CollaborationSignSummaryTemplateId.ValueGuid.HasValue && dsw_p_CollaborationSignSummaryTemplateId.ValueGuid.Value != Guid.Empty)
{
TemplateDocumentRepository templateDocumentRepository = WebAPIImpersonatorFacade.ImpersonateFinder(new TemplateDocumentRepositoryFinder(tenantModels),
(impersonationType, finder) =>
{
finder.UniqueId = dsw_p_CollaborationSignSummaryTemplateId.ValueGuid.Value;
finder.EnablePaging = false;
return(finder.DoSearch().SingleOrDefault()?.Entity);
});
if (templateDocumentRepository != null)
{
BiblosChainInfo biblosChainInfo = new BiblosChainInfo(templateDocumentRepository.IdArchiveChain);
DocumentInfo biblosDocumentInfo = biblosChainInfo.Documents.Single(f => !f.IsRemoved);
List <BuildValueModel> buildValueModels = new List <BuildValueModel>();
buildValueModels.Add(new BuildValueModel()
{
IsHTML = false,
Name = "oggetto",
Value = protInitializer.Subject,
});
DateTime signDate;
string token;
foreach (CollaborationSign item in collaboration.CollaborationSigns)
{
signDate = item.SignDate ?? item.LastChangedDate.Value.DateTime;
token = signDate.DayOfWeek == DayOfWeek.Sunday ? "la" : "il";
buildValueModels.Add(new BuildValueModel()
{
IsHTML = false,
Name = $"signer_info_{item.Incremental}",
Value = $"{item.SignName} {token} {signDate.ToLongDateString()}",
});
}
buildValueModels = BuildValueProposerRole(dsw_p_ProposerRole, buildValueModels);
buildValueModels = BuildValueUDS(udsDto, buildValueModels);
byte[] pdf = Services.StampaConforme.Service.BuildPDF(biblosDocumentInfo.Stream, buildValueModels.ToArray(), string.Empty);
if (protInitializer.Attachments == null)
{
protInitializer.Attachments = new List <DocumentInfo>();
}
protInitializer.Attachments.Add(SaveStream(owner, pdf, "riepilogo_firmatari.pdf"));
}
}
// Annessi
results = null;
if (protocolModel.Annexes != null && (results = protocolModel.Annexes.Where(f => !string.IsNullOrEmpty(f.FileName) && (f.ContentStream != null || f.DocumentId.HasValue))).Any())
{
protInitializer.Annexed = SaveStream(owner, results);
}
// Contatti
protInitializer.Senders = new List <Data.ContactDTO>();
protInitializer.Recipients = new List <Data.ContactDTO>();
if (protocolModel.ContactManuals != null && protocolModel.ContactManuals.Any())
{
foreach (ProtocolContactManualModel protocolContactManualModel in protocolModel.ContactManuals)
{
Data.Contact contact = new Data.Contact();
contact.ContactType = new Data.ContactType(Data.ContactType.Aoo);
contact.Description = protocolContactManualModel.Description;
contact.CertifiedMail = protocolContactManualModel.CertifiedEmail;
contact.EmailAddress = protocolContactManualModel.EMail;
if (!string.IsNullOrEmpty(protocolContactManualModel.Address))
{
contact.Address = new Data.Address();
contact.Address.Address = protocolContactManualModel.Address;
}
if (protocolContactManualModel.ComunicationType == ComunicationType.Sender)
{
protInitializer.Senders.Add(new Data.ContactDTO(contact, Data.ContactDTO.ContactType.Manual));
}
else
{
protInitializer.Recipients.Add(new Data.ContactDTO(contact, Data.ContactDTO.ContactType.Manual));
}
}
}
if (protocolModel.Contacts != null && protocolModel.Contacts.Any())
{
foreach (ProtocolContactModel protocolContactModel in protocolModel.Contacts)
{
Data.Contact contact = FacadeFactory.Instance.ContactFacade.GetById(protocolContactModel.IdContact);
if (protocolContactModel.ComunicationType == ComunicationType.Sender)
{
protInitializer.Senders.Add(new Data.ContactDTO(contact, Data.ContactDTO.ContactType.Address));
}
else
{
protInitializer.Recipients.Add(new Data.ContactDTO(contact, Data.ContactDTO.ContactType.Address));
}
}
}
return(protInitializer);
}
