public static async Task QueryServicesAsync(BackendService <UserT> backend) { AppService serviceSeed = new AppService(); ResultMultiple <AppService> result = await ResultMultipleUI <AppService> .WaitForObjectsAsync( true, serviceSeed, new CachedHttpRequest <AppService, ResultMultiple <AppService> >( backend.QueryAsyncListAsync), true); if (result.Code < 0) { return; } _appServices = result.Data.Payload; AppServiceTier tierSeed = new AppServiceTier(); ResultMultiple <AppServiceTier> resultTier; foreach (AppService service in _appServices) { tierSeed.OwnedBy = service; resultTier = await ResultMultipleUI <AppServiceTier> .WaitForObjectsAsync( true, tierSeed, new CachedHttpRequest <AppServiceTier, ResultMultiple <AppServiceTier> >( backend.QueryAsyncListAsync), true); if (result.Code == 0) { service.Tiers = resultTier.Data.Payload; } } }
public async Task <ResultMultiple <Deployment> > QueryDeploymentsAsync( Deployment deployment = null, bool doCache = false, bool throwIfError = true) { Deployment theDeployment = deployment == null ? _editApp.Deployment : deployment; ResultMultiple <Deployment> result = await ResultMultipleUI <Deployment> .WaitForObjectsAsync( true, theDeployment, new CachedHttpRequest <Deployment, ResultMultiple <Deployment> >( Backend.QueryAsyncListAsync), true); _editApp.Deployment = null; if (result.Code >= 0) { _deployments = result.Data.Payload; if (_deployments.Any()) { _editDeployment = _deployments.First(); _editApp.Deployment = _editDeployment; } OnPropertyChanged("Deployments"); } return(result); }
public async Task <ResultMultiple <Forest> > QueryAppServiceTierLocationsAsync(AppServiceTier teir, bool doCache = false, bool throwIfError = true) { Forest forestSeeder = new Forest(); forestSeeder.OwnedBy = teir; return(await ResultMultipleUI <Forest> .WaitForObjectsAsync( throwIfError, forestSeeder, new CachedHttpRequest <Forest, ResultMultiple <Forest> >( Backend.QueryAsyncListAsync), doCache)); }
public async Task <ResultMultiple <T> > QueryLogsAsync <T>(string sql, bool doCache = false, bool throwIfError = false) where T : Log, new() { Dictionary <string, string> data = new Dictionary <string, string>(); data.Add("sql", sql); T logsSeed = new T(); return(await ResultMultipleUI <T> .WaitForObjectsAsync( true, logsSeed, new CachedHttpRequest <T, ResultMultiple <T> >( Backend.QueryAsyncListAsync), true)); }
public async Task <ResultMultiple <Permission> > QueryPermissionsAsync(Contact contact = null, bool doCache = false, bool throwIfError = true) { Contact theContact = contact == null ? _editContact : contact; Permission seedPermission = new Permission(); seedPermission.OwnedBy = theContact; ObservableCollection <Permission> permissions = new ObservableCollection <Permission>(); ResultMultiple <Permission> result = await ResultMultipleUI <Permission> .WaitForObjectsAsync( true, seedPermission, new CachedHttpRequest <Permission, ResultMultiple <Permission> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { permissions = result.Data.Payload; OwnerCapabilities caps = new OwnerCapabilities(); caps.Reset(); foreach (Permission permission in permissions) { switch (permission.AppPermissionTag) { case "create-app": break; case "view-app": caps.CanViewApp = true; break; case "update-app": caps.CanUpdateApp = true; break; case "delete-app": caps.CanDeleteApp = true; break; case "create-nest": caps.CanCreateNest = true; break; case "update-nest": caps.CanUpdateNest = true; break; case "delete-nest": caps.CanDeleteNest = true; break; case "view-nest": caps.CanViewNest = true; break; default: System.Diagnostics.Debugger.Break(); break; } } theContact.OwnerCapabilities = caps; } return(result); }
public async Task <ResultMultiple <BillingCycle> > QueryBillingCyclesAsync( bool doCache = true, bool throwIfError = true) { BillingCycle seed = new BillingCycle(); ResultMultiple <BillingCycle> result = await ResultMultipleUI <BillingCycle> .WaitForObjectsAsync( true, seed, new CachedHttpRequest <BillingCycle, ResultMultiple <BillingCycle> >( Backend.QueryAsyncListAsync), true); if (result.Code == 0) { BillingCycles = result.Data.Payload; } return(result); }
public async Task <ResultMultiple <Inkton.Nest.Model.Nest> > QueryNestsAsync( bool doCache = false, bool throwIfError = true) { _editNest.OwnedBy = _editApp; ResultMultiple <Nest.Model.Nest> result = await ResultMultipleUI <Nest.Model.Nest> .WaitForObjectsAsync( true, _editNest, new CachedHttpRequest <Nest.Model.Nest, ResultMultiple <Nest.Model.Nest> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { _nests = result.Data.Payload; OnPropertyChanged("Nests"); } return(result); }
public async Task <ResultMultiple <AppAudit> > QueryAppAuditsAsync(IDictionary <string, object> filter, AppAudit appAudit = null, bool doCache = false, bool throwIfError = true) { AppAudit theAudit = appAudit == null ? _editAudit : appAudit; ResultMultiple <AppAudit> result = await ResultMultipleUI <AppAudit> .WaitForObjectsAsync( true, theAudit, new CachedHttpRequest <AppAudit, ResultMultiple <AppAudit> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { _audits = result.Data.Payload; OnPropertyChanged("AppAudits"); } return(result); }
public async Task <ResultMultiple <UserBillingTask> > QueryUserBillingTasksAsync(IDictionary <string, object> filter, bool doCache = true, bool throwIfError = true) { UserBillingTask seed = new UserBillingTask(); seed.OwnedBy = Backend.Permit.User; ResultMultiple <UserBillingTask> result = await ResultMultipleUI <UserBillingTask> .WaitForObjectsAsync( true, seed, new CachedHttpRequest <UserBillingTask, ResultMultiple <UserBillingTask> >( Backend.QueryAsyncListAsync), true); if (result.Code == 0) { UserBillingTasks = result.Data.Payload; } return(result); }
public async Task <ResultMultiple <NestPlatform> > QueryNestPlatformsAsync( bool doCache = false, bool throwIfError = true) { NestPlatform platformSeed = new NestPlatform(); platformSeed.OwnedBy = _editApp; ResultMultiple <NestPlatform> result = await ResultMultipleUI <NestPlatform> .WaitForObjectsAsync( true, platformSeed, new CachedHttpRequest <NestPlatform, ResultMultiple <NestPlatform> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { _platforms = result.Data.Payload; } return(result); }
public async Task <ResultMultiple <UserEvent> > QueryUserEventsAsync(UserT user, bool doCache = false, bool throwIfError = true, Dictionary <string, object> data = null) { UserEvent userEventSeed = new UserEvent(); userEventSeed.OwnedBy = user == null ? Backend.Permit.User : user; ResultMultiple <UserEvent> result = await ResultMultipleUI <UserEvent> .WaitForObjectsAsync( true, userEventSeed, new CachedHttpRequest <UserEvent, ResultMultiple <UserEvent> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { UserEvents = result.Data.Payload; } return(result); }
public async Task <ResultMultiple <Notification> > QueryAppNotificationsAsync(App app = null, bool doCache = false, bool throwIfError = true) { App theApp = app == null ? _editApp : app; Notification notificationSeed = new Notification(); notificationSeed.OwnedBy = theApp; ResultMultiple <Notification> result = await ResultMultipleUI <Notification> .WaitForObjectsAsync( true, notificationSeed, new CachedHttpRequest <Notification, ResultMultiple <Notification> >( Backend.QueryAsyncListAsync), true); if (result.Code == 0) { _notifications = result.Data.Payload; } return(result); }
public async Task <ResultMultiple <Share> > QuerySharesAsync( bool doCache = true, bool throwIfError = true) { Share shareSeed = new Share(); shareSeed.OwnedBy = _selectedIndustry; ResultMultiple <Share> result = await ResultMultipleUI <Share> .WaitForObjectsAsync( true, shareSeed, new CachedHttpRequest <Share, ResultMultiple <Share> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { Shares = result.Data.Payload; SelectedShare = _shares.FirstOrDefault(); } return(result); }
public async Task <ResultMultiple <Invitation> > QueryInvitationsAsync( bool doCache = false, bool throwIfError = true) { ResultMultiple <Invitation> result = await ResultMultipleUI <Invitation> .WaitForObjectsAsync( true, _editInvitation, new CachedHttpRequest <Invitation, ResultMultiple <Invitation> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { _invitations = result.Data.Payload; if (_invitations.Any()) { _editInvitation = _invitations.FirstOrDefault(); } } return(result); }
public async Task <ResultMultiple <AppBackup> > QueryAppBackupsAsync(AppBackup appBackup = null, bool doCache = false, bool throwIfError = true) { AppBackup theBackup = appBackup == null ? _editBackup : appBackup; theBackup.OwnedBy = _editApp.Deployment; ResultMultiple <AppBackup> result = await ResultMultipleUI <AppBackup> .WaitForObjectsAsync( true, theBackup, new CachedHttpRequest <AppBackup, ResultMultiple <AppBackup> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { _backups = result.Data.Payload; OnPropertyChanged("AppBackups"); } return(result); }
public async Task <ResultMultiple <SoftwareFramework.Version> > QuerySoftwareFrameworkVersionsAsync( bool doCache = true, bool throwIfError = true) { SoftwareFramework frameworkSeed = new SoftwareFramework(); frameworkSeed.Tag = "aspdotnetcore"; SoftwareFramework.Version versionSeed = new SoftwareFramework.Version(); versionSeed.OwnedBy = frameworkSeed; ResultMultiple <SoftwareFramework.Version> result = await ResultMultipleUI <SoftwareFramework.Version> .WaitForObjectsAsync( true, versionSeed, new CachedHttpRequest <SoftwareFramework.Version, ResultMultiple <SoftwareFramework.Version> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { _dotnetVersions = result.Data.Payload; } return(result); }
public async Task <ResultMultiple <App> > LoadApps( bool doCache = true, bool throwIfError = true) { ResultMultiple <App> result = await ResultMultipleUI <App> .WaitForObjectAsync( Platform, throwIfError, _editApp, doCache); if (result.Code == 0) { ObservableCollection <App> apps = result.Data.Payload; if (apps.Any()) { foreach (App app in apps) { AddApp(app); } } } 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 async Task<ResultMultiple<AppDomain>> QueryDomainsAsync( bool doCache = false, bool throwIfError = true) { ResultMultiple<AppDomain> result = await ResultMultipleUI<AppDomain>.WaitForObjectsAsync( true, _editDomain, new CachedHttpRequest<AppDomain, ResultMultiple<AppDomain>>( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { _domains = result.Data.Payload; foreach (AppDomain domain in _domains) { domain.OwnedBy = _editApp; domain.Primary = (_editApp.PrimaryDomainId == domain.Id); domain.IPAddress = _editApp.IPAddress; AppDomainCertificate seedCert = new AppDomainCertificate(); seedCert.OwnedBy = domain; 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()) { domain.Certificate = list.First(); domain.Certificate.OwnedBy = domain; } } } } return result; }
public async Task <ResultMultiple <Forest> > QueryForestsAsync( bool doCache = true, bool throwIfError = true) { Forest forestSeed = new Forest(); ResultMultiple <Forest> result = await ResultMultipleUI <Forest> .WaitForObjectsAsync( true, forestSeed, new CachedHttpRequest <Forest, ResultMultiple <Forest> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { _forests = result.Data.Payload; _forestByTag.Clear(); foreach (Forest forest in _forests) { _forestByTag[forest.Tag] = forest; } } return(result); }
public async Task <ResultMultiple <AppServiceSubscription> > QueryAppSubscriptions(App app = null, bool doCache = false, bool throwIfError = true) { AppServiceSubscription subSeeder = new AppServiceSubscription(); subSeeder.OwnedBy = (app == null ? _editApp : app); ResultMultiple <AppServiceSubscription> result = await ResultMultipleUI <AppServiceSubscription> .WaitForObjectsAsync( true, subSeeder, new CachedHttpRequest <AppServiceSubscription, ResultMultiple <AppServiceSubscription> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { ObservableCollection <AppServiceSubscription> serviceSubscriptions = result.Data.Payload; foreach (AppServiceSubscription subscription in serviceSubscriptions) { subscription.OwnedBy = subSeeder.OwnedBy; foreach (AppService service in _appServices) { foreach (AppServiceTier tier in service.Tiers) { if (subscription.AppServiceTierId == tier.Id) { subscription.ServiceTier = tier; } } } } (subSeeder.OwnedBy as App).Subscriptions = serviceSubscriptions; } return(result); }
public async Task <ResultMultiple <Industry> > QueryIndustriesAsync( bool doCache = true, bool throwIfError = true) { _shares.Clear(); Industry industrySeed = new Industry(); ResultMultiple <Industry> result = await ResultMultipleUI <Industry> .WaitForObjectsAsync( true, industrySeed, new CachedHttpRequest <Industry, ResultMultiple <Industry> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { Industries = result.Data.Payload; SelectedIndustry = _industries.FirstOrDefault(); if (_selectedIndustry != null) { await QuerySharesAsync(doCache, throwIfError); } } return(result); }
public async Task <ResultMultiple <AppServiceTier> > QueryAppUpgradeServiceTiersAsync( AppService service = null, Deployment deployment = null, bool doCache = true, bool throwIfError = true) { AppService theService = service == null ? AppService : service; Deployment theDeployment = deployment == null ? _editApp.Deployment : deployment; theService.OwnedBy = theDeployment; AppServiceTier tierSeed = new AppServiceTier(); tierSeed.OwnedBy = theService; ResultMultiple <AppServiceTier> result = await ResultMultipleUI <AppServiceTier> .WaitForObjectsAsync( true, tierSeed, new CachedHttpRequest <AppServiceTier, ResultMultiple <AppServiceTier> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { _upgradableAppTiers = result.Data.Payload; } return(result); }
public async Task <ResultMultiple <Contact> > QueryContactsAsync( bool doCache = false, bool throwIfError = true) { ResultMultiple <Contact> result = await ResultMultipleUI <Contact> .WaitForObjectsAsync( true, _editContact, new CachedHttpRequest <Contact, ResultMultiple <Contact> >( Backend.QueryAsyncListAsync), true); if (result.Code >= 0) { _contacts = result.Data.Payload; _editApp.OwnerCapabilities = null; /* The owner is to be treated differently * The owner contact does not need invitation * for example. */ foreach (Contact contact in _contacts) { contact.OwnedBy = _editContact.OwnedBy; await QueryPermissionsAsync(contact, throwIfError); if (contact.UserId != null && contact.UserId == Backend.Permit.User.Id) { _ownerContact = contact; _editContact = contact; _collaboration.OwnedBy = contact; _editApp.OwnerCapabilities = contact.OwnerCapabilities; } } OnPropertyChanged("Contacts"); } return(result); }