public void Create(string tenantName)
{
Context.Output.WriteLine(T("Creating tenant '{0}'...", tenantName));
if (String.IsNullOrWhiteSpace(tenantName) || !Regex.IsMatch(tenantName, @"^[a-zA-Z]\w*$"))
{
Context.Output.WriteLine(T("Invalid tenant name. Must contain characters only and no spaces."));
return;
}
if (_tenantService.GetTenants().Any(tenant => String.Equals(tenant.Name, tenantName, StringComparison.OrdinalIgnoreCase)))
{
Context.Output.WriteLine(T("Could not create tenant '{0}'. A tenant with the same name already exists.", tenantName));
return;
}
if (DataProvider != null && !_validDataProviderNames.Contains(DataProvider))
{
Context.Output.WriteLine(T("Invalid value '{0}' for parameter DataProvider. Expect one of the following: {1}", DataProvider, String.Join(", ", _validDataProviderNames)));
return;
}
_tenantService.CreateTenant(
new ShellSettings {
Name = tenantName,
State = TenantState.Uninitialized,
DataProvider = DataProvider,
DataConnectionString = DataConnectionString,
DataTablePrefix = DataTablePrefix,
RequestUrlHost = UrlHost,
RequestUrlPrefix = UrlPrefix,
Themes = Themes != null ? Themes.Split(';') : new string[] { },
Modules = Modules != null ? Modules.Split(';') : new string[] { }
});
}
public ActionResult AddPost(TenantAddViewModel viewModel)
{
if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("You don't have permission to create tenants.")))
{
return(new HttpUnauthorizedResult());
}
if (!IsExecutingInDefaultTenant())
{
return(new HttpUnauthorizedResult());
}
if (_tenantService.GetTenants().Any(tenant => string.Equals(tenant.Name, viewModel.Name, StringComparison.OrdinalIgnoreCase)))
{
ModelState.AddModelError("Name", T("A tenant with the same name already exists.", viewModel.Name).Text);
}
// Ensure tenants name are valid.
if (!String.IsNullOrEmpty(viewModel.Name) && !Regex.IsMatch(viewModel.Name, @"^[a-zA-Z]\w*$"))
{
ModelState.AddModelError("Name", T("Invalid tenant name. Must contain characters only and no spaces.").Text);
}
if (!string.Equals(viewModel.Name, "default", StringComparison.OrdinalIgnoreCase) && string.IsNullOrWhiteSpace(viewModel.RequestUrlHost) && string.IsNullOrWhiteSpace(viewModel.RequestUrlPrefix))
{
ModelState.AddModelError("RequestUrlHostRequestUrlPrefix", T("RequestUrlHost and RequestUrlPrefix can not be empty at the same time.").Text);
}
if (!ModelState.IsValid)
{
return(View(viewModel));
}
try {
_tenantService.CreateTenant(
new ShellSettings {
Name = viewModel.Name,
RequestUrlHost = viewModel.RequestUrlHost,
RequestUrlPrefix = viewModel.RequestUrlPrefix,
DataProvider = viewModel.DataProvider,
DataConnectionString = viewModel.DatabaseConnectionString,
DataTablePrefix = viewModel.DatabaseTablePrefix,
State = TenantState.Uninitialized,
Themes = viewModel.Themes.Where(x => x.Checked).Select(x => x.ThemeId).ToArray(),
Modules = viewModel.Modules.Where(x => x.Checked).Select(x => x.ModuleId).ToArray()
});
Services.Notifier.Success(T("Tenant '{0}' was created successfully.", viewModel.Name));
return(RedirectToAction("Index"));
}
catch (ArgumentException ex) {
Logger.Error(ex, "Error while creating tenant.");
Services.Notifier.Error(T("Tenant creation failed with error: {0}.", ex.Message));
return(View(viewModel));
}
}
public async Task <ResultMessage <bool> > CreateTenant([FromBody] SynchronizeTenantDto input)
{
var otherSystem = _principalAccessor.Principal?.Claims.FirstOrDefault(c => c.Type == "SplitPackageOtherSystemId");
if (string.IsNullOrEmpty(otherSystem?.Value))
{
throw new UserFriendlyException("不存在该系统标识");
}
return(new ResultMessage <bool>(ResultCode.Success, "success", await _tenantService.CreateTenant(input, long.Parse(otherSystem.Value))));
}
public async Task <ActionResult <Tenant_DetailDto> > CreateTenant([FromForm] Tenant_CreateDto value)
{
if (ModelState.IsValid)
{
var newTenant = _mapper.Map <Tenant>(value);
var createdTenant = await _tenantService.CreateTenant(newTenant, value.Profile);
return(Ok(createdTenant));
}
return(BadRequest(ModelState));
}
public void Create(string tenantName)
{
Context.Output.WriteLine(T("Creating tenant"));
_tenantService.CreateTenant(
new ShellSettings {
Name = tenantName,
RequestUrlHost = Host,
RequestUrlPrefix = UrlPrefix,
State = new TenantState("Uninitialized")
});
}
public async Task <IActionResult> PostTenantCreate([FromBody] TenantCreateViewModel model)
{
var tenantDto = new TenantDto
{
Name = model.Name,
ParentTenantId = model.ParentId
};
var model2 = await _tenantService.CreateTenant(tenantDto);
return(new JsonResult(model));
}
public IActionResult CreateTenant(Tenant tenant)
{
if (tenant == null)
{
return(BadRequest());
}
var tenantResponse = _tenantService.CreateTenant(tenant);
return(tenantResponse == null
? StatusCode(500)
: (IActionResult)Ok(tenantResponse));
}
public ActionResult AddPOST(TenantAddViewModel viewModel)
{
if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Couldn't create tenant")))
{
return(new HttpUnauthorizedResult());
}
if (!EnsureDefaultTenant())
{
return(new HttpUnauthorizedResult());
}
if (_tenantService.GetTenants().Any(tenant => string.Equals(tenant.Name, viewModel.Name, StringComparison.OrdinalIgnoreCase)))
{
ModelState.AddModelError("Name", T("A tenant with the same name already exists.", viewModel.Name).Text);
}
// ensure tenants name are valid
if (!String.IsNullOrEmpty(viewModel.Name) && !Regex.IsMatch(viewModel.Name, @"^\w+$"))
{
ModelState.AddModelError("Name", T("Invalid tenant name. Must contain characters only and no spaces.").Text);
}
if (!ModelState.IsValid)
{
return(View(viewModel));
}
try {
_tenantService.CreateTenant(
new ShellSettings {
Name = viewModel.Name,
RequestUrlHost = viewModel.RequestUrlHost,
RequestUrlPrefix = viewModel.RequestUrlPrefix,
DataProvider = viewModel.DataProvider,
DataConnectionString = viewModel.DatabaseConnectionString,
DataTablePrefix = viewModel.DatabaseTablePrefix,
State = TenantState.Uninitialized,
Themes = viewModel.Themes.Where(x => x.Checked).Select(x => x.ThemeId).ToArray(),
Modules = viewModel.Modules.Where(x => x.Checked).Select(x => x.ModuleId).ToArray()
});
return(RedirectToAction("Index"));
}
catch (ArgumentException exception) {
Services.Notifier.Error(T("Creating Tenant failed: {0}", exception.Message));
return(View(viewModel));
}
}
public async Task CreateTenantToThisNode(CreateTenantDetails createTenantDetails)
{
_logger.LogInformation($"Request to create tenant '{createTenantDetails.Name}' from other nodes");
if (_tenantRepository.GetTenant(createTenantDetails.Name) == null)
{
_tenantApiService.CreateTenant(createTenantDetails.Name, createTenantDetails.TenantSettings);
_logger.LogInformation($"Tenant' {createTenantDetails.Name}' has been created and linked, informing other nodes");
}
else
{
_logger.LogInformation($"Tenant' {createTenantDetails.Name}' already exists, ignoring the request");
}
// send to other nodes....
await _storageHubService.SendCreateTenantStorage(createTenantDetails);
}
public ActionResult <string> AddTenant(string tenantName, [FromBody] TenantSettings tenantSettings)
{
tenantName = tenantName.ToLower().Replace(" ", string.Empty);
var isFromCli = HttpContext.Request.Headers["x-called-by"].ToString();
if (isFromCli != "")
{
_logger.LogInformation($"{isFromCli} POST '{HttpContext.Request.Path}' is called");
}
else
{
_logger.LogInformation($"POST '{HttpContext.Request.Path}' is called");
}
if (_tenantService.CreateTenant(tenantName, tenantSettings) != true)
{
return(BadRequest("Couldn't add new tenant, or tenant already exists"));
}
return(Ok($"Tenant {tenantName} has been created"));
}
public async Task <IActionResult> Create(Guid portfolioId, Guid propertyId, [Bind("FirstName,LastName,PhoneNumber,JobTitle,Nationality,TenancyStartDate,TenancyEndDate,TenantImage,Id,CreatedDate,UpdatedDate")] TenantCreateDTO tenant)
{
if (ModelState.IsValid)
{
var new_tenant = _mapper.Map <Tenant>(tenant);
var property = await _propertyService.GetPropertyById(portfolioId, propertyId);
var o = await _tenantService.CreateTenant(new_tenant);
o.Property = property;
if (tenant.TenantImage != null)
{
o.TenantImage = await _tenantService.CreateTenantImage(o.Id, tenant.TenantImage);
}
await _tenantService.SaveAsync();
return(Ok(o));
}
return(BadRequest(tenant));
}
public async Task <IActionResult> Create(Models.Journals.CreateJournalModel model)
{
if (ModelState.IsValid)
{
await _tenantService.CreateTenant(new ViewModels.Journals.CreateJournalModel
{
IsActive = model.IsActive,
JournalName = model.JournalName,
JournalPath = model.JournalPath,
PhoneNumber = model.PhoneNumber,
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
JournalTitle = model.JournalTitle
}, model.Logo.OpenReadStream(), model.Logo.FileName);
var emailModel = new AddUserEmailNotificationModel
{
FirstName = model.FirstName,
LastName = model.LastName,
JournalName = model.JournalName,
JournalPath = model.JournalPath,
RoleNames = new List <string> {
RoleName.Admin
}
};
try
{
await SendAdminEmail(emailModel, model.Email);
}
catch (System.Exception ex)
{
HttpContext.RiseError(ex);
AddFailMessage("Journal has been Created but failed to send confirmation email to Admin.");
}
return(RedirectToAction("Index"));
}
return(View());
}
public void Create(string tenantName)
{
Context.Output.WriteLine(T("Creating tenant"));
if (string.IsNullOrWhiteSpace(tenantName) || !Regex.IsMatch(tenantName, @"^\w+$"))
{
Context.Output.WriteLine(T("Invalid tenant name. Must contain characters only and no spaces."));
return;
}
if (_tenantService.GetTenants().Any(tenant => string.Equals(tenant.Name, tenantName, StringComparison.OrdinalIgnoreCase)))
{
Context.Output.WriteLine(T("Could not create tenant \"{0}\". A tenant with the same name already exists.", tenantName));
return;
}
_tenantService.CreateTenant(
new ShellSettings {
Name = tenantName,
RequestUrlHost = Host,
RequestUrlPrefix = UrlPrefix,
State = TenantState.Uninitialized
});
}
