public async Task <ResultSingle <Trader> > QueryUserAsync(string email, bool throwIfError = true)
{
Trader seed = new Trader();
seed.Email = email;
ResultSingle <Trader> result = await ResultSingleUI <Trader> .WaitForObjectAsync(
throwIfError, seed, new CachedHttpRequest <Trader, ResultSingle <Trader> >(
Backend.QueryAsync), false);
return(result);
}
async public Task <ResultSingle <App> > QueryStatusAsync()
{
ResultSingle <App> result = await QueryAppAsync();
if (result.Code == 0)
{
await DeploymentViewModel.InitAsync();
}
OnPropertyChanged("EditApp");
return(result);
}
public async Task <ResultSingle <Permit <UserT> > > RevokeTokenAsync(
bool throwIfError = true)
{
ResultSingle <Permit <UserT> > result = await
Backend.RevokeAccessAsync();
if (result.Code < 0 && throwIfError)
{
MessageHandler.ThrowMessage(result);
}
return(result);
}
public async Task <ResultSingle <Devkit> > QueryDevkitAsync(Devkit devkit,
bool doCache = false, bool throwIfError = true)
{
ResultSingle <Devkit> result = await ResultSingleUI <Devkit> .WaitForObjectAsync(
throwIfError, devkit, new CachedHttpRequest <Devkit, ResultSingle <Devkit> >(
Backend.QueryAsync), doCache);
if (result.Code >= 0)
{
result.Data.Payload.CopyTo(devkit);
}
return(result);
}
public static async Task <ResultSingle <PayloadT> > WaitForObjectAsync(bool throwIfError,
PayloadT seed, CachedHttpRequest <PayloadT, ResultSingle <PayloadT> > request,
bool doCache = true, IDictionary <string, object> data = null, string subPath = null)
{
ResultSingle <PayloadT> result = await
request(seed, data, subPath, doCache);
if (result.Code < 0 && throwIfError)
{
MessageHandler.ThrowMessage(result);
}
return(result);
}
public async Task <ResultSingle <Permit <UserT> > > RevokeAccessAsync(
Dictionary <string, object> data = null)
{
Notifier?.BeginQuery();
ResultSingle <Permit <UserT> > result = await
Send <Permit <UserT>, ResultSingle <Permit <UserT> >, Permit <UserT> >(
new HttpRequest <Permit <UserT>, ResultSingle <Permit <UserT> > >(DeleteAsync),
Permit, true, data, null, false);
Notifier?.EndQuery();
return(result);
}
public async Task <ResultSingle <Share> > UpdateShareAsync(
bool doCache = true, bool throwIfError = true)
{
ResultSingle <Share> result = await ResultSingleUI <Share> .WaitForObjectAsync(
throwIfError, _selectedShare, new CachedHttpRequest <Share, ResultSingle <Share> >(
Backend.UpdateAsync), doCache);
if (result.Code >= 0)
{
result.Data.Payload.CopyTo(SelectedShare);
}
return(result);
}
public async Task <ResultSingle <ObjectT> > RemoveAsync <ObjectT>(
ObjectT seed, IDictionary <string, object> data = null,
string subPath = null, bool doCache = false)
where ObjectT : ICloudObject, new()
{
Notifier?.BeginQuery();
ResultSingle <ObjectT> result = await TrySend <ObjectT, ResultSingle <ObjectT>, ObjectT>(
new HttpRequest <ObjectT, ResultSingle <ObjectT> >(DeleteAsync),
seed, true, data, subPath, doCache);
Notifier?.EndQuery();
return(result);
}
public async Task <ResultSingle <Credit> > QueryCreditAsync(Credit credit = null,
bool dCache = false, bool throwIfError = true)
{
Credit theCredit = credit == null ? EditCredit : credit;
ResultSingle <Credit> result = await ResultSingleUI <Credit> .WaitForObjectAsync(
throwIfError, theCredit, new CachedHttpRequest <Credit, ResultSingle <Credit> >(
Backend.QueryAsync), dCache, null, null);
if (result.Code >= 0)
{
EditCredit = result.Data.Payload;
}
return(result);
}
public async Task <ResultSingle <PaymentMethod> > CreatePaymentMethodAsync(
bool doCache = false, bool throwIfError = true)
{
EditPaymentMethod.OwnedBy = Backend.Permit.User;
ResultSingle <PaymentMethod> result = await ResultSingleUI <PaymentMethod> .WaitForObjectAsync(
throwIfError, EditPaymentMethod, new CachedHttpRequest <PaymentMethod, ResultSingle <PaymentMethod> >(
Backend.CreateAsync), doCache);
if (result.Code >= 0)
{
EditPaymentMethod = result.Data.Payload;
}
return(result);
}
public async Task <ResultSingle <Inkton.Nest.Model.Nest> > UpdateNestAsync(Inkton.Nest.Model.Nest nest = null,
bool doCache = false, bool throwIfError = true)
{
Inkton.Nest.Model.Nest theNest = nest == null ? _editNest : nest;
ResultSingle <Inkton.Nest.Model.Nest> result = await ResultSingleUI <Inkton.Nest.Model.Nest> .WaitForObjectAsync(
throwIfError, theNest, new CachedHttpRequest <Inkton.Nest.Model.Nest, ResultSingle <Inkton.Nest.Model.Nest> >(
Backend.UpdateAsync), doCache);
if (result.Code >= 0)
{
_editNest = result.Data.Payload;
}
return(result);
}
public async Task <ResultSingle <Share> > QueryShareAsync(
bool doCache = true, bool throwIfError = true)
{
SelectedShare.OwnedBy = _selectedIndustry;
ResultSingle <Share> result = await ResultSingleUI <Share> .WaitForObjectAsync(
throwIfError, SelectedShare, new CachedHttpRequest <Share, ResultSingle <Share> >(
Backend.QueryAsync), doCache);
if (result.Code >= 0)
{
result.Data.Payload.CopyTo(SelectedShare);
}
return(result);
}
public async Task <ResultSingle <Permit <UserT> > > SignupAsync(
Dictionary <string, object> data = null)
{
Notifier?.BeginQuery();
ResultSingle <Permit <UserT> > result = await
Send <Permit <UserT>, ResultSingle <Permit <UserT> >, Permit <UserT> >(
new HttpRequest <Permit <UserT>, ResultSingle <Permit <UserT> > >(PostAsync),
Permit, false, data, null, false);
UpdatePermit(result);
Notifier?.EndQuery();
return(result);
}
public async Task<ResultSingle<AppDomainCertificate>> UpdateDomainCertificateAsync(AppDomainCertificate cert = null,
bool doCache = false, bool throwIfError = true)
{
AppDomainCertificate theCert = cert == null ? _editDomain.Certificate : cert;
ResultSingle<AppDomainCertificate> result = await ResultSingleUI<AppDomainCertificate>.WaitForObjectAsync(
throwIfError, theCert, new CachedHttpRequest<AppDomainCertificate, ResultSingle<AppDomainCertificate>>(
Backend.UpdateAsync), doCache);
if (result.Code >= 0)
{
_editDomain.Certificate = result.Data.Payload;
}
return result;
}
public async Task <ResultSingle <App> > UpdateAppAsync(App app = null,
bool doCache = false, bool throwIfError = true)
{
App theApp = app == null ? _editApp : app;
ResultSingle <App> result = await ResultSingleUI <App> .WaitForObjectAsync(
throwIfError, theApp, new CachedHttpRequest <App, ResultSingle <App> >(
Backend.UpdateAsync), doCache);
if (result.Code == 0)
{
EditApp = result.Data.Payload;
}
return(result);
}
public static ResultSingle <PayloadT> ConvertObject(string json, PayloadT seed)
{
ResultSingle <PayloadT> result = JsonConvert.DeserializeObject <ResultSingle <PayloadT> >(json,
new SingleDataContainerConverter <PayloadT>());
if (result.Code == 0 && result.Data != null)
{
/* make a complete object by setting null
* values in the received object by the seed
* object
*/
FillNullsFrom(seed, result.Data.Payload);
}
return(result);
}
public async Task <ResultSingle <Collaboration> > QueryContactCollaborateAccountAsync(Collaboration collaboration = null,
bool doCache = false, bool throwIfError = true)
{
Collaboration theCollaboration = collaboration == null ? _collaboration : collaboration;
theCollaboration.AccountId = "0";
ResultSingle <Collaboration> result = await ResultSingleUI <Collaboration> .WaitForObjectAsync(
throwIfError, theCollaboration, new CachedHttpRequest <Collaboration, ResultSingle <Collaboration> >(
Backend.QueryAsync), doCache, null, null);
if (result.Code >= 0)
{
_collaboration = result.Data.Payload;
}
return(result);
}
public async Task <ResultSingle <Permit <UserT> > > SignupAsync(
string password, bool throwIfError = true)
{
Debug.Assert(!string.IsNullOrWhiteSpace(Backend.Permit.User.Email));
Dictionary <string, object> data = new Dictionary <string, object>();
data["password"] = password;
ResultSingle <Permit <UserT> > result =
await Backend.SignupAsync(data);
if (result.Code < 0 && throwIfError)
{
MessageHandler.ThrowMessage(result);
}
return(result);
}
public async Task <ResultSingle <Permit <UserT> > > RequestEmailConfirmationAsync(
bool throwIfError = true)
{
Debug.Assert(!string.IsNullOrWhiteSpace(Backend.Permit.User.Email));
Dictionary <string, object> data = new Dictionary <string, object>();
data["action"] = PermitAction.RequestEmailConfirmation.ToString();
ResultSingle <Permit <UserT> > result =
await Backend.SetupPermitAsync(data);
if (result.Code < 0 && throwIfError)
{
MessageHandler.ThrowMessage(result);
}
return(result);
}
public async Task <ResultSingle <Contact> > RemoveContactAsync(Contact contact = null,
bool doCache = false, bool throwIfError = true)
{
Contact theContact = contact == null ? _editContact : contact;
ResultSingle <Contact> result = await ResultSingleUI <Contact> .WaitForObjectAsync(
throwIfError, theContact, new CachedHttpRequest <Contact, ResultSingle <Contact> >(
Backend.RemoveAsync), doCache);
if (result.Code >= 0)
{
if (contact != null)
{
_contacts.Remove(contact);
OnPropertyChanged("Contacts");
}
}
return(result);
}
public async Task <ResultSingle <Inkton.Nest.Model.Nest> > RemoveNestAsync(Inkton.Nest.Model.Nest nest = null,
bool doCache = false, bool throwIfError = true)
{
Inkton.Nest.Model.Nest theNest = nest == null ? _editNest : nest;
ResultSingle <Inkton.Nest.Model.Nest> result = await ResultSingleUI <Inkton.Nest.Model.Nest> .WaitForObjectAsync(
throwIfError, theNest, new CachedHttpRequest <Inkton.Nest.Model.Nest, ResultSingle <Inkton.Nest.Model.Nest> >(
Backend.RemoveAsync), doCache);
if (result.Code >= 0)
{
if (nest != null)
{
_nests.Remove(nest);
OnPropertyChanged("Nests");
}
}
return(result);
}
public async Task <ResultSingle <Deployment> > RemoveDeploymentAsync(Deployment deployment = null,
bool doCache = false, bool throwIfError = true)
{
Deployment theDeployment = deployment == null ? _editApp.Deployment : deployment;
ResultSingle <Deployment> result = await ResultSingleUI <Deployment> .WaitForObjectAsync(
throwIfError, theDeployment, new CachedHttpRequest <Deployment, ResultSingle <Deployment> >(
Backend.RemoveAsync), doCache);
if (result.Code == 0)
{
if (deployment == null)
{
_deployments.Remove(deployment);
OnPropertyChanged("Deployments");
}
}
return(result);
}
public async Task<ResultSingle<AppDomain>> UpdateDomainAsync(AppDomain domain = null,
bool doCache = false, bool throwIfError = true)
{
AppDomain theDomain = domain == null ? _editDomain : domain;
ResultSingle<AppDomain> result = await ResultSingleUI<AppDomain>.WaitForObjectAsync(
throwIfError, theDomain, new CachedHttpRequest<AppDomain, ResultSingle<AppDomain>>(
Backend.UpdateAsync), doCache);
if (result.Code >= 0)
{
_editDomain = result.Data.Payload;
/* updates to the domain invalidates attached
* certificates.
*/
_editDomain.Certificate = null;
}
return result;
}
public async Task <ResultSingle <Deployment> > UpdateDeploymentAsync(string activity,
Deployment deployment = null, bool doCache = true, bool throwIfError = true)
{
Deployment theDeployment = deployment == null ? _editApp.Deployment : deployment;
Dictionary <string, object> data = new Dictionary <string, object>();
data.Add("activity", activity);
ResultSingle <Deployment> result = await ResultSingleUI <Deployment> .WaitForObjectAsync(
throwIfError, theDeployment, new CachedHttpRequest <Deployment, ResultSingle <Deployment> >(
Backend.UpdateAsync), doCache, data);
if (result.Code >= 0)
{
_editDeployment = result.Data.Payload;
_editApp.Deployment = _editDeployment;
}
return(result);
}
public async Task <ResultSingle <Permit <UserT> > > ChangePasswordAsync(
string securityCode, string password, bool throwIfError = true)
{
Debug.Assert(!string.IsNullOrWhiteSpace(Backend.Permit.User.Email));
Dictionary <string, object> data = new Dictionary <string, object>();
data["action"] = PermitAction.ChangePassword.ToString();
data["securityCode"] = securityCode;
data["password"] = password;
ResultSingle <Permit <UserT> > result =
await Backend.SetupPermitAsync(data);
if (result.Code < 0 && throwIfError)
{
MessageHandler.ThrowMessage(result);
}
return(result);
}
async private void OnLoginButtonClickedAsync(object sender, EventArgs e)
{
IsServiceActive = true;
try
{
ResultSingle <Permit> result = await BaseViewModels
.AuthViewModel.QueryTokenAsync(false);
if (result.Code == Cloud.ServerStatus.NEST_RESULT_ERROR_AUTH_SECCODE)
{
// the user can be hanging in inactive state
// if he/she did not confirm the security code
// in the second stage after registration.
// this result suggests the credentials were
// sound but need to confirm the security code.
// a new sec code would have been sent too.
await PushUserUpdateAsync();
}
else if (result.Code == Cloud.ServerStatus.NEST_RESULT_SUCCESS)
{
await BaseViewModels.PaymentViewModel.InitAsync();
await BaseViewModels.AppCollectionViewModel.LoadApps();
await MainView.GoHomeAsync();
}
else
{
new ResultHandler <Permit>(result).Throw();
}
}
catch (Exception ex)
{
await ErrorHandler.ExceptionAsync(this, ex);
}
IsServiceActive = false;
}
private async void ButtonDoDiscount_ClickedAsync(object sender, EventArgs e)
{
IsServiceActive = true;
try
{
AppViewModel.ServicesViewModel.CreateServicesTables();
AppViewModel.DeploymentViewModel.ApplyCredit = null;
if (CreditCode.Text.Length > 0)
{
Credit credit = BaseViewModels.PaymentViewModel.EditCredit;
credit.Code = CreditCode.Text.Trim();
ResultSingle <Credit> result = await BaseViewModels
.PaymentViewModel.QueryCreditAsync();
if (result.Code == 0)
{
credit = BaseViewModels.PaymentViewModel.EditCredit;
DisplayTotals(credit);
AppViewModel
.DeploymentViewModel
.ApplyCredit = credit;
}
}
else
{
DisplayTotals();
}
await PricesGrid.ScrollToAsync(0, PricesGrid.Content.Height, true);
}
catch (Exception ex)
{
await ErrorHandler.ExceptionAsync(this, ex);
}
IsServiceActive = false;
}
public async Task<ResultSingle<AppDomain>> RemoveDomainAsync(AppDomain domain = null,
bool doCache = false, bool throwIfError = true)
{
AppDomain theDomain = domain == null ? _editDomain : domain;
ResultSingle<AppDomain> result = await ResultSingleUI<AppDomain>.WaitForObjectAsync(
throwIfError, theDomain, new CachedHttpRequest<AppDomain, ResultSingle<AppDomain>>(
Backend.RemoveAsync), doCache);
if (result.Code >= 0)
{
if (domain != null)
{
// any cert that belong to the domain
// are automatically removed in the server
_domains.Remove(domain);
OnPropertyChanged("Domains");
}
}
return result;
}
public async Task<ResultSingle<AppDomain>> QueryDomainAsync(AppDomain domain = null,
bool doCache = false, bool throwIfError = true)
{
AppDomain theDomain = domain == null ? _editDomain : domain;
ResultSingle<AppDomain> result = await ResultSingleUI<AppDomain>.WaitForObjectAsync(
throwIfError, theDomain, new CachedHttpRequest<AppDomain, ResultSingle<AppDomain>>(
Backend.QueryAsync), doCache, null, null);
if (result.Code >= 0)
{
_editDomain = result.Data.Payload;
AppDomainCertificate seedCert = new AppDomainCertificate();
seedCert.OwnedBy = _editDomain;
ResultMultiple<AppDomainCertificate> certResult = await ResultMultipleUI<AppDomainCertificate>.WaitForObjectsAsync(
true, seedCert, new CachedHttpRequest<AppDomainCertificate, ResultMultiple<AppDomainCertificate>>(
Backend.QueryAsyncListAsync), true);
if (certResult.Code >= 0)
{
ObservableCollection<AppDomainCertificate> list = certResult.Data.Payload;
if (list.Any())
{
theDomain.Certificate = list.First();
theDomain.Certificate.OwnedBy = theDomain;
}
}
if (domain != null)
{
_editDomain.CopyTo(domain);
}
}
return result;
}
public void TestSearch()
{
// Arrange
var mockRuntime = new Mock <Runtime>(
QueueMode.Server | QueueMode.Client,
180, Enviorenment.Development
)
{
CallBase = true
};
mockRuntime.Setup(x => x.ReceiveSingle <SearchResult>())
.Returns(ResultSingle <SearchResult> .ConvertObject(
GetInput("test-input-a"), new SearchResult()));
mockRuntime.Setup(x => x.ReceiveSingle <SearchResult>())
.Returns(ResultSingle <SearchResult> .ConvertObject(
GetInput("test-input-b"), new SearchResult()));
var serviceProvider = new ServiceCollection()
.AddLogging()
.BuildServiceProvider();
var factory = serviceProvider.GetService <ILoggerFactory>();
var logger = factory.CreateLogger <SearchController>();
var controller = new SearchController(
logger, mockRuntime.Object);
// Act
var result = controller.Get("docker");
// Assert
var okResult = result as JsonResult;
Assert.NotNull(okResult);
Assert.Equal(200, okResult.StatusCode);
Assert.IsType <Result <List <SearchResult> > >(okResult.Value);
}