protected void ResetPassword_Click(object sender, EventArgs e)
{
Mode = ViewMode.Reset;
var email = Request["email"].ToString();
var user = UsersMapper.GetByEmailAddress(email);
if (user == null)
{
ResetServerMessage.Text = $"<div class='alert alert-danger' role='alert'>Cannot find an account for email address: {email}</div>";
return;
}
if (user.ResetCode != ResetCode.Text || user.ResetCodeIssueDate == null || ((DateTime)user.ResetCodeIssueDate).AddDays(1) < DateTime.Now)
{
ResetServerMessage.Text = $"<div class='alert alert-danger' role='alert'>The Reset Code you entered is incorrect or has expired</div>";
return;
}
var returnObj = user.SetPassword(NewPassword.Text);
if (!returnObj.IsError)
{
ResetServerMessage.Text = $"<div class='alert alert-success' role='alert'>Password for email address '{user.EmailAddress}' has been reset</div>";
EmailHelper.Send(AppSettings.SystemEmailAddress, EmailHelper.GetMailAddressesFromString(user.EmailAddress), "Password has been reset", "Your password was successfully reset for: " + URIHelper.BaseUrl);
user.ResetCode = "";
returnObj = UsersMapper.Update(user);
}
else
{
ResetServerMessage.Text = $"Error resetting password: { returnObj.Error.Exception.Message }";
}
}
public HttpResponseMessage RegisterUser(UserRegisterModel userToRegister)
{
UserValidator.ValidateAuthCode(userToRegister.AuthCode);
UserValidator.ValidateNickname(userToRegister.Nickname);
UserValidator.ValidateUsername(userToRegister.Username);
User newUser = null;
try
{
newUser = UsersMapper.ToUserEntity(userToRegister);
}
catch (Exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid user register model provided!"));
}
usersRepository.Add(newUser);
User inDbUser = this.usersRepository.GetByUsernameAndAuthCode(newUser.Username, newUser.AuthCode);
inDbUser.SessionKey = UserValidator.GenerateSessionKey(inDbUser.ID);
this.usersRepository.Update(inDbUser.ID, inDbUser);
UserLoggedModel loggedUser = new UserLoggedModel()
{
Nickname = inDbUser.Nickname,
SessionKey = inDbUser.SessionKey
};
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, loggedUser);
response.Headers.Location = new Uri(Url.Link("NewsApi", new { sessionKey = loggedUser.SessionKey }));
return(response);
}
public ActionResult Create()
{
ViewBag.Filters = FiltersMapper.MapRange(_photosService.Filters);
//ViewBag.Tags = _tagsMapper.MapRange(_photosService.Tags);
return(View(UsersMapper.Map(_currentUserService.GetDTO)));
}
public HttpResponseMessage LoginUser([FromBody] UserLoginModel user)
{
HttpResponseMessage responseMessage = this.PerformOperation(() =>
{
UserValidator.ValidateUsername(user.Username);
UserValidator.ValidateAuthenticationCode(user.AuthCode);
using (var context = this.ContextFactory.Create())
{
var userEntity = context.Set <User>().FirstOrDefault(
u => u.AuthCode == user.AuthCode && u.Username == user.Username.ToLower());
if (userEntity == null)
{
throw new InvalidOperationException("User not registered!");
}
userEntity.SessionKey = UserValidator.GenerateSessionKey(userEntity.ID);
context.SaveChanges();
UserLoggedModel loggedUser = UsersMapper.ToModel(userEntity);
return(this.Request.CreateResponse(HttpStatusCode.Created, loggedUser));
}
});
return(responseMessage);
}
public IActionResult Patch(int key, [FromBody] Delta <User> delta)
{
IEnumerable <string> invalidPropertyNames = delta.GetChangedPropertyNames().Except(new[]
{
"Email", "Profile"
});
if (invalidPropertyNames.Any())
{
foreach (string propertyName in invalidPropertyNames)
{
return(BadRequest(propertyName + " : This field is not allowed to be updated."));
}
}
var entity = _userRepository.GetByKey(key);
if (entity == null)
{
return(NotFound());
}
var map = new UsersMapper();
var model = map.FromEntity(entity);
delta.Patch(model);
var userEntity = map.ToEntity(model, entity);
_userRepository.Update(userEntity);
_userRepository.Save();
return(Ok());
}
public HttpResponseMessage RegisterUser([FromBody] UserRegisterModel user)
{
HttpResponseMessage responseMessage = this.PerformOperation(() =>
{
UserValidator.ValidateUsername(user.Username);
UserValidator.ValidateDisplayName(user.DisplayName);
UserValidator.ValidateAuthenticationCode(user.AuthCode);
using (var context = this.ContextFactory.Create())
{
User exstingUserEntity = context.Set <User>().FirstOrDefault(
u => u.Username == user.Username.ToLower() || u.DisplayName.ToLower() == user.DisplayName.ToLower());
if (exstingUserEntity != null)
{
throw new InvalidOperationException("User already exists!");
}
User newUserEntity = UsersMapper.ToEntity(user);
context.Set <User>().Add(newUserEntity);
context.SaveChanges();
newUserEntity.SessionKey = UserValidator.GenerateSessionKey(newUserEntity.ID);
context.SaveChanges();
UserLoggedModel loggedUser = UsersMapper.ToModel(newUserEntity);
return(this.Request.CreateResponse(HttpStatusCode.Created, loggedUser));
}
});
return(responseMessage);
}
//POST api/users/register
public IHttpActionResult Register(UserDto input)
{
if (!input.Validate())
{
return(BadRequest("Popunite sve podatke"));
}
//provjeri jel ima vec neki email ili username
if (_userRepo.Single(x => x.Email.Equals(input.Email) || x.UserName.Equals(input.UserName)) != null)
{
return(BadRequest("Postoji vec user s podatcima email/username"));
}
User user = UsersMapper.MapUserDtoToUser(input);
City city = _userRepo.FindCity(input.CityName);
if (city == null)
{
return(BadRequest("Grad ne postoji"));
}
user.City = city;
_userRepo.Add(user);
return(Ok());
////init all ratings
//List<Sport> sports = _userRepo.GetAllSports().ToList();
//user.Ratings = new List<Rating>();
//foreach(Sport s in sports)
//{
// user.Ratings.Add(new Rating() { Sport = s, Value = 0 });
//}
//_userRepo.Add(user);
//return Ok();
}
public UserController()
{
_UsersBusinessLogic = new UsersBusinessLogic();
_AccountsBusinessLogic = new AccountsBusinessLogic();
_LookupsBusinessLogic = new LookupsBusinessLogic();
mapper = new UsersMapper();
}
public ActionResult <Response <Users> > ValidateUser([FromQuery] string user, [FromQuery] string password)
{
if (user == null)
{
user = "";
}
if (password == null)
{
password = "";
}
var hashpass = CommonFunctions.GetSHA256(password);
Users users = UsersMapper.ValidateUser(user, hashpass);
var rtn = new Response <Users>();
rtn.Item = users;
if (users != null)
{
rtn.Message = "Usuario recuperado con Exito";
rtn.MessageType = MessageType.OK;
}
else
{
rtn.Message = "Usuario o Password no Validos";
rtn.MessageType = MessageType.Alert;
}
return(Ok(rtn));
}
public void UpdateFieldsFromObject()
{
MediaDetailID.Text = selectedItem.ID.ToString();
MediaID.Text = selectedItem.MediaID.ToString();
Handler.SetValue(selectedItem.Handler);
MediaTypeID.Text = selectedItem.MediaTypeID.ToString();
MediaType.Text = MediaTypesMapper.GetByID(selectedItem.MediaTypeID).Name.ToString();
EnableCaching.Checked = selectedItem.EnableCaching;
if (selectedItem.LastUpdatedByUserID != 0)
{
LastModifiedByUser.Text = UsersMapper.GetByID(selectedItem.LastUpdatedByUserID).UserName;
}
if (selectedItem.CreatedByUserID != 0)
{
CreatedByUser.Text = UsersMapper.GetByID(selectedItem.CreatedByUserID).UserName;
}
if (selectedItem.ID != 0)
{
OrderIndex.Text = MediasMapper.GetByMediaDetail(selectedItem).OrderIndex.ToString();
}
MasterPageSelector.SelectedValue = selectedItem.MasterPageID.ToString();
}
public UsersViewModel GetUserByEmailWithoutDecryption(string email)
{
using (var usersRep = UnitOfWork.UsersRepository)
{
var usersModel = usersRep.Where(x => x.Email == email && x.IsDeleted == false).FirstOrDefault() ??
new Users();
return(UsersMapper.MapModelToViewModel(usersModel));
}
}
public bool Run(NgTableParams model, ref IQueryable <User> repository, NgTable <UserViewModel> result, ICoreUser user, IUnitOfWork db)
{
var ngTransformer = new QueryToNgTable <UserViewModel>();
var query = UsersMapper.MapDbModelQueryToViewModelQuery(repository);
ngTransformer.ToNgTableDataSet(model, query, result);
return(true);
}
public ObjectResult Create(UserItem user)
{
var userItem = UsersMapper.MapToCommon(user);
var result = _UsersManager.CreateUser(userItem);
var userObject = UsersMapper.MapToDto(result);
return(Ok(userObject));
}
public ObjectResult Update(string id, UserItem user)
{
var userItem = UsersMapper.MapToCommon(user);
var result = _UsersManager.UpdateUser(id, userItem);
var userObject = UsersMapper.MapToDto(result);
return(Ok(userObject));
}
public override bool ValidateUser(string username, string password)
{
var user = new UsersMapper().SelectToLogin(username, password);
if (user != null)
{
return(true);
}
return(false);
}
public ActionResult Details(string userName)
{
UserViewModel item = UsersDetailsMapper.Map(_usersService.Get(userName));
if (User.Identity.IsAuthenticated)
{
ViewBag.CurrentUser = UsersMapper.Map(_currentUserService.GetDTO);
}
return(View(item));
}
public async Task <ActionResult> Details(int id)
{
PhotoViewModel item = PhotosMapper.Map(await _photosService.GetAsync(id));
if (User.Identity.IsAuthenticated)
{
ViewBag.CurrentUser = UsersMapper.Map(_currentUserService.GetDTO);
}
return(View(item));
}
public override string[] GetRolesForUser(string username)
{
Users user = new UsersMapper().SelectUser(username);
if (user == null)
{
return(new string[] { });
}
return(new string[] { user.Type });
}
public override bool IsUserInRole(string username, string roleName)
{
Users user = new UsersMapper().SelectUser(username);
if (user == null)
{
return(false);
}
return(roleName == user.Type);
}
public ActionResult Details(string name)
{
TagViewModel item = TagsMapper.Map(_tagsService.Get(name));
if (User.Identity.IsAuthenticated)
{
ViewBag.CurrentUser = UsersMapper.Map(_currentUserService.GetDTO);
}
return(View(item));
}
public Return SendNotificationToAdministrators(string message, string subject, List <User> toAdministrators = null)
{
if (toAdministrators == null)
{
toAdministrators = new List <User>();
}
toAdministrators.AddRange(UsersMapper.GetAllByRoleEnum(RoleEnum.Administrator));
return(SendEmailToUsers(toAdministrators, subject, message));
}
public bool Run(UserViewModel model, IUnitOfWork unitOfWork, Response <UserViewModel> result, ICoreUser user)
{
var newCustom = UsersMapper.MapInsertModelToDbModel(model);
unitOfWork.With <User>().Add(newCustom);
unitOfWork.SaveChanges();
var newCustomResult = UsersMapper.MapDbModelToViewModel(newCustom);
result.Body = newCustomResult;
return(true);
}
/// <summary>
/// Helps map user entity to user data transfer object.
/// </summary>
protected UserDTO MapUser(User user)
{
User currentUser = _currentUserService.Get;
return(UsersMapper.Map(
user,
_unitOfWork.Confirmations.Find(c => c.UserId == user.Id).FirstOrDefault() != null,
_unitOfWork.Followings.Find(f => f.FollowedUserId == user.Id && f.UserId == currentUser.Id).FirstOrDefault() != null,
_unitOfWork.Blockings.Find(b => b.BlockedUserId == user.Id && b.UserId == currentUser.Id).FirstOrDefault() != null,
_unitOfWork.Blockings.Find(b => b.BlockedUserId == currentUser.Id && b.UserId == user.Id).FirstOrDefault() != null
));
}
public bool Run(UserViewModel model, ref IQueryable <User> repository, IUnitOfWork unitOfWork, Response <UserViewModel> result, ICoreUser user)
{
var dbModel = repository.Single(c => c.Id == model.Id); // you need to be using the primary key could be composit
var updatedDbModel = UsersMapper.MapInsertModelToDbModel(model, dbModel);
unitOfWork.With <User>().Update(updatedDbModel);
unitOfWork.SaveChanges();
var newCustomResult = UsersMapper.MapDbModelToViewModel(updatedDbModel);
result.Body = newCustomResult;
return(true);
}
private Return SendNotificationEmails(User user)
{
var admins = UsersMapper.GetAllByRole(RolesMapper.GetByEnum(RoleEnum.Administrator));
var adminEmails = new List <MailAddress>();
foreach (var admin in admins)
{
adminEmails.Add(new MailAddress(admin.EmailAddress));
}
return(EmailHelper.SendTemplate(adminEmails, "A new account was created at " + URIHelper.BaseUrl,
AppSettings.SystemName, AppSettings.SystemEmailAddress,
"~/Controls/EmailTemplates/CreateAccount/Notification.ascx", user));
}
//GET api/events/getevent
public IHttpActionResult GetEvent(int id)
{
Event ev = _eventRepo.Single(x => x.Id == id);
if (ev == null)
{
return(BadRequest("event ne postoji"));
}
List <UserDto> participants = UsersMapper.MapUserToUserDto(ev.Participants.ToList(), ev.Sport.Id);
participants.Add(UsersMapper.MapUserToUserDto(ev.Creator));
EventParticipantsDto result = EventMapper.MapEventsToEventParticipantsDto(ev, participants);
return(Ok(result));
}
//GET api/users/getbyid
public IHttpActionResult GetById(int?id)
{
if (id == null)
{
return(BadRequest());
}
User user;
user = _userRepo.GetById((int)id);
if (user == null)
{
return(NotFound());
}
return(Ok(UsersMapper.MapUserToUserDto(user)));
}
//POST api/users/login
public IHttpActionResult Login(UserDto input)
{
if (input.UserName == null || input.Password == null)
{
return(BadRequest());
}
User user;
user = _userRepo.Single(x => (x.UserName.Equals(input.UserName)) && (x.Password.Equals(input.Password)));
if (user == null)
{
return(Unauthorized());
}
return(Ok(UsersMapper.MapUserToUserDto(user)));
}
static void Main(string[] args)
{
User u;
u = new UsersMapper().Select(4);
u.DietPlans = new DietPlanMapper().SelectUserDietPlans(u.Userid, DateTime.Parse("8.12.2018").Date);
foreach (DietPlan dp in u.DietPlans)
{
Console.WriteLine(dp.Dpid);
}
}
protected void DeleteUser_Click(object sender, EventArgs e)
{
var id = ((LinkButton)sender).CommandArgument;
if (!string.IsNullOrEmpty(id))
{
IEnumerable <UserMedia> selectedUserMediaDetails = new List <UserMedia>();
if (ItemList.SelectedValue != null)
{
selectedUserMediaDetails = UsersMediasMapper.GetByUser(UsersMapper.GetByID(long.Parse(ItemList.SelectedValue.ToString())), selectedItem);
}
HandleDelete(selectedUserMediaDetails);
}
}
