public Task SetState(int userId, int taskId, TaskStateEnum stateEnum)
{
return(stateEnum switch
{
TaskStateEnum.Success => _set.FromSqlInterpolated($"EXEC SetUserTaskAsSuccess {userId}, {taskId}").ToListAsync(),
TaskStateEnum.Fail => _set.FromSqlInterpolated($"EXEC SetUserTaskAsFail {taskId}, {taskId}").ToListAsync(),
_ => Task.CompletedTask
});
public FindTasksResult FindTasks(IEnumerable<string> taskTypes, IDictionary<string, string> searchAttributes, TaskStateEnum? taskState)
{
Contract.Requires(Transaction.Current != null);
Contract.Requires(taskTypes != null);
Contract.Ensures(Contract.Result<FindTasksResult>() != null);
return default(FindTasksResult);
}
public FindTasksResult FindTasks(string tasktype, string reference, TaskStateEnum? taskState)
{
Contract.Requires(Transaction.Current != null);
Contract.Requires(!string.IsNullOrEmpty(reference));
Contract.Ensures(Contract.Result<FindTasksResult>() != null);
return default(FindTasksResult);
}
/// <summary>
/// 设置任务状态
/// </summary>
/// <param name="task"></param>
/// <param name="logonUser"></param>
/// <param name="taskState"></param>
/// <param name="session"></param>
private void SetTaskState(TaskEntity task,
WfLogonUser logonUser,
TaskStateEnum taskState,
ISession session)
{
task.TaskState = (short)taskState;
task.LastUpdatedByUserID = logonUser.UserID;
task.LastUpdatedByUserName = logonUser.UserName;
task.LastUpdatedDateTime = System.DateTime.Now;
Update(task, session);
}
/// <summary>
/// 设置任务状态
/// </summary>
/// <param name="task"></param>
/// <param name="logonUser"></param>
/// <param name="taskState"></param>
/// <param name="session"></param>
private void SetTaskState(TaskEntity task,
string userID,
string userName,
TaskStateEnum taskState,
IDbSession session)
{
task.TaskState = (short)taskState;
task.LastUpdatedByUserID = userID;
task.LastUpdatedByUserName = userName;
task.LastUpdatedDateTime = System.DateTime.Now;
Update(task, session);
}
public void ChangeTaskState(TaskStateEnum destinyState)
{
//If a Task has Children then it's state is determined by it's childen's state
if (this.SubTasks.Any())
{
throw new DomainRulesException("A parent Task's state can only be changed by changing it's children's Tasks state");
}
if (this.TaskState != destinyState)
{
this.TaskState = destinyState;
}
}
public static void UpdateSongPacks()
{
if (cancellationTokenSource.Token.CanBeCanceled)
{
cancellationTokenSource.Cancel();
}
cancellationTokenSource = new CancellationTokenSource();
QuickPlaySongPacksDropdown instance = GameClassInstanceProvider.Instance.QuickPlaySongPacksDropdown;
if (instance != null)
{
instance.SetField <QuickPlaySongPacksDropdown, MasterServerQuickPlaySetupData.QuickPlaySongPacksOverride>("_quickPlaySongPacksOverride", null);
}
if (ModStatusProvider.ShouldBlockSongPackOverrides)
{
Plugin.Logger.Info("MultiplayerExtensions not installed, not overriding packs");
return;
}
TaskState = TaskStateEnum.Running;
System.Threading.Tasks.Task.Run(async() =>
{
try
{
Plugin.Logger.Info("Get QuickPlaySongPacksOverride");
var quickPlaySetupData = await GameClassInstanceProvider.Instance.MasterServerQuickPlaySetupModel.GetQuickPlaySetupAsync(cancellationTokenSource.Token);
return(quickPlaySetupData.quickPlayAvailablePacksOverride);
}
catch (Exception)
{
Plugin.Logger.Warn("Could not get QuickPlaySongPacksOverride");
TaskState = TaskStateEnum.Failed;
return(null);
}
}).ContinueWith(r =>
{
Plugin.Logger.Debug("ContinueWith running for quickplaySongPackOverrides");
if (instance != null)
{
instance.SetField("_quickPlaySongPacksOverride", r.Result);
instance.SetField("_initialized", false);
}
if (TaskState == TaskStateEnum.Running)
{
TaskState = TaskStateEnum.Finished;
}
//MultiplayerModeSelectionFlowCoordinatorPatch.ShowQuickPlayLobbyScreenIfWaiting();
//GameClassInstanceProvider.Instance.QuickPlaySongPacksDropdown.LazyInit();
}
);
}
/// <summary>
/// 设置任务完成
/// </summary>
/// <param name="taskID">任务ID</param>
/// <param name="taskState">任务状态</param>
/// <param name="runner">运行者</param>
/// <param name="session">会话</param>
internal void EndTaskState(long taskID,
TaskStateEnum taskState,
WfAppRunner runner,
IDbSession session)
{
TaskEntity task = Repository.GetById <TaskEntity>(session.Connection, taskID, session.Transaction);
task.TaskState = (byte)taskState;
task.EndedDateTime = DateTime.Now;
task.EndedByUserID = runner.UserID;
task.EndedByUserName = runner.UserName;
Update(task, session);
}
public void ChangeSubTaskState(Task taskToChange, TaskStateEnum destinyState)
{
if (taskToChange == null)
{
throw new BusinessLogicException("Please, informe a SubTask to be changed");
}
var subTask = this.SubTasks.FirstOrDefault(st => st.ChildTask.Id == taskToChange.Id)
??
throw new BusinessLogicException("The SubTask does not belong to the current Task");
subTask.ChildTask.ChangeTaskState(destinyState);
//When changing one SubTask's State the Parent Task should be aware of it's own State
this.TaskState = GetWhichStateTheParentTaskShouldBe();
}
/// <summary>
/// Method to update a Task's State
/// </summary>
public TaskDto ChangeTaskState(int id, TaskStateEnum destinyState, bool commit = false)
{
//Find the Task that will be updated or Throw Exception
var taskToUpdate = _taskRepository.SelectById(id)
??
throw new BusinessLogicException("Error while changing Task's state, informed Id didn't return any result");
//If the Task has a Parent
if (taskToUpdate.ParentTaskId.HasValue)
{
//Then find it's Parent or Throw Exception
var parentTask =
_taskRepository.SelectById(taskToUpdate.ParentTaskId.Value)
??
throw new BusinessLogicException("Error while changing Task's state, parent Task not found");
//And change the Child Task's State through the Parent's methods
parentTask.ChangeSubTaskState(taskToUpdate, destinyState);
//Set all the changes to be commited by the Unit of Work
_taskRepository.Update(parentTask);
}
else
{
//If the Task has no Parent then it's responsible for editing it's own State
taskToUpdate.ChangeTaskState(destinyState);
//Set all the changes to be commited by the Unit of Work
_taskRepository.Update(taskToUpdate);
}
if (commit)
{
//Commit the changes done by the Service
_uow.Commit();
}
//Do not return Domain to Application
return(taskToUpdate.MapToDto());
}
public FindTasksResult FindTasks(string tasktype, string reference, TaskStateEnum? taskState)
{
const int MaximumResults = 50;
const string MethodName = "FindTasks";
CheckObjectAlreadyDisposed();
ICollection<Task> result = new HashedSet<Task>();
int numberOfMatchingTasks = -1;
if (s_Logger.IsDebugEnabled)
{
s_Logger.Debug(
string.Format(
"{0}({1},{2},{3})",
MethodName,
tasktype ?? string.Empty,
reference,
taskState.HasValue
? taskState.ToString()
: string.Empty));
}
try
{
ICriteria criteria = BuildFindTasksQuery(tasktype, reference, taskState, MaximumResults);
result = criteria.List<Task>();
if (result.Count < MaximumResults)
{
numberOfMatchingTasks = result.Count;
}
else
{
criteria = BuildCountTasksQuery(tasktype, reference, taskState);
numberOfMatchingTasks = criteria.UniqueResult<int>();
}
}
catch (HibernateException he)
{
// Any hibernate exception is an error
string message = string.Format(
"{0}({1},{2},{3})",
MethodName,
tasktype ?? string.Empty,
reference,
taskState.HasValue ?
taskState.ToString()
: string.Empty);
s_Logger.Fatal(message, he);
StatelessCrudDao.TriageException(he, message);
}
if (s_Logger.IsDebugEnabled)
{
s_Logger.Debug(
string.Format(
"{0}({1},{2},{3}) result {4}",
MethodName,
tasktype ?? string.Empty,
reference,
taskState.HasValue
? taskState.ToString()
: string.Empty, result));
}
ICollection<Task> allowedResult = result
.Where(r => HasSufficientSecurity(r.GetType(), SecurityActionFlag.RETRIEVE))
.ToList();
return new FindTasksResult(allowedResult, numberOfMatchingTasks);
}
private ICriteria BuildCountTasksQuery(string tasktype, string reference, TaskStateEnum? taskState)
{
ICriteria criteria = BuildBaseTasksQuery(tasktype, reference, taskState);
criteria.SetProjection(Projections.RowCount());
return criteria;
}
private ICriteria BuildFindTasksQuery(string tasktype, string reference, TaskStateEnum? taskState, int maximumResults)
{
ICriteria criteria = BuildBaseTasksQuery(tasktype, reference, taskState);
criteria.AddOrder(Order.Asc("CreatedAt"));
criteria.SetMaxResults(maximumResults);
return criteria;
}
private ICriteria BuildBaseTasksQuery(string tasktype, string reference, TaskStateEnum? taskState)
{
if (!reference.EndsWith("%"))
{
reference = string.Concat(reference, "%");
}
if (!(string.IsNullOrEmpty(tasktype) || tasktype.EndsWith("/")))
{
tasktype = string.Concat(tasktype, "/");
}
ICriteria criteria = Session
.CreateCriteria<Task>()
.Add(Restrictions.Like("Reference", reference));
if (!string.IsNullOrEmpty(tasktype))
{
criteria.Add(Restrictions.Eq("TaskType", tasktype));
}
if (taskState.HasValue)
{
int value = (int)taskState.Value;
Junction disjunction = Restrictions.Disjunction();
int state = 1;
while (state <= value)
{
if ((state & value) != 0)
{
disjunction.Add(Restrictions.Eq("State", (TaskStateEnum)state));
}
state <<= 1;
}
criteria.Add(disjunction);
}
return criteria;
}
public FindTasksResult FindTasks(IEnumerable<string> taskTypes, IDictionary<string, string> searchAttributes, TaskStateEnum? taskState)
{
// NOP
return null;
}
/// <inheritdoc cref="ITasksDao.FindTasks"/>
public FindTasksResult FindTasks(string taskType, string reference, TaskStateEnum? taskState)
{
Contract.Requires(!string.IsNullOrEmpty(reference));
Contract.Ensures(Contract.Result<FindTasksResult>() != null);
CheckObjectAlreadyDisposed();
if (WindowsIdentity != null)
{
using (WindowsIdentity.Impersonate())
{
return TasksDao.FindTasks(taskType, reference, taskState);
}
}
return TasksDao.FindTasks(taskType, reference, taskState);
}
public Task SetState(int userId, int taskId, TaskStateEnum stateEnum)
{
return(_repository.SetState(userId, taskId, stateEnum));
}
public FindTasksResult FindTasks(IEnumerable<string> taskTypes, IDictionary<string, string> searchAttributes, TaskStateEnum? taskState)
{
const int MaximumResults = 50;
const string MethodName = "FindTasks";
CheckObjectAlreadyDisposed();
int numberOfMatchingTasks;
if (s_Logger.IsDebugEnabled)
{
s_Logger.DebugFormat(
"{0}({1},{2},{3})",
MethodName,
string.Join(@",", taskTypes.ToArray()),
searchAttributes,
taskState != null
? taskState.ToString()
: string.Empty);
}
// coalesce if nescessary
searchAttributes = searchAttributes ?? new Dictionary<string, string>();
taskTypes = taskTypes ?? Enumerable.Empty<string>();
IList<Task> result;
try
{
IQuery query = BuildFindTasksQuery(taskTypes, searchAttributes, taskState, MaximumResults);
result = query.List<Task>();
if (result.Count < MaximumResults)
{
numberOfMatchingTasks = result.Count;
}
else
{
query = BuildCountTasksQuery(taskTypes, searchAttributes, taskState);
numberOfMatchingTasks = (int)query.UniqueResult<long>();
}
}
catch (HibernateException he)
{
// Any hibernate exception is an error
string message = string.Format(
"{0}({1},{2},{3})",
MethodName,
string.Join(@",", taskTypes.ToArray()),
searchAttributes,
taskState != null
? taskState.ToString()
: string.Empty);
s_Logger.Fatal(message, he);
StatelessCrudDao.TriageException(he, message);
// Line needed to keep resharper happy :)
// triageException should give an exception back instead of throwing it already
throw new Exception();
}
if (s_Logger.IsDebugEnabled)
{
s_Logger.DebugFormat(
"{0}({1},{2},{3}) result {4}",
MethodName,
string.Join(@",", taskTypes.ToArray()),
searchAttributes,
taskState.HasValue
? taskState.ToString()
: string.Empty, result);
}
ICollection<Task> allowedResult = result
.Where(r => HasSufficientSecurity(r.GetType(), SecurityActionFlag.RETRIEVE))
.ToArray();
return new FindTasksResult(allowedResult, numberOfMatchingTasks);
}
private void ThrowExceptionDestinyStateNotFound(TaskStateEnum destinyState) =>
throw new BusinessLogicException($"The informed status ({(int)destinyState}) does not exist");
public FindTasksResult FindTasks(string tasktype, IDictionary<string, string> searchAttributes, TaskStateEnum? taskState)
{
// NOP
return null;
}
public FindTasksResult FindTasks(string tasktype, string reference, TaskStateEnum? taskState)
{
// NOP
return null;
}
private IQuery BuildFindTasksQuery(
IEnumerable<string> taskTypes,
IEnumerable<KeyValuePair<string, string>> searchAttributes,
TaskStateEnum? taskState,
int? maximumResults)
{
Contract.Requires(searchAttributes != null);
Contract.Ensures(Contract.Result<IQuery>() != null);
TaskQuery taskQuery = BuildBaseTasksQuery(taskTypes, searchAttributes, taskState, @"t.CreatedAt asc");
IQuery query = Session.CreateQuery(taskQuery.QueryString);
foreach (KeyValuePair<string, object> parameter in taskQuery.Parameters)
{
query.SetParameter(parameter.Key, parameter.Value);
}
if (maximumResults != null)
{
query.SetMaxResults(maximumResults.Value);
}
return query;
}
private IQuery BuildCountTasksQuery(
IEnumerable<string> taskTypes,
IEnumerable<KeyValuePair<string, string>> searchAttributes,
TaskStateEnum? taskState)
{
Contract.Requires(searchAttributes != null);
Contract.Ensures(Contract.Result<IQuery>() != null);
TaskQuery taskQuery = BuildBaseTasksQuery(taskTypes, searchAttributes, taskState, null);
IQuery query = Session.CreateQuery(@"select count(*) " + taskQuery.QueryString);
foreach (KeyValuePair<string, object> parameter in taskQuery.Parameters)
{
query.SetParameter(parameter.Key, parameter.Value);
}
return query;
}
public FindTasksResult FindTasks(IEnumerable<string> taskTypes, IDictionary<string, string> searchAttributes, TaskStateEnum? taskState)
{
return new FindTasksResult(m_Tasks, 0);
}
/// <summary>
/// 设置任务状态
/// </summary>
/// <param name="task"></param>
/// <param name="logonUser"></param>
/// <param name="taskState"></param>
/// <param name="session"></param>
private void SetTaskState(TaskEntity task,
string userID,
string userName,
TaskStateEnum taskState,
IDbSession session)
{
task.TaskState = (short)taskState;
task.LastUpdatedByUserID = userID;
task.LastUpdatedByUserName = userName;
task.LastUpdatedDateTime = System.DateTime.Now;
Update(task, session);
}
// ReSharper restore MemberCanBePrivate.Global
#endregion
#region Methods
/// <inheritdoc cref="ITasksDao.FindTasks"/>
public FindTasksResult FindTasks(string taskType, string reference, TaskStateEnum? taskState)
{
CheckObjectAlreadyDisposed();
return m_TasksDao.FindTasks(taskType, reference, taskState);
}
public FindTasksResult FindTasks(string tasktype, IDictionary<string, string> searchAttributes, TaskStateEnum? taskState)
{
return new FindTasksResult(m_Tasks, 0);
}
public static bool IsSingleTaskState(TaskStateEnum taskState)
{
int value = (int)taskState;
return((value & (value - 1)) == 0);
}
public static bool IsSingleTaskState(TaskStateEnum taskState)
{
int value = (int)taskState;
return (value & (value - 1)) == 0;
}
private static TaskQuery BuildBaseTasksQuery(
IEnumerable<string> taskTypes,
IEnumerable<KeyValuePair<string, string>> searchAttributes,
TaskStateEnum? taskState,
string optionalOrderbyClause)
{
Contract.Requires(searchAttributes != null);
Contract.Ensures(Contract.Result<TaskQuery>() != null);
// Start with base query
StringBuilder queryString = new StringBuilder(@"from Task t", 2048);
List<string> wherePredicates = new List<string>();
IDictionary<string, object> parameters = new Dictionary<string, object>();
// Handle searchAttributes
{
int i = 0;
foreach (KeyValuePair<string, string> pair in searchAttributes)
{
queryString.AppendFormat(@" join t.Attributes a{0}", i);
wherePredicates.Add(string.Format(@"index(a{0}) = :AttributeName{0} and a{0} = :AttributeValue{0}", i));
parameters.Add(@"AttributeName" + i, pair.Key);
parameters.Add(@"AttributeValue" + i, pair.Value);
i++;
}
}
// Handle taskTypes
{
StringBuilder orTasks = new StringBuilder(512);
int i = 0;
foreach (string taskType in taskTypes.Where(taskType => !string.IsNullOrEmpty(taskType)))
{
orTasks.Append(i == 0 ? "(" : " or ");
orTasks.Append(@"t.TaskType = :TaskType" + i);
parameters.Add(@"TaskType" + i, taskType.EndsWith("/") ? taskType : string.Concat(taskType, "/"));
i++;
}
if (i > 0)
{
orTasks.Append(')');
wherePredicates.Add(orTasks.ToString());
}
}
// Handle taskState
if (taskState != null)
{
int value = (int)taskState.Value;
StringBuilder taskStatePredicate = new StringBuilder(64);
bool firstStatePredicate = true;
int state = 1;
int i = 0;
while (state <= value)
{
if ((state & value) != 0)
{
if (firstStatePredicate)
{
taskStatePredicate.AppendFormat(@"(t.State = :State{0}", i);
firstStatePredicate = false;
}
else
{
taskStatePredicate.AppendFormat(@" or t.State = :State{0}", i);
}
parameters.Add(@"State" + i, (TaskStateEnum)state);
}
state <<= 1;
i++;
}
if (!firstStatePredicate)
{
taskStatePredicate.Append(')');
wherePredicates.Add(taskStatePredicate.ToString());
}
}
// join query with where predicates
bool firstPredicate = true;
foreach (string predicate in wherePredicates)
{
if (firstPredicate)
{
queryString.AppendFormat(@" where {0}", predicate);
firstPredicate = false;
}
else
{
queryString.AppendFormat(@" and {0}", predicate);
}
}
// Append 'order by' clause if specified
if (!string.IsNullOrEmpty(optionalOrderbyClause))
{
queryString.AppendFormat(@" order by {0}", optionalOrderbyClause);
}
return new TaskQuery(queryString.ToString(), parameters);
}
