public bool CheckIfEmployeeIdAlreadyExists(RegistrationDTO registrationDTO)
{
var entities = new FoodfeedbackDBContext();
var CheckEmployeeIdresult = entities.Users.Where(x => x.EmpId == registrationDTO.EmpId).Any();
return(CheckEmployeeIdresult);
}
public async Task <RegistrationDTO> Create(string eventId, [FromBody] RegistrationDTO registration)
{
var e = await eventsCollection.FindByIdAsync(eventId);
if (e == null)
{
throw new EventNotFoundException();
}
if (e.Prices.Any())
{
throw new UnauthorizedAccessException("Cannot perform this operation for paid events!");
}
await registrationListCollection.ChangeOneSafeAsync(eventId, list =>
{
if (list.Registrations.Count < e.MaxAttendeeCount)
{
var r = Mapper.Map <Registration>(registration);
registration.Id = r.Id = Guid.NewGuid().ToString();
list.Registrations.Add(r);
}
});
return(registration);
}
public ActionResult Registration(RegistrationDTO registrationDTO, string SubjectSelected)
{
if (!ModelState.IsValid)
{
return(Json(new ReturnFormat(400, "failed", null), JsonRequestBehavior.AllowGet));
}
var school = (T_DM_Truong)Session[Constant.SCHOOL_SESSION];
if (school == null)
{
return(Json(new ReturnFormat(400, "failed", null), JsonRequestBehavior.AllowGet));
}
using (var registrationService = new HDHocTapTraiNghiemService())
{
Registration registration = registrationService.GetRegistrationsById(registrationDTO.Id);
Mapper.Map(registrationDTO, registration);
registration.SchoolName = school.TenTruong;
registration.CreatedAt = DateTime.Now;
registration.SchoolId = school.SchoolID;
string[] arraySubject = SubjectSelected.Split(new char[] { ',' });
var inserted = registrationService.UpdateRegistration(registration);
foreach (var item in arraySubject)
{
using (var subjectRegisted = new SubjectRegistedService())
{
SubjectsRegisted subjectsRegisted = new SubjectsRegisted();
subjectsRegisted.SubjectId = Convert.ToInt32(item);
subjectsRegisted.RegistrationId = registrationDTO.Id;
subjectRegisted.CreateSubjectRegisted(subjectsRegisted);
}
}
return(Json(new ReturnFormat(200, "success", null), JsonRequestBehavior.AllowGet));
}
}
public async Task <IActionResult> Post([FromBody] RegistrationDTO model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <AppUser>(model);
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
await _userManager.AddToRoleAsync(userIdentity, Constants.Strings.JwtClaims.Creator);
await _appDbContext.SaveChangesAsync();
var emailConfirmationToken = await _userManager.GenerateEmailConfirmationTokenAsync(userIdentity);
var emailConfirmationResult = await _userManager.ConfirmEmailAsync(userIdentity, emailConfirmationToken);
if (!emailConfirmationResult.Succeeded)
{
return(Content(emailConfirmationResult.Errors.Select(error => error.Description).Aggregate((allErrors, error) => allErrors += ", " + error)));
}
return(new OkObjectResult("New Creator successfully added!"));
}
public void RegistrationTest()
{
RegistrationDTO dto = new RegistrationDTO {
UserName = "******", Password = "******", ConfirmPassword = "******"
};
bool result = (_userRepository.Register(dto, "User")).Result.Succeeded;
Assert.True(result);
dto = new RegistrationDTO {
UserName = "", Password = "******", ConfirmPassword = "******"
};
result = (_userRepository.Register(dto, "User")).Result.Succeeded;
Assert.True(result != true);
dto = new RegistrationDTO {
UserName = "", Password = "", ConfirmPassword = ""
};
result = (_userRepository.Register(dto, "User")).Result.Succeeded;
Assert.True(result != true);
dto = new RegistrationDTO {
UserName = "******", Password = "******", ConfirmPassword = "******"
};
result = (_userRepository.Register(dto, "User")).Result.Succeeded;
Assert.True(result != true);
}
public async Task <ResultMessage <bool> > GenerateRegistrationEmail(RegisterFormDTO registerFormDTO)
{
RegistrationDTO regDTO = Mapping.Mapper.Map <RegistrationDTO>(registerFormDTO);
regDTO.RegistrationCode = GenerateRegistrationCode();
regDTO.Used = false;
regDTO.Timestamp = DateTime.Now;
ResultMessage <RegistrationDTO> registrationProcessResult = await _registrationService.Add(regDTO);
if (!registrationProcessResult.IsSuccess)
{
return(new ResultMessage <bool>(registrationProcessResult.Status, registrationProcessResult.Message));
}
await _emailSender.SendTemplateEmailAsync(
new TemplateEmail
{
From = _fromEmailAddress,
To = registerFormDTO.Email,
TemplateId = _regEmailTemplateId,
TemplateData = new
{
reg_link = GenerateRegistrationLink(regDTO.RegistrationCode),
first_name = registerFormDTO.FirstName,
last_name = registerFormDTO.LastName,
index_number = registerFormDTO.Index
},
});
return(new ResultMessage <bool>(true));
}
public async Task <IHttpActionResult> Register(RegistrationDTO model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.Email,
SlackId = model.SlackId,
Email = model.Email
};
var result = await Microsoft.AspNet.Identity.UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(Ok());
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(BadRequest());
}
public async Task RegisterCrossVerifingEmailToCreateUser()
{
var store = new Mock <IUserStore <AppUser> >();
var _mockUserMgr = new Mock <UserManager <AppUser> >(store.Object, null, null, null, null, null, null, null, null);
var appUser = new AppUser {
Email = "*****@*****.**"
};
var registrationDTO = new RegistrationDTO {
Email = "*****@*****.**", Password = "******"
};
//Set up findByEmail
_mockUserMgr.Setup(userMgr => userMgr.FindByEmailAsync(null))
.Returns(Task.FromResult <AppUser>(null));
//Set up create and assert user enterered email is same as set in AppUser obj
_mockUserMgr.Setup(userMgr => userMgr.CreateAsync(appUser, It.IsAny <string>()))
.Returns(Task.FromResult(It.IsAny <IdentityResult>()))
.Callback(() => Assert.AreEqual(appUser.Email, registrationDTO.Email));
var authenticateController = new AuthenticateController(_mockUserMgr.Object, null);
//Called Register method
var result = await authenticateController.Register(registrationDTO);
// if result is null or not succedded
var badResult = result as BadRequestObjectResult;
Assert.AreEqual(Convert.ToString(badResult.StatusCode), "400");
}
public async Task <string> Register(RegistrationDTO model)
{
var user = new StrategyGameUser
{
UserName = model.Email,
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
try
{
await _orszagService.MakeOrszagUserConnection(user, model.CountryName);
} catch (Exception e)
{
await _userManager.DeleteAsync(user);
throw e;
}
await _signInManager.SignInAsync(user, false);
return(await _jwtService.GenerateJwtToken(model.Email, user));
}
throw new ApplicationException("UNKNOWN_ERROR");
}
public async Task <ActionResult> Registration(RegistrationDTO model)
{
await authenticateService.Registration(model, ModelState.IsValid);
return(Ok());
}
public async Task <IActionResult> Registration([FromBody] RegistrationDTO user)
{
if (_context.Users.Any(x => x.UserName == user.Username))
{
return(StatusCode(409, new { message = $"User '{user.Username}' is already exists." }));
}
if (_context.Users.Any(x => x.Email == user.Email))
{
return(StatusCode(409, new { message = $"Email '{user.Email}' is currently in use." }));
}
try
{
var userToCreate = _mapper.Map <Users>(user);
await _registrationRepository.SignOutUserAsync(userToCreate, user.Password);
await _context.SaveChangesAsync();
return(StatusCode(201));
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <ActionResult> PostRegisterUser([FromBody] RegistrationDTO registrationDTO)
{
await _tenantRepository.Add(new Tenant()
{
CompanyName = registrationDTO.CompanyName, CompanyStrength = registrationDTO.CompanyStrength
});
if (await _tenantRepository.FirstOrDefault(tenant => tenant.CompanyName == registrationDTO.CompanyName) != null)
{
Tenant tenantAcc = await _tenantRepository.FirstOrDefault(tenant => tenant.CompanyName == registrationDTO.CompanyName);
await _userRepository.Add(new User()
{
Id = new Guid(),
Username = registrationDTO.Username,
Password = _encryptorDecryptor.Encrypt(registrationDTO.Password),
Email = registrationDTO.CompanyEmail,
Role = "Admin",
TenantId = tenantAcc.Id,
});
if (await _userRepository.FirstOrDefault(user => user.Email == registrationDTO.CompanyEmail) != null)
{
return(Ok("User added successfully"));
}
else
{
return(BadRequest("Cannot add user"));
}
}
else
{
return(BadRequest("Cannot Register User"));
}
}
public async Task <IActionResult> Post([FromBody] RegistrationDTO model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <AppUser>(model);
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
await _userManager.AddToRoleAsync(userIdentity, Constants.Strings.JwtClaims.Subscriber);
await _userManager.AddClaimAsync(userIdentity, new Claim(ClaimTypes.Role, Constants.Strings.JwtClaims.Subscriber));
await _appDbContext.SaveChangesAsync();
var emailConfirmationToken = await _userManager.GenerateEmailConfirmationTokenAsync(userIdentity);
var tokenVerificationUrl = Url.Action("VerifyEmail", "Accounts", new { id = userIdentity.Id, token = emailConfirmationToken }, Request.Scheme);
await _messageService.Send(userIdentity.Email, "Verify your email", $"Click <a href=\"{tokenVerificationUrl}\">here</a> to verify your email");
return(new OkObjectResult("Check your email for a verification link"));
}
public async Task Test_Post()
{
//Arrange.
UserDTO userMock = new UserDTO()
{
Login = "******",
Name = "Yago",
Id = 1
};
RegistrationDTO registrationData = new RegistrationDTO()
{
Login = "******",
Name = "Yago",
Password = "******"
};
this._userServiceMock
.Setup(srv => srv.RegisterAsync(registrationData))
.Returns(Task.FromResult(userMock));
//Act.
var result = await this._usersController.Post(registrationData);
var createdAtResult = result as CreatedAtActionResult;
//Assert.
Assert.IsNotNull(createdAtResult);
Assert.IsInstanceOfType(createdAtResult.Value, typeof(UserDTO));
Assert.AreEqual(userMock, createdAtResult.Value as UserDTO);
//Testar URL de redirecionamento.
Assert.AreEqual(createdAtResult.ActionName, nameof(this._usersController.GetByLogin));
Assert.AreEqual(createdAtResult.RouteValues["login"], userMock.Login);
}
public bool Registration(RegistrationDTO registrationDTO)
{
NetworkStream networkStream = tcpClient.GetStream();
BinaryFormatter bf = new BinaryFormatter();
DataToSend dataToSend = new DataToSend()
{
FirstObject = new RegistrationSocket()
{
Email = registrationDTO.Email,
Login = registrationDTO.Login,
Password = registrationDTO.Password,
PhoneNumber = registrationDTO.PhoneNumber,
RepeatPassword = registrationDTO.RepeatPassword
},
Action = MessageSocketData.SocketObj.Action.Registration,
};
bf.Serialize(networkStream, dataToSend);
///////////////////////////////////////////////////////////////
DataToSend answer = bf.Deserialize(tcpClient.GetStream()) as DataToSend;
bool obj = (answer.Boolean);
return(obj);
}
public async Task <ActionResult <UserDTO> > RegisterUser(RegistrationDTO registrationDto)
{
if (await UserExist(registrationDto.Username))
{
return(BadRequest("Username is already registered!!"));
}
using var hmac = new HMACSHA512();
var user = new AppUser
{
UserName = registrationDto.Username,
PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registrationDto.Password)),
PasswordSalt = hmac.Key
};
await _database.Users.AddAsync(user);
await _database.SaveChangesAsync();
return(new UserDTO
{
Username = user.UserName,
Token = _tokenServices.CreateToken(user)
});
}
/// <summary>
/// Checks whether registration code is valid
/// </summary>
/// <param name="code">Registration link code</param>
/// <returns>Task which wraps result</returns>
/// <remarks>Code is valid if registration for given code exists
/// and user with given email is not already registered</remarks>
public async Task <bool> ValidateRegistrationCode(string code)
{
RegistrationDTO registration =
await _registrationService.GetSingleOrDefault(reg => reg.RegistrationCode == code && !reg.Used);
return(registration != null && !await IsStudentRegistered(registration.Email));
}
public async Task <RegistrationResultDTO> RegisterAsync(RegistrationDTO registrationDto)
{
var registrationResult = new RegistrationResultDTO();
var user = Mapper.Map <RegistrationDTO, User>(registrationDto);
var result = await _unitOfWork.UserManager.CreateAsync(user, registrationDto.Password);
registrationResult.Succeded = result.Succeeded;
if (result.Succeeded)
{
var code = await _unitOfWork.UserManager.GenerateEmailConfirmationTokenAsync(user);
code = HttpUtility.UrlEncode(code);
var callbackUrl = $"email/verify/{user.UserName}/{code}";
var htmlMessage = $"Please confirm your account by clicking this link: <a href='http://localhost:3000/{callbackUrl}'>Confirm</a>";
await _emailSender.SendEmailAsync(registrationDto.Email, "Confirm your email", htmlMessage);
await _userManager.AddToRoleAsync(user, "User");
await _unitOfWork.SignInManager.SignInAsync(user, false);
user.RefreshToken = _tokenService.GenerateRefreshToken();
registrationResult.Token = await _tokenService.GenerateJwtToken(user.UserName, user.Id);
registrationResult.Token.RefreshToken = user.RefreshToken;
await _unitOfWork.SaveAsync();
}
return(registrationResult);
}
public ActionResult RegistrationForm(RegistrationDTO newUser)
{
userSerivice.AddPartner(newUser);
Session["user"] = userSerivice.GetUserIdByLogin(newUser.LoginAndPassword.Login);
Session["login"] = newUser.LoginAndPassword.Login;
return(RedirectToAction("PrivatePage", "User", new { login = newUser.LoginAndPassword.Login }));
}
/// <summary>
///
/// </summary>
/// <param name="registrationDTO">Registration data transfer object</param>
/// <returns>Created user id.</returns>
public async Task <string> RegisterAsync(RegistrationDTO registrationDTO)
{
// map dto to AppUser class
var user = _mapper.Map <AppUser>(registrationDTO);
// Try to create the new user
var result = await _userManager.CreateAsync(user, registrationDTO.Password);
// If it fails throw an exception
if (!result.Succeeded)
{
throw new InvalidOperationException(result.ErrorMessage());
}
var customer = new Customer {
IdentityId = user.Id
};
// Add new user to customers table with the identity id assigned.
await _context.Customers.AddAsync(customer);
// Commit changes to database
await _context.SaveChangesAsync();
return(customer.IdentityId);
}
public async Task <IActionResult> RegisterVehicle(RegistrationDTO model)
{
try
{
if (!ModelState.IsValid)
{
_logger.LogError("Model validation failed.");
return(BadRequest(ModelState));
}
bool result = await _registrationService.RegisterVehicle(model);
if (result)
{
_logger.LogInformation("User/Device Registered.");
return(Ok(true));
}
else
{
_logger.LogInformation("Error Occured");
return(Ok(false));
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(BadRequest("Error Occured"));
}
}
//update data of donors
public void UpdateAllInfo(RegistrationDTO registerDTO, DonorDetailsDTO donorDTO)
{
// for registered Donors
sqlConnection.Open();
string sqlQuery1 = "UPDATE RegisteredDonor SET Name='" + registerDTO.NAME +
"',Email='" + registerDTO.EMAIL +
"',District='" + registerDTO.DISTRICT +
"',BloodGroup='" + registerDTO.BLOODGROUP +
"',ContactNo='" + registerDTO.CONTACTNO +
"' where DonorID=" + registerDTO.ID;
sqlCommand = new SqlCommand(sqlQuery1, sqlConnection);
sqlCommand.ExecuteNonQuery();
//for Donor Details
string sqlQuery2 = "UPDATE DonorDetails SET Address='" + donorDTO.ADDRESS +
"',Gender='" + donorDTO.GENDER +
"',Weight='" + donorDTO.WEIGHT +
"',Height='" + donorDTO.HEIGHT +
"',Smoker='" + donorDTO.SMOKER +
"',Addict='" + donorDTO.ADDICT +
"',DateofBirth='" + donorDTO.DATEOFBIRTH +
"',DonationStatus='" + donorDTO.DONATIONSTATUS +
"',Bio='" + donorDTO.BIO +
"' where DonorID=" + donorDTO.DONORID;
sqlCommand = new SqlCommand(sqlQuery2, sqlConnection);
sqlCommand.ExecuteNonQuery();
sqlConnection.Close();
}
public async Task <IActionResult> Post([FromBody] RegistrationDTO model)
{
try
{
AppUser userIdentity = _mapper.Map <AppUser>(model);
string role = Constants.Strings.DefaultRoles.Guest;
IdentityResult result = await _userService.CreateAsync(userIdentity, model.Password);
if (result.Succeeded)
{
await _userService.AddClaimAsync(userIdentity, role);
await _userService.AddToRoleAsync(userIdentity, role);
}
else
{
return(BadRequest(Errors.AddErrorToModelState(result, ModelState)));
}
return(new JsonResult("User Registered Successfully"));
}
catch (Exception ex)
{
throw;
}
}
public DataToSend Processing(DataToSend inputData)
{
ISocketService socketService = new SocketService();
DataToSend outputData = new DataToSend();
LoginMap loginMap = new LoginMap();
DeviceMap deviceMap = new DeviceMap();
AccountMap accountMap = new AccountMap();
RegistrationMap registrationMap = new RegistrationMap();
if (inputData.Action == MessageSocketData.SocketObj.Action.Login)
{
Console.WriteLine("Login...");
LoginDTO loginDTO = loginMap.MapTo(inputData.FirstObject as LoginSocket);
DeviceDTO deviceDTO = deviceMap.MapTo(inputData.SecondObject as DeviceSocket);
AccountDTO accountDTO = new AccountDTO();
accountDTO = socketService.CheckUser(loginDTO, deviceDTO);
outputData.FirstObject = accountMap.MapFrom(accountDTO);
}
if (inputData.Action == MessageSocketData.SocketObj.Action.Registration)
{
Console.WriteLine("Registration...");
RegistrationDTO registrationDTO = registrationMap.MapTo(inputData.FirstObject as RegistrationSocket);
bool answer = socketService.GetRegistration(registrationDTO);
outputData.Boolean = answer;
}
return(outputData);
}
public async Task Registration(RegistrationDTO model, bool ModelValid)
{
try
{
if (ModelValid == true)
{
var role = model.Role == null ? model.Role = RolesEnum.User.ToString() : model.Role;
var user = new ApplicationUser
{
UserName = model.UserName,
Email = model.Email,
PhoneNumber = model.Phone,
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, role);
}
}
}
catch (Exception ex)
{
_loger.LogError(ex.Message);
}
finally
{
}
}
public async Task Test_RegisterAsync_Valido()
{
//Arrange.
RegistrationDTO registration = new RegistrationDTO()
{
Login = "******",
Password = "******",
Name = "Yago"
};
//Mockar query de usuário existente por login.
var userByLoginQuery = new Query <User>();
this._userQueryMock.Setup(x => x.ByLogin(registration.Login))
.Returns(userByLoginQuery);
this._userRepositoryMock.Setup(x => x.ExistsAsync(It.Is <Query <User> >(it => it.Equals(userByLoginQuery))))
.Returns(Task.FromResult(false));
//Mockar usuário criado.
var createdUserMock = new User()
{
Id = 1,
Login = "******",
Name = "Yago"
};
//Act.
var createdUser = await this._userService.RegisterAsync(registration);
//Assert.
Assert.IsNotNull(createdUser);
Assert.AreEqual(createdUserMock.Name, createdUser.Name);
this._userRepositoryMock.Verify(rep => rep.InsertAsync(It.IsAny <User>()), Times.Once);
}
public IHttpActionResult SubmitPartialRegistration(RegistrationDTO registrationForm)
{
Validate(registrationForm);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Make custom error validator to make sure all values are not null... This is only the start.
// The only difference is the password.
if (registrationForm.FirstName == null ||
registrationForm.LastName == null ||
registrationForm.Username == null ||
registrationForm.Password != null ||
registrationForm.Email == null ||
registrationForm.SecurityQuestions[0].Answer == null ||
registrationForm.SecurityQuestions[1].Answer == null ||
registrationForm.SecurityQuestions[2].Answer == null)
{
return(BadRequest("Improper Request"));
}
var response = _controllerLogic.FinishRegistration(registrationForm);
IHttpActionResult actionResultResponse = ResponseMessage(response);
return(actionResultResponse);
}
public async Task <string> RegistrationAsync(RegistrationDTO registrationDto)
{
bool IsPhoneExist = _userManager.Users.Any(item => item.PhoneNumber == registrationDto.PhoneNumber);
if (IsPhoneExist)
{
return("Пользователь с таким номером телефона уже существует");
}
bool isEmailExist = _userManager.Users.Any(item => item.Email == registrationDto.Email);
if (isEmailExist)
{
return("Пользователь с таким Email уже существует");
}
User user = _mapper.Map <User>(registrationDto);
var userName = await _userManager.FindByNameAsync(registrationDto.UserName);
if (userName != null)
{
user.UserName = registrationDto.UserName + Guid.NewGuid();
}
var result = await _userManager.CreateAsync(user, registrationDto.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
await UpdateCoefficient(1, user.Id);
}
return("Вы зарегистрированы успешно");
}
public ServiceResult <RegistrationDTO> RegisterUser(RegistrationDTO regDTO, string confirmUrl)
{
if (!db.Users.Any(u => u.Email == regDTO.Email))
{
User user = db.Users.Get(regDTO.userId);
user.FirstName = regDTO.FirstName;
user.LastName = regDTO.LastName;
user.Email = regDTO.Email;
user.HashPassword = regDTO.HashPassword;
user.PhoneNumber = regDTO.PhoneNumber;
user.Address = regDTO.Address;
user.ZipCode = regDTO.ZipCode;
db.Save();
EmailSender.Send(user.Email, "Подтверждение регистрации на BeGreen!",
string.Format("Для завершения регистрации перейдите по ссылке:" +
"<a href='{0}' title='Подтвердить регистрацию'>подтвердить</a>", confirmUrl));
return(new ServiceResult <RegistrationDTO>(null, null));
}
else
{
return(new ServiceResult <RegistrationDTO>(null, "Email", "Пользователь с таким адресом электронной почты уже зарегистрирован"));
}
}
/// <summary>
/// Register the user details
/// </summary>
/// <param name="registrationDTO"></param>
/// <returns>
/// true if user register
/// </returns>
public int RegisterUser([FromBody] RegistrationDTO registrationDTO)
{
//string exists = "";
var entities = new FoodfeedbackDBContext();
var RegisteredUserDetails = new Users()
{
Email = registrationDTO.Email,
Password = registrationDTO.Password,
EmpId = registrationDTO.EmpId,
Username = registrationDTO.Username,
};
var UserExists = CheckIfEmailAlreadyExists(registrationDTO);
var EmployeeIdExists = CheckIfEmployeeIdAlreadyExists(registrationDTO);
if (UserExists == true)
{
return(2);
}
else if (EmployeeIdExists == true)
{
return(0);
}
else
{
entities.Users.Add(RegisteredUserDetails);
entities.SaveChanges();
return(1);
}
}
