///// <summary>
///// Creates multiple subscriptions in the [TangledServices.ServicePortal].[Subscriptions] container.
///// </summary>
///// <param name="container">The container represented as a ResetContainerModel object.</param>
///// <returns></returns>
//private async Task<IEnumerable<Subscription>> createContainerSubscriptions(SystemResetModel container)
//{
// List<Subscription> items = new List<Subscription>();
// if (container.Subscriptions != null)
// {
// foreach (Subscription subscription in container.Subscriptions)
// {
// // If a renewal timeframe exists, retrieve it. Otherwise, make it null.
// subscription.RenewalTimeframe = subscription.RenewalTimeframe == null ? null : await _adminLookupItemManager.GetItemAsync("Subscription Renewal Timeframes", subscription.RenewalTimeframe.Id);
// var item = await _customerAdminSubscriptionsManager.CreateItemAsync(subscription);
// items.Add(item);
// }
// }
// return items;
//}
/// <summary>
/// Creates multiple subscriptions in the [TangledServices.ServicePortal].[Users] container.
/// </summary>
/// <param name="container">The container represented as a ResetContainerModel object.</param>
/// <returns></returns>
private async Task CreateContainerUsers(SystemLookupItem container)
{
//if (container.Users != null)
//{
// foreach (Entities.User user in container.Users)
// {
// foreach (EmailAddress userEmailAddress in user.EmailAddresses)
// {
// // Retrieve email address lookup items.
// LookupGroup emailAddressesGroup = await _systemLookupItemService.GetItem(Enums.LookupGroups.EmailAddressTypes);
// LookupItemEntity emailAddressType = emailAddressesGroup.Items.SingleOrDefault(x => x.Name == userEmailAddress.Type.Name.ToString().ToTitleCase());
// userEmailAddress.Type = emailAddressType;
// }
// foreach (PhoneNumber userPhoneNumber in user.PhoneNumbers)
// {
// // Retrieve phone number lookup items.
// LookupGroup phoneNumberGroup = await _systemLookupItemService.GetItem(Enums.LookupGroups.PhoneNumberTypes);
// LookupItemEntity phoneNumberType = phoneNumberGroup.Items.SingleOrDefault(x => x.Name == userPhoneNumber.Type.Name.ToString().ToTitleCase());
// userPhoneNumber.Type = phoneNumberType;
// }
// // Encrypt password.
// user.Password = _hashingService.EncryptString(user.Password);
// // Persist item.
// var item = await _customerAdminUserManager.CreateItemAsync(user);
// }
//}
}
public async Task <SystemLookupItem> GetItemAsync(Enums.LookupItems group, string id)
{
SystemLookupItem result = await GetItemAsync(group.GetDescription());
result.Values.SingleOrDefault(x => x.Id == id);
return(result);
}
public AdminLookupItemModel(SystemLookupItem entity)
{
Id = entity.Id;
CanonicalName = entity.CanonicalName;
DisplayName = entity.DisplayName;
Values = AdminLookupItemValueModel.Construct(entity.Values);
}
public async Task <SystemLookupItemModel> GetItem(Enums.LookupItems item, string id)
{
SystemLookupItem entity = await _systemLookupItemManager.GetItemAsync(item, id);
var model = new SystemLookupItemModel(entity);
return(model);
}
public SystemLookupItemModel(SystemLookupItem entity)
{
Id = entity.Id;
CanonicalName = entity.CanonicalName;
DisplayName = entity.DisplayName;
CloneToAdminDatabase = entity.CloneToAdminDatabase;
Values = SystemLookupItemValueModel.Construct(entity.Values);
Enabled = entity.Enabled;
}
/// <summary>
/// Creates multiple items in the [TangledServices.ServicePortal].[LookupItems] container.
/// </summary>
/// <param name="container">The container represented as a ResetContainerModel object.</param>
/// <returns>ContainerResponse object</returns>
private async Task CreateContainerLookupGroups(SystemLookupItem container)
{
//if (container.Groups != null)
//{
// foreach (LookupGroup group in container.Groups)
// {
// await _adminLookupItemManager.CreateItemAsync(group);
// }
//}
}
public async Task <SystemLookupItemModel> DeleteItem(string groupKey, string itemKey)
{
var groupKeyIsGuid = Guid.TryParse(groupKey, out var groupId);
var itemKeyIsGuid = Guid.TryParse(itemKey, out var itemId);
var group = new SystemLookupItem();
if (groupKeyIsGuid)
{
group = await _systemLookupItemManager.GetItemAsync(groupId);
if (group == null)
{
throw new SystemLookupItemNotFoundException(string.Format("System LookupItem group ID '{0}', item ID '{1}' deleted successfully.", groupId, itemId));
}
}
else
{
group = await _systemLookupItemManager.GetItemAsync(groupKey);
if (group == null)
{
throw new SystemLookupItemNotFoundException(string.Format("System LookupItem group '{0}', item ID '{1}' deleted successfully.", groupKey, itemId));
}
}
var item = new SystemLookupItemValue();
if (itemKeyIsGuid)
{
item = group.Values.SingleOrDefault(x => x.Id == itemKey);
if (item == null)
{
throw new SystemLookupItemNotFoundException(string.Format("System LookupItem group ID '{0}', item '{1}' deleted successfully.", groupId, itemKey));
}
}
else
{
item = group.Values.SingleOrDefault(x => x.CanonicalName == itemKey);
if (group == null)
{
throw new SystemLookupItemNotFoundException(string.Format("System LookupItem group '{0}', item '{1}' deleted successfully.", groupKey, itemKey));
}
}
item.Enabled = false;
var model = new SystemLookupItemModel(group);
return(model);
}
public async Task <SystemLookupItem> UpdateGroup(SystemLookupItem model)
{
var group = await _systemLookupItemManager.GetItemAsync(model.CanonicalName);
if (group != null)
{
group.Values.ToList().ForEach(x => x.Id = x.Id != null ? x.Id : Guid.NewGuid().ToString());
SystemLookupItem results = await _systemLookupItemManager.UpsertGroupAsync(group);
return(results);
}
return(null);
}
public async Task <SystemLookupItemModel> CreateItem(SystemLookupItemModel model)
{
if (await GetItem(model.CanonicalName) != null)
{
throw new SystemLookupItemAlreadyExistsException(model.CanonicalName);
}
SystemLookupItem entity = new SystemLookupItem(model);
entity = await _systemLookupItemManager.CreateItemAsync(entity);
model = new SystemLookupItemModel(entity);
return(model);
}
public async Task <SystemLookupItemModel> Update(SystemLookupItemModel model)
{
var entity = await _systemLookupItemManager.GetItemAsync(new Guid(model.Id));
if (entity == null)
{
throw new SystemLookupItemNotFoundException();
}
entity = new SystemLookupItem(model);
entity = await _systemLookupItemManager.UpsertGroupAsync(entity);
model = new SystemLookupItemModel(entity);
return(model);
}
public async Task <SystemLookupItem> CreateItem(SystemLookupItemModel model)
{
if (await GetItem(model.CanonicalName) == null)
{
SystemLookupItem lookupGroupEntity = new SystemLookupItem()
{
Id = Guid.NewGuid().ToString(),
CanonicalName = model.CanonicalName,
Values = await ConvertModelToEntity(model.Values.ToList())
};
SystemLookupItem results = await _systemLookupItemManager.CreateItemAsync(lookupGroupEntity);
return(results);
}
return(null);
}
public async Task <CustomerModel> Create(CustomerModel model)
{
model = await Validate(model);
model.AdminMoniker = model.AdminMoniker.ToUpper();
model.TenantMonikers = new List <string>()
{
model.AdminMoniker
};
// Create customer entity
CustomerEntity customerEntity = new CustomerEntity(model);
// Create customer item in system database.
customerEntity = await _customersManager.CreateItemAsync(customerEntity);
// Create customer admin database.
DatabaseResponse databaseResponse = await _adminService.CreateDatabase();
if (databaseResponse.StatusCode != HttpStatusCode.Created)
{
throw new SystemDatabaseNotCreatedException();
}
// Clone 'LookupItems' container and clone items from system database.
var containerResponse = await _adminService.CreateContainer("LookupItems", "/canonicalName");
if (containerResponse.StatusCode != HttpStatusCode.Created)
{
throw new AdminContainerNotCreatedException("LookupItems");
}
var systemLookupItemModels = await _systemLookupItemService.GetItems();
var systemLookupItems = SystemLookupItem.Construct(systemLookupItemModels);
foreach (SystemLookupItem systemLookupItem in systemLookupItems)
{
if (systemLookupItem.CloneToAdminDatabase)
{
var adminLookupItemModel = new AdminLookupItemModel(systemLookupItem);
await _adminLookupItemsService.CreateItem(adminLookupItemModel);
}
}
// Create 'Users' container and clone items from system database.
containerResponse = await _adminService.CreateContainer("Users", "/username");
if (containerResponse.StatusCode != HttpStatusCode.Created)
{
throw new AdminContainerNotCreatedException("Users");
}
var systemAuthenticateUsers = await _systemUserService.GetItems();
foreach (SystemAuthenticateUser systemAuthenticateUser in systemAuthenticateUsers)
{
if (systemAuthenticateUser.CloneToAdminDatabase)
{
AdminAuthenticateUserModel adminAuthenticateUserModel = new AdminAuthenticateUserModel(systemAuthenticateUser);
await _adminUsersService.CreateItem(adminAuthenticateUserModel);
}
}
// Create customer 'admin' user.
foreach (AdminAuthenticateUserModel adminUserModel in model.Users)
{
adminUserModel.NameFirst = adminUserModel.NameFirst.Replace("{moniker}", model.AdminMoniker.ToUpper());
adminUserModel.Username = adminUserModel.Username.Replace("{moniker}", model.AdminMoniker.ToLower());
adminUserModel.DisplayAs = adminUserModel.DisplayAs.Replace("{moniker}", model.AdminMoniker.ToUpper());
adminUserModel.EmailAddresses.ForEach(x => x.Address = x.Address.Replace("{moniker}", model.AdminMoniker.ToLower()));
//for (int i = 0; i < adminUserModel.Roles.Count; i++) adminUserModel.Roles[i] = adminUserModel.Roles[i].Replace("{moniker}", model.AdminMoniker.ToUpper());
var randomWord = await Helpers.GetRandomWordFromWordsApi();
var joPassword = JObject.Parse(randomWord)["word"];
adminUserModel.Password = _hashingService.EncryptString(joPassword.ToString());
adminUserModel.EmailAddresses = await _adminEmailAddressService.Validate(adminUserModel.EmailAddresses);
adminUserModel.PhoneNumbers = await _adminPhoneNumberService.Validate(adminUserModel.PhoneNumbers);
await _adminUsersService.CreateItem(adminUserModel);
}
// Create Tenants container.
containerResponse = await _adminService.CreateContainer("Tenants", "/moniker");
if (containerResponse.StatusCode != HttpStatusCode.Created)
{
throw new AdminContainerNotCreatedException("Tenants");
}
model = new CustomerModel(customerEntity);
return(model);
}
public async Task <SystemLookupItem> UpsertGroupAsync(SystemLookupItem group)
{
var results = await _container.UpsertItemAsync <SystemLookupItem>(group);
return(results);
}
public async Task <SystemLookupItem> CreateItemAsync(SystemLookupItem group)
{
var item = await _container.CreateItemAsync <SystemLookupItem>(group);
return(item);
}
public async Task <SystemLookupItem> GetItemAsync(Enums.LookupItems group)
{
SystemLookupItem result = await GetItemAsync(group.GetDescription());
return(result);
}
public async Task <SystemLookupItem> GetItem(Enums.LookupItems item)
{
SystemLookupItem results = await _systemLookupItemManager.GetItemAsync(item);
return(results);
}
public async Task <SystemLookupItem> GetItem(string itemName)
{
SystemLookupItem results = await _systemLookupItemManager.GetItemAsync(itemName);
return(results);
}
/// <summary>
/// Creates a container in the [TangledServices.ServicePortal] database.
/// </summary>
/// <param name="database">The [TangledServices.ServicePortal] database object.</param>
/// <param name="container">The container represented as a ResetContainerModel object.</param>
/// <returns>ContainerResponse object</returns>
private async Task <ContainerResponse> CreateContainer(SystemLookupItem group)
{
ContainerResponse containerResponse = await _adminManager.CreateContainer(group.CanonicalName, group.CanonicalName);
return(containerResponse);
}
