public ChangeHistoryViewModel(ModuleNames module, int? rootModelKey)
{
DisplayName = module.ToString() + " Change History";
Module = module;
RootModelKey = rootModelKey;
Results = new SmartCollection<AuditedModelValue>();
}
public PdfViewModel(string displayName, ModuleNames module, ReportRecord reportRecord)
{
DisplayName = displayName;
this.ReportRecord = reportRecord;
DialogHeight = IoC.Get<IShell>().CurrentHeight - 125;
DialogWidth = IoC.Get<IShell>().CurrentWidth - 50;
this.ModuleName = module;
}
public void LoadModule(CliModuleBase module)
{
var cliModuleAttribute = module.GetType().GetCustomAttribute <CliModuleAttribute>();
CliConsole.WriteLine($"module ({cliModuleAttribute.ModuleName})");
ModuleNames.Add(cliModuleAttribute.ModuleName);
MethodsByModules[cliModuleAttribute.ModuleName] = new List <string>();
var methods = module.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
foreach (MethodInfo methodInfo in methods.OrderBy(m => m.Name))
{
var cliProperty = methodInfo.GetCustomAttribute <CliPropertyAttribute>();
var cliFunction = methodInfo.GetCustomAttribute <CliFunctionAttribute>();
bool isProperty = cliProperty != null;
string objectName = cliProperty?.ObjectName ?? cliFunction?.ObjectName;
string itemName = cliProperty?.PropertyName ?? cliFunction?.FunctionName;
if (objectName == null)
{
throw new InvalidDataException($"Method {methodInfo.Name} of {module.GetType().Name} should be decorated with one of {nameof(CliPropertyAttribute)} or {nameof(CliFunctionAttribute)}");
}
ObjectInstance instance;
if (!_objects.ContainsKey(objectName))
{
instance = _engine.JintEngine.Object.Construct(Arguments.Empty);
_engine.JintEngine.SetValue(objectName, instance);
_objects[objectName] = instance;
}
instance = _objects[objectName];
var @delegate = CreateDelegate(methodInfo, module);
DelegateWrapper nativeDelegate = new DelegateWrapper(_engine.JintEngine, @delegate);
if (isProperty)
{
CliConsole.WriteKeyword($" {objectName}");
CliConsole.WriteLine($".{itemName}");
MethodsByModules[objectName].Add(itemName);
AddProperty(instance, itemName, nativeDelegate);
}
else
{
CliConsole.WriteKeyword($" {objectName}");
CliConsole.WriteLine($".{itemName}({string.Join(", ", methodInfo.GetParameters().Select(p => p.Name))})");
MethodsByModules[objectName].Add(itemName + "(");
AddMethod(instance, itemName, nativeDelegate);
}
}
CliConsole.WriteLine();
}
public void TryAddModules(string[] modules)
{
foreach (string module in modules)
{
if (!ModuleNames.Contains(module))
{
ModuleNames.Add(module);
}
}
}
public void Load(string file)
{
if (!IsLoaded)
{
ModuleNames.Clear();
var listItems = JsonConvert.DeserializeObject <List <ModuleNameData> >(Resources.Load <TextAsset>(file).text);
listItems.ForEach(item => ModuleNames.Add(item.id, item));
IsLoaded = true;
}
}
public virtual async Task <IReadOnlyCollection <string> > GetEnabledModulesAsync(ulong guildId)
{
var cacheKey = CacheKey.GetEnabledModulesCacheKey(guildId);
var cache = await _cache.GetAsync <string[]>(cacheKey);
if (cache.HasValue)
{
return(cache.Value);
}
using var scope = _provider.CreateScope();
var repo = scope.ServiceProvider.GetService <IGuildModuleRepository>();
string[] enabledModules;
if (repo != null)
{
var entities = (await repo.GetAllAsync(guildId))
.Where(gm => gm.Enabled)
.ToDictionary(gm => gm.Name, gm => gm.Enabled, StringComparer.OrdinalIgnoreCase);
var result = entities
.Where(kv => kv.Value)
.Select(kv => kv.Key)
.ToList();
// Add the default-enabled modules.
result.AddRange(DefaultModuleNames.Where(name => !entities.ContainsKey(name)));
// Add the modules that are always enabled.
foreach (var name in CoreModuleNames)
{
if (!result.Contains(name, StringComparer.OrdinalIgnoreCase))
{
result.Add(name);
}
}
enabledModules = result.ToArray();
}
else
{
enabledModules = ModuleNames.ToArray();
}
await _cache.SetAsync(cacheKey, enabledModules, CacheTime);
return(enabledModules);
}
public virtual async Task SetModuleEnabledAsync(ulong guildId, string casedModuleName, bool enabled)
{
var moduleName = ModuleNames.FirstOrDefault(name => name.Equals(casedModuleName, StringComparison.OrdinalIgnoreCase));
if (string.IsNullOrEmpty(moduleName))
{
throw new KeyNotFoundException("The module could not be found.");
}
using var scope = _provider.CreateScope();
var repo = scope.ServiceProvider.GetService <IGuildModuleRepository>();
if (repo == null)
{
throw new NotSupportedException($"There was no {nameof(IGuildModuleRepository)} registered. {nameof(SetModuleEnabledAsync)} is not available.");
}
var enabledGuildModule = await repo.GetAsync(guildId, moduleName);
if (CoreModuleNames.Contains(moduleName))
{
throw new InvalidOperationException($"The module {moduleName} is a core module and cannot be disabled");
}
if (enabledGuildModule == null)
{
enabledGuildModule = new GuildModule
{
GuildId = guildId,
Name = moduleName,
Enabled = enabled
};
repo.Add(enabledGuildModule);
}
else
{
enabledGuildModule.Enabled = enabled;
repo.Update(enabledGuildModule);
}
await repo.SaveChangesAsync();
await _cache.RemoveAsync(CacheKey.GetEnabledModulesCacheKey(guildId));
}
public ITranslationModule this[string moduleName]
{
get
{
if (!Collection.Projects.ContainsKey(moduleName) && ModuleNames.Contains(moduleName))
{
Collection.Projects.Add(moduleName, IO.ResX.FromResX(this.Directory, moduleName, this.MasterLanguage));
}
return(Collection.Projects[moduleName]);
}
set
{
if (!Collection.Projects.ContainsKey(moduleName))
{
Collection.Projects.Add(moduleName, value);
IO.ResX.ToResX(value, this.Directory);
}
}
}
static ModuleType ModuleTypeFromString(string moduleName)
{
return(ModuleNames.FirstOrDefault(tuple => tuple.name == moduleName).module);
}
public ModuleNameData GetModuleNameData(int moduleId) => ModuleNames.ContainsKey(moduleId) ? ModuleNames[moduleId] : null;
public string GetModuleName(string filePath)
{
ModuleNames.TryGetValue(filePath, out string moduleName);
return(moduleName);
}
