public bool CreateNewCompany(CompanyCreateModel companyCreateModel)
{
bool check = false;
if (companyCreateModel != null)
{
Company company = new Company
{
CompanyId = Guid.NewGuid(),
Password = companyCreateModel.Password,
CompanyName = companyCreateModel.CompanyName,
Address = companyCreateModel.Address,
Email = companyCreateModel.Email,
Phone = companyCreateModel.Phone,
Status = true,
Avatar = companyCreateModel.Avatar,
CreatedDate = DateTime.UtcNow,
TaxIdentificationNumber = companyCreateModel.TaxIdentificationNumber
};
_unitOfWork.GetRepository <Company>().Insert(company);
_unitOfWork.Commit();
check = true;
}
return(check);
}
public async Task <CompanyResponseModel> CreateAsync(CompanyCreateModel model)
{
var newCompany = _mapper.Map <Company>(model);
var createdCompany = await _companyService.CreateAsync(newCompany);
return(_mapper.Map <CompanyResponseModel>(createdCompany));
}
public async Task <int> CreateAsync(CompanyCreateModel input)
{
var industryId = await this.industriesService.CreateAsync(input.IndustryName);
var addressId = await this.addressService.CreateAsync(input.Country, input.City, input.Street, input.ZipCode);
var user = await this.userRepository
.All()
.Where(x => x.Id == input.UserId)
.FirstOrDefaultAsync();
var company = new Company
{
Name = input.Name,
Description = input.Description,
IsPublic = input.IsPublic,
IndustryId = industryId,
AddressId = addressId,
};
await this.companyRepository.AddAsync(company);
await this.companyRepository.SaveChangesAsync();
user.Company = company;
this.userRepository.Update(user);
return(await this.userRepository.SaveChangesAsync());
}
public async Task <CompanyCreateModel> UpdateCompany(CompanyCreateModel data)
{
try
{
CompanyCreateModel model = null;
switch (data.companyType)
{
case "MSP":
tblMSPDetail dataMSP = await Task.Run(() => ManageMSP.UpdateMSP(data.ConvertTotblMSPDetail()));
model = dataMSP.ConvertTocompany();
break;
case "Customer":
tblCustomer dataCustomer = await Task.Run(() => ManageCustomer.UpdateCustomer(data.ConvertTotblCustomer()));
model = dataCustomer.ConvertTocompany();
break;
case "Supplier":
tblSupplier dataSupplier = await Task.Run(() => ManageSupplier.UpdateSupplier(data.ConvertTotblSupplier()));
model = dataSupplier.ConvertTocompany();
break;
}
return(model);
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> Post(CompanyCreateModel model)
{
var createdCompany = await _companyService.CreateAsync(model);
var response = new Response(createdCompany);
var getParams = new { createdCompany.Id };
return(CreatedAtAction(nameof(Get), getParams, response));
}
public async Task <IActionResult> Post([FromBody] CompanyCreateModel model)
{
_logger.LogInformation($"Create new videoGame : {HttpContext.Request.Query} ");
if (await _service.CreateAsync(_mapper.Map <CompanyDTO>(model)))
{
return(Ok());
}
return(BadRequest());
}
public async Task <ResponseModel <Company> > CreateCompany([FromBody] CompanyCreateModel model)
{
var userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
var result = await _companyService.CreateCompany(userId, model);
Response.StatusCode = (int)HttpStatusCode.Created;
return(new ResponseBuilder <Company>()
.Success()
.Data(result)
.build());
}
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 ActionResult Create(CompanyCreateModel model)
{
try
{
manager.SaveCreateModel(model);
return(Ok());
}
catch (Exception ex)
{
return(Problem());
}
}
public async Task <string> CreateCompany(CompanyCreateModel model)
{
var company = new Company();
company.CompanyName = model.CompanyName;
company.Address = model.Address;
company.Capital = model.Capital;
company.TotalShares = model.TotalShares;
company.OptionPoll = model.OptionPoll;
_CompanyRepository.Insert(company);
await _UnitOfWork.CommitAsyn();
return(ApiResponse.Ok());
}
public async Task <IHttpActionResult> UpdateCompany(CompanyCreateModel data)
{
try
{
string userId = User.Identity.GetUserId();
Helpers.Helpers.AddBaseProperties(data, "update", userId);
return(Ok(await CompanyService.UpdateCompany(data)));
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> Create(string userId)
{
var user = await this.userManager.GetUserAsync(this.User);
if (user.CompanyId != null)
{
return(this.RedirectToAction("Index", "Dashboard"));
}
var viewModel = new CompanyCreateModel
{
UserId = userId,
};
return(View(viewModel));
}
public async Task <IActionResult> Create([FromBody] CompanyCreateModel model)
{
using (var client = clientHelper.GetServiceSecuredClient(User))
{
var resp = await client.PostAsync(this.routeTable.GetRoute(SvcRouteTable.CompanyCreate),
new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8, "application/json"));
if (!resp.IsSuccessStatusCode)
{
return(new StatusCodeResult((int)resp.StatusCode));
}
var content = await resp.Content.ReadAsStringAsync();
return(Content(content));
}
}
//
public IdentityCompany ExtractCreateFormData(CompanyCreateModel formData)
{
var myIdentity = new IdentityCompany();
myIdentity.Code = formData.Code;
myIdentity.Name = formData.Name;
myIdentity.CountryId = formData.CountryId;
myIdentity.ProvinceId = formData.ProvinceId;
myIdentity.DistrictId = formData.DistrictId;
myIdentity.Address = formData.Address;
myIdentity.Email = formData.Email;
myIdentity.Phone = formData.Phone;
myIdentity.IsEPE = formData.IsEPE;
myIdentity.Status = formData.Status;
return(myIdentity);
}
public IActionResult CreateCompany([FromBody] CompanyCreateModel companyCreateModel)
{
if (companyCreateModel == null)
{
return(BadRequest("Error"));
}
bool check = _companyLogic.CreateNewCompany(companyCreateModel);
if (check)
{
return(Ok("Create New Company Successful"));
}
else
{
return(BadRequest("Cannot Create New Company"));
}
}
public async Task <ActionResult <CompanyModel> > PostCompany(CompanyCreateModel model)
{
var result = Check(Operation.Create);
if (result.Fail())
{
return(result);
}
var entity = new Company
{
Name = model.Name
};
DB_TABLE.Add(entity);
await DB.SaveChangesAsync();
var user = new AspNetUser {
UserName = model.Name, Email = model.Email, Company_Id = entity.Id, Level = AspNetUserLevel.Company
};
var identityResult = await UserManager.CreateAsync(user, model.Password);
if (identityResult.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false);
if (User.Identity is ClaimsIdentity)
{
((ClaimsIdentity)User.Identity).AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id.ToString(), ClaimValueTypes.Integer64));
Log(DB_TABLE.GetName(), Operation.Create, null, GetModel(entity));
Log(DB.Users.GetName(), Operation.Create, null, model);
}
return(CreatedAtAction(nameof(GetCompany), new { id = entity.Id }, GetModel(entity)));
}
if ((entity = await DB_TABLE.FindAsync(entity.Id)) != null)
{
DB_TABLE.Remove(entity);
await DB.SaveChangesAsync();
}
return(BadRequest(string.Join(";", identityResult.Errors.Select(e => e.Description))));
}
public async Task <IActionResult> EditAsync(int id, [FromBody] CompanyCreateModel company)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!await companyService.ExistsAsync(id))
{
return(NotFound());
}
await companyService
.EditAsync(id, company.Name, company.CreationDate);
return(NoContent());
}
public async Task <IActionResult> Create(CompanyCreateModel input)
{
var user = await this.userManager.GetUserAsync(this.User);
if (user.CompanyId != null)
{
return(this.RedirectToAction("Index", "Dashboard"));
}
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
await this.companiesService.CreateAsync(input);
return(this.RedirectToAction("Index", "Dashboard"));
}
public IActionResult CreateCompany([FromBody] CompanyCreateModel model)
{
try
{
var companyCreateDto = new CompanyCreateDto
{
Name = model.Name,
UserId = model.UserId,
Type = model.Type,
Description = model.Description
};
var data = _service.CreateCompany(companyCreateDto);
return(Ok(data));
}
catch (ValidationException ex)
{
return(BadRequest(ex.Message));
}
}
//public ActionResult Create()
//{
// var createModel = new CompanyCreateModel();
// return View(createModel);
//}
public ActionResult Create()
{
var createModel = new CompanyCreateModel();
try
{
//createModel.MinInventory = "0";
createModel.Countrys = CommonHelpers.GetListCountry();
//createModel.ProvinceId = CommonHelpers.GetProvinceByCountry(listCountry.Id);
//createModel.DistrictId = CommonHelpers.GetDistrictByProvince(listProvince.Id);
}
catch (Exception ex)
{
this.AddNotification(NotifSettings.Error_SystemBusy, NotificationType.ERROR);
logger.Error("Failed display Create Product page: " + ex.ToString());
}
return(View(createModel));
}
public static tblCustomer ConvertTotblCustomer(this CompanyCreateModel data)
{
return(new tblCustomer()
{
ID = Convert.ToInt64(data.id),
Name = data.companyName,
EmailAddress = data.companyEmail,
PhoneNumber = data.companyPhoneNumber,
Address = data.companyAddress,
City = data.companyCity,
WebSite = data.companyWebsite,
CountryID = Convert.ToInt64(data.CountryID),
StateID = Convert.ToInt64(data.StateID),
CreatedUserID = data.createdUserID,
UpdatedUserID = data.updatedUserID,
CreatedTimestamp = data.createdTimestamp ?? DateTime.Now,
UpdatedTimestamp = data.updatedTimestamp ?? DateTime.Now,
LogoPath = data.LogoPath
});
}
public ActionResult Create(CompanyCreateModel model)
{
var newId = 0;
if (!ModelState.IsValid)
{
string messages = string.Join("; ", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage + x.Exception));
this.AddNotification(messages, NotificationType.ERROR);
return(View(model));
}
try
{
var info = ExtractCreateFormData(model);
newId = _mainStore.Insert(info);
if (newId > 0)
{
this.AddNotification(ManagerResource.LB_INSERT_SUCCESS, NotificationType.SUCCESS);
}
else
{
this.AddNotification(NotifSettings.Error_SystemBusy, NotificationType.ERROR);
}
}
catch (Exception ex)
{
this.AddNotification(NotifSettings.Error_SystemBusy, NotificationType.ERROR);
logger.Error("Failed for Create Product request: " + ex.ToString());
return(View(model));
}
//return RedirectToAction("Edit/" + newId);
return(RedirectToAction("Create"));
}
public ActionResult Register(CompanyCreateModel m)
{
try
{
Company client = new Company();
client.Name = m.Name;
// client.TicketStartNumber = Convert.ToInt32(m.TicketStartNumber);
CRMUser user = new CRMUser()
{
Username = m.EmailId, Password = m.Password
};
CompanyManager <Company> clientManager = new CompanyManager <Company>(new CompanyStore <Company>());
clientManager.CreateClient <CRMUser>(client, user);
return(View("RegisterSuccess"));
}
catch (Exception ex)
{
ModelState.AddModelError("CC", ex.Message);
return(View(m));
}
}
/// <summary>
/// Create the specified model.
/// </summary>
/// <param name="userId"></param>
/// <param name="model">The model.</param>
/// <returns></returns>
/// <exception cref="UnauthorizedUser"></exception>
public async Task <Company> CreateCompany(string userId, CompanyCreateModel model)
{
if (ValidateUtils.IsNullOrEmpty(userId))
{
throw new UnauthorizedUser();
}
var company = new Company
{
AdminProfileId = Guid.Parse(userId),
CompanyName = model.CompanyName,
CompanyDescription = model.CompanyDescription,
Address = model.Address,
Phone = model.Phone,
Capital = model.Capital,
TotalShares = model.TotalShares,
};
var inserted = _companyRepository.Insert(company).Entity;
await _unitOfWork.CommitAsync();
return(inserted);
}
public async Task <CompanyCreateModel> GetCompany(CompanyModel data)
{
try
{
CompanyCreateModel model = null;
long Id = data != null?Convert.ToInt64(data.id) : 0;
switch (data.companyType)
{
case "MSP":
long id = Convert.ToInt64(ConfigurationManager.AppSettings["MSP_ID"]);
Id = id != null ? id : Id;
tblMSPDetail dataMSP = await Task.Run(() => ManageMSP.GetMSPDetails(Id));
model = dataMSP.ConvertTocompany();
break;
case "Customer":
tblCustomer dataCustomer = await Task.Run(() => ManageCustomer.GetCustomerDetails(Id));
model = dataCustomer.ConvertTocompany();
break;
case "Supplier":
tblSupplier dataSupplier = await Task.Run(() => ManageSupplier.GetSupplierDetails(Id));
model = dataSupplier.ConvertTocompany();
break;
}
return(model);
}
catch (Exception)
{
throw;
}
}
public void SaveCreateModel(CompanyCreateModel model)
{
}
public async Task <string> CreateCompany([FromBody] CompanyCreateModel model)
{
return(await _customerAppService.CreateCompany(model));
}
public async Task <JsonResult> Create(CompanyCreateModel ccm, EmployerRegistrationController.EmployerRegistration er)
{
//Create payment periodicity
PaymentPeriodicity pp;
if (ccm.PeriodType == "Weekly")
{
pp = PaymentPeriodicity.Weekly;
}
else if (ccm.PeriodType == "BiWeekly")
{
pp = PaymentPeriodicity.Biweekly;
}
else
{
pp = PaymentPeriodicity.Monthly;
}
//Create employer registration
EmployerRegistration employerRegistration = null;
if (ccm.HasIMSS)
{
var employerRegistrationAddress = new Address
{
ID = Guid.NewGuid(),
ZipCode = er.ZipCode,
FederalEntity = er.FederalEntity,
Municipality = er.Municipality,
Reference = "",
ExteriorNumber = "",
InteriorNumber = "",
Street = "",
Suburb = "",
//Common
Name = String.Empty,
Description = String.Empty,
StatusID = 1,
user = SessionModel.IdentityID,
Timestamp = DateTime.Now,
DeleteDate = null,
Active = true,
company = SessionModel.CompanyID,
InstanceID = SessionModel.InstanceID,
CreationDate = DateTime.Now,
};
employerRegistration = new EmployerRegistration
{
ID = Guid.NewGuid(),
Code = er.Code.ToUpper(),
RiskClass = er.RiskClass,
RiskClassFraction = er.RiskClassFraction,
AddressID = employerRegistrationAddress.ID,
Address = employerRegistrationAddress,
//Common
Active = true,
company = SessionModel.CompanyID,
InstanceID = SessionModel.InstanceID,
CreationDate = DateTime.Now,
Description = String.Empty,
StatusID = 1,
user = SessionModel.IdentityID,
Timestamp = DateTime.Now,
DeleteDate = null,
Name = String.Empty,
};
}
//Create company and employer registration addresses
var companyAddress = new Address
{
ID = Guid.NewGuid(),
ZipCode = er.ZipCode,
FederalEntity = er.FederalEntity,
Municipality = er.Municipality,
Reference = "",
ExteriorNumber = "",
InteriorNumber = "",
Street = "",
Suburb = "",
//Common
Name = String.Empty,
Description = String.Empty,
StatusID = 1,
user = SessionModel.IdentityID,
Timestamp = DateTime.Now,
DeleteDate = null,
Active = true,
company = SessionModel.CompanyID,
InstanceID = SessionModel.InstanceID,
CreationDate = DateTime.Now,
};
//Create payroll configuration
var payrollConfiguration = new PayrollCompanyConfiguration()
{
//Step 1
RFC = ccm.CompanyRFC.ToUpper(),
CURP = String.IsNullOrEmpty(ccm.CompanyCURP) ? "" : ccm.CompanyCURP.ToUpper(),
SocialReason = ccm.CompanySocialReason,
SalaryZone = Enum.Parse <SalaryZone>(ccm.SalaryZone),
FiscalRegime = ccm.FiscalRegime,
AddressID = companyAddress.ID,
Address = companyAddress,
CurrencyID = ccm.CurrencyID,
//Step 2
//EmployerRegistration
//Step 3
PaymentPeriodicity = pp, //This is used as PeriodType (...)
CurrentExerciseYear = ccm.CurrentFiscalYear,
PeriodInitialDate = ccm.InitialDate,
CurrentPeriod = ccm.CurrentPeriod,
//PeriodTotalDays = ccm.PeriodTotalDays, (internally calculated)
PaymentDays = ccm.PaymentDays,
WeeklySeventhDay = ccm.WeeklySeventhDay,
AdjustmentPay = ccm.FortnightPaymentDays,
NonDeducibleFactor = ccm.NonDeductibleFactor,
//Step 4
CompanyInformation = ccm.CompanyInformation,
ComercialName = ccm.ComercialName,
CompanyScope = ccm.CompanyScope,
CompanyBusinessSector = ccm.CompanyBusinessSector,
CompanyCreationDate = ccm.CompanyCreationDate,
CompanyWebSite = ccm.CompanyWebSite,
Facebook = ccm.Facebook,
Instagram = ccm.Instagram
};
var res = await client.InitializeAsync(
SessionModel.AuthorizationHeader,
Guid.Parse(CommonUX.SecurityUX.DecryptString(ccm.LicenseServiceID)),
ccm.CompanySocialReason,
ccm.CompanyRFC.ToUpper(),
payrollConfiguration,
employerRegistration
);
return(Json(new
{
CompanyID = CommonUX.SecurityUX.EncryptString(res.CompanyID.ToString(), SessionModel.EncryptKey),
InstanceID = CommonUX.SecurityUX.EncryptString(res.InstanceID.ToString(), SessionModel.EncryptKey),
LicenseID = CommonUX.SecurityUX.EncryptString(res.LicenseID.ToString(), SessionModel.EncryptKey),
LicenseServiceID = CommonUX.SecurityUX.EncryptString(res.LicenseServiceID.ToString(), SessionModel.EncryptKey)
}));
}
