public async Task <CompanyViewModel> Add(string companyName) { var model = new CompanyViewModel(); await _service.AddAsync(new Company { CompanyName = companyName }); var companies = await _service.GetAllAsync(); // Geçici olarak yazıldı düzeltilecek List <CompanyDto> companyDtos = new List <CompanyDto>();; foreach (var item in companies) { companyDtos.Add(new CompanyDto { CompanyName = item.CompanyName, Id = item.Id }); } model.Companies = companyDtos; model.ResultModel.Success = true; model.ResultModel.Message = $"Şirket Başarılı bir şekilde eklendi."; return(model); }
public async Task <ActionResult> Add(InterviewDTO interviewDTO) { interviewDTO.SalesPerson = await _salesPersonService.GetByNameAndEmailAsync(interviewDTO.SalesPerson); var company = await _companyService.GetByNameAsync(interviewDTO.Company.Name); if (company == null) { company = await _companyService.AddAsync(interviewDTO.Company, true); } interviewDTO.Company = company; var interviewer = await _interviewerService.GetByNameAndEmailAsync(interviewDTO.Interviewer); if (interviewer == null) { interviewDTO.Interviewer.Company = company; interviewer = await _interviewerService.AddAsync(interviewDTO.Interviewer); } interviewDTO.Interviewer = interviewer; var interview = await _interviewService.AddAsync(interviewDTO); foreach (var fairId in interviewDTO.FairIds) { await _interviewFairService.AddAsync(new InterviewFairDTO { Name = "GörüşmeKaydıFuar" + fairId, Interview = interview, Company = interviewDTO.Company, Fair = _fairService.Get(Guid.Parse(fairId)) }); } return(Ok()); }
public async Task <ActionResult <CompanyDto> > Add(CompanyForAddDto companyForAdd) { Company company = _mapper.Map <Company>(companyForAdd); await _companyService.AddAsync(company); return(CreatedAtAction(nameof(GetById), new { id = company.CompanyId }, _mapper.Map <CompanyDto>(company))); }
public async Task <ActionResult <Company> > Post(Company company) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await _companyService.AddAsync(company); return(CreatedAtAction(nameof(Get), new { id = company.Id }, company)); }
public async Task <IActionResult> Post([FromBody] Company company) { if (company == null || company.Id != 0) { return(BadRequest()); } await _companyService.AddAsync(company, true); return(CreatedAtRoute("Getcompany", new { id = company.Id }, company)); }
public async Task <IActionResult> CreateAsync([FromBody] CompanyCreateModel company) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } int createdCompanyId = await companyService.AddAsync(company.Name, company.CreationDate); return(CreatedAtAction(nameof(GetByIdAsync), new { id = createdCompanyId })); }
public async Task <IActionResult> Create([Bind("IdentityDocumentNumber,BusinessName,Address")] CompanyEntity companyEntity) { companyEntity.UserId = HttpContext.Session.GetInt32("userId").Value; companyEntity.CreatorUser = ""; companyEntity.UpdaterUser = ""; companyEntity.CreateDate = DateTime.Now; companyEntity.UpdateDate = DateTime.Now; companyEntity.Status = true; companyEntity.Removed = false; await _companyService.AddAsync(companyEntity); return(RedirectToAction("Index", "Company")); }
public async Task <IActionResult> Create([FromBody] CompanyBindingModel company) { await companyService.AddAsync(new Core.Models.Company { Name = company.Name, Exchange = company.Exchange, Ticker = company.Ticker, ISIN = company.ISIN, Website = company?.Website }); // TODO: Return id ?? return(Ok()); }
public async Task <IActionResult> Save([FromBody] CompanyDto companyDto) { try { var newCompany = await _companyService.AddAsync(_mapper.Map <Company>(companyDto)); await _distributedCache.RemoveAsync("companies"); return(Created(string.Empty, _mapper.Map <CompanyDto>(newCompany))); } catch (Exception ex) { _logger.LogError(ex.Message); return(StatusCode(500, ex.Message)); } }
public async Task <IActionResult> PostAsync([FromBody] CompanyModel model) { try { await _companyService.AddAsync(model); return(Ok()); } catch (CustomExceptions ex) { return(BadRequest(ex.Message)); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <CompanyDto> Handle(Query request, CancellationToken cancellationToken) { var currentUser = await userManager.FindByIdAsync(userAccessor.GetCurrentUserId()); if (await userManager.IsInRoleAsync(currentUser, RoleNames.Inspector)) { throw new RestException(HttpStatusCode.Forbidden, new { Forbidden = "Permission Denied." }); } var doesExist = companyService.CheckExistsByName(request.Name); if (doesExist) { throw new RestException(HttpStatusCode.BadRequest, new { Name = "Company name already exists." }); } var newCompany = new Company { Name = request.Name, CreatedOn = DateTime.UtcNow, CreatedBy = currentUser.FullName, UpdatedOn = null, UpdatedBy = null, IsActive = true }; var succeeded = await companyService.AddAsync(newCompany); if (!succeeded) { throw new Exception("Error Saving New Company."); } var company = await companyService.FindByNameAsync(newCompany.Name); return(new CompanyDto(company)); }
public async Task <IActionResult> Add(CompanyViewModel vm) { if (ModelState.IsValid) { var businessEntities = await _businessEntityService.GetAllAsync(); var businessEntity = businessEntities.FindBusinessEntity(vm.BusinessEntityName); if (businessEntity == null) { return(View("Company", vm)); } var dto = CompanyViewModel.ToDto(vm, businessEntity); var result = await _companyService.AddAsync(dto); if (result) { return(RedirectToAction("Index")); } } return(View("Company", vm)); }
public async Task <ActionResult <Company> > CreateAsync(Company company) { await _companyService.AddAsync(company); return(Ok(company)); }
public async Task <IActionResult> Register([FromBody] AccountViewModel model) { if (model != null) { try { var user = new User() { CompanyId = model.CompanyId, TenantId = tenant.Id, Active = model.Active, Email = model.Email, Password = model.Password, ConfirmPassword = model.ConfirmPassword, RecoveryEmail = model.RecoveryEmail, MobileNo = model.MobileNo, IsSystemAdministrator = model.IsSystemAdministrator, IsConfirmed = false, UserName = model.UserName, LockoutEnabled = model.LockoutEnabled, TwoFactorEnabled = model.TwoFactorEnabled }; var companies = await companyService.ListAsync(); if (companies.Count == 0) { var company = new Company { Code = tenant.Name, Name = tenant.Name, TenantId = tenant.Id }; await companyService.AddAsync(company); await companyService.SaveAsync(); user.CompanyId = company.Id; } var result = await userManager.CreateAsync(user, model.Password); if (result.Succeeded) { var confirmationCode = await userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.Action( controller: "Account", action: "ConfirmEmail", values: new { userId = user.Id, code = confirmationCode }, protocol: Request.Scheme); await emailSender.SendEmailAsync( email : user.Email, subject : "Confirm Email", htmlMessage : callbackUrl ); return(Ok(new { message = "User account registered successfully.", success = true })); } // await context.Users.AddAsync(user); // await context.SaveChangesAsync(); return(BadRequest(new { message = "Failed to register user account.", errors = result.Errors, success = false })); } catch (Exception ex) { return(StatusCode(StatusCodes.Status500InternalServerError, new { message = "An error has occurred while registering a new user.", success = false, details = ex.Message })); } } return(BadRequest()); }
public async Task Post([FromBody] CreateCompany company) { await _companyService.AddAsync(_mapper.Map <CreateCompany, CompanyDTO>(company)); }
public async Task <IActionResult> PostCompany([FromBody] Company company) { return(ApiOk(await CompanyService.AddAsync(company))); }
public async Task <ActionResult> Save(CompanyViewModel companyViewModel) { var companyDto = Mapper.Map <CompanyDto>(companyViewModel); companyDto.AspNetUserId = User.Identity.Name; if (!ModelState.IsValid) { companyViewModel = new CompanyViewModel(); return(View("CompanyForm", companyViewModel)); } if (companyDto.Id == 0) { var path = fileManager.GeneratePictureName("/Files/Companies/"); companyDto.PictureId = path; OperationDetails operationDetails = await companyService.AddAsync(companyDto); if (operationDetails.Succedeed) { if (companyViewModel.Picture.Upload != null) { companyViewModel.Picture.Upload .SaveAs(Server.MapPath(path)); } } else { ModelState.AddModelError(operationDetails.Property, operationDetails.Message); return(View("CompanyForm", companyViewModel)); } } else { var pictureLink = companyDto.PictureId; bool delete = true; if (pictureLink == null) { companyDto.PictureId = fileManager.GeneratePictureName("/Files/Companies/"); delete = false; } OperationDetails operationDetails = await companyService.EditAsync(companyDto); if (operationDetails.Succedeed) { if (companyViewModel.Picture.Upload != null) { if (delete) { var pathToPicture = Server.MapPath(pictureLink); if (fileManager.FileExists(pathToPicture)) { fileManager.Delete(pathToPicture); } } companyViewModel.Picture.Upload .SaveAs(Server.MapPath(pictureLink)); } } else { ModelState.AddModelError(operationDetails.Property, operationDetails.Message); return(View("CompanyForm", companyViewModel)); } } return(RedirectToAction("Index", "Companies")); }
public async Task <ActionResult> ActivateClient(string code) { DomainPendingClient model; try { model = await _pendingClientService.GetAndDeleteAsync(code); } catch (NotFoundException) { return((ActionResult)RedirectToAction("Index", "Home")); } catch (Exception e) { Trace.TraceError("Failed to find client: {0}", e); return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError)); } // Add profile var user = new DomainUser { ApplicationName = AppName, Name = model.ContactPerson, Country = model.Country, UserAgent = _productIdExtractor.Get(Request.UserAgent), Email = model.Email, Roles = new List <string> { DomainRoles.Client } }; try { user = await _userService.AddAsync(user); } catch (ConflictException) { return(new HttpStatusCodeResult(HttpStatusCode.Conflict)); } catch (Exception e) { Trace.TraceError("Failed to create user profile for {0}: {1}", model.Email, e); return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError)); } // Set user password try { await _passwordService.SetPasswordAsync(user.Id, model.Password, model.PasswordSalt); } catch (Exception e) { Trace.TraceError("Failed to set user {0} password: {1}", user.Id, e); return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError)); } // Add company var company = new DomainCompany { Email = model.Email, Name = model.CompanyName, Address = model.Address, ZipCode = model.ZipCode, Phone = model.PhoneNumber, Country = model.Country, Ein = model.Ein, Users = new List <string> { user.Id } }; try { await _companyService.AddAsync(company); } catch (Exception e) { Trace.TraceError("Failed to create company for user {0}: {1}", user.Id, e); return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError)); } // Authenticate await _authenticationService.SetUserAsync(user, null, true); return(RedirectToRoute(RouteNames.ClientSubscriptions)); }
public async Task <ActionResult <CompanyDTO> > Add(CompanyDTO companyDTO) { var company = await _companyService.AddAsync(companyDTO); return(company); }