public async Task <IUserBase> GetUser(string userName)
{
IUserBase user = null;
if (userName.IsStudentID())
{
//user = await unitOfWork.StudentRepository.GetByIDAsync(userName.ToIntID());
user = await unitOfWork.Cache.StudentEntities(userName.ToDepartment()).GetAsync(userName);
if (user != null)
{ // Check Students
return(user);
}
}
if (userName.IsHexNumber())
{
user = await unitOfWork.CounselorRepository.GetByIDAsync(userName.ToIntID());
if (user != null)
{ // Check Counselors
return(user);
}
}
user = await unitOfWork.AdminRepository.FirstOrDefaultAsync(u => u.UserName == userName);
if (user != null)
{ // Check Administrators
return(user);
}
return(null);
}
public LoginPageViewModel(IUserBase userBase, IPageService pageService)
{
_userBase = userBase;
_pageService = pageService;
SignIn = new Command(async() => await Save());
}
public CommonComponent(ICommonServices services, TransitBaseComponent tb, IUserBase ub)
{
Current = this;
this.Services = services;
this.Config = Config.Current;
this.TB = tb;
this.UB = ub;
}
public bool CheckIfUserFiltered(IUserBase user)
{
var stateOfCheck = FilteredUsers.Any(x => x.UserId == user.UserId);
Log.Debug("FilterCheck requested for {user} {userID} result: {result}", user.DisplayName, user.UserId,
stateOfCheck);
return(stateOfCheck);
}
public void AddTalker(IUserBase user)
{
Log.Debug("AddTalker ran for {User}({userID})", user.DisplayName, user.UserId);
if (Talkers.All(x => x.UserId != user.UserId))
{
Talkers.Add(user);
}
}
public Task <bool> RemoveFromFilterAsync(IUserBase user)
{
//NO EXCEPTION SHOULD OR CAN BE THROWN HERE
//await eliding is okay because the methods above this will not throw exceptions, or shouldn't
Log.Debug("{user} {userId} removing from the filter", user.DisplayName, user.UserId);
FilteredUsers.RemoveAll(x => x.UserId == user.UserId);
return(_dataAccess.ModifyFilteredUsersAsync(FilteredUsersDatabaseAction.Remove, user.UserId));
}
protected virtual void LoggedinInit(IUserBase loginuser)
{
IUserBase user = loginuser;
HttpContext.Current.Session[SLOGINNAME] = user.LoginName;
HttpContext.Current.Session[SPASWORD] = user.PassWord;
HttpContext.Current.Session[SUSERID] = user.Id;
HttpContext.Current.Session[SUSERNAME] = user.Name;
}
public MainPageViewModel(IUserBase userBase, IPageService pageService)
{
_userBase = userBase;
_pageService = pageService;
LoginButton = new Command(async() => await Login());
RegisterButton = new Command(async() => await Register());
}
private static void AuditRow <TModel>(TModel model, SaveAction saveAction, IUserBase user)
{
if (user == null)
{
return;
}
var audit = model as IAudit;
audit?.Stamp(saveAction, user);
}
public OrderPageViewModel(IUserBase userBase, IPageService pageService, UserViewModel user)
{
_userBase = userBase;
_pageService = pageService;
_user = user;
AddPressed = new Command(async() => await AddPosition());
SettingsCommand = new Command(async() => await Settings());
DeletePositionCommand = new Command <PositionViewModel>(async c => await Delete(c));
MakeOrderCommand = new Command(async() => await MakeOrder());
}
public PositionListPageViewModel(IUserBase userBase, IPageService pageService, List <Position> pos)
{
_userBase = userBase;
_pageService = pageService;
foreach (var _pos in pos)
{
Positions.Add(new PositionViewModel(_pos));
}
SelectPositionCommand = new Command <PositionViewModel>(async c => await SelectPosition(c));
}
public RegisterPageViewModel(IUserBase userBase, IPageService pageService)
{
_userBase = userBase;
_pageService = pageService;
New_user = new User();
RegisterClickedCommand = new Command(async() => await Register());
MaleClickedCommand = new Command(Male);
FemaleClickedCommand = new Command(Female);
// Default Male Clicked
MaleClickedCommand.Execute(null);
}
public AddNewPositionPageViewModel(IUserBase userBase, IPageService pageService)
{
_userBase = userBase;
_pageService = pageService;
AddPizzaCommand = new Command(async() => await Pizza());
AddSoupCommand = new Command(async() => await Soup());
AddDessertCommand = new Command(async() => await Dessert());
ExitCommand = new Command(Exit);
AddCocaCommand = new Command(async() => await Coca());
AddSpriteCommand = new Command(async() => await Sprite());
AddPepsiCommand = new Command(async() => await Pepsi());
}
public SettingsPageViewModel(IUserBase userBase, IPageService pageService, UserViewModel user)
{
_userBase = userBase;
_pageService = pageService;
geoCoder = new Geocoder();
SaveCommand = new Command(async() => await Save());
ExitCommand = new Command(async() => await ExitPressed());
DeleteCommand = new Command(async() => await DeletePressed());
ChangeAvatarCommand = new Command(async() => await ChangeAvatar());
GetAddressCommand = new Command(async() => await GetAddress());
User = user;
}
public bool UpdateUser(IUserBase userEntity)
{
var fullUser = userEntity as ERUserEntity;
var execute = false;
if (fullUser != null)
{
DataAccessManager.ExecuteCommand("UpdateUser", cmd =>
{
execute = cmd.ExecuteNonQuery(userEntity) != 0;
});
}
return(execute);
}
public void Stamp(SaveAction saveAction, IUserBase user)
{
switch (saveAction)
{
case SaveAction.Insert:
CreatedBy = user.Name;
DateCreated = user.LocalTime;
break;
case SaveAction.Update:
ModifiedBy = user.Name;
DateModified = user.LocalTime;
break;
}
}
public Task <bool> AddToFilterAsync(IUserBase user)
{
//NO EXCEPTION SHOULD OR CAN BE THROWN HERE
//await eliding is okay because the methods above this will not throw exceptions, or shouldn't
if (AddUser(user))
{
Log.Debug("{user} {userId} adding to the filter", user.DisplayName, user.UserId);
}
else
{
Users.First(x => x.UserId == user.UserId).DisplayName =
user.DisplayName;
}
return(_dataAccess.ModifyFilteredUsersAsync(FilteredUsersDatabaseAction.Insert, user.UserId));
}
public PositionDetailPageViewModel(IUserBase userBase, IPageService pageService, PositionViewModel viewModel)
{
_userBase = userBase;
_pageService = pageService;
my_position = new Position
{
Name = viewModel.Name,
Description = viewModel.Description,
OnePrice = viewModel.OnePrice,
Count = viewModel.Count,
Url = viewModel.Url,
Composition = viewModel.Composition
};
AddCommand = new Command(async() => await AddPosition());
}
public async Task <AccountContext> ValidateUser(string userName, string password)
{
UserViewModel userViewModel = null;
var userClaims = new List <Claim>();
IUserBase user = await GetUser(userName);
if (user != null && user.CheckPassword(password))
{
userViewModel = new UserViewModel {
UserName = userName, RealName = user.Name, Role = user.GetType().Name
};
userClaims.AddRange(new List <Claim>
{
new Claim(ClaimTypes.Role, userViewModel.Role),
new Claim("RealName", userViewModel.RealName),
new Claim("UserName", userViewModel.UserName)
});
}
return(new AccountContext {
UserEntity = user, UserViewModel = userViewModel, Claims = userClaims
});
}
public async Task <TModel> GetWhereAsync <TModel>(IDbConnection connection, IUserBase user, IDbTransaction txn, params Expression <Func <TModel, bool> >[] criteria)
{
return(await GetWhereAsync(connection, criteria, user, txn));
}
public static async Task UpdateAsync <TModel>(this IDbConnection connection, TModel model, ChangeTracker <TModel> changeTracker = null, IDbTransaction txn = null, IUserBase user = null)
{
await GetProvider().UpdateAsync(connection, model, changeTracker, txn);
}
public static async Task DeleteAsync <TModel>(this IDbConnection connection, long id, IDbTransaction txn = null, IUserBase user = null)
{
await GetProvider().DeleteAsync <TModel>(connection, id, txn, user);
}
public static async Task <long> MergeAsync <TModel>(this IDbConnection connection, TModel model, ChangeTracker <TModel> changeTracker = null, IDbTransaction txn = null, IUserBase user = null, Action <SaveAction, TModel> onSave = null)
{
return(await GetProvider().MergeAsync(connection, model, changeTracker, txn, user, onSave));
}
public UserController(IUserBase app)
: base(app)
{
this.app = app;
}
public async Task RowSavingAsync(IDbConnection connection, SaveAction saveAction, IDbTransaction txn = null, IUserBase user = null)
{
await Task.CompletedTask;
}
public LoggedChangeTracker(ISqlCrudProvider <TIdentity> crudProvider, IUserBase user, TModel @object, string nullText = "<null>") : base(@object)
{
_user = user;
_nullText = nullText;
_crudProvider = crudProvider;
}
public Task UpdateRankAsync(IUserBase user)
{
return(UpdateRankAsync(new[] { user }));
}
public async Task <IEnumerable <string> > GetUserRole(IUserBase user)
{
return(await this.SDHCMemberService.GetRolesAsync(user as TUser));
}
public async Task <TModel> GetWhereAsync <TModel>(IDbConnection connection, Expression <Func <TModel, bool> >[] criteria, IUserBase user = null, IDbTransaction txn = null)
{
var cmd = GetWhereClauseCommand(criteria, txn);
var result = await connection.QuerySingleOrDefaultAsync <TModel>(cmd);
if (result != null && user != null)
{
await VerifyGetPermission(connection, GetIdentity(result), txn, user, result);
await VerifyTenantIsolation(connection, user, result, txn);
}
await OnGetRelatedAsync(connection, result, txn);
return(result);
}
public UserViewComponent(IUserBase <ApplicationUser> user)
{
this.user = user;
}
public async Task RowDeletedAsync(IDbConnection connection, IDbTransaction txn = null, IUserBase user = null)
{
Value = OtherEnum.Other;
await Task.CompletedTask;
}
