public IActionResult Delete(int id)
{
var model = new TenantViewModel();
model.Delete(id);
return(LocalRedirect("/Admin/Tenant/Index"));
}
public IActionResult GenerateBill(TenantViewModel model)
{
model.InitiateTenant(model.Id);
model.InitiateReading(model.Id, model.MonthPicker.AddMonths(-1));
// model.TotalCalculate();
return(View(model));
}
public void ProvisionTenant(TenantViewModel tenant, StaffViewModel administrator)
{
ProvisionTenantCommand command = new ProvisionTenantCommand(
tenant.Name,
tenant.Description,
administrator.FirstName,
administrator.LastName,
administrator.EmailAddress,
administrator.PrimaryTelephone,
administrator.SecondaryTelephone,
administrator.AddressStreetAddress,
administrator.AddressCity,
administrator.AddressStateProvince,
administrator.AddressPostalCode,
administrator.AddressCountryCode
);
var _tenant = _identityApplicationService.ProvisionTenant(command).Result;
TenantCreatedEvent tenantCreatedEvent = new TenantCreatedEvent(
_tenant.Id,
_tenant.Name,
_tenant.Description
);
_eventPublisher.Publish <TenantCreatedEvent>(tenantCreatedEvent);
}
public async Task <IActionResult> Index()
{
var signedUserId = _userTable.GetUserId(HttpContext.User.Identity.Name);
var model = new TenantViewModel()
{
AllUsers = _userTable.GetAllUsers(),
AllProject = _projectTable.GetAllProjects(),
UsersNotManager = new List <SelectListItem>(),
Managers = new List <User>()
};
foreach (var user in model.AllUsers)
{
if (!await _userMgr.IsInRoleAsync(user, nameof(Roles.Manager)))
{
var text = user.FirstName + " " + user.Surname + " - " + user.Email;
model.UsersNotManager.Add(new SelectListItem {
Text = text, Value = user.Id.ToString()
});
}
else if (user.Id != signedUserId)
{
model.Managers.Add(user);
}
}
return(View(model));
}
public void ProvisionTenant(TenantViewModel tenant, StaffViewModel administrator)
{
ProvisionTenantCommand command = new ProvisionTenantCommand(
tenant.Name,
tenant.Description,
administrator.FirstName,
administrator.LastName,
administrator.EmailAddress,
administrator.PrimaryTelephone,
administrator.SecondaryTelephone,
administrator.AddressStreetAddress,
administrator.AddressCity,
administrator.AddressStateProvince,
administrator.AddressPostalCode,
administrator.AddressCountryCode
);
var _tenant = _identityApplicationService.ProvisionTenant(command);
//TenantCreatedEvent tenantCreatedEvent = new TenantCreatedEvent(
// Guid.Parse(_tenant.TenantId_Id),
// _tenant.Name,
// _tenant.Description
//);
//_eventPublisher.Publish<TenantCreatedEvent>(tenantCreatedEvent);
//_businessInformationService.ProvisionSite(_tenant.TenantId.Id, _tenant.Name,
//_tenant.Description, _tenant.Active);
}
public async Task UpdateAsync(TenantViewModel model)
{
var tenant = _mapper.Map <Tenant>(model);
_tenantRepository.Update(tenant);
await _unitOfWork.SaveAsync();
}
async Task DeleteTenantAsync()
{
var result = await _apiWrapper.Tenants.DeleteAsync(EditContext.Id);
if (result.IsSuccess && result.Error == null)
{
PopupVisible = false;
await grid.CancelRowEdit();
EditContext = null;
var apiTenantResult = await _apiWrapper.Tenants.GetAllAsync(search);
if (apiTenantResult.IsSuccess && apiTenantResult.Error == null)
{
dataSource = apiTenantResult.Data;
}
else
{
message = apiTenantResult.Error.Message;
_toastAppService.ShowWarning(_localizer[message]);
}
await InvokeAsync(StateHasChanged);
}
else
{
message = result.Error.Message;
_toastAppService.ShowWarning(_localizer[message]);
}
}
private string CreateTenantAdminEmployee(TenantViewModel model, string tenantId, string companyId, string branchId)
{
var employee = new Employee()
{
Id = Guid.NewGuid().ToString(),
Code = "EM001",
Name = model.FirstName + " " + model.LastName,
Email = model.Email,
Phone = model.PhoneNumber,
Type = EmployeeType.FullTime,
DateOfBirth = null,
TenantId = tenantId,
CompanyId = companyId,
BranchId = branchId,
Active = true,
CreatedBy = null,
Created = DateTime.Now,
ModifiedBy = null,
Modified = DateTime.Now
};
_employeeRepository.CreateTenantAdminEmployee(employee);
_employeeRepository.Commit();
return(employee.Id);
}
public HttpResponseMessage UpdateTenant(HttpRequestMessage request, TenantViewModel tenant)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, new { success = false });
}
else
{
var existingTenant = _tenantRepository.GetAll().FirstOrDefault(x => x.tenant_key == tenant.tenant_key);
var oTenant = new TenantViewModel();
_membershipService.UpdateTenant(tenant.tenant_key, tenant.domain, tenant.contact_person, tenant.pan, tenant.tin, tenant.vat,
tenant.email, tenant.contact_no, tenant.alt_contact_no, tenant.finance_start_month, tenant.bank_account_no, tenant.bank_name,
tenant.bank_branch, tenant.ifsc_code, tenant.address, tenant.city, tenant.state, tenant.country, tenant.zip, tenant.comments, tenant.logo, tenant.logo_image_type);
response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
}
return response;
}));
}
public async Task <IActionResult> Save([FromBody] TenantViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Tenant tenant = null;
if (model.Id == 0)
{
tenant = new Tenant();
_appDbContext.Tenants.Add(tenant);
}
else
{
tenant = await _appDbContext.Tenants.SingleOrDefaultAsync(t => t.Id == model.Id);
}
if (tenant == null)
{
return(BadRequest());
}
tenant.Name = model.Name;
await _appDbContext.SaveChangesAsync();
return(new OkObjectResult(tenant));
}
public IActionResult Post([FromBody] TenantViewModel model)
{
try
{
if (ModelState.IsValid)
{
var newTenant = _mapper.Map <TenantViewModel, Tenant>(model);
if (_tenantRepository.addEntity(newTenant))
{
return(Created($"api/Tenant/{newTenant.Id}", _mapper.Map <Tenant, TenantViewModel>(newTenant)));
}
else
{
return(BadRequest());
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
return(BadRequest($"There is a issue : {ex}"));
}
}
// GET: SiteAdmin/ApplicationTenants/Edit/5
public async Task <IActionResult> Edit(long?id)
{
if (id == null)
{
return(NotFound());
}
var applicationTenant = await _context.Tenants.FindAsync(id);
if (applicationTenant == null)
{
return(NotFound());
}
TenantViewModel tenant = new TenantViewModel
{
Id = applicationTenant.Id,
EmailAddress = applicationTenant.EmailAddress,
LogoURL = applicationTenant.LogoURL,
Name = applicationTenant.Name,
PhoneContact = applicationTenant.PhoneContact,
System = applicationTenant.System,
Visible = applicationTenant.Visible,
WebSite = applicationTenant.WebSite
};
return(View(tenant));
}
public async Task <IActionResult> Register([FromBody]
TenantViewModel tenant,
StaffViewModel administrator
)
{
//throw new NotImplementedException();
if (!ModelState.IsValid)
{
//NotifyModelStateErrors();
return((IActionResult)BadRequest());
}
ProvisionTenantCommand command = new ProvisionTenantCommand(
tenant.Name,
tenant.Description,
administrator.FirstName,
administrator.LastName,
administrator.EmailAddress,
administrator.PrimaryTelephone,
administrator.SecondaryTelephone,
administrator.AddressStreetAddress,
administrator.AddressCity,
administrator.AddressStateProvince,
administrator.AddressPostalCode,
administrator.AddressCountryCode
);
var _tenant = await _identityApplicationService.ProvisionTenant(command);
return((IActionResult)Ok(_tenant));
}
/// <summary>
/// This is the logic which will Display All Tenants and will separate them in pages and each page will show 20 items.
/// </summary>
/// <param name="page"></param>
/// <returns></returns>
public TenantsViewModel GetAllTenants(int?page)
{
TenantsViewModel model = new TenantsViewModel();
List <TenantViewModel> tenantsList = new List <TenantViewModel>();
var tenants = this.Context.Tenants.OrderBy(m => m.Id).ToArray();
if (page == null)
{
model.Pager = new Pager(tenants.Count(), 1, NumberOfItemsInPage);
foreach (var tenant in tenants.Take(20))
{
TenantViewModel tenantModel = Mapper.Map <Tenant, TenantViewModel>(tenant);
tenantsList.Add(tenantModel);
}
model.Tenants = tenantsList;
}
else
{
model.Pager = new Pager(tenants.Count(), (int)page, NumberOfItemsInPage);
model.Tenants = Mapper.Instance.Map <IEnumerable <Tenant>, IEnumerable <TenantViewModel> >(
tenants.Skip((model.Pager.CurrentPage - 1) * model.Pager.PageSize).Take(model.Pager.PageSize));
}
return(model);
}
private void InitializeTenants()
{
string tenantName = "Chanel";
string email = "*****@*****.**";
string phone = "123-123-1234";
TenantViewModel tenant = new TenantViewModel(
Guid.NewGuid(),
tenantName,
tenantName,
email,
phone,
phone,
"",
"",
"",
"",
"",
""
);
StaffViewModel administrator = new StaffViewModel {
FirstName = tenantName,
LastName = tenantName,
EmailAddress = email,
PrimaryTelephone = phone,
SecondaryTelephone = phone,
AddressStreetAddress = "Tianhe",
AddressCity = "Guangzhou",
AddressStateProvince = "Guangdong",
AddressPostalCode = "510510",
AddressCountryCode = "China"
};
//tenants.Add(tenant, administrator);
}
public async Task <TenantViewModel> TenantById(int TenantId)
{
var t = await _tenantRepository.TenantById(TenantId);
TenantViewModel tVM = new TenantViewModel();
tVM.TenantId = t.TenantId;
tVM.PropertyId = t.PropertyId;
tVM.FirstName = t.FirstName;
tVM.LastName = t.LastName;
tVM.Age = t.Age;
tVM.DOB = t.DOB;
tVM.DriverLicenseNo = t.DriverLicenseNo;
tVM.Email = t.Email;
tVM.EmergencyContact = t.EmergencyContact;
tVM.Gender = t.Gender;
tVM.MoveInDate = t.MoveInDate;
tVM.MoveOutDate = t.MoveOutDate;
tVM.Phone = t.Phone;
tVM.StatusId = t.StatusId;
tVM.Notes = t.Notes;
tVM.DepositAmount = Convert.ToDecimal(string.Format("{0:0.00}", t.DepositAmount));
tVM.DepositReturned = Convert.ToDecimal(string.Format("{0:0.00}", t.DepositReturned));
tVM.DepositWithHold = Convert.ToDecimal(string.Format("{0:0.00}", t.DepositWithHold));
tVM.MonthlyRent = Convert.ToDecimal(string.Format("{0:0.00}", t.MonthlyRent));
tVM.ProratedRent = Convert.ToDecimal(string.Format("{0:0.00}", t.ProratedRent));
return(tVM);
}
public async Task <List <TenantViewModel> > TenantList()
{
List <TenantList> tenant = await _tenantRepository.TenantList();
List <TenantViewModel> tenantVM = new List <TenantViewModel>();
foreach (TenantList t in tenant)
{
TenantViewModel tVM = new TenantViewModel();
tVM.TenantId = t.TenantId;
tVM.PropertyId = t.PropertyId;
tVM.FirstName = t.FirstName;
tVM.LastName = t.LastName;
tVM.Age = t.Age;
tVM.DOB = t.DOB;
tVM.DriverLicenseNo = t.DriverLicenseNo;
tVM.Email = t.Email;
tVM.EmergencyContact = t.EmergencyContact;
tVM.Gender = t.Gender;
tVM.MoveInDate = t.MoveInDate;
tVM.MoveOutDate = t.MoveOutDate;
tVM.Phone = t.Phone;
tVM.StatusId = t.StatusId;
tVM.Notes = t.Notes;
tVM.DepositAmount = t.DepositAmount;
tVM.PropertyAddress = t.PropertyAddress;
tVM.StatusName = t.StatusName;
tVM.MonthlyRent = t.MonthlyRent;
tVM.ProratedRent = t.ProratedRent;
tenantVM.Add(tVM);
}
return(tenantVM);
}
public string CreateTenant(TenantViewModel model)
{
var tenant = new Tenant()
{
Id = model.Id,
Created = model.Created,
CreatedBy = model.CreatedBy,
Modified = model.Modified,
ModifiedBy = model.ModifiedBy,
IsActive = true,
Active = model.Active,
EditionId = model.EditionId,
ConnectionString = model.ConnectionString,
Name = model.Name,
TenancyName = model.TenancyName,
Url = model.Url,
IsInTrialPeriod = model.IsInTrialPeriod,
SubscriptionEndTime = model.SubscriptionEndTime,
LogoId = model.LogoId,
LogoFilePath = model.LogoFilePath,
NoOfShowroom = model.NoOfShowroom,
Package = model.Package,
BonusUserAccessCount = 1
};
_tenantRepository.CreateAsHost(tenant);
_tenantRepository.Commit();
return(model.Id);
}
// GET: Tenants/Edit/5
public async Task <IActionResult> Edit(Guid?id)
{
if (id == null)
{
return(NotFound());
}
var tenant = await _context.Tenants.FindAsync(id);
if (tenant == null)
{
return(NotFound());
}
TenantViewModel vm = new TenantViewModel();
vm.Domain = tenant.Domain;
vm.Name = tenant.Name;
vm.TenantId = tenant.TenantId;
var settings = tenant.GetSiteSettings();
if (settings != null)
{
vm.SettingsTitle = settings.Title;
vm.SettingsDescription = settings.Description;
}
return(View(vm));
}
public async Task <IEnumerable <ModelError> > ValidateAsync(TenantViewModel model)
{
var errors = new List <ModelError>();
var selectedProvider = _databaseProviders.FirstOrDefault(x => x.Value == model.DatabaseProvider);
if (selectedProvider != null && selectedProvider.HasConnectionString && String.IsNullOrWhiteSpace(model.ConnectionString))
{
errors.Add(new ModelError(nameof(model.ConnectionString), S["The connection string is mandatory for this provider."]));
}
if (String.IsNullOrWhiteSpace(model.Name))
{
errors.Add(new ModelError(nameof(model.Name), S["The tenant name is mandatory."]));
}
if (!String.IsNullOrWhiteSpace(model.FeatureProfile))
{
var featureProfiles = await _featureProfilesService.GetFeatureProfilesAsync();
if (!featureProfiles.ContainsKey(model.FeatureProfile))
{
errors.Add(new ModelError(nameof(model.FeatureProfile), S["The feature profile does not exist."]));
}
}
if (!String.IsNullOrEmpty(model.Name) && !Regex.IsMatch(model.Name, @"^\w+$"))
{
errors.Add(new ModelError(nameof(model.Name), S["Invalid tenant name. Must contain characters only and no spaces."]));
}
if (!_shellSettings.IsDefaultShell() && String.IsNullOrWhiteSpace(model.RequestUrlHost) && String.IsNullOrWhiteSpace(model.RequestUrlPrefix))
{
errors.Add(new ModelError(nameof(model.RequestUrlPrefix), S["Host and url prefix can not be empty at the same time."]));
}
if (!String.IsNullOrWhiteSpace(model.RequestUrlPrefix))
{
if (model.RequestUrlPrefix.Contains('/'))
{
errors.Add(new ModelError(nameof(model.RequestUrlPrefix), S["The url prefix can not contain more than one segment."]));
}
}
var allSettings = _shellHost.GetAllSettings();
if (model.IsNewTenant && allSettings.Any(tenant => String.Equals(tenant.Name, model.Name, StringComparison.OrdinalIgnoreCase)))
{
errors.Add(new ModelError(nameof(model.Name), S["A tenant with the same name already exists."]));
}
var allOtherShells = allSettings.Where(t => !String.Equals(t.Name, model.Name, StringComparison.OrdinalIgnoreCase));
if (allOtherShells.Any(tenant => String.Equals(tenant.RequestUrlPrefix, model.RequestUrlPrefix?.Trim(), StringComparison.OrdinalIgnoreCase) && DoesUrlHostExist(tenant.RequestUrlHost, model.RequestUrlHost)))
{
errors.Add(new ModelError(nameof(model.RequestUrlPrefix), S["A tenant with the same host and prefix already exists."]));
}
return(errors);
}
public async Task<IHttpActionResult> AddTenant([FromBody] TenantViewModel tenant)
{
return await HttpActionResultWithErrorHandling(SecurityActions.SuperTenantAdmin, async () =>
{
await _adminRepo.AddTenant(tenant);
return Ok();
});
}
public async Task <IActionResult> RegisterTenant([FromBody] TenantViewModel tenant)
{
var res = await _tenantAppService.Register(tenant);
//TODO Check res
return(Ok());
}
/// <summary>
/// The logic is the same as the EditProperty Action
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public TenantViewModel EditTenantById(int id)
{
var tenant = this.Context.Tenants.Find(id);
TenantViewModel model = Mapper.Map <Tenant, TenantViewModel>(tenant);
return(model);
}
public IActionResult GetTenants()
{
var tableModel = new DataTablesAjaxRequestModel(Request);
var model = new TenantViewModel();
var data = model.GetTenantAndContactPerson(tableModel);
return(Json(data));
}
public IActionResult Index()
{
var model = new TenantViewModel();
ViewBag.BillType = Enum.GetNames(typeof(PrintingFormat));
ViewBag.PaymentMethod = Enum.GetNames(typeof(PaymentMethod));
return(View(model));
}
public async Task<IHttpActionResult> UpdateTenant([FromBody] TenantViewModel tenantViewModel)
{
return await HttpActionResultWithErrorHandling(SecurityActions.ConfigureEntityStuff, async () =>
{
var updatedTenant = _adminRepo.UpdateTenant(tenantViewModel);
//var updatedViewModel = Mapper.Map<EntityTreeViewModel>(updatedEntity);
return Json(updatedTenant);
});
}
public ActionResult EditTenant([Bind(Include = "Id, FullName, PhoneNumber, Description")] TenantViewModel tenant)
{
if (ModelState.IsValid)
{
this.service.EditTenantById(tenant);
return(this.RedirectToAction($"Show/Tenants", "Properties", new { area = "" }));
}
return(this.View(tenant));
}
public ActionResult Details(int?id)
{
// Create the model
var model = new TenantViewModel();
var tenant = new Tenant();
try
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
using (var ctx = new SaasDbContext())
{
// Get tenant from db
tenant = ctx.Tenants.Include("Applications").Where(i => i.TenantId == id).FirstOrDefault();
}
if (tenant == null)
{
return(HttpNotFound());
}
// Create the breadcrumb
var breadcrumb = new List <BreadcrumbItemViewModel>();
breadcrumb.Add(new BreadcrumbItemViewModel()
{
Text = "Tenants",
Link = "/Tenants"
});
breadcrumb.Add(new BreadcrumbItemViewModel()
{
Text = tenant.Name,
Link = "/Tenants/" + tenant.TenantId + "/Details"
});
breadcrumb.Add(new BreadcrumbItemViewModel()
{
Text = "Details"
});
ViewBag.Breadcrumb = breadcrumb;
// Set the tenant
model.Tenant = tenant;
}
catch (Exception ex)
{
LogService.Info("Tenants not found", ex.Message, ex.InnerException);
}
return(View(model));
}
public int ProcessCommit(string batchId, TenantViewModel tenant)
{
int bulkImportId = int.Parse(batchId);
BulkImport bulkImport = BulkImportRepository.Single(x => x.BulkImportId == bulkImportId);
ConvertedAssetsDto convertedAssets = BuildAssetsClearLookups(bulkImport.ImportText, tenant.TenantId);
CommitImport(convertedAssets.Assets);
return(convertedAssets.Assets.Count());
}
/// <summary>
/// The logic is the same as the EditProperty Action
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public void EditTenantById(TenantViewModel model)
{
var tenantToEdit = this.Context.Tenants.Find(model.Id);
tenantToEdit.FullName = model.FullName;
tenantToEdit.PhoneNumber = model.PhoneNumber;
tenantToEdit.Description = model.Description;
this.Context.SaveChanges();
}
