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");
}
}