/// <summary>
/// Update Tenant
/// </summary>
/// <param name="tenant"></param>
/// <returns></returns>
public void Update(TenantDomain tenant)
{
var tenantDb = _context.Tenant.FirstOrDefault(x => x.TenantId == tenant.Id);
tenantDb.FromDomainModel(tenant);
_context.SaveChanges();
}
public TenantDomains RemoveTenantDomain(TenantDomain tenantDomain, bool secureUrls)
{
ValidateTenant(tenantDomain.TenantUid);
var tenantHome = nodeHelper.GetTenantRoot(tenantDomain.TenantUid);
var domains = nodeHelper.GetTenantDomains(tenantDomain.TenantUid);
if (domains.AlternateDomains == null)
{
throw new TenantException(ExceptionCode.DomainDoesNotExist.CodeToString(), ExceptionCode.DomainDoesNotExist, tenantDomain.TenantUid, tenantDomain.Domain);
}
if (domains.AlternateDomains.SingleOrDefault(x => x == tenantDomain.Domain) == null)
{
throw new TenantException(ExceptionCode.DomainDoesNotExist.CodeToString(), ExceptionCode.DomainDoesNotExist, tenantDomain.TenantUid, tenantDomain.Domain);
}
var domainList = nodeHelper.GetTenantDomainsString(tenantDomain.TenantUid);
domainList = domainList.Replace($"{tenantDomain.Domain}", string.Empty);
var array = domainList.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
domainList = string.Join(",", array);
nodeHelper.SetNodeContent(tenantHome, "alternateDomains", domainList, false);
nodeHelper.SaveNode(tenantHome);
languageDictionaryService.RemoveCultureAndHostname(tenantDomain, secureUrls);
nodeHelper.TryPublishSite(tenantHome.Id);
return(nodeHelper.GetTenantDomains(tenantDomain.TenantUid));
}
public JsonRpcResponseData RemoveTenantDomain(TenantDomain payload, ApiAuthorization authorization)
{
SetupAuth();
IsValidRequest(authorization.AppId, authorization.ApiKey);
var apiController = new ControllerService();
try
{
var tenantDomains = apiController.RemoveTenantDomain(payload);
return(new JsonRpcResponseData
{
Message = $"Domain {payload.Domain} for Tenant {payload.TenantUid} has been removed",
Status = JsonRpcResponseData.OK,
TenantUid = payload.TenantUid,
Data = new
{
tenantDomains
}
});
}
catch (System.Exception ex)
{
throw HandleException(ex);
}
}
public TenantDomains AddTenantDomain(TenantDomain tenantDomain, bool setupLocalUrls, bool secureUrls)
{
ValidateTenant(tenantDomain.TenantUid);
var tenantHome = nodeHelper.GetTenantRoot(tenantDomain.TenantUid);
string domainList = nodeHelper.GetTenantDomainsString(tenantDomain.TenantUid);
if (tenantDomain.isPrimary)
{
nodeHelper.SetNodeContent(tenantHome, "domain", tenantDomain.Domain, false);
nodeHelper.SaveNode(tenantHome);
languageDictionaryService.AddCultureAndHostnameDomain(tenantDomain, secureUrls);
nodeHelper.TryPublishSite(tenantHome.Id);
return(nodeHelper.GetTenantDomains(tenantDomain.TenantUid));
}
if (DomainAlreadyExists(tenantDomain.TenantUid, tenantDomain.Domain))
{
throw new TenantException(ExceptionCode.DomainAlreadyAssigned.CodeToString(), ExceptionCode.DomainAlreadyAssigned, tenantDomain.TenantUid, tenantDomain.Domain);
}
domainList += string.IsNullOrEmpty(domainList) ? tenantDomain.Domain : $",{tenantDomain.Domain}";
nodeHelper.SetNodeContent(tenantHome, "alternateDomains", domainList, false);
nodeHelper.SaveNode(tenantHome);
languageDictionaryService.AddCultureAndHostnameDomain(tenantDomain, secureUrls);
nodeHelper.TryPublishSite(tenantHome.Id);
return(nodeHelper.GetTenantDomains(tenantDomain.TenantUid));
}
/// <summary>
/// Adds new tenant to the database
/// </summary>
/// <param name="tenant">Tenant information to be added. Instance of <see cref="TenantDomain"/></param>
/// <returns>TenantId of the newly created tenant</returns>
public int Add(TenantDomain tenant)
{
var tenantDb = new Tenant().FromDomainModel(tenant);
_context.Tenant.Add(tenantDb);
_context.SaveChanges();
return(tenantDb.TenantId);
}
private void ValidateTenantModel(TenantDomain tenant)
{
ValidationHelper.NotNull(tenant, MembershipMessages.TenantNotProvided);
ValidationHelper.GreaterThanZero(tenant.DefaultLanguageId, MembershipMessages.LanguageIdInvalid);
ValidationHelper.NotNull(_languageRepository.GetById(tenant.DefaultLanguageId), MembershipMessages.LanguageWithIdDoesNotExist);
ValidationHelper.MaxLength(tenant.Name, 100, MembershipMessages.TenantNameLengthExceeded);
ValidationHelper.NotNullOrWhitespace(tenant.Name, MembershipMessages.TenantNameInvalid);
}
/// <summary>
/// Update Tenant
/// </summary>
/// <param name="tenant"></param>
/// <returns></returns>
public void UpdateTenant(TenantDomain tenant)
{
ValidateTenantModel(tenant);
ValidationHelper.GreaterThanZero(tenant.Id, MembershipMessages.TenantIdInvalid);
ValidationHelper.NotNull(_tenantRepository.GetById(tenant.Id), MembershipMessages.TenantWithIdDoesNotExist);
_tenantRepository.Update(tenant);
}
public void AddTenant_Fail_NameInvalid()
{
TenantDomain tenant = new TenantDomain()
{
Name = "",
DefaultLanguageId = 1,
IsActive = true,
Id = 1
};
_tenantManipulation.AddTenant(tenant);
}
public void AddTenant_Fail_NameLengthExceeded()
{
TenantDomain tenant = new TenantDomain()
{
Name = "LejlaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaLejlaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
DefaultLanguageId = 1,
IsActive = true,
Id = 1
};
_tenantManipulation.AddTenant(tenant);
}
public void AddCultureAndHostname(TenantDomain tenant, bool secureUrl)
{
const string protocolBase = "http";
var protocol = secureUrl ? $"{protocolBase}s" : protocolBase;
try
{
var tenantRoot = nodeHelper.GetTenantRoot(tenant.TenantUid);
var languages = localizationService.GetAllLanguages();
var subDomain = tenantRoot.GetValue <string>("subDomain");
string domainName = $"{protocol}://{subDomain}.{tenant.Domain}/";
var existingDomain = domainService.GetByName(domainName);
if (Uri.IsWellFormedUriString(domainName, UriKind.RelativeOrAbsolute))
{
if (existingDomain == null)
{
var defaultLanguageId = localizationService.GetDefaultLanguageId();
existingDomain = new UmbracoDomain(domainName)
{
LanguageId = defaultLanguageId,
RootContentId = tenantRoot.Id
};
domainService.Save(existingDomain);
ConnectorContext.AuditService.Add(AuditType.New, -1, existingDomain.Id, "Language", $"Domain '{domainName}' for Tenant '{tenant.TenantUid}' has been created");
}
foreach (var language in languages)
{
var localizedDomainName = $"{domainName}{language.IsoCode}";
var localizedDomain = domainService.GetByName(localizedDomainName);
if (localizedDomain == null)
{
localizedDomain = new UmbracoDomain(localizedDomainName)
{
LanguageId = language.Id,
RootContentId = tenantRoot.Id
};
domainService.Save(localizedDomain);
ConnectorContext.AuditService.Add(AuditType.New, -1, existingDomain.Id, "Language", $"Domain '{localizedDomainName}' for Tenant '{tenant.TenantUid}' has been created");
}
}
}
}
catch (Exception ex)
{
logger.Error(typeof(LanguageDictionaryService), ex.Message);
logger.Error(typeof(LanguageDictionaryService), ex.StackTrace);
throw;
}
}
/// <summary>
/// Adds new tenant to the database
/// </summary>
/// <param name="tenant">Tenant information to be added. Instance of <see cref="TenantDomain"/></param>
/// <returns>TenantId of the newly created tenant</returns>
public int AddTenant(TenantDomain tenant)
{
ValidateTenantModel(tenant);
tenant.Identifier = Guid.NewGuid();
// Check if identifier exists
var tenantWithProvidedIdentifier = _tenantRepository.GetByIdentifier(tenant.Identifier);
if (tenantWithProvidedIdentifier != null)
{
throw new NsiArgumentException(MembershipMessages.TenantIdentifierAlreadyExists, Common.Enumerations.SeverityEnum.Warning);
}
return(_tenantRepository.Add(tenant));
}
public static Tenant FromDomainModel(this Tenant obj, TenantDomain domain)
{
if (obj == null)
{
obj = new Tenant();
}
obj.TenantId = domain.Id;
obj.Name = domain.Name;
obj.Identifier = domain.Identifier;
obj.LanguageId = domain.DefaultLanguageId;
obj.IsActive = domain.IsActive;
return(obj);
}
public IHttpActionResult AddTenant(AddTenantRequest request)
{
request.ValidateNotNull();
TenantDomain tenantDomain = new TenantDomain()
{
//Identifier = request.Identifier,
Name = request.Name,
IsActive = request.IsActive,
DefaultLanguageId = request.DefaultLanguageId
};
return(Ok(new AddTenantResponse()
{
Data = _tenantManipulation.AddTenant(tenantDomain),
Success = Common.Enumerations.ResponseStatus.Succeeded
}));
}
public IHttpActionResult UpdateTenant(UpdateTenantRequest request)
{
request.ValidateNotNull();
TenantDomain tenantDomain = _tenantManipulation.GetTenantById(request.Id);
if (tenantDomain == null)
{
return(NotFound());
}
tenantDomain.Name = request.Name;
tenantDomain.IsActive = request.IsActive;
tenantDomain.DefaultLanguageId = request.DefaultLanguageId;
_tenantManipulation.UpdateTenant(tenantDomain);
return(Ok(new UpdateTenantResponse()
{
Success = Common.Enumerations.ResponseStatus.Succeeded
}));
}
public void RemoveCultureAndHostname(TenantDomain tenant, bool secureUrl)
{
const string protocolBase = "http";
var protocol = secureUrl ? $"{protocolBase}s" : protocolBase;
try
{
var tenantRoot = nodeHelper.GetTenantRoot(tenant.TenantUid);
var languages = localizationService.GetAllLanguages();
//var subDomain = tenantRoot.GetValue<string>("subDomain");
string domainName = $"{protocol}://{tenant.Domain}/";
var existingDomain = domainService.GetByName(domainName);
if (existingDomain != null)
{
domainService.Delete(existingDomain);
ConnectorContext.AuditService.Add(AuditType.Delete, -1, existingDomain.Id, "Language", $"Domain '{domainName}' for Tenant '{tenant.TenantUid}' has been deleted");
}
foreach (var language in languages)
{
var localizedDomainName = $"{domainName}{language.IsoCode}";
var localizedDomain = domainService.GetByName(localizedDomainName);
if (localizedDomain != null)
{
domainService.Delete(localizedDomain);
ConnectorContext.AuditService.Add(AuditType.Delete, -1, localizedDomain.Id, "Language", $"Domain '{localizedDomainName}' for Tenant '{tenant.TenantUid}' has been deleted");
}
}
}
catch (Exception ex)
{
logger.Error(typeof(LanguageDictionaryService), ex.Message);
logger.Error(typeof(LanguageDictionaryService), ex.StackTrace);
throw;
}
}
public TenantDomains RemoveTenantDomain(TenantDomain payload)
{
return(homeNode.RemoveTenantDomain(payload, SecureUrls));
}
public void GetTenantById_Success()
{
TenantDomain tenant = _tenantManipulation.GetTenantById(1);
Assert.AreEqual(1, tenant.Id);
}
public void GetModuleByIdentifier_Success()
{
TenantDomain tenant = _tenantManipulation.GetTenantByIdentifier(Guid.Parse("81a130d2-502f-4cf1-a376-63edeb000e9f"));
Assert.AreEqual(Guid.Parse("81a130d2-502f-4cf1-a376-63edeb000e9f"), tenant.Identifier);
}
public TenantDomains AddTenantDomain(TenantDomain payload)
{
return(homeNode.AddTenantDomain(payload, SetupLocalUrls, SecureUrls));
}
public void AddCultureAndHostnameDomain(TenantDomain tenant, bool secureUrl)
{
const string protocolBase = "http";
var protocol = secureUrl ? $"{protocolBase}s" : protocolBase;
try
{
var tenantRoot = nodeHelper.GetTenantRoot(tenant.TenantUid);
var languages = localizationService.GetAllLanguages();
var subDomain = tenantRoot.GetValue <string>("subDomain");
var tenantHome = nodeHelper.GetTenantRoot(tenant.TenantUid);
var domains = nodeHelper.GetTenantDomains(tenant.TenantUid);
string[] langs = new string[] { };
if (tenantRoot.HasProperty("languages") && tenantRoot.GetValue("languages") != null)
{
var languages_val = tenantRoot.GetValue("languages").ToString();
if (languages_val.Contains(","))
{
langs = languages_val.Split(',');
}
else
{
langs = new string[] { languages_val };
}
}
string defaultLang = tenantRoot.GetValue("defaultLanguage").ToString();
string domainName = $"{protocol}://{tenant.Domain}/";
var existingDomain = domainService.GetByName(domainName);
if (Uri.IsWellFormedUriString(domainName, UriKind.RelativeOrAbsolute))
{
if (existingDomain == null)
{
var defaultLanguageId = localizationService.GetLanguageIdByIsoCode(defaultLang);
existingDomain = new UmbracoDomain(domainName)
{
LanguageId = defaultLanguageId,
RootContentId = tenantRoot.Id
};
domainService.Save(existingDomain);
ConnectorContext.AuditService.Add(AuditType.New, -1, existingDomain.Id, "Language", $"Domain '{domainName}' for Tenant '{tenant.TenantUid}' has been created");
}
foreach (var language in languages)
{
if (langs.Contains(language.IsoCode))
{
var localizedDomainName = $"{domainName}{language.IsoCode}";
var localizedDomain = domainService.GetByName(localizedDomainName);
if (localizedDomain == null)
{
localizedDomain = new UmbracoDomain(localizedDomainName)
{
LanguageId = language.Id,
RootContentId = tenantRoot.Id
};
domainService.Save(localizedDomain);
ConnectorContext.AuditService.Add(AuditType.New, -1, existingDomain.Id, "Language", $"Domain '{localizedDomainName}' for Tenant '{tenant.TenantUid}' has been created");
}
}
}
}
string domainWWW = $"{protocol}://www.{tenant.Domain}/";
var existingDomainWWW = domainService.GetByName(domainWWW);
if (Uri.IsWellFormedUriString(domainWWW, UriKind.RelativeOrAbsolute))
{
if (existingDomainWWW == null)
{
var defaultLanguageId = localizationService.GetLanguageIdByIsoCode(defaultLang);
existingDomainWWW = new UmbracoDomain(domainWWW)
{
LanguageId = defaultLanguageId,
RootContentId = tenantRoot.Id
};
domainService.Save(existingDomainWWW);
ConnectorContext.AuditService.Add(AuditType.New, -1, existingDomainWWW.Id, "Language", $"Domain '{domainWWW}' for Tenant '{tenant.TenantUid}' has been created");
}
foreach (var language in languages)
{
if (langs.Contains(language.IsoCode))
{
var localizedDomainName = $"{domainWWW}{language.IsoCode}";
var localizedDomain = domainService.GetByName(localizedDomainName);
if (localizedDomain == null)
{
localizedDomain = new UmbracoDomain(localizedDomainName)
{
LanguageId = language.Id,
RootContentId = tenantRoot.Id
};
domainService.Save(localizedDomain);
ConnectorContext.AuditService.Add(AuditType.New, -1, existingDomainWWW.Id, "Language", $"Domain '{localizedDomainName}' for Tenant '{tenant.TenantUid}' has been created");
}
}
}
}
string domainSubdomain = $"{protocol}://{subDomain}.{tenant.Domain}/";
var existingDomainSubdomain = domainService.GetByName(domainSubdomain);
if (Uri.IsWellFormedUriString(domainSubdomain, UriKind.RelativeOrAbsolute))
{
if (existingDomainSubdomain == null)
{
var defaultLanguageId = localizationService.GetLanguageIdByIsoCode(defaultLang);
existingDomainSubdomain = new UmbracoDomain(domainSubdomain)
{
LanguageId = defaultLanguageId,
RootContentId = tenantRoot.Id
};
domainService.Save(existingDomainSubdomain);
ConnectorContext.AuditService.Add(AuditType.New, -1, existingDomainSubdomain.Id, "Language", $"Domain '{domainSubdomain}' for Tenant '{tenant.TenantUid}' has been created");
}
foreach (var language in languages)
{
if (langs.Contains(language.IsoCode))
{
var localizedDomainName = $"{domainSubdomain}{language.IsoCode}";
var localizedDomain = domainService.GetByName(localizedDomainName);
if (localizedDomain == null)
{
localizedDomain = new UmbracoDomain(localizedDomainName)
{
LanguageId = language.Id,
RootContentId = tenantRoot.Id
};
domainService.Save(localizedDomain);
ConnectorContext.AuditService.Add(AuditType.New, -1, existingDomainSubdomain.Id, "Language", $"Domain '{localizedDomainName}' for Tenant '{tenant.TenantUid}' has been created");
}
}
}
}
}
catch (Exception ex)
{
logger.Error(typeof(LanguageDictionaryService), ex.Message);
logger.Error(typeof(LanguageDictionaryService), ex.StackTrace);
throw;
}
}
static void Main(string[] args)
{
//****************************************
//The EFDAL project is generated
//The Installer project is generated
//Teh API project is hand written containing a few utilities to create tenants
//The Console app
//For now this will store the tenant ID in a variable.
//In production you would use a session variable or some other login management technique.
var tenant1Id = 0;
var tenant2Id = 0;
//Connect to the database with the master connection string
//There is no tenant information in this connection string
using (var context = new MultiTenantEntities(DatabaseHelper.MasterConnectionString))
{
var tenant1Name = "Tenant1";
var tenant2Name = "Tenant2";
#region Create Tenants IF EMPTY
if (!context.TenantMaster.Any())
{
//Create Tenant 1
TenantDomain.CreateTenant(tenant1Name);
Console.WriteLine($"Created {tenant1Name}");
//Create Tenant 2
TenantDomain.CreateTenant(tenant2Name);
Console.WriteLine($"Created {tenant2Name}");
}
#endregion
//Pull each Tenant ID from the database for testing
tenant1Id = context.TenantMaster.FirstOrDefault(x => x.TenantName == tenant1Name).TenantId;
tenant2Id = context.TenantMaster.FirstOrDefault(x => x.TenantName == tenant2Name).TenantId;
}
//Now connect with the connection string for Tenant1
using (var context = new MultiTenantEntities(DatabaseHelper.GetTenantConnectionString(tenant1Id)))
{
//Add "Project 1" through "Project 10"
for (var ii = 1; ii <= 10; ii++)
{
var newProject = new Project
{
Name = $"Project {ii}",
ProjectTypeValue = ProjectTypeConstants.CSharp
};
context.AddItem(newProject);
}
context.SaveChanges();
}
//Now connect with the connection string for Tenant2
using (var context = new MultiTenantEntities(DatabaseHelper.GetTenantConnectionString(tenant2Id)))
{
//Add "Project 11" through "Project 20"
for (var ii = 11; ii <= 20; ii++)
{
var newProject = new Project
{
Name = $"Project {ii}",
ProjectTypeValue = ProjectTypeConstants.Java
};
context.AddItem(newProject);
}
context.SaveChanges();
}
//Now select ALL Projects using the Tenant1 connection string
using (var context = new MultiTenantEntities(DatabaseHelper.GetTenantConnectionString(tenant1Id)))
{
var list = context.Project.ToList();
Console.WriteLine($"Tenant 1 Project Count={list.Count}");
foreach (var item in list)
{
Console.WriteLine($"Tenant 1, Project ={item.Name}");
}
//Notice that there are only 10 items even with no Where clause
//The framework limits the selection to only items for Tenant 1.
//There is never any data leak between tenants
}
//Now select ALL Projects using the Tenant2 connection string
using (var context = new MultiTenantEntities(DatabaseHelper.GetTenantConnectionString(tenant2Id)))
{
var list = context.Project.ToList();
Console.WriteLine($"Tenant 2 Project Count={list.Count}");
foreach (var item in list)
{
Console.WriteLine($"Tenant 2, Project ={item.Name}");
}
//Notice that there are only 10 items even with no Where clause
//The framework limits the selection to only items for Tenant 2.
//There is never any data leak between tenants
}
}
