public IActionResult Add()
{
CompanyCreateViewModel model = new CompanyCreateViewModel();
model.Countries = GetCountries();
return(View(model));
}
public async Task <IActionResult> Create(CompanyCreateCheckNameViewModel companyModel)
{
if (ModelState.IsValid)
{
var companyBinding = new CompanyCreateViewModel
{
Name = companyModel.Name,
Address = companyModel.Address,
FieldOfService = companyModel.FieldOfService
};
var userId = this.userManager.GetUserId(this.User);
var userFromDb = this.userService.GetCurrentUserFromDb(userId);
this.companyService.CreateCompany(companyBinding, userFromDb);
if (!await roleManager.RoleExistsAsync(GlobalConstants.RoleAdmin))
{
await this.roleManager.CreateAsync(new IdentityRole()
{
Name = GlobalConstants.RoleAdmin
});
}
await this.userManager.AddToRoleAsync(userFromDb, GlobalConstants.RoleAdmin);
await this.signInManager.SignOutAsync();
return(Redirect("/Identity/Account/Login"));
}
return(this.View());
}
public void CreateCompanySouldCreateCompanyAndAddInDb()
{
var options = new DbContextOptionsBuilder <TaskPlannerDbContext>()
.UseInMemoryDatabase(databaseName: "Company_CreateCompany_Database")
.Options;
var dbContext = new TaskPlannerDbContext(options);
var companyModel = new CompanyCreateViewModel
{
Name = "DataCenter",
Address = "asd",
FieldOfService = "IT"
};
var user = new ApplicationUser
{
Email = "*****@*****.**",
FullName = "Pesho Peshev"
};
var companyService = new CompanyService(dbContext, null);
companyService.CreateCompany(companyModel, user);
var company = dbContext.Companies.FirstOrDefault(x => x.Name == companyModel.Name);
Assert.Equal(companyModel.Name, company.Name);
Assert.Equal(companyModel.Address, company.Address);
Assert.Equal(companyModel.FieldOfService, company.FieldOfService);
}
public async Task <IActionResult> Create(CompanyCreateViewModel company)
{
//create new instance of company
var c = new Company()
{
Name = company.Name,
Address = company.Address,
City = company.City,
State = company.State,
Zip = company.Zip,
Phone = company.Phone
};
_context.Company.Add(c);
_context.SaveChanges();
//create new instance of CompanyNote
var note = new CompanyNotes()
{
User = await _userManager.GetUserAsync(User),
CompanyId = c.Id,
Notes = company.Note
};
_context.CompanyNotes.Add(note);
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create([FromBody] CompanyCreateViewModel companyViewModel)
{
var company = _mapper.Map <Company>(companyViewModel);
await _companyService.CreateAsync(company);;
return(ResponseHelper.Ok(company));
}
public async Task <IActionResult> CreateCompany(CompanyCreateViewModel input)
{
var user = await this.userManager.GetUserAsync(this.User);
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
var img = await this.fileService.UploadImageFileAsync(input.PictureFile, user.Id, "CompanyLogo");
int result = this.companyService.AddCompany(
input.CompanyName,
input.SanitizedCompanyDescription,
input?.CompanyWebsite,
input?.FacebookWebsite,
input?.TwitterWebsite,
input?.LinkedInWebsite,
img?.SecureUri.ToString(),
user.Id).Result;
if (result < 0)
{
return(this.View(input));
}
return(this.RedirectToAction("Index"));
}
public IActionResult Create(CompanyCreateViewModel model)
{
try
{
if (ModelState.IsValid)
{
if (model.Photo != null)
{
model.CreatedDate = DateTime.Now;
model.CreatedBy = User.Identity.Name;
model.PhotoPath = ProcessUploadFile(model);
}
var response = _companyRepository.Create(model);
if (response != null && response.Id != 0)
{
return(RedirectToAction("CompanyList"));
}
}
return(View(model));
}
catch (Exception ex)
{
_logger.LogError(ex, $"When trying to create a new company.");
throw;
}
//TODO Implement error model.
}
public IActionResult AddCompany(CompanyCreateViewModel model)
{
if (ModelState.IsValid)
{
var result1 = _rsApplication.CreateCompany(model);
return(Ok(result1));
}
return(Json(ModelState.Values.Where(m => m.Errors.Count > 0).Select(s => s.Errors)));
}
public static CompanyCreateViewModel Map(CompanyCreateViewDtoModel viewModelDto)
{
var viewModel = new CompanyCreateViewModel
{
CategoryNames = viewModelDto.CategoryNames,
TownNames = viewModelDto.TownNames
};
return(viewModel);
}
public string Create([Bind(Include = "Id,Name,City")] CompanyCreateViewModel companyCreateViewModel)
{
if (ModelState.IsValid)
{
var company = _mapper.Map <Company>(companyCreateViewModel);
_repositoryCompany.Add(company);
return(JsonConvert.SerializeObject(company));
}
return("Failure to create company");
}
public IActionResult Create(CompanyCreateViewModel companyCreateViewModel)
{
var json = JsonConvert.SerializeObject(companyCreateViewModel);
var data = new StringContent(json, Encoding.UTF8, "application/json");
var result = _client.PostAsync("api/companies", data).Result;
if (result.StatusCode == System.Net.HttpStatusCode.OK)
{
return(Redirect("/site/vertical/table-company.html"));
}
return(Redirect("/site/vertical/create-company.html"));
}
public CompanyCreateViewModel GetCompanyCreateParams()
{
List <string> townNames = this.townService.GetAllTowns().Select(x => x.Name).ToList();
List <string> categoryNames = this.useFullCategoryService.GetAllUseFullCategories().Select(x => x.Name).ToList();
CompanyCreateViewModel viewModel = new CompanyCreateViewModel()
{
TownNames = townNames,
CategoryNames = categoryNames,
};
return(viewModel);
}
public bool CreateCompany(CompanyCreateViewModel model)
{
using (var context = new ApplicationDbContext())
{
var entity =
new Company()
{
CompanyAmount = 0,
CompanyName = model.CompanyName
};
context.Company.Add(entity);
return(context.SaveChanges() == 1);
}
}
private string ProcessUploadFile(CompanyCreateViewModel model)
{
string uniqueFileName = null;
if (model.Photo != null)
{
var uploadsFolder = Path.Combine(_webHostEnvironment.WebRootPath, "images");
uniqueFileName = $"{Guid.NewGuid().ToString()}_{model.Photo.FileName}";
var filePath = Path.Combine(uploadsFolder, uniqueFileName);
using FileStream fileStream = new FileStream(filePath, FileMode.Create);
model.Photo.CopyTo(fileStream);
}
return(uniqueFileName);
}
public void CreateCompany(CompanyCreateViewModel company, ApplicationUser user)
{
var companyForAdd = new Company
{
Name = company.Name,
FieldOfService = company.FieldOfService,
Address = company.Address
};
user.CompanyName = companyForAdd.Name;
user.IsPromoted = true;
companyForAdd.TeamMembers.Add(user);
this.AddCompanyDefaultProjects(companyForAdd);
this.dbContext.Companies.Add(companyForAdd);
this.dbContext.SaveChanges();
}
public IActionResult Register(CompanyCreateViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var user = new CompanyUser
{
FullName = viewModel.FullName,
Password = viewModel.Password,
Username = viewModel.Username
};
var company = new Company
{
Name = viewModel.Name,
Address = viewModel.Address,
Email = viewModel.Email
};
user.Company = company;
// check for the company profile image
if (viewModel.File != null)
{
user.Company.ProfilePicture = SaveFile(viewModel.File);
}
// Create session
var session = new CompanySession
{
User = user,
Token = Guid.NewGuid().ToString()
};
_db.Add(session);
_db.SaveChanges();
Response.Cookies.Append(SESSION_KEY, session.Token, new CookieOptions
{
Path = "/"
});
return(RedirectToAction("Index", "Home"));
}
// POST /api/Company
public IHttpActionResult Post(CompanyCreateViewModel company)
{
if (company == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CompanyService companyService = CreateCompanyService();
companyService.CreateCompany(company);
return(Ok());
}
public Result <CompanyReturnDto> CreateCompany(CompanyCreateViewModel model)
{
var result = new Result <CompanyReturnDto>();
if (_db.Company.Any(s => s.Name == model.Name && !s.Deleted))
{
result.Success = false;
}
else
{
var comapny = _db.Company.Add(new Company {
Name = model.Name, CompanyScaleId = model.ScaleId, CompanyTypeId = model.TypeId, CompanyWorkLineId = model.WorklineId
});
_db.SaveChanges();
result.Success = true;
var returnModel = new CompanyReturnDto(comapny.Entity);
result.Response = returnModel;
}
return(result);
}
public async Task <IActionResult> Add(CompanyCreateViewModel model)
{
if (ModelState.IsValid && !(dbContext.Companies.Any(c => c.Title == model.Title)))
{
var user = await userManager.FindByNameAsync(model.AssignedUser);
Company company = new Company
{
UserId = user.Id,
Title = model.Title,
Country = model.Country,
Town = model.Town,
Description = model.Description
};
companyRepository.Add(company, user);
return(RedirectToAction("Details", "Company", new { id = company.Id }));
}
model.Countries = GetCountries();
return(View(model));
}
public ActionResult Create(CompanyCreateViewModel companyCreateViewModel)
{
if (ModelState.IsValid)
{
companyCreateViewModel.Company.Id = Guid.NewGuid();
companyCreateViewModel.Company.CreateDate = DateTime.Now;
companyCreateViewModel.Company.CreatedByUserId = Guid.Parse(User.Identity.GetUserId());
var contactId = Guid.NewGuid();
companyCreateViewModel.Contact.Id = contactId;
companyCreateViewModel.Company.ContactId = contactId;
companyCreateViewModel.Contact.CreateDate = DateTime.Now;
companyCreateViewModel.Contact.CreatedByUserId = Guid.Parse(User.Identity.GetUserId());
var companyAddressId = Guid.NewGuid();
companyCreateViewModel.CompanyAddress.Id = companyAddressId;
companyCreateViewModel.Company.CompanyAddressId = companyAddressId;
companyCreateViewModel.Company.CreateDate = DateTime.Now;
companyCreateViewModel.Company.CreatedByUserId = Guid.Parse(User.Identity.GetUserId());
companyCreateViewModel.CompanyAddress.CreateDate = DateTime.Now;
companyCreateViewModel.CompanyAddress.CreatedByUserId = Guid.Parse(User.Identity.GetUserId());
db.Contacts.Add(companyCreateViewModel.Contact);
db.CompanyAddresses.Add(companyCreateViewModel.CompanyAddress);
db.Companies.Add(companyCreateViewModel.Company);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CompanyAddressId = new SelectList(db.CompanyAddresses, "Id", "Address1", companyCreateViewModel.Company.CompanyAddressId);
ViewBag.ContactId = new SelectList(db.Contacts, "Id", "Name", companyCreateViewModel.Company.ContactId);
return(View(companyCreateViewModel));
}
public CompanyCreatePage()
{
InitializeComponent();
model = new CompanyCreateViewModel();
DataContext = model;
}
