private static void GetCurrentAndPrevStateIdByTimeTrackingBlock(TimeTrackingBlock block, out int curStateId, out int prevStateId)
{
curStateId = -1;
prevStateId = -1;
StateMachineService stateMachine = block.GetService <StateMachineService>();
if (stateMachine == null || stateMachine.StateMachine.States.Count == 0 || stateMachine.CurrentState == null)
{
return;
}
EventService eventService = block.GetService <EventService>();
if (eventService != null)
{
// Detects that state is changed, find moFromStateName, toStateName
MetaObject[] events = eventService.LoadEvents(TriggerContext.Current.TransactionId);
StateMachineEventServiceArgs args = StateMachine.GetStateChangedEventArgs(events);
if (args != null)
{
curStateId = StateMachineManager.GetState(TimeTrackingBlock.GetAssignedMetaClass(), args.CurrentState.Name).PrimaryKeyId.Value;
prevStateId = StateMachineManager.GetState(TimeTrackingBlock.GetAssignedMetaClass(), args.PrevState.Name).PrimaryKeyId.Value;
}
}
}
public void Invoke(object Sender, object Element)
{
if (Element is CommandParameters)
{
CommandParameters cp = (CommandParameters)Element;
DateTime startDate = DateTime.Parse(cp.CommandArguments["primaryKeyId"], CultureInfo.InvariantCulture);
TimeTrackingBlock[] mas = TimeTrackingBlock.List(FilterElement.EqualElement("OwnerId", Mediachase.IBN.Business.Security.CurrentUser.UserID), FilterElement.EqualElement("StartDate", startDate));
using (TransactionScope tran = DataContext.Current.BeginTransaction())
{
foreach (TimeTrackingBlock ttb in mas)
{
StateMachineService sms = ((BusinessObject)ttb).GetService <StateMachineService>();
// process only initial state
if (sms.StateMachine.GetStateIndex(sms.CurrentState.Name) == 0)
{
StateTransition[] availableTransitions = sms.GetNextAvailableTransitions(true);
if (availableTransitions.Length > 0)
{
sms.MakeTransition(availableTransitions[0].Uid);
ttb.Save();
}
}
}
tran.Commit();
}
CHelper.RequireBindGrid();
}
}
public bool IsEnable(object Sender, object Element)
{
if (Element is CommandParameters)
{
CommandParameters cp = (CommandParameters)Element;
if (!cp.CommandArguments.ContainsKey("parentBlockId"))
{
return(false);
}
MetaObject ttb = MetaObjectActivator.CreateInstance <BusinessObject>(MetaDataWrapper.ResolveMetaClassByNameOrCardName("TimeTrackingBlock"), Convert.ToInt32(cp.CommandArguments["parentBlockId"]));
StateMachineService sms = ((BusinessObject)ttb).GetService <StateMachineService>();
StateTransition[] transitions = sms.GetNextAvailableTransitions(true);
bool retval = true;
if (transitions.Length == 0)
{
transitions = sms.GetPrevAvailableTransitions(true);
retval = transitions.Length > 0;
}
return(retval);
}
return(false);
}
protected async Task <Guid> PutTestStateMachine(string name, string body)
{
var repository = new DummyRepository <StateMachineEntity, Guid>(_storage);
var service = new StateMachineService(repository);
return(await service.Put(new StateMachineInputDto()
{
Name = name,
Body = body
}));
}
private static int GetFinalStateIdByTimeTrackingBlock(TimeTrackingBlock block)
{
StateMachineService stateMachine = block.GetService <StateMachineService>();
if (stateMachine == null || stateMachine.StateMachine.States.Count == 0)
{
return(-1);
}
State finalState = stateMachine.StateMachine.States[stateMachine.StateMachine.States.Count - 1];
MetaObject stateObject = StateMachineManager.GetState(TimeTrackingBlock.GetAssignedMetaClass(), finalState.Name);
return(stateObject.PrimaryKeyId.Value);
}
public void SetUp()
{
_stateMachineService = new StateMachineService(string.Empty,
new[] { "Entropy.SimpleStateMachine.Tests" },
new[] { GetType().Assembly });
_domainContextRepository = MockRepository.GenerateMock <IDomainContextRepository>();
_workflowPersister = MockRepository.GenerateMock <IWorkflowPersister>();
_workflowService = new WorkflowService(_stateMachineService,
_workflowPersister,
_domainContextRepository);
_userStateChangedCount = 0;
}
private void BindData()
{
if (BlockId > 0)
{
TimeTrackingBlock ttb = MetaObjectActivator.CreateInstance <TimeTrackingBlock>(TimeTrackingBlock.GetAssignedMetaClass(), BlockId);
StateMachineService sms = ttb.GetService <StateMachineService>();
StateTransition[] nextTransitions = sms.GetNextAvailableTransitions();
StateTransition[] prevTransitions = sms.GetPrevAvailableTransitions();
ttbTitle.Text = ttb.Title;
TTBlockComment.Value = string.Empty;
BindTransitions(nextTransitions, prevTransitions);
}
}
public bool IsEnable(object Sender, object Element)
{
if (Element is CommandParameters)
{
CommandParameters cp = (CommandParameters)Element;
if (!cp.CommandArguments.ContainsKey("parentBlockId"))
{
return(false);
}
TimeTrackingBlock ttb = MetaObjectActivator.CreateInstance <TimeTrackingBlock>(MetaDataWrapper.ResolveMetaClassByNameOrCardName("TimeTrackingBlock"), Convert.ToInt32(cp.CommandArguments["parentBlockId"].ToString(), CultureInfo.InvariantCulture));
StateMachineService sms = ttb.GetService <StateMachineService>();
StateTransition[] transitions = sms.GetNextAvailableTransitions(true);
bool isInitialState = sms.StateMachine.GetStateIndex(sms.CurrentState.Name) == 0;
return(transitions.Length > 0 && isInitialState);
}
return(false);
}
public bool IsEnable(object Sender, object Element)
{
if (Element is CommandParameters)
{
CommandParameters cp = (CommandParameters)Element;
if (!cp.CommandArguments.ContainsKey("parentBlockId"))
{
return(false);
}
MetaObject ttb = MetaObjectActivator.CreateInstance <BusinessObject>(MetaDataWrapper.ResolveMetaClassByNameOrCardName("TimeTrackingBlock"), Convert.ToInt32(cp.CommandArguments["parentBlockId"]));
StateMachineService sms = ((BusinessObject)ttb).GetService <StateMachineService>();
bool canWrite = TimeTrackingBlock.CheckUserRight((Mediachase.IbnNext.TimeTracking.TimeTrackingBlock)ttb, Security.RightWrite);
bool isInitialState = sms.StateMachine.GetStateIndex(sms.CurrentState.Name) == 0;
return(canWrite && isInitialState);
}
return(false);
}
private void btnComplete_Click(object sender, EventArgs e)
{
try
{
btnComplete.Enabled = false;
StateMachineService stateMachineService = SampleWorkflowRuntime.Current.GetService <StateMachineService>();
stateMachineService.OnCompleted(_workflowInstance.InstanceId);
SampleWorkflowRuntime.Current.RunWorkflow(_workflowInstance.InstanceId);
btnCreate.Enabled = true;
}
catch (Exception ex)
{
MessageBox.Show("Unexpected error: {0}", ex.ToString());
btnCreate.Enabled = false;
btnComplete.Enabled = true;
}
btnComplete.Enabled = false;
btnCreate.Enabled = true;
}
protected override void OnSaving()
{
// Call Base Method => Call Service PreSaveMethod
base.OnSaving();
if (this.Properties.Contains("IsRejected") &&
this.IsServiceActivated <StateMachineService>())
{
StateMachineService stateMachine = this.GetService <StateMachineService>();
if (stateMachine != null &&
this.Properties["mc_StateId"].IsChanged)
{
// Get Name
string oldState = (string)this.Properties["mc_State"].OriginalValue;
string newState = (string)this.Properties["mc_State"].Value;
// Get State Machine Index
int oldStateIndex = stateMachine.StateMachine.GetStateIndex(oldState);
int newStateIndex = stateMachine.StateMachine.GetStateIndex(newState);
// Update IsRejectedState state field.
this.Properties["IsRejected"].Value = (oldStateIndex > newStateIndex);
}
}
// OZ: Clean up from HttpContext
if (this.PrimaryKeyId.HasValue)
{
ClearUserRight(this.PrimaryKeyId.Value, Security.RightRead);
ClearUserRight(this.PrimaryKeyId.Value, Security.RightWrite);
}
string cacheKey = this.ToString() + "_" + Security.CurrentUserId.ToString() + "_AllowedRights";
DataContext.Current.Cache.Remove(cacheKey);
}
public void Invoke(object Sender, object Element)
{
if (Element is CommandParameters)
{
CommandParameters cp = (CommandParameters)Element;
string[] elems = null;
if (cp.CommandArguments.ContainsKey("GridId"))
{
elems = MetaGridServer.GetCheckedCollection(((CommandManager)Sender).Page, cp.CommandArguments["GridId"]);
}
List <int> ttbIds = new List <int>();
//fix by DV: 2008-05-14
//Esli vyzyvaetsa s grida (iconka v otklonennih listah), to primitiv v gride ustanovit etot flag
//i togda ID budet bratsa iz parametrov, v protivnom sluchae ID - beretsa iz checkboxes
if (!cp.CommandArguments.ContainsKey("callFromGrid"))
{
foreach (string elem in elems)
{
string type = MetaViewGroupUtil.GetMetaTypeFromUniqueKey(elem); // elem.Split(new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries)[1];
if (type == MetaViewGroupUtil.keyValueNotDefined)
{
continue;
}
int id = Convert.ToInt32(MetaViewGroupUtil.GetIdFromUniqueKey(elem), CultureInfo.InvariantCulture); //Convert.ToInt32(elem.Split(new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries)[0], CultureInfo.InvariantCulture);
if (type == TimeTrackingEntry.GetAssignedMetaClass().Name)
{
//TimeTrackingEntry tte = MetaObjectActivator.CreateInstance<TimeTrackingEntry>(TimeTrackingEntry.GetAssignedMetaClass(), id);
//if (!ttbIds.Contains(tte.ParentBlockId))
// ttbIds.Add(tte.ParentBlockId);
}
else
{
if (!ttbIds.Contains(id))
{
ttbIds.Add(id);
}
}
}
}
else
{
ttbIds.Add(Convert.ToInt32(MetaViewGroupUtil.GetIdFromUniqueKey(cp.CommandArguments["primaryKeyId"]), CultureInfo.InvariantCulture));
}
using (TransactionScope tran = DataContext.Current.BeginTransaction())
{
foreach (int ttbId in ttbIds)
{
TimeTrackingBlock ttb = MetaObjectActivator.CreateInstance <TimeTrackingBlock>(TimeTrackingBlock.GetAssignedMetaClass(), ttbId);
StateMachineService sms = ((BusinessObject)ttb).GetService <StateMachineService>();
// process only initial state
if (sms.StateMachine.GetStateIndex(sms.CurrentState.Name) == 0)
{
StateTransition[] availableTransitions = sms.GetNextAvailableTransitions(true);
if (availableTransitions.Length > 0)
{
sms.MakeTransition(availableTransitions[0].Uid);
ttb.Save();
}
}
}
tran.Commit();
}
}
}
private void button4_Click(object sender, EventArgs e)
{
StateMachineService.RemoveStateMachine(LatestMachine);
}
private void button1_Click(object sender, EventArgs e)
{
LatestMachine = StateMachineService.AddStateMachine();
}
public Form1()
{
InitializeComponent();
LatestMachine = StateMachineService.AddStateMachine();
}