public async Task <InvokeResult <UserNotificationInfo> > GetUserAsync(string id) { await ValidateRequest(HttpContext.Request); if (await _orgUserRepo.QueryOrgHasUserAsync(OrgEntityHeader.Id, id)) { var user = await _userManager.GetUserByIdAsync(id, OrgEntityHeader, UserEntityHeader); if (user == null) { return(InvokeResult <UserNotificationInfo> .FromError("Could not find requested user by user id")); } else { return(InvokeResult <UserNotificationInfo> .Create(new UserNotificationInfo() { Id = id, Email = user.Email.ToLower(), Phone = user.PhoneNumber })); } } else { return(InvokeResult <UserNotificationInfo> .FromError("Requested user does not belong to deployment org")); } }
public async Task <InvokeResult <Mission> > GetWayPointsAsync(IConnectedUas uas) { var mission = new Mission(); var missionRequest = new UasMissionRequestList { TargetSystem = uas.Uas.SystemId, TargetComponent = uas.Uas.ComponentId }; var result = await uas.Transport.RequestDataAsync <UasMissionCount>(missionRequest, UasMessages.MissionCount); if (result.Successful) { for (ushort idx = 0; idx < result.Result.Count; ++idx) { var reqf = new UasMissionRequestInt { TargetSystem = uas.Uas.SystemId, TargetComponent = uas.Uas.ComponentId, Seq = idx }; var wpResult = await uas.Transport.RequestDataAsync <UasMissionItemInt>(reqf, UasMessages.MissionItemInt); if (wpResult.Successful) { mission.Waypoints.Add(Waypoint.Create(wpResult.Result)); } } } return(InvokeResult <Mission> .Create(mission)); }
private Task <InvokeResult <TAsyncResult> > GetAsyncResult <TAsyncResult>(AsyncRequest <object> asyncRequest) { if (!asyncRequest.CompletionSource.Task.IsCompleted) { UsageMetrics.ErrorCount++; return(Task.FromResult(InvokeResult <TAsyncResult> .FromError("Timeout waiting for response."))); } if (asyncRequest.CompletionSource.Task.Result == null) { UsageMetrics.ErrorCount++; return(Task.FromResult(InvokeResult <TAsyncResult> .FromError("Null Response From Completion Routine."))); } var result = asyncRequest.CompletionSource.Task.Result; if (result is TAsyncResult typedResult) { return(Task.FromResult(InvokeResult <TAsyncResult> .Create(typedResult))); } else { UsageMetrics.ErrorCount++; return(Task.FromResult(InvokeResult <TAsyncResult> .FromError($"Type Mismatch - Expected: {typeof(TAsyncResult).Name} - Actual: {result.GetType().Name}."))); } }
public InvokeResult <AuthResponse> GenerateAuthResponse(AppUser appUser, AuthRequest authRequest, InvokeResult <RefreshToken> refreshTokenResponse) { if (!refreshTokenResponse.Successful) { return(InvokeResult <AuthResponse> .FromInvokeResult(refreshTokenResponse.ToInvokeResult())); } var accessExpires = DateTime.UtcNow.AddMinutes(_tokenOptions.AccessExpiration.TotalMinutes); var token = GetJWToken(appUser, accessExpires, authRequest.AppInstanceId); var authResponse = new AuthResponse() { AccessToken = token, AppInstanceId = authRequest.AppInstanceId, AccessTokenExpiresUTC = accessExpires.ToJSONString(), RefreshToken = refreshTokenResponse.Result.RowKey, Roles = appUser.CurrentOrganizationRoles, RefreshTokenExpiresUTC = refreshTokenResponse.Result.ExpiresUtc, User = appUser.ToEntityHeader(), Org = appUser.CurrentOrganization }; if (!String.IsNullOrEmpty(authRequest.OrgId)) { authResponse.Org = new Core.Models.EntityHeader() { Id = authRequest.OrgId, Text = authRequest.OrgName }; } return(InvokeResult <AuthResponse> .Create(authResponse)); }
public async Task <InvokeResult <FirmwareDownloadRequest> > RequestDownloadLinkAsync(string deviceRepoId, string deviceId, string firmwareId, string revisionId, EntityHeader org, EntityHeader user) { var firmware = await _repo.GetFirmwareAsync(firmwareId); if (firmware.OwnerOrganization.Id != org.Id) { return(InvokeResult <FirmwareDownloadRequest> .FromError("Can not request firmware from a different organization.")); } var revision = firmware.Revisions.SingleOrDefault(rev => rev.Id == revisionId); if (revision == null) { throw new RecordNotFoundException(nameof(FirmwareRevision), revisionId); } var request = new FirmwareDownloadRequest() { FirmwareId = firmwareId, FirmwareName = $"{firmware.FirmwareSku} {revision.VersionCode}", OrgId = org.Id, FirmwareRevisionId = revisionId, ExpiresUTC = DateTime.UtcNow.AddMinutes(30).ToJSONString(), DeviceId = deviceId, DeviceRepoId = deviceRepoId, Status = "New", PercentRequested = 0, }; await AuthorizeAsync(firmware, AuthorizeResult.AuthorizeActions.Update, user, org, "updateDeviceFirmware"); await _repo.AddDownloadRequestAsync(request); return(InvokeResult <FirmwareDownloadRequest> .Create(request)); }
private async Task <InvokeResult <CloudBlobContainer> > GetStorageContainerAsync(string orgId) { var client = CreateBlobClient(_blobConnectionSettings); var containerName = $"dtresource-{orgId}".ToLower(); Console.WriteLine(containerName); var container = client.GetContainerReference(containerName); try { var options = new BlobRequestOptions() { MaximumExecutionTime = TimeSpan.FromSeconds(15) }; var opContext = new OperationContext(); await container.CreateIfNotExistsAsync(options, opContext); return(InvokeResult <CloudBlobContainer> .Create(container)); } catch (ArgumentException ex) { _logger.AddException("MediaServicesRepo_GetStorageContainerAsync", ex); return(InvokeResult <CloudBlobContainer> .FromException("MediaServicesRepo_GetStorageContainerAsync_InitAsync", ex)); } catch (StorageException ex) { _logger.AddException("MediaServicesRepo_GetStorageContainerAsync", ex); return(InvokeResult <CloudBlobContainer> .FromException("MediaServicesRepo_GetStorageContainerAsync", ex)); } }
public async Task <InvokeResult <AppUser> > ChangeOrgsAsync(string newOrgId, EntityHeader org, EntityHeader user) { if (newOrgId == org.Id) { return(InvokeResult <AppUser> .FromErrors(UserAdminErrorCodes.AuthAlreadyInOrg.ToErrorMessage())); } var hasAccess = await _orgUserRepo.QueryOrgHasUserAsync(newOrgId, user.Id); if (!hasAccess) { return(InvokeResult <AppUser> .FromErrors(UserAdminErrorCodes.AuthOrgNotAuthorized.ToErrorMessage())); } var newOrg = await _organizationRepo.GetOrganizationAsync(newOrgId); var appUser = await _appUserRepo.FindByIdAsync(user.Id); appUser.CurrentOrganization = newOrg.ToEntityHeader(); appUser.IsOrgAdmin = await _orgUserRepo.IsUserOrgAdminAsync(newOrgId, user.Id); appUser.IsAppBuilder = await _orgUserRepo.IsAppBuilderAsync(newOrgId, user.Id); await AuthorizeAsync(appUser, AuthorizeResult.AuthorizeActions.Update, user, org, "switchOrgs"); await _appUserRepo.UpdateAsync(appUser); return(InvokeResult <AppUser> .Create(appUser)); }
public async Task <InvokeResult <ServiceTicket> > AddTicketNoteAsync(string ticketId, ServiceTicketNote ticketNote, EntityHeader org, EntityHeader user) { if (string.IsNullOrEmpty(ticketId)) { throw new ArgumentNullException(nameof(ticketId)); } if (org == null) { throw new ArgumentNullException(nameof(org)); } if (user == null) { throw new ArgumentNullException(nameof(user)); } if (ticketNote == null) { throw new ArgumentNullException(nameof(ticketNote)); } var ticket = await _repo.GetServiceTicketAsync(ticketId); await AuthorizeAsync(ticket, AuthorizeResult.AuthorizeActions.Update, user, org, "AddNote"); ValidationCheck(ticketNote, Actions.Create); ticket.Notes.Add(ticketNote); ticket.LastUpdatedBy = user; ticket.LastUpdatedDate = ticketNote.DateStamp; await _repo.UpdateServiceTicketAsync(ticket); return(InvokeResult <ServiceTicket> .Create(ticket)); }
public static InvokeResult <IDataStreamConnector> GetConnector(DataStreamTypes type, IAdminLogger logger) { IDataStreamConnector _streamConnector = null; switch (type) { case DataStreamTypes.AWSElasticSearch: _streamConnector = new AWSElasticSearchConnector(logger); break; case DataStreamTypes.AWSS3: _streamConnector = new AWSS3Connector(logger); break; case DataStreamTypes.AzureBlob: _streamConnector = new AzureBlobConnector(logger); break; case DataStreamTypes.AzureEventHub: _streamConnector = new AzureEventHubConnector(logger); break; case DataStreamTypes.AzureTableStorage: case DataStreamTypes.AzureTableStorage_Managed: _streamConnector = new AzureTableStorageConnector(logger); break; case DataStreamTypes.SQLServer: _streamConnector = new SQLServerConnector(logger); break; case DataStreamTypes.Redis: _streamConnector = new RedisConnector(logger); break; case DataStreamTypes.Postgresql: _streamConnector = new PostgresqlConnector(logger); break; case DataStreamTypes.PointArrayStorage: _streamConnector = new PointArrayPostgresqlConnector(logger); break; } if (_streamConnector == null) { return(InvokeResult <IDataStreamConnector> .FromError("Unsupported Stream Type")); } return(InvokeResult <IDataStreamConnector> .Create(_streamConnector)); }
public async Task <InvokeResult <byte[]> > GetModelAsync(string orgId, string modelId, int revisionId) { var retryCount = 0; Exception ex = null; while (retryCount++ < 5) { try { var cloudClient = CreateBlobClient(); var primaryContainer = cloudClient.GetContainerReference(GetContainerName(orgId)); await primaryContainer.CreateIfNotExistsAsync(); var blobName = GetBlobName(modelId, revisionId); var blob = primaryContainer.GetBlobReference(blobName); using (var ms = new MemoryStream()) { await blob.DownloadToStreamAsync(ms); ms.Seek(0, SeekOrigin.Begin); return(InvokeResult <byte[]> .Create(ms.ToArray())); } } catch (Exception exc) { ex = exc; _adminLogger.AddException("MLModelRepo_GetModelAsync", ex); Console.WriteLine("Exception deserializeing: " + ex.Message); await Task.Delay(retryCount * 250); } } return(InvokeResult <byte[]> .FromException("MLModelRepo_GetModelAsync", ex)); }
public async Task <InvokeResult <string> > GetTokenAsync(string uid, string pwd) { /* Note we really should be using OAuth here, but that can wait */ var loginCredentials = new { username = uid, password = pwd }; var strContent = new StringContent(JsonConvert.SerializeObject(loginCredentials), System.Text.Encoding.ASCII, "application/json"); using (var client = new HttpClient()) { client.BaseAddress = new Uri(DOCKER_REPO_URI); var loginResponse = await client.PostAsync("v2/users/login/", strContent); if (!loginResponse.IsSuccessStatusCode) { return(InvokeResult <string> .FromError(loginResponse.ReasonPhrase)); } try { var responseContent = await loginResponse.Content.ReadAsStringAsync(); var tokenResult = JsonConvert.DeserializeObject <TokenResponse>(responseContent); return(InvokeResult <string> .Create(tokenResult.Token)); } catch (Exception ex) { return(InvokeResult <string> .FromError(ex.Message)); } } }
public async Task <InvokeResult <DeviceGroupEntry> > AddDeviceToGroupAsync(DeviceRepository deviceRepo, String deviceGroupId, String deviceUniqueId, EntityHeader org, EntityHeader user) { var group = await GetDeviceGroupAsync(deviceRepo, deviceGroupId, org, user); await AuthorizeAsync(group, AuthorizeResult.AuthorizeActions.Update, user, org, "Add Device to Device Group"); var device = await GetDeviceManagementRepo(deviceRepo).GetDeviceByIdAsync(deviceRepo, deviceUniqueId); await AuthorizeAsync(device, AuthorizeResult.AuthorizeActions.Update, user, org, "Add Devvice to Device Group"); //TODO: Add localization if (group.Devices.Where(grp => grp.DeviceUniqueId == deviceUniqueId).Any()) { return(InvokeResult <DeviceGroupEntry> .FromError($"The device [{device.DeviceId}] already belongs to this device group and can not be added again.")); } var entry = DeviceGroupEntry.FromDevice(device, user); group.Devices.Add(entry); device.DeviceGroups.Add(new EntityHeader() { Id = group.Id, Text = group.Name }); await GetDeviceManagementRepo(deviceRepo).UpdateDeviceAsync(deviceRepo, device); await GetDeviceGroupRepo(deviceRepo).UpdateDeviceGroupAsync(deviceRepo, group); return(InvokeResult <DeviceGroupEntry> .Create(entry)); }
public async Task <InvokeResult <Device> > GetDeviceByiOSBLEAddressAsync(DeviceRepository deviceRepo, string iosBLEAddress, EntityHeader org, EntityHeader user) { if (String.IsNullOrEmpty(iosBLEAddress)) { throw new ArgumentNullException(nameof(iosBLEAddress)); } if (!Regex.IsMatch(iosBLEAddress, @"^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$")) { throw new ValidationException("Invalid mac address", false, $"{iosBLEAddress} is not a valid mac address."); } var repo = GetRepo(deviceRepo); if (repo == null) { throw new NullReferenceException(nameof(repo)); } var device = await repo.GetDeviceByiOSBLEAddressAsync(deviceRepo, iosBLEAddress); if (device == null) { return(InvokeResult <Device> .FromError($"Could not find device with mac address {iosBLEAddress}")); } await AuthorizeAsync(device, AuthorizeActions.Read, user, org); return(InvokeResult <Device> .Create(device)); }
public async Task <InvokeResult <ApplicationCache> > LoadFullApplicationCacheConfigurationAsync(String id, EntityHeader org, EntityHeader user) { try { var cache = await _applicationCacheRepo.GetApplicationCacheAsync(id); await AuthorizeAsync(cache, AuthorizeResult.AuthorizeActions.Read, user, org, "LoadFull"); if (cache.CacheType.Value == CacheTypes.Redis && !String.IsNullOrEmpty(cache.PasswordSecretId)) { var getResult = await _secureStorage.GetSecretAsync(org, cache.PasswordSecretId, user); if (!getResult.Successful) { return(InvokeResult <ApplicationCache> .FromInvokeResult(getResult.ToInvokeResult())); } cache.Password = getResult.Result; } return(InvokeResult <ApplicationCache> .Create(cache)); } catch (RecordNotFoundException) { return(InvokeResult <ApplicationCache> .FromErrors(ErrorCodes.CouldNotLoadDataStreamModule.ToErrorMessage($"ModuleId={id}"))); } }
private async Task <InvokeResult <CloudBlobContainer> > GetStorageContainerAsync(string containerName) { var client = CreateBlobClient(); var container = client.GetContainerReference(containerName); try { var options = new BlobRequestOptions() { MaximumExecutionTime = TimeSpan.FromSeconds(15) }; var opContext = new OperationContext(); await container.CreateIfNotExistsAsync(options, opContext); return(InvokeResult <CloudBlobContainer> .Create(container)); } catch (ArgumentException ex) { _logger.AddException("CloudFileStorage_GetStorageContainerAsync", ex, containerName.ToKVP(nameof(containerName))); return(InvokeResult <CloudBlobContainer> .FromException("CloudFileStorage_GetStorageContainerAsync_InitAsync", ex)); } catch (StorageException ex) { _logger.AddException("ReportsLibraryRepo_GetStorageContainerAsync", ex, containerName.ToKVP(nameof(containerName))); return(InvokeResult <CloudBlobContainer> .FromException("CloudFileStorage_GetStorageContainerAsync", ex)); } }
public async Task <InvokeResult <DockerTagsResponse> > GetTagsAsync(string nameSpace, string repo, string token) { using (var client = new HttpClient()) { client.BaseAddress = new Uri(DOCKER_REPO_URI); client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("JWT", token); var repoResponse = await client.GetAsync($"v2/repositories/{nameSpace}/{repo}/tags"); if (!repoResponse.IsSuccessStatusCode) { return(InvokeResult <DockerTagsResponse> .FromError(repoResponse.ReasonPhrase)); } try { var responseContent = await repoResponse.Content.ReadAsStringAsync(); var repos = JsonConvert.DeserializeObject <DockerTagsResponse>(responseContent); return(InvokeResult <DockerTagsResponse> .Create(repos)); } catch (Exception ex) { return(InvokeResult <DockerTagsResponse> .FromError(ex.Message)); } } }
public async Task <InvokeResult <MediaResource> > AddResourceMediaAsync(String id, Stream stream, string fileName, string contentType, EntityHeader org, EntityHeader user) { var deviceTypeResource = new MediaResource(); deviceTypeResource.Id = id; await AuthorizeAsync(user, org, "addDeviceTypeResource", $"{{mediaItemId:'{id}'}}"); // Also sets the blob reference name. deviceTypeResource.SetContentType(contentType); var bytes = new byte[stream.Length]; stream.Position = 0; stream.Read(bytes, 0, (int)stream.Length); deviceTypeResource.FileName = fileName; deviceTypeResource.ContentSize = stream.Length; var result = await _mediaRepo.AddMediaAsync(bytes, org.Id, deviceTypeResource.StorageReferenceName, contentType); if (result.Successful) { return(InvokeResult <MediaResource> .Create(deviceTypeResource)); } else { return(InvokeResult <MediaResource> .FromInvokeResult(result)); } }
public async Task <InvokeResult <ModelRevision> > AddRevisionAsync(string modelId, ModelRevision revision, EntityHeader org, EntityHeader user) { revision.Id = Guid.NewGuid().ToId(); var model = await this.GetModelAsync(modelId, org, user); model.Revisions.Add(revision); revision.VersionNumber = model.Revisions.Count; revision.MinorVersionNumber = 1; if (model.Revisions.Any()) { if (!revision.Preprocessors.Any()) { revision.Preprocessors.AddRange(model.Revisions.Last().Preprocessors); } if (!revision.Settings.Any()) { revision.Settings.AddRange(model.Revisions.Last().Settings); } if (String.IsNullOrEmpty(revision.TrainingSettings)) { revision.TrainingSettings = revision.TrainingSettings; } } await this.UpdateModelAsync(model, org, user); return(InvokeResult <ModelRevision> .Create(revision)); }
private async Task <InvokeResult <CloudBlobContainer> > GetStorageContainerAsync(IConnectionSettings settings, string containerName) { var client = CreateBlobClient(settings); var container = client.GetContainerReference(containerName); try { var options = new BlobRequestOptions() { MaximumExecutionTime = TimeSpan.FromSeconds(15) }; var opContext = new OperationContext(); await container.CreateIfNotExistsAsync(options, opContext); return(InvokeResult <CloudBlobContainer> .Create(container)); } catch (ArgumentException ex) { _logger.AddException("DeviceMediaRepo_GetStorageContainerAsync", ex); return(InvokeResult <CloudBlobContainer> .FromException("DeviceMediaRepo_GetStorageContainerAsync_InitAsync", ex)); } catch (StorageException ex) { _logger.AddException("DeviceMediaRepo_GetStorageContainerAsync", ex); return(InvokeResult <CloudBlobContainer> .FromException("DeviceMediaRepo_GetStorageContainerAsync", ex)); } }
public async Task <InvokeResult <byte[]> > DownloadFirmwareAsync(string downloadId, int?start = null, int?length = null) { var request = await _repo.GetDownloadRequestAsync(downloadId); if (request == null) { throw new RecordNotFoundException(nameof(FirmwareDownloadRequest), downloadId); } if (request.Expired) { throw new NotAuthorizedException("Request has already been handled or has expired."); } if ((DateTime.UtcNow - request.ExpiresUTC.ToDateTime()).TotalMinutes > 10) { request.Expired = true; request.Status = "Expired"; request.Error = "Requested after expired."; await _repo.UpdateDownloadRequestAsync(request); throw new NotAuthorizedException("Firmware request has expired."); } await _repo.UpdateDownloadRequestAsync(request); var result = await _repo.GetFirmareBinaryAsync(request.FirmwareId, request.FirmwareRevisionId); if (result.Successful) { if (start.HasValue && length.HasValue) { var buffer = result.Result; var remainingLength = buffer.Length - start.Value; var sendLength = Math.Min(length.Value, remainingLength); var output = new byte[sendLength]; Array.Copy(buffer, start.Value, output, 0, sendLength); var requestedSoFar = start.Value + length.Value; request.PercentRequested = (requestedSoFar * 100) / buffer.Length; request.Status = "Downloading"; await _repo.UpdateDownloadRequestAsync(request); return(InvokeResult <byte[]> .Create(output)); } else { request.PercentRequested = 100; request.Status = "Downloading"; return(result); } } else { return(result); } }
public async Task <InvokeResult <SharedConnection> > LoadFullSharedConnectionAsync(string id, EntityHeader org, EntityHeader user) { var connection = await _sharedConnectionRepo.GetSharedConnectionAsync(id); await AuthorizeAsync(connection, AuthorizeResult.AuthorizeActions.Read, user, org, "WithSecrets"); switch (connection.ConnectionType.Value) { case SharedConnectionTypes.AWS: { var result = await _secureStorage.GetSecretAsync(org, connection.AWSSecretKeySecureId, user); if (!result.Successful) { return(InvokeResult <SharedConnection> .FromInvokeResult(result.ToInvokeResult())); } connection.AwsSecretKey = result.Result; } break; case SharedConnectionTypes.Azure: { var result = await _secureStorage.GetSecretAsync(org, connection.AzureAccessKeySecureId, user); if (!result.Successful) { return(InvokeResult <SharedConnection> .FromInvokeResult(result.ToInvokeResult())); } connection.AzureAccessKey = result.Result; } break; case SharedConnectionTypes.Redis: { var result = await _secureStorage.GetSecretAsync(org, connection.RedisPasswordSecureId, user); if (!result.Successful) { return(InvokeResult <SharedConnection> .FromInvokeResult(result.ToInvokeResult())); } connection.RedisPassword = result.Result; } break; case SharedConnectionTypes.Database: { var result = await _secureStorage.GetSecretAsync(org, connection.DBPasswordSecureId, user); if (!result.Successful) { return(InvokeResult <SharedConnection> .FromInvokeResult(result.ToInvokeResult())); } connection.DbPassword = result.Result; } break; } return(InvokeResult <SharedConnection> .Create(connection)); }
public async Task <InvokeResult <byte[]> > GetFileAsync(string fileName) { if (string.IsNullOrEmpty(fileName)) { throw new ArgumentNullException(nameof(fileName)); } if (fileName.StartsWith("/")) { fileName = fileName.TrimStart('/'); } var result = await GetStorageContainerAsync(_containerName); if (!result.Successful) { return(InvokeResult <byte[]> .FromInvokeResult(result.ToInvokeResult())); } var container = result.Result; var blob = container.GetBlockBlobReference(fileName); var numberRetries = 5; var retryCount = 0; var completed = false; while (retryCount++ < numberRetries && !completed) { try { //TODO: We shouldn't likely return a byte array here probably return access to the response object and stream the bytes as they are downloaded, current architecture doesn't support... using (var ms = new MemoryStream()) { await blob.DownloadToStreamAsync(ms); return(InvokeResult <byte[]> .Create(ms.ToArray())); } } catch (Exception ex) { if (retryCount == numberRetries) { _logger.AddException("CloudFileStorage_GetFileAsync", ex, _containerName.ToKVP("containerName")); return(InvokeResult <byte[]> .FromException("CloudFileStorage_GetFileAsync", ex)); } else { _logger.AddCustomEvent(LagoVista.Core.PlatformSupport.LogLevel.Warning, "CloudFileStorage_GetFileAsync", "", fileName.ToKVP("fileName"), _containerName.ToKVP("containerName"), ex.Message.ToKVP("exceptionMessage"), ex.GetType().Name.ToKVP("exceptionType"), retryCount.ToString().ToKVP("retryCount")); } await Task.Delay(retryCount * 250); } } return(InvokeResult <byte[]> .FromError("Could not retrieve Media Item")); }
public async Task <InvokeResult <string> > AddServiceTicketAsync(ServiceTicket serviceTicket, EntityHeader org, EntityHeader user) { ValidationCheck(serviceTicket, Actions.Create); await AuthorizeAsync(serviceTicket, AuthorizeResult.AuthorizeActions.Create, user, org); await _repo.AddServiceTicketAsync(serviceTicket); return(InvokeResult <string> .Create(serviceTicket.TicketId)); }
public async Task <InvokeResult <InputTranslatorConfiguration> > LoadFullInputTranslatorConfigurationAsync(String id) { try { var inputTranslator = await _inputTranslatorConfigurationRepo.GetInputTranslatorConfigurationAsync(id); switch (inputTranslator.InputTranslatorType.Value) { case InputTranslatorConfiguration.InputTranslatorTypes.NuvAIModel: if (EntityHeader.IsNullOrEmpty(inputTranslator.Model)) { throw new InvalidDataException("Input Translator set to be NuvAI, but does not have a model object assigned."); } inputTranslator.Model.Value = await _modelRepo.GetModelAsync(inputTranslator.Model.Id); if (inputTranslator.Model.Value == null) { throw new RecordNotFoundException("Model", inputTranslator.Model.Id); } if (EntityHeader.IsNullOrEmpty(inputTranslator.ModelRevision) && EntityHeader.IsNullOrEmpty(inputTranslator.Model.Value.PreferredRevision)) { throw new InvalidDataException("Input Translator does not have a model revision, model does not have a preferred revision."); } if (EntityHeader.IsNullOrEmpty(inputTranslator.ModelRevision)) { inputTranslator.ModelRevision.Value = inputTranslator.Model.Value.Revisions.Where(rev => rev.Id == inputTranslator.Model.Value.PreferredRevision.Id).FirstOrDefault(); if (inputTranslator.ModelRevision.Value == null) { throw new InvalidDataException("Could not find preferred model revision."); } } else { inputTranslator.ModelRevision.Value = inputTranslator.Model.Value.Revisions.Where(rev => rev.Id == inputTranslator.ModelRevision.Id).FirstOrDefault(); if (inputTranslator.ModelRevision.Value == null) { throw new InvalidDataException("Could not find specified model revision."); } } break; } return(InvokeResult <InputTranslatorConfiguration> .Create(inputTranslator)); } catch (RecordNotFoundException) { return(InvokeResult <InputTranslatorConfiguration> .FromErrors(ErrorCodes.CouldNotLoadInputTranslator.ToErrorMessage($"ModuleId={id}"))); } }
public async Task <InvokeResult <string> > SendAsync(MessageTransmissionPlan plan) { IsBusy = true; _pointIndex = 0; var messageTemplate = plan.Message.Value; try { InvokeResult res = InvokeResult.FromError(""); switch (messageTemplate.Transport.Value) { case TransportTypes.TCP: res = await SendTCPMessage(plan); break; case TransportTypes.UDP: res = await SendUDPMessage(plan); break; case TransportTypes.AzureServiceBus: res = await SendServiceBusMessage(plan); break; case TransportTypes.AzureEventHub: res = await SendEventHubMessage(plan); break; case TransportTypes.AzureIoTHub: res = await SendIoTHubMessage(plan); break; case TransportTypes.MQTT: res = await SendMQTTMessage(plan); break; case TransportTypes.RestHttps: case TransportTypes.RestHttp: res = await SendRESTRequestAsync(plan); break; } if (res.Successful) { var msg = BuildRequestContent(plan); return(InvokeResult <string> .Create(msg)); } else { return(InvokeResult <string> .FromInvokeResult(res)); } } catch (Exception ex) { _adminLogger.AddException("Send", ex); ReceivedContent = ex.Message; await _notificationPublisher.PublishTextAsync(Targets.WebSocket, Channels.Simulator, InstanceId, $"Error sending {messageTemplate.Transport.Value} message {ex.Message}."); return(InvokeResult <string> .FromException("SendAsync", ex)); } finally { IsBusy = false; } }
public async Task <InvokeResult <TransmitterConfiguration> > LoadFullTransmitterConfigurationAsync(String id) { try { return(InvokeResult <TransmitterConfiguration> .Create(await _transmitterConfigurationRepo.GetTransmitterConfigurationAsync(id))); } catch (RecordNotFoundException) { return(InvokeResult <TransmitterConfiguration> .FromErrors(ErrorCodes.CouldNotLoadTransmitter.ToErrorMessage($"ModuleId={id}"))); } }
public async Task <InvokeResult <DataStream> > LoadFullDataStreamConfigurationAsync(String id) { try { return(InvokeResult <DataStream> .Create(await _dataStreamRepo.GetDataStreamAsync(id))); } catch (RecordNotFoundException) { return(InvokeResult <DataStream> .FromErrors(ErrorCodes.CouldNotLoadDataStreamModule.ToErrorMessage($"ModuleId={id}"))); } }
public Task <InvokeResult <string> > GetSecretAsync(EntityHeader org, string id, EntityHeader user) { if (_storage.ContainsKey(id)) { return(Task.FromResult(InvokeResult <string> .Create(_storage[id]))); } else { return(Task.FromResult(InvokeResult <string> .FromError("Could not find key."))); } }
public async Task <InvokeResult <Solution> > LoadFullSolutionAsync(string id, EntityHeader org, EntityHeader user) { var result = new InvokeResult <Solution>(); var solution = await _deploymentRepo.GetSolutionAsync(id); foreach (var config in solution.DeviceConfigurations) { var loadResult = await _deviceConfigManager.LoadFullDeviceConfigurationAsync(config.Id, org, user); if (result.Successful) { config.Value = loadResult.Result; } else { result.Concat(loadResult); } } if (solution.Planner.IsEmpty()) { result.Errors.Add(DeploymentErrorCodes.NoPlannerSpecified.ToErrorMessage()); } else { var loadResult = await _pipelineModuleManager.LoadFullPlannerConfigurationAsync(solution.Planner.Id); if (loadResult.Successful) { solution.Planner.Value = loadResult.Result; } else { result.Concat(loadResult); } } foreach (var listenerConfig in solution.Listeners) { var loadResult = await _pipelineModuleManager.LoadFullListenerConfigurationAsync(listenerConfig.Id); if (loadResult.Successful) { listenerConfig.Value = loadResult.Result; } else { result.Concat(loadResult); } } return(InvokeResult <Solution> .Create(solution)); }
public async Task <InvokeResult <CustomModuleConfiguration> > LoadFullCustomPipelineModuleConfigurationAsync(String id) { try { return(InvokeResult <CustomModuleConfiguration> .Create(await _customPipelineConfigurationRepo.GetCustomPipelineModuleConfigurationAsync(id))); } catch (RecordNotFoundException) { return(InvokeResult <CustomModuleConfiguration> .FromErrors(ErrorCodes.CouldNotLoadCustomModule.ToErrorMessage($"ModuleId={id}"))); } }