public async Task <IHttpActionResult> Create(CreateCompanyViewModel model)
{
if (model.ParentId == 0)
{
if (String.IsNullOrEmpty(model.ParentUniqueIdentifier))
{
return(StatusCode(HttpStatusCode.Forbidden));
}
var company = _companyService.GetCompany(model.ParentUniqueIdentifier);
model.Logo = _imageHelper.SaveCompanyLogo($"prepopulatedPicture{company.LogoUrl}");
model.ParentId = company.Id;
}
var createCompanyQueue = CompanyServiceConstants.QueueCreateCompany;
model.ClientDbId = await _clientService.GetClientDbId("cloudplusAdminPortal");
await _messageBroker.GetSendEndpoint(createCompanyQueue)
.Send <ICreateCompanyCommand>(
model.ToCreateCompanyCommand()
);
return(Ok());
}
public void Create(CreateCompanyViewModel createCompanyViewModel)
{
//Should have called their service, not repo directly
//Create Address
var address = new Address
{
Id = Guid.NewGuid().ToString(),
StreetName = createCompanyViewModel.StreetName,
StreetNumber = createCompanyViewModel.StreetNumber,
BuildingNumber = createCompanyViewModel.BuildingNumber
};
_addressService.Create(address);
//Create company
//var compan = new Company { AddressId = "" };
var company = new Company
{
Id = Guid.NewGuid().ToString(),
IsActive = true,
CompanyName = createCompanyViewModel.CompanyName,
Telephone = createCompanyViewModel.Telephone,
ProvinceId = createCompanyViewModel.ProvinceId,
AddressId = address.Id,
CityId = createCompanyViewModel.CityId
};
_companyRepository.Insert(company);
}
public async Task <IActionResult> Create(CreateCompanyViewModel viewModel)
{
Company company = new Company();
if (ModelState.IsValid)
{
string path = Path.Combine(
_environment.WebRootPath,
$"images\\{viewModel.Title}\\");
string photo = $"/images/{viewModel.Title}/{viewModel.File.FileName}";
_fileUploadService.Upload(path, viewModel.File.FileName, viewModel.File);
company = new Company()
{
CommentCount = 0,
PhotoPath = photo,
Descriprion = viewModel.Description,
Title = viewModel.Title,
PhotoCount = 1,
};
ViewData["UserId"] = new SelectList(_context.ApplicaionUsers, "Id", "Id");
_context.Add(company);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(viewModel));
}
// GET: Company/Create
public IActionResult Create()
{
var model = new CreateCompanyViewModel();
model.Countries = new SelectList(Country.GetCountryList());
return(View(model));
}
public async Task <IActionResult> Create(CreateCompanyViewModel model)
{
Company company = new Company();
if (model != null)
{
company = new Company()
{
CompanyName = model.CompanyName,
ShortName = model.ShortName,
CompanyINN = model.CompanyINN,
CheckingAccount = model.CheckingAccount,
IndividualAddress = model.IndividualAddress,
LegalAddress = model.LegalAddress,
BIC = model.BIC,
Country = model.Country,
MailAddress = model.MailAddress
};
_context.Add(company);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public async Task <ActionResult> CreateCompany([FromBody] CreateCompanyViewModel model)
{
var command = this.mapper.Map <CreateCompanyViewModel, CreateCompanyCommand>(model);
var result = await this.mediator.Send(command);
return(StatusCode(201, result));
}
public static CompanyModel ToCompanyModel(this CreateCompanyViewModel company)
{
if (company == null)
{
return(null);
}
return(new CompanyModel
{
Name = company.Name,
ParentId = company.ParentId,
Status = CompanyStatus.Active,
Type = (CompanyType)company.Type,
StreetAddress = company.StreetAddress,
City = company.City,
State = company.State,
ZipCode = company.ZipCode,
PhoneNumber = company.PhoneNumber,
Email = company.Email,
BrandColorPrimary = company.BrandColorPrimary,
BrandColorSecondary = company.BrandColorSecondary,
BrandColorText = company.BrandColorText,
CatalogId = company.CatalogId,
LogoUrl = company.Logo,
Website = company.Website,
Country = company.Country,
Domains = company.Domains.Select(d => d.ToDomainModel()),
SupportSiteUrl = company.SupportSiteUrl,
ControlPanelSiteUrl = company.ControlPanelSiteUrl,
SendWelcomeLetters = company.User.SendWelcomeLetters
});
}
public IActionResult Create(CreateCompanyViewModel viewModel)
{
var model = viewModel.Company;
_createCompany.Execute(model);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create(CreateCompanyViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
viewModel.Company.Id = Guid.NewGuid();
_context.Add(viewModel.Company);
viewModel.PrimaryContact.Id = Guid.NewGuid();
viewModel.PrimaryContact.CompanyId = viewModel.Company.Id;
_context.Add(viewModel.PrimaryContact);
var site = new Site
{
Address = viewModel.Company.Address,
CompanyId = viewModel.Company.Id
};
_context.Add(site);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <int> Create(CreateCompanyViewModel viewModel)
{
var company = this._mapper.Map <CreateCompanyViewModel, Company>(viewModel);
await this._dbContext.AddAsync(company);
return(await this._dbContext.SaveChangesAsync());
}
public ActionResult CreateCompany()
{
// if (!userManager.IsInRole(User.Identity.GetUserId<int>(), "financeadmin")) return HttpNotFound();
var model = new CreateCompanyViewModel();
model.Roles = CreateUserAllowedRoles;
return(View(model));
}
public static Company ToCompany(this CreateCompanyViewModel model)
{
return(new Company
{
Name = model.Name,
TimezoneId = model.TimeZoneId
});
}
public Company Map(CreateCompanyViewModel model)
{
return(new Company
{
Name = model.Name,
LegalForm = model.LegalForm
});
}
private void PopulateCompany(CreateCompanyViewModel createCompanyViewModel, Company company)
{
company.Name = createCompanyViewModel.Name;
company.Description = createCompanyViewModel.Description;
company.LogoUrl = createCompanyViewModel.LogoUrl;
company.TypeId = createCompanyViewModel.TypeId;
company.CostId = createCompanyViewModel.CostId;
}
public ActionResult Create()
{
System.Diagnostics.Debug.WriteLine("Company");
var createCompanyViewModel = new CreateCompanyViewModel();
PopulateSelectLists(createCompanyViewModel);
return(View(createCompanyViewModel));
}
public async Task <CreateCompanyViewModel> CreateAsync(CreateCompanyViewModel model)
{
var company = mapper.Map(model);
await companyRepository.AddAsync(company);
await dataContext.SaveChangeAsync();
return(model);
}
// GET: CompanyController/Create
public ActionResult Create()
{
CreateCompanyViewModel createCompanyViewModel = new CreateCompanyViewModel
{
Provinces = _addressService.GetAllProvinces(),
Cities = _addressService.GetAllCities()
};
return(View(createCompanyViewModel));
}
public async Task <IActionResult> Create(CreateCompanyViewModel viewModel)
{
if (ModelState.IsValid)
{
await this._companiesService.Create(viewModel);
return(RedirectToAction(nameof(Index)));
}
return(View(viewModel));
}
public async Task <Companies> Edit(Guid id, CreateCompanyViewModel company)
{
Companies editedCompany = new Companies()
{
Id = id, Name = company.Name, OrganizationNumber = company.OrganizationNumber, Notes = company.Notes
};
await _companiesRepo.Update(editedCompany);
return(editedCompany);
}
public async Task <IActionResult> Create(CreateCompanyViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await companyService.CreateAsync(model);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Post([FromBody] CreateCompanyViewModel model)
{
if (string.IsNullOrWhiteSpace(model.Name) || model.Name.Length < 3)
{
return(BadRequest(model.Name));
}
var companyId = _companyService.CreateCompany(model.Name, GetUserId());
return(CreatedAtAction("Get", new { id = companyId }, companyId));
}
public async Task <IActionResult> CreateCompany(CreateCompanyViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var createModel = _mapper.Map <CompanyServiceModel>(model);
await _adminService.CreateCompany(createModel);
return(RedirectToAction(nameof(Companies)));
}
public async Task <IActionResult> Edit(Guid id, CreateCompanyViewModel createCompanyViewModel)
{
if (ModelState.IsValid)
{
if (await _companiesService.Edit(id, createCompanyViewModel) != null)
{
return(RedirectToAction(nameof(Index)));
}
ModelState.AddModelError("System", "Failed to edit");
}
return(View(createCompanyViewModel));
}
public IActionResult Create(CreateCompanyViewModel model)
{
if (ModelState.IsValid)
{
var companyId = Guid.NewGuid().ToString();
string shortCode = GenerateShortcode();
var newCompany = new Company(companyId, shortCode, model.CompanyName);
companyRepository.Insert(newCompany);
InsertUserCompany(companyId, model.UserId);
InsertRoleCompany(companyId);
InsertUserRoleCompany(companyId, model.UserId);
return(RedirectToAction("/home/listusers", shortCode));
}
return(View());
}
public int?Create(CreateCompanyViewModel company)
{
var objCompany = new Company(company.Name);
_companyRepository.Create(objCompany);
if (!IsError() && _companyRepository.ExistCompanyNameDapper(objCompany.Name))
{
AddError("Company already exists");
}
if (Commit())
{
return(objCompany.IdCompany);
}
return(null);
}
public IActionResult CreateCompany(CreateCompanyViewModel model)
{
Company company = new Company(model.CompanyName);
if (company != null)
{
if (!_companyHandler.CheckIfCompanyNameExists(company.CompanyName))
{
_companyHandler.Create(ModelConverter.ConvertModelToCompanyDto(company));
return(RedirectToAction("RegisterEmployer", "Account", new { id = company.CompanyId }));
}
ModelState.AddModelError("", "Company name already exists");
}
return(View());
}
public async Task Create(CreateCompanyViewModel model)
{
var company = new Company
{
Name = model.Name,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
FullAddres = model.FullAddres,
CreatedOn = DateTime.UtcNow,
IsDeleted = false
};
await this.companyRepository.AddAsync(company);
await this.companyRepository.SaveChangesAsync();
}
public IActionResult CreateCompany(CreateCompanyViewModel model)
{
if (ModelState.IsValid)
{
Company newCompany = new Company
{
CompanyName = model.CompanyName,
Address = model.Address,
ContactName = model.ContactName,
ContactEmail = model.ContactEmail,
ContactPhone = model.ContactPhone
};
_manageEmployment.AddCompany(newCompany);
return(RedirectToAction("index", "home"));
}
return(View());
}
public ActionResult Add(CreateCompanyViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (_companyService.Get(model.Name) != null)
{
ModelState.AddModelError("Name", "Company's name already registered");
return(View(model));
}
_companyService.Add(model.ToCompany());
return(RedirectToAction("Index"));
}
public async Task <IActionResult> CreateCompany(CreateCompanyViewModel model)
{
var user = await _userManager.GetUserAsync(User);
var company = new Company
{
Title = model.Title,
Description = model.Description,
Avatar = await _fileKeeper.KeepFileAsync("/images/CompanyAvatars", model.File.FileName, model.File),
UserId = user.Id
};
_db.Companies.Add(company);
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(CompaniesManagment)));
}
