public ResponseResult <ProductOrderEntity> SyncOrder() { var result = ResponseResult <ProductOrderEntity> .Default(); try { using (var session = SessionFactory.CreateSession()) { try { session.BeginTrans(); var entity = ProductOrderService.SyncOrder(session.Connection, session.Transaction); session.Commit(); result = ResponseResult <ProductOrderEntity> .Success(entity, "同步订单数据成功!"); } catch (System.Exception ex) { session.Rollback(); result = ResponseResult <ProductOrderEntity> .Error( string.Format("同步订单{0}失败, 错误:{1}", "ProductOrder", ex.Message) ); } } } catch (System.Exception ex) { result = ResponseResult <ProductOrderEntity> .Error( string.Format("同步订单{0}失败, 错误:{1}", "ProductOrder", ex.Message) ); } return(result); }
public ScriptRunnerFixture(string fileName = "./build.cake") { Source = "Hello World"; Options = new CakeOptions(); Options.Verbosity = Verbosity.Diagnostic; Options.Script = fileName; Environment = Substitute.For <ICakeEnvironment>(); Environment.WorkingDirectory.Returns("/Working"); FileSystem = new FakeFileSystem(true); FileSystem.GetCreatedFile(Options.Script.MakeAbsolute(Environment), Source); Session = Substitute.For <IScriptSession>(); SessionFactory = Substitute.For <IScriptSessionFactory>(); SessionFactory.CreateSession(Arg.Any <IScriptHost>()).Returns(Session); Arguments = new CakeArguments(); AliasGenerator = Substitute.For <IScriptAliasGenerator>(); Host = Substitute.For <IScriptHost>(); Log = Substitute.For <ICakeLog>(); ScriptProcessor = new ScriptProcessor(FileSystem, Environment, Log); }
/// <summary> /// reset password /// </summary> /// <param name="userID"></param> /// <returns></returns> public string ResetPassword(int userID) { var session = SessionFactory.CreateSession(); session.BeginTrans(); try { var saltText = string.Empty; EnumHashProvider hashProvider; var r = new Random(); var newPassword = r.Next(100000, 999999).ToString(); var encryptedPwd = HashingAlgorithmUtility.GetEncryptedHashText(newPassword, out saltText, out hashProvider); var userEntity = QuickRepository.GetById <UserAccountEntity>(userID); userEntity.Password = encryptedPwd; userEntity.PasswordFormat = (short)hashProvider; userEntity.PasswordSalt = saltText; QuickRepository.Update <UserAccountEntity>(session.Connection, userEntity, session.Transaction); session.Commit(); return(newPassword); } catch (System.Exception ex) { session.Rollback(); throw new ApplicationException("用户密码修改发生错误!"); } finally { session.Dispose(); } }
public ResponseResult StartProcess([FromBody] WfAppRunner runner) { using (var session = SessionFactory.CreateSession()) { var transaction = session.BeginTrans(); var wfService = new WorkflowService(); var result = wfService.StartProcess(session.Connection, runner, session.Transaction); if (result.Status == WfExecutedStatus.Success) { //var nextSteps = wfService.GetNextActivityTree(session.Connection, runner, null, session.Transaction).ToList(); //runner.NextActivityPerformers = new Dictionary<string, PerformerList>(); //var performerList = new PerformerList(); //performerList.Add(new Performer(runner.UserID, runner.UserID)); //runner.NextActivityPerformers.Add(nextSteps[0].ActivityGUID, performerList); //var result2 = wfService.RunProcess(session.Connection, runner, session.Transaction); transaction.Commit(); return(ResponseResult.Success()); } else { transaction.Rollback(); return(ResponseResult.Error(result.Message)); } } }
/// <summary> /// 删除不正常的流程实例(流程在取消状态,才可以进行删除!) /// </summary> /// <param name="processInstanceGUID"></param> /// <returns></returns> internal bool Delete(Guid processInstanceGUID) { bool isDeleted = false; ISession session = SessionFactory.CreateSession(); try { ProcessInstanceEntity entity = ProcessInstanceRepository.GetById <ProcessInstanceEntity>(processInstanceGUID); if (entity.ProcessState == (int)ProcessStateEnum.Canceled) { ProcessInstanceRepository.Delete <ProcessInstanceEntity>(processInstanceGUID, session.Connection, session.Transaction); session.Commit(); isDeleted = true; } else { throw new ProcessInstanceException("流程只有先取消,才可以删除!"); } } catch (System.Exception) { session.Rollback(); throw; } finally { session.Dispose(); } return(isDeleted); }
public async Task Where__When_WhereStringContains__Then_ReturnMatchingResults (string[] props) { await DeleteAll <AllPropertyTypes>(); using (var session = SessionFactory.CreateSession()) { await Task.WhenAll(props .Select((x, i) => session.Create(new AllPropertyTypes { StringProperty = props[i] })) .ToArray()); } using (var session = SessionFactory.CreateSession()) { var expectedProp = props[1]; var results = session.CreateQuery <AllPropertyTypes>() .Where(x => x.StringProperty.Contains(expectedProp)) .ToArray(); Assert.Equal(1, results.Length); Assert.Equal(props[1], results[0].StringProperty); } await DeleteAll <AllPropertyTypes>(); }
public HrsLeaveResult Insert(BizAppFlowEntity bizapp) { IDbSession session = SessionFactory.CreateSession(); try { var result = Repository.Insert <BizAppFlowEntity>(session.Connection, bizapp); if (result > 0) { HrsLeaveResult.ResultIdentity = result; return(HrsLeaveResult.Success); } else { return(HrsLeaveResult.Failed("")); } } catch (System.Exception exception) { return(HrsLeaveResult.Failed(exception.Message)); } finally { session.Dispose(); } }
/// <summary> /// 获取任务视图 /// </summary> /// <param name="runner">当前运行者</param> /// <returns>任务视图</returns> internal TaskViewEntity GetTaskOfMine(WfAppRunner runner) { using (var session = SessionFactory.CreateSession()) { return(GetTaskOfMine(session.Connection, runner, session.Transaction)); } }
/// <summary> /// Get the sub-folders of a particular CMIS folder. /// </summary> /// <returns>Full path of each sub-folder, including leading slash.</returns> static public string[] GetSubfolders(string repositoryId, string path, string address, string user, string password) { List <string> result = new List <string>(); // Connect to the CMIS repository. Dictionary <string, string> cmisParameters = new Dictionary <string, string>(); cmisParameters[SessionParameter.BindingType] = BindingType.AtomPub; cmisParameters[SessionParameter.AtomPubUrl] = address; cmisParameters[SessionParameter.User] = user; cmisParameters[SessionParameter.Password] = password; cmisParameters[SessionParameter.RepositoryId] = repositoryId; SessionFactory factory = SessionFactory.NewInstance(); ISession session = factory.CreateSession(cmisParameters); // Get the folder. IFolder folder = (IFolder)session.GetObjectByPath(path); // Debug the properties count, which allows to check whether a particular CMIS implementation is compliant or not. // For instance, IBM Connections is known to send an illegal count. Logger.Info("CmisUtils | folder.Properties.Count:" + folder.Properties.Count.ToString()); // Get the folder's sub-folders. IItemEnumerable <ICmisObject> children = folder.GetChildren(); // Return the full path of each of the sub-folders. foreach (var subfolder in children.OfType <IFolder>()) { result.Add(subfolder.Path); } return(result.ToArray()); }
/// <summary> /// 获取流程的发起人 /// </summary> /// <param name="processInstanceID">流程实例ID</param> /// <returns>流程发起人</returns> internal User GetProcessInitiator(int processInstanceID) { using (var session = SessionFactory.CreateSession()) { return(GetProcessInitiator(session.Connection, processInstanceID, session.Transaction)); } }
/// <summary> /// 读取任务,设置任务为已读状态 /// </summary> /// <param name="taskRunner">运行者实体</param> internal void SetTaskRead(WfAppRunner taskRunner) { IDbSession session = SessionFactory.CreateSession(); try { session.BeginTrans(); //置任务为处理状态 var task = GetTask(taskRunner.TaskID.Value); SetTaskState(task, taskRunner.UserID, taskRunner.UserName, TaskStateEnum.Reading, session); //置活动为运行状态 (new ActivityInstanceManager()).Read(task.ActivityInstanceID, taskRunner, session); session.Commit(); } catch (System.Exception e) { session.Rollback(); throw new WorkflowException(LocalizeHelper.GetEngineMessage("taskmanager.settaskread.error", e.Message), e); } finally { session.Dispose(); } }
/// <summary> /// 根据流程信息获取任务 /// </summary> /// <param name="processInstanceID">流程实例ID</param> /// <param name="activityInstanceID">活动实例ID</param> /// <returns>任务实体</returns> internal TaskViewEntity GetTaskViewByActivity(int processInstanceID, int activityInstanceID) { string sql = @"SELECT * FROM vwWfActivityInstanceTasks WHERE ActivityInstanceID=@activityInstanceID AND ProcessInstanceID=@processInstanceID "; using (var session = SessionFactory.CreateSession()) { var list = Repository.Query <TaskViewEntity>(session.Connection, sql, new { processInstanceID = processInstanceID, activityInstanceID = activityInstanceID }, session.Transaction).ToList(); if (list != null && list.Count() > 0) { return(list[0]); } return(null); }; }
//----------------------------------------------------------------// //session must be input paramater public async Task ReinitNotificationList() { using (ISession session = SessionFactory.CreateSession()) { await ReinitNotificationList(session); } }
/// <summary> /// 保存表单模板内容 /// </summary> /// <param name="entity"></param> internal void SaveTemplateContent(EntityDefEntity entity) { var session = SessionFactory.CreateSession(); try { session.BeginTrans(); string sql = @"UPDATE EavEntityDef SET TemplateContent=@templateContent WHERE ID=@id"; Repository.Execute(session.Connection, sql, new { id = entity.ID, templateContent = entity.TemplateContent }, session.Transaction); session.Commit(); } catch (System.Exception ex) { session.Rollback(); throw; } finally { session.Dispose(); } }
/// <summary> /// 保存字段同时,更新模板 /// </summary> /// <param name="view"></param> public EntityAttributeEntity SaveAttributeWithTemplate(EntityAttributeView view) { EntityAttributeEntity attrEntity = null; var session = SessionFactory.CreateSession(); try { session.BeginTrans(); //保存字段 var eam = new EntityAttributeManager(); attrEntity = eam.SaveAttribute(session.Connection, view.EntityAttribute, session.Transaction); //保存模板内容 var edm = new EntityDefManager(); edm.SaveTemplateWithHTMLContent(session.Connection, view.EntityDef, session.Transaction); session.Commit(); } catch (System.Exception ex) { session.Rollback(); throw; } finally { session.Dispose(); } return(attrEntity); }
/// <summary> /// 删除流程定义记录 /// </summary> /// <param name="processGUID"></param> public void DeleteProcess(string processGUID, string version) { IDbSession session = SessionFactory.CreateSession(); try { session.BeginTrans(); var processManager = new ProcessManager(); var entity = processManager.GetByVersion(processGUID, version); processManager.Delete(session.Connection, entity, session.Transaction); //delete the xml file var serverPath = ConfigHelper.GetAppSettingString("WorkflowFileServer"); var physicalFileName = string.Format("{0}\\{1}", serverPath, entity.XmlFilePath); File.Delete(physicalFileName); session.Commit(); } catch (System.Exception ex) { session.Rollback(); } finally { session.Dispose(); } }
public async Task Where__When_WhereHasMetaClauses__Then_ReturnMatchingResults (string[] meta, string[] attribute) { await DeleteAll <Widget>(); var now = DateTime.UtcNow; using (var session = SessionFactory.CreateSession()) { await Task.WhenAll(meta .Select((x, i) => session.Create( new Widget { Name = attribute[i], Whatever = meta[i] } )) .ToArray()); } using (var session = SessionFactory.CreateSession()) { var expectedMeta = meta[1]; var expectedAttr = attribute[1]; var results = session.CreateQuery <Widget>() .Where(x => x.Name == expectedAttr && x.Whatever == expectedMeta && x.CreatedAt >= now) .ToArray(); Assert.Equal(1, results.Length); Assert.Equal(attribute[1], results[0].Name); Assert.Equal(meta[1], results[0].Whatever); Assert.NotSame(DateTime.MinValue, results[0].CreatedAt); } await DeleteAll <Widget>(); }
/// <summary> /// 启动流程 /// </summary> /// <param name="conn">连接</param> /// <param name="starter">启动人</param> /// <param name="trans">事务</param> /// <returns>启动结果</returns> public WfExecutedResult StartProcess(IDbConnection conn, WfAppRunner starter, IDbTransaction trans) { try { IDbSession session = SessionFactory.CreateSession(conn, trans); var runtimeInstance = WfRuntimeManagerFactory.CreateRuntimeInstanceStartup(starter, ref _startedResult); if (_startedResult.Status == WfExecutedStatus.Exception) { return(_startedResult); } runtimeInstance.OnWfProcessExecuted += runtimeInstance_OnWfProcessStarted; runtimeInstance.Execute(session); //do something else here... waitHandler.WaitOne(); } catch (System.Exception e) { _startedResult.Status = WfExecutedStatus.Failed; _startedResult.Message = string.Format("流程启动发生错误,内部异常:{0}", e.Message); LogManager.RecordLog(WfDefine.WF_PROCESS_ERROR, LogEventType.Error, LogPriority.High, starter, e); } return(_startedResult); }
public HrsLeaveResult Insert(LeaveEntity leave) { IDbSession session = SessionFactory.CreateSession(); try { leave.CreatedDate = System.DateTime.Now; session.BeginTrans(); dynamic result = Repository.Insert <LeaveEntity>(session.Connection, leave, session.Transaction); session.Commit(); if (result > 0) { HrsLeaveResult.ResultIdentity = result; return(HrsLeaveResult.Success); } else { return(HrsLeaveResult.Failed("")); } } catch (System.Exception exception) { session.Rollback(); return(HrsLeaveResult.Failed(exception.Message)); } finally { session.Dispose(); } }
/// <summary> /// 运行流程 /// </summary> /// <param name="conn">连接</param> /// <param name="runner">运行人</param> /// <param name="trans">事务</param> /// <returns>运行结果</returns> public WfExecutedResult RunProcessApp(IDbConnection conn, WfAppRunner runner, IDbTransaction trans) { try { IDbSession session = SessionFactory.CreateSession(conn, trans); var runtimeInstance = WfRuntimeManagerFactory.CreateRuntimeInstanceAppRunning(runner, ref _runAppResult); if (_runAppResult.Status == WfExecutedStatus.Exception) { return(_runAppResult); } runtimeInstance.OnWfProcessExecuted += runtimeInstance_OnWfProcessContinued; bool isRunning = runtimeInstance.Execute(session); waitHandler.WaitOne(); return(_runAppResult); } catch (System.Exception e) { _runAppResult.Status = WfExecutedStatus.Failed; var error = e.InnerException != null ? e.InnerException.Message : e.Message; _runAppResult.Message = string.Format("流程运行时发生异常!,详细错误:{0}", error); LogManager.RecordLog(WfDefine.WF_PROCESS_ERROR, LogEventType.Error, LogPriority.High, runner, e); } return(_runAppResult); }
/// <summary> /// 根据appinstanceid 获取请假信息数据 /// </summary> /// <param name="appinstanceId">请假单主键</param> /// <returns></returns> public async Task <LeaveEntity> FindByIdAsync(int appinstanceId) { IDbSession session = SessionFactory.CreateSession(); string sql = @"SELECT dbo.HrsLeave.ID,CASE dbo.HrsLeave.LeaveType WHEN 1 THEN '病假' WHEN 2 THEN '事假' WHEN 3 THEN '丧假' WHEN 4 THEN '产假' WHEN 5 THEN '工伤假' WHEN 6 THEN '婚假' WHEN 7 THEN '年休假' ELSE '其他假' end AS LeaveType ,[Days], FromDate,ToDate,CreatedDate, dbo.AspNetUsers.RealName as CreatedUserName, DepManagerRemark,DeputyGeneralRemark,DirectorRemark,GeneralManagerRemark FROM dbo.HrsLeave INNER JOIN dbo.AspNetUsers ON dbo.HrsLeave.CreatedUserID=dbo.AspNetUsers.Id WHERE dbo.HrsLeave.id=@appinstanceId "; try { return(await Repository.Query(session.Connection, sql, new { appinstanceId = appinstanceId }, trans : session.Transaction).FirstOrDefault()); } finally{ session.Dispose(); } }
/// <summary> /// 流程跳转 /// </summary> /// <param name="conn">连接</param> /// <param name="runner">执行操作人</param> /// <param name="trans">事务</param> /// <returns>跳转结果</returns> public WfExecutedResult JumpProcess(IDbConnection conn, WfAppRunner runner, IDbTransaction trans) { try { IDbSession session = SessionFactory.CreateSession(conn, trans); var runtimeInstance = WfRuntimeManagerFactory.CreateRuntimeInstanceJump(runner, ref _jumpResult); if (_jumpResult.Status == WfExecutedStatus.Exception) { return(_jumpResult); } runtimeInstance.OnWfProcessExecuted += runtimeInstance_OnWfProcessJump; bool isJumping = runtimeInstance.Execute(session); waitHandler.WaitOne(); return(_jumpResult); } catch (System.Exception e) { _jumpResult.ExceptionType = WfExceptionType.Jump_OtherError; _jumpResult.Message = string.Format("流程跳转时发生异常!,详细错误:{0}", e.Message); LogManager.RecordLog(WfDefine.WF_PROCESS_ERROR, LogEventType.Error, LogPriority.High, runner, e); } return(_jumpResult); }
/// <summary> /// 流程的取消操作 /// </summary> /// <returns>是否成功</returns> internal bool Cancel(string appName, int appInstanceID, Guid processGUID, int userID, string userName) { var isCanceled = false; var entities = GetProcessInstance(appName, appInstanceID, processGUID, ProcessStateEnum.Running).ToList(); if (entities == null || entities.Count == 0 || entities.Count > 1) { throw new WorkflowException("无法取消流程,错误原因:当前没有运行中的流程实例,或者同时有多个运行中的流程实例(不合法数据)!"); } try { ISession session = SessionFactory.CreateSession(); var entity = entities[0]; entity.ProcessState = (short)ProcessStateEnum.Canceled; entity.RecordStatusInvalid = 1; entity.LastUpdatedByUserID = userID; entity.LastUpdatedByUserName = userName; entity.LastUpdatedDateTime = System.DateTime.Now; Update(entity, session); isCanceled = true; } catch (System.Exception e) { throw new WorkflowException(string.Format("取消流程实例失败,错误原因:{0}", e.Message)); } return(isCanceled); }
/// <summary> /// 撤销流程 /// </summary> /// <param name="conn">连接</param> /// <param name="withdrawer">撤销人</param> /// <param name="trans">事务</param> /// <returns>撤销结果</returns> public WfExecutedResult WithdrawProcess(IDbConnection conn, WfAppRunner withdrawer, IDbTransaction trans) { try { IDbSession session = SessionFactory.CreateSession(conn, trans); var runtimeInstance = WfRuntimeManagerFactory.CreateRuntimeInstanceWithdraw(withdrawer, ref _withdrawedResult); //不满足撤销操作,返回异常结果信息 if (_withdrawedResult.Status == WfExecutedStatus.Exception) { return(_withdrawedResult); } runtimeInstance.OnWfProcessExecuted += runtimeInstance_OnWfProcessWithdrawed; bool isWithdrawed = runtimeInstance.Execute(session); waitHandler.WaitOne(); return(_withdrawedResult); } catch (System.Exception e) { _withdrawedResult.Status = WfExecutedStatus.Failed; _withdrawedResult.Message = string.Format("流程撤销发生异常!,详细错误:{0}", e.Message); LogManager.RecordLog(WfDefine.WF_PROCESS_ERROR, LogEventType.Error, LogPriority.High, withdrawer, e); } return(_withdrawedResult); }
/// <summary> /// 创建流程模型实例 /// </summary> /// <param name="processGUID">流程GUID</param> /// <param name="version">版本</param> /// <returns>流程模型</returns> public static IProcessModel Create(string processGUID, string version) { using (var session = SessionFactory.CreateSession()) { return(Create(session.Connection, processGUID, version, session.Transaction)); } }
/// <summary> /// 读取任务,设置任务为已读状态 /// </summary> /// <param name="taskRunner">运行者实体</param> internal void SetTaskRead(WfAppRunner taskRunner) { IDbSession session = SessionFactory.CreateSession(); try { session.BeginTrans(); //置任务为处理状态 var task = GetTask(taskRunner.TaskID.Value); SetTaskState(task, taskRunner.UserID, taskRunner.UserName, TaskStateEnum.Handling, session); //置活动为运行状态 (new ActivityInstanceManager()).SetActivityRead(task.ActivityInstanceID, taskRunner, session); session.Commit(); } catch (System.Exception e) { session.Rollback(); throw new WorkflowException(string.Format("阅读待办任务时出错!,详细错误:{0}", e.Message), e); } finally { session.Dispose(); } }
/// <summary> /// 根据角色获取用户列表 /// </summary> /// <param name="roleIDs">多个角色ID</param> /// <returns>用户列表</returns> internal List <User> GetUserListByRoles(string[] idsin) { using (var session = SessionFactory.CreateSession()) { return(GetUserListByRoles(idsin, session)); } }
/// <summary> /// 保存属性 /// </summary> /// <param name="entity"></param> public EntityAttributeEntity SaveAttribute(EntityAttributeEntity entity) { EntityAttributeEntity attrEntity = null; var session = SessionFactory.CreateSession(); try { session.BeginTrans(); //保存字段 var eam = new EntityAttributeManager(); attrEntity = eam.SaveAttribute(session.Connection, entity, session.Transaction); session.Commit(); } catch (System.Exception ex) { session.Rollback(); throw; } finally { session.Dispose(); } return(attrEntity); }
/// <summary> /// 流程返签 /// </summary> /// <param name="conn">连接</param> /// <param name="ender">结束人</param> /// <param name="trans">事务</param> /// <returns>返签结果</returns> public WfExecutedResult ReverseProcess(IDbConnection conn, WfAppRunner ender, IDbTransaction trans) { try { IDbSession session = SessionFactory.CreateSession(conn, trans); var runtimeInstance = WfRuntimeManagerFactory.CreateRuntimeInstanceReverse(ender, ref _reversedResult); if (_reversedResult.Status == WfExecutedStatus.Exception) { return(_reversedResult); } runtimeInstance.OnWfProcessExecuted += runtimeInstance_OnWfProcessReversed; bool isReversed = runtimeInstance.Execute(session); waitHandler.WaitOne(); //return _wfExecutedResult; return(_reversedResult); } catch (System.Exception e) { _reversedResult.Status = WfExecutedStatus.Failed; _reversedResult.Message = string.Format("流程返签发生异常!,详细错误:{0}", e.Message); LogManager.RecordLog(WfDefine.WF_PROCESS_ERROR, LogEventType.Error, LogPriority.High, ender, e); } return(_reversedResult); }
public void SessionShufflesQuestions() { ISession session; var parameters = new SessionParameters() { Mode = QuestionsGenerationMode.RandomTicket, Shuffle = true }; Stopwatch sw = new Stopwatch(); var maxExecutionTime = 10; sw.Start(); bool shuffled = false; while (sw.Elapsed.TotalSeconds < maxExecutionTime) { var creationResult = SessionFactory.CreateSession(parameters, out session); Assert.IsNotNull(session); Assert.AreEqual(ParametersValidationResult.Valid, creationResult); var questions = session.Tickets.Single().Questions; if (!questions.OrderBy(question => question.Number).SequenceEqual(questions)) { shuffled = true; break; } } sw.Stop(); if (!shuffled) { Assert.Fail("Questions wasn't shuffled"); } }