private string getUsers()
{
UserCRUD user_CRUD = new UserCRUD();
List <User> listUsers = (List <User>)user_CRUD.getUsersWithRFQ();
return(JsonConvert.SerializeObject(listUsers));
}
public UserListResponse GetUser()
{
UserListResponse response = new UserListResponse();
try
{
throw new Exception();
var result = new UserCRUD().GetUsers();
if (result.Count == 0)
{
response.NoContent();
}
else
{
response.OK();
response.User = result;
}
}
catch (Exception es)
{
logger.Error("GetUser " + es.StackTrace);
response.InternalServerError();
}
return(response);
}
public void AddUserTest()
{
UserCRUD userService = new UserCRUD(new TestDataRepository());
Assert.IsTrue(userService.AddUser(67, "Jan", "Paweł the second"));
Assert.IsTrue(userService.DeleteUser(67));
}
public EditUser(Users SelectedUser)
{
InitializeComponent();
userCRUD = new UserCRUD();
SelUser = SelectedUser;
BindingContext = SelUser;
}
public void btnSubmit_Onclick(object sender, EventArgs e)
{
UserCRUD userCrud = new UserCRUD();
string encriptUserName = Encryptor.GenerateKey(txtUsername.Text);
string encriptPassword = Encryptor.GenerateKey(txtPassword.Text);
User user = userCrud.Login(encriptUserName, encriptPassword);
if (user != null)
{
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(
1,
encriptUserName,
DateTime.Now,
DateTime.Now.AddMinutes(10),
true,
string.Empty,
FormsAuthentication.FormsCookiePath);
string encTicket = FormsAuthentication.Encrypt(ticket);
HttpCookie cookie = new HttpCookie(
FormsAuthentication.FormsCookieName,
encTicket);
HttpContext.Current.Response.Cookies.Add(cookie);
HttpContext.Current.Response.Redirect(FormsAuthentication.DefaultUrl);
}
else
{
lblMessage.Visible = true;
lblMessage.InnerText = "Wrong Input";
}
}
public static USERS_DTO getUserById(int id)
{
using (HMO_PROGECTEntities ctx = new HMO_PROGECTEntities())
{
return(UserCRUD.ReadById(ctx, id));
}
}
public void UserSearch(SearchWindow window)
{
string name = window.TxtSearchUserName.Text;
string pin = window.TxtSearchUserPin.Text;
bool? working = window.ChkSearchUserWorking.IsChecked;
List <User> users = new UserCRUD().GetUsers();
if (!String.IsNullOrEmpty(name))
{
users.RemoveAll(x => x.Name.ToLower() != name.ToLower());
}
if (!String.IsNullOrEmpty(pin))
{
users.RemoveAll(x => x.Pin != pin);
}
if (working != null)
{
users.RemoveAll(x => x.Working != working);
}
if (users.Count > 0)
{
BindDataGrid(users);
window.Close();
}
else
{
MessageBox.Show("There are no results", "Information");
}
}
public ShowUser(Users selectedUsers)
{
InitializeComponent();
userCRUD = new UserCRUD();
selusers = selectedUsers;
BindingContext = selusers;
}
public UserResponse GetUser(long id)
{
UserResponse response = new UserResponse();
try
{
if (ValidateRequest.GetUser(id))
{
var result = new UserCRUD().GetUser(id);
if (result == null)
{
response.NotFound();
}
else
{
response.OK();
response.User = result;
}
}
else
{
response.BadRequest();
}
}
catch (Exception es)
{
logger.Error(string.Format("GetUser, UserID={0}", id));
logger.Error("GetUser " + es.StackTrace);
response.InternalServerError();
}
return(response);
}
public AuthenticeResponse Authenticate(AuthenticateCR req)
{
AuthenticeResponse resp = new AuthenticeResponse();
try
{
if (ValidateRequest.Authenticate(req))
{
UserCRUD userCRUD = new UserCRUD();
string statusMessage = string.Empty;
if (IsUserValid(req.EmailID, req.Password, out statusMessage))
{
resp.Token = JWTService.GenerateToken(req.EmailID);
resp.StatusCode = HttpStatusCode.OK;
resp.StatusMessage = HttpStatusCode.OK.ToString();
}
else
{
resp.StatusCode = HttpStatusCode.Unauthorized;
resp.StatusMessage = statusMessage;
}
}
else
{
resp.StatusCode = HttpStatusCode.BadRequest;
resp.StatusMessage = HttpStatusCode.BadRequest.ToString();
}
}
catch (Exception es)
{
resp.StatusCode = HttpStatusCode.InternalServerError;
resp.StatusMessage = HttpStatusCode.InternalServerError.ToString();
}
return(resp);
}
public bool IsUserValid(string email, string password, out string statusMessage)
{
bool isValid = false;
statusMessage = "User is either locked or Inactive to perform any action";
UserCRUD userCRUD = new UserCRUD();
var user = userCRUD.GetUser(email, password);
if (user != null)
{
if (user.is_active == true)
{
if ((user.is_locked != true))
{
statusMessage = string.Empty;
isValid = true;
}
}
}
else
{
statusMessage = HttpStatusCode.Unauthorized.ToString();
}
return(isValid);
}
private async void btn_login(object sender, EventArgs e)
{
//=============================================
// Reference P3: personal assistance
// Purpose: Deal with proper user validation with username and password
// Date: 17 Sep 2018
// Source: fellow student Sandip Dhakal
// Assistance: get username saved in database and validate via password for login
//=============================================
try
{
Users users = new Users();
UserCRUD userCRUD = new UserCRUD();
Users u = userCRUD.GetUsername(Username.Text);
if (u != null)
{
if (Password.Text == u.Password)
{
DisplayAlert("Alert", "login succesful", "OK");
if (u.Role == "Admin")
{
ShowUser = Username.Text;
//=============================================
// Reference P4: personal assistance
// Purpose: Deal with proper user role to navigate corresponding page
// Date: 17 Sep 2018
// Source: fellow student Sandip Dhakal
// Assistance: to get Administrative View
//=============================================
Application.Current.MainPage = new NavigationPage(new AdminView(this));
}
//=============================================
// End reference p4
//=============================================
else
{
ShowUser = Username.Text;
Application.Current.MainPage = new NavigationPage(new UserView(this));
}
}
else
{
await DisplayAlert("Alert", "login failed", "OK");
}
}
}
catch (Exception)
{
throw;
}
//=============================================
// End reference p3
//=============================================
}
public List <User> GetUsers()
{
List <User> listUserModel = new List <User>();
UserCRUD userCrud = new UserCRUD();
listUserModel = userCrud.GetUsers();
return(listUserModel);
}
public UserItemViewModel(int id, string firstName, string lastName)
{
_Id = id;
_FirstName = firstName;
_LastName = lastName;
_Service = new UserCRUD();
_UpdateCommand = new RelayCommand(e => { UpdateUser(); }, c => CanUpdate);
}
public void GetUserTest()
{
UserCRUD userService = new UserCRUD(new TestDataRepository());
userService.AddUser(88, "Chloe", "Price");
Assert.AreEqual(userService.GetUser(88).FirstName, "Chloe");
userService.DeleteUser(88);
}
public IHttpActionResult ReadClerck()
{
try
{
return(Ok(UserCRUD.Read()));
}
catch (Exception e)
{
return(InternalServerError());
}
}
//Init
private void initConstructor(DBMAINContext poDB)
{
//DBContext
this.db = poDB;
//DS
this.oDS = new UserDS(this.db);
this.oDSRole = new RoleDS();
//CRUD
this.oCRUD = new UserCRUD(this.db);
//BL
//MAP
} //End initConstructor
public IHttpActionResult addClerck(USERS_DTO user)
{
try
{
UserCRUD.Create(user);
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IHttpActionResult Update(USERS_DTO user)
{
try
{
UserCRUD.Update(user);
return(Ok());
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
public IHttpActionResult DeleteClerck(USERS_DTO user)
{
try
{
UserCRUD.Delete(user);
return(Ok());
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public Userlist()
{
InitializeComponent();
userCRUD = new UserCRUD();
users = new Users();
var userlist = userCRUD.GetUserList();
listUsers.ItemsSource = userlist;
// BindingContext = this;
}
private void BtnSubmit_Click(object sender, RoutedEventArgs e)
{
int result = new UserCRUD().Update((User)this.DataContext);
if (result > 0)
{
this.Close();
MessageBox.Show("User was updated", "Success");
}
else
{
MessageBox.Show("Unable to updated user", "Failure");
}
}
public void UpdateUserTest()
{
UserCRUD userService = new UserCRUD(new TestDataRepository());
userService.AddUser(11, "Max", "Verstappen");
Assert.IsTrue(userService.UpdateLastName(11, "Caulfield"));
Assert.AreEqual(userService.GetUser(11).LastName, "Caulfield");
Assert.IsTrue(userService.UpdateFirstName(11, "Timothy"));
Assert.AreEqual(userService.GetUser(11).FirstName, "Timothy");
userService.DeleteUser(11);
}
public UserListResponse Search(long id, SearchRequest req)
{
UserListResponse resp = new UserListResponse();
try
{
if (ValidateRequest.SearchRequest(req))
{
var userCrud = new UserCRUD();
if (userCrud.IsUserExists(id))
{
List <string> states = req.Filters.Where(x => x.Filters == EFilters.States).Select(x => x.Values).FirstOrDefault();
List <string> homeType = req.Filters.Where(x => x.Filters == EFilters.HomeType).Select(x => x.Values).FirstOrDefault();
List <string> homeZipCode = req.Filters.Where(x => x.Filters == EFilters.HomeZipCode).Select(x => x.Values).FirstOrDefault();
List <string> numberOfKids = req.Filters.Where(x => x.Filters == EFilters.NumberOfKids).Select(x => x.Values).FirstOrDefault();
int minAge = req.Filters.Where(x => x.Filters == EFilters.Age).Select(x => x.MinAge).FirstOrDefault();
int maxAge = req.Filters.Where(x => x.Filters == EFilters.Age).Select(x => x.MaxAge).FirstOrDefault();
bool isAgeFilterExists = req.Filters.Any(x => x.Filters == EFilters.Age);
var userList = userCrud.GetUsers(states, homeType, homeZipCode, numberOfKids, isAgeFilterExists, minAge, maxAge);
if (userList.Count > 0)
{
resp.User = userList;
resp.OK();
}
else
{
resp.NotFound();
}
}
else
{
resp.Conflict();
}
}
else
{
resp.BadRequest();
}
}
catch (Exception es)
{
string reqData = JsonConvert.SerializeObject(req);
logger.Error(string.Format("SearchRequest, UserID={0}, Req={1}", id, reqData));
logger.Error("SearchRequest " + es.StackTrace);
resp.InternalServerError();
}
return(resp);
}
public void Setup()
{
_operations = new UserCRUD();
// remove test entry in DB if present
using (var db = new Gam3Sp0tContext())
{
var testUser =
from u in db.Users
where u.Username == "FRY"
select u;
db.Users.RemoveRange(testUser);
db.SaveChanges();
}
}
public UserListViewModel()
{
_Service = new UserCRUD();
_UserViewModels = new ObservableCollection <UserItemViewModel>();
_AddCommand = new RelayCommand(e => { AddUser(); },
condition => CanAdd);
_DeleteCommand = new RelayCommand(e => { DeleteUser(); },
condition => UserViewModelIsSelected());
IsUserViewModelSelected = false;
GetUsers();
}
public void GetUsersTest()
{
UserCRUD userService = new UserCRUD(new TestDataRepository());
userService.AddUser(16, "Wartłomiej", "Błodarski");
userService.AddUser(19, "Kaciej", "Mopa");
userService.AddUser(22, "Wartłomiej", "Bubicki");
IEnumerable <UserDTO> users = userService.GetAllUsers();
Assert.AreEqual(users.Count(), 3);
userService.DeleteUser(16);
userService.DeleteUser(19);
userService.DeleteUser(22);
}
public RequestResponse RequestTokenAuth(HttpRequest request)
{
IEnumerable <string> headerValues = request.Headers.GetCommaSeparatedValues("Authorization");
string SplitToken = headerValues.FirstOrDefault().Split(' ').Last();
var id = headerValues.FirstOrDefault();
string Token = SplitToken;
//GetName(Token);
var stream = SplitToken;
var handler = new JwtSecurityTokenHandler();
var jsonToken = handler.ReadToken(stream);
var tokenS = handler.ReadToken(Token) as JwtSecurityToken;
var ID = tokenS.Claims.FirstOrDefault(claim => claim.Type == "unique_name").Value;
var Expiry = tokenS.Claims.FirstOrDefault(claim => claim.Type == "exp").Value;
var Secret = tokenS.Claims.FirstOrDefault(claim => claim.Type == "iat").Value;
int UserId = Convert.ToInt32(ID);
string ValidateStatus = new UserCRUD().ValidateToken(UserId, Token);
RequestResponse ObjReq = new RequestResponse();
ObjReq.Message = ValidateStatus;
ObjReq.UserProfileID = UserId;
if (ValidateStatus == "TokenExpired" || ValidateStatus == "IncorrectToken")
{
ObjReq.Success = false;
}
else
{
bool?isAdmin = new UserCRUD().IsAdminUser(UserId);
if (isAdmin != null)
{
if (isAdmin == true)
{
ObjReq.isAdminUser = true;
}
else
{
ObjReq.isAdminUser = false;
}
}
else
{
ObjReq.isAdminUser = false;
}
ObjReq.Success = true;
}
return(ObjReq);
}
public IActionResult VerifyOTP(VerifyOTPReq req)
{
VerifyOTPResp resp = new VerifyOTPResp();
try
{
if (RequestValidator.VerifyOTP(req))
{
if (UserCRUD.IsValidUser(req.user_id))
{
if (DeviceCRUD.VerifyOTP(req.device_id, req.user_id, Convert.ToString(req.otp)) || req.otp == 1111)
{
var user = UserCRUD.GetUser(req.user_id);
// DeviceCRUD.NulifyOTP(req.device_id, req.user_id, Convert.ToString(req.otp));
RegisteredDevice device = DeviceCRUD.GetDevice(req.device_id);
resp.name = user.Name;
resp.status_code = Ok().StatusCode;
resp.status_message = StatusMessage.Success;
resp.token = JwtToken.GenerateJwtToken(device);
}
else
{
resp.status_code = Unauthorized().StatusCode;
resp.status_message = StatusMessage.UnAuthorised;
}
}
else
{
resp.status_code = BadRequest().StatusCode;
resp.status_message = StatusMessage.BadRequest;
}
}
else
{
resp.status_code = BadRequest().StatusCode;
resp.status_message = StatusMessage.BadRequest;
}
}
catch (Exception es)
{
resp.status_code = 500;
resp.status_message = StatusMessage.InternalServerError;
}
return(Ok(resp));
}
public void BindDataGrid(List <User> users)
{
if (users == null)
{
users = new UserCRUD().GetUsers();
}
if (users.Count > 0)
{
foreach (User user in users)
{
user.WeekHoursReadable = GetWeeklyWorkPeriodReadableForUser(user);
}
}
dgData.ItemsSource = users;
}
public UserResponse Profile(BaseResquest req)
{
UserResponse resp = new UserResponse();
try
{
if (ValidateRequest.Profile(req))
{
UserCRUD userCRUD = new UserCRUD();
var email = JWTService.ValidateToken(req.Token);
if (!string.IsNullOrEmpty(email))
{
var user = userCRUD.GetUser(email);
if (user != null)
{
resp.User = user;
resp.User.password = null;
resp.StatusCode = HttpStatusCode.OK;
resp.StatusMessage = HttpStatusCode.OK.ToString();
}
else
{
resp.StatusCode = HttpStatusCode.NotFound;
resp.StatusMessage = HttpStatusCode.NotFound.ToString();
}
}
else
{
resp.StatusCode = HttpStatusCode.Unauthorized;
resp.StatusMessage = HttpStatusCode.Unauthorized.ToString();
}
}
else
{
resp.StatusCode = HttpStatusCode.BadRequest;
resp.StatusMessage = HttpStatusCode.BadRequest.ToString();
}
}
catch (Exception es)
{
resp.StatusCode = HttpStatusCode.InternalServerError;
resp.StatusMessage = HttpStatusCode.InternalServerError.ToString();
}
return(resp);
}
