public async Task <IActionResult> CreateDoctor()
{
TempUser foundTempUser = (from tmpUsr in _db.TempUser where tmpUsr.Pesel == TempUser.Pesel select tmpUsr).FirstOrDefault();
User foundUser = (from usr in _db.User where usr.Pesel == TempUser.Pesel select usr).FirstOrDefault();
if (foundTempUser != null || foundUser != null)
{
_flasher.Flash(Types.Danger, "Lekarz o podanym numer PESEL już istnieje.", dismissable: true);
}
else if (!PeselChecksum(TempUser.Pesel))
{
_flasher.Flash(Types.Danger, "Podany pesel jest nieprawidłowy.", dismissable: true);
}
else
{
await _db.TempUser.AddAsync(TempUser);
await _db.SaveChangesAsync();
_flasher.Flash(Types.Success, "Pomyślnie zarejestrowano lekarza.", dismissable: true);
}
return(RedirectToAction("RegisterDoctor"));
}
public virtual async Task <IActionResult> ResendValidation([FromBody] ResendValidateUser tempUser)
{
var user = _context.Users.FirstOrDefault(u => u.Id == tempUser.Id);
if (user == null)
{
// Our response is vague to avoid leaking information
return(ResponseShell.Error("Could not find an account with that information"));
}
if (!string.IsNullOrWhiteSpace(tempUser.Email) && !user.ValidatedEmail)
{
Log.Information("Sending Email Validation to {user}", tempUser.Email);
var temp = new TempUser(user);
await _validation.SendValidationToEmail(temp);
_memoryCache.SetForChallenge(temp);
}
if (!string.IsNullOrWhiteSpace(tempUser.PhoneNumber) && !user.ValidatedSms)
{
tempUser.PhoneNumber = tempUser.PhoneNumber.CleanPhone();
Log.Information("Sending SMS Validation to {user}", tempUser.PhoneNumber);
var temp = new TempUser(user);
await _validation.SendValidationToSms(temp);
_memoryCache.SetForChallenge(temp);
}
return(ResponseShell.Ok());
}
public IHttpActionResult PutTempUser(int id, TempUser tempUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != tempUser.EmployeeID)
{
return(BadRequest());
}
db.Entry(tempUser).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!TempUserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public static void RegisterSendEmail(TempUser user)
{
if (user == null)
{
return;
}
using (var _context = new DiemServiceDB())
{
_context.TempUserDbSet.Add(user);
_context.SaveChanges();
}
MailMessage mail = new MailMessage();
SmtpClient SmtpServer = new SmtpClient("smtp.gmail.com");
mail.From = new MailAddress("*****@*****.**");
mail.To.Add(user.Email);
mail.Subject = "User activation email";
mail.Body = "Click this link to activate email: " + "localhost:4200/ActivateUser/" + user.ActivationLink;
SmtpServer.Port = 587;
SmtpServer.Credentials = new System.Net.NetworkCredential("*****@*****.**", "web2projekat2020");
SmtpServer.EnableSsl = true;
SmtpServer.Send(mail);
}
public async Task <IActionResult> Create([Bind("Id,UserName,UserPhoneNo,UserPassword,IsModerator,Latitude,Longitude,RandOTP")] TempUser tempUser)
{
var currentuser = _context.Users.FirstOrDefault(n => n.UserPhoneNo == tempUser.UserPhoneNo);
if (currentuser != null)
{
ModelState.AddModelError("UserPhoneNo", "Phone number already registered.Login to your account");
return(View(tempUser));
}
if (TempData["UserType"].ToString() == "Moderator")
{
tempUser.IsModerator = true;
}
else
{
tempUser.IsModerator = false;
}
var randOTP = util.GenerateRandomOTP(4, new string[] { "1", "2", "3", "4", "5", "6", "7", "8", "9", "0" });
tempUser.RandOTP = randOTP;
if (ModelState.IsValid)
{
_context.Add(tempUser);
await _context.SaveChangesAsync();
SendOTPToUser(tempUser.UserPhoneNo, tempUser.RandOTP);
return(RedirectToAction("Edit", "Register", new { id = tempUser.Id }));
}
//var query = from state in ModelState.Values
// from error in state.Errors
// select error.ErrorMessage;
//var errors = query.ToArray();
return(View(tempUser));
}
public async Task <string> SendValidationToEmail(TempUser model)
{
var token = SetToken(model, TokenType.EmailToken);
var emailMessage = new MimeMessage();
emailMessage.From.Add(new MailboxAddress(_config.Email.Validation.Address));
emailMessage.To.Add(new MailboxAddress(model.Email));
emailMessage.Subject = "Cal-Notify Validation Link";
var path = Path.Combine(_hostingEnv.ContentRootPath, "Templates", "email_validation.hbs");
var template = File.ReadAllText(path);
var verificationTemplate = Handlebars.Compile(template);
var data = new
{
name = model.Name ?? model.Email,
tokenurl = GetTokenUrl(model),
helpurl = $"{_config.Urls.Frontend.Trim('/')}/{_config.Pages.HelpPage}"
};
var builder = new BodyBuilder();
builder.HtmlBody = verificationTemplate(data);
emailMessage.Body = builder.ToMessageBody();
await SendEmail(emailMessage);
return(token);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
if (UserID != null)
{
string ImageUrl = string.Empty;
string SitePath = ConfigurationManager.AppSettings["SitePath"].ToString();
TempUser _GetUser = new TempUser().GetUserDetails(UserID);
if (_GetUser != null)
{
if (_GetUser.ProfilePhoto != null)
{
userPicture.Src = new Utils().GetPhotoPCTPath(_GetUser.ProfilePhoto.PhotoID, Request);
}
else
{
if (_GetUser.Gender == 1)
{
userPicture.Src = SitePath + "web/images/M.png";
}
else
{
userPicture.Src = SitePath + "web/images/F.png";
}
}
}
}
}
}
public void TransferData()
{
try
{
List <User> data = _context.Users.ToList();
for (int i = 0; i < data.Count; i++)
{
User user = data[i];
var tempUser = _context.TempUsers.Where(x => x.Name == data[i].Name).FirstOrDefault();
if (tempUser == null)
{
TempUser temp = new TempUser()
{
Name = data[i].Name,
Contect = data[i].Contect,
Date = DateTime.Now
};
_context.TempUsers.Add(temp);
_context.SaveChanges();
}
}
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> RegisterDoctor()
{
ViewBag.AllDoctors = await _db.User.ToListAsync();
TempUser = new TempUser();
return(View(TempUser));
}
private void RellenarUsuario(ref TempUser userTemp)
{
userTemp.IdUser = (int)spIdUsuario.Value;
userTemp.UserName = txtUserName.Text;
userTemp.Password = txtPassword.Text;
userTemp.IdEmployee = (int)cbEmpleado.SelectedValue;
userTemp.Status = true;
}
public ActionResult Validate(TempUser temp)
{
tem = new Models.TempUser {
Name = temp.name, Password = temp.password, stationId = temp.stationID.Value, Role = temp.role
};
ViewBag.temp = tem;
return(View());
}
public ActionResult Create(Models.TempUser temp)
{
int stationid = (int)Session["StationId"];
TempUser tempuser = new TempUser { stationID = stationid, name = temp.Name, password = temp.Password, accountCreated = false,role=temp.Role };
db.TempUsers.Add(tempuser);
db.SaveChanges();
return RedirectToAction("Index", "stations");
}
private string SetToken(TempUser model, TokenType tokenType)
{
var guid = Guid.NewGuid().ToString();
// Cant forget to set our token
model.Token = guid;
model.TokenType = tokenType;
return(guid);
}
public ActionResult CleanTempUser()
{
TempUser tp = db.TempUsers.ToList()[0];
User us = db.Users.Find(tp.tempuser_id);
db.Users.Remove(us);
db.TempUsers.Remove(tp);
db.SaveChanges();
return(RedirectToAction("CreateEmployee", "Create"));
}
public async Task <IActionResult> Put(string id, [FromBody] TempUser tempUserFromRequest)
{
var user = userManager.FindByIdAsync(id).Result;
user.Type = (UserType)tempUserFromRequest.Rank;
await userManager.UpdateAsync(user);
return(NoContent());
}
public ActionResult Create(Models.TempUser temp)
{
int stationid = (int)Session["StationId"];
TempUser tempuser = new TempUser {
stationID = stationid, name = temp.Name, password = temp.Password, accountCreated = false, role = temp.Role
};
db.TempUsers.Add(tempuser);
db.SaveChanges();
return(RedirectToAction("Index", "stations"));
}
public virtual void SetForChallenge(TempUser model)
{
// Hold our token and model for a while to give our user a chance to validate their info
if (string.IsNullOrEmpty(model.Token))
{
throw new Exception("Should always recieve a token");
}
var copy = model.ShallowCopy();
_cache.Set(model.Token, copy, TimeSpan.FromMinutes(5));
}
//private readonly TeamCellContext _dbContext = new TeamCellContext();
//public UserController(TeamCellContext dbContext)
//{
// _dbContext = dbContext;
//}
private User convertToUser(TempUser userTmp)
{
var user = new User();
user.UserName = userTmp.UserName;
user.Salt = Cryptographic.GenerateSalt();
user.Password = Cryptographic.HashPasswordWithSalt(Encoding.UTF8.GetBytes(userTmp.Password), user.Salt);
user.IdEmployee = userTmp.IdEmployee;
user.Status = userTmp.Status;
return(user);
}
public IHttpActionResult GetTempUser(int id)
{
TempUser tempUser = db.TempUsers.Find(id);
if (tempUser == null)
{
return(NotFound());
}
return(Ok(tempUser));
}
private string SetShortToken(TempUser model, TokenType tokenType)
{
var r = new Random((int)DateTime.Now.Ticks);
// Generate four-digit token
var token = r.Next(1000, 9999).ToString();
// Cant forget to set our token
model.Token = token;
model.TokenType = tokenType;
return(token);
}
public IHttpActionResult PostTempUser(TempUser tempUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.TempUsers.Add(tempUser);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = tempUser.EmployeeID }, tempUser));
}
public Address(TempUser user)
{
Number = user.Number;
Street = user.Street;
State = user.State;
Zip = user.Zip;
City = user.City;
FormattedAddress = user.FormattedAddress;
GeoLocation = new PostgisPoint(user.Longitude, user.Latitude)
{
SRID = Constants.SRID
};
}
public IHttpActionResult DeleteTempUser(int id)
{
TempUser tempUser = db.TempUsers.Find(id);
if (tempUser == null)
{
return(NotFound());
}
db.TempUsers.Remove(tempUser);
db.SaveChanges();
return(Ok(tempUser));
}
public int InsertTemp(string Username, string Password, string ip, string Certificate, DateTime created)
{
DataClasses1DataContext classes1DataContext = new DataClasses1DataContext();
TempUser entity = new TempUser();
entity.Username = Username;
entity.Password = Password;
entity.Ip = ip;
entity.Certificate = Certificate;
entity.DateCreated = new DateTime?(created);
classes1DataContext.TempUsers.InsertOnSubmit(entity);
classes1DataContext.SubmitChanges();
return(entity.ID);
}
public HttpResponseMessage updateUser(TempUser pUser)
{
using (PRINCE_STGEntities entPrince = new PRINCE_STGEntities())
{
User user = entPrince.User.Where(wr => wr.Code == pUser.Code).SingleOrDefault();
user.FirstName = pUser.FirstName;
user.LastName = pUser.LastName;
user.EmailAdd = pUser.EmailAdd;
user.Status = pUser.Status;
entPrince.Entry(user).State = EntityState.Modified;
entPrince.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, "User successfully updated!"));
}
}
public TempUser Get(string id)
{
TempUser resultUser = new TempUser();
var allUsersFromUserManager = userManager.Users;
foreach (var user in allUsersFromUserManager)
{
if (user.Id == id)
{
resultUser.Id = user.Id;
resultUser.FirstName = user.FirstName;
resultUser.LastName = user.LastName;
resultUser.Rank = (int)user.Type;
}
}
return(resultUser);
}
public bool addUser(TempUser userTmp)
{
try
{
using (TeamCellContext _dbContext = new TeamCellContext())
{
User user = convertToUser(userTmp);
_dbContext.User.Add(user);
_dbContext.SaveChanges();
return(true);
}
}
catch (Exception)
{
return(false);
}
}
public virtual async Task <string> SendValidationToSms(TempUser model)
{
var token = SetShortToken(model, TokenType.SmsToken);
var path = Path.Combine(_hostingEnv.ContentRootPath, "Templates", "sms_validation.hbs");
var template = File.ReadAllText(path);
var verificationTemplate = Handlebars.Compile(template);
var data = new
{
url = GetTokenUrl(model),
name = model.Name ?? "hello"
};
await SendMessage(model.PhoneNumber, verificationTemplate(data));
return(token);
}
public ActionResult Login(String UserName, String Password, String returnUrl)
{
TempUser temp = null;
//db.TempUsers.Where(c => c.name == logindata.UserName && c.password == logindata.Password).First();
if (temp == null && WebSecurity.Login(UserName, Password, true))
{
if (Roles.GetRolesForUser(UserName).Any())
{
if (!(Roles.GetRolesForUser(UserName)[0].Equals("Administrator") || Roles.GetRolesForUser(UserName)[0].Equals("PhoneUser")))
{
int userid = db.UserProfiles.Where(m => m.UserName.Equals(UserName)).First().UserId;
int stationId = db.StationUsers.Where(c => c.UserId == userid).First().StationId.Value;
byte[] logo = db.stations.Where(c => c.id == stationId).First().logo;
Session["Logo"] = logo;
Session["UserId"] = userid;
Session["StationId"] = stationId;
return(RedirectToAction("Index", "stations"));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
//if (returnUrl != null)
//{
// return RedirectToAction(returnUrl);
//}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else if (temp != null)
{
TempUserController con = new TempUserController();
return(RedirectToAction("Validate", "TempUser", temp));
}
else
{
ModelState.AddModelError("", "Sorry invalid username or password");
return(View());
}
}
public HttpResponseMessage saveUser(TempUser pUser)
{
using (PRINCE_STGEntities entPrince = new PRINCE_STGEntities())
{
int lastIdNo = (from u in entPrince.User.OrderByDescending(p => p.Id) select u.Id).FirstOrDefault();
User user = new User();
user.Code = lastIdNo + 1;
user.FirstName = pUser.FirstName;
user.LastName = pUser.LastName;
user.EmailAdd = pUser.EmailAdd;
user.Status = pUser.Status;
user.Password = "******";
user.STORE_CODE = pUser.STORE_CODE;
entPrince.User.Add(user);
entPrince.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, "User successfully save!"));
}
}
public static void ActivateUser(string actId)
{
using (var _context = new DiemServiceDB())
{
TempUser toAdd = _context.TempUserDbSet.Where(s => s.ActivationLink == actId).FirstOrDefault();
if (toAdd == null)
{
throw new Exception("Activation link expired or wrong");
}
User toInjectPoison = _context.UserDbSet.Add(new User(toAdd));
RegisteredUser dumbshit = _context.RegisteredUserDbSet.Add(new RegisteredUser());
_context.SaveChanges();
toInjectPoison.UlogaID = dumbshit.Id;
_context.TempUserDbSet.Remove(toAdd);
_context.SaveChanges();
}
}
public ActionResult Validate(TempUser temp)
{
tem = new Models.TempUser{ Name = temp.name, Password = temp.password, stationId = temp.stationID.Value, Role = temp.role };
ViewBag.temp = tem;
return View();
}
