private async Task <bool> AdvanceState(IUserState userState, Transition transition)
{
if (transition.KeepState)
{
return(false);
}
if (transition.InnerTransition != null)
{
userState.InnerState = transition.InnerTransition.GetMethodInfo().Name;
return(false);
}
if (transition.Symbol != null)
{
var currentOuterState = _controllerNameToType[userState.OuterState];
try
{
(var outerState, var innerState, var forward) = _stateMachine.IdempotentStep(currentOuterState, transition.Symbol);
userState.InnerState = innerState;
userState.OuterState = outerState.GetControllerName();
return(forward);
}
catch
{
await _logger.LogError($"There is no registered transition {transition.Symbol} from {currentOuterState.Name}")
.ConfigureAwait(false);
return(false);
}
}
return(false);
}
private void ResizeWindow(IUserState state)
{
var guiConfiguration = state.GetGuiConfiguration();
this.Width = guiConfiguration.Width;
this.Height = guiConfiguration.Height;
this.Top = guiConfiguration.Y;
this.Left = guiConfiguration.X;
}
public IUserState Get(string id)
{
IUserState state = CurrentSession.Get <UserState>(id);
if (ReadOnlyProxyGenerator != null && state != null)
{
return(ReadOnlyProxyGenerator.CreateProxy <IUserState>(state, new Type[] { typeof(ISaveable) }, _readOnlyPropertyNames));
}
return(state);
}
public static TDeleteUser ToDeleteUser <TDeleteUser>(this IUserState state)
where TDeleteUser : IDeleteUser, new()
{
var cmd = new TDeleteUser();
cmd.UserId = state.UserId;
cmd.Version = ((IUserStateProperties)state).Version;
return(cmd);
}
private bool CheckPassword(string userName, string password, out IUserState user)
{
user = UserApplicationService.GetByProperty("UserName", userName, null, 0, 1).FirstOrDefault();
bool isOk = true;
if (user == null || PasswordHasher.VerifyHashedPassword(user.PasswordHash, password) == PasswordVerificationResult.Failed)
{
isOk = false;
}
return(isOk);
}
public void Save(IUserState state)
{
CurrentSession.SaveOrUpdate(state);
var saveable = state as ISaveable;
if (saveable != null)
{
saveable.Save();
}
}
public IUserState Get(string id)
{
IUserState state = CurrentSession.Get <UserState> (id);
if (state == null)
{
state = new UserState();
(state as UserState).UserId = id;
}
return(state);
}
private void AddUserRoleIdsToList(IUserState user, IList <string> idList)
{
var userRoles = user.UserRoles;
if (userRoles != null)
{
foreach (var role in userRoles)
{
idList.Add(role.RoleId);
}
}
}
private static void AddUserPermissionIdsToIdList(IUserState user, List <string> idList)
{
var userPermissions = user.UserPermissions;
if (userPermissions != null)
{
foreach (var p in userPermissions)
{
idList.Add(p.PermissionId);
}
}
}
public DtoUserLoginStates(IUserState outerState, IEnumerable <IUserLoginState> innerStates)
{
this._outerState = outerState;
if (innerStates == null)
{
this._innerStates = new IUserLoginState[] { };
}
else
{
this._innerStates = innerStates;
}
}
public async Task SetState(IUserState state)
{
if (CurrentState != null)
{
await CurrentState.OnExit();
}
CurrentState = state;
await state.OnEnter();
await state.Handle();
}
public StateItem(IUserState state)
{
if (state == null)
{
return;
}
Id = state.Id;
Title = state.Title;
Icon = GetIcon(state);
Background = GetBrush(state.Color);
Name = state.Name;
}
public IUserState Get(string id, bool nullAllowed)
{
IUserState state = CurrentSession.Get <UserState> (id);
if (!nullAllowed && state == null)
{
state = new UserState();
(state as UserState).UserId = id;
}
if (ReadOnlyProxyGenerator != null && state != null)
{
return(ReadOnlyProxyGenerator.CreateProxy <IUserState>(state, new Type[] { typeof(ISaveable) }, _readOnlyPropertyNames));
}
return(state);
}
public async Task <IUserState> GetAsync(string userId)
{
IUserState state = null;
var idObj = userId;
var uriParameters = new UserUriParameters();
uriParameters.Id = idObj;
var req = new UserGetRequest(uriParameters);
var resp = await _ramlClient.User.Get(req);
UserProxyUtils.ThrowOnHttpResponseError(resp);
state = resp.Content;
return(state);
}
public void Save(IUserState state)
{
IUserState s = state;
if (ReadOnlyProxyGenerator != null)
{
s = ReadOnlyProxyGenerator.GetTarget <IUserState>(state);
}
CurrentSession.SaveOrUpdate(s);
var saveable = s as ISaveable;
if (saveable != null)
{
saveable.Save();
}
}
public static TMergePatchUser ToMergePatchUser <TMergePatchUser, TCreateUserRole, TMergePatchUserRole, TCreateUserClaim, TMergePatchUserClaim, TCreateUserPermission, TMergePatchUserPermission, TCreateUserLogin, TMergePatchUserLogin>(this IUserState state)
where TMergePatchUser : IMergePatchUser, new()
where TCreateUserRole : ICreateUserRole, new()
where TMergePatchUserRole : IMergePatchUserRole, new()
where TCreateUserClaim : ICreateUserClaim, new()
where TMergePatchUserClaim : IMergePatchUserClaim, new()
where TCreateUserPermission : ICreateUserPermission, new()
where TMergePatchUserPermission : IMergePatchUserPermission, new()
where TCreateUserLogin : ICreateUserLogin, new()
where TMergePatchUserLogin : IMergePatchUserLogin, new()
{
var cmd = new TMergePatchUser();
cmd.Version = ((IUserStateProperties)state).Version;
cmd.UserId = state.UserId;
cmd.UserName = state.UserName;
cmd.AccessFailedCount = state.AccessFailedCount;
cmd.Email = state.Email;
cmd.EmailConfirmed = state.EmailConfirmed;
cmd.LockoutEnabled = state.LockoutEnabled;
cmd.LockoutEndDateUtc = state.LockoutEndDateUtc;
cmd.PasswordHash = state.PasswordHash;
cmd.PhoneNumber = state.PhoneNumber;
cmd.PhoneNumberConfirmed = state.PhoneNumberConfirmed;
cmd.TwoFactorEnabled = state.TwoFactorEnabled;
cmd.SecurityStamp = state.SecurityStamp;
cmd.Active = ((IUserStateProperties)state).Active;
if (state.UserName == null)
{
cmd.IsPropertyUserNameRemoved = true;
}
if (state.Email == null)
{
cmd.IsPropertyEmailRemoved = true;
}
if (state.LockoutEndDateUtc == null)
{
cmd.IsPropertyLockoutEndDateUtcRemoved = true;
}
if (state.PasswordHash == null)
{
cmd.IsPropertyPasswordHashRemoved = true;
}
if (state.PhoneNumber == null)
{
cmd.IsPropertyPhoneNumberRemoved = true;
}
if (state.SecurityStamp == null)
{
cmd.IsPropertySecurityStampRemoved = true;
}
foreach (var d in state.UserRoles)
{
var c = d.ToCreateOrMergePatchUserRole <TCreateUserRole, TMergePatchUserRole>();
cmd.UserRoleCommands.Add(c);
}
foreach (var d in state.UserClaims)
{
var c = d.ToCreateOrMergePatchUserClaim <TCreateUserClaim, TMergePatchUserClaim>();
cmd.UserClaimCommands.Add(c);
}
foreach (var d in state.UserPermissions)
{
var c = d.ToCreateOrMergePatchUserPermission <TCreateUserPermission, TMergePatchUserPermission>();
cmd.UserPermissionCommands.Add(c);
}
foreach (var d in state.UserLogins)
{
var c = d.ToCreateOrMergePatchUserLogin <TCreateUserLogin, TMergePatchUserLogin>();
cmd.UserLoginCommands.Add(c);
}
return(cmd);
}
public UserRoleStates(IUserState outerState)
{
this._userState = outerState;
}
public LoginPresenter(ILoginView view, IUserState userState)
{
_view = view;
_userState = userState;
}
}// END Map(ICreate... ////////////////////////////
protected virtual IUserLoginStateMergePatched MapMergePatch(IMergePatchUserLogin c, IUserCommand outerCommand, long version, IUserState outerState)
{
c.RequesterId = outerCommand.RequesterId;
var stateEventId = new UserLoginEventId(c.UserId, c.LoginKey, version);
IUserLoginStateMergePatched e = NewUserLoginStateMergePatched(stateEventId);
var s = outerState.UserLogins.Get(c.LoginKey);
e.Active = c.Active;
e.IsPropertyActiveRemoved = c.IsPropertyActiveRemoved;
e.CreatedBy = (string)c.RequesterId;
e.CreatedAt = ApplicationContext.Current.TimestampService.Now <DateTime>();
return(e);
}// END Map(IMergePatch... ////////////////////////////
}// END Map(IRemove... ////////////////////////////
protected virtual IUserLoginEvent Map(IUserLoginCommand c, IUserCommand outerCommand, long version, IUserState outerState)
{
var create = (c.CommandType == CommandType.Create) ? (c as ICreateUserLogin) : null;
if (create != null)
{
return(MapCreate(create, outerCommand, version, outerState));
}
var merge = (c.CommandType == CommandType.MergePatch || c.CommandType == null) ? (c as IMergePatchUserLogin) : null;
if (merge != null)
{
return(MapMergePatch(merge, outerCommand, version, outerState));
}
var remove = (c.CommandType == CommandType.Remove) ? (c as IRemoveUserLogin) : null;
if (remove != null)
{
return(MapRemove(remove, outerCommand, version));
}
throw new NotSupportedException();
}
protected virtual IUserPermissionStateCreated MapCreate(ICreateUserPermission c, IUserCommand outerCommand, long version, IUserState outerState)
{
c.RequesterId = outerCommand.RequesterId;
var stateEventId = new UserPermissionEventId(c.UserId, c.PermissionId, version);
IUserPermissionStateCreated e = NewUserPermissionStateCreated(stateEventId);
var s = outerState.UserPermissions.Get(c.PermissionId, true);
e.Active = c.Active;
e.CreatedBy = (string)c.RequesterId;
e.CreatedAt = ApplicationContext.Current.TimestampService.Now <DateTime>();
return(e);
}// END Map(ICreate... ////////////////////////////
public UserAggregate(IUserState state)
{
_state = state;
}
public UserRoleStates(IUserState outerState)
{
this._userState = outerState;
this._forReapplying = outerState.ForReapplying;
}
protected bool IsRepeatedCommand(IUserCommand command, IEventStoreAggregateId eventStoreAggregateId, IUserState state)
{
bool repeated = false;
if (((IUserStateProperties)state).Version > command.AggregateVersion)
{
var lastEvent = EventStore.FindLastEvent(typeof(IUserStateEvent), eventStoreAggregateId, command.AggregateVersion);
if (lastEvent != null && lastEvent.CommandId == command.CommandId)
{
repeated = true;
}
}
return(repeated);
}
public Task SetUserState(int telegramUserId, IUserState state)
{
_memory[telegramUserId] = state;
return(Task.CompletedTask);
}
private ImageSource GetIcon(IUserState state)
{
return(UserStateIconConverter.Convert(state));
}
public static IUserCommand ToCreateOrMergePatchUser <TCreateUser, TMergePatchUser, TCreateUserRole, TMergePatchUserRole, TCreateUserClaim, TMergePatchUserClaim, TCreateUserPermission, TMergePatchUserPermission, TCreateUserLogin, TMergePatchUserLogin>(this IUserState state)
where TCreateUser : ICreateUser, new()
where TMergePatchUser : IMergePatchUser, new()
where TCreateUserRole : ICreateUserRole, new()
where TMergePatchUserRole : IMergePatchUserRole, new()
where TCreateUserClaim : ICreateUserClaim, new()
where TMergePatchUserClaim : IMergePatchUserClaim, new()
where TCreateUserPermission : ICreateUserPermission, new()
where TMergePatchUserPermission : IMergePatchUserPermission, new()
where TCreateUserLogin : ICreateUserLogin, new()
where TMergePatchUserLogin : IMergePatchUserLogin, new()
{
bool bUnsaved = ((IUserState)state).IsUnsaved;
if (bUnsaved)
{
return(state.ToCreateUser <TCreateUser, TCreateUserRole, TCreateUserClaim, TCreateUserPermission, TCreateUserLogin>());
}
else
{
return(state.ToMergePatchUser <TMergePatchUser, TCreateUserRole, TMergePatchUserRole, TCreateUserClaim, TMergePatchUserClaim, TCreateUserPermission, TMergePatchUserPermission, TCreateUserLogin, TMergePatchUserLogin>());
}
}
public static TCreateUser ToCreateUser <TCreateUser, TCreateUserRole, TCreateUserClaim, TCreateUserPermission, TCreateUserLogin>(this IUserState state)
where TCreateUser : ICreateUser, new()
where TCreateUserRole : ICreateUserRole, new()
where TCreateUserClaim : ICreateUserClaim, new()
where TCreateUserPermission : ICreateUserPermission, new()
where TCreateUserLogin : ICreateUserLogin, new()
{
var cmd = new TCreateUser();
cmd.Version = ((IUserStateProperties)state).Version;
cmd.UserId = state.UserId;
cmd.UserName = state.UserName;
cmd.AccessFailedCount = state.AccessFailedCount;
cmd.Email = state.Email;
cmd.EmailConfirmed = state.EmailConfirmed;
cmd.LockoutEnabled = state.LockoutEnabled;
cmd.LockoutEndDateUtc = state.LockoutEndDateUtc;
cmd.PasswordHash = state.PasswordHash;
cmd.PhoneNumber = state.PhoneNumber;
cmd.PhoneNumberConfirmed = state.PhoneNumberConfirmed;
cmd.TwoFactorEnabled = state.TwoFactorEnabled;
cmd.SecurityStamp = state.SecurityStamp;
cmd.Active = ((IUserStateProperties)state).Active;
foreach (var d in state.UserRoles)
{
var c = d.ToCreateUserRole <TCreateUserRole>();
cmd.UserRoles.Add(c);
}
foreach (var d in state.UserClaims)
{
var c = d.ToCreateUserClaim <TCreateUserClaim>();
cmd.UserClaims.Add(c);
}
foreach (var d in state.UserPermissions)
{
var c = d.ToCreateUserPermission <TCreateUserPermission>();
cmd.UserPermissions.Add(c);
}
foreach (var d in state.UserLogins)
{
var c = d.ToCreateUserLogin <TCreateUserLogin>();
cmd.UserLogins.Add(c);
}
return(cmd);
}
public void change_state(USER_STATE_TYPE state)
{
this.current_user_state = this.user_states[state];
}
public abstract IUserAggregate GetUserAggregate(IUserState state);
public MiddlewareContext(IUserState userState, ControllerContext context)
{
UserState = userState;
ControllerContext = context;
Response = new List <ResponseMessage>();
}
public DefaultPresenter(IDefaultView view, IUserState userState)
{
_view = view;
_userState = userState;
}
