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}")));
}
}
