/// <summary>
/// Returns transition type if combination of
/// status of current and previous revision represents one.
/// </summary>
/// <remarks>
/// State groups:
/// ----------------------------------------------------
/// DontExist :
/// ForAnalysis : open, reopen
/// Postponed : analysed, suspend
/// ForWork : to_be_assigned, assigned, active
/// ForTesting : invalid, duplicate, works_for_me, fixed,
/// modelling, regression, test_cases
/// Finished : verified, closed, deleted
///
/// Allowed transitions:
/// ------------------------------------------------------------------
/// +) Added : (DontExist, ForTesting, Finished)->(ForAnalysis)
/// +) Removed : (ForAnalysis, ForWork, Postponed)->(ForTesting)
/// +) Postponed : (ForAnalysis, ForWork)->(Postponed)
/// +) Reactivated : (Postponed)->(ForAnalysis, ForWork)
///
/// It also catches disallowed transitions:
/// +) (ForAnalysis, Postponed, ForWork)->(Finished)
/// +) (Finished)->(ForAnalysis, Postponed, ForWork)
/// </remarks>
private static StatusTransition GetStatusTransition(Revision prevRevision,
Revision curRevision)
{
Debug.Assert(curRevision != null);
StatusGroup statusGroupPrev = GetStateGroup(prevRevision);
StatusGroup statusGroupCur = GetStateGroup(curRevision);
IDictionary <StatusGroup[], StatusTransition> allowed =
new Dictionary <StatusGroup[], StatusTransition>(new StateGroupMappingComparer());
// +) Added : (DontExist, ForTesting, Finished)->(ForAnalysis)
allowed.Add(new[] { StatusGroup.DontExist, StatusGroup.ForAnalysis }, StatusTransition.Added);
allowed.Add(new[] { StatusGroup.ForTesting, StatusGroup.ForAnalysis }, StatusTransition.Added);
allowed.Add(new[] { StatusGroup.Finished, StatusGroup.ForAnalysis }, StatusTransition.Added);
// +) Removed : (ForAnalysis, ForWork, Postponed)->(ForTesting)
allowed.Add(new[] { StatusGroup.ForAnalysis, StatusGroup.ForTesting }, StatusTransition.Removed);
allowed.Add(new[] { StatusGroup.ForWork, StatusGroup.ForTesting }, StatusTransition.Removed);
allowed.Add(new[] { StatusGroup.Postponed, StatusGroup.ForTesting }, StatusTransition.Removed);
// +) Postponed : (ForAnalysis, ForWork)->(Postponed)
allowed.Add(new[] { StatusGroup.ForAnalysis, StatusGroup.Postponed }, StatusTransition.Postponed);
allowed.Add(new[] { StatusGroup.ForWork, StatusGroup.Postponed }, StatusTransition.Postponed);
// +) Reactivated : (Postponed)->(ForAnalysis, ForWork)
allowed.Add(new[] { StatusGroup.Postponed, StatusGroup.ForAnalysis }, StatusTransition.Reactivated);
allowed.Add(new[] { StatusGroup.Postponed, StatusGroup.ForWork }, StatusTransition.Reactivated);
IDictionary <StatusGroup[], StatusTransition> forbidden =
new Dictionary <StatusGroup[], StatusTransition>(new StateGroupMappingComparer());
// +) (ForAnalysis, Postponed, ForWork)->(Finished)
forbidden.Add(new[] { StatusGroup.ForAnalysis, StatusGroup.Finished }, StatusTransition.None);
forbidden.Add(new[] { StatusGroup.Postponed, StatusGroup.Finished }, StatusTransition.None);
forbidden.Add(new[] { StatusGroup.ForWork, StatusGroup.Finished }, StatusTransition.None);
// +) (Finished)->(ForAnalysis, Postponed, ForWork)
forbidden.Add(new[] { StatusGroup.Finished, StatusGroup.ForAnalysis }, StatusTransition.None);
forbidden.Add(new[] { StatusGroup.Finished, StatusGroup.Postponed }, StatusTransition.None);
forbidden.Add(new[] { StatusGroup.Finished, StatusGroup.ForWork }, StatusTransition.None);
StatusTransition transition;// = StatusTransition.None;
// First try to find in allowed transitions
var key = new[] { statusGroupPrev, statusGroupCur };
if (!allowed.TryGetValue(key, out transition))
{
// Next in forbidded - report
if (forbidden.TryGetValue(key, out transition))
{
Debug.Fail("Forbidden transition detected.");
}
else
{
// If neither - then None
transition = StatusTransition.None;
}
}
return(transition);
}
protected IEnumerable <uint> GetAccounts()
{
IReadOnlyCollection <uint> result = Database.GetAccountIds();
FilterTypes filteredBy = FilterTypes.empty;
FilterTypes filteredByUnion = FilterTypes.empty;
if (_filters.ContainsAll(FilterTypes.interests_any | FilterTypes.likes_all))
{
_filters = _filters.ResetFlags(FilterTypes.likes_all);
if (likes.Count == 1)
{
return(LikesIndexer.GetAllWhoLikes(likes[0]));
}
foreach (var likee in likes)
{
_intersect.Add(LikesIndexer.GetAllWhoLikes(likee));
}
foreach (var interest in interestIndexes)
{
_intersect.Add(StringIndexer.Interests.GetList(interest));
}
_filters = _filters.ResetFlags(FilterTypes.interests_any);
return(_intersect);
}
if (_filters.ContainsAll(FilterTypes.fname_any | FilterTypes.sex_eq))
{
if (fnamesIndexes == null || fnamesIndexes.Count == 0)
{
return(Array.Empty <uint>());
}
var probeNameList = StringIndexer.FirstNames.GetList(fnamesIndexes[0]);
var probeSex = Database.GetAccount(probeNameList[0]).SexStatus & SexStatus.AllSex;
if ((probeSex & _sexStatus) == SexStatus.None)
{
return(Array.Empty <uint>());
}
}
if (_filters.ContainsAll(FilterTypes.birth_year) &&
_filters.ContainsAny(FilterTypes.cities_all_types) &&
_filters.ContainsAny(FilterTypes.sex_status_all_types))
{
ref StatusGroup filtered = ref GroupIndex.SexGroupByCity(cityIndex);
var birthYear = (ushort)birth;
var list = filtered.GetListBy(_sexStatus, birthYear, _union);
_filters = _filters.ResetFlags(FilterTypes.birth_year | FilterTypes.cities_all_types | FilterTypes.sex_status_all_types);
return(list);
}
public void AddStatusGroup(StatusGroup statusGroup)
{
if (this.StatusGroups == null)
{
this.StatusGroups = new ItemsDictionary <StatusGroup>();
}
if (statusGroup != null && statusGroup.Id != null)
{
this.StatusGroups.Add(statusGroup.Id, statusGroup);
}
}
public void AddStatusGroup(StatusGroup sg)
{
if (statusGroups.ContainsKey(sg.GetHashCode()))
{
statusGroups[sg.GetHashCode()].MergeStatus(sg);
}
else
{
statusGroups.Add(sg.GetHashCode(), sg);
BattleManager bm = GameObject.FindGameObjectWithTag(Constants.BM.Tag).GetComponent <BattleManager>();
if (sg.showIcon)
{
bm.AddStatusIconToUI();
}
Debug.Log($"Entity {this.name} added {sg.ToString()}, has {statusGroups.Count} statuses.");
}
}
void ReleaseDesignerOutlets()
{
if (CommandButton != null)
{
CommandButton.Dispose();
CommandButton = null;
}
if (StatusGroup != null)
{
StatusGroup.Dispose();
StatusGroup = null;
}
if (StatusLabel != null)
{
StatusLabel.Dispose();
StatusLabel = null;
}
}
/// <summary>
/// Returns status group for the revision.
/// </summary>
/// <remarks>
/// DontExist :
/// ForAnalysis : open, reopen
/// Postponed : analysed, suspend
/// ForWork : to_be_assigned, assigned, active
/// ForTesting : invalid, duplicate, works_for_me, fixed,
/// modelling, regression, test_cases
/// Finished : verified, closed, deleted
/// </remarks>
private static StatusGroup GetStateGroup(Revision revision)
{
StatusGroup statusGroup = StatusGroup.DontExist;
IDictionary <BugStatus, StatusGroup> mapping = new Dictionary <BugStatus, StatusGroup>();
/// ForAnalysis : open, reopen
mapping.Add(BugStatus.Open, StatusGroup.ForAnalysis);
mapping.Add(BugStatus.Reopen, StatusGroup.ForAnalysis);
/// Postponed : analysed, suspend
mapping.Add(BugStatus.Analyzed, StatusGroup.Postponed);
mapping.Add(BugStatus.Suspend, StatusGroup.Postponed);
/// ForWork : to_be_assigned, assigned, active
mapping.Add(BugStatus.ToBeAssigned, StatusGroup.ForWork);
mapping.Add(BugStatus.Assigned, StatusGroup.ForWork);
mapping.Add(BugStatus.Active, StatusGroup.ForWork);
/// ForTesting : invalid, duplicate, works_for_me, fixed,
/// modelling, regression, test_cases
mapping.Add(BugStatus.Invalid, StatusGroup.ForTesting);
mapping.Add(BugStatus.Duplicate, StatusGroup.ForTesting);
mapping.Add(BugStatus.WorksForMe, StatusGroup.ForTesting);
mapping.Add(BugStatus.Fixed, StatusGroup.ForTesting);
mapping.Add(BugStatus.Modeling, StatusGroup.ForTesting);
mapping.Add(BugStatus.Regression, StatusGroup.ForTesting);
mapping.Add(BugStatus.TestCases, StatusGroup.ForTesting);
/// Finished : verified, closed, deleted
mapping.Add(BugStatus.Verified, StatusGroup.Finished);
mapping.Add(BugStatus.Closed, StatusGroup.Finished);
mapping.Add(BugStatus.Deleted, StatusGroup.Finished);
// If revision didn't exist - then group is DontExist
if (revision != null)
{
// Get status group (treat empty status as if but is just open)
Debug.Assert(mapping.TryGetValue(revision.Status,
out statusGroup));
}
return(statusGroup);
}
public void RemoveStatusGroup(StatusGroup sg)
{
Debug.Log($"Entity {this.name} removes {sg.ToString()}, has {statusGroups.Count} statuses.");
statusGroups.Remove(sg.GetHashCode());
}
public virtual void MergeStatus(StatusGroup another)
{
// TODO: Merge two status group with the same effect
}
public override void MergeStatus(StatusGroup another)
{
// TODO: Merge
base.MergeStatus(another);
}
