protected async Task <StateResult> Step0(Message message, string text, TelegramBotClient bot, bool batchMode)
{
var userId = base.GetUserId(message);
var chatId = base.GetChatId(message);
var currentChatSettings = this.getCurrentChatSettingsQuery.Execute(new GetCurrentChatSettingsRequest(ChatId: chatId));
var gyms = this.getGymsByChatQuery.Execute(new GetGymsByChatRequest(Chat: currentChatSettings));
var special = this.getSpecialGymsQuery.Execute(new GetSpecialGymsForChatsRequest(ChatIds: new[] { chatId }));
StringBuilder msg = new StringBuilder("Bitte wähle ein Gym\r\n");
int i = 0;
foreach (var gym in gyms)
{
var line = $"{i} - {(special.Any(x => x.GymId == gym.Id && x.Type == (int)GymType.Exclude) ? "X " : "")}{(special.Any(x => x.GymId == gym.Id && x.Type == (int)GymType.ExRaid) ? "+ " : "")}{gym.Name}";
if (line.Length + msg.Length > 4096)
{
await bot.SendTextMessageAsync(chatId, msg.ToString());
msg.Clear();
}
msg.AppendLine(line);
i++;
}
await bot.SendTextMessageAsync(chatId, msg.ToString());
return(StateResult.AwaitUserAt(1));
}
protected async Task <StateResult> Step7(Message message, string text, TelegramBotClient bot, bool batchMode)
{
var chatId = base.GetChatId(message);
await bot.SendTextMessageAsync(chatId, "Titel (Max 40):").ConfigureAwait(false);
return(StateResult.AwaitUserAt(8));
}
protected override void InitializeValues(StateResult state)
{
base.InitializeValues(state);
AlarmControlPanelStateEnum alarmState = AlarmControlPanelStateEnum.Disarmed;
if (state.State == "armed_away")
{
alarmState = AlarmControlPanelStateEnum.ArmedAway;
}
else if (state.State == "armed_home")
{
alarmState = AlarmControlPanelStateEnum.ArmedHome;
}
else if (state.State == "triggered")
{
alarmState = AlarmControlPanelStateEnum.Triggered;
}
else if (state.State == "pending")
{
if ("triggered".Equals(state.Attributes.GetValue <string>("post_pending_state")))
{
alarmState = AlarmControlPanelStateEnum.PendingTriggered;
}
else
{
alarmState = AlarmControlPanelStateEnum.PendingArmedAway;
}
}
State = alarmState;
}
public static State <S, Writer <Out, V> > SelectMany <S, Out, T, U, V>(
this State <S, T> self,
Func <T, Writer <Out, U> > bind,
Func <T, U, V> project
)
{
if (bind == null)
{
throw new ArgumentNullException(nameof(bind));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
return((S s) =>
{
var resT = self.Valid()(s);
if (resT.IsBottom)
{
return StateResult.Bottom <S, Writer <Out, V> >(s);
}
return StateResult.Return <S, Writer <Out, V> >(resT.State, () =>
{
var resU = bind(resT.Value).Valid()();
if (resU.IsBottom)
{
return new WriterResult <Out, V>(default(V), resU.Output, true);
}
return WriterResult.Return(project(resT.Value, resU.Value), resU.Output);
});
});
}
protected virtual void InitializeValues(StateResult state)
{
ContextId = state.Context.GetValue <string>("id");
FriendlyName = state.Attributes.GetValue <string>("friendly_name");
LastChanged = state.LastChanged;
LastUpdated = state.LastUpdated;
}
public static State <S, V> SelectMany <S, T, U, V>(
this State <S, T> self,
Func <T, State <S, U> > bind,
Func <T, U, V> project
)
{
if (bind == null)
{
throw new ArgumentNullException(nameof(bind));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
return((S state) =>
{
var resT = self.Valid()(state);
if (resT.IsBottom)
{
return StateResult.Bottom <S, V>(state);
}
var resU = bind(resT.Value).Valid()(resT.State);
if (resU.IsBottom)
{
return StateResult.Bottom <S, V>(resT.State);
}
var resV = project(resT.Value, resU.Value);
return StateResult.Return(resU.State, resV);
});
}
public static State <S, Reader <E, V> > SelectMany <S, E, T, U, V>(
this State <S, T> self,
Func <T, Reader <E, U> > bind,
Func <T, U, V> project
)
{
if (bind == null)
{
throw new ArgumentNullException(nameof(bind));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
return((S s) =>
{
var resT = self.Valid()(s);
if (resT.IsBottom)
{
return StateResult.Bottom <S, Reader <E, V> >(s);
}
return StateResult.Return <S, Reader <E, V> >(resT.State, envInner =>
{
var resU = bind(resT.Value).Valid()(envInner);
if (resU.IsBottom)
{
return new ReaderResult <V>(default(V), true);
}
return ReaderResult.Return(project(resT.Value, resU.Value));
});
});
}
public override StateResult Finish(IAppContext context, float time)
{
var dataReposity = context.GetDataRepository();
var buildFirstCacheResult = dataReposity.GetContainer <BuildFirstCacheResult>(DataKey.BuildFirstCacheResult);
var res = buildFirstCacheResult.Read();
var stateResult = new StateResult();
stateResult.NextStateCode = StateResult.Error;
stateResult.Result = StateResult.Error;
if (res.result == BuildFirstCacheResult.Ok)
{
PrefsUtil.SetInt(PrefsKeys.AssetBundleInitializedKey, 1);
PrefsUtil.Flush();
MyLog.InfoWithFrame(Tag, "BuildFirstCacheResult ok.");
stateResult.NextStateCode = TestLoginStateCode.SetPServerState;
stateResult.Result = StateResult.Ok;
return(stateResult);
}
MyLog.InfoWithFrame(Tag, "BuildFirstCacheResult Fail!");
stateResult.ErrMsg = res.error;
return(stateResult);
}
private static void configurePushTransitions(
ITransitionConfigurator transitions,
ITogglApi api,
ITogglDataSource dataSource,
IAnalyticsService analyticsService,
ILeakyBucket minutesLeakyBucket,
IRateLimiter rateLimiter,
IScheduler scheduler,
StateResult entryPoint,
DependencyContainer dependencyContainer)
{
var delayState = new WaitForAWhileState(scheduler, analyticsService);
var pushNotificationsToken = new SyncPushNotificationsTokenState(dependencyContainer.PushNotificationsTokenStorage, api, dependencyContainer.PushNotificationsTokenService, dependencyContainer.TimeService, dependencyContainer.RemoteConfigService);
transitions.ConfigureTransition(entryPoint, pushNotificationsToken);
var pushingWorkspaces = configureCreateOnlyPush(transitions, pushNotificationsToken.Done, dataSource.Workspaces, analyticsService, api.Workspaces, minutesLeakyBucket, rateLimiter, delayState, Workspace.Clean, Workspace.Unsyncable);
var pushingUsers = configurePushSingleton(transitions, pushingWorkspaces.NoMoreChanges, dataSource.User, analyticsService, api.User, minutesLeakyBucket, rateLimiter, delayState, User.Clean, User.Unsyncable);
var pushingPreferences = configurePushSingleton(transitions, pushingUsers.NoMoreChanges, dataSource.Preferences, analyticsService, api.Preferences, minutesLeakyBucket, rateLimiter, delayState, Preferences.Clean, Preferences.Unsyncable);
var pushingTags = configureCreateOnlyPush(transitions, pushingPreferences.NoMoreChanges, dataSource.Tags, analyticsService, api.Tags, minutesLeakyBucket, rateLimiter, delayState, Tag.Clean, Tag.Unsyncable);
var pushingClients = configureCreateOnlyPush(transitions, pushingTags.NoMoreChanges, dataSource.Clients, analyticsService, api.Clients, minutesLeakyBucket, rateLimiter, delayState, Client.Clean, Client.Unsyncable);
var pushingProjects = configureCreateOnlyPush(transitions, pushingClients.NoMoreChanges, dataSource.Projects, analyticsService, api.Projects, minutesLeakyBucket, rateLimiter, delayState, Project.Clean, Project.Unsyncable);
var pushingTimeEntries = configurePush(transitions, pushingProjects.NoMoreChanges, dataSource.TimeEntries, analyticsService, api.TimeEntries, api.TimeEntries, api.TimeEntries, minutesLeakyBucket, rateLimiter, delayState, TimeEntry.Clean, TimeEntry.Unsyncable);
transitions.ConfigureTransition(delayState.Done, pushingWorkspaces);
transitions.ConfigureTransition(pushingTimeEntries.NoMoreChanges, new DeadEndState());
}
public StateResult Execute(StateResult previousStateResult)
{
this.previousStateResult = previousStateResult;
ClearScreen();
WriteHeader("Delete");
var deleteMessage = String.Format("Are you sure you want to delete {0}?", previousStateResult.AdditionalData.phoneBookEntry.Name);
WriteLine("");
WriteLine(deleteMessage);
WriteLine("");
WriteLine("============================ ACTIONS ============================");
WriteLine("[Y]-Yes | [N]-No");
WriteLine("=================================================================");
var delete = Console.ReadKey();
if (delete.Key == ConsoleKey.Y)
{
DeleteEntry();
return(ReturnChangeState(AppState.PhoneBook));
}
else
{
return(ReturnChangeState(AppState.PhoneBook));
}
}
public StateResult CreateRole(string name)
{
if (this.m_isUseAudit)
{
}
StateResult result = null;
if (this.OnCheckPermission == null)
{
result = StateResult.NotUsedModuleChangeProcessing;
result.ObjectType = this.GetType().Name;
result.Method = System.Reflection.MethodBase.GetCurrentMethod().Name;
return(result);
}
result = this.OnCheckPermission(this, System.Reflection.MethodBase.GetCurrentMethod()
.GetCustomAttributes <PrivilegeAttribute>(), this.m_contextUser);
if (!result.Result)
{
result = StateResult.Forbidden;
}
else
{
IRole role = new Role(name);
this.m_roles.Add(role);
result = StateResult.Success;
result.ObjectId = (role as IdClass).Id;
result.ObjectType = role.GetType().Name;
}
result.ObjectType = this.GetType().Name;
result.Method = System.Reflection.MethodBase.GetCurrentMethod().Name;
this.OnCreateRole?.Invoke(this, new EventArgs());
return(result);
}
public override StateResult Finish(IAppContext context, float time)
{
var dataReposity = context.GetDataRepository();
var buildFirstCacheResult = dataReposity.GetContainer <BuildFirstCacheResult>(DataKey.BuildFirstCacheResult);
var res = buildFirstCacheResult.Read();
var assetBundleManager = context.GetResourceManager();
var stateResult = new StateResult();
stateResult.NextStateCode = StateResult.Error;
stateResult.Result = StateResult.Error;
if (res.result == BuildFirstCacheResult.Ok)
{
var initAssetKey = assetBundleManager.GetAssetBundleInitializedKey();
PrefsUtil.SetInt(initAssetKey, 1);
PrefsUtil.Flush();
MyLog.InfoWithFrame(Tag, "BuildFirstCacheResult ok.");
stateResult.NextStateCode = NetworkState.DownloadResources;
stateResult.Result = StateResult.Ok;
return(stateResult);
}
MyLog.InfoWithFrame(Tag, "BuildFirstCacheResult Fail!");
stateResult.ErrMsg = res.error;
return(stateResult);
}
public ExaState createState(int id, object[] parameters)
{
//Initialize
ExaState NewState = null;
//Check ID
switch(id) {
case ExaState.TITLE:
if (parameters != null && parameters.Length >= 1) NewState = new StateTitle((StateGame)parameters[0]);
break;
case ExaState.GAME:
NewState = new StateGame();
break;
case ExaState.PAUSE:
break;
case ExaState.RESULT:
if (parameters != null && parameters.Length >= 2) NewState = new StateResult ((StateGame)parameters [0], (float)parameters[1]);
break;
}
//Return
return NewState;
}
public void Create()
{
var result = StateResult.Create(5, "A");
Assert.AreEqual(5, result.State);
Assert.AreEqual("A", result.Value);
}
protected override void InitializeValues(StateResult state)
{
base.InitializeValues(state);
State = state.State;
DeviceClass = state.Attributes.GetValue <string>("device_class");
UnitOfMeasurement = state.Attributes.GetValue <string>("unit_of_measurement");
}
public static Reader <E, State <S, V> > SelectMany <E, S, T, U, V>(
this Reader <E, T> self,
Func <T, State <S, U> > bind,
Func <T, U, V> project
)
{
if (bind == null)
{
throw new ArgumentNullException(nameof(bind));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
return((E env) =>
{
var resT = self.Valid()(env);
if (resT.IsBottom)
{
return Bottom <State <S, V> >();
}
return Return <State <S, V> >(state =>
{
var resU = bind(resT.Value).Valid()(state);
if (resU.IsBottom)
{
return StateResult.Bottom <S, V>(state);
}
return StateResult.Return(resU.State, project(resT.Value, resU.Value));
});
});
}
private void WriteToLog(string stateText, StateResult stateResult, Exception ex = null)
{
if (stateResult == StateResult.Error)
{
if (ex != null)
{
var wrappedEx = ex.WrapException();
var wrapedStateText = wrappedEx.Message;
_log.Error(wrapedStateText, wrappedEx);
new ErrorDialogView(wrapedStateText).ShowDialog();
stateText = wrapedStateText;
}
else
{
_log.Error(stateText);
new ErrorDialogView(stateText).ShowDialog();
}
}
var message = stateResult.StateResultToString() + stateText;
_mainViewModel.Log += message + Environment.NewLine;
_mainViewModel.State = message;
}
private static void configurePullTransitions(
TransitionHandlerProvider transitions,
ITogglDatabase database,
ITogglApi api,
ITogglDataSource dataSource,
ITimeService timeService,
StateResult entryPoint)
{
var fetchAllSince = new FetchAllSinceState(database, api, timeService);
var persistWorkspaces = new PersistWorkspacesState(database.Workspaces, database.SinceParameters);
var persistWorkspaceFeatures = new PersistWorkspacesFeaturesState(database.WorkspaceFeatures, database.SinceParameters);
var persistTags = new PersistTagsState(database.Tags, database.SinceParameters);
var persistClients = new PersistClientsState(database.Clients, database.SinceParameters);
var persistProjects = new PersistProjectsState(database.Projects, database.SinceParameters);
var persistTimeEntries = new PersistTimeEntriesState(dataSource.TimeEntries, database.SinceParameters, timeService);
var persistTasks = new PersistTasksState(database.Tasks, database.SinceParameters);
transitions.ConfigureTransition(entryPoint, fetchAllSince.Start);
transitions.ConfigureTransition(fetchAllSince.FetchStarted, persistWorkspaces.Start);
transitions.ConfigureTransition(persistWorkspaces.FinishedPersisting, persistWorkspaceFeatures.Start);
transitions.ConfigureTransition(persistWorkspaceFeatures.FinishedPersisting, persistTags.Start);
transitions.ConfigureTransition(persistTags.FinishedPersisting, persistClients.Start);
transitions.ConfigureTransition(persistClients.FinishedPersisting, persistProjects.Start);
transitions.ConfigureTransition(persistProjects.FinishedPersisting, persistTasks.Start);
transitions.ConfigureTransition(persistTasks.FinishedPersisting, persistTimeEntries.Start);
}
public override StateResult Finish(IAppContext context, float time)
{
var network = context.GetNetworkManager();
var stateResult = new StateResult();
stateResult.NextStateCode = StateResult.Error;
stateResult.Result = StateResult.Error;
// if (network.GetServer() == Server.GServer &&
// network.IsConnected())
// {
MyLog.InfoWithFrame(Tag, "GServer connect ok.");
stateResult.NextStateCode = NetworkState.LoginGameServer;
stateResult.Result = StateResult.Ok;
return(stateResult);
// }
MyLog.InfoWithFrame(Tag, "Connect GServer Fail!");
if (!_isTimeout)
{
stateResult.ErrMsg = string.Format("连接服务器失败，请重新登陆\n【错误码{0}】",
NetworkStateErrorCode.ConnectGameServerFailCode);
}
else
{
stateResult.ErrMsg = string.Format("登录超时，请重新登陆\n【错误码{0}】",
NetworkStateErrorCode.ConnectGameServerFailCode);
}
return(stateResult);
}
public override StateResult Finish(IAppContext context, float time)
{
MyLog.DebugWithFrame(Tag, "Finish login game server.");
var res = _gLoginResult.Read();
var stateResult = new StateResult();
stateResult.NextStateCode = StateResult.Error;
stateResult.Result = StateResult.Error;
// if ((res != null) && (res.result == ResultCode.OK))
// {
LoginOk(context);
stateResult.NextStateCode = NetworkState.LoginGameServerOk;
stateResult.Result = StateResult.Ok;
return(stateResult);
// }
if (!_isTimeout)
{
stateResult.ErrMsg = string.Format("登录游戏服务器失败，请重新登陆\n【错误码{0}】）",
NetworkStateErrorCode.LoginGameServerFailCode);
}
else
{
stateResult.ErrMsg = string.Format("登录游戏服务器登录超时，请重新登陆\n【错误码{0}】",
NetworkStateErrorCode.LoginGameServerFailCode);
}
return(stateResult);
}
protected async Task <StateResult> Step0(Message message, string text, TelegramBotClient bot, bool batchMode)
{
var chatId = base.GetChatId(message);
StringBuilder msg = new StringBuilder("Du hast für folgende Bosse Marker gesetzt:");
var currentBosses = this.getRaidBossPreferencesQuery.Execute(new GetRaidBossPreferencesRequest(ChatId: chatId));
msg.AppendLine();
if (currentBosses.Count() == 0)
{
msg.AppendLine("Keine");
}
else
{
foreach (var boss in currentBosses)
{
msg.AppendLine($"{boss.PokeId}");
}
}
msg.AppendLine("Du kannst 'x' antworten, dann wird nichts geändert.");
msg.Append("Poke-Id, die de- / aktiviert werden soll:");
await bot.SendTextMessageAsync(chatId, msg.ToString()).ConfigureAwait(false);
return(StateResult.AwaitUserAt(1));
}
public override StateResult Finish(IAppContext context, float time)
{
var dataReposity = context.GetDataRepository();
var downloadResourceResult =
dataReposity.GetContainer <DownloadResourceResult>(DataKey.DownloadResourceResult);
var res = downloadResourceResult.Read();
var stateResult = new StateResult();
stateResult.NextStateCode = StateResult.Error;
stateResult.Result = StateResult.Error;
if (res.result == DownloadResourceResult.Ok)
{
MyLog.InfoWithFrame(Tag, "DownloadResourceResult ok.");
stateResult.NextStateCode = NetworkState.ConnectGateServer;
stateResult.Result = StateResult.Ok;
return(stateResult);
}
MyLog.InfoWithFrame(Tag, "DownloadResourceResult Fail!");
stateResult.ErrMsg = res.error;
return(stateResult);
}
public (GameState state, List <TiltDirection> directions) GetWinningStrategy(Field field)
{
//TODO Check that each ball has corresponding hole
var usedStates = new HashSet <string>();
Queue <FieldNode> queue = new Queue <FieldNode>();
queue.Enqueue(new FieldNode(field, new List <TiltDirection>()));
while (queue.TryDequeue(out var node))
{
var ballsState = node.Field.GetBallsState();
if (!usedStates.Contains(ballsState))
{
usedStates.Add(ballsState);
StateResult result = CheckState(node.Field);
switch (result.GameState)
{
case GameState.Fail:
continue;
case GameState.Win:
return(result.GameState, node.Directions);
case GameState.Continue:
default:
var childs = GetChildStates(node.Field, node);
foreach (var child in childs)
{
queue.Enqueue(child);
}
break;
}
}
}
return(GameState.Fail, new List <TiltDirection>());
}
protected async Task <StateResult> Step3(Message message, string text, TelegramBotClient bot, bool batchMode)
{
var userId = base.GetUserId(message);
var chatId = base.GetChatId(message);
if (!batchMode)
{
var raid = this.getCurrentManualRaidQuery.Execute(new GetCurrentManualRaidRequest(UserId: userId));
var gyms = this.getActiveGymsByChatQuery.Execute(new GetActiveGymsByChatRequest(ChatId: raid.ChatId ?? 0));
var special = this.getSpecialGymsQuery.Execute(new GetSpecialGymsForChatsRequest(ChatIds: new[] { raid.ChatId ?? 0 }));
StringBuilder msg = new StringBuilder();
int i = 0;
foreach (var gym in gyms)
{
var gymName = special.FirstOrDefault(x => x.GymId == gym.Id && x.Type == (int)GymType.AlternativeName)?.Data ?? gym.Name;
var line = $"{i} - {gymName}";
if (line.Length + msg.Length > 4096)
{
await bot.SendTextMessageAsync(chatId, msg.ToString());
msg.Clear();
}
msg.AppendLine(line);
i++;
}
await bot.SendTextMessageAsync(chatId, msg.ToString());
}
return(StateResult.AwaitUserAt(4));
}
public static Writer <Out, State <S, V> > SelectMany <Out, S, T, U, V>(
this Writer <Out, T> self,
Func <T, State <S, U> > bind,
Func <T, U, V> project
)
{
if (bind == null)
{
throw new ArgumentNullException(nameof(bind));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
return(() =>
{
var resT = self.Valid()();
if (resT.IsBottom)
{
return WriterResult.Bottom <Out, State <S, V> >(resT.Output);
}
return WriterResult.Return <Out, State <S, V> >(state =>
{
var resU = bind(resT.Value).Valid()(state);
if (resU.IsBottom)
{
return StateResult.Bottom <S, V>(state);
}
return StateResult.Return(resU.State, project(resT.Value, resU.Value));
}, resT.Output);
});
}
public override StateResult Finish(IAppContext context, float time)
{
var stateResult = new StateResult();
stateResult.NextStateCode = TestLoginStateCode.ConnetPserverState;
stateResult.Result = StateResult.Ok;
return(stateResult);
}
protected async Task <StateResult> Step6(Message message, string text, TelegramBotClient bot, bool batchMode)
{
var chatId = base.GetChatId(message);
await bot.SendTextMessageAsync(chatId, "Poke-Id:");
return(StateResult.AwaitUserAt(7));
}
public static State <S, int> Count <S, T>(this State <S, T> self) =>
s =>
{
var res = self.Valid()(s);
return(res.IsBottom
? StateResult.Bottom <S, int>(s)
: StateResult.Return(res.State, 1));
};
public StateResult Execute(StateResult previousStateResult)
{
ClearScreen();
WriteHeader("Search");
stateResult.AdditionalData.SearchText = ReadStringNoEmpty("Please enter a name or phone number:");
return(ReturnChangeState(AppState.PhoneBook));
}
public StateEventArgs(string stateText, StateResult stateResult,
Exception ex = null)
{
StateText = stateText;
StateResult = stateResult;
Ex = ex;
}
private Action startStateMachineAndPrepareSecondStart(StateResult first, StateResult second)
{
var observable = stateMachineFinised();
StateMachine.Start(first.Transition());
observable.Wait();
return(() => StateMachine.Start(second.Transition()));
}
internal override StateResult HandleSendingResponse(SipInviteServerTransaction tx, SipResponse response)
{
var stateResult = new StateResult();
var statusCode = response.StatusLine.StatusCode;
if (statusCode >= 100 && statusCode < 200)
{
tx.SendResponseInternal(response);
}
else if (statusCode >= 200 && statusCode < 300)
{
tx.SendResponseInternal(response);
stateResult.Dispose = true;
}
else if (statusCode >= 300 && statusCode < 700)
{
tx.SendResponseInternal(response);
tx.ChangeState(SipInviteServerTransaction.CompletedState);
}
return stateResult;
}
public override HandlerResponse Handle(JObject parsed)
{
// agent/lib/agent/monit.rb running, starting, failing or unknown
var stateResult = new StateResult(config.AgentID, config.VM, "running", config.BoshProtocol);
return new HandlerResponse(stateResult);
}
