public void SetMetaData(Guid userId, TakeDocModel.Document document, TakeDocModel.Entity entity, bool startWorkflow, Newtonsoft.Json.Linq.JArray jsonMetaData)
{
ICollection <TakeDocModel.MetaData> metadatas = daoMetaData.GetBy(x => x.MetaDataVersionId == document.DocumentCurrentVersionId && x.EtatDeleteData == false && x.EntityId == document.EntityId);
foreach (Newtonsoft.Json.Linq.JObject obj in jsonMetaData)
{
string name = obj.Value <string>("name");
TakeDocModel.MetaData meta = metadatas.First(x => x.MetaDataName == name);
meta.MetaDataValue = obj.Value <string>("value");
meta.MetaDataText = obj.Value <string>("text");
if (obj.Value <string>("type") != null && IsBlob(obj.Value <string>("type")))
{
meta.MetaDataBlob = obj.Value <string>("value");
meta.MetaDataText = null;
meta.MetaDataValue = null;
}
}
try
{
daoMetaData.SetMetaData(userId, document.EntityId, document.DocumentTypeId, metadatas);
}
catch (System.Data.Entity.Validation.DbEntityValidationException ex1)
{
base.Logger.Error(ex1);
throw ex1;
}
}
public void RemoveUser(Guid userId, Guid entityId)
{
TakeDocModel.Entity entity = daoEntity.GetBy(x => x.EntityId == entityId).First();
TakeDocModel.UserTk user = daoUser.GetBy(x => x.UserTkId == userId).First();
daoEntity.RemoveUser(user, entity);
}
private void FillField(TakeDocModel.Version version, TakeDocModel.Entity entity, FileInfo destination)
{
TakeDocModel.UserTk user = daoUser.GetBy(x => x.UserTkId == version.Document.DocumentOwnerId).First();
string directoryEntity = string.Concat(TakeDocModel.Environnement.ModelDirectory, entity.EntityReference);
ICollection <TakeDocModel.Dto.Document.ReadOnlyMetadata> roMetaDatas = servMetaData.GetReadOnlyMetaData(version);
ULibre.Drivers.Interface.IDriver model = new ULibre.Drivers.Implementation.OdtDriver();
model.Open(destination.FullName);
foreach (TakeDocModel.Dto.Document.ReadOnlyMetadata ro in roMetaDatas.OrderBy(x => x.DisplayIndex))
{
if (ro.Type.ToUpper().Equals("IMAGE") == true)
{
model.FillImageBase64(ro.Name, ro.Value);
}
else
{
model.FillField(ro.Name, ro.Label);
}
}
ICollection <string> title = new List <string>();
title.Add("Titre");
title.Add(version.Document.DocumentLabel);
if (model.Exists("TabMetadata"))
{
model.AddLine("TabMetadata", title.ToArray <string>());
ICollection <string> reference = new List <string>();
reference.Add("Référence doc.");
reference.Add(version.Document.DocumentReference);
model.AddLine("TabMetadata", reference.ToArray <string>());
foreach (TakeDocModel.Dto.Document.ReadOnlyMetadata ro in roMetaDatas.OrderBy(x => x.DisplayIndex))
{
ICollection <string> line = new List <string>();
line.Add((string.IsNullOrEmpty(ro.Label) ? string.Empty : ro.Label));
line.Add((string.IsNullOrEmpty(ro.Text) ? string.Empty : servTraduction.Get("fr", ro.Text)));
if (ro.Type.ToUpper().Equals("IMAGE") == false)
{
model.AddLine("TabMetadata", line.ToArray <string>());
}
}
model.RemoveEmptyLine("TabMetadata");
}
FileInfo logo = new FileInfo(string.Concat(directoryEntity, @"\images\Logo.png"));
if (logo.Exists)
{
model.FillImage("Logo", logo.FullName);
}
model.FillField("TypeDocument", version.Document.Type_Document.TypeDocumentLabel);
model.FillField("Entite", entity.EntityLabel);
model.FillField("Consultant", string.Concat(user.UserTkFirstName, " ", user.UserTkLastName));
model.Save();
}
public void Update(TakeDocModel.UserTk user, TakeDocModel.Entity entity, TakeDocModel.Version version, Newtonsoft.Json.Linq.JObject jsonDocument, Newtonsoft.Json.Linq.JArray jsonMetadata, bool startWorkflow)
{
TakeDocModel.Document document = daoDocument.GetBy(x => x.DocumentCurrentVersionId == version.VersionId).First();
if (jsonDocument != null && jsonDocument.Value <string>("label") != null)
{
this.SetTitle(jsonDocument.Value <string>("label"), version.VersionId, user.UserTkId, entity.EntityId);
}
if (jsonMetadata != null)
{
servMeta.SetMetaData(user.UserTkId, document, entity, startWorkflow, jsonMetadata);
}
bool ok = true;
try
{
ok = servMeta.BeProven(document, document.LastVersionMetadata);
}
catch (Exception ex) { ok = false; }
if (jsonDocument != null && ok == true)
{
servStatus.SetStatus(document, TakeDocModel.Status_Document.Complete, user.UserTkId, true);
}
if (startWorkflow)
{
if (ok == false)
{
throw new Exception("MetaData non valide.");
}
this.StartWorkflow(document, user, entity.EntityId, false);
}
}
public ICollection <object> GetJsonByPeriod(ICollection <JObject> agendas, DateTimeOffset start, DateTimeOffset end)
{
ICollection <Guid> agendaIds = new List <Guid>();
foreach (JObject agenda in agendas)
{
agendaIds.Add(new Guid(agenda.Value <string>("id")));
}
ICollection <TakeDocModel.Entity> entitys = daoEntity.GetAll();
ICollection <TakeDocModel.FolderType> types = daoFolderType.GetAll();
ICollection <TakeDocModel.StatusFolder> status = daoStatusFolder.GetAll();
ICollection <TakeDocModel.Folder> folders = this.GetByPeriod(agendaIds, start, end);
IList <object> items = new List <object>();
foreach (TakeDocModel.Folder folder in folders)
{
TakeDocModel.Entity entity = entitys.First(x => x.EntityId == folder.EntityId);
TakeDocModel.FolderType ctype = types.First(x => x.FolderTypeId == folder.FolderTypeId);
TakeDocModel.StatusFolder cstatus = status.First(x => x.StatusFolderId == folder.FolderStatusId);
string color = string.Empty;
ICollection <JObject> currentAgenda = agendas.Where(x => new Guid(x.Value <string>("id")) == folder.FolderOwnerId).ToList();
if (currentAgenda.Count() > 0)
{
color = currentAgenda.First().Value <string>("color");
}
var json = new
{
id = folder.FolderId,
folderId = folder.FolderId,
folderTypeLabel = ctype.FolderTypeLabel,
title = folder.FolderLabel,
detail = folder.FolderDetail,
status = cstatus.StatusFolderLabel,
statusReference = cstatus.StatusFolderReference,
start = folder.FolderDateStart,
end = folder.FolderDateEnd,
allDay = false,
entityId = folder.EntityId,
entityLabel = entity.EntityLabel,
ownerId = folder.FolderOwnerId,
folderTypeId = folder.FolderTypeId,
readOnly = false,
color = color,
documentId = folder.Document.First().DocumentId,
documentVersionId = folder.Document.First().DocumentCurrentVersionId,
documentReference = folder.Document.First().DocumentReference,
typeDocumentId = folder.Document.First().DocumentTypeId,
documentStatutReference = folder.Document.First().Status_Document.StatusDocumentReference
};
items.Add(json);
}
return(items);
}
public byte[] Generate(TakeDocModel.Version version, TakeDocModel.Entity entity)
{
byte[] data = this.GenerateStarterPdf(version, entity);
if (data == null)
{
return(null);
}
PdfReader entetePdf = new PdfReader(data);
PdfReader imagePdf = servImage.GetImagePdf(version);
its.Document document = new its.Document(iTextSharp.text.PageSize.A4, -70, -70, 0, 0);
MemoryStream streamOut = new MemoryStream();
using (PdfCopy copy = new PdfCopy(document, streamOut))
{
document.Open();
for (int p = 1; p <= entetePdf.NumberOfPages; p++)
{
PdfImportedPage page = copy.GetImportedPage(entetePdf, p);
copy.AddPage(page);
}
copy.FreeReader(entetePdf);
entetePdf.Close();
if (imagePdf != null)
{
// add page image to the pdf
for (int p = 1; p <= imagePdf.NumberOfPages; p++)
{
PdfImportedPage page = copy.GetImportedPage(imagePdf, p);
copy.AddPage(page);
}
copy.FreeReader(imagePdf);
imagePdf.Close();
}
}
System.IO.FileInfo file = this.GetGenerateFileInfo(entity.EntityReference, version.VersionReference, "pdf");
System.IO.File.WriteAllBytes(file.FullName, streamOut.ToArray());
version.VersionPath = file.FullName.Replace(TakeDocModel.Environnement.VersionStoreUNC, string.Empty);
servVersion.Update(version);
return(streamOut.ToArray());
}
/// <summary>
/// Init tab with metadata name and value
/// </summary>
/// <param name="version"></param>
/// <param name="entity"></param>
/// <returns></returns>
private byte[] GenerateStarterPdf(TakeDocModel.Version version, TakeDocModel.Entity entity)
{
byte[] data = null;
FileInfo modele = new FileInfo(string.Concat(TakeDocModel.Environnement.ModelDirectory, entity.EntityReference, @"\", version.Document.Type_Document.TypeDocumentReference, "_", "starter.odt"));
if (modele.Exists == false)
{
modele = new FileInfo(string.Concat(TakeDocModel.Environnement.ModelDirectory, "version_starter.odt"));
}
FileInfo destinationOdt = new FileInfo(string.Concat(TakeDocModel.Environnement.TempDirectory, Guid.NewGuid().ToString(), modele.Extension));
FileInfo destinationPdf = new FileInfo(string.Concat(destinationOdt.FullName.Replace(destinationOdt.Extension, ".pdf")));
modele.CopyTo(destinationOdt.FullName);
try
{
this.FillField(version, entity, destinationOdt);
System.Diagnostics.ProcessStartInfo info = new System.Diagnostics.ProcessStartInfo(TakeDocModel.Environnement.BatchConvertPdf);
info.WorkingDirectory = TakeDocModel.Environnement.TempDirectory;
info.Arguments = destinationOdt.FullName;
System.Diagnostics.Process process = System.Diagnostics.Process.Start(info);
process.WaitForExit();
data = System.IO.File.ReadAllBytes(destinationPdf.FullName);
}
catch (Exception ex)
{
this.Logger.Error(ex);
}
finally
{
if (destinationOdt.Exists)
{
destinationOdt.Delete();
}
if (destinationPdf.Exists)
{
destinationPdf.Delete();
}
}
return(data);
}
private void AddPage(Guid userId, Guid entityId, Guid versionId, byte[] data, string extension, int rotation, int pageNumber)
{
base.Logger.DebugFormat("AddPage: add page to version [{0}], extension : [{1}], rotation [{2}]", versionId, extension, rotation);
TakeDocModel.Page page = daoPage.Add(userId, entityId, versionId, extension, rotation, pageNumber);
TakeDocModel.Entity entity = daoEntity.GetBy(x => x.EntityId == entityId).First();
//**********************************
// Store page in original format
//**********************************
// generate full path filename
System.IO.FileInfo file = this.GeneratePageUNC(entity.EntityReference, page.PageReference, extension);
// write full path file name
base.Logger.DebugFormat("AddPage: write byte in file [{0}]", file.FullName);
System.IO.File.WriteAllBytes(file.FullName, data);
page.PagePath = file.FullName.Replace(TakeDocModel.Environnement.PageStoreUNC, string.Empty);
daoPage.Update(page);
}
/// <summary>
/// Send mail to inform that a user ask a account
/// </summary>
/// <param name="user">user who want to create account</param>
/// <param name="entity"></param>
private void SendMailToInform(TakeDocModel.UserTk user, TakeDocModel.Entity entity)
{
string toParameter = string.Concat("MAIL_INFORM_REQUEST_ACCOUNT_TO_", entity.EntityReference);
ICollection <TakeDocModel.Parameter> parameters = daoParameter.GetBy(x => x.ParameterReference == toParameter);
if (parameters.Count() == 0)
{
throw new Exception("Aucun destinataire ne sera informé dans cette demande. Votre demande ne sera pas prise en compte.");
}
string to = parameters.First().ParameterValue;
string from = daoParameter.GetBy(x => x.ParameterReference == "MAIL_INFORM_REQUEST_ACCOUNT_FROM").First().ParameterValue;
string title = daoParameter.GetBy(x => x.ParameterReference == "MAIL_INFORM_REQUEST_ACCOUNT_TITLE").First().ParameterValue;
string bodyFile = daoParameter.GetBy(x => x.ParameterReference == "MAIL_INFORM_REQUEST_ACCOUNT_BODY").First().ParameterValue;
string path = string.Concat(TakeDocModel.Environnement.ModelDirectory, entity.EntityReference, @"\", "mail", @"\", bodyFile);
string body = System.IO.File.ReadAllText(path);
servMail.Send(title, body, from, to, user);
}
public void Update(Guid userId, Guid entityId, string json, bool startWorkflow)
{
using (TransactionScope transaction = new TransactionScope())
{
Newtonsoft.Json.Linq.JArray data = Newtonsoft.Json.Linq.JArray.Parse(json);
Newtonsoft.Json.Linq.JObject context = String.IsNullOrEmpty(data[0].ToString()) ? null : (Newtonsoft.Json.Linq.JObject)data[0];
Newtonsoft.Json.Linq.JObject document = String.IsNullOrEmpty(data[1].ToString()) ? null : (Newtonsoft.Json.Linq.JObject)data[1];
Newtonsoft.Json.Linq.JArray metadatas = String.IsNullOrEmpty(data[2].ToString()) ? null : (Newtonsoft.Json.Linq.JArray)data[2];
Newtonsoft.Json.Linq.JArray pages = String.IsNullOrEmpty(data[3].ToString()) ? null : (Newtonsoft.Json.Linq.JArray)data[3];
Guid versionId = new Guid(document.Value <string>("versionId"));
TakeDocModel.Entity entity = daoEntity.GetBy(x => x.EntityId == entityId).First();
TakeDocModel.Version version = servVersion.GetById(versionId);
TakeDocModel.UserTk user = daoUser.GetBy(x => x.UserTkId == userId).First();
if (pages != null)
{
servPage.Update(pages, userId, version, entity.EntityId);
}
servDocument.Update(user, entity, version, document, metadatas, startWorkflow);
transaction.Complete();
}
}
public TakeDocModel.UserTk Create(TakeDocModel.UserTk user, TakeDocModel.Entity entity)
{
this.Create(user);
servEntity.AddUser(user, entity);
return(user);
}
public void AddUser(TakeDocModel.UserTk user, TakeDocModel.Entity entity)
{
daoEntity.AddUser(user, entity);
}
public byte[] Generate(Guid versionId, Guid entityId)
{
TakeDocModel.Version version = servVersion.GetBy(x => x.VersionId == versionId && x.EntityId == entityId).First();
TakeDocModel.Entity entity = daoEntity.GetBy(x => x.EntityId == entityId).First();
return(this.Generate(version, entity));
}
public TakeDocModel.MetaDataFile Update(string fullName, byte[] data, Guid metadataId, Guid userId, TakeDocModel.Entity entity)
{
ICollection <TakeDocModel.MetaDataFile> mFiles = daoMdFile.GetBy(x => x.MetaDataId == metadataId && x.EntityId == entity.EntityId && x.EtatDeleteData == false);
foreach (TakeDocModel.MetaDataFile mFile in mFiles)
{
daoMdFile.Delete(mFile.MetaDataId, userId);
}
string reference = daoMdFile.GenerateReference();
System.IO.FileInfo f = this.GetFile(fullName);
System.IO.FileInfo file = this.GenerateUNC(entity.EntityReference, TakeDocModel.Environnement.MetaDataFileStoreUNC, reference, f.Extension.Replace(".", string.Empty), true);
TakeDocModel.MetaDataFile back = new TakeDocModel.MetaDataFile()
{
MetaDataFileReference = reference,
MetaDataFilePath = file.FullName.Replace(TakeDocModel.Environnement.MetaDataFileStoreUNC, string.Empty),
MetaDataFileName = string.Concat(reference, file.Extension),
MetaDataId = metadataId,
UserCreateData = userId,
DateCreateData = System.DateTimeOffset.UtcNow,
EtatDeleteData = false,
EntityId = entity.EntityId,
MetaDataFileExtension = file.Extension.Replace(".", string.Empty)
};
try
{
daoMdFile.Add(back);
System.IO.File.WriteAllBytes(file.FullName, data);
}
catch (System.Data.Entity.Validation.DbEntityValidationException ex1)
{
base.Logger.Error(ex1);
throw ex1;
}
catch (Exception ex)
{
base.Logger.Error(ex);
throw ex;
}
return(back);
}
