public async Task <IActionResult> Post([FromBody] RegisterCompanyModel model) { if (ModelState.IsValid) { var user = _imapper.Map <CompanyModel>(model); user.LocationModel = new LocationModel { Street = "", City = "", Number = "", Zip = "" }; user.Jobs = new List <string>(); user.Role = Role.Company; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(BadRequest(string.Join(",", result.Errors?.Select(error => error.Description) ?? throw new InvalidOperationException()))); } var created = new JsonResult("User created") { StatusCode = 201 }; return(Ok(created)); } var errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage)); return(BadRequest(errorMessage)); }
public ActionResult RegisterCompany(RegisterCompanyModel model) { if (ModelState.IsValid) { // Attempt to register the comapny string rolename = "u_" + model.CompanyName; Roles.CreateRole(rolename); // Add Company to Database Company comp = new Company(); comp.Name = model.CompanyName; comp.RoleId = secRep.GetRoleId(rolename); comp.Removed = false; comp = secRep.AddCompany(comp); RegisterUserModel userNew = new RegisterUserModel(); userNew.CompanyRole = rolename; return(RedirectToAction("RegisterUser", "Account", new { CompanyName = model.CompanyName })); } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task <IActionResult> Create(RegisterCompanyModel registerCompanyModel, IFormFile LoadedFile) { if (ModelState.IsValid) { Company company = new Company(); company.Name = registerCompanyModel.Name; company.Logo = registerCompanyModel.Logo; company.BrieflyAbout = registerCompanyModel.BrieflyAbout; company.About = registerCompanyModel.About; company.NeedMoney = registerCompanyModel.NeedMoney; company.OwnerName = registerCompanyModel.OwnerName; company.DateCreate = DateTime.Now; if (await SaveImgAsync(LoadedFile, "Logo", registerCompanyModel.OwnerName)) { company.Logo = GetPathImg(LoadedFile.FileName, "Logo", registerCompanyModel.OwnerName); } company.NeedMoney *= 100; db.Companies.Add(company); await db.SaveChangesAsync(); return(RedirectToAction("Index", "Home")); } ViewBag.Name = registerCompanyModel.OwnerName; return(View(registerCompanyModel)); }
public async Task<IActionResult> RegisterCompany([FromBody] RegisterCompanyModel model) { if (await userManager.FindByEmailAsync(model.Email) != null) { return BadRequest("Company already exists!"); } var identityResult = await userManager.CreateAsync(new ApplicationUser { UserName = model.Email, Email = model.Email }, model.Password); if (!identityResult.Succeeded) { return BadRequest("Something went wrong!"); } var user = await userManager.FindByEmailAsync(model.Email); await companiesProvider.AddCompany(new Company { Name = model.CompanyName, ApplicationUserId = user.Id }); var token = await userManager.GenerateEmailConfirmationTokenAsync(user); await emailProvider.SendConfirmEmail(user, token); var appToken = await jwtFactory.GenerateEncodedToken(user); var newRefreshToken = jwtFactory.GenerateRefreshToken(); user.RefreshToken = newRefreshToken; await userManager.UpdateAsync(user); return new ObjectResult(new { token = appToken, refreshToken = newRefreshToken }); }
public object Register(RegisterCompanyModel model) { Company company = new Company { nameOfCompany = model.nameOfCompany }; Company registeredCompany = CompanyManager.Register(company); RegisterCompanyModel modelNew = Mapper.Map <RegisterCompanyModel>(company); return(new { modelNew }); }
public IActionResult Register([FromBody] RegisterCompanyModel model) { try { _userService.CreateCompany(model, model.Slaptazodis); return(Ok()); } catch (AppException ex) { return(BadRequest(new { message = ex.Message })); } }
public async Task <IActionResult> RegisterCompany([FromBody] RegisterCompanyModel model) { var newCompany = new Company { Name = model.CompanyName, Bulstat = model.Bulstat, Logo = model.CompanyLogo }; var newUser = new User { UserName = model.Username, Email = model.Email, FirstName = model.FirstName, MiddleName = model.MiddleName, LastName = model.LastName, Company = newCompany }; IdentityResult result; try { result = await this.userManager.CreateAsync(newUser, model.Password); } catch (Exception) { return(this.BadRequest(new { Title = "There is already a company with this name or bulstat!" })); } if (!result.Succeeded) { var errors = result.Errors.Select(x => x.Description); return(BadRequest(new RegisterResult { Successful = false, Errors = errors })); } IdentityResult adToRoleResult = await this.userManager.AddToRoleAsync(newUser, CompanyRole); if (!adToRoleResult.Succeeded) { return(BadRequest(new RegisterResult { Successful = false })); } return(Ok(new RegisterResult { Successful = true, Message = "Successfully registered!" })); }
private void MapImone(Imone imone, RegisterCompanyModel register) { imone.Adresas = register.Adresas; imone.Aprasymas = register.Aprasymas; imone.ArUzsaldytas = false; imone.ElPastas = register.ImonesPastas; imone.ImonesKodas = register.ImonesKodas; imone.Miestas = register.Miestas; imone.Nuotrauka = register.Nuotrauka; imone.Pavadinimas = register.Pavadinimas; imone.TelNr = register.TelNr; imone.Tinklalapis = register.Tinklapis; imone.Vadovas = register.Vadovas; }
public async Task <IActionResult> RegisterCompany(RegisterCompanyModel model) { if (ModelState.IsValid) { var user = new User { UserName = model.Username, Email = model.Email, PictureUrl = GlobalConstants.CompanyDefaulthAvatarUri }; var result = await userManager.CreateAsync(user, model.Password); if (result.Succeeded) { //Add company to database var addedResult = await companyService.CreateAsync(new CompanyServiceModel() { CompanyName = model.CompanyName, User = new UserServiceModel() { UserName = user.UserName } }); if (!addedResult) { return(NotFound()); } //Add role to user var role = await userManager.AddToRoleAsync(user, GlobalConstants.Company); var code = await userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme); var viewResult = await GetConfirmationTemplate(user, callbackUrl, "ConfirmEmailTemplate"); await emailSender.SendEmailAsync(model.Email, "Please verify your email", viewResult); await signInManager.SignInAsync(user, isPersistent : false); this.Success(NotificationMessages.VerificationEmailSent); return(LocalRedirect("/")); } AddErrors(result); } return(View(model)); }
public void Log(ErrorCodes ErrorCode, string ErrorDescription, RegisterCompanyModel model) { AuthenticationLog log = new AuthenticationLog(); log.Method = "CompanyRegister"; log.ServerIP = Utilities.GetServerIP(); log.CreatedDate = DateTime.Now; log.Channel = model?.Channel; log.ErrorCode = ErrorCode; log.ErrorDescription = ErrorDescription; log.Password = model?.Password; log.Email = model?.Email; log.UserName = model?.Email; log.CompanyCrNumber = model?.CompanyCrNumber; log.CompanyName = model?.CompanyName; log.CompanySponserId = model?.CompanySponserId; log.CompanyVatNumber = model?.CompanyVatNumber; _authenticationLogRepository.Insert(log); }
public async Task <IActionResult> CompanyRegister([FromBody] RegisterCompanyModel model) { CompanyRegisterOutput output = new CompanyRegisterOutput(); if (model.IsValid) { RegisterCompany registerUser = new RegisterCompany(_signInManager, _userManager, _configuration); output = await registerUser.UserRegister(model); return(Ok(output)); } else { output.ErrorCode = CompanyRegisterOutput.ErrorCodes.NullRequest; output.ErrorDescription = "Model is not valid"; output.Token = null; return(BadRequest(output)); } }
public async Task <string> RegisterCompany(RegisterCompanyModel model) { try { string json = ""; try { // Verifying if company exists var result = await _gatewayRepository.ApiAccountsCompaniesExistsGetAsync(model.Siret); if (result != null) { throw new BusinessException(ErrorMessages.companyAlreadyExists); } } catch (ApiException apiexc) { if (apiexc.StatusCode != 204) { throw apiexc; } } // Updates company json = await _gatewayRepository.ApiAccountsCompaniesRegisterPostAsync(_mapper.Map <RegisterCompanyRequest>(model)); string id = JsonConvert.DeserializeObject <string>(json); return(id); } catch (ApiException apiExc) { throw new TechnicalException(ErrorMessages.serverErrorText + apiExc.StatusCode); } catch { throw; } }
/// <inheritdoc/> public async Task <CompanyDetails> RegisterCompanyAsync(RegisterCompanyModel company, CancellationToken cancellationToken) { var companyDetails = await this.companyRepository.RegisterCompanyAsync( new Company() { Name = company.Name, Description = company.Description, AddressLine1 = company.AddressLine1, AddressLine2 = company.AddressLine2, AddressLine3 = company.AddressLine3, AddressLine4 = company.AddressLine4, }, cancellationToken); foreach (var account in company.Accounts) { account.CompanyId = companyDetails.CompanyId; await this.accountService.RegisterAsync(account, cancellationToken); } return(companyDetails); }
public PrisijungimoDuomenys CreateCompany(RegisterCompanyModel company, string password) { if (string.IsNullOrWhiteSpace(password)) { throw new AppException("Slaptažodis privalomas"); } if (_db.PrisijungimoDuomenys.Any(x => x.Epastas == company.Epastas)) { throw new AppException("El.Paštas \"" + company.Epastas + "\" jau naudojamas"); } byte[] passwordHash, passwordSalt; CreatePasswordHash(password, out passwordHash, out passwordSalt); var duomenys = new PrisijungimoDuomenys(); duomenys.Epastas = company.Epastas; duomenys.FkTipas = 3; duomenys.Slaptazodis = passwordHash; duomenys.SlaptazodisSalt = passwordSalt; var imone = new Imone(); MapImone(imone, company); imone.ArUzsaldytas = true; _db.Imone.Add(imone); _db.SaveChanges(); var imonesId = imone.IdImone; duomenys.FkImoneId = imonesId; _db.PrisijungimoDuomenys.Add(duomenys); _db.SaveChanges(); return(duomenys); }
public async Task <ActionResult <CompanyDetails> > RegisterCompany(RegisterCompanyModel companyModel, CancellationToken cancellationToken) { var companyDetails = await this.companyService.RegisterCompanyAsync(companyModel, cancellationToken); return(this.CreatedAtAction(nameof(this.GetCompany), new { id = companyDetails.CompanyId }, companyDetails)); }
public ActionResult RegisterCompany(RegisterCompanyModel model) { if (ModelState.IsValid) { // Attempt to register the comapny string rolename = "u_" + model.CompanyName; Roles.CreateRole(rolename); // Add Company to Database Company comp = new Company(); comp.Name = model.CompanyName; comp.RoleId = secRep.GetRoleId(rolename); comp.Removed = false; comp = secRep.AddCompany(comp); RegisterUserModel userNew = new RegisterUserModel(); userNew.CompanyRole = rolename; return RedirectToAction("RegisterUser", "Account", new { CompanyName = model.CompanyName}); } // If we got this far, something failed, redisplay form return View(model); }
public async Task <IActionResult> RegisterCompany([FromBody] RegisterCompanyModel model) { var user = new User { UserName = model.LoginEmail, Email = model.LoginEmail, }; var contactCompany = new ContactCompany { Email = model.EmailContactPerson, JobTitle = model.JobTitleContactPerson, PhoneNumber = model.PhoneNumberContactPerson, Name = model.FirstNameContactPerson, LastName = model.LastNameContactPerson, }; var companyPromoter = new CompanyPromoter { Email = model.EmailPromoter, Name = model.FirstNamePromoter, LastName = model.LastNamePromoter, PhoneNumber = model.PhoneNumberPromoter, JobTitle = model.JobTitlePromoter }; var address = new Address { Street = model.Street, PostalNumber = model.PostalNumber, Township = model.Township, Number = model.Number }; var company = new Company { AmountOfITPersonnel = model.AmountOfItEmployees, AmountOfPersonnel = model.AmountOfEmployees, NameCompany = model.NameCompany, ContactCompany = contactCompany, Promoter = companyPromoter, AddressCompany = address, }; try { var comppanyId = _companyData.AddCompany(company); user.CompanyId = comppanyId; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { var role = Role.Company; await EnsureRoleExists(role); await _userManager.AddToRoleAsync(user, role); return(Ok()); } foreach (var error in result.Errors) { ModelState.AddModelError(error.Code, error.Description); } return(BadRequest(ModelState)); } catch (Exception e) { Console.WriteLine(e); return(BadRequest()); } }
public async Task <CompanyRegisterOutput> UserRegister(RegisterCompanyModel model) { CompanyRegisterOutput output = new CompanyRegisterOutput(); if (model == null) { Log(ErrorCodes.NullRequest, "Model is Null", model); output.ErrorCode = CompanyRegisterOutput.ErrorCodes.NullRequest; output.ErrorDescription = "Model is not valid"; output.Token = null; return(output); } try { var user = new ApplicationUser { Email = model.Email, UserName = model.Email, IsCompany = true, EmailConfirmed = true, PhoneNumber = model.Mobile, PhoneNumberConfirmed = false, CreatedDate = DateTime.Now, LastModifiedDate = DateTime.Now, LastLoginDate = DateTime.Now, RoleId = Guid.Parse("DB5159FA-D585-4FEE-87B1-D9290D515DFB"), LanguageId = Guid.Parse("5046A00B-D915-48A1-8CCF-5E5DFAB934FB") }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { Log(ErrorCodes.ServiceException, "User failed to register", model); StringBuilder errorList = new StringBuilder(); result.Errors.ToList().ForEach(e => errorList.Append(e.Description + Environment.NewLine)); output.ErrorCode = CompanyRegisterOutput.ErrorCodes.ServiceException; output.ErrorDescription = errorList.ToString(); output.Token = null; return(output); } else { var registeredUser = await _userManager.FindByEmailAsync(model.Email); if (registeredUser != null) { Log(ErrorCodes.Success, "User Registered Successfully", model); GenerateToken generateToken = new GenerateToken(_configuration); JwtSecurityToken token = generateToken.GenerateTokenJWT(user.Id, user.Email); output.ErrorCode = CompanyRegisterOutput.ErrorCodes.Success; output.ErrorDescription = "Registered Successfully"; output.Token = new JwtSecurityTokenHandler().WriteToken(token); return(output); } else { Log(ErrorCodes.NullResponse, "User not found", model); output.ErrorCode = CompanyRegisterOutput.ErrorCodes.NullResponse; output.ErrorDescription = "Failed to create user"; output.Token = null; return(output); } } } catch (Exception exp) { Log(ErrorCodes.MethodException, exp.ToString(), model); output.ErrorCode = CompanyRegisterOutput.ErrorCodes.MethodException; output.ErrorDescription = "UserLogin through exception"; output.Token = null; return(output); } }