public ActionResult ReturnTo(WorkFlowFormViewModel formData)
{
if (formData.Description == null)
{
string errorMessage = "Please enter your cancellation reason.";
ModelState.AddModelError("ProcessForm.Description", errorMessage);
UserProcessViewModel kullaniciIslemVM = _workFlowProcessService.GetUserProcessVM(formData.Id);
var workFlowBase = _workFlowProcessService.WorkFlowBaseInfo(kullaniciIslemVM);
_workFlowProcessService.SetWorkFlowTraceForm(formData, workFlowBase);
return(View(formData.ProcessTaskSpecialFormTemplateView, formData).WithMessage(this, "Error occured!", MessageType.Warning));
}
WorkFlowTrace islem = Mapper.Map <WorkFlowFormViewModel, WorkFlowTrace>(formData);
_workFlowProcessService.AddOrUpdate(islem);
var workFlowTraceId = formData.Id;
_workFlowProcessService.CancelWorkFlowTrace(workFlowTraceId, formData.TargetProcessId);
var surecKontrolSonuc = _workFlowProcessService.SetNextProcessForWorkFlow(workFlowTraceId);
return(RedirectToAction("Index", surecKontrolSonuc).WithMessage(this, "Previous step started.", MessageType.Success));
}
public override void WorkFlowFormSave <TClass, TVM>(WorkFlowFormViewModel workFlowFormViewModel)
{
base.WorkFlowFormSave <TClass, TVM>(workFlowFormViewModel);
WorkFlowTrace torSatinAlmaIslem = Mapper.Map <WorkFlowFormViewModel, WorkFlowTrace>(workFlowFormViewModel);
AddOrUpdate(torSatinAlmaIslem);
}
public virtual WorkFlowTrace WorkFlowTraceDetail(int workFlowTraceId)
{
WorkFlowTrace WorkFlowTrace = _unitOfWork.Repository <WorkFlowTrace>()
.Get(
x => x.Id == workFlowTraceId,
x => x.Process,
x => x.Process.DocumentList,
x => x.Process.FormView,
x => x.DocumentList,
x => x.Process.Task
);
if (WorkFlowTrace.Process.GetType() == typeof(Condition))
{
((Condition)WorkFlowTrace.Process).OptionList = _unitOfWork.Repository <ConditionOption>().GetList(x => x.ConditionId == WorkFlowTrace.ProcessId).ToList();
}
if (WorkFlowTrace.Process.GetType() == typeof(SubProcess))
{
WorkFlowTrace.SubProcessList = _unitOfWork.Repository <BusinessProcess>().GetList(x => x.OwnerSubProcessTraceId == workFlowTraceId).ToList();
}
return(WorkFlowTrace);
}
public ActionResult Index(int workFlowTraceId)
{
UserProcessViewModel userProcessVM = _workFlowProcessService.GetUserProcessVM(workFlowTraceId);
if (_workFlowProcessService.WorkFlowPermissionCheck(userProcessVM) == false)
{
return(RedirectToAction("Index", new { controller = "Home" }).WithMessage(this, "Access denied!", MessageType.Danger));
}
WorkFlowTrace workFlowTrace = _workFlowProcessService.WorkFlowTraceDetail(workFlowTraceId);
WorkFlowFormViewModel workFlowTraceForm = Mapper.Map <WorkFlowTrace, WorkFlowFormViewModel>(workFlowTrace);
int ownerId = workFlowTraceForm.OwnerId;
ActionResult viewResult = null;
WorkFlowFormViewModel workFlowForm = null;
var workFlowBase = _workFlowProcessService.WorkFlowBaseInfo(userProcessVM);
_workFlowProcessService.SetWorkFlowTraceForm(workFlowTraceForm, workFlowBase);
workFlowForm = _workFlowProcessService.WorkFlowFormLoad(workFlowTraceForm);
viewResult = View(workFlowForm.ProcessTaskSpecialFormTemplateView, workFlowForm);
return(viewResult);
}
public ActionResult SaveAsDraft(WorkFlowFormViewModel formData)
{
if (ModelState.IsValid)
{
if (formData.ProcessFormViewCompleted && formData.GetType() != typeof(WorkFlowFormViewModel))
{
_workFlowProcessService.CustomFormSave(formData);
}
else
{
WorkFlowTrace torSatinAlmaIslem = Mapper.Map <WorkFlowFormViewModel, WorkFlowTrace>(formData);
_workFlowProcessService.AddOrUpdate(torSatinAlmaIslem);
}
UserProcessViewModel kullaniciIslemVM = _workFlowProcessService.GetUserProcessVM(formData.Id);
var workFlowBase = _workFlowProcessService.WorkFlowBaseInfo(kullaniciIslemVM);
_workFlowProcessService.SetWorkFlowTraceForm(formData, workFlowBase);
return(View(formData.ProcessTaskSpecialFormTemplateView, formData).WithMessage(this, string.Format("{0} saved successfully.", formData.ProcessName), MessageType.Success));
}
else
{
UserProcessViewModel kullaniciIslemVM = _workFlowProcessService.GetUserProcessVM(formData.Id);
var workFlowBase = _workFlowProcessService.WorkFlowBaseInfo(kullaniciIslemVM);
_workFlowProcessService.SetWorkFlowTraceForm(formData, workFlowBase);
return(View(formData.ProcessTaskSpecialFormTemplateView, formData).WithMessage(this, string.Format("Validation error!"), MessageType.Danger));
}
}
public object SetNextProcessForWorkFlow(int WorkFlowTraceId)
{
WorkFlowTrace WorkFlowTrace = WorkFlowTraceDetail(WorkFlowTraceId);
int workFlowTraceProcessId = WorkFlowTrace.ProcessId;
Process process = _unitOfWork.Repository <Process>().Get(workFlowTraceProcessId);
var workFlowProcessList = WorkFlowTraceList(WorkFlowTrace.OwnerId);
UserProcessViewModel lastWorkFlowTrace = workFlowProcessList.OrderByDescending(x => x.Id).First();
int lastWorkFlowTraceProcessId = lastWorkFlowTrace.ProcessId;
bool nextProcessIsSuitable = false;
if (process.Id != lastWorkFlowTraceProcessId)
{
nextProcessIsSuitable = true;
}
object routeObject = null;
if (nextProcessIsSuitable)
{
routeObject = new { workFlowTraceId = lastWorkFlowTrace.Id };
}
else
{
routeObject = new { controller = "Home" };
}
return(routeObject);
}
public string DecisionPointJobCallBase(string id, string jobId, string hourInterval)
{
WorkFlowTrace torSatinAlmaWorkFlowTrace = _unitOfWork.Repository <WorkFlowTrace>().Get(int.Parse(id));
torSatinAlmaWorkFlowTrace.JobId = jobId;
_unitOfWork.Repository <WorkFlowTrace>().Update(torSatinAlmaWorkFlowTrace);
_unitOfWork.Complete();
return("OK");
}
public virtual void CancelWorkFlowTrace(int workFlowTraceId, int targetProcessId)
{
WorkFlowTrace WorkFlowTrace = _unitOfWork.Repository <WorkFlowTrace>().Get(workFlowTraceId);
WorkFlowTrace.ProcessStatus = ProcessStatus.Cancelled;
AddOrUpdate(WorkFlowTrace);
CreateWorkFlowTrace(targetProcessId, WorkFlowTrace.OwnerId);
}
public int StartWorkFlow(int ownerId, Task task)
{
WorkFlowTrace workFlowTrace = null;
workFlowTrace = new WorkFlowTrace()
{
ProcessId = (int)task.StartingProcessId,
OwnerId = ownerId,
ProcessStatus = Common.Enums.ProcessStatus.Draft
};
AddOrUpdate(workFlowTrace);
return(workFlowTrace.Id);
}
public ActionResult SaveAndSend(WorkFlowFormViewModel formData)
{
if (ModelState.IsValid)
{
bool fullFormValidate = _workFlowProcessService.FullFormValidate(formData, ModelState);
if (!fullFormValidate)
{
UserProcessViewModel userProcessVM = _workFlowProcessService.GetUserProcessVM(formData.Id);
var workFlowBase = _workFlowProcessService.WorkFlowBaseInfo(userProcessVM);
_workFlowProcessService.SetWorkFlowTraceForm(formData, workFlowBase);
return(View(formData.ProcessTaskSpecialFormTemplateView, formData).WithMessage(this, "Validation error!", MessageType.Warning));
}
WorkFlowTrace workFlowTrace = Mapper.Map <WorkFlowFormViewModel, WorkFlowTrace>(formData);
if (formData.ProcessFormViewCompleted)
{
if (formData.GetType() != typeof(WorkFlowFormViewModel))
{
_workFlowProcessService.CustomFormSave(formData);
}
else
{
_workFlowProcessService.AddOrUpdate(workFlowTrace);
}
}
else
{
_workFlowProcessService.AddOrUpdate(workFlowTrace);
}
_workFlowProcessService.GoToWorkFlowNextProcess(workFlowTrace.OwnerId);
var targetProcess = _workFlowProcessService.SetNextProcessForWorkFlow(workFlowTrace.Id);
return(RedirectToAction("Index", targetProcess).WithMessage(this, "Saved Successfully.", MessageType.Success));
}
else
{
UserProcessViewModel userProcessVM = _workFlowProcessService.GetUserProcessVM(formData.Id);
var workFlowBase = _workFlowProcessService.WorkFlowBaseInfo(userProcessVM);
_workFlowProcessService.SetWorkFlowTraceForm(formData, workFlowBase);
return(View(formData.ProcessTaskSpecialFormTemplateView, formData).WithMessage(this, string.Format("Validation error!"), MessageType.Danger));
}
}
private void CreateNewWorkFlowTrace(Process targetProcess, int ownerId)
{
WorkFlowTrace workFlowTrace = new WorkFlowTrace()
{
ProcessId = targetProcess.Id,
OwnerId = ownerId,
ProcessStatus = ProcessStatus.Draft
};
AddOrUpdate(workFlowTrace);
if (targetProcess is DecisionPoint)
{
DecisionPointTakeTheNextStep(workFlowTrace.Id);
}
else if (targetProcess is SubProcess)
{
//Sub process will be start
var taskVariableList = JsonConvert.DeserializeObject <List <TaskVariable> >(((SubProcess)targetProcess).TaskVariableList);
foreach (var taskVariable in taskVariableList)
{
var numberOfSubProcessCount = 0;
var numberOfSubProcessCountString = GetVariable(taskVariable.VariableName, ownerId);
if (numberOfSubProcessCountString == null)
{
numberOfSubProcessCount = 1;
}
else
{
numberOfSubProcessCount = int.Parse(numberOfSubProcessCountString);
}
var task = _unitOfWork.Repository <Task>().Get(taskVariable.TaskId);
var subBusinessProcess = new BusinessProcess()
{
OwnerId = ownerId, Name = task.Name, OwnerSubProcessTraceId = workFlowTrace.Id
};
_unitOfWork.Repository <BusinessProcess>().Add(subBusinessProcess);
_unitOfWork.Complete();
StartWorkFlow(subBusinessProcess.Id, task);
}
}
}
public virtual void AddOrUpdate(WorkFlowTrace workFlowTrace)
{
WorkFlowTrace workFlowTraceDB = null;
if (workFlowTrace.Id == 0)
{
workFlowTraceDB = Mapper.Map <WorkFlowTrace, WorkFlowTrace>(workFlowTrace);
_unitOfWork.Repository <WorkFlowTrace>().Add(workFlowTraceDB);
}
else
{
workFlowTraceDB = _unitOfWork.Repository <WorkFlowTrace>().Get(workFlowTrace.Id);
Mapper.Map(workFlowTrace, workFlowTraceDB);
_unitOfWork.Repository <WorkFlowTrace>().Update(workFlowTraceDB);
}
_unitOfWork.Complete();
workFlowTrace.Id = workFlowTraceDB.Id;
}
public virtual void WorkFlowProcessCancel(int workFlowTraceId)
{
WorkFlowTrace workFlowTrace = WorkFlowTraceDetail(workFlowTraceId);
if (workFlowTrace.Process.GetType() == typeof(DecisionPoint))
{
DecisionPoint decisionPoint = (DecisionPoint)workFlowTrace.Process;
if (decisionPoint.CancelProcessId != null)
{
int cancelProcessId = (int)decisionPoint.CancelProcessId;
if (workFlowTrace.JobId != null)
{
RecurringJob.RemoveIfExists(workFlowTrace.JobId);
}
_unitOfWork.Repository <WorkFlowTrace>().Remove(workFlowTraceId);
CreateWorkFlowTrace(cancelProcessId, workFlowTrace.OwnerId);
}
}
}
public void DecisionPointTakeTheNextStep(int workFlowTraceId)
{
WorkFlowTrace workFlowTraceDecisionPoint = _unitOfWork.Repository <WorkFlowTrace>().Get(workFlowTraceId);
DecisionPoint decisionPoint = _unitOfWork.Repository <DecisionPoint>().Get(x => x.Id == workFlowTraceDecisionPoint.ProcessId, x => x.DecisionMethod, x => x.Task);
if (!string.IsNullOrEmpty(decisionPoint.DecisionMethod.MethodFunction))
{
string serviceName = decisionPoint.Task.MethodServiceName;
string methodName = string.Format("{0}.{1}", serviceName, decisionPoint.DecisionMethod.MethodFunction.Substring(0, decisionPoint.DecisionMethod.MethodFunction.LastIndexOf("(")));
var parameters = decisionPoint.DecisionMethod.MethodFunction.Substring(
decisionPoint.DecisionMethod.MethodFunction.LastIndexOf("(") + 1,
(decisionPoint.DecisionMethod.MethodFunction.LastIndexOf(")") - decisionPoint.DecisionMethod.MethodFunction.LastIndexOf("(") - 1))
.Split(',')
.Select(p => p.Trim())
.ToList();
List <object> parametersValue = new List <object>();
foreach (var parameter in parameters)
{
if (!string.IsNullOrWhiteSpace(parameter))
{
var property = workFlowTraceDecisionPoint.GetType().GetProperties().Where(x => x.Name == parameter).FirstOrDefault();
if (property != null)
{
var value = property.GetValue(workFlowTraceDecisionPoint, null);
parametersValue.Add(value);
}
else
{
parametersValue.Add(parameter);
}
}
}
var parametersArray = parametersValue.ToArray();
var methodCallString = string.Format("{0}({1})", methodName, string.Join(",", parametersArray));
var decisionMethodResult =
DynamicMethodCallService.Caller(
_unitOfWork,
methodCallString,
_workFlowDataService);
Process conditionOption = _unitOfWork.Repository <ConditionOption>().Get(x => x.ConditionId == decisionPoint.Id && x.Value == decisionMethodResult);
if (conditionOption.NextProcessId == decisionPoint.Id)
{
if (workFlowTraceDecisionPoint.JobId == null)
{
List <object> decisionPointJobCallParameterList = new List <object>();
string jobId = Guid.NewGuid().ToString();
decisionPointJobCallParameterList.Add(workFlowTraceId);
decisionPointJobCallParameterList.Add(jobId);
decisionPointJobCallParameterList.Add(decisionPoint.RepetitionFrequenceByHour);
var methodJobCallString = string.Format("{0}.DecisionPointJobCall({1})", serviceName, string.Join(",", decisionPointJobCallParameterList.ToArray()));
DynamicMethodCallService.Caller(
_unitOfWork,
methodJobCallString,
_workFlowDataService);
}
}
else
{
workFlowTraceDecisionPoint.ConditionOptionId = conditionOption.Id;
AddOrUpdate(workFlowTraceDecisionPoint);
if (workFlowTraceDecisionPoint.JobId != null)
{
RecurringJob.RemoveIfExists(workFlowTraceDecisionPoint.JobId);
}
GoToWorkFlowNextProcess(workFlowTraceDecisionPoint.OwnerId);
}
}
}
public virtual void GoToWorkFlowNextProcess(int ownerId)
{
var WorkFlowTraceList = this.WorkFlowTraceList(ownerId);
UserProcessViewModel userProcessVMCurrent = WorkFlowTraceList.OrderByDescending(x => x.Id).First();
int currentUserProcessVMProcessId = userProcessVMCurrent.ProcessId;
if (userProcessVMCurrent.ConditionOptionId != null)
{
currentUserProcessVMProcessId = (int)userProcessVMCurrent.ConditionOptionId;
}
WorkFlowTrace workFlowTraceCurrentDB = _unitOfWork.Repository <WorkFlowTrace>().Get(userProcessVMCurrent.Id);
workFlowTraceCurrentDB.ProcessStatus = Common.Enums.ProcessStatus.Completed;
AddOrUpdate(workFlowTraceCurrentDB);
Process currentProcess = _unitOfWork.Repository <Process>().Get(x => x.Id == currentUserProcessVMProcessId, x => x.NextProcess);
if (currentProcess.GetType() == typeof(ConditionOption))
{
var key = userProcessVMCurrent.ProcessVariableName;
if (key != null)
{
var value = ((ConditionOption)currentProcess).Value;
SetVariable(key, value, ownerId);
}
}
if (currentProcess.NextProcessId != null)
{
CreateNewWorkFlowTrace(currentProcess.NextProcess, ownerId);
}
else
{
//If process is last node of the work flow
//And business process is a sub flow
//We will check all sub flows (except current)
var businessProcess = _unitOfWork.Repository <BusinessProcess>().Get(ownerId);
if (businessProcess.OwnerSubProcessTraceId != null)
{
var allSubFlowsExceptCurrent = _unitOfWork.Repository <BusinessProcess>().GetAll().Where(x => x.OwnerSubProcessTraceId == businessProcess.OwnerSubProcessTraceId && x.Id != ownerId);
bool allSubProcessCompleted = true;
foreach (var subFlow in allSubFlowsExceptCurrent)
{
var draftProcess = _unitOfWork.Repository <WorkFlowTrace>().GetAll().FirstOrDefault(x => x.OwnerId == subFlow.Id && x.ProcessStatus == ProcessStatus.Draft);
allSubProcessCompleted = draftProcess == null;
if (!allSubProcessCompleted)
{
break;
}
}
if (allSubProcessCompleted)
{
GoToWorkFlowNextProcess((int)businessProcess.OwnerId);
}
}
}
}
