/// <summary>
/// Private method that parses the configuration XML and creates the ConfigCollections that reprent that
/// configuration. This is used to store the entire set of collections in memory once and have clones
/// sent out whenever they are requested.
/// </summary>
private void InitializeConfigurations()
{
XmlNodeList nodeList;
IConfigurationCollection list = null;
IConfiguration config = null;
m_configurations.Clear();
const string xpathVal = "//rule";
nodeList = m_masterDoc.SelectNodes(xpathVal);
try
{
foreach (XmlNode ruleNode in nodeList)
{
config = new ConfigurationData(ruleNode);
list = new ConfigurationCollection();
m_configurations.Add("ItemPrice", list);
list.AddConfiguration(config);
}
}
catch (Exception ex)
{
throw new Exception(String.Format("Error occured while initializing the configuration in ConfigurationSet.InitializeConfigurations method : {0}", ex.Message));
}
}
/// <inheritdoc/>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
IConfigurationCollection collection = (IConfigurationCollection)value;
JObject collectionRoot = new JObject();
foreach (var section in collection.Select(s => s.Value))
{
JObject sectionOptionsRoot = new JObject();
foreach (var option in section)
{
JObject optionRoot = new JObject()
{
{ "Value", JObject.FromObject(option.Value) },
{ "Descriptor", ConfigurationCollectionSerializer.SerializeOption(option.Key) },
};
if (option.Key.Type.GetTypeInfo().IsEnum)
{
optionRoot.Add("Selection",
new JObject(ConfigurationCollectionSerializer.SerializeEnumValues(option.Key.Type)));
}
sectionOptionsRoot.Add(option.Key.OptionKey, optionRoot);
}
JObject sectionRoot = new JObject
{
{ "Configuration", sectionOptionsRoot },
{ "Descriptor", ConfigurationCollectionSerializer.SerializeSectionDescriptor(section.Descriptor) },
};
collectionRoot.Add(section.Descriptor.SectionName, sectionRoot);
}
collectionRoot.WriteTo(writer, new StringEnumConverter());
}
/// <summary>
/// It reads an xml config file and deserializes into collection of ItemPriceCollection
/// </summary>
/// <returns>Collection of item price</returns>
private static ItemPriceCollection GetItemsPriceCollectionFromConfig()
{
const string configCategory = "ItemPrice";
const string configRuleData = "ItemPriceData";
ItemPriceCollection itemsPriceColl = null;
try
{
IConfigurationSet configurationSet = ConfigurationFactory.GetConfigurationSet(typeof(ItemsPriceCollectionManager));
IConfigurationCollection configurations = configurationSet.GetConfigurations(configCategory);
IConfiguration itemConfig = configurations.GetConfiguration(configRuleData);
if (itemConfig != null)
{
itemsPriceColl = SerializerHelper.Deserialize(
itemConfig.ConfigurationBasis.InnerXml,
typeof(ItemPriceCollection)
) as ItemPriceCollection;
}
}
catch (Exception ex)
{
throw new Exception(String.Format
("Error occured while retrieving ItemPrice configuration and ItemPricecollection in ItemsPriceCollectionManager.GetItemsPriceCollectionFromConfig method : {0}",
ex.Message));
}
return(itemsPriceColl);
}
public RetroArchBsnesGameEmulation(IGame game,
IConfigurationCollection <HiganRetroArchConfiguration> configurationProfile,
IEnumerable <IEmulatedController> controllerPorts,
ISaveProfile saveProfile,
IDictionary <InputDriver, IDeviceInputMapping> inputMappings,
IEmulatorExecutable retroarchExecutable) : base(game, configurationProfile, controllerPorts, saveProfile)
{
this.InputMappings = inputMappings;
this.Executable = retroarchExecutable;
this.Scratch = this.Game.WithFiles().GetRuntimeLocation();
}
public static ConfigurationProfileModel AsModel <T>
(this IConfigurationCollection <T> @this, string prototypeName)
where T : class, IConfigurationCollection <T>
{
return(new ConfigurationProfileModel
{
ValueCollectionGuid = @this.ValueCollection.Guid,
ConfigurationSource = prototypeName,
Values = @this.ValueCollection.AsModel()
});
}
private void InitializeApplication(Host.IApplication hostApplication)
{
IConfigurationCollection hostConfigurations = hostApplication.Configurations;
hostConfigurations.ConfigurationCreated += OnHostConfigurationCreated;
hostConfigurations.ConfigurationRemoved += OnHostConfigurationRemoved;
foreach (IConfiguration hostConfiguration in hostConfigurations)
{
Add(hostConfiguration.Uid, hostConfiguration);
}
}
private void DisposeApplication(Host.IApplication hostApplication)
{
IConfigurationCollection hostConfigurations = hostApplication.Configurations;
hostConfigurations.ConfigurationCreated -= OnHostConfigurationCreated;
hostConfigurations.ConfigurationRemoved -= OnHostConfigurationRemoved;
foreach (IConfiguration configuration in this)
{
if (configuration.Application == hostApplication)
{
Remove(configuration.Uid);
}
}
}
public void UpdateConfiguration(IConfigurationCollection configurationCollection)
{
using var context = new DatabaseContext(this.Options.Options);
var guid = configurationCollection.ValueCollection.Guid;
var config = context.ConfigurationProfiles?
.Find(guid);
if (config == null)
{
return;
}
foreach
(var value in
context.ConfigurationValues.Where(v => v.ValueCollectionGuid == guid))
{
var realValue = configurationCollection.GetSection(value.SectionKey)?[value.OptionKey]
?.AsConfigurationStringValue();
if (realValue == value.Value || realValue == null)
{
continue;
}
value.Value = realValue;
context.Entry(value).State = EntityState.Modified;
}
var valueGuids = configurationCollection.ValueCollection.Select(v => v.value.Guid).ToList();
var alreadyExists = context.ConfigurationValues.Where(g => valueGuids.Contains(g.Guid))
.Select(g => g.Guid)
.AsEnumerable()
.ToHashSet();
var newValues = valueGuids.Except(alreadyExists)
.Select(g =>
{
(string?section, string?option, IConfigurationValue? configurationValue) = configurationCollection.ValueCollection[g];
// Values must not be null because g is from the value collection's GUIDs.
return(new ConfigurationValueModel
{
SectionKey = section !,
OptionKey = option !,
Guid = configurationValue !.Guid,
Value = configurationValue !.Value.AsConfigurationStringValue(),
ValueCollectionGuid = configurationCollection.ValueCollection.Guid
});
});
public void UpdateConfiguration(IConfigurationCollection configurationCollection)
{
using var context = new DatabaseContext(this.Options.Options);
var guid = configurationCollection.ValueCollection.Guid;
var config = context.ConfigurationProfiles?
.Find(guid);
if (config == null)
{
return;
}
foreach
(var value in
context.ConfigurationValues.Where(v => v.ValueCollectionGuid == guid))
{
var realValue = configurationCollection[value.SectionKey][value.OptionKey]
?.AsConfigurationStringValue();
if (realValue == value.Value || realValue == null)
{
continue;
}
value.Value = realValue;
context.Entry(value).State = EntityState.Modified;
}
foreach ((string section, string option, IConfigurationValue configurationValue) in configurationCollection.ValueCollection)
{
var value = context.ConfigurationValues.Find(configurationValue.Guid);
if (value != null)
{
continue;
}
context.ConfigurationValues.Add(new ConfigurationValueModel
{
SectionKey = section,
OptionKey = option,
Guid = configurationValue.Guid,
Value = configurationValue.Value.AsConfigurationStringValue(),
ValueCollectionGuid = configurationCollection.ValueCollection.Guid
});
}
context.SaveChanges();
}
public override IEmulatorTask CreateTask(IGameRecord executingGame,
ISaveLocation saveLocation,
IList <IEmulatedController> controllerConfiguration,
string profileContext = "default")
{
IConfigurationCollection <HiganRetroArchConfiguration> configuration =
this.GenericConfigurationFactory.GetConfiguration(executingGame.RecordId, profileContext);
var templates = controllerConfiguration.Select(c => this.ConfigurationFactory.GetInputMappings(c)).ToList();
var task = new EmulatorTask(executingGame)
{
GameSaveLocation = saveLocation,
ControllerConfiguration = templates
// todo: refactor out into extension method.
.Select(t => (t.template as IInputTemplate, t.mapping)).ToList(),
};
task.ProcessTaskRoot = new RetroArchTaskRoot(this.TaskRootProvider.GetTaskRoot(task));
configuration.Configuration.DirectoryConfiguration.SavefileDirectory =
task.ProcessTaskRoot.SaveDirectory.FullName;
configuration.Configuration.DirectoryConfiguration.SystemDirectory =
task.ProcessTaskRoot.SystemDirectory.FullName;
configuration.Configuration.DirectoryConfiguration.CoreOptionsPath =
Path.Combine(task.ProcessTaskRoot.ConfigurationDirectory.FullName,
"retroarch-core-options.cfg");
switch (configuration.Configuration.BsnesCoreConfig.PerformanceProfile)
{
case PerformanceProfile.Performance:
task.AddPragma("retroarch_core", "bsnes_performance_libretro.dll");
break;
case PerformanceProfile.Accuracy:
task.AddPragma("retroarch_core", "bsnes_accuracy_libretro.dll");
break;
case PerformanceProfile.Balanced:
task.AddPragma("retroarch_core", "bsnes_balanced_libretro.dll");
break;
}
task.EmulatorConfiguration = configuration;
return(task);
}
public DeepLinkCollectionViewModel(
IConfigurationCollection configurationCollection,
IClipboardManager clipboardManager,
IDeepLinkManager deepLinkManager,
IMapper mapper,
IEventAggregator eventAggregator,
IBrowserManager browserManager)
{
this.clipboardManager = clipboardManager;
this.configurationCollection = configurationCollection;
this.deepLinkManager = deepLinkManager;
this.mapper = mapper;
this.eventAggregator = eventAggregator;
this.browserManager = browserManager;
this.clipboardManager.ClipboardTextUpdateReceived += this.OnClipboardTextUpdateReceived;
this.eventAggregator.Subscribe(this);
// this.currentMatchName = "-";
this.HierarchicalLinks = new BindingList <HierarchyLevelOne>();
}
public override void WriteJson(global::Newtonsoft.Json.JsonWriter writer, [AllowNull] IConfigurationCollection <TElement> value, global::Newtonsoft.Json.JsonSerializer serializer)
{
if (ReferenceEquals(value, null))
{
writer.WriteNull();
return;
}
writer.WriteStartArray();
foreach (var item in value)
{
if (ReferenceEquals(value, null))
{
writer.WriteNull();
}
else
{
serializer.Serialize(writer, item);
}
}
writer.WriteEndArray();
}
public CollectionCircularInterceptor(IConfigurationCollection <T> @this)
{
this.@this = @this;
}
public Task UpdateProfileAsync(IConfigurationCollection profile)
{
return(this.CollectionStore.UpdateConfigurationAsync(profile));
}
public void UpdateProfile(IConfigurationCollection profile)
{
this.CollectionStore.UpdateConfiguration(profile);
}
public MainViewModel(IConfigurationCollection configCollection)
{
configs = configCollection;
NavigationTreeItems = BuildNavigationTree();
SelectedItem = NavigationTreeItems[0].Items[0];
}
protected IDictionary <string, string> BuildConfiguration(IConfigurationCollection configuration,
IEnumerable <(IInputTemplate, IInputMapping)> inputTemplates)
public override IConfigurationCollection <TElement> ReadJson(global::Newtonsoft.Json.JsonReader reader, Type objectType, [AllowNull] IConfigurationCollection <TElement> existingValue, bool hasExistingValue, global::Newtonsoft.Json.JsonSerializer serializer)
{
throw new NotImplementedException();
}
protected override void Configure(IObjectTypeDescriptor descriptor)
{
descriptor.ExtendMutation();
descriptor.Field("updateGameConfigurationValues")
.UseAutoSubscription()
.UseClientMutationId()
.Description("Updates the provided configuration values.")
.Argument("input", a => a.Type <UpdateGameConfigurationValueInputType>())
.Resolve(async ctx =>
{
var configStore = ctx.SnowflakeService <IGameLibrary>().GetExtension <IGameConfigurationExtensionProvider>();
var input = ctx.ArgumentValue <UpdateGameConfigurationValueInput>("input");
var newValues = new List <IConfigurationValue>();
var newValueGuid = new List <(Guid valueCollection, Guid value)>();
foreach (var value in input.Values)
{
var owningGuid = await configStore.GetOwningValueCollectionAsync(value.ValueID);
if (owningGuid == default)
{
continue; // value is an orphan or not found.
}
await configStore.UpdateValueAsync(value.ValueID, value.Value);
newValues.Add(await configStore.GetValueAsync(value.ValueID));
newValueGuid.Add((owningGuid, value.ValueID));
}
return(new UpdateGameConfigurationValuePayload()
{
Values = newValues,
Collections = newValueGuid.GroupBy(k => k.valueCollection, v => v.value),
});
}).Type <NonNullType <UpdateGameConfigurationValuePayloadType> >();
descriptor.Field("deleteGameConfiguration")
.UseAutoSubscription()
.UseClientMutationId()
.Description("Delete the specified game configuration profile.")
.Argument("input", a => a.Type <DeleteGameConfigurationInputType>())
.Resolve(async ctx =>
{
var games = ctx.SnowflakeService <IGameLibrary>();
var configStore = games.GetExtension <IGameConfigurationExtensionProvider>();
var orchestrators = ctx.SnowflakeService <IPluginManager>().GetCollection <IEmulatorOrchestrator>();
var input = ctx.ArgumentValue <DeleteGameConfigurationInput>("input");
IConfigurationCollection config = null;
if (input.Retrieval != null)
{
var orchestrator = orchestrators[input.Retrieval.Orchestrator];
var game = await games.GetGameAsync(input.Retrieval.GameID);
if (orchestrator == null)
{
return(ErrorBuilder.New()
.SetCode("CFG_NOTFOUND_ORCHESTRATOR")
.SetMessage("The specified orchestrator was not found.")
.Build());
}
if (game == null)
{
return(ErrorBuilder.New()
.SetCode("CFG_NOTFOUND_GAME")
.SetMessage("The specified game was not found.")
.Build());
}
config = orchestrator.GetGameConfiguration(game, input.CollectionID);
if (config == null)
{
return(ErrorBuilder.New()
.SetCode("CFG_NOTFOUND_COLLECTION")
.SetMessage("The specified collectionId was not found in the configuration set for the specified orchestrator..")
.Build());
}
}
await configStore.DeleteProfileAsync(input.CollectionID);
return(new DeleteGameConfigurationPayload()
{
CollectionID = input.CollectionID,
Configuration = config,
});
}).Type <NonNullType <DeleteGameConfigurationPayloadType> >();
descriptor.Field("updatePluginConfigurationValues")
.UseAutoSubscription()
.UseClientMutationId()
.Description("Updates configuration values for a plugin.")
.Argument("input", a => a.Type <UpdatePluginConfigurationValueInputType>())
.Resolve(async ctx =>
{
var input = ctx.ArgumentValue <UpdatePluginConfigurationValueInput>("input");
var plugin = ctx.SnowflakeService <IPluginManager>().Get(input.Plugin);
if (plugin == null)
{
return(ErrorBuilder.New()
.SetCode("PCFG_NOTFOUND_PLUGIN")
.SetMessage("The specified plugin was not found.")
.Build());
}
var configStore = plugin?.Provision?.ConfigurationStore;
if (configStore == null)
{
return(ErrorBuilder.New()
.SetCode("PCFG_NOTPROVISIONED")
.SetMessage("The specified plugin was not a provisioned plugin.")
.Build());
}
var newValues = input.Values.Select(i => i.ValueID);
await configStore.SetAsync(input.Values.Select(i => (i.ValueID, i.Value)));
var configuration = plugin.GetPluginConfiguration();
return(new UpdatePluginConfigurationValuePayload()
{
Values = newValues.Select(g => configuration.ValueCollection[g].value).Where(v => v != null).ToList(),
Plugin = plugin,
});
}).Type <NonNullType <UpdatePluginConfigurationValuePayloadType> >();
}
