public async Task <IActionResult> Get(string id)
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
return await _dashboardPanelRepository.Get(new ObjectId(id));
}));
}
public async Task <IActionResult> Get()
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
return await _workflowTransitionRepository.GetAll();
}));
}
public async Task <IActionResult> Post([FromBody] WorkflowTransition item)
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
return await _workflowTransitionRepository.Add(item);
}));
}
private bool ProcessDecryptMessage(FunctionWrapper f)
{
Core.ProcessFunctions.DecryptMessage fDecryptMessage = new Core.ProcessFunctions.DecryptMessage(f);
byte[] buffer = fDecryptMessage.GetBuffer();
if (buffer == null)
{
lbFunction.Invoke(new MethodInvoker(delegate
{
lbFunction.Text = "";
}));
f.status = FunctionWrapper.Status.Forwarded;
return(false);
}
DynamicFileByteProvider dynamicFileByteProvider;
mStream = new MemoryStream();
mStream.Write(buffer, 0, buffer.Length);
mStream.Seek(0, SeekOrigin.Begin);
dynamicFileByteProvider = new DynamicFileByteProvider(mStream);
hexBox.Invoke(new MethodInvoker(delegate
{
hexBox.ByteProvider = dynamicFileByteProvider;
}));
Search(0);
return(true);
}
private async Task GenerateForRecord(ObjectGeneration obj, FileGeneration fg)
{
if (!obj.IsTopClass)
{
return;
}
using (var args = new FunctionWrapper(fg,
$"public{obj.FunctionOverride()}async Task WriteToXmlFolder"))
{
args.Add("DirectoryPath dir");
args.Add("string name");
args.Add("XElement node");
args.Add("int counter");
args.Add($"ErrorMaskBuilder? errorMask");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
"this.WriteToXml"))
{
args.Add("node: node");
args.Add("errorMask: errorMask");
args.Add("translationMask: null");
}
}
}
public async Task <IActionResult> Search([FromQuery] ItemSearchRequest requestArgs)
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
return await _itemRepository.Search(requestArgs);
}));
}
private bool ProcessRecvFrom(FunctionWrapper f)
{
Core.ProcessFunctions.recvfrom fRecvfrom = new Core.ProcessFunctions.recvfrom(f);
byte[] buffer = fRecvfrom.GetBuffer();
// Esto ocurre cuando la funcion devuelve -1 bytes leidos. Cuando no quedan mas datos que leer.
if (buffer == null || buffer.Length == 0)
{
// Hacemos forward de la función y aceptamos nuevas
f.status = FunctionWrapper.Status.Forwarded;
//Program.data.AceptingNewFunctions = true;
lbFunction.Invoke(new MethodInvoker(delegate
{
lbFunction.Text = "";
}));
return(false);
}
DynamicFileByteProvider dynamicFileByteProvider;
mStream = new MemoryStream();
mStream.Write(buffer, 0, buffer.Length);
mStream.Seek(0, SeekOrigin.Begin);
dynamicFileByteProvider = new DynamicFileByteProvider(mStream);
hexBox.Invoke(new MethodInvoker(delegate
{
hexBox.ByteProvider = dynamicFileByteProvider;
}));
Search(0);
return(true);
}
private static Point GeneralizedNewtonMethod(FunctionWrapper function, Point x0, double h0, double epsilon)
{
var g = function.Gradient(x0);
if (!(g.Normalize() > epsilon))
{
return(x0);
}
double h;
var hessian = function.Hess(x0);
var hessianInverted = hessian.InvertByJordanGauss();
do
{
CountThisLoop();
var x = x0;
x0 = new Point(new double[x0.Length]);
var w = new Vector(new double[x0.Length]);
for (var i = 0; i < w.Length; i++)
{
for (var j = 0; j < w.Length; j++)
{
w[i] += hessianInverted[i, j] * g[j];
}
}
h = function.FindHForFastestDescent(x, w, h0, epsilon);
x0 = x - h * w;
g = function.Gradient(x0);
} while (g.Normalize() >= epsilon && Math.Abs(h) > Math.Sqrt(epsilon));
return(x0);
}
public async Task <IActionResult> Post([FromBody] ItemType item)
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
return await _itemTypeRepository.Add(item);
}));
}
private static Point NewtonMethod(FunctionWrapper function, Point x0, double epsilon)
{
var g = function.Gradient(x0);
if (g.Normalize() > epsilon)
{
do
{
CountThisLoop();
var x = x0;
var hessian = function.Hess(x0);
var hessianInverted = hessian.InvertByJordanGauss();
x0 = new Point(new double[x0.Length]);
var w = new Vector(new double[x0.Length]);
for (var i = 0; i < w.Length; i++)
{
for (var j = 0; j < w.Length; j++)
{
w[i] += hessianInverted[i, j] * g[j];
}
}
x0 = x - w;
g = function.Gradient(x0);
} while (g.Normalize() >= epsilon);
}
return(x0);
}
private static Point CoordinateDescent(FunctionWrapper function, Point x0, double h0, double epsilon)
{
var h = new Vector(new double[x0.Length]);
for (var i = 0; i < h.Length; i++)
{
h[i] = h0;
}
var xInt = x0.Clone();
Point xExt;
do
{
xExt = xInt.Clone();
for (var i = 0; i < xInt.Length; i++)
{
Program.CountThisLoop();
var x = xInt.Clone();
var y1 = x.Clone();
y1[i] += 3 * epsilon;
var y2 = x.Clone();
y2[i] -= 3 * epsilon;
var f1 = function.Eval(y1);
var f2 = function.Eval(y2);
var z = Math.Sign(f2 - f1);
h[i] = function.FindHForCoordinateDescent(xInt.Clone(), z, i, h[i], epsilon);
xInt[i] = x[i] + h[i] * z;
}
} while ((xInt - xExt).Normalize() >= epsilon);
return(xInt);
}
public async Task <IActionResult> Find([FromBody] List <ObjectId> screenIds)
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
return await _screenRepository.Find(screenIds);
}));
}
public async Task <IActionResult> Post([FromBody] DashboardPanel item)
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
return await _dashboardPanelRepository.Add(item);
}));
}
public async Task <IActionResult> Get()
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
return await _dashboardPanelRepository.GetAll();
}));
}
public async Task <IActionResult> Post([FromBody] TestCase testCaseR)
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
return await _testCaseRepository.Add(testCaseR);
}));
}
private void GetThreadName(ThreadWrapper threadWrapper, ValueWrapper threadObject, NuGenFrameRefresher threadActiveFrameRefresher)
{
List <ModuleWrapper> modules = threadWrapper.FindModulesByName(GetThreadNameMethod.BaseTypeDefinition.ModuleScope.Assembly.FileName);
if (modules.Count == 1)
{
ModuleWrapper module = modules[0];
FunctionWrapper getThreadNameFunction = module.GetFunction(GetThreadNameMethod.Token);
List <ValueWrapper> arguments = new List <ValueWrapper>(1);
arguments.Add(threadObject);
NuGenEvaluationHandler methodCaller = new NuGenEvaluationHandler(threadActiveFrameRefresher);
NuGenBaseEvaluationResult evaluationResult = methodCaller.CallFunction(getThreadNameFunction, arguments);
if (evaluationResult.IsSuccessful)
{
if (evaluationResult.Result != null && (CorElementType)evaluationResult.Result.ElementType == CorElementType.ELEMENT_TYPE_STRING)
{
ValueWrapper dereferencedResult = evaluationResult.Result.DereferenceValue();
if (dereferencedResult != null)
{
EvaluatedThreadName = NuGenHelperFunctions.ShowEscapeCharacters(dereferencedResult.GetStringValue(), true);
}
}
}
}
}
public async Task <IActionResult> Get(string id, [FromQuery] string expand = null)
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
return await _itemRepository.Get(new ObjectId(id), new ItemExpansionParams(expand));
}));
}
public static FunctionWrapper PrepareFunction(FunctionWrapper f, byte[] buffer)
{
Nektra.Deviare2.INktParam lpBuffers = f.callInfo.Params().GetAt(1);
Nektra.Deviare2.INktParam dwBufferCount = f.callInfo.Params().GetAt(2);
Nektra.Deviare2.INktParam lpNumberOfBytesRecvd = f.callInfo.Params().GetAt(3);
// Numero de estructuras
ulong nStructs = dwBufferCount.Memory().Read(dwBufferCount.Address, Nektra.Deviare2.eNktDboFundamentalType.ftUnsignedWord);
// Puntero a donde apunta la lista de estructuras
IntPtr lpwsabuf = new IntPtr(lpBuffers.Memory().Read(lpBuffers.Address, Nektra.Deviare2.eNktDboFundamentalType.ftUnsignedDoubleWord));
// len. No la leemos de la estructura WSABUF sino de WSARecv
Nektra.Deviare2.INktParam NumberOfBytesRecvd = lpNumberOfBytesRecvd.Evaluate();
// *buf
IntPtr pBuffer = new IntPtr(lpBuffers.Memory().Read(lpwsabuf + 4, Nektra.Deviare2.eNktDboFundamentalType.ftUnsignedDoubleWord));
// Modificamos el buffer
Auxiliar.Memory.WriteMemory(f.callInfo.Process().Id, pBuffer, buffer);
// Modificamos el tamaño
lpNumberOfBytesRecvd.Value = buffer.Length;
return(f);
}
public async Task <IActionResult> Get([FromQuery] string imageFileName)
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
if (string.IsNullOrEmpty(imageFileName))
{
return "";
}
var url = string.Concat(
"https://meticulos.blob.core.windows.net/images/",
imageFileName);
var blob = new CloudBlockBlob(new Uri(url), GetStorageCredentials());
if (await blob.ExistsAsync())
{
await blob.FetchAttributesAsync();
byte[] imageBytes = new byte[blob.Properties.Length];
await blob.DownloadToByteArrayAsync(imageBytes, 0);
return Convert.ToBase64String(imageBytes);
}
return "";
}));
}
public void AddEventHandlerToCalculator()
{
Listener listener = new Listener();
Calculator calculator = new Calculator();
FunctionWrapper <int, int, int, Action <int, int> > wrapper = new FunctionWrapper <int, int, int, Action <int, int> >(listener, null);
typeof(Calculator).GetEvent("MyEvent").AddEventHandler(calculator, wrapper.CreateActionDelegate());
calculator.Add(1, 2);
Assert.AreEqual(1, listener.X);
Assert.AreEqual(2, listener.Y);
MethodInfo invoke = typeof(Calculator).GetEvent("MyEvent").EventHandlerType.GetMethod("Invoke");
MethodInfo add = typeof(Calculator).GetEvent("MyEvent").GetAddMethod();
Assert.IsNotNull(add);
Assert.AreEqual(1, add.GetParameters().Count());
Assert.IsNotNull(invoke);
var parameters = invoke.GetParameters();
var returnparameter = invoke.ReturnParameter;
Assert.IsNotNull(returnparameter);
Assert.AreEqual("System.Void", returnparameter.ParameterType.FullName);
Assert.AreEqual(typeof(MyEvent), typeof(Person).GetEvent("NameEvent").EventHandlerType);
}
private bool ProcessWSASendTo(FunctionWrapper f)
{
//f.status = FunctionWrapper.Status.Forwarded;
////Program.data.AceptingNewFunctions = true;
//lbFunction.Invoke(new MethodInvoker(delegate
//{
// lbFunction.Text = "";
//}));
//return true;
//throw new Exception("Not implemented");
Core.ProcessFunctions.WSAsendto fWSASendTo = new Core.ProcessFunctions.WSAsendto(f);
byte[] buffer = fWSASendTo.GetBuffer();
DynamicFileByteProvider dynamicFileByteProvider;
mStream = new MemoryStream();
mStream.Write(buffer, 0, buffer.Length);
mStream.Seek(0, SeekOrigin.Begin);
dynamicFileByteProvider = new DynamicFileByteProvider(mStream);
hexBox.Invoke(new MethodInvoker(delegate
{
hexBox.ByteProvider = dynamicFileByteProvider;
}));
Search(0);
return(true);
}
public static void GenerateWritePartialMethods(
FileGeneration fg,
ObjectGeneration obj,
TypeGeneration field,
bool isAsync)
{
using (var args = new FunctionWrapper(fg,
$"public static partial void WriteBinary{field.Name}Custom{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.IGetter, defs: obj.Generics));
args.SemiColon = true;
args.Add($"{nameof(MutagenWriter)} writer");
args.Add($"{obj.Interface(getter: true, internalInterface: true)} item");
}
fg.AppendLine();
using (var args = new FunctionWrapper(fg,
$"public static void WriteBinary{field.Name}{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.IGetter, defs: obj.Generics));
args.Add($"{nameof(MutagenWriter)} writer");
args.Add($"{obj.Interface(getter: true, internalInterface: true)} item");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"WriteBinary{field.Name}Custom"))
{
args.Add("writer: writer");
args.Add("item: item");
}
}
fg.AppendLine();
}
public async Task <IActionResult> Delete(string id)
{
return(await FunctionWrapper.ExecuteAction(this, async() =>
{
await _workflowRepository.Delete(new ObjectId(id));
}));
}
public override async Task GenerateInCommonMixin(ObjectGeneration obj, FileGeneration fg)
{
if (!await obj.IsMajorRecord())
{
return;
}
if (!obj.IsTopClass)
{
return;
}
using (var args = new FunctionWrapper(fg,
$"public static {nameof(IMajorRecordCommon)} {nameof(IDuplicatable.Duplicate)}"))
{
//ToDo
// Modify to getter interface after copy is refactored
args.Add($"this {obj.ObjectName} item");
args.Add("Func<FormKey> getNextFormKey");
args.Add($"IList<({nameof(IMajorRecordCommon)} Record, FormKey OriginalFormKey)>? duplicatedRecords = null");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"return {obj.CommonClassInstance("item", LoquiInterfaceType.IGetter, CommonGenerics.Class, MaskType.Normal)}.{nameof(IDuplicatable.Duplicate)}"))
{
args.AddPassArg("item");
args.AddPassArg("getNextFormKey");
args.AddPassArg("duplicatedRecords");
}
}
}
public override async Task GenerateInCommonMixin(ObjectGeneration obj, FileGeneration fg)
{
await base.GenerateInCommonMixin(obj, fg);
if (!await obj.IsMajorRecord())
{
return;
}
using (var args = new FunctionWrapper(fg,
$"public static {obj.ObjectName} Duplicate{obj.GetGenericTypes(MaskType.Normal, MaskType.NormalGetter)}"))
{
args.Wheres.AddRange(obj.GenericTypeMaskWheres(LoquiInterfaceType.IGetter, MaskType.Normal, MaskType.NormalGetter));
args.Add($"this {obj.Interface(obj.GetGenericTypes(MaskType.NormalGetter), getter: true, internalInterface: true)} item");
args.Add($"{nameof(FormKey)} formKey");
args.Add($"{obj.Mask(MaskType.Translation)}? copyMask = null");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"return {obj.CommonClassInstance("item", LoquiInterfaceType.IGetter, CommonGenerics.Functions, MaskType.NormalGetter)}.Duplicate{obj.GetGenericTypes(MaskType.Normal, MaskType.NormalGetter, MaskType.Translation)}"))
{
args.AddPassArg("item");
args.AddPassArg("formKey");
args.Add("copyMask: copyMask?.GetCrystal()");
}
}
fg.AppendLine();
}
public static FunctionWrapper PrepareFunction(FunctionWrapper f, byte[] buffer)
{
foreach (MatchAndReplace.MatchAndReplace match in Program.data.GetReplaceList())
{
if (!match.enabled)
{
continue;
}
if (match.replaceIncomming)
{
bool changed;
do
{
buffer = Searcher.Searcher.ReplaceBytes(buffer, match.match, match.replace, out changed);
} while (changed);
}
}
f.callInfo.Result().Value = buffer.Length;
f.callInfo.Params().GetAt(2).Value = buffer.Length;;
f.callInfo.Params().GetAt(1).set_ValueAt(0, buffer);
return(f);
}
public async Task <IActionResult> Get(string id)
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
return await _workflowTransitionRepository.Get(new ObjectId(id));
}));
}
public async Task <IActionResult> Search([FromQuery] TestCaseSearchRequest searchRequest)
{
return(await FunctionWrapper.ExecuteFunction(this, async() =>
{
return await _testCaseRepository.Search(searchRequest);
}));
}
public static FunctionWrapper PrepareFunction(FunctionWrapper f, byte[] buffer)
{
Nektra.Deviare2.INktParam lWsabuf = f.callInfo.Params().GetAt(1).Evaluate();
Nektra.Deviare2.INktParam lWsaSendTo = f.callInfo.Params().GetAt(3).Evaluate();
Nektra.Deviare2.INktParam len = lWsabuf.Fields().GetAt(0);
Nektra.Deviare2.INktParam pBuff = lWsabuf.Fields().GetAt(1);
foreach (MatchAndReplace.MatchAndReplace match in Program.data.GetReplaceList())
{
if (!match.enabled)
{
continue;
}
if (match.replaceOutcomming)
{
bool changed;
do
{
buffer = Searcher.Searcher.ReplaceBytes(buffer, match.match, match.replace, out changed);
} while (changed);
}
}
len.Value = buffer.Length;
pBuff.Value = buffer;
return(f);
}
public static async Task Main(string[] args)
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", true)
.AddEnvironmentVariables()
.Build();
var configWrapper = new ConfigurationWrapper(config);
var topClipsModuleHelper = new TopClipsModuleHelper(configWrapper);
var botHelper = new BotHelper(configWrapper);
using (var functionWrapper = new FunctionWrapper(configWrapper))
using (var discordWrapper = new DiscordWrapper(configWrapper["BotToken"]))
using (var services = new ServiceCollection()
.AddSingleton <IDiscordWrapper>(discordWrapper)
.AddSingleton <IConfigurationWrapper>(configWrapper)
.AddSingleton <IFunctionWrapper>(functionWrapper)
.AddSingleton <ITopClipsModuleHelper>(topClipsModuleHelper)
.AddSingleton <IBotHelper>(botHelper)
.AddLogging(s => s.AddConsole())
.BuildServiceProvider())
{
var bot = new Bot(services);
await bot.RunAsync();
await Task.Delay(-1);
}
}
