public async Task <CustomReturn <User> > GetInformationAsync()
{
var service = new UserRest();
var user = await service.GetInformationAsync(Account.Current.Token.AccessToken);
return(user);
}
public JsonResult GetRests2()
{
RMSEntities ctx = new RMSEntities();
var data = from a in ctx.Branches.ToList() where a.bcity == Session["Usercity"].ToString()
select new { name = a.Rname };
var data1 = from a in ctx.Restaurants.ToList() join b in data.ToList() on a.Rname equals b.name
select new { type = a.Category };
string s = data1.ToList()[0].type;
List <UserRest> listRest = new List <UserRest>();
foreach (var item in ctx.Branches.ToList())
{
if (Session["Usercity"].ToString() == item.bcity)
{
UserRest u = new UserRest();
u.Rname = item.Rname;
u.Location = item.Location;
u.bcity = item.bcity;
u.Category = s;
u.bimage = String.Format("data:image/jpg;base64,{0}", Convert.ToBase64String(item.bimage));
listRest.Add(u);
}
}
return(Json(listRest,
JsonRequestBehavior.AllowGet));
}
public async Task <CustomReturn <IList <Event> > > GetFavoriteEventsAsync()
{
var service = new UserRest();
var result = await service.GetFavoriteEventsAsync();
return(result);
}
public async Task <IList <Event> > GetFavoriteEventsAsync()
{
var service = new UserRest();
var items = await service.GetFavoriteEventsAsync();
return(items.OrderBy(o => o.Name).ToList());
}
public async Task <bool> Authenticate(LoginPageModel login)
{
ValidateLogin(login);
var tokenService = new TokenRest();
var token = await tokenService.Login(login);
if (token == null)
{
throw new Exception("Usuário ou Senha incorreta");
}
var userService = new UserRest();
var userVm = await userService.GetInformationAsync(token.AccessToken);
if (userVm == null)
{
throw new Exception("Usuário ou Senha incorreta");
}
var userToken = new UserTokenVm
{
Token = token,
User = userVm.Value
};
Login(userToken);
return(true);
}
public async Task <ActionResult> OnPostAsync()
{
_logger.LogTrace("CreateModel {CreateModel} submitted", newUserList);
if (!ModelState.IsValid)
{
_logger.LogTrace("Submitted TaskModel is invalid {errors}", ModelState.Values);
return(Page());
}
else
{
List <UserRest> userList = new List <UserRest>();
char[] separators = new char[] { '\n' };
string[] subs = newUserList.UserList.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var sub in subs)
{
if (EmailValidator.IsValidEmail(sub.Trim()))
{
var usr = new UserRest();
usr.UserEmail = sub.Trim();
usr.Claims = new Dictionary <string, string> {
{ newUserList.ClaimName,
newUserList.ClaimValue }
};
userList.Add(usr);
}
else
{
string errmsg = string.Format("{0} is not a valid email address.", sub);
_logger.LogTrace("Input list of users is not valid. Entry {sub} is not a valid email address.", sub);
ModelState.AddModelError(String.Empty, errmsg);
return(Page());
}
}
try
{
_logger.LogTrace("List if users {userList}", userList);
await _userService.OnUpdateUserListAsync(userList);
_logger.LogTrace("List of users was updated successfuly");
return(RedirectToPage("/Admin/Users/Index"));
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, "List of users update failed.");
_logger.LogError("List of users update failed. {e}", e);
return(Page());
}
}
}
public async Task <IActionResult> UpdateUser(UserRest user)
{
var response = await _acoountApplication.UpdateData(user);
if (response == null)
{
return(BadRequest());
}
return(Ok(response));
}
private async Task <UserRest> CreateUser(UserRest user, string password)
{
var result = await _userHelper.AddUserAsync(Mapper.Map <UserDto>(user), password);
if (result.Succeeded)
{
var userDto = await _userHelper.GetUserByEmailAsync(user.Email);
await _userHelper.AddUserToRoleAsync(userDto, Constans.ROLE_OWNER);
return(Mapper.Map <UserRest>(userDto));
}
return(null);
}
public UserCreatePage(MainWindow mainWindow)
{
if (userRest == null)
{
userRest = new UserRest();
}
if (userManager == null)
{
userManager = new ClientUserManager();
}
InitializeComponent();
this.mainWindow = mainWindow;
}
public async Task <IDictionary <string, string> > GetUserClaimsAsync(string userEmail)
{
HttpResponseMessage response = await _client.GetAsync($"/user/{userEmail}");
if (!response.IsSuccessStatusCode)
{
throw new OperationFailedException($"Error on claims retrieval {response.StatusCode}");
}
UserRest user = await response.Content.ReadAsAsync <UserRest>();
if (user.UserEmail != userEmail)
{
throw new OperationFailedException("Retrieved wrong user");
}
return(user.Claims);
}
internal async Task <UserRest> UpdateData(UserRest user)
{
var userDto = await _userHelper.GetUserByEmailAsync(user.Email);
if (userDto == null)
{
return(null);
}
userDto.Document = user.Document;
userDto.FirstName = user.FirstName;
userDto.LastName = user.LastName;
userDto.Address = user.Address;
userDto.PhoneNumber = user.PhoneNumber;
await _userHelper.UpdateUserAsync(userDto);
return(_mapper.Map <UserRest>(userDto));
}
public async Task <UserRest> SaveUser(AutoRegisterRest user)
{
UserRest userRest = null;
if (user.Role.Equals(Helper.Constans.ROLE_OWNER))
{
var owner = await _ownerApplication.Save(GetOwnerByAutoRegister(user));
userRest = owner.User;
}
else if (user.Role.Equals(Helper.Constans.ROLE_LESSEE))
{
var lessee = await _lesseeApplication.Save(GetLesseeByAutoRegister(user));
userRest = lessee.User;
}
return(userRest);
}
public UserPage(MainWindow userWindow)
{
if (userRest == null)
{
userRest = new UserRest();
}
if (userManager == null)
{
userManager = new ClientUserManager();
}
InitializeComponent();
List <ThingDto> users = new List <ThingDto>();
fillUsersList();
this.mainWindow = userWindow;
currentUsernameTextBlock.Text = "Current user: " + userManager.Get().Result.Username;
}
public UserUpdatePage(MainWindow mainWindow)
{
if (userRest == null)
{
userRest = new UserRest();
}
if (userManager == null)
{
userManager = new ClientUserManager();
}
InitializeComponent();
this.mainWindow = mainWindow;
currentUser = userRest.Get(mainWindow.currentId);
usernameTextBox.Text = currentUser.Username;
emailTextBox.Text = currentUser.Email;
phoneNumberTextBox.Text = currentUser.PhoneNumber;
firstNameTextBox.Text = currentUser.FName;
lastNameTextBox.Text = currentUser.LName;
}
public async Task <bool> SendUser(UserDto user)
{
var userRest = new UserRest
{
Email = user.Name,
Token = user.Token,
Description = "",
PlatformType = PlatformType.Android
};
var userJson = JsonConvert.SerializeObject(userRest);
var contentUser = new StringContent(userJson, Encoding.UTF8, "application/json");
var uri = new Uri($"{Ip}/User/?jwtToken={user.Token}");
try
{
var response = await _client.PutAsync(uri, contentUser);
if (!response.IsSuccessStatusCode)
{
return(false);
}
var content = await response.Content.ReadAsStringAsync();
var token = JsonConvert.DeserializeObject <TokenRest>(content);
user.ApiToken = token.Token;
user.SyncStatus = SyncStatus.Uploaded;
user.UserId = await UserService.Instance.SaveUser(user);
UserService.Instance.SetLoggedUser(user);
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task <CustomReturn <User> > Register(RegisterPageModel register)
{
if (string.IsNullOrWhiteSpace(register.FirstName))
{
throw new Exception("Campo Nome é obrigatório");
}
if (string.IsNullOrWhiteSpace(register.LastName))
{
throw new Exception("Campo Sobrenome é obrigatório");
}
if (string.IsNullOrWhiteSpace(register.Telephone) || string.IsNullOrWhiteSpace(register.Telephone))
{
throw new Exception("Informe pelo menos um número de contato");
}
if (!PhoneNumberValidatorBehavior.IsValidPhoneNumber(register.Telephone))
{
throw new Exception("Campo Telefone é inválido");
}
if (!PhoneNumberValidatorBehavior.IsValidPhoneNumber(register.CellPhone))
{
throw new Exception("Campo Celular é inválido");
}
if (string.IsNullOrWhiteSpace(register.Cpf))
{
throw new Exception("Campo CPF é obrigatório");
}
if (!CpfValidatorBehavior.IsValidCpf(register.Cpf))
{
throw new Exception("Campo CPF é inválido");
}
if (string.IsNullOrWhiteSpace(register.Email))
{
throw new Exception("Campo Email é obrigatório");
}
if (!EmailHelper.IsEmail(register.Email))
{
throw new Exception("Email inválido");
}
if (string.IsNullOrWhiteSpace(register.Password))
{
throw new Exception("Campo Senha é obrigatório");
}
if (string.IsNullOrWhiteSpace(register.ConfirmPassword))
{
throw new Exception("Campo Confirmação de Senha é obrigatório");
}
if (!string.Equals(register.Password, register.ConfirmPassword))
{
throw new Exception("A senha e confirmação não confere");
}
var userRest = new UserRest();
var userResult = await userRest.Register(register);
if (!userResult.IsValid)
{
return(userResult);
}
var tokenRest = new TokenRest();
var token = await tokenRest.Login(new LoginPageModel { UserName = userResult.Value.Cpf, Password = register.Password });
var userToken = new UserTokenVm
{
User = userResult.Value,
Token = token
};
Login(userToken);
return(userResult);
}
