public ActionResult DeleteClick()
{
RegisterMapper regMap = new RegisterMapper();
regMap.DeleteClick(mail);
return(View());
}
public HttpResponseMessage IHttpActionResult([FromBody] RegisterModel model)
{
_mapper = new RegisterMapper();
_valid = new RegisterValidator();
HttpResponseMessage response = new HttpResponseMessage();
UsersDbEntities usersDbEntities = new UsersDbEntities();
if (_valid.Valid(model))
{
usersDbEntities.users.Add(_mapper.MapToUser(model));
usersDbEntities.SaveChanges();
response.Content = new StringContent("ok", Encoding.Unicode);
response.StatusCode = HttpStatusCode.OK;
return(response);
}
else
{
response.Content = new StringContent("user already exist", Encoding.Unicode);
response.StatusCode = HttpStatusCode.Conflict;
return(response);
}
//catch (Exception ex)
//{
// // return error message if there was an exception
// return response;
//}
}
public ActionResult UpdateClick()
{
RegisterMapper regMap = new RegisterMapper();
regMap.UpdateClick(Request["email"], Request["fname"], Request["lname"], Request["address"], Request["mobile"], Request["password"]);
return(View());
}
public ActionResult Delete()
{
RegisterMapper regMap = new RegisterMapper();
ViewBag.Message = regMap.GetUserDetails(mail);
return(View());
}
public ActionResult ClickEvent()
{
RegisterMapper regMap = new RegisterMapper();
ViewBag.Message = regMap.Register(Request["email"], Request["fname"], Request["lname"], Request["address"], Request["mobile"], Request["password"]);
return(View());
}
public static IServiceCollection ConfigureAutoMapper(this IServiceCollection services)
{
services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
services.AddSingleton <IConfigurationProvider>(RegisterMapper.Register());
return(services);
}
public ActionResult Validate()
{
RegisterMapper regMap = new RegisterMapper();
ViewBag.Message = regMap.Update(Request["email"], Request["password"]);
mail = Request["email"];
return(View());
}
/// <summary>
/// Compile RL into the Dex method body.
/// </summary>
private void CompileToDex(DexTargetPackage targetPackage, bool generateDebugInfo, MapFile mapFile)
{
var dmethod = DexMethod;
if (dmethod == null)
{
throw new ArgumentException("No DexMethod set");
}
if ((dmethod.IsAbstract) || (dmethod.IsNative))
{
return;
}
var rlBody = RLBody;
if (rlBody == null && dmethod.Body != null) // already satisfied from the cache?
{
return;
}
if (rlBody == null)
{
throw new ArgumentException(string.Format("internal compiler error: No RL body set on method '{2}'.'{3}' => '{0}'.'{1}'", dmethod.Owner.Name, dmethod.Name, method == null ? null : method.DeclaringType.FullName, method == null ? null : method.Name));
}
// Ensure RL is optimized
OptimizeRL(targetPackage.DexFile);
// Compile to Dex
var dbody = new Dot42.DexLib.Instructions.MethodBody(dmethod, 0);
var dexCompiler = new DexCompiler(rlBody, dbody, InvocationFrame);
regMapper = dexCompiler.Compile();
// Optimize code
//dbody.UpdateInstructionOffsets();
DexOptimizer.DexOptimizer.Optimize(dbody);
// Ensure correct offsets
dbody.UpdateInstructionOffsets();
dmethod.Body = dbody;
if (generateDebugInfo || (mapFile != null))
{
// Add debug info
var debugInfoBuilder = new DebugInfoBuilder(this);
if (generateDebugInfo)
{
debugInfoBuilder.CreateDebugInfo(dbody, regMapper, targetPackage);
}
if (mapFile != null && dmethod.MapFileId != 0)
{
debugInfoBuilder.AddDocumentMapping(mapFile);
}
}
}
/// <summary>
/// Compile RL into the Dex method body.
/// </summary>
private void CompileToDex(DexTargetPackage targetPackage, bool generateDebugInfo, MapFile mapFile)
{
var dmethod = DexMethod;
if (dmethod == null)
{
throw new ArgumentException("No DexMethod set");
}
if ((dmethod.IsAbstract) || (dmethod.IsNative))
{
return;
}
var rlBody = RLBody;
if (rlBody == null)
{
throw new ArgumentException("No RL body set");
}
// Ensure RL is optimized
OptimizeRL(targetPackage.DexFile);
// Compile to Dex
var dbody = new Dot42.DexLib.Instructions.MethodBody(dmethod, 0);
var dexCompiler = new DexCompiler(rlBody, dbody, InvocationFrame);
regMapper = dexCompiler.Compile();
// Optimize code
//dbody.UpdateInstructionOffsets();
DexOptimizer.DexOptimizer.Optimize(dbody);
// Ensure correct offsets
dbody.UpdateInstructionOffsets();
dmethod.Body = dbody;
if (generateDebugInfo || (mapFile != null))
{
// Add debug info
var debugInfoBuilder = new DebugInfoBuilder(this);
if (generateDebugInfo)
{
debugInfoBuilder.CreateDebugInfo(dbody, regMapper, targetPackage);
}
if (mapFile != null)
{
debugInfoBuilder.AddDocumentMapping(mapFile);
}
}
}
private void skinButton1_Click(object sender, EventArgs e)
{
RegisterState registerState = RegisterMapper.Submit(Phone.Text, Pwd.Text, Pwd2.Text);
if (registerState == RegisterState.sucess)
{
MessageBox.Show(StateString.GetRegisterStateString(registerState));
TransfEvent(Phone.Text);
this.Close();
}
else
{
MessageBox.Show(StateString.GetRegisterStateString(registerState));
}
}
public IActionResult Register(UserVm user)
{
using (SHA256 sha256Hash = SHA256.Create())
{
if (user != null)
{
if (_userService.IfExistsUser(user.Email))
{
//return BadRequest(new { message = "Użytkownik o podanym emailu już istnieje" });
return(Ok(ResponseManager.GenerateResponse("Błąd: Użytkownik o podanym emailu już istnieje", (int)MessageType.Error, null)));
}
else
{
if (user.IdAccountType == 1)
{
user.BossKey = _userService.GetBossKey();
}
if (user.IdAccountType == 2)
{
if (_userService.GetIdBoss(user.BossKey) == 0)
{
//return BadRequest(new { message = "Nie istnieje szef o podanym kodzie" });
return(Ok(ResponseManager.GenerateResponse("Błąd: Nie istnieje szef o podanym kodzie", (int)MessageType.Error, null)));
}
else
{
user.IdBoss = _userService.GetIdBoss(user.BossKey);
user.BossKey = null;
}
}
var hash = _userService.GetHash(sha256Hash, user.Password);
user.Password = hash;
var idUser = _userService.AddUser(user);
user.Id = idUser;
//var token = _userService.Authenticate(user.Email);
RegisterVm registerVm = RegisterMapper.MapToVm(user);
return(Ok(ResponseManager.GenerateResponse(null, (int)MessageType.Ok, registerVm)));
}
}
//return BadRequest(new { message = "Podany użytkownik jest pusty" });
return(Ok(ResponseManager.GenerateResponse("Błąd: Podany użytkownik jest pusty", (int)MessageType.Error, null)));
}
}
public ActionResult Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var result = _unitOfWork.Customer_List.AddWithUser(RegisterMapper.MapToCustomer(model), model.Password);
if (result.Succeeded)
{
_unitOfWork.Complete();
Response.StatusCode = (int)HttpStatusCode.OK;
SignInManager.SignIn(
_unitOfWork.Customer_List.GetAll()
.FirstOrDefault(f => f.NationalCode == model.NationalCode)
.Person_ApplicationUser, false, false);
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
return(View(model));
}
public async Task <ActionResult <bool> > signUpUserToClass(RegisterUserForClassRequest register)
{
if (await classRepository.getClassById(register.ClassId) == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "The class the user wants to signup for does not exist!"));
}
if (await userRepository.getUser(register.Username) == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "The user does not exist!"));
}
ClassRegister existingRegister = await registerRepository.getSpecificUserAndClass(register.Username, register.ClassId);
if (existingRegister == null)
{
GymClasses targetClass = await classRepository.getClassById(register.ClassId);
if (targetClass.CurrentStudents < targetClass.MaxCapacity)
{
if (await registerRepository.addRegister(RegisterMapper.registerUserForClassToClassRegister(register)))
{
return(Ok(true));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "An error occurred while trying to register the user for the class!"));
}
}
else
{
return(StatusCode(StatusCodes.Status400BadRequest, "Class max capacity reached!"));
}
}
else
{
return(StatusCode(StatusCodes.Status400BadRequest, "User is already signed up for the specified class"));
}
}
public ActionResult Register(RegisterPO form)
{
ActionResult response = null;
if (ModelState.IsValid)
{
try
{
string Username = form.Username;
bool UsernameExists = _dataAccess.UsernameExists(Username);
//The "!" is "not", "Username does not exist"
if (!UsernameExists)
{
RegisterDO dataObject = RegisterMapper.RegisterPOToDO(form);
_dataAccess.RegisterUser(dataObject);
//has user login after they have registered
response = RedirectToAction("Login", "Account");
}
else
{
ModelState.AddModelError("Username", "Username already in use, please try a different username.");
response = View();
}
}
catch (Exception ex)
{
Logger.Log("Fatal", ex.TargetSite.ToString(), ex.Message, ex.StackTrace);
}
}
else
{
response = View(form);
}
return(response);
}
public async Task <ActionResult <bool> > signUpUserToClass(RegisterUserForClassRequest register)
{
if (await classRepository.getClassById(register.ClassId) == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "The class the user wants to signup for does not exist!"));
}
if (await userRepository.getUser(register.Username) == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "The user does not exist!"));
}
ClassRegister existingRegister = await registerRepository.getSpecificUserAndClass(register.Username, register.ClassId);
if (existingRegister == null)
{
GymClasses targetClass = await classRepository.getClassById(register.ClassId);
if (targetClass.CurrentStudents < targetClass.MaxCapacity)
{
if (await registerRepository.addRegister(RegisterMapper.registerUserForClassToClassRegister(register)))
{
DayOfWeek today = DateTime.Today.DayOfWeek;
DateTime date;
if (today.ToString().ToLower() == targetClass.Day.ToLower())
{
date = DateTime.Today.Date;
}
else
{
DayOfWeek dayOfClass;
switch (targetClass.Day.ToLower())
{
case "monday":
dayOfClass = DayOfWeek.Monday;
break;
case "tuesday":
dayOfClass = DayOfWeek.Tuesday;
break;
case "wednesday":
dayOfClass = DayOfWeek.Wednesday;
break;
case "thursday":
dayOfClass = DayOfWeek.Thursday;
break;
case "friday":
dayOfClass = DayOfWeek.Friday;
break;
case "saturday":
dayOfClass = DayOfWeek.Saturday;
break;
default:
dayOfClass = DayOfWeek.Sunday;
break;
}
int difference = days[(int)today, (int)dayOfClass];
date = DateTime.Today.AddDays(difference).Date;
}
ClassAttendance classToChange = await classAttendanceRepository.getClassInstance(register.ClassId, date);
if (classToChange == null)
{
ClassAttendance newClass = new ClassAttendance();
newClass.Date = date;
newClass.ClassId = targetClass.ClassId;
newClass.Capacity = targetClass.MaxCapacity;
newClass.Class = targetClass;
newClass.NumberOfStudents = targetClass.CurrentStudents;
await classAttendanceRepository.addNewClassInstance(newClass);
}
else
{
await classAttendanceRepository.editClassAttendance(classToChange.ClassId, classToChange.Date, 1);
}
return(Ok(true));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "An error occurred while trying to register the user for the class!"));
}
}
else
{
return(StatusCode(StatusCodes.Status400BadRequest, "Class max capacity reached!"));
}
}
else
{
return(StatusCode(StatusCodes.Status400BadRequest, "User is already signed up for the specified class"));
}
}
