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));
}
private async Task <InvokeResult> RenewRefreshToken()
{
var authRequest = new AuthRequest();
authRequest.AppId = _appConfig.AppId;
authRequest.ClientType = "mobileapp";
authRequest.DeviceId = _deviceInfo.DeviceUniqueId;
authRequest.AppInstanceId = _authManager.AppInstanceId;
authRequest.GrantType = "refreshtoken";
authRequest.UserName = _authManager.User.Email;
authRequest.Email = _authManager.User.Email;
authRequest.RefreshToken = _authManager.RefreshToken;
var response = await _authClient.LoginAsync(authRequest);
if (response.Successful)
{
_authManager.AccessToken = response.Result.AccessToken;
_authManager.AccessTokenExpirationUTC = response.Result.AccessTokenExpiresUTC;
_authManager.RefreshToken = response.Result.RefreshToken;
_authManager.AppInstanceId = response.Result.AppInstanceId;
_authManager.RefreshTokenExpirationUTC = response.Result.RefreshTokenExpiresUTC;
_logger.AddCustomEvent(LogLevel.Message, "RawRestClient_RenewRefreshTokenAsync", "Access Token Renewed with Refresh Token");
await _authManager.PersistAsync();
return(InvokeResult.Success);
}
else
{
_logger.AddCustomEvent(LogLevel.Error, "RawRestClient_RenewRefreshTokenAsync", "Could Not Renew Access Token", response.ErrorsToKVPArray());
var result = new InvokeResult();
result.Concat(response);
throw new Exceptions.CouldNotRenewTokenException();
}
}
public async Task <InvokeResult <AuthResponse> > CreateUserAsync(RegisterUser newUser)
{
if (String.IsNullOrEmpty(newUser.Email))
{
_adminLogger.AddCustomEvent(Core.PlatformSupport.LogLevel.Error, "UserServicesController_CreateNewAsync", UserAdminErrorCodes.RegMissingEmail.Message);
return(InvokeResult <AuthResponse> .FromErrors(UserAdminErrorCodes.RegMissingEmail.ToErrorMessage()));
}
var user = await _appUserRepo.FindByEmailAsync(newUser.Email);
if (user != null)
{
_adminLogger.AddCustomEvent(Core.PlatformSupport.LogLevel.Error, "UserServicesController_CreateNewAsync", UserAdminErrorCodes.RegErrorUserExists.Message);
return(InvokeResult <AuthResponse> .FromErrors(UserAdminErrorCodes.RegErrorUserExists.ToErrorMessage()));
}
/* Need to check all these, if any fail, we want to aboart, we need to refactor this into the UserAdmin module :( */
if (String.IsNullOrEmpty(newUser.AppId))
{
_adminLogger.AddCustomEvent(Core.PlatformSupport.LogLevel.Error, "UserServicesController_CreateNewAsync", UserAdminErrorCodes.AuthMissingAppId.Message);
return(InvokeResult <AuthResponse> .FromErrors(UserAdminErrorCodes.AuthMissingAppId.ToErrorMessage()));
}
if (String.IsNullOrEmpty(newUser.ClientType))
{
_adminLogger.AddCustomEvent(Core.PlatformSupport.LogLevel.Error, "UserServicesController_CreateNewAsync", UserAdminErrorCodes.AuthMissingClientType.Message);
return(InvokeResult <AuthResponse> .FromErrors(UserAdminErrorCodes.AuthMissingClientType.ToErrorMessage()));
}
if (String.IsNullOrEmpty(newUser.DeviceId))
{
_adminLogger.AddCustomEvent(Core.PlatformSupport.LogLevel.Error, "UserServicesController_CreateNewAsync", UserAdminErrorCodes.AuthMissingDeviceId.Message);
return(InvokeResult <AuthResponse> .FromErrors(UserAdminErrorCodes.AuthMissingDeviceId.ToErrorMessage()));
}
if (String.IsNullOrEmpty(newUser.FirstName))
{
_adminLogger.AddCustomEvent(Core.PlatformSupport.LogLevel.Error, "UserServicesController_CreateNewAsync", UserAdminErrorCodes.RegMissingFirstLastName.Message);
return(InvokeResult <AuthResponse> .FromErrors(UserAdminErrorCodes.RegMissingFirstLastName.ToErrorMessage()));
}
if (String.IsNullOrEmpty(newUser.LastName))
{
_adminLogger.AddCustomEvent(Core.PlatformSupport.LogLevel.Error, "UserServicesController_CreateNewAsync", UserAdminErrorCodes.RegMissingLastName.Message);
return(InvokeResult <AuthResponse> .FromErrors(UserAdminErrorCodes.RegMissingLastName.ToErrorMessage()));
}
if (String.IsNullOrEmpty(newUser.Password))
{
_adminLogger.AddCustomEvent(Core.PlatformSupport.LogLevel.Error, "UserServicesController_CreateNewAsync", UserAdminErrorCodes.RegMissingPassword.Message);
return(InvokeResult <AuthResponse> .FromErrors(UserAdminErrorCodes.RegMissingPassword.ToErrorMessage()));
}
var emailRegEx = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
if (!emailRegEx.Match(newUser.Email).Success)
{
_adminLogger.AddCustomEvent(Core.PlatformSupport.LogLevel.Error, "UserServicesController_CreateNewAsync", UserAdminErrorCodes.RegInvalidEmailAddress.Message);
return(InvokeResult <AuthResponse> .FromErrors(UserAdminErrorCodes.RegInvalidEmailAddress.ToErrorMessage()));
}
var appUser = new AppUser(newUser.Email, $"{newUser.FirstName} {newUser.LastName}")
{
FirstName = newUser.FirstName,
LastName = newUser.LastName,
};
/* In the testing environment we just go ahead and not make the user confirm by email or phone number so we can start using
* right away, eventually we will probably build this into testing but need some way of getting the confirmation tokens */
if (_appConfig.Environment == Environments.Testing)
{
appUser.PhoneNumberConfirmed = true;
appUser.EmailConfirmed = true;
}
var identityResult = await _userManager.CreateAsync(appUser, newUser.Password);
if (identityResult.Successful)
{
await LogEntityActionAsync(appUser.Id, typeof(AppUser).Name, "New User Registered", null, appUser.ToEntityHeader());
await _signInManager.SignInAsync(appUser);
if (newUser.ClientType != "WEBAPP")
{
var authRequest = new AuthRequest()
{
AppId = newUser.AppId,
DeviceId = newUser.DeviceId,
AppInstanceId = newUser.AppInstanceId,
ClientType = newUser.ClientType,
GrantType = "password",
Email = newUser.Email,
UserName = newUser.Email,
Password = newUser.Password,
};
var tokenResponse = await _authTokenManager.AccessTokenGrantAsync(authRequest);
if (tokenResponse.Successful)
{
await _userVerificationmanager.SendConfirmationEmailAsync(null, appUser.ToEntityHeader());
return(InvokeResult <AuthResponse> .Create(tokenResponse.Result));
}
else
{
var failedValidationResult = new InvokeResult <AuthResponse>();
failedValidationResult.Concat(tokenResponse);
return(failedValidationResult);
}
}
else
{
await _userVerificationmanager.SendConfirmationEmailAsync(null, appUser.ToEntityHeader());
/* If we are logging in as web app, none of this applies */
return(InvokeResult <AuthResponse> .Create(new AuthResponse()
{
AccessToken = "N/A",
AccessTokenExpiresUTC = "N/A",
RefreshToken = "N/A",
AppInstanceId = "N/A",
RefreshTokenExpiresUTC = "N/A",
IsLockedOut = false,
User = appUser.ToEntityHeader(),
Roles = new List <EntityHeader>()
}));
}
}
else
{
return(InvokeResult <AuthResponse> .FromInvokeResult(identityResult));
}
}
public async Task <InvokeResult> PopulateDeviceConfigToDeviceAsync(Device device, EntityHeader instanceEH, EntityHeader org, EntityHeader user)
{
Console.WriteLine("Hhhhh...eeerrre");
var result = new InvokeResult();
if (EntityHeader.IsNullOrEmpty(instanceEH))
{
result.AddSystemError($"Device does not have a valid device configuration Device Id={device.Id}");
return(result);
}
Console.WriteLine("H1");
var deviceConfig = await GetDeviceConfigurationAsync(device.DeviceConfiguration.Id, org, user);
if (deviceConfig == null)
{
result.AddSystemError($"Could Not Load Device Configuration with Device Configuration {device.DeviceConfiguration.Text}, Id={device.DeviceConfiguration.Id}.");
return(result);
}
var instance = await _deploymentInstanceManager.GetInstanceAsync(instanceEH.Id, org, user);
Console.WriteLine("H2");
if (instance != null && instance.Status.Value == DeploymentInstanceStates.Running)
{
if (instance.InputCommandSSL)
{
device.DeviceURI = $"https://{instance.DnsHostName}:{instance.InputCommandPort}/devices/{device.Id}";
}
else
{
device.DeviceURI = $"http://{instance.DnsHostName}:{instance.InputCommandPort}/devices/{device.Id}";
}
var endpoints = new List <InputCommandEndPoint>();
foreach (var route in deviceConfig.Routes)
{
Console.WriteLine("H3");
foreach (var module in route.PipelineModules)
{
Console.WriteLine("H4");
if (module.ModuleType.Value == Pipeline.Admin.Models.PipelineModuleType.Workflow)
{
Console.WriteLine("H4.1");
var wfLoadResult = await _deviceAdminManager.LoadFullDeviceWorkflowAsync(module.Module.Id, org, user);
Console.WriteLine("H4.2");
if (wfLoadResult.Successful)
{
Console.WriteLine("H4.3");
if (wfLoadResult.Result.Attributes != null)
{
foreach (var attribute in wfLoadResult.Result.Attributes)
{
if (device.AttributeMetaData == null)
{
device.AttributeMetaData = new List <DeviceAdmin.Models.Attribute>();
}
if (!device.AttributeMetaData.Where(attr => attr.Key == attribute.Key).Any())
{
device.AttributeMetaData.Add(attribute);
}
}
}
Console.WriteLine("H4.4");
if (wfLoadResult.Result.StateMachines != null)
{
if (device.StateMachineMetaData == null)
{
device.StateMachineMetaData = new List <StateMachine>();
}
foreach (var stateMachine in wfLoadResult.Result.StateMachines)
{
if (!device.StateMachineMetaData.Where(attr => attr.Key == stateMachine.Key).Any())
{
device.StateMachineMetaData.Add(stateMachine);
}
}
}
Console.WriteLine("H4.5");
if (wfLoadResult.Result.InputCommands != null)
{
foreach (var inputCommand in wfLoadResult.Result.InputCommands)
{
var protocol = instance.InputCommandSSL ? "https://" : "http://";
var endPoint = new InputCommandEndPoint
{
EndPoint = $"{protocol}{instance.DnsHostName}:{instance.InputCommandPort}/{deviceConfig.Key}/{route.Key}/{wfLoadResult.Result.Key}/{inputCommand.Key}/{device.DeviceId}",
InputCommand = inputCommand
};
if (!endpoints.Where(end => end.EndPoint == endPoint.EndPoint).Any())
{
endpoints.Add(endPoint);
}
}
}
Console.WriteLine("H43");
}
else
{
result.Concat(result);
}
}
}
}
device.InputCommandEndPoints = endpoints;
}
else
{
Console.WriteLine("H21");
device.InputCommandEndPoints = new List <InputCommandEndPoint>();
device.AttributeMetaData = new List <DeviceAdmin.Models.Attribute>();
device.StateMachineMetaData = new List <StateMachine>();
}
Console.WriteLine("H5");
if (deviceConfig.Properties != null)
{
device.PropertiesMetaData = new List <DeviceAdmin.Models.CustomField>();
foreach (var prop in deviceConfig.Properties.OrderBy(prop => prop.Order))
{
device.PropertiesMetaData.Add(prop);
if (prop.FieldType.Value == DeviceAdmin.Models.ParameterTypes.State)
{
prop.StateSet.Value = await _deviceAdminManager.GetStateSetAsync(prop.StateSet.Id, org, user);
}
else if (prop.FieldType.Value == DeviceAdmin.Models.ParameterTypes.ValueWithUnit)
{
prop.UnitSet.Value = await _deviceAdminManager.GetAttributeUnitSetAsync(prop.UnitSet.Id, org, user);
}
}
}
Console.WriteLine("H6");
return(result);
}
public async Task <InvokeResult> PopulateRoutes(Route route, EntityHeader org, EntityHeader user)
{
var fullLoadResult = new InvokeResult();
var msgLoadResult = await _deviceMessageDefinitionManager.LoadFullDeviceMessageDefinitionAsync(route.MessageDefinition.Id, org, user);
if (msgLoadResult.Successful)
{
route.MessageDefinition.Value = msgLoadResult.Result;
}
else
{
fullLoadResult.Concat(fullLoadResult);
}
foreach (var module in route.PipelineModules)
{
switch (module.ModuleType.Value)
{
case Pipeline.Admin.Models.PipelineModuleType.InputTranslator:
{
var result = await _pipelineModuleManager.LoadFullInputTranslatorConfigurationAsync(module.Module.Id);
if (result.Successful)
{
module.Module.Value = result.Result;
}
else
{
fullLoadResult.Concat(result);
}
}
break;
case Pipeline.Admin.Models.PipelineModuleType.DataStream:
{
var result = await _dataStreamManager.LoadFullDataStreamConfigurationAsync(module.Module.Id);
if (result.Successful)
{
module.Module.Value = result.Result;
}
else
{
fullLoadResult.Concat(result);
}
}
break;
case Pipeline.Admin.Models.PipelineModuleType.Sentinel:
{
var result = await _pipelineModuleManager.LoadFullSentinelConfigurationAsync(module.Module.Id);
if (result.Successful)
{
module.Module.Value = result.Result;
}
else
{
fullLoadResult.Concat(result);
}
}
break;
case Pipeline.Admin.Models.PipelineModuleType.Workflow:
{
var result = await _deviceAdminManager.LoadFullDeviceWorkflowAsync(module.Module.Id, org, user);
if (result.Successful)
{
module.Module.Value = result.Result;
var destModuleConfig = route.PipelineModules.Where(mod => mod.Id == module.PrimaryOutput.Id).FirstOrDefault();
if (destModuleConfig.ModuleType.Value == Pipeline.Admin.Models.PipelineModuleType.OutputTranslator)
{
if (module.PrimaryOutput != null && module.PrimaryOutput.Mappings != null)
{
for (var idx = 0; idx < module.PrimaryOutput.Mappings.Count; ++idx)
{
var mapping = module.PrimaryOutput.Mappings[idx];
if (mapping.Value != null)
{
var mappingValue = JsonConvert.DeserializeObject <OutputCommandMapping>(mapping.Value.ToString());
if (mappingValue != null && !EntityHeader.IsNullOrEmpty(mappingValue.OutgoingDeviceMessage))
{
var outgoingMsgLoadResult = await _deviceMessageDefinitionManager.LoadFullDeviceMessageDefinitionAsync(mappingValue.OutgoingDeviceMessage.Id, org, user);
mappingValue.OutgoingDeviceMessage.Value = outgoingMsgLoadResult.Result;
module.PrimaryOutput.Mappings[idx] = new KeyValuePair <string, object>(mapping.Key, mappingValue);
}
}
}
}
}
}
else
{
fullLoadResult.Concat(result);
}
}
break;
case Pipeline.Admin.Models.PipelineModuleType.OutputTranslator:
{
var result = await _pipelineModuleManager.LoadFullOutputTranslatorConfigurationAsync(module.Module.Id);
if (result.Successful)
{
module.Module.Value = result.Result;
}
else
{
fullLoadResult.Concat(result);
}
}
break;
case Pipeline.Admin.Models.PipelineModuleType.Transmitter:
{
var result = await _pipelineModuleManager.LoadFullTransmitterConfigurationAsync(module.Module.Id);
if (result.Successful)
{
module.Module.Value = result.Result;
}
else
{
fullLoadResult.Concat(result);
}
}
break;
case Pipeline.Admin.Models.PipelineModuleType.Custom:
{
var result = await _pipelineModuleManager.LoadFullCustomPipelineModuleConfigurationAsync(module.Module.Id);
if (result.Successful)
{
module.Module.Value = result.Result;
}
else
{
fullLoadResult.Concat(result);
}
}
break;
}
}
return(fullLoadResult);
}
public async Task <InvokeResult> ValidateConnectionAsync(DataStream stream)
{
var result = new InvokeResult();
var builder = new System.Data.SqlClient.SqlConnectionStringBuilder();
builder.Add("Data Source", stream.DbURL);
builder.Add("Initial Catalog", stream.DbName);
builder.Add("User Id", stream.DbUserName);
builder.Add("Password", stream.DbPassword);
_connectionString = builder.ConnectionString;
/* be careful when updating the SQL below, the rdr uses field indexes,
* if this wasn't so small and self contained, I probably wouldn't be so lazy,
* buf for one field...well...moving on.*/
var sql = $@"
select
b.name as ColumnName,
type_name(b.xusertype) ColumnType,
b.IsNullable,
columnproperty(a.id, b.name, 'isIdentity') IsIdentity,
sm.text AS DefaultValue
from sysobjects a
inner join syscolumns b on a.id = b.id
LEFT JOIN sys.syscomments sm ON sm.id = b.cdefault
WHERE a.xtype = 'U' and a.name = @tableName";
var fields = new List <SQLFieldMetaData>();
using (var cn = new System.Data.SqlClient.SqlConnection(_connectionString))
using (var cmd = new System.Data.SqlClient.SqlCommand(sql, cn))
{
cmd.Parameters.AddWithValue("@tableName", stream.DbTableName);
try
{
await cn.OpenAsync();
using (var rdr = await cmd.ExecuteReaderAsync())
{
while (await rdr.ReadAsync())
{
fields.Add(new SQLFieldMetaData()
{
ColumnName = rdr["ColumnName"].ToString(),
IsRequired = !Convert.ToBoolean(rdr["IsNullable"]),
DataType = rdr["ColumnType"].ToString(),
IsIdentity = Convert.ToBoolean(rdr["IsIdentity"]),
DefaultValue = Convert.ToString(rdr["DefaultValue"])
});
}
}
}
catch (Exception ex)
{
result.AddUserError($"Could not access SQL Server: {ex.Message}");
return(result);
}
}
if (fields.Count == 0)
{
result.AddUserError($"Table [{stream.DbTableName}] name not found on SQL Server database [{stream.DbName}] on server [{stream.DbURL}.");
}
else
{
result.Concat(stream.ValidateSQLSeverMetaData(fields));
}
return(result);
}
