public JsonResult GetAdminRoleListData()
{
var adminRoleList = this._adminRoleService.GetList(s => s.State == 1).Select(t => new { t.RoleName, t.Id }).ToList();
if (adminRoleList == null)
{
return(Json(ResultStatus.Fail));
}
List <object> AdminUserObject = new List <object>();
for (int i = 0; i < adminRoleList.Count; i++)
{
if (i == 0)
{
DefaultInputList adminRoleDefault = new DefaultInputList();
adminRoleDefault.id = adminRoleList[i].Id;
adminRoleDefault.name = adminRoleList[i].RoleName;
adminRoleDefault.desc = " ";
adminRoleDefault.selected = true;
AdminUserObject.Add(adminRoleDefault);
}
else
{
InputList list = new InputList();
list.id = adminRoleList[i].Id;
list.name = adminRoleList[i].RoleName;
list.desc = " ";
AdminUserObject.Add(list);
}
}
return(Json(AdminUserObject, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Check whether all Grouped/Configurable products'/Kits' children are valid.
/// </summary>
/// <param name="inventoryItem">Grouped/Configurable Product/Kit that should be checked</param>
/// <returns>Validation result</returns>
private bool ValidateChildren(InventoryItem inventoryItem)
{
List <int> validIds = InputList.Select(validItem => validItem.InventoryID.GetValueOrDefault()).ToList();
List <int> childIds = new List <int>();
bool result = false;
InventoryItemPCExt itemPCExt = inventoryItem.GetExtension <InventoryItemPCExt>();
if (itemPCExt != null)
{
if (itemPCExt.UsrKNCompositeType == KCConstants.GroupedProduct)
{
IEnumerable <KNSIGroupedItems> childItems = Graph.GroupedItemChilds.Select(inventoryItem.InventoryID).RowCast <KNSIGroupedItems>();
childIds.AddRange(childItems.Select(child => child.MappedInventoryID.GetValueOrDefault()));
}
else if (itemPCExt.UsrKNCompositeType == KCConstants.ConfigurableProduct)
{
IEnumerable <InventoryItem> childItems = Graph.ChildrenByCompositeId.Select(inventoryItem.InventoryID).RowCast <InventoryItem>();
childIds.AddRange(childItems.Select(child => child.InventoryID.GetValueOrDefault()));
}
}
if (inventoryItem.KitItem.GetValueOrDefault())
{
string revisionId = Graph.KitProduct.SelectSingle(inventoryItem.InventoryID)?.RevisionID;
IEnumerable <INKitSpecStkDet> stockKitComponents = Graph.StockKitComponents.Select(inventoryItem.InventoryID, revisionId)?.RowCast <INKitSpecStkDet>();
IEnumerable <INKitSpecNonStkDet> nonStockKitComponents = Graph.NonStockKitComponents.Select(inventoryItem.InventoryID, revisionId)?.RowCast <INKitSpecNonStkDet>();
childIds.AddRange(stockKitComponents.Select(x => x.CompInventoryID.GetValueOrDefault()));
childIds.AddRange(nonStockKitComponents.Select(x => x.CompInventoryID.GetValueOrDefault()));
}
result = childIds.Count == 0 || childIds.All(child => validIds.Contains(child));
return(result);
}
private void Button_Click_2(object sender, RoutedEventArgs e)
{
var doop = ((Button)sender).DataContext;
InputList woop = doop as InputList;
if (woop != null)
{
var t = woop.Plugin.GetDetails();
string about = $@"Pluging: {woop.Name}
Author: {t.Author}
Support: {t.SupportLink}
Version: {t.Version}";
MessageBox.Show(this, about);
}
OutputList woop2 = doop as OutputList;
if (woop2 != null)
{
var t = woop2.Plugin.GetDetails();
string about = $@"Pluging: {woop2.Name}
Author: {t.Author}
Support: {t.SupportLink}
Version: {t.Version}";
MessageBox.Show(this, about);
}
}
public static void CreateInputInfo()
{
GameObject canvasObject = CreateCanvas(null, "Input Info", 9, false).gameObject;
InputList list = canvasObject.AddComponent <InputList>();
list.SetupText(CreateTextObject(canvasObject.transform, "Text", 12));
}
/// <summary>
/// Parses a transaction from the specified stream.
/// </summary>
/// <param name="stream">A BlockchainStream containing the data to load.</param>
/// <exception cref="System.ArgumentException">The specified stream is NULL or invalid.</exception>
/// <exception cref="System.InvalidOperationException">The transaction could not be parsed from the specified stream.</exception>
/// <returns>A Transaction parsed from the stream.</returns>
internal static Transaction Parse(BlockchainStream stream)
{
Transaction returnValue;
// Verify params
if (stream == null)
{
throw new ArgumentException("The specified stream is NULL", nameof(stream));
}
// Get the transaction version
if (stream.TryReadInt(out int version))
{
// Get number of inputs
if (stream.TryReadVarInt(out VarInt inputCount) && inputCount.AsInt64 > 0)
{
InputList inputs;
// Load inputs
inputs = new InputList();
for (long i = 0; i < inputCount.AsInt64; i++)
{
Input nextInput;
nextInput = InputParser.Parse(stream);
inputs.Add(nextInput);
}
// Get number of outputs
if (stream.TryReadVarInt(out VarInt outputCount) && outputCount.AsInt64 > 0)
{
OutputList outputs;
// Load outputs
outputs = new OutputList();
for (long i = 0; i < outputCount.AsInt64; i++)
{
Output nextOutput;
nextOutput = OutputParser.Parse(stream);
outputs.Add(nextOutput);
}
if (stream.TryReadUInt(out uint rawLockTime))
{
LockTime lockTime;
lockTime = ParseLockTime(rawLockTime);
returnValue = new Transaction(version, lockTime, inputs, outputs);
}
else
{
throw new InvalidOperationException("The locktime could not be parsed");
}
}
else
{
throw new InvalidOperationException("The number of outputs could not be parsed");
}
}
public async Task FuncWithListParamOutputWorks()
{
Func <string, Func <FuncWithListParamInvokeArgs>, Task> check = (
(expected, args) => Assert
.Output(() => FuncWithListParam.Invoke(args()).Apply(x => x.R))
.ResolvesTo(expected)
);
var lst = new InputList <string>();
lst.Add("e1");
lst.Add("e2");
lst.Add("e3");
// Similarly to dicts, omitted value defaults to null, not empty list.
await check("a=null b=null", () => new FuncWithListParamInvokeArgs());
await check("a=[e1, e2, e3] b=null", () => new FuncWithListParamInvokeArgs()
{
A = lst,
});
await check("a=[e1, e2, e3] b=my-b", () => new FuncWithListParamInvokeArgs()
{
A = lst,
B = Out("my-b"),
});
}
public Joystick(string _name, int _position)
{
name = _name;
position = _position;
input = new InputList(_position);
}
public void SetDefaultInputs()
{
if (InputList.Count == 0 && DefaultInputs.Count > 0)
{
InputList.AddRange(DefaultInputs.Values);
}
}
private void AddMouseInput(MouseButtons button, bool isMouseUp)
{
INPUT input = new INPUT();
input.Type = InputType.InputMouse;
input.Data.Mouse = new MOUSEINPUT();
if (button == MouseButtons.Left)
{
input.Data.Mouse.dwFlags = isMouseUp ? MouseEventFlags.MOUSEEVENTF_LEFTUP : MouseEventFlags.MOUSEEVENTF_LEFTDOWN;
}
else if (button == MouseButtons.Right)
{
input.Data.Mouse.dwFlags = isMouseUp ? MouseEventFlags.MOUSEEVENTF_RIGHTUP : MouseEventFlags.MOUSEEVENTF_RIGHTDOWN;
}
else if (button == MouseButtons.Middle)
{
input.Data.Mouse.dwFlags = isMouseUp ? MouseEventFlags.MOUSEEVENTF_MIDDLEUP : MouseEventFlags.MOUSEEVENTF_MIDDLEDOWN;
}
else if (button == MouseButtons.XButton1)
{
input.Data.Mouse.mouseData = (uint)MouseEventDataXButtons.XBUTTON1;
input.Data.Mouse.dwFlags = isMouseUp ? MouseEventFlags.MOUSEEVENTF_XUP : MouseEventFlags.MOUSEEVENTF_XDOWN;
}
else if (button == MouseButtons.XButton2)
{
input.Data.Mouse.mouseData = (uint)MouseEventDataXButtons.XBUTTON2;
input.Data.Mouse.dwFlags = isMouseUp ? MouseEventFlags.MOUSEEVENTF_XUP : MouseEventFlags.MOUSEEVENTF_XDOWN;
}
InputList.Add(input);
}
private void Button_Click_4(object sender, RoutedEventArgs e)
{
Button button = sender as Button;
Grid grid = button.Parent as Grid;
InputList dc = grid.DataContext as InputList;
if (dc != null)
{
Debug.WriteLine(dc.Name);
((MainWindowViewModel)this.DataContext).AddInput(dc);
}
OutputList dc2 = grid.DataContext as OutputList;
if (dc2 != null)
{
Debug.WriteLine(dc2.Name);
((MainWindowViewModel)this.DataContext).AddOutput(dc2);
}
this.UpdateLayout();
((MainWindowViewModel)this.DataContext).AddedInputPlugins = ((MainWindowViewModel)this.DataContext).AddedInputPlugins;
((MainWindowViewModel)this.DataContext).AddedOutputPlugins = ((MainWindowViewModel)this.DataContext).AddedOutputPlugins;
}
protected override void SetValuesInList()
{
for (int i = 0; i <= k_NumOfInputJumps; i++)
{
InputList.Add((int)(i * k_ValueOfOneJump));
}
}
private void Crosslink()
{
try {
InputList.CrosslinkBrackets();
} catch (Exception ex) {
InputList.ThrowException(ex.Message);
}
}
private void Button_Click_1(object sender, RoutedEventArgs e)
{
var doop = ((Button)sender).DataContext;
InputList woop = (InputList)doop;
woop.Plugin.ShowMonitor();
}
public void SetDefaultInputs()
{
if (!DefaultSet)
{
DefaultSet = true;
InputList.AddRange(DefaultInputs.Values);
}
}
void OnButtonPressed(string _button)
{
if (Delegate != null)
{
InputFieldElement[] _inputList = (InputFieldElement[])InputList.Clone(); //Create a new copy and send as this object will be destroyed
Delegate(_button, _inputList);
}
}
public void ConsoleClear()
{
if (_conTxt != null)
{
_conTxt.text = "";
InputList.Clear();
MsgList.Clear();
}
}
/// <summary>
/// Virtual network address space
/// </summary>
/// <param name="builder">VNet Builder</param>
/// <param name="addressPrefixes">VNet address space</param>
/// <returns></returns>
public static VNetBuilder AddressSpace(this VNetBuilder builder, InputList <string> addressPrefixes)
{
builder.Arguments.AddressSpace = new AddressSpaceArgs
{
AddressPrefixes = addressPrefixes
};
return(builder);
}
public Body this[InputList list] {
get {
if (!inputsListToBody.TryGetValue(list, out Body body))
{
return(null);
}
return(body);
}
}
/// <summary>
/// Remove an input from this block.
/// </summary>
public void RemoveInput(Input input)
{
if (InputList.Contains(input))
{
input.Dispose();
InputList.Remove(input);
FireUpdate(1 << (int)UpdateState.Inputs);
}
}
public void AddMouseWheel(int delta)
{
INPUT input = new INPUT();
input.Type = InputType.InputMouse;
input.Data.Mouse = new MOUSEINPUT();
input.Data.Mouse.dwFlags = MouseEventFlags.MOUSEEVENTF_WHEEL;
input.Data.Mouse.mouseData = (uint)delta;
InputList.Add(input);
}
public void AddMouseMove(int x, int y)
{
INPUT input = new INPUT();
input.Type = InputType.InputMouse;
input.Data.Mouse = new MOUSEINPUT();
input.Data.Mouse.dx = (int)Math.Ceiling((double)(x * 65535) / NativeMethods.GetSystemMetrics(SystemMetric.SM_CXSCREEN)) + 1;
input.Data.Mouse.dy = (int)Math.Ceiling((double)(y * 65535) / NativeMethods.GetSystemMetrics(SystemMetric.SM_CYSCREEN)) + 1;
input.Data.Mouse.dwFlags = MouseEventFlags.MOUSEEVENTF_MOVE | MouseEventFlags.MOUSEEVENTF_ABSOLUTE;
InputList.Add(input);
}
/// <summary>
/// Check whether parent of composite child item is valid.
/// </summary>
/// <param name="inventoryItem">Grouped/Configurable Product/Kit that should be checked</param>
/// <returns>Validation result</returns>
private bool Validate(InventoryItem inventoryItem)
{
List <int> validIds = InputList.Select(validItem => validItem.InventoryID.GetValueOrDefault()).ToList();
//List<int> childIds = new List<int>();
bool result = true;
InventoryItemPCExt itemPCExt = inventoryItem.GetExtension <InventoryItemPCExt>();
if (itemPCExt != null && itemPCExt.UsrKNCompositeType == null)
{
if (itemPCExt.UsrKNCompositeID != null)
{
result = validIds.Contains(itemPCExt.UsrKNCompositeID.Value);
if (!result)
{
return(result);
}
}
if (inventoryItem.StkItem.GetValueOrDefault())
{
PXResultset <INKitSpecStkDet> stockComponents = Graph.StockKitComponentsExisted.Select(inventoryItem.InventoryID);
foreach (INKitSpecStkDet comp in stockComponents)
{
string revisionId = Graph.KitProduct.SelectSingle(comp.KitInventoryID)?.RevisionID;
if (comp.RevisionID == revisionId)
{
result = validIds.Contains(comp.KitInventoryID.Value);
}
if (result)
{
return(result);
}
}
}
else
{
PXResultset <INKitSpecNonStkDet> nonStockComponents = Graph.NonStockKitComponentsExisted.Select(inventoryItem.InventoryID);
foreach (INKitSpecNonStkDet comp in nonStockComponents)
{
string revisionId = Graph.KitProduct.SelectSingle(comp.KitInventoryID)?.RevisionID;
if (comp.RevisionID == revisionId)
{
result = validIds.Contains(comp.KitInventoryID.Value);
}
if (result)
{
return(result);
}
}
}
}
return(result);
}
private bool RemoveInvalidChildren(InventoryItem item)
{
InventoryItemPCExt itemPCExt = item.GetExtension <InventoryItemPCExt>();
string parentCD = null;
bool result = true;
if (itemPCExt != null && itemPCExt.UsrKNCompositeID != null)
{
parentCD = Graph.ItemById.SelectSingle(itemPCExt.UsrKNCompositeID).InventoryCD;
}
if (parentCD != null)
{
result = InputList.Any(x => x.InventoryCD == parentCD);
if (!result)
{
return(result);
}
}
if (item.StkItem.GetValueOrDefault())
{
PXResultset <INKitSpecStkDet> stockComponents = Graph.StockKitComponentsExisted.Select(item.InventoryID);
foreach (INKitSpecStkDet comp in stockComponents)
{
string revisionId = Graph.KitProduct.SelectSingle(comp.KitInventoryID)?.RevisionID;
if (comp.RevisionID == revisionId)
{
result = InputList.Any(x => x.InventoryID == comp.KitInventoryID.Value);
}
if (result)
{
return(result);
}
}
}
else
{
PXResultset <INKitSpecNonStkDet> nonStockComponents = Graph.NonStockKitComponentsExisted.Select(item.InventoryID);
foreach (INKitSpecNonStkDet comp in nonStockComponents)
{
string revisionId = Graph.KitProduct.SelectSingle(comp.KitInventoryID)?.RevisionID;
if (comp.RevisionID == revisionId)
{
result = InputList.Any(x => x.InventoryID == comp.KitInventoryID.Value);
}
if (result)
{
return(result);
}
}
}
return(result);
}
public void Dispose()
{
InputList.Clear();
FieldList.Clear();
foreach (var m in OutputList)
{
m.Dispose();
}
OutputList.Clear();
}
public bool SendInputs()
{
INPUT[] inputList = InputList.ToArray();
uint len = (uint)inputList.Length;
uint successfulInputs = NativeMethods.SendInput(len, inputList, Marshal.SizeOf(typeof(INPUT)));
if (AutoClearAfterSend)
{
ClearInputs();
}
return(successfulInputs == len);
}
/// <summary>
/// Remove an input
/// </summary>
/// <param name="name">Name of the input</param>
public void RemoveInput(string name)
{
if (string.IsNullOrEmpty(name))
{
return;
}
if (InputList.ContainsKey(name))
{
InputList.Remove(name);
}
}
private void AddKeyInput(VirtualKeyCode keyCode, bool isKeyUp)
{
INPUT input = new INPUT();
input.Type = InputType.InputKeyboard;
input.Data.Keyboard = new KEYBDINPUT();
input.Data.Keyboard.wVk = keyCode;
if (isKeyUp)
{
input.Data.Keyboard.dwFlags = KeyboardEventFlags.KEYEVENTF_KEYUP;
}
InputList.Add(input);
}
public override void Handle()
{
base.Handle();
this.Output = true;
InputList.ForEach((bool input) =>
{
if (input)
{
this.Output = false;
}
});
}
/// <summary>
/// Removes an input from the console.
/// This updates the input regex if removed.
/// </summary>
/// <param name="inputName">The name of the input to remove.</param>
/// <returns>true if the input was removed, otherwise false.</returns>
public bool RemoveInput(string inputName)
{
bool removed = ConsoleInputs.Remove(inputName);
if (removed == true)
{
int index = InputList.FindIndex((inpData) => inpData.Name == inputName);
InputList.RemoveAt(index);
UpdateInputRegex();
}
return(removed);
}
public void SetConsoleInputs(Dictionary <string, InputData> consoleInputs)
{
ConsoleInputs = consoleInputs;
if (InputList == null)
{
InputList = new List <InputData>(ConsoleInputs.Count);
}
InputList.Clear();
InputList.AddRange(ConsoleInputs.Values.ToList());
UpdateInputRegex();
}
