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