private static bool IsFromOptions(Type type, SettingsOptions options)
{
try
{
var info = type.GetTypeInfo();
if (info.GetCustomAttribute(options.AttributeType, true) != null)
{
return(true);
}
if (options.InterfaceBase.GetTypeInfo().IsAssignableFrom(info))
{
return(true);
}
if (info.Name.ToLower().EndsWith(options.SettingsSuffix.Trim().ToLower()))
{
return(true);
}
return(false);
}
catch (Exception e)
{
throw new SettingsExtractionException(type, e);
}
}
/// <summary>
/// Generate AWS Settings file(s)
/// </summary>
/// <param name="settingsOptions"></param>
/// <returns></returns>
public static int RunSettings(SettingsOptions settingsOptions)
{
var logger = new Logger();
try
{
if (string.IsNullOrEmpty(settingsOptions.StackName))
{
throw new Exception($"Error: no StackName provided");
}
var json = (settingsOptions.MethodMap)
? AwsConfig.GenerateMethodMapJsonAsync(
settingsOptions.ProfileName,
settingsOptions.StackName).GetAwaiter().GetResult()
: AwsConfig.GenerateSettingsJsonAsync(
settingsOptions.ProfileName,
settingsOptions.StackName).GetAwaiter().GetResult();
if (string.IsNullOrEmpty(settingsOptions.OutputFilePath))
{
Console.Write(json);
}
else
{
File.WriteAllText(settingsOptions.OutputFilePath, json);
}
}
catch (Exception e)
{
logger.Error(e, e.Message);
return(-1);
}
return(1);
}
public object ConvertValue(object value, PropertyInfo propertyInfo, SettingsOptions options)
{
var propertyType = propertyInfo.PropertyType;
if (value == null)
{
ValidateNullAcceptance(propertyInfo);
if (!propertyType.IsEnumerable())
{
return(propertyType.GetTypeInfo().IsValueType ? Activator.CreateInstance(propertyType) : null);
}
var genericType = propertyType.GetTypeInfo().GetGenericArguments().First();
var method = typeof(Enumerable).GetTypeInfo().GetMethod("Empty").MakeGenericMethod(genericType);
var emptyEnumerable = method.Invoke(null, null);
return(emptyEnumerable);
}
var strippedType = StripIfNullable(propertyType);
var settingsTypeConverter = GetConverter(strippedType, propertyInfo, options);
return(settingsTypeConverter.Convert(value, strippedType));
}
public void ValidateOptions(SettingsOptions settingsOptions)
{
if (settingsOptions.AttributeType == null &&
settingsOptions.InterfaceBase == null &&
string.IsNullOrWhiteSpace(settingsOptions.SettingsSuffix))
{
throw new SettingsOptionsArgumentNullException();
}
if (!typeof(Attribute).GetTypeInfo().IsAssignableFrom(settingsOptions.AttributeType))
{
throw new SettingsOptionNonAttributeException(settingsOptions.AttributeType);
}
if (string.IsNullOrWhiteSpace(settingsOptions.ArraySplitDelimiter))
{
throw new SettingsOptionsArgumentMissingException(nameof(settingsOptions.ArraySplitDelimiter));
}
if (string.IsNullOrWhiteSpace(settingsOptions.DateTimeFormat))
{
throw new SettingsOptionsArgumentMissingException(nameof(settingsOptions.DateTimeFormat));
}
if (settingsOptions.SectionNameFormatter == null)
{
throw new SettingsOptionsArgumentMissingException("SectionNameFormatter");
}
}
public static string GetSectionName(this Type settingsClass, SettingsOptions options)
{
var attribute = settingsClass.GetTypeInfo().GetCustomAttribute <SettingsSectionAttribute>(true);
return(!string.IsNullOrWhiteSpace(attribute?.Name)
? attribute.Name
: options.SectionNameFormatter(settingsClass));
}
public static void SavingOptionData(string savePath)
{
File saveData = new File();
saveData.Open(savePath, File.ModeFlags.Write);
saveData.StoreLine(JSON.Print(SettingsOptions.GetData()));
saveData.Close();
}
public TypeConvertersCollections(SettingsOptions settingsOptions)
{
AddLast(new DateTimeTypeConverter(settingsOptions));
AddLast(new UriTypeConvertor());
AddLast(new ArrayTypeConverter(settingsOptions, this));
AddLast(new EnumerableTypeConverter(settingsOptions, this));
AddLast(new DefaultTypeConverter());
}
public void UpdatingKeyConfig()
{
InputEventKey updatedKey = SettingsOptions.GetInputFromKey(input);
InputHandler.SetActionFromInput(InputHandler.GetNameFromKey(input), updatedKey);
button.Text = OS.GetScancodeString(updatedKey.Scancode);
previousText = button.Text;
}
public MyAccountController(IDbContextFetcher dbContextFetcher, UserManager <MoxUser> userManager, RoleManager <IdentityRole> roleManager, IUserRolesFetcher rolesFetcher, SignInManager <MoxUser> signInManager, IOptions <SettingsOptions> settingsExtension)
{
this._context = dbContextFetcher.FetchDbContext <Data.MoxIdentityDbContext>();
this._userManager = userManager;
this._roleManager = roleManager;
this._rolesFetcher = rolesFetcher as Services.UserRolesFetcher;
this._signinManager = signInManager;
this._settingsExtension = settingsExtension.Value;
}
public RevendedorService(AppDbContext context, HistoricoService historicoService, HelperService helperService,
IOptions <SettingsOptions> settingsOptions, ILogger <RevendedorService> logger)
{
this.context = context;
this.historicoService = historicoService;
this.helperService = helperService;
this.settingsOptions = settingsOptions.Value;
this.logger = logger;
}
public TasksInicializer(IOptions <SettingsOptions> settingsOptions, ILoggerFactory loggerFactory, IServiceProvider serviceProvider)
{
_settingsOptions = settingsOptions?.Value;
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger <TasksInicializer>();
_serviceProvider = serviceProvider;
InstanceId = System.Environment.GetEnvironmentVariable("COMPUTERNAME");
}
public override void _Ready()
{
button = GetChild <Button>(0);
button.Text = ((InputEvent)InputMap.GetActionList(InputHandler.GetNameFromKey(input))[0]).AsText();
GetChild <RichTextLabel>(1).Text = text;
button.Connect("pressed", this, nameof(ButtonPressed));
SettingsOptions.RegisterUpdatedEvent(UpdatingKeyConfig);
previousText = button.Text;
}
public override void _Ready()
{
Button holder = GetChild <Button>(0);
holder.Pressed = SettingsOptions.GetSetting <bool>(optionName);
holder.Connect("toggled", this, nameof(ChangeSetting));
button = holder;
SettingsOptions.RegisterUpdatedEvent(UpdateValue);
button.Text = text;
}
public override void _Ready()
{
instance = this;
datas[0] = SavingAndLoading.LoadingGameSaveData(savePath + "0" + savePathEnd);
datas[1] = SavingAndLoading.LoadingGameSaveData(savePath + "1" + savePathEnd);
datas[2] = SavingAndLoading.LoadingGameSaveData(savePath + "2" + savePathEnd);
SavingAndLoading.LoadingOptionsSaveData("user://Option.save");
AllDataLoaded = true;
SettingsOptions.RegisterUpdatedEvent(UpdateGameSettings);
}
public void ValidateOptions_WhenHasNoSectionNameFormater_ShouldThrowException()
{
var options = new SettingsOptions
{
SectionNameFormatter = null
};
var sut = GetSut();
Assert.Throws <SettingsOptionsArgumentMissingException>(() => sut.ValidateOptions(options));
}
public async Task <IActionResult> Get()
{
using (var repository = new Repository(HttpContext.GetUserGuid()))
{
var settingsOptions = new SettingsOptions();
settingsOptions.IsPlayerAdmin = AuthorizeService.HashRight(repository.ServiceUser?.Role, Rights.EditPlayer);
settingsOptions.Roles = repository.Context.Roles.AsNoTracking().ToList().Select(x => x.FromDal()).ToList();
return(Ok(settingsOptions));
}
}
public void ValidateOptions_WhenHasNoArrayDelimiter_ShouldThrowException(string delimiter)
{
var options = new SettingsOptions()
{
ArraySplitDelimiter = delimiter
};
var sut = GetSut();
Assert.Throws <SettingsOptionsArgumentMissingException>(() => sut.ValidateOptions(options));
}
public void ValidateOptions_WhenHasNoDateTimeFormat_ShouldThrowException(string format)
{
var options = new SettingsOptions()
{
DateTimeFormat = format
};
var sut = GetSut();
Assert.Throws <SettingsOptionsArgumentMissingException>(() => sut.ValidateOptions(options));
}
public void ValidateOptions_WhenAttributeTypeIAnAttribute_ShouldPassValidation()
{
var options = new SettingsOptions()
{
AttributeType = typeof(SomeAttribute)
};
var sut = GetSut();
sut.ValidateOptions(options);
}
public void ValidateOptions_WhenAttributeTypeIsNotAnAttribute_ShouldThrowException()
{
var options = new SettingsOptions()
{
AttributeType = typeof(NotAttribute)
};
var sut = GetSut();
Assert.Throws <SettingsOptionNonAttributeException>(() => sut.ValidateOptions(options));
}
private bool SprintOutput()
{
if (SettingsOptions.GetSetting <bool>(SettingsNames.toggleSprint))
{
if (Input.IsActionJustPressed("Sprint"))
{
sprintToggleOn = !sprintToggleOn;
}
return(sprintToggleOn);
}
return(Input.IsActionPressed("Sprint"));
}
public UserManagementController(IDbContextFetcher dbContextFetcher, IUserValidator <MoxUser> userValidator, UserManager <MoxUser> userManager, RoleManager <IdentityRole> roleManager, IUserRolesFetcher rolesFetcher, SignInManager <MoxUser> signInManager, IStringLocalizer localizer, IOptions <SettingsOptions> settingsExtension, IOptions <MoxIdentityOptions> identityOptions)
{
this._context = dbContextFetcher.FetchDbContext <Data.MoxIdentityDbContext>();
this._userValidator = userValidator;
this._userManager = userManager;
this._roleManager = roleManager;
this._rolesFetcher = rolesFetcher as Services.UserRolesFetcher;
this._signinManager = signInManager;
this._localizer = localizer;
this._settingsExtension = settingsExtension.Value;
this._identityOptions = identityOptions.Value;
}
public static void LoadingOptionsSaveData(string savePath)
{
File saveData = new File();
if (saveData.FileExists(savePath))
{
saveData.Open(savePath, File.ModeFlags.Read);
Dictionary settingsOption = (Dictionary)JSON.Parse(saveData.GetLine()).Result;
SettingsOptions.SetData(settingsOption);
}
saveData.Close();
}
public Settings GetSettings(SettingsOptions options)
{
var tenderOptions = new List <TenderOption>();
if (options.TenderTypes?.Count > 0)
{
tenderOptions.AddRange(options.TenderTypes);
}
// Create receipt options and add a default value
var receiptOptions = new List <ReceiptOption>();
receiptOptions.Add(new ReceiptOption()
{
Id = "0",
ReceiptType = ReceiptType.Order,
DisplayName = "Customer"
});
if (options.IsMultiplePrintOptions)
{
receiptOptions.Add(new ReceiptOption()
{
Id = "1",
ReceiptType = ReceiptType.Order,
DisplayName = "Extended"
});
}
//Create Header printer options
var printerOption = new PrinterOption()
{
PrintMode = PrinterMode.POS,
Location = options.CustomReceiptLocation,
StaticReceipt = new List <string>()
{
"------------------------",
"Some generic text",
"that will print before",
"every eftpos receipt",
"if PrintMode = STATIC",
"and location = header",
}
};
return(new Settings()
{
TenderOptions = tenderOptions,
ReceiptOptions = receiptOptions,
PrinterOption = printerOption
});
}
protected override bool OnSwap()
{
if (SettingsOptions.ChangesMade())
{
if (confirm == null)
{
confirm = GetNode <Control>(confirmPath);
}
GameManager.Instance.currentMenu.AddonToCurrent(confirm);
return(false);
}
return(true);
}
public ApiKeyAuthenticationHandler(
IOptionsMonitor <ApiKeyAuthenticationOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock, IOptionsMonitor <SettingsOptions> settingsOptions) : base(options, logger, encoder, clock)
{
_logger = logger.CreateLogger(nameof(ApiKeyAuthenticationHandler));
_settingsOptions = settingsOptions.CurrentValue;
settingsOptions.OnChange(config =>
{
_settingsOptions = config;
_logger.LogInformation("The SettingsOptions has been updated.");
});
}
public void ToggleMenu(bool state)
{
if (state)
{
SwapToHud();
SettingsOptions.ResetNewSettings();
mainNode = menu;
}
else
{
hud.Visible = false;
mainNode.Visible = true;
}
}
public override void _Input(InputEvent @event)
{
if (readingInput)
{
if (@event is InputEventKey key)
{
readingInput = false;
string newName = OS.GetScancodeString(key.Scancode);
button.Text = newName;
previousText = button.Text;
SettingsOptions.UpdateKeyData(input, key);
}
}
}
public override void _Ready()
{
number = GetChild <SpinBox>(0);
slider = GetChild <Slider>(1);
number.Connect("value_changed", this, nameof(ValuesChanged));
slider.Connect("value_changed", this, nameof(ValuesChanged));
number.MaxValue = max;
slider.MaxValue = max;
slider.MinValue = min;
number.MinValue = min;
GetChild <RichTextLabel>(2).BbcodeText = "[center]" + name + "[/center]";
number.Value = SettingsOptions.GetSetting <float>(optionName) * multiplier;
slider.Value = number.Value;
SettingsOptions.RegisterUpdatedEvent(UpdateValue);
}
public void ValidateOptions_WhenAttributeAndInterfaceAndSuffixAreMissing_ShouldThrowException(Type attributeType,
Type interfaceType,
string suffix)
{
var options = new SettingsOptions()
{
AttributeType = attributeType,
InterfaceBase = interfaceType,
SettingsSuffix = suffix
};
var sut = GetSut();
Assert.Throws <SettingsOptionsArgumentNullException>(() => sut.ValidateOptions(options));
}
