public async Task <ActionResult> Delete(byte id)
{
try
{
string apicheckIsUsedUrl = controllerName + "/CheckIsUsed/" + id;
var checkIsused = await APIProvider.Get <bool>(apicheckIsUsedUrl);
if (!checkIsused)
{
var model = new WorkflowViewModel();
model.Id = id;
//Call API Provider - Transactions
string apiUrl = APIProvider.APIGenerator(controllerName, APIConstant.ACTION_DELETE);
var result = await APIProvider.Authorize_DynamicTransaction <WorkflowViewModel, bool>(model, _userSession.BearerToken, apiUrl, APIConstant.API_Resource_CMS, ARS.IgnoredARS);
}
else
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.TypeResult.ERROR, ApplicationGenerator.GeneralActionMessage(APIConstant.ACTION_DELETE, ApplicationGenerator.TypeResult.ISUSED));
}
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
Logger.LogError(ex);
return(View());
}
}
public async Task <ActionResult> Edit(byte id)
{
var data = new WorkflowViewModel();
try
{
if (!await APIProvider.Authorization(_userSession.BearerToken, ARS.Edit))
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.FuntionType.Account, APIConstant.ACTION_UPDATE);
return(RedirectToAction("Index"));
}
else
{
//Call API Provider
string strUrl = APIProvider.APIGenerator(this, this.RouteData.Values["action"].ToString(), id);
data = await APIProvider.Get <WorkflowViewModel>(controllerName + strUrl);
return(View(data));
}
}
catch (HttpException ex)
{
Logger.LogError(ex);
int statusCode = ex.GetHttpCode();
if (statusCode == 401)
{
TempData["Alert"] = ApplicationGenerator.RenderResult(FuntionType.Department, APIConstant.ACTION_ACCESS);
return(new HttpUnauthorizedResult());
}
throw ex;
}
}
public async Task <ActionResult> ViewConfirmDelete(WorkflowViewModel model)
{
try
{
if (!await APIProvider.Authorization(_userSession.BearerToken, ARS.Delete))
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.FuntionType.Article, APIConstant.ACTION_DELETE);
return(RedirectToAction("Index"));
}
else
{
return(PartialView("_Delete", model));
}
}
catch (HttpException ex)
{
Logger.LogError(ex);
int statusCode = ex.GetHttpCode();
if (statusCode == 401)
{
TempData["Alert"] = ApplicationGenerator.RenderResult(FuntionType.Department, APIConstant.ACTION_ACCESS);
return(new HttpUnauthorizedResult());
}
throw ex;
}
}
/// <summary>
/// Action workflow by outcome in workflow.
/// </summary>
/// <param name="model">The task list information.</param>
public string Action(WorkflowViewModel model)
{
string result = string.Empty;
int nextStep = model.Step + 1;
string processInstanceStatus = ConstantValue.WorkflowStatusInWorkflowProcess;
Dictionary <string, object> dataFields = new Dictionary <string, object>();
if (!this.IsWorkflowFisnish(model.ProcessInstanceId, nextStep) && model.Action != ConstantValue.WorkflowActionReject)
{
result = "GoNext";
dataFields.Add(ConstantValue.DataFieldsKeyGoNextActivity, false);
dataFields.Add(ConstantValue.DataFieldsKeyActionUser, this.GetCurrentApprove(model.ProcessInstanceId, nextStep));
dataFields.Add(ConstantValue.DataFieldsKeyCurrentStep, nextStep);
}
else
{
dataFields.Add(ConstantValue.DataFieldsKeyGoNextActivity, true);
nextStep = 0;
processInstanceStatus = ConstantValue.WorkflowStatusComplete;
}
_k2Service.ActionWorkflow(model.SerialNo, model.Action, dataFields);
this.UpdateWorkflowProcessInstance(model.ProcessInstanceId, nextStep, processInstanceStatus);
this.SaveWorkflowLog(this.InitialWorkflowLog(model.ProcessInstanceId, model.Step, model.SerialNo, model.Action, model.Comment));
return(result);
}
public IEnumerable <WorkflowViewModel> PorDocumento(int id)
{
var workflow = this.workflowRepositorio
.ObterDoDocumento(id);
Log.App.Info("Fluxos do documento:: " + workflow.Count);
var fluxos = new List <WorkflowViewModel>();
foreach (var fluxo in workflow)
{
var viewModel = new WorkflowViewModel
{
Id = fluxo.Id,
CriadoEm = fluxo.CriadoEm,
De = fluxo.De,
Documento = fluxo.Documento,
FinalizadoEm = fluxo.FinalizadoEm,
Lido = fluxo.Lido,
Mensagem = fluxo.Mensagem,
Para = fluxo.Para,
Status = fluxo.Status
};
fluxos.Add(viewModel);
}
return(fluxos as IEnumerable <WorkflowViewModel>);
}
public IEnumerable <WorkflowViewModel> CaixaEntrada(int id = 0)
{
var workflow = this.workflowRepositorio
.ObterCaixaEntrada(this.sessaoDoUsuario.UsuarioAtual);
Log.App.Info("Documentos da Caixa de entrada:: " + workflow.Count);
var fluxos = new List <WorkflowViewModel>();
foreach (var fluxo in workflow)
{
var viewModel = new WorkflowViewModel
{
Id = fluxo.Id,
CriadoEm = fluxo.CriadoEm,
De = fluxo.De,
Documento = fluxo.Documento,
FinalizadoEm = fluxo.FinalizadoEm,
Lido = fluxo.Lido,
Mensagem = fluxo.Mensagem,
Para = fluxo.Para,
Status = fluxo.Status
};
fluxos.Add(viewModel);
}
return(fluxos as IEnumerable <WorkflowViewModel>);
}
// GET: Workflow
public async Task <ActionResult> Index()
{
var results = new WorkflowsModel();
try
{
//Call API Provider
controllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
var list = await APIProvider.Authorize_Get <List <WorkflowViewModel> >(_userSession.BearerToken, controllerName, APIConstant.API_Resource_CMS, ARS.Get);
var data = new WorkflowViewModel();
results.lstWorkflowViewModel = list;
results.WorkflowViewModel = data;
return(View(results));
}
catch (HttpException ex)
{
Logger.LogError(ex);
int statusCode = ex.GetHttpCode();
if (statusCode == 401)
{
TempData["Alert"] = ApplicationGenerator.RenderResult(FuntionType.Department, APIConstant.ACTION_ACCESS);
return(new HttpUnauthorizedResult());
}
throw ex;
}
}
public async Task <IActionResult> OnPostAsync(Guid idTarefa, Guid idWorkflow)
{
try
{
if (!ModelState.IsValid)
{
Lista = await _cpnucleoApiService.GetAsync <IEnumerable <WorkflowViewModel> >("workflow", Token);
ListaTarefas = await _cpnucleoApiService.GetAsync <IEnumerable <TarefaViewModel> >("tarefa", Token, true);
return(Page());
}
WorkflowViewModel result3 = await _cpnucleoApiService.GetAsync <WorkflowViewModel>("workflow", Token, idWorkflow);
await _cpnucleoApiService.PutAsync("tarefa", "putByWorkflow", Token, idTarefa, result3);
return(Page());
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(Page());
}
}
public void Test_OnPost(string nome, int ordem)
{
// Arrange
WorkflowViewModel workflowMock = new WorkflowViewModel {
Nome = nome, Ordem = ordem
};
_workflowAppService.Setup(x => x.Incluir(workflowMock));
IncluirModel pageModel = new IncluirModel(_workflowAppService.Object);
PageModelTester <IncluirModel> pageTester = new PageModelTester <IncluirModel>(pageModel);
// Act
pageTester
.Action(x => x.OnPost)
// Assert
.WhenModelStateIsValidEquals(false)
.TestPage();
// Act
pageTester
.Action(x => x.OnPost)
// Assert
.WhenModelStateIsValidEquals(true)
.TestRedirectToPage("Listar");
// Assert
Validation.For(workflowMock).ShouldReturn.NoErrors();
}
public async Task GetWorkflowQuery_Handle()
{
// Arrange
IUnitOfWork unitOfWork = DbContextHelper.GetContext();
IMapper mapper = AutoMapperHelper.GetMappings();
Guid workflowId = Guid.NewGuid();
await unitOfWork.WorkflowRepository.AddAsync(MockEntityHelper.GetNewWorkflow(workflowId));
await unitOfWork.SaveChangesAsync();
GetWorkflowQuery request = new()
{
Id = workflowId
};
// Act
WorkflowHandler handler = new(unitOfWork, mapper);
WorkflowViewModel response = await handler.Handle(request, CancellationToken.None);
// Assert
Assert.True(response != null);
Assert.True(response.Id != Guid.Empty);
Assert.True(response.DataInclusao.Ticks != 0);
}
public ActionResult Workflow(long?id, int?step)
{
// Default right panel with information
var model = new WorkflowViewModel()
{
ID = id, Details = new InheritanceViewModel()
};
if (id.HasValue)
{
model.Summary.AddTitle("Editing ID {0}", id.Value);
}
else
{
model.Summary.AddTitle("Creating a new record");
}
if (step.HasValue)
{
switch (step.Value)
{
case 1:
// Prepopulate step if we're editing (have an ID), otherwise it will be set wuth an empty Step1ViewModel
model.Details = GetStep1(id);
break;
case 2:
// Prepopulate step if we're editing (have an ID), otherwise it will be set with an empty Step2ViewModel
model.Details = GetStep2(id);
break;
}
}
return(View(model));
}
///--------------------------------------------------------------------------------
/// <summary>This method is used to copy/paste a new item.</summary>
///
/// <param name="copyItem">The item to copy/paste.</param>
/// <param name="savePaste">Flag to determine whether to save the results of the paste.</param>
///--------------------------------------------------------------------------------
public WorkflowViewModel PasteWorkflow(WorkflowViewModel copyItem, bool savePaste = true)
{
Workflow newItem = new Workflow();
newItem.ReverseInstance = new Workflow();
newItem.TransformDataFromObject(copyItem.Workflow, null, false);
newItem.WorkflowID = Guid.NewGuid();
newItem.IsAutoUpdated = false;
newItem.Solution = Solution;
newItem.Solution = Solution;
WorkflowViewModel newView = new WorkflowViewModel(newItem, Solution);
newView.ResetModified(true);
AddWorkflow(newView);
// paste children
foreach (StageViewModel childView in copyItem.Stages)
{
newView.PasteStage(childView, savePaste);
}
if (savePaste == true)
{
Solution.WorkflowList.Add(newItem);
newView.OnUpdated(this, null);
Solution.ResetModified(true);
}
return(newView);
}
public static WorkflowCreationRequest InitialGenericWorkflowDataLoad(WorkflowViewModel workflowModel)
{
var workflowRequest = new WorkflowCreationRequest
{
Parameters = new Dictionary <string, string>(),
AdditionalValidators = new List <string>()
};
workflowRequest.CreateUser = string.IsNullOrEmpty(workflowModel.UserName)
? IDBContext.Current.UserName : workflowModel.UserName;
if (IDBContext.Current.Roles.Any(x => x.Length < 40))
{
workflowRequest.CreateProfile = IDBContext.Current.Roles
.FirstOrDefault(x => x.Length < 40);
}
var additionalValidators = workflowModel.Validators
.Where(a => a.Mandatory == false)
.Select(x => x.Role).ToList();
workflowRequest.EntityId = workflowModel.EntityId;
workflowRequest.EntityType = workflowModel.EntityType;
workflowRequest.OperationNumber = workflowModel.OperationNumber;
workflowRequest.WorkflowType = workflowModel.WorkflowCode;
workflowRequest.ContractNumber = workflowModel.ContractNumber;
workflowRequest.AdditionalValidators = additionalValidators;
return(workflowRequest);
}
public IActionResult Put(Guid id, [FromBody] WorkflowViewModel obj)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != obj.Id)
{
return(BadRequest());
}
try
{
_workflowAppService.Alterar(obj);
}
catch (Exception)
{
if (!ObjExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public static WorkflowCreationRequest LoadWorkflowRequest(WorkflowViewModel workflowModel)
{
var workflowRequest = new WorkflowCreationRequest
{
CreateProfile = "GenericWorkflow",
};
workflowRequest.CreateUser = GetWorkflowCreateUser(workflowModel.UserName);
workflowRequest.CreateProfile = GetWorkflowCreateProfile(workflowRequest.CreateProfile);
workflowRequest.EntityId = workflowModel.EntityId;
workflowRequest.EntityType = workflowModel.EntityType;
workflowRequest.OperationNumber = workflowModel.OperationNumber;
workflowRequest.WorkflowType = workflowModel.WorkflowCode;
workflowRequest.ContractNumber = workflowModel.ContractNumber;
var listAdditionalValidators = workflowModel.Validators.Where(a => a.Mandatory == false).Select(x => new { x.Role });
if (listAdditionalValidators.Any())
{
workflowRequest.AdditionalValidators = new List <string>();
foreach (var validator in listAdditionalValidators)
{
workflowRequest.AdditionalValidators.Add(validator.Role);
}
}
return(workflowRequest);
}
/// <summary>
/// Submit action task approve or reject.
/// </summary>
/// <param name="model">The evaluation task information.</param>
/// <returns></returns>
public ResultViewModel SubmitAction(WorkflowViewModel model)
{
var result = new ResultViewModel();
using (TransactionScope scope = new TransactionScope())
{
var response = _workflow.Action(model);
if (string.IsNullOrEmpty(response))
{
var data = _unitOfWork.GetRepository <Data.Pocos.Evaluation>().GetById(model.DataId);
if (string.Equals(model.Action, ConstantValue.WorkflowActionApprove, StringComparison.OrdinalIgnoreCase))
{
data.Status = ConstantValue.WorkflowStatusApproved;
}
else
{
data.Status = ConstantValue.WorkflowActionReject;
}
_unitOfWork.GetRepository <Data.Pocos.Evaluation>().Update(data);
}
_unitOfWork.Complete(scope);
}
this.SendEmailToCreater(model.DataId);
return(result);
}
public async Task <IActionResult> CreateWorkFlow([FromBody] WorkflowViewModel workflowViewModel)
{
if (ModelState.IsValid)
{
try
{
var workFlow = _mapper.Map <WorkFlowMaster>(workflowViewModel);
var workflowId = await workFlowRepository.CreateNewWorkFlow(workFlow);
if (workflowId > 0)
{
return(Ok(workflowId));
}
else
{
return(NotFound());
}
}
catch (Exception)
{
return(BadRequest());
}
}
return(BadRequest());
}
public async Task <WorkflowViewModel> AddAsync(WorkflowViewModel viewModel)
{
WorkflowViewModel result = _mapper.Map <WorkflowViewModel>(await _unitOfWork.WorkflowRepository.AddAsync(_mapper.Map <Workflow>(viewModel)));
await _unitOfWork.SaveChangesAsync();
return(result);
}
public void Test_OnPost()
{
// Arrange
Guid id = Guid.NewGuid();
WorkflowViewModel workflowMock = new WorkflowViewModel {
};
_workflowAppService.Setup(x => x.Remover(id));
RemoverModel pageModel = new RemoverModel(_workflowAppService.Object)
{
Workflow = new WorkflowViewModel {
Id = id
}
};
PageModelTester <RemoverModel> pageTester = new PageModelTester <RemoverModel>(pageModel);
// Act
pageTester
.Action(x => x.OnPost)
// Assert
.TestRedirectToPage("Listar");
}
public dynamic Workflow()
{
var workflowId = Request.Form["WorkflowId"];
var connId = Request.Form["ConnectionId"];
var currentUser = _userStore.GetUser(this.Context.CurrentUser.UserName);
// get the connection and load the workflow store
ConnectionModel connection = _userStore.GetConnection(connId);
IWorkflowStore store = _workflowStoreFactory.GetWorkflowStore(connection);
// extract the data we need to display the workflow
string json = store.GetWorkflowAsJson(workflowId);
if (json == null)
{
return(this.Response.AsJson(new { Message = "No workflow found matching the supplied workflow and connection (the workflow may have completed)." }, HttpStatusCode.NotFound));
}
UIWorkflow wf = _workflowInfoService.GetWorkflowInfoFromJson(json, connection.WorkflowStoreType);
WorkflowViewModel viewModel = new WorkflowViewModel();
viewModel.WorkflowJson = json;
viewModel.IsSuspended = wf.IsSuspended;
return(this.Response.AsJson(viewModel));
}
public ActionResult New(string tabId, int parentId)
{
var workflow = _workflowService.NewWorkflowProperties(parentId);
var model = WorkflowViewModel.Create(workflow, tabId, parentId, _workflowService);
return(JsonHtml("Properties", model));
}
public ActionResult <WorkflowViewModel> Post([FromBody] WorkflowViewModel obj)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
obj.Id = _workflowAppService.Incluir(obj);
}
catch (Exception)
{
if (ObjExists(obj.Id))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction("GetWorkflow", new { id = obj.Id }, obj));
}
public static void SetBeginState(this WorkflowViewModel workflow, string stateName)
{
workflow.Model.Machine.BeginState = stateName;
foreach (var state in workflow.States)
{
state.SetBegin(state.Name.Equals(stateName));
}
}
public ActionResult Properties(string tabId, int parentId, int id, string successfulActionCode)
{
var workflow = _workflowService.ReadProperties(id);
var model = WorkflowViewModel.Create(workflow, tabId, parentId, _workflowService);
model.SuccesfulActionCode = successfulActionCode;
return(JsonHtml("Properties", model));
}
public async Task <IActionResult> Details(int id)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageWorkflows))
{
return(Unauthorized());
}
var workflow = await _workflowStore.GetAsync(id);
if (workflow == null)
{
return(NotFound());
}
var workflowType = await _workflowTypeStore.GetAsync(workflow.WorkflowTypeId);
var blockingActivities = workflow.BlockingActivities.ToDictionary(x => x.ActivityId);
var workflowContext = await _workflowManager.CreateWorkflowExecutionContextAsync(workflowType, workflow);
var activityContexts = await Task.WhenAll(workflowType.Activities.Select(async x => await _workflowManager.CreateActivityExecutionContextAsync(x, x.Properties)));
var activityDesignShapes = (await Task.WhenAll(activityContexts.Select(async x => await BuildActivityDisplayAsync(x, workflowType.Id, blockingActivities.ContainsKey(x.ActivityRecord.ActivityId), "Design")))).ToList();
var activitiesDataQuery = activityContexts.Select(x => new
{
Id = x.ActivityRecord.ActivityId,
X = x.ActivityRecord.X,
Y = x.ActivityRecord.Y,
Name = x.ActivityRecord.Name,
IsStart = x.ActivityRecord.IsStart,
IsEvent = x.Activity.IsEvent(),
IsBlocking = workflow.BlockingActivities.Any(a => a.ActivityId == x.ActivityRecord.ActivityId),
Outcomes = x.Activity.GetPossibleOutcomes(workflowContext, x).ToArray()
});
var workflowTypeData = new
{
Id = workflowType.Id,
Name = workflowType.Name,
IsEnabled = workflowType.IsEnabled,
Activities = activitiesDataQuery.ToArray(),
Transitions = workflowType.Transitions
};
var jsonSerializerSettings = new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var viewModel = new WorkflowViewModel
{
Workflow = workflow,
WorkflowType = workflowType,
WorkflowTypeJson = JsonConvert.SerializeObject(workflowTypeData, Formatting.None, jsonSerializerSettings),
WorkflowJson = JsonConvert.SerializeObject(workflow, Formatting.Indented, jsonSerializerSettings),
ActivityDesignShapes = activityDesignShapes
};
return(View(viewModel));
}
public async Task <ActionResult> Create(WorkflowViewModel model)
{
try
{
if (ModelState.IsValid)
{
//Call API Provider
string strUrl = APIProvider.APIGenerator(controllerName, APIConstant.ACTION_INSERT);
var result = await APIProvider.Authorize_DynamicTransaction <WorkflowViewModel, bool>(model, _userSession.BearerToken, strUrl, APIConstant.API_Resource_CMS, ARS.Insert);
if (result)
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.TypeResult.SUCCESS, ApplicationGenerator.GeneralActionMessage(APIConstant.ACTION_INSERT, ApplicationGenerator.TypeResult.SUCCESS));
}
else
{
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.TypeResult.FAIL, ApplicationGenerator.GeneralActionMessage(APIConstant.ACTION_INSERT, ApplicationGenerator.TypeResult.FAIL));
}
return(RedirectToAction("Index"));
}
else
{
var workflows = new WorkflowsModel();
if (TempData["Data"] != null)
{
workflows.lstWorkflowViewModel = (List <WorkflowViewModel>)TempData["Data"];
}
else
{
workflows.lstWorkflowViewModel = await APIProvider.Authorize_Get <List <WorkflowViewModel> >(_userSession.BearerToken, controllerName, APIConstant.API_Resource_CMS, ARS.Get);
}
if (workflows.lstWorkflowViewModel == null)
{
workflows.lstWorkflowViewModel = ApplicationGenerator.GetObject <List <WorkflowViewModel> >();
}
workflows.WorkflowViewModel = model;
TempData["Alert"] = ApplicationGenerator.RenderResult(ApplicationGenerator.TypeResult.FAIL, ApplicationGenerator.GeneralActionMessage(APIConstant.ACTION_INSERT, ApplicationGenerator.TypeResult.FAIL));
return(View("Index", workflows));
}
}
catch (HttpException ex)
{
Logger.LogError(ex);
int statusCode = ex.GetHttpCode();
if (statusCode == 401)
{
TempData["Alert"] = ApplicationGenerator.RenderResult(FuntionType.Department, APIConstant.ACTION_ACCESS);
return(new HttpUnauthorizedResult());
}
throw ex;
}
}
private void Model_PropertyChanged(object sender, PropertyChangedEventArgs args)
{
if (args.PropertyName == "DisplayNameWithModifiedIndicator" || args.PropertyName == "DisplayName")
{
WorkflowViewModel model = this.DataContext as WorkflowViewModel;
if (model != null)
{
this.Title = model.DisplayNameWithModifiedIndicator;
}
}
}
private ResponseBase InitialGenericWorkflow(WorkflowViewModel workflowModel)
{
var workflowRequest = WorkflowsHelper.LoadWorkflowRequest(workflowModel);
var responseRequest = _workflowManager.InitiateWorkflow(workflowRequest);
return(new ResponseBase
{
IsValid = responseRequest.IsValid,
ErrorMessage = responseRequest.ErrorMessage
});
}
public async Task <WorkflowViewModel> GetById(byte id)
{
var list = this.RequestContext.RouteData.Values.Keys;
var para = APIProvider.APIGeneratorParameter(list, id);
var source = await _workflow.SingleQuery(para);
WorkflowViewModel dest = Mapper.Map <WorkflowViewModel>(source);
return(dest);
}
public ActionResult <WorkflowViewModel> Get(Guid id)
{
WorkflowViewModel workflow = _workflowAppService.Consultar(id);
if (workflow == null)
{
return(NotFound());
}
return(Ok(workflow));
}
