public void SetStatus(TakeDocModel.Document document, string status, Guid userId, bool updateStatusVersion)
{
bool ok = (document.Status_Document.StatusDocumentReference.Equals(status) == false);
if (ok)
{
bool okStatus = this.CheckNewStatus(document.Status_Document.StatusDocumentReference, status);
if (okStatus == false)
{
throw new Exception("Erreur workflow");
}
using (TransactionScope transaction = new TransactionScope())
{
TakeDocModel.Status_Document stDocument = daoStDocument.GetBy(x => x.StatusDocumentReference == status && x.EntityId == document.EntityId).First();
// mise à jour du statut de la version à recu
if (document.DocumentCurrentVersionId.HasValue && updateStatusVersion == true)
{
TakeDocModel.Version version = document.Version.Where(x => x.VersionId == document.DocumentCurrentVersionId).First();
servVersion.SetStatus(version, status, userId);
}
context.AddDocumentStatusHisto(document.DocumentId, document.DocumentStatusId, userId, document.EntityId);
// mise à jour du statut du document à recu
document.DocumentStatusId = stDocument.StatusDocumentId;
document.UserUpdateData = userId;
document.DateUpdateData = System.DateTimeOffset.UtcNow;
daoDocument.Update(document);
transaction.Complete();
}
}
}
public void CreateDocument()
{
TakeDocModel.Environnement.Init(System.Configuration.ConfigurationManager.AppSettings);
TakeDocModel.TypeDocument typeDocument = daoTypeDocument.GetBy(x => x.TypeDocumentReference == "TEST-INTEGRATION-NO-VALIDATION").First();
MyDocument = servDocument.Create(userId, entityId, typeDocument.TypeDocumentId, "Test intégration no validation");
Assert.IsTrue(MyDocument.Status_Document.StatusDocumentReference.Equals(TakeDocModel.Status_Document.Create), "Statut du document CREATE");
Assert.IsTrue(MyDocument.Version.Count() == 1);
Assert.IsTrue(MyDocument.LastVersion.VersionMajor);
Assert.IsTrue(MyDocument.LastVersion.VersionNumber == 0);
Assert.AreEqual(MyDocument.UserCreateData, userId);
Assert.AreEqual(MyDocument.EntityId, entityId);
Assert.IsNotNull(MyDocument.DateCreateData);
Assert.AreNotEqual(MyDocument.DateCreateData, System.DateTimeOffset.MinValue);
Assert.IsFalse(MyDocument.EtatDeleteData);
Assert.IsFalse(MyDocument.LastVersion.EtatDeleteData);
Assert.IsTrue(MyDocument.Type_Document.TypeDocumentReference == "TEST-INTEGRATION-NO-VALIDATION");
Assert.IsTrue(MyDocument.DocumentLabel == "Test intégration no validation");
Assert.IsTrue(MyDocument.LastVersionMetadata.Count() == 2);
Assert.IsTrue(MyDocument.LastVersionMetadata.Any(x => x.MetaDataName == "REFACTURABLE") == true);
Assert.IsTrue(MyDocument.LastVersionMetadata.Any(x => x.MetaDataName == "MONTANT") == true);
ICollection <TakeDocModel.DocumentStatusHisto> histos = servStatus.GetStatus(MyDocument);
Assert.IsTrue(histos.Count() == 0, "no histo for the moment");
}
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 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 SetTitle(string title, Guid versionId, Guid userId, Guid entityId)
{
TakeDocModel.Document document = daoDocument.GetBy(x => x.DocumentCurrentVersionId == versionId && x.EntityId == entityId).First();
document.DateUpdateData = System.DateTime.UtcNow;
document.UserUpdateData = userId;
document.DocumentLabel = title;
daoDocument.Update(document);
}
public bool Execute(TakeDocModel.Document document, TakeDocModel.UserTk user)
{
this.SetStatus(document, TakeDocModel.Status_Document.ToValidate, user.UserTkId);
base.SetTypeDocumentValidation(document, "BACKOFFICE", 0);
daoDocument.Update(document);
servReportVersion.Generate(document.DocumentCurrentVersionId.Value, document.EntityId);
return(true);
}
private bool Execute(TakeDocModel.Document document, Guid userId)
{
TakeDocModel.Version version = document.LastVersion;
servReportVersion.Generate(version.VersionId, version.EntityId);
if (this.daoWorkflow.IsAllApprove(version.VersionId, version.EntityId))
{
this.SetStatus(document, TakeDocModel.Status_Document.Archive, userId);
}
return(true);
}
public void CreateDocumentTest()
{
TakeDocModel.Environnement.Init(System.Configuration.ConfigurationManager.AppSettings);
TakeDocModel.TypeDocument typeDocument = daoTypeDocument.GetBy(x => x.TypeDocumentReference == "NOTE_FRAIS").First();
MyDocument = servDocument.Create(userId, entityId, typeDocument.TypeDocumentId, "Test creation document");
string base64image = servImage.ToBase64String(TakeDocModel.Environnement.JpegTestFile1);
servDocument.AddPage(userId, entityId, MyDocument.DocumentId, base64image, "jpeg", 90);
}
public void AddPage(Guid userId, Guid entityId, Guid documentId, string imageString, string extension, int rotation)
{
using (TransactionScope transaction = new TransactionScope())
{
TakeDocModel.Document document = daoDocument.GetBy(x => x.DocumentId == documentId).First();
servPage.Add(userId, entityId, document.DocumentCurrentVersionId.Value, imageString, extension, rotation, Int32.MinValue);
transaction.Complete();
}
}
private void StartWorkflow(TakeDocModel.Document document, TakeDocModel.UserTk user, Guid entityId, bool checkValue)
{
bool ok = true;
if (checkValue)
{
TakeDocModel.Version version = servVersion.GetById(document.DocumentCurrentVersionId.Value, x => x.MetaData);
ok = servMeta.BeProven(document, version.MetaData);
// here, all metadata are ok, so document is complete
servStatus.SetStatus(document, TakeDocModel.Status_Document.Complete, user.UserTkId, true);
}
if (ok)
{
using (TransactionScope transaction = new TransactionScope())
{
//***********************************
// update status of document
//***********************************
TakeDocModel.WorkflowType validation = document.Type_Document.WorkflowType;
TakeDocService.Workflow.Document.Interface.IValidation wfValidation = null;
if (validation.WorkflowTypeReference == "AUTO")
{
wfValidation = new TakeDocService.Workflow.Document.ValidationAuto();
wfValidation.Execute(document, user);
}
else if (validation.WorkflowTypeReference == "NO")
{
wfValidation = new TakeDocService.Workflow.Document.ValidationNo();
wfValidation.Execute(document, user);
}
else if (validation.WorkflowTypeReference == "MANAGER")
{
wfValidation = new TakeDocService.Workflow.Document.ValidationManager();
wfValidation.Execute(document, user);
}
else if (validation.WorkflowTypeReference == "BACKOFFICE")
{
wfValidation = new TakeDocService.Workflow.Document.ValidationBackOffice();
wfValidation.Execute(document, user);
}
else if (validation.WorkflowTypeReference == "MANAGER-BACKOFFICE")
{
wfValidation = new TakeDocService.Workflow.Document.ValidationManagerBackOffice();
wfValidation.Execute(document, user);
}
//***********************************
// end update status of document
//***********************************
transaction.Complete();
}
}
}
public void Delete(Guid documentId, Guid entityId, Guid userId)
{
using (TransactionScope transaction = new TransactionScope())
{
TakeDocModel.Document document = daoDocument.GetBy(x => x.DocumentId == documentId).First();
servVersion.Delete(documentId, entityId, userId);
document.EtatDeleteData = true;
document.DateDeleteData = System.DateTime.UtcNow;
document.UserDeleteData = userId;
daoDocument.Delete(document);
transaction.Complete();
}
}
public void AddVersionMinor(Guid userId, Guid entityId, Guid documentId)
{
using (TransactionScope transaction = new TransactionScope())
{
TakeDocModel.Document document = daoDocument.GetBy(x => x.DocumentId == documentId).First();
TakeDocModel.Version version = servVersion.CreateMinor(userId, entityId, System.Guid.NewGuid(), documentId, document.DocumentTypeId);
servStatus.SetStatus(document.DocumentId, TakeDocModel.Status_Document.Create, userId, false);
document.DocumentCurrentVersionId = version.VersionId;
daoDocument.Update(document);
transaction.Complete();
}
}
public TakeDocModel.Document Create(Guid userId, Guid entityId, Guid typeDocumentId, string documentLabel, Guid?folderId)
{
using (TransactionScope transaction = new TransactionScope())
{
this.Logger.Info(string.Format("Create document by {0}", userId));
Guid documentId = System.Guid.NewGuid();
Guid versionId = documentId;
TakeDocModel.Document document = daoDocument.Create(userId, entityId, documentId, versionId, typeDocumentId, documentLabel, folderId);
TakeDocModel.Version version = servVersion.CreateMajor(userId, entityId, versionId, documentId, typeDocumentId);
transaction.Complete();
return(document);
}
}
public ICollection <object> GetStatusHistory(Guid documentId, Guid entityId)
{
ICollection <object> back = new List <object>();
try
{
TakeDocModel.Document document = daoDocument.GetBy(x => x.DocumentId == documentId && x.EntityId == entityId).First();
ICollection <TakeDocModel.GetWorkflowHistory_Result> steps = context.GetWorkflowHistory(documentId, entityId).ToList();
ICollection <TakeDocModel.DocumentStatusHisto> historyStatus = servStatus.GetStatus(documentId, entityId);
ICollection <TakeDocModel.Status_Document> statusDocument = daoStDocument.GetBy(x => x.EntityId == entityId);
// when document is create
TakeDocModel.DocumentStatusHisto historyToAdd = new TakeDocModel.DocumentStatusHisto();
historyToAdd.DateCreateData = document.DateCreateData;
historyToAdd.DocumentId = document.DocumentId;
historyToAdd.DocumentIndex = historyStatus.Count() + 1;
historyToAdd.DocumentStatusId = document.DocumentStatusId;
historyToAdd.DocumentVersionId = document.DocumentCurrentVersionId.Value;
historyToAdd.EntityId = document.EntityId;
historyToAdd.UserCreateData = document.UserCreateData;
historyStatus.Add(historyToAdd);
foreach (TakeDocModel.DocumentStatusHisto h in historyStatus)
{
var actions = steps.Where(x => x.StatusDocumentId == h.DocumentStatusId).ToList();
ICollection <TakeDocModel.Status_Document> myStatusDocument = statusDocument.Where(x => x.EntityId == entityId && x.StatusDocumentId == h.DocumentStatusId).ToList();
string statusLabel = (myStatusDocument.Count() == 0) ? "" : myStatusDocument.First().StatusDocumentLabel;
var toAdd = new
{
DocumentId = h.DocumentId,
DocumentIndex = h.DocumentIndex,
DocumentStatusId = h.DocumentStatusId,
DocumentStatusLabel = statusLabel,
DocumentVersionId = h.DocumentVersionId,
EntityId = h.EntityId,
DateCreateData = h.DateCreateData,
Actions = actions
};
back.Add(toAdd);
}
}
catch (Exception ex)
{
base.Logger.Error(ex.Message, ex);
throw ex;
}
return(back);
}
/// <summary>
/// Add/enable manager validation for this document
/// </summary>
/// <param name="user"></param>
protected void SetTypeDocumentValidation(TakeDocModel.Document document, string workflowType, int step)
{
if (document.DocumentCurrentVersionId.Value == Guid.Empty || document.DocumentCurrentVersionId.Value == null)
{
throw new Exception("Version can't be empty.");
}
TakeDocModel.Workflow workflow = new TakeDocModel.Workflow();
workflow.WorkflowId = Guid.NewGuid();
workflow.EntityId = document.EntityId;
workflow.WorkflowVersionId = document.DocumentCurrentVersionId.Value;
workflow.WorkflowIndex = step;
workflow.WorkflowAnswerId = null;
workflow.WorkflowTypeId = daoWorkflowType.GetBy(x => x.WorkflowTypeReference == workflowType).First().WorkflowTypeId;
workflow.WorkflowTypeDocumentId = document.DocumentTypeId;
workflow.WorkflowStatusDocumentId = document.DocumentStatusId;
workflow.EtatDeleteData = false;
workflow.DateCreateData = System.DateTimeOffset.UtcNow;
daoWorkflow.Add(workflow);
}
/// <summary>
/// Check if metadata is valid (type, mandatory, .....)
/// </summary>
/// <param name="document"></param>
/// <param name="metadatas"></param>
/// <returns></returns>
public bool BeProven(TakeDocModel.Document document, ICollection <TakeDocModel.MetaData> metadatas)
{
ICollection <TakeDocModel.View_TypeDocumentDataField> fields = servDataField.GetDataField(document.DocumentTypeId, document.EntityId);
foreach (TakeDocModel.MetaData meta in metadatas)
{
ICollection <TakeDocModel.View_TypeDocumentDataField> field = fields.Where(x => x.Reference == meta.MetaDataName && x.TypeDocumentId == document.DocumentTypeId).ToList();
if (field.Count() > 0)
{
string value = (string.IsNullOrEmpty(meta.MetaDataValue) == false) ? meta.MetaDataValue : meta.MetaDataBlob;
bool ok = this.BeProven(field.First().TypeId, value, field.First().Mandatory);
if (ok == false)
{
throw new Exception(string.Format("Champ [{0}] non valide : {1}.", field.First().Label, meta.MetaDataValue));
}
}
}
return(true);
}
public void CreateDocument()
{
TakeDocModel.Environnement.Init(System.Configuration.ConfigurationManager.AppSettings);
TakeDocModel.TypeDocument typeDocument = daoTypeDocument.GetBy(x => x.TypeDocumentReference == "NOTE_FRAIS").First();
MyDocument = servDocument.Create(userId, entityId, typeDocument.TypeDocumentId, "Test creation document");
Assert.IsTrue(MyDocument.Status_Document.StatusDocumentReference.Equals(TakeDocModel.Status_Document.Create), "Statut du document CREATE");
Assert.IsTrue(MyDocument.Version.Count() == 1);
Assert.IsTrue(MyDocument.LastVersion.VersionMajor);
Assert.IsTrue(MyDocument.LastVersion.VersionNumber == 0);
Assert.AreEqual(MyDocument.UserCreateData, userId);
Assert.AreEqual(MyDocument.EntityId, entityId);
Assert.IsNotNull(MyDocument.DateCreateData);
Assert.AreNotEqual(MyDocument.DateCreateData, System.DateTimeOffset.MinValue);
Assert.IsFalse(MyDocument.EtatDeleteData);
Assert.IsFalse(MyDocument.LastVersion.EtatDeleteData);
Assert.IsTrue(MyDocument.Type_Document.TypeDocumentReference == "NOTE_FRAIS");
Assert.IsTrue(MyDocument.DocumentLabel == "Test creation document");
Assert.IsTrue(MyDocument.LastVersionMetadata.Count() > 2);
}
public void SetAnswer(Guid workflowId, Guid versionId, Guid userId, Guid answerId, string comment)
{
using (TransactionScope transaction = new TransactionScope())
{
try
{
TakeDocModel.Document document = daoDoc.GetBy(x => x.DocumentCurrentVersionId == versionId).First();
ICollection <TakeDocModel.Workflow> workflows = daoWf.GetBy(x => x.WorkflowVersionId == versionId, x => x.WorkflowAnswer);
TakeDocModel.Workflow workflow = workflows.Where(x => x.WorkflowId == workflowId && x.WorkflowDateRealize == null && x.WorkflowAnswerId == null).First();
daoWf.SetAnswer(workflow, answerId, userId, comment);
TakeDocModel.WorkflowAnswer answer = daoAnswer.GetBy(x => x.WorkflowAnswerId == answerId).First();
if (answer.WorkflowAnswerGoOn == false)
{
daoWf.CancelWorkflowStep(document.DocumentCurrentVersionId.Value);
servStatus.SetStatus(document.DocumentId, TakeDocModel.Status_Document.Refuse, userId, true);
}
else
{
bool isAllApprove = !workflows.Any(x => x.WorkflowAnswer == null);
if (isAllApprove)
{
isAllApprove = !workflows.Any(x => x.WorkflowAnswer.WorkflowAnswerGoOn != true);
}
if (isAllApprove)
{
servStatus.SetStatus(document.DocumentId, TakeDocModel.Status_Document.Approve, userId, true);
}
}
transaction.Complete();
}
catch (Exception ex)
{
base.Logger.Error("Answer.Answer", ex);
throw ex;
}
}
}
public HttpResponseMessage Put(Guid typeDocumentId, Guid userId, Guid entityId, [FromBody] string label)
{
TakeDocService.Document.Interface.IDocumentService servDoc = Utility.MyUnityHelper.UnityHelper.Resolve <TakeDocService.Document.Interface.IDocumentService>();
TakeDocService.Document.Interface.IDocumentCompleteService servDocTk = Utility.MyUnityHelper.UnityHelper.Resolve <TakeDocService.Document.Interface.IDocumentCompleteService>();
try
{
TakeDocModel.Document document = servDoc.Create(userId, entityId, typeDocumentId, label);
TakeDocModel.Dto.Document.DocumentComplete documentComplete = servDocTk.GetByVersion(document.DocumentCurrentVersionId.Value, userId, entityId);
var back = new
{
MetaDatas = new List <TakeDocModel.MetaData>(),
Document = documentComplete.Document,
Pages = new List <TakeDocModel.Page>()
};
return(Request.CreateResponse(back));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
protected void SetStatus(TakeDocModel.Document document, string status, Guid userId)
{
servStatus.SetStatus(document, status, userId, true);
if (document.DocumentFolderId != null && document.DocumentFolderId != System.Guid.Empty)
{
TakeDocModel.StatusFolder stFolder = null;
if (status == TakeDocModel.Status_Document.Approve || status == TakeDocModel.Status_Document.Archive)
{
stFolder = daoStFolder.GetBy(x => x.EntityId == document.EntityId && x.StatusFolderReference == "CLOSE").First();
}
else if (status == TakeDocModel.Status_Document.Create)
{
stFolder = daoStFolder.GetBy(x => x.EntityId == document.EntityId && x.StatusFolderReference == "OPEN").First();
}
else if (status == TakeDocModel.Status_Document.Complete || status == TakeDocModel.Status_Document.Incomplete ||
status == TakeDocModel.Status_Document.Refuse || status == TakeDocModel.Status_Document.ToValidate)
{
stFolder = daoStFolder.GetBy(x => x.EntityId == document.EntityId && x.StatusFolderReference == "INPROGRESS").First();
}
this.context.UpdateFolderStatus(document.DocumentFolderId, document.EntityId, stFolder.StatusFolderId);
}
}
public ICollection <TakeDocModel.DocumentStatusHisto> GetStatus(TakeDocModel.Document document)
{
return(this.GetStatus(document.DocumentId, document.EntityId));
}
public void SetStatus(Guid documentId, string status, Guid userId, bool updateStatusVersion)
{
TakeDocModel.Document document = daoDocument.GetBy(x => x.DocumentId == documentId).First();
this.SetStatus(document, status, userId, updateStatusVersion);
}
public void DeleteByFolderId(Guid folderId, Guid entityId, Guid userId)
{
TakeDocModel.Document document = daoDocument.GetBy(x => x.DocumentFolderId == folderId).First();
this.Delete(document.DocumentId, entityId, userId);
}
public bool Execute(TakeDocModel.Document document, TakeDocModel.UserTk user)
{
return(this.Execute(document, user.UserTkId));
}
public void SetStatusComplete()
{
servStatus.SetStatus(MyDocument.DocumentId, TakeDocModel.Status_Document.Complete, userId, true);
MyDocument = servDocument.GetById(MyDocument.DocumentId, x => x.Status_Document);
Assert.IsTrue(MyDocument.Status_Document.StatusDocumentReference.Equals(TakeDocModel.Status_Document.Complete), "Statut du document MetaSend");
}
