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);
}
}
