protected override void InitializeClassInternal(OperationSettings settings, IAuthenticationManager authManager)
{
if (!(settings is UserLoginOperationSettings))
{
throw new ArgumentException($"Type '{settings.GetType()}' is invalid for this operation.");
}
UserLoginOperationSettings internalSettings = (settings as UserLoginOperationSettings);
UserLoginOperation.Creds = new ConcurrentBag <Credentials>();
foreach (Credentials creds in internalSettings.Credentials)
{
if (!authManager.UserExists(creds.UserId))
{
this.logger?.Log(EventType.OperationClassInitalization, "User '{0}' isn't known.", creds.UserId);
continue;
}
this.logger?.Log(EventType.OperationClassInitalization, "Adding credentials for user '{0}'.", creds.UserId);
UserLoginOperation.Creds.Add(creds);
}
UserLoginOperation.HttpsOnly = internalSettings.HttpsOnly;
this.logger?.Log(EventType.OperationClassInitalization, "Use HttpsOnly for UserLogin: '******'.", UserLoginOperation.HttpsOnly);
}
public OperationsSpaceTemplate()
{
OperationSettings settings = new OperationSettings();
_ = Package.AddFile(Workspace.PSettings)
.UseTemplate(new TextFileTemplate(new StringTemplate(JsonFormatter.Serialize(settings))));
}
protected override void InitializeClassInternal(OperationSettings settings, IAuthenticationManager authManager)
{
if (!(settings is ClientLoginOperationSettings))
{
throw new ArgumentException($"Type '{settings.GetType()}' is invalid for this operation.");
}
ClientLoginOperationSettings internalSettings = (settings as ClientLoginOperationSettings);
ClientLoginOperation.ClientMappings = new ConcurrentDictionary <string, ClientLoginOperation.Client>();
foreach (ClientLoginOperation.Client client in internalSettings.Clients)
{
this.logger?.Log(EventType.OperationClassInitalization, "Adding user '{0}' to white list.", client.UserId);
if (!authManager.UserExists(client.UserId))
{
this.logger?.Log(EventType.OperationClassInitalization, "User '{0}' isn't known.", client.UserId);
continue;
}
foreach (string ip in client.Addresses)
{
if (!ClientLoginOperation.ClientMappings.TryAdd(ip, client))
{
this.logger?.Log(EventType.OperationClassInitalization, "Failed to whitelist '{0}' for user '{1}'.", ip, client.UserId);
continue;
}
}
}
ClientLoginOperation.HttpsOnly = internalSettings.HttpsOnly;
this.logger?.Log(EventType.OperationClassInitalization, "Use HttpsOnly for ClientLogin: '******'.", ClientLoginOperation.HttpsOnly);
}
public void ProcessCSharpClass()
{
// type: String size 1 => public string {key} { get; set;}
// Define {key} NVARCHAR({size/default};
// JsonDocument.AddJsonOptions(option =>
//option.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase);
var options = new JsonDocumentOptions
{
// P = JsonNamingPolicy.CamelCase,
};
var doc = JsonDocument.Parse(@"{ ""Text"": ""1"", ""DetailChanges"":[{""Property"":""Comments"",""ChangedTo"":""2nd Comment"",""UniqueId"":null,""SummaryInstance"":null},{""Property"":""CCC"",""ChangedTo"":""XR71"",""UniqueId"":null,""SummaryInstance"":null}], ""Value"": 1, ""IsValid"": true, ""Account"" : { ""AccountId"" : 1234 } }"
, options);
Assert.IsNotNull(doc);
var settings = new OperationSettings()
{
Name = "TestName"
};
var instance = doc.RootElement.WalkStructure <CSharpClass, CSharpProperty>
(new CSharpClass(settings, null), null);
Assert.IsNotNull(instance);
SettingsSingleton.Settings = new TempSettings()
{
Name = "ProcessCharpClass"
};
Console.WriteLine(instance.ToString());
}
protected override void InitializeClassInternal(OperationSettings settings, IAuthenticationManager authManager)
{
if (!(settings is IdOperationSettings))
{
throw new ArgumentException($"Type '{settings.GetType()}' is invalid for this operation.");
}
IdOperation.ServerId = (settings as IdOperationSettings).ServerId;
}
public void InitializeClass(OperationSettings settings, IAuthenticationManager authManager)
{
Operation.AuthConfigs[this.GetType()] = new AuthenticationConfiguration()
{
AuthenticationRequired = settings.AuthenticationRequired,
HttpsOnly = settings.HttpsOnly
};
try
{
this.InitializeClassInternal(settings, authManager);
}
catch (Exception ex)
{
/* Log exception in operation logs */
this.logger?.Log(EventType.OperationClassInitializationError, $"Operation initialization failed with exception '{ex}'.");
throw ex;
}
}
protected override void InitializeClassInternal(OperationSettings settings, IAuthenticationManager authManager)
{
if (!(settings is DynamicOperationSettings))
{
throw new ArgumentException($"Type '{settings.GetType()}' is invalid for this operation.");
}
DynamicOperationSettings customSettings = settings as DynamicOperationSettings;
DynamicOperation.Responses = new ConcurrentDictionary <string, DynamicResponse>();
if (customSettings.Responses != null)
{
foreach (var responseEntry in customSettings.Responses)
{
this.logger?.Log(EventType.OperationInformation, "Create DynamicResponse for id '{0}' using '{1}'.", responseEntry.Id, JsonConvert.SerializeObject(responseEntry.Response, Formatting.Indented));
DynamicOperation.Responses[responseEntry.Id] = responseEntry.Response;
}
}
}
/// <summary>
/// Used to initialize static properties at the beginning of the operation.
/// </summary>
/// <param name="logger">The logger instance.</param>
/// <param name="settings">The settings.</param>
protected virtual void InitializeClassInternal(OperationSettings settings, IAuthenticationManager authManager)
{
}
public OperationService(IOptions <OperationSettings> options, ApplicationDbContext context, ICashRegistrationService cashService)
{
_context = context;
_settings = options.Value;
_cashService = cashService;
}
public CashRegistrationService(ApplicationDbContext context, IOptions <OperationSettings> options)
{
_context = context;
_settings = options.Value;
}
