public async Task <InvokeResult> ValidateConnectionAsync(DataStream stream)
{
var result = await InitAsync(stream);
if (!result.Successful)
{
return(result);
}
try
{
var existsResult = await _client.Indices.ExistsAsync("dontcare");
if (existsResult.IsValid)
{
return(InvokeResult.Success);
}
if (existsResult.OriginalException != null)
{
var failedResult = InvokeResult.FromError(existsResult.OriginalException.Message);
return(failedResult);
}
else
{
return(InvokeResult.FromError("Could not validate AWS Elastic Search Connection, no data returned"));
}
}
catch (Exception ex)
{
return(InvokeResult.FromException("AWSElasticSearchConnector_ValidateConnection", ex));
}
}
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 <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> AddItemAsync(DataStreamRecord item)
{
var recordId = DateTime.UtcNow.ToInverseTicksRowKey();
item.Data.Add(_stream.TimeStampFieldName, item.GetTimeStampValue(_stream));
item.Data.Add("sortOrder", item.GetTicks());
item.Data.Add("deviceId", item.DeviceId);
item.Data.Add("id", recordId);
item.Data.Add("dataStreamId", _stream.Id);
var result = await _client.IndexAsync(item.Data,
idx => idx
.Index(_stream.ESIndexName)
.Type(_stream.ESTypeName)
.Id(recordId));
if (result.IsValid)
{
return(InvokeResult.Success);
}
else
{
if (result.OriginalException != null)
{
return(InvokeResult.FromError(result.OriginalException.Message));
}
else
{
return(InvokeResult.FromError(result.ServerError.Error.Reason));
}
}
}
public async Task <InvokeResult> DisableAccountAsync(string userId, EntityHeader org, EntityHeader adminUser)
{
await AuthorizeAsync(adminUser, org, "DisabledUser", userId);
var appUser = await GetUserByIdAsync(adminUser.Id, org, adminUser);
if (appUser == null)
{
return(InvokeResult.FromError($"Could not find admin user with id: {adminUser.Id}."));
}
if (appUser.CurrentOrganization.Id != org.Id)
{
return(InvokeResult.FromError("Org Mismatch on current user."));
}
if (!appUser.IsOrgAdmin)
{
return(InvokeResult.FromError("Must be an org admin to disable a user."));
}
var user = await _appUserRepo.FindByIdAsync(userId);
user.IsAccountDisabled = true;
await _appUserRepo.UpdateAsync(user);
await LogEntityActionAsync(userId, typeof(AppUser).Name, "Disabe User Account", org, adminUser);
return(InvokeResult.Success);
}
public async Task <InvokeResult> ClearDeviceErrorAsync(DeviceRepository deviceRepo, string deviceId, string errorCode, EntityHeader org, EntityHeader user)
{
var repo = GetRepo(deviceRepo);
var device = await repo.GetDeviceByIdAsync(deviceRepo, deviceId);
var errorToRemove = device.Errors.Where(err => err.DeviceErrorCode == errorCode).FirstOrDefault();
if (errorToRemove != null)
{
device.Errors.Remove(errorToRemove);
await repo.UpdateDeviceAsync(deviceRepo, device);
await _deviceExceptionRepo.AddDeviceExceptionAsync(deviceRepo, new DeviceException()
{
DeviceId = device.DeviceId,
DeviceUniqueId = deviceId,
DeviceRepositoryId = deviceRepo.Id,
Details = $"Error cleared by {user.Text}",
ErrorCode = errorCode,
Timestamp = DateTime.UtcNow.ToJSONString()
});
return(InvokeResult.Success);
}
else
{
return(InvokeResult.FromError($"Could not find error {errorCode} on {device.DeviceId}."));
}
}
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));
}
public async Task <InvokeResult> UpdateGeoLocationAsync(DeviceRepository deviceRepo, string id, GeoLocation geoLocation, EntityHeader org, EntityHeader user)
{
if (geoLocation == null)
{
return(InvokeResult.FromError("Geolocation must not be null."));
}
// todo: would really like to add history of device llocations, likely only if it moved.
var device = await GetDeviceByIdAsync(deviceRepo, id, org, user);
if (device == null)
{
return(InvokeResult.FromErrors(Resources.ErrorCodes.CouldNotFindDeviceWithId.ToErrorMessage()));
}
await AuthorizeAsync(device, AuthorizeActions.Update, user, org);
device.GeoLocation = geoLocation;
device.LastUpdatedBy = user;
device.LastUpdatedDate = DateTime.UtcNow.ToJSONString();
device.LocationLastUpdatedDate = device.LastUpdatedDate;
var repo = GetRepo(deviceRepo);
await repo.UpdateDeviceAsync(deviceRepo, device);
return(InvokeResult.Success);
}
public async Task <InvokeResult> AttachChildDeviceAsync(DeviceRepository deviceRepo, string parentDeviceId, string childDeviceId, ListRequest listRequest, EntityHeader org, EntityHeader user)
{
if (parentDeviceId == childDeviceId)
{
return(InvokeResult.FromError("Parent is the same as the child device."));
}
var repo = GetRepo(deviceRepo);
var childDevice = await repo.GetDeviceByIdAsync(deviceRepo, childDeviceId);
await AuthorizeAsync(childDevice, AuthorizeActions.Update, user, org, "Attach this child to a parent");
var parentDevice = await repo.GetDeviceByIdAsync(deviceRepo, parentDeviceId);
await AuthorizeAsync(childDevice, AuthorizeActions.Update, user, org, "Attach a child to this parent");
childDevice.ParentDevice = new EntityHeader <string>()
{
Id = parentDeviceId,
Text = parentDevice.Name,
Value = parentDevice.DeviceId,
};
await repo.UpdateDeviceAsync(deviceRepo, childDevice);
return(InvokeResult.Success);
}
public async Task <InvokeResult <List <DataStreamResult> > > SqlQuery(string datastreamid, [FromBody] SQLRequest request)
{
if (request == null)
{
return(InvokeResult <List <DataStreamResult> > .FromError($"Empty SQL Request"));
}
if (String.IsNullOrEmpty(request.Query))
{
return(InvokeResult <List <DataStreamResult> > .FromError($"Empty Query SQL Request"));
}
var dataStream = await _dataStreamManager.LoadFullDataStreamConfigurationAsync(datastreamid, OrgEntityHeader, UserEntityHeader);
if (dataStream == null)
{
throw new RecordNotFoundException("DataStream", datastreamid);
}
var connectorResult = DataStreamServices.GetConnector(dataStream.Result.StreamType.Value, _adminlogger);
if (connectorResult == null)
{
return(InvokeResult <List <DataStreamResult> > .FromError($"Could not get data stream connector for: {dataStream.Result.StreamType.Value}"));
}
var connector = connectorResult.Result;
await connector.InitAsync(dataStream.Result);
return(await connector.ExecSQLAsync(request.Query, request.Parameters));
}
public async Task <InvokeResult> RemoveDeviceFromGroupAsync(DeviceRepository deviceRepo, string deviceGroupId, string deviceUniqueId, EntityHeader org, EntityHeader user)
{
var group = await GetDeviceGroupRepo(deviceRepo).GetDeviceGroupAsync(deviceRepo, deviceGroupId);
await AuthorizeAsync(group, AuthorizeResult.AuthorizeActions.Update, user, org, "Remove Device From Device Group");
var device = await GetDeviceManagementRepo(deviceRepo).GetDeviceByIdAsync(deviceRepo, deviceUniqueId);
await AuthorizeAsync(group, AuthorizeResult.AuthorizeActions.Update, user, org, "Remove Device From Device Group");
//TODO: Add localization
if (!group.Devices.Where(grp => grp.DeviceUniqueId == deviceUniqueId).Any())
{
return(InvokeResult.FromError($"The device [{device.DeviceId}] does not belong to this device group and can not be removed again."));
}
var deviceInGroup = device.DeviceGroups.Where(devc => devc.Id == deviceGroupId).FirstOrDefault();
if (deviceInGroup == null)
{
Logger.AddCustomEvent(LogLevel.Error, "DeviceGroupManager_RemoveDeviceFromGroup", "Device Group does not exist in list of groups for device.", org.Id.ToKVP("orgId"), deviceUniqueId.ToKVP("deviceId"), deviceGroupId.ToKVP("deviceGroupId"));
}
else
{
device.DeviceGroups.Remove(deviceInGroup);
await GetDeviceManagementRepo(deviceRepo).UpdateDeviceAsync(deviceRepo, device);
}
var deviceGroupEntry = group.Devices.Where(dev => dev.DeviceUniqueId == deviceUniqueId).First();
group.Devices.Remove(deviceGroupEntry);
await GetDeviceGroupRepo(deviceRepo).UpdateDeviceGroupAsync(deviceRepo, group);
return(InvokeResult.Success);
}
private async Task <InvokeResult> SendIoTHubMessage(MessageTransmissionPlan plan)
{
var messageTemplate = plan.Message.Value;
if (_azureIoTHubClient == null)
{
await _notificationPublisher.PublishTextAsync(Targets.WebSocket, Channels.Simulator, InstanceId, "Azure IoT Hub is null, could not send message");
return(InvokeResult.FromError("Azure IoT Hub is null, could not send message"));
}
if (!_isConnected)
{
await _notificationPublisher.PublishTextAsync(Targets.WebSocket, Channels.Simulator, InstanceId, "Azure IoT Hub is not connected, could not send message");
return(InvokeResult.FromError("Azure IoT Hub is not connected, could not send message"));
}
await _notificationPublisher.PublishTextAsync(Targets.WebSocket, Channels.Simulator, InstanceId, $"Sending message to Azure IoT Hub {_simulator.DefaultEndPoint}");
var textPayload = ReplaceTokens(_instance, plan, messageTemplate.TextPayload);
var msg = new Microsoft.Azure.Devices.Client.Message(GetMessageBytes(plan));
await _azureIoTHubClient.SendEventAsync(msg);
ReceivedContent = $"{DateTime.Now} {SimulatorRuntimeResources.SendMessage_MessagePublished}";
await _notificationPublisher.PublishTextAsync(Targets.WebSocket, Channels.Simulator, InstanceId, ReceivedContent);
return(InvokeResult.Success);
}
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 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> SendUserNotificationAsync([FromBody] UserMessage message)
{
await ValidateRequest(HttpContext.Request);
if (!String.IsNullOrEmpty(message.UserId))
{
return(await SendToUserAsync(message));
}
var group = await _distroManager.GetListAsync(message.DistributionGroupId, OrgEntityHeader, UserEntityHeader);
if (group == null)
{
return(InvokeResult.FromError($"Could not load distribution group for group id [{message.DistributionGroupId}]."));
}
foreach (var user in group.AppUsers)
{
message.UserId = user.Id;
var sendResult = await SendToUserAsync(message);
if (!sendResult.Successful)
{
return(sendResult);
}
}
return(InvokeResult.Success);
}
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 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> UpdateDeviceCustomStatusAsync(DeviceRepository deviceRepo, string id, string customstatus, EntityHeader org, EntityHeader user)
{
var device = await GetDeviceByIdAsync(deviceRepo, id, org, user);
if (device == null)
{
return(InvokeResult.FromErrors(Resources.ErrorCodes.CouldNotFindDeviceWithId.ToErrorMessage()));
}
await AuthorizeAsync(device, AuthorizeActions.Update, user, org);
var deviceStates = await _deviceConfigHelper.GetCustomDeviceStatesAsync(device.DeviceConfiguration.Id, org, user);
if (deviceStates == null)
{
return(InvokeResult.FromError("Could not load device states for device configuration."));
}
var newDeviceState = deviceStates.Value.States.Where(st => st.Key.ToLower() == customstatus.ToLower()).FirstOrDefault();
if (newDeviceState == null)
{
return(InvokeResult.FromError("Invalid status."));
}
device.CustomStatus = EntityHeader.Create(newDeviceState.Key, newDeviceState.Name);
device.LastUpdatedBy = user;
device.LastUpdatedDate = DateTime.UtcNow.ToJSONString();
var repo = GetRepo(deviceRepo);
await repo.UpdateDeviceAsync(deviceRepo, device);
return(InvokeResult.Success);
}
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> SetApprovedAsync(string userId, EntityHeader org, EntityHeader approvingUser)
{
await AuthorizeAsync(approvingUser, org, "SetApporvedStatus", userId);
var appUser = await GetUserByIdAsync(approvingUser.Id, org, approvingUser);
if (appUser == null)
{
return(InvokeResult.FromError($"Could not find approving user with id: {approvingUser.Id}."));
}
if (appUser.CurrentOrganization.Id != org.Id)
{
return(InvokeResult.FromError("Org Mismatch on current user."));
}
if (!appUser.IsOrgAdmin)
{
return(InvokeResult.FromError("Must be an org admin to automically approve a user."));
}
var user = await _appUserRepo.FindByIdAsync(userId);
user.EmailConfirmed = true;
user.PhoneNumberConfirmed = true;
user.IsAccountDisabled = false;
user.CurrentOrganization = org;
await _appUserRepo.UpdateAsync(user);
await LogEntityActionAsync(userId, typeof(AppUser).Name, "Auto Approved", org, approvingUser);
return(InvokeResult.Success);
}
private async Task <InvokeResult> SendMQTTMessage(MessageTransmissionPlan plan)
{
var messageTemplate = plan.Message.Value;
if (_mqttClient == null)
{
await _notificationPublisher.PublishTextAsync(Targets.WebSocket, Channels.Simulator, InstanceId, "MQTT Client is null, could not send message");
return(InvokeResult.FromError("MQTT Client is null, could not send message"));
}
if (!_mqttClient.IsConnected)
{
await _notificationPublisher.PublishTextAsync(Targets.WebSocket, Channels.Simulator, InstanceId, "MQTT Client is not connected, reconnecting.");
var connectResult = await _mqttClient.ConnectAsync();
if (connectResult.Result == ConnAck.Accepted)
{
await _notificationPublisher.PublishTextAsync(Targets.WebSocket, Channels.Simulator, InstanceId, "MQTT Client is not connected, reconnected.");
}
else
{
await _notificationPublisher.PublishTextAsync(Targets.WebSocket, Channels.Simulator, InstanceId, "MQTT Client is not connected, could not connect, did not send message");
return(InvokeResult.FromError("MQTT Client is not is not connected, could not send message"));
}
}
var qos = QOS.QOS0;
if (!EntityHeader.IsNullOrEmpty(messageTemplate.QualityOfServiceLevel))
{
switch (messageTemplate.QualityOfServiceLevel.Value)
{
case QualityOfServiceLevels.QOS1: qos = QOS.QOS1; break;
case QualityOfServiceLevels.QOS2: qos = QOS.QOS2; break;
}
}
if (messageTemplate.PayloadType.Id == MessageTemplate.PayloadTypes_GeoPath)
{
return(await SendMQTTGeoMessage(plan));
}
await _notificationPublisher.PublishTextAsync(Targets.WebSocket, Channels.Simulator, InstanceId, $"Sending message to MQTT Server {_simulator.DefaultEndPoint} with topic {messageTemplate.Topic}");
await _mqttClient.PublishAsync(ReplaceTokens(_instance, plan, messageTemplate.Topic), GetMessageBytes(plan), qos, messageTemplate.RetainFlag);
ReceivedContent = $"{DateTime.Now} {SimulatorRuntimeResources.SendMessage_MessagePublished}";
await _notificationPublisher.PublishTextAsync(Targets.WebSocket, Channels.Simulator, InstanceId, ReceivedContent);
return(InvokeResult.Success);
}
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> UpdateUserAsync(UserInfo user, EntityHeader org, EntityHeader updatedByUser)
{
var appUser = await _appUserRepo.FindByIdAsync(user.Id);
if (!String.IsNullOrEmpty(user.FirstName))
{
appUser.FirstName = user.FirstName;
}
if (!String.IsNullOrEmpty(user.LastName))
{
appUser.LastName = user.LastName;
}
if (!String.IsNullOrEmpty(user.PhoneNumber))
{
appUser.PhoneNumber = user.PhoneNumber;
appUser.PhoneNumberConfirmed = true;
}
if ((user.ProfileImageUrl != null))
{
appUser.ProfileImageUrl = user.ProfileImageUrl;
}
appUser.LastUpdatedBy = updatedByUser;
appUser.LastUpdatedDate = DateTime.UtcNow.ToJSONString();
if (appUser.IsSystemAdmin != user.IsSystemAdmin)
{
var updateByAppUser = await GetUserByIdAsync(updatedByUser.Id, org, updatedByUser);
if (updateByAppUser == null)
{
return(InvokeResult.FromError($"Could not find updating user with id: {updateByAppUser.Id}."));
}
if (!updateByAppUser.IsSystemAdmin)
{
_adminLogger.AddCustomEvent(Core.PlatformSupport.LogLevel.Error, "UserServicesController_UpdateUserAsync", UserAdminErrorCodes.AuthNotSysAdmin.Message);
return(InvokeResult.FromErrors(UserAdminErrorCodes.AuthNotSysAdmin.ToErrorMessage()));
}
appUser.IsSystemAdmin = user.IsSystemAdmin;
appUser.IsAppBuilder = user.IsAppBuilder;
appUser.IsOrgAdmin = user.IsOrgAdmin;
appUser.IsRuntimeuser = user.IsRuntimeUser;
appUser.IsUserDevice = user.IsUserDevice;
}
ValidationCheck(appUser, Actions.Update);
await AuthorizeAsync(appUser, AuthorizeResult.AuthorizeActions.Update, updatedByUser, org);
await _appUserRepo.UpdateAsync(appUser);
return(InvokeResult.Success);
}
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 <ServiceTicket> > SetTicketViewedStatusAsync(string id, bool viewed, EntityHeader org, EntityHeader user)
{
var ticket = await _repo.GetServiceTicketAsync(id);
var date = DateTime.UtcNow.ToJSONString();
await AuthorizeAsync(ticket, AuthorizeResult.AuthorizeActions.Update, user, org, "SetViewStatus");
if (viewed == ticket.IsViewed)
{
return(InvokeResult <ServiceTicket> .FromError(viewed?$"Aleady been marked as viewed." : "Already been marked as not viewed"));
}
ticket.IsViewed = viewed;
if (viewed)
{
if (!EntityHeader.IsNullOrEmpty(ticket.AssignedTo) && user.Id != ticket.AssignedTo.Id)
{
return(InvokeResult <ServiceTicket> .FromError($"Assigned to {ticket.AssignedTo.Text} but attempted to be viewed by {user.Text}. Only the assigned user can mark as viewed."));
}
ticket.ViewedDate = DateTime.UtcNow.ToJSONString();
ticket.ViewedBy = user;
var history = new ServiceTicketStatusHistory()
{
AddedBy = user,
DateStamp = date,
Status = ticket.Status.Text,
Note = $"Viewed by [{user.Text}]"
};
ticket.History.Insert(0, history);
}
else
{
ticket.ViewedDate = null;
ticket.ViewedBy = null;
var history = new ServiceTicketStatusHistory()
{
AddedBy = user,
DateStamp = date,
Status = ticket.Status.Text,
Note = $"Cleared viewed by [{user.Text}]"
};
ticket.History.Insert(0, history);
}
ticket.LastUpdatedBy = user;
ticket.LastUpdatedDate = date;
await _repo.UpdateServiceTicketAsync(ticket);
return(InvokeResult <ServiceTicket> .Create(ticket));
}
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> DeleteFileAsync(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(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
{
await blob.DeleteAsync();
return(InvokeResult.Success);
}
catch (Exception ex)
{
if (retryCount == numberRetries)
{
_logger.AddException("CloudFileStorage_GetFileAsync", ex, _containerName.ToKVP("containerName"));
return(InvokeResult.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.FromError("Could not delete Media Item"));
}
public async Task <InvokeResult> UpdateInstanceStatusAsync(String status, bool isdeployed, string version)
{
await ValidateRequest(HttpContext.Request);
if (Enum.TryParse <DeploymentInstanceStates>(status, out DeploymentInstanceStates newStatus))
{
return(await _instanceManager.UpdateInstanceStatusAsync(InstanceEntityHeader.Id, newStatus, isdeployed, version, OrgEntityHeader, UserEntityHeader));
}
else
{
return(InvokeResult.FromError($"Could not parse [status] to DeploymentInstanceStates"));
}
}
public async Task <InvokeResult> AddUserToOrgAsync(string orgId, string userId, EntityHeader userOrg, EntityHeader addedBy)
{
await AuthorizeOrgAccessAsync(addedBy, userOrg, typeof(OrgUser), Actions.Create, new SecurityHelper()
{
OrgId = orgId, UserId = userId
});
var appUser = await _appUserRepo.FindByIdAsync(userId);
if (appUser == null)
{
return(InvokeResult.FromError($"Could not find user with user id [{userId}] when attempting to add user to the org [{orgId}]"));
}
var org = await _organizationRepo.GetOrganizationAsync(orgId);
if (org == null)
{
return(InvokeResult.FromError($"Could not find org with org id [{orgId}] when attempting to add a user with id [{userId}] to this org."));
}
await AuthorizeOrgAccessAsync(addedBy, org.ToEntityHeader(), typeof(OrgUser));
if (await _orgUserRepo.QueryOrgHasUserAsync(orgId, userId))
{
var result = new InvokeResult();
result.Errors.Add(new ErrorMessage(UserAdminResources.OrganizationUser_UserExists.Replace(Tokens.USERS_FULL_NAME, appUser.Name).Replace(Tokens.ORG_NAME, org.Name)));
return(result);
}
var user = new OrgUser(org.Id, userId)
{
Email = appUser.Email,
OrganizationName = org.Name,
IsOrgAdmin = false,
IsAppBuilder = false,
UserName = appUser.Name,
ProfileImageUrl = appUser.ProfileImageUrl.ImageUrl,
};
user.CreatedBy = addedBy.Text;
user.CreatedById = addedBy.Text;
user.CreationDate = DateTime.UtcNow.ToJSONString();
user.LastUpdatedBy = addedBy.Text;
user.LastUpdatedById = addedBy.Id;
user.LastUpdatedDate = user.CreationDate;
await _orgUserRepo.AddOrgUserAsync(user);
return(InvokeResult.Success);
}
public async Task <InvokeResult <ServiceTicket> > SetTicketClosedStatusAsync(string id, bool isClosed, EntityHeader org, EntityHeader user)
{
var ticket = await _repo.GetServiceTicketAsync(id);
var date = DateTime.UtcNow.ToJSONString();
await AuthorizeAsync(ticket, AuthorizeResult.AuthorizeActions.Update, user, org, "SetClosedStatus");
if (isClosed == ticket.IsClosed)
{
return(InvokeResult <ServiceTicket> .FromError(isClosed?$"Aleady been marked as closed." : "Already been marked as not closed"));
}
ticket.IsClosed = isClosed;
if (isClosed)
{
ticket.ClosedDate = DateTime.UtcNow.ToJSONString();
ticket.ClosedBy = user;
var history = new ServiceTicketStatusHistory()
{
AddedBy = user,
DateStamp = date,
Status = ticket.Status.Text,
Note = $"Closed by [{user.Text}]"
};
ticket.History.Insert(0, history);
}
else
{
ticket.ClosedDate = null;
ticket.ClosedBy = null;
var history = new ServiceTicketStatusHistory()
{
AddedBy = user,
DateStamp = date,
Status = ticket.Status.Text,
Note = $"Re-opened by [{user.Text}]"
};
ticket.History.Insert(0, history);
}
ticket.LastUpdatedBy = user;
ticket.LastUpdatedDate = date;
await _repo.UpdateServiceTicketAsync(ticket);
return(InvokeResult <ServiceTicket> .Create(ticket));
}
