public async Task SigninAuthLogicSignup()
{
var logic = new CoreApiLogicHandler();
logic.Result.Setup(m => m.Execute(It.IsAny <WriteToken>())).Returns(true);
var command = new SigninAuth
{
LogicHandler = logic,
Login = StandardUser,
Config = UserConfigData.GetFirst(),
Tenant = TenantData.GetFirst(),
Settings = new FakeSettings()
};
await command.Execute();
logic.HasExecuted.Should().BeTrue();
logic.Result.Should().NotBeNull();
command.Result.Verification.Should().BeNullOrEmpty();
command.Result.Key.Should().NotBeNullOrEmpty();
command.Result.Message.Should().BeNullOrEmpty();
command.Result.Config.Should().NotBeNull();
command.Result.Id.Should().NotBeNullOrEmpty();
command.Result.Success.Should().BeTrue();
}
public async Task UserControllerFilter()
{
var data = new FakeApiDataResultHandler <Tenant, TenantDisplay>();
var list = new List <TenantDisplay> {
TenantData.GetFirstDisplay()
};
var filter = new TenantFilter {
TenantRestrict = true
};
data.Result.Setup(m => m.Execute(It.IsAny <TenantDisplayByFilter>())).Returns(list);
var controller = new TenantController(data, Logic)
{
CurrentUser = SuperUser
};
var result = await controller.Filter(filter) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
result.Value.Should().NotBeNull();
var check = result.Value as PagedResult <IEnumerable <TenantDisplay> >;
check.Should().NotBeNull();
check.Data.Count().Should().Be(list.Count);
Assert.That(check.Data, Is.DeepEqualTo(list));
data.HasExecuted.Should().BeTrue();
data.Result.Verify(s => s.Execute(It.IsAny <TenantDisplayByFilter>()), Times.Once());
}
internal static TenantListResult DeserializeTenantListResult(JsonElement element)
{
Optional <IReadOnlyList <TenantData> > value = default;
string nextLink = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("value"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
List <TenantData> array = new List <TenantData>();
foreach (var item in property.Value.EnumerateArray())
{
array.Add(TenantData.DeserializeTenantIdDescription(item));
}
value = array;
continue;
}
if (property.NameEquals("nextLink"))
{
nextLink = property.Value.GetString();
continue;
}
}
return(new TenantListResult(Optional.ToList(value), nextLink));
}
protected override void SetupDatabase(IDocumentStore store)
{
using var session = store.OpenSession();
session.Store(TenantData.GetFirst());
session.Store(UserData.GetFirst());
session.SaveChanges();
}
private void AddTenantToDumpDb(TenantData tenantData)
{
if (!_tasksConfig.UseDump)
{
return;
}
try
{
lock (_locker)
{
var tenant = _tenants.FindOne(Query.EQ("Tenant", tenantData.Tenant));
if (tenant != null)
{
return;
}
_tenants.Insert(tenantData);
// Create, if not exists, new index on Name field
_tenants.EnsureIndex(x => x.Tenant);
}
}
catch (Exception ex)
{
_log.ErrorFormat("AddTenantToDumpDb(tenantId={0}) Exception: {1}", tenantData.Tenant, ex.ToString());
ReCreateDump();
}
}
public async Task TenantControllerPost()
{
var data = new FakeApiDataEntityHandler <Tenant>();
var model = TenantData.GetFirst();
data.Result.Setup(m => m.Execute(It.IsAny <Loader <Tenant> >())).Returns(model);
data.Result.Setup(m => m.Execute(It.IsAny <TenantSave>())).Returns(model);
var controller = new TenantController(data, Logic)
{
CurrentUser = SuperUser
};
var viewModel = controller.Mapper.Map <TenantViewModel>(model);
var result = await controller.Post(viewModel) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
result.Value.Should().NotBeNull();
var check = result.Value as ConfirmViewModel;
check.Success.Should().BeTrue();
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeTrue();
data.Result.Verify(s => s.Execute(It.IsAny <TenantSave>()), Times.Once);
}
public async Task SimpleNotifyLogicSignup()
{
var data = new FakeApiDataEntityHandler <NotifyTemplate>();
var logic = new FakeApiLogicHandler();
var cloud = new FakeCloudHandler();
var template = NotifyTemplateData.GetFirst();
var tenant = TenantData.GetFirst();
var config = UserConfigData.GetFirst();
data.Result.Setup(m => m.Execute(It.IsAny <NotifyTemplateByName>())).Returns(template);
data.Result.Setup(m => m.Execute(It.IsAny <Loader <Tenant> >())).Returns(tenant);
data.Result.Setup(m => m.Execute(It.IsAny <Loader <UserConfig> >())).Returns(config);
cloud.Result.Setup(m => m.Execute(It.IsAny <EmailTemplateCmd>()))
.Returns(ActionConfirm.CreateSuccess("Sent"));
var command = new SimpleNotify
{
DataHandler = data,
CurrentUser = StandardUser,
TemplateName = "signup",
CloudHandler = cloud,
LogicHandler = logic,
Model = tenant
};
await command.Execute();
cloud.HasExecuted.Should().BeTrue();
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <NotifyTemplateByName>()), Times.Once());
data.Result.Verify(s => s.Execute(It.IsAny <Loader <Tenant> >()), Times.Once());
}
private void AddTenantToCache(TenantData tenantData, bool needDump = true)
{
var now = DateTime.UtcNow;
if (tenantData.Expired < now)
{
DeleteTenantFromDumpDb(tenantData.Tenant);
return; // Skip Expired tenant
}
var cacheItem = new CacheItem(tenantData.Tenant.ToString(CultureInfo.InvariantCulture), tenantData);
var nowOffset = tenantData.Expired - now;
var absoluteExpiration = DateTime.UtcNow.Add(nowOffset);
var cacheItemPolicy = new CacheItemPolicy
{
RemovedCallback = CacheEntryRemove,
AbsoluteExpiration = absoluteExpiration
};
_tenantMemCache.Add(cacheItem, cacheItemPolicy);
if (!needDump)
{
return;
}
AddTenantToDumpDb(tenantData);
}
public async Task SimpleNotifyLogicSignupMissingTemplate()
{
var data = new FakeApiDataEntityHandler <NotifyTemplate>();
var logic = new FakeApiLogicHandler();
var cloud = new FakeCloudHandler();
var template = NotifyTemplateData.GetFirst();
var tenant = TenantData.GetFirst();
data.Result.Setup(m => m.Execute(It.IsAny <NotifyTemplateByName>())).Returns(null);
var command = new SimpleNotify
{
DataHandler = data,
CurrentUser = StandardUser,
TemplateName = "signup",
CloudHandler = cloud,
LogicHandler = logic,
Model = tenant,
Result = ActionConfirm.CreateFailure("It failed")
};
await command.Execute();
command.Result.Success.Should().BeFalse();
cloud.HasExecuted.Should().BeFalse();
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <NotifyTemplateByName>()), Times.Once());
data.Result.Verify(s => s.Execute(It.IsAny <Loader <Tenant> >()), Times.Never());
}
public JsonRpcResponseData EditTenant(TenantData tenant, ApiAuthorization authorization, TenantUser user = null, TenantGroup group = null)
{
SetupAuth();
IsValidRequest(authorization.AppId, authorization.ApiKey);
var apiController = new ControllerService();
try
{
var extended = apiController.EditTenant(tenant, user, group);
return(new JsonRpcResponseData
{
Message = "Tenant edited",
Status = JsonRpcResponseData.OK,
TenantUid = extended.Tenant.TenantUId.ToString(),
Data = new
{
extended
}
});
}
catch (System.Exception ex)
{
throw HandleException(ex);
}
}
public async Task TenantControllerGet()
{
var data = new FakeApiDataEntityHandler <Tenant>();
var model = TenantData.GetFirst();
data.Result.Setup(m => m.Execute(It.IsAny <Loader <Tenant> >())).Returns(model);
var controller = new TenantController(data, Logic)
{
CurrentUser = AdminUser
};
var result = await controller.Get(TenantData.FirstId) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
result.Value.Should().NotBeNull();
var check = result.Value as TenantViewModel;
check.ProfileId.Should().Be(model.ProfileId);
check.ProfileThumbUrl.Should().Be(model.ProfileThumbUrl);
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <Loader <Tenant> >()), Times.Once);
}
public async Task SignupUserLogic()
{
var data = new SignupDataHandler();
var logic = new CoreApiLogicHandler();
var cloud = new FakeCloudHandler();
var tenant = TenantData.GetFirst();
var viewModel = LoginData.GetSignup();
data.Result.Setup(m => m.Execute(It.IsAny <Loader <Tenant> >())).Returns(tenant);
data.Result.Setup(m => m.Execute(It.IsAny <UserSave>())).Returns(StandardUser);
logic.Result.Setup(m => m.Execute(It.IsAny <SimpleNotify>())).Returns(ActionConfirm.CreateSuccess("Worked"));
var command = new SignupUser
{
DataHandler = data,
CloudHandler = cloud,
LogicHandler = logic,
Input = viewModel
};
await command.Execute();
logic.HasExecuted.Should().BeTrue();
logic.Result.Verify(s => s.Execute(It.IsAny <SimpleNotify>()), Times.Once());
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeTrue();
data.Result.Verify(s => s.Execute(It.IsAny <Loader <Tenant> >()), Times.Once());
data.Result.Verify(s => s.Execute(It.IsAny <UserSave>()), Times.AtLeastOnce());
}
public void CreateUserFromNewButton(TenantData data, string planName)
{
Log.Information("---Click New button---");
Browser.WaitForAjax();
OpenDrawer();
Log.Information("---Select User Account---");
Browser.WaitForAjax();
this.drawer.SelectItem("USER ACCOUNT");
Browser.WaitForAjax();
this.drawer.SelectItem("QUICK CREATE");
var emailTextBox = new HtmlTextBox(this, this.Browser.FindElement(By.Id("accountEmail")));
emailTextBox.SetText(data.emailAddress);
var passwordTextBox = new HtmlTextBox(this, this.Browser.FindElement(By.Id("accountPassword")));
passwordTextBox.SetText(data.password);
var repeatPswTextBox = new HtmlTextBox(this, this.Browser.FindElement(By.Id("confirmPassword")));
repeatPswTextBox.SetText(data.password);
Thread.Sleep(1000 * 2);
IWebElement ee = this.SearchContext.FindElement(By.Id("accountPlanDropDown"));
SelectElement e = new SelectElement(ee);
e.WrappedElement.Click();
e.SelectByText(planName + " (public)");
Thread.Sleep(1000 * 2);
var createButton = new HtmlButton(this, this.Browser.FindElement(By.XPath("//*[text()='Create']")));
createButton.Click();
}
public void AdminCreateUserTest(TenantData data, string planName)
{
Log.Information("---Open Service Management Portal Page...---");
TestInitialize();
var smpPage = new SmpPage(this.driver);
smpPage.CreateUserFromNewButton(data, planName);
}
public IActionResult GetTenants()
{
TenantData TenantData = new TenantData();
TenantData.Tenants = new List <TenantPersonnelModel>();
TenantData.Tenants = _tenantService.GetTenants();
TenantData.Genders = _genderService.GetGenders();
return(Ok(TenantData));
}
private async Task <Tenant> AddTenantAsync(TenantData data)
{
var command = new AddTenantCommand(data);
CommandResult <Tenant> result = await GetTenantCommandResult(command);
result.ValidationMessages.Should().BeEmpty();
result.Succeeded.Should().BeTrue();
return(result.Value);
}
public TenantService(IOptions <TenantSettings> options, IHttpContextAccessor contextAccessor)
{
tenantSettings = options.Value;
httpContext = contextAccessor.HttpContext;
if (httpContext.Request.Cookies.TryGetValue("tenant-code", out string site) && tenantSettings.Sites.ContainsKey(site))
{
tenantCode = site;
tenant = tenantSettings.Sites[site];
}
}
protected override void SetupDatabase(IDocumentStore store)
{
store.ExecuteIndex(new TenantIndex());
store.ExecuteIndex(new OwnedMasterIndex());
using var session = store.OpenSession();
session.Store(TenantData.GetFirst());
session.SaveChanges();
WaitForIndexing(store);
}
public async Task TenantByEntryKeyDataTest()
{
using var store = GetDocumentStore();
using var session = store.OpenAsyncSession();
var loader = new TenantByEntryKey {
Session = session, EntryKey = "first"
};
await loader.Execute();
loader.Result.Should().NotBeNull();
loader.Result.Id.Should().Be(TenantData.FirstId);
Assert.That(loader.Result, Is.DeepEqualTo(TenantData.GetFirst()));
}
public async Task PersistDataTestFail()
{
var model = TenantData.GetSecond();
model.Id = string.Empty;
var persist = new Persist <Tenant> {
Model = model
};
await persist.Execute();
persist.Confirm.Success.Should().BeFalse();
}
public int RenameMediaHome(TenantData tenant, TenantUser tenantUser)
{
var home = TenantHelper.GetCurrentTenantHome(ConnectorContext.ContentService, tenant.TenantUId.ToString());
if (home == null)
{
throw new TenantException(ExceptionCode.TenantNotFound.CodeToString(), ExceptionCode.TenantNotFound, tenant.TenantUId);
}
IMedia mediaHome = null;
IReadOnlyUserGroup group = null;
if (tenantUser != null)
{
var uService = ConnectorContext.UserService;
var user = uService.GetByUsername(tenantUser.Username);
group = user.Groups.ToList()[0];
mediaHome = mediaService.GetById(group.StartMediaId.Value);
}
else
{
mediaHome = mediaService.GetByLevel(1).SingleOrDefault(x => x.Name.Contains(tenant.Name));
}
if (mediaHome == null)
{
string mediaId = group?.StartMediaId.Value.ToString() ?? tenant.Name;
//string mediaId = group?.StartMediaId.Value.ToString() ?? tenant.BrandName;
throw new TenantException(ExceptionCode.MediaNodeDoesNotExist.CodeToString(), ExceptionCode.MediaNodeDoesNotExist, tenant.TenantUId, mediaId);
}
try
{
if (!mediaHome.Name.Equals(tenant.Name))
{
mediaHome.Name = tenant.Name;
//mediaHome.Name = tenant.BrandName;
mediaService.Save(mediaHome);
ConnectorContext.AuditService.Add(AuditType.Save, -1, mediaHome.Id, "Media Folder", $"Media home for {tenant.TenantUId} has been renamed");
}
return(mediaHome.Id);
}
catch (System.Exception ex)
{
logger.Error(typeof(HomeMediaNode), ex.Message);
logger.Error(typeof(HomeMediaNode), ex.StackTrace);
throw;
}
}
public async Task TenantDisplayByIdDataTest()
{
using var store = GetDocumentStore();
using var session = store.OpenAsyncSession();
var query = new TenantDisplayById {
Session = session, Id = TenantData.FirstId
};
await query.Execute();
query.Result.Should().NotBeNull();
query.Result.Id.Should().Be(TenantData.FirstId);
query.Result.Searchable.Should().BeEmpty();
Assert.That(query.Result, Is.DeepEqualTo(TenantData.GetFirstDisplay()));
}
public async Task LoadersDataTest()
{
using var store = GetDocumentStore();
using var session = store.OpenAsyncSession();
var loader = new Loaders <Tenant> {
Session = session, Ids = new List <string> {
TenantData.FirstId
}
};
await loader.Execute();
loader.Result.Should().NotBeNull();
loader.Result.First().Id.Should().Be(TenantData.FirstId);
Assert.That(loader.Result.First(), Is.DeepEqualTo(TenantData.GetFirst()));
}
public async Task PersistDataTestInsert()
{
using var store = GetDocumentStore();
using var session = store.OpenAsyncSession();
var model = TenantData.GetSecond();
model.Id = string.Empty;
var persist = new Persist <Tenant> {
Session = session, Model = model
};
await persist.Execute();
persist.Confirm.Success.Should().BeTrue();
}
public void TenantMasterTest()
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Tenant, TenantMaster>();
cfg.CreateMap <TenantMaster, Tenant>();
});
var mapper = new Mapper(config);
var master = mapper.Map <TenantMaster>(TenantData.GetFirst());
var document = mapper.Map <Tenant>(master);
master.Should().NotBeNull();
document.Should().NotBeNull();
}
public async Task TenantSaveDataTest()
{
using var store = GetDocumentStore();
using var session = store.OpenAsyncSession();
var model = TenantData.GetSecond();
var persist = new TenantSave {
Session = session, Model = model
};
await persist.Execute();
persist.Confirm.Should().NotBeNull();
persist.Confirm.Identity.Should().Be(model.Id);
persist.Confirm.Success.Should().BeTrue();
Assert.That(persist.Model, Is.DeepEqualTo(model));
}
public async Task TenantDisplayByFilterDataTestSearch()
{
var filter = new TenantFilter {
Search = "Org", Take = 10
};
using var store = GetDocumentStore();
using var session = store.OpenAsyncSession();
var query = new TenantDisplayByFilter {
Session = session, Filter = filter, CurrentUser = StandardUser
};
await query.Execute();
query.Result.Should().NotBeNull();
query.Result.Count().Should().Be(1);
Assert.That(query.Result.First(), Is.DeepEqualTo(TenantData.GetFirstDisplay()));
}
protected override void SetupDatabase(IDocumentStore store)
{
store.ExecuteIndex(new MeetingIndex());
store.ExecuteIndex(new MsgIndex());
store.ExecuteIndex(new AttendanceIndex());
store.ExecuteIndex(new TenantStatIndex());
using (var session = store.OpenSession())
{
session.Store(MeetingData.GetFirst());
session.Store(MsgData.GetFirst());
session.Store(AttendanceData.GetFirst());
session.Store(TenantData.GetFirst());
session.SaveChanges();
}
WaitForIndexing(store);
}
public async Task ThenIGetWhenTryingToModifyTenantSEmailFromTo(string errorMessage, string findEmail, string modifyEmail)
{
var repo = Resolve <ITenantRepository>();
var entity = await repo.FindByEmailAsync(findEmail);
entity.Should().NotBeNull();
var data = TenantData.From(entity);
data.Email = modifyEmail;
var command = new ModifyTenantCommand(entity.Id, data, entity.ConcurrencyToken);
CommandResult <Tenant> result = await GetTenantCommandResult(command);
result.Succeeded.Should().BeFalse();
result.ValidationMessages.Should().Contain(errorMessage);
}
public async Task TenantControllerDisplayUnauthorized()
{
var data = new FakeApiDataResultHandler <Tenant, TenantDisplay>();
var display = TenantData.GetFirstDisplay();
data.Result.Setup(m => m.Execute(It.IsAny <TenantDisplayById>())).Returns(display);
var controller = new TenantController(data, Logic)
{
CurrentUser = NonTenantUser
};
var result = await controller.Display(TenantData.FirstId) as UnauthorizedResult;
result.Should().NotBeNull();
result.Should().BeOfType <UnauthorizedResult>();
data.HasExecuted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <UserDisplayById>()), Times.Never());
}
