/// <summary>
/// Adds a new key to the rollback list
/// </summary>
/// <param name="originalValue">Original value to restore</param>
/// <param name="model">Model to restore</param>
/// <param name="propertyName">Property to restore</param>
public void AddRollback(object originalValue, object model, string propertyName)
{
KeyEntry key = new KeyEntry();
key.SourceObject = originalValue;
key.DestinationObject = model;
key.DestinationProperty = model.GetType().GetProperty(propertyName);
this.Revert.Add(key);
}
public async Task <long> ListDelete(KeyEntry key, List <long> indexes)
{
const string name = "\u0001#removed";
var tran = _db.CreateTransaction();
indexes.ForEach(index => tran.ListSetByIndexAsync(key.FullName, index, name));
var result = tran.ListRemoveAsync(key.FullName, name);
await tran.ExecuteAsync();
return(await result);
}
byte[] PackageValueNameValueCollection(KeyEntry keyEntry, Entry entry, Type type)
{
TreePackage package = new TreePackage();
System.Collections.Specialized.NameValueCollection col = (System.Collections.Specialized.NameValueCollection)entry.Value;
for (int i = 0; i < col.Count; i++)
{
package.Add(i.ToString(), col.GetValues(i));
package.Entries[i.ToString()].Attributes.Add("Key", col.GetKey(i));
}
return(package.Save());
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
KeyEntry.ShouldReturn = (textField) =>
{
KeyEntry.ResignFirstResponder();
string key = KeyEntry.Text;
return(true);
};
}
public async Task <BaseKeyViewModel> Create(KeyEntry key)
{
var(type, ttl) = await key.GetProperties();
return(type switch
{
RedisType.String => new StringViewModel(key, ttl),
RedisType.Set => new UnsortedSetViewModel(key, ttl),
RedisType.Hash => new HashSetViewModel(key, ttl),
RedisType.List => new ListViewModel(key, ttl),
RedisType.SortedSet => new SortedSetViewModel(key, ttl),
_ => throw new ArgumentOutOfRangeException()
});
public async Task <long> ListSave(KeyEntry key, Dictionary <long, RedisValue> existingItems, RedisValue[] newItems)
{
var tran = _db.CreateTransaction();
foreach (var item in existingItems)
{
var _ = tran.ListSetByIndexAsync(key.FullName, item.Key, item.Value);
}
var addResult = tran.ListRightPushAsync(key.FullName, newItems);
await tran.ExecuteAsync();
return(await addResult + existingItems.Count);
}
private void OnGUI()
{
if (currentKey != null)
{
Event e = Event.current;
if (e.isKey)
{
keyDict[(E_Direction)Enum.Parse(typeof(E_Direction), currentKey.name)] = e.keyCode;
currentKey.currentKeyText.text = e.keyCode.ToString();
currentKey = null;
}
}
SaveKeySet();
}
public async Task <long> UnsortedSetSave(KeyEntry key, RedisValue[] removed, RedisValue[] added)
{
var tran = _db.CreateTransaction();
var removeResult = removed.Length > 0
? tran.SetRemoveAsync(key.FullName, removed)
: Task.FromResult(0L);
var addResult = added.Length > 0
? tran.SetAddAsync(key.FullName, added)
: Task.FromResult(0L);
await tran.ExecuteAsync();
return(await removeResult + await addResult);
}
void Start()
{
foreach (E_Direction key in Enum.GetValues(typeof(E_Direction)))
{
keyDict.Add(key, (KeyCode)Enum.Parse(typeof(KeyCode), PlayerPrefs.GetString(key.ToString(), KeyCode.W.ToString())));
}
if (gridArea)
{
foreach (E_Direction key in Enum.GetValues(typeof(E_Direction)))
{
KeyEntry tmp = Instantiate(keyEntry, gridArea.transform);
tmp.Initialize(key, keyDict[key]);
tmp.name = key.ToString();
}
}
}
public JsonResult StoreValue(string Key, string Secret, string Value)
{
try
{
//create a new key entry and store it
KeyEntry entry = new KeyEntry();
entry.Key = Key;
entry.Secret = Secret;
entry.Value = Value;
mRepo.addKeyEntry(entry);
return(Json("Success"));
}
catch (Exception ex) {
return(Json("Error, try again later"));
}
}
byte[] PackageValueArrayData(KeyEntry keyEntry, Entry entry)
{
Type type = entry.Value.GetType();
switch (keyEntry.ArrayType)
{
case PackageArrayTypes.Dictionary:
return(PackageValueDictionary(keyEntry, entry, type));
case PackageArrayTypes.NameValueCollection:
return(PackageValueNameValueCollection(keyEntry, entry, type));
default:
return(PackageValueIEnumerable(keyEntry, entry, type));
}
}
static void UnPackageValueArrayData(KeyEntry keyEntry, Entry entry, byte[] buffer, TreePackage treePackage)
{
switch (keyEntry.ArrayType)
{
case PackageArrayTypes.Dictionary:
UnPackageValueDictionary(keyEntry, entry, buffer);
break;
case PackageArrayTypes.NameValueCollection:
UnPackageValueNameValueCollection(keyEntry, entry, buffer);
break;
default:
UnPackageValueIEnumerable(keyEntry, entry, buffer, treePackage);
break;
}
}
public static bool GetKeyUpCS(IConvertible control_scheme, IConvertible control)
{
List <Entry> entries = I.TryGetEntryList(control_scheme, control);
if (entries == null)
{
return(false);
}
bool answer = false;
foreach (Entry e in entries)
{
KeyEntry ke = e as KeyEntry;
if (ke != null)
{
answer = answer || ke.GetKeyUp();
}
}
return(answer);
}
static System.Collections.IList CreateTArray(KeyEntry keyEntry, int length, bool list, bool isT, Type type)
{
if (type == null)
{
if (isT)
{
type = _valueTypes[keyEntry.ValueType];
}
else
{
type = typeof(object);
}
}
if (list)
{
return((System.Collections.IList)FastWrapper.CreateInstance(typeof(System.Collections.Generic.List <>).MakeGenericType(type), length));
}
else
{
return(Array.CreateInstance(type, length));
}
}
void ReleaseDesignerOutlets()
{
if (CaptureFrontButton != null)
{
CaptureFrontButton.Dispose();
CaptureFrontButton = null;
}
if (CardTypeSegment != null)
{
CardTypeSegment.Dispose();
CardTypeSegment = null;
}
if (KeyEntry != null)
{
KeyEntry.Dispose();
KeyEntry = null;
}
if (ProcessDataButton != null)
{
ProcessDataButton.Dispose();
ProcessDataButton = null;
}
if (BackImageView != null)
{
BackImageView.Dispose();
BackImageView = null;
}
if (FrontImageView != null)
{
FrontImageView.Dispose();
FrontImageView = null;
}
}
static void UnPackageValueData(KeyEntry keyEntry, Entry entry, byte[] buffer, TreePackage treePackage)
{
if (keyEntry.CompressType != PackageCompressTypes.None)
{
if (!_compressors.ContainsKey(keyEntry.CompressType))
{
throw new NotSupportedException("暂不支持“" + keyEntry.CompressType + "”压缩算法。");
}
buffer = _compressors[keyEntry.CompressType](buffer, false);
}
if (keyEntry.ArrayType == PackageArrayTypes.None)
{
if (!_unPakcageValueSingleDataHandlers.ContainsKey(keyEntry.ValueType))
{
throw new NotSupportedException("暂时不支持“" + keyEntry.ValueType + "”类型。");
}
_unPakcageValueSingleDataHandlers[keyEntry.ValueType](keyEntry, entry, buffer);
}
else
{
UnPackageValueArrayData(keyEntry, entry, buffer, treePackage);
}
}
static void UnPackageValueDictionary(KeyEntry keyEntry, Entry entry, byte[] buffer)
{
TreePackage package = Load(buffer);
if (package == null || package.Count == 0)
{
entry.Value = new System.Collections.Hashtable();
return;
}
bool isGeneric = (bool)package.Attributes["IsGeneric"];
System.Collections.IDictionary result = null;
if (isGeneric)
{
Type t1 = FastWrapper.GetWarpperType((string)package.Attributes["T1"]);
Type t2 = FastWrapper.GetWarpperType((string)package.Attributes["T2"]);
object comparer = FastWrapper.Get(typeof(System.Collections.Generic.EqualityComparer <>).MakeGenericType(t1), "Default");
if (package.Attributes.ContainsKey("KeyIsString") && (bool)package.Attributes["KeyIsString"])
{
comparer = (bool)package.Attributes["ComparerIgnoreCase"] ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
}
result = (System.Collections.IDictionary)FastWrapper.CreateInstance(typeof(System.Collections.Generic.Dictionary <,>).MakeGenericType(t1, t2), package.Count, comparer);
}
else
{
result = new System.Collections.Hashtable(package.Count);
}
Entry entry2 = null;
for (int index = 0; index < package.Count; index++)
{
entry2 = package.Entries[index.ToString()];
result.Add(entry2.Attributes["Key"], entry2.Value);
}
entry.Value = result;
}
public void RemoveEntry (KeyEntry entry)
{
if (_privateKeys.Contains (entry)) {
_privateKeys.Remove (entry);
Save ();
RaisePrivateKeyUpdatedEvent ();
return;
}
if (_publicKeys.Contains (entry)) {
_publicKeys.Remove (entry);
Save ();
RaisePublicKeyUpdatedEvent ();
return;
}
}
byte[] PackageValueIEnumerable(KeyEntry keyEntry, Entry entry, Type type)
{
if (Version == 2)
{
if (entry.ArrayType == PackageArrayTypes.T_Array && entry.ValueType == PackageValueTypes.Byte)
{
byte[] buffer1 = entry.Value as byte[];
if (buffer1 != null)
{
return(buffer1);
}
IEnumerable <byte> buffer2 = entry.Value as IEnumerable <byte>;
if (buffer2 != null)
{
buffer1 = LinqHelper.ToArray(buffer2);
if (buffer1 == null)
{
return(new byte[0]);
}
return(buffer1);
}
IEnumerator <byte> buffer3 = entry.Value as IEnumerator <byte>;
if (buffer3 != null)
{
using (buffer3) {
List <byte> buffer3_x = new List <byte>();
while (buffer3.MoveNext())
{
buffer3_x.Add(buffer3.Current);
}
return(buffer3_x.ToArray());
}
}
return(new byte[0]);
}
}
TreePackage package = new TreePackage();
if (entry.ArrayType == PackageArrayTypes.T_Array || entry.ArrayType == PackageArrayTypes.T_List)
{
if (entry.ValueType == PackageValueTypes.Object)
{
Type t1 = null;
if (entry.ArrayType == PackageArrayTypes.T_Array)
{
t1 = entry.Value.GetType().GetElementType();
}
else
{
t1 = entry.Value.GetType();
if (t1.GetGenericArguments().Length == 0)
{
t1 = null;
}
else
{
t1 = t1.GetGenericArguments()[0];
}
}
if (t1 != null)
{
package.Attributes.Add("T1", t1.AssemblyQualifiedName);
}
}
}
int index = -1;
if (IsTheTypes(type, typeof(System.Collections.IEnumerable)))
{
foreach (object item in (System.Collections.IEnumerable)entry.Value)
{
index++;
package.Add(index.ToString(), item);
}
}
else
{
System.Collections.IEnumerator enumerator = (System.Collections.IEnumerator)entry.Value;
System.Collections.Generic.List <object> list = new System.Collections.Generic.List <object>();
while (enumerator.MoveNext())
{
index++;
package.Add(index.ToString(), enumerator.Current);
list.Add(enumerator.Current);
}
IDisposable disp = enumerator as IDisposable;
if (disp != null)
{
disp.Dispose();
}
disp = null;
enumerator = null;
entry.Value = list;
}
return(package.Save());
}
public async Task <bool> SetString(KeyEntry key, string value)
{
return(await _db.StringSetAsync(key.FullName, value));
}
// List operations
public async Task <RedisValue[]> GetListAsync(KeyEntry key)
{
return(await _db.ListRangeAsync(key.FullName));
}
public async Task ListSet(KeyEntry key, long index, RedisValue value)
{
await _db.ListSetByIndexAsync(key.FullName, index, value);
}
// Set operations
public async Task <RedisValue[]> GetUnsortedSetAsync(KeyEntry key)
{
return(await _db.SetMembersAsync(key.FullName));
}
public bool OnKeyRepeated(KeyEventArg arg)
{
KeyEntry entry = new KeyEntry(arg, KeyState.Repeated);
AddKeyEntry(ref entry);
return false;
}
void Remove (KeyEntry entry)
{
if (entry == null)
return;
if (MessageBox.Show (entry.Name + "を削除してもよろしいですか？", "確認", MessageBoxButtons.OKCancel) == DialogResult.OK)
_store.RemoveEntry (entry);
}
void Rename (KeyEntry entry)
{
using (TextInputDialog dlg = new TextInputDialog ("名前の変更", "名前を変更してOKを押してください")) {
dlg.SetDefaultText (entry.Name, true);
if (dlg.ShowDialog () == DialogResult.OK) {
entry.Name = dlg.InputText;
}
}
}
public List <DeltaEntry> Read(string Name, bool isGrouped = false)
{
List <DeltaEntry> deltaEntries = new List <DeltaEntry>();
if (CommonConfig == null || Workbook == null)
{
return(deltaEntries);
}
IXLWorksheet keySheet = Workbook.Worksheets.Worksheet(Name);
IXLRows rows = keySheet.RowsUsed();
bool firstRow = true;
foreach (IXLRow row in rows)
{
if (firstRow)
{
firstRow = false;
continue;
}
DeltaEntry entry = new DeltaEntry();
// Index
IXLCell indexCell = row.Cell("A");
if (string.IsNullOrWhiteSpace(indexCell.GetString()))
{
Logger.Error($"Empty index cell in row {row.RowNumber()}");
continue;
}
ushort index = ushort.MinValue;
try
{
index = indexCell.GetValue <ushort>();
}
catch (FormatException e)
{
Logger.Error($"Unable to parse index '{indexCell.GetString()}' as ushort in row {row.RowNumber()}", e);
continue;
}
entry.Index = index;
//Grouped Delta Entry
if (isGrouped)
{
entry.DataType = KeyEntries.First()
.DataType;
}
else
{
// Map DataType from KeyList
if (KeyEntries == null || KeyEntries.Count == 0)
{
Logger.Error("Cannot parse value of DeltaEntry, because KeyEntries are not available.");
continue;
}
if (KeyEntries.Count < entry.Index)
{
Logger.Error($"Cannot parse value of DeltaEntry, because index [{entry.Index}] of Delta Entry is not available in KeyEntries List (count is {KeyEntries.Count})."
);
continue;
}
KeyEntry keyEntry = KeyEntries[entry.Index];
entry.DataType = keyEntry.DataType;
}
// Orcat
IXLCell orcatCell = row.Cell("B");
if (ParseOrcat(row, orcatCell, out byte?orcatValue) && orcatValue.HasValue)
{
entry.Orcat = orcatValue.Value;
}
// Quality
IXLCell qualityCell = row.Cell("C");
if (ParseQuality(row, qualityCell, out ushort?qualityValue) && qualityValue.HasValue)
{
entry.Quality = qualityValue.Value;
}
// Timestamp
IXLCell timeStampCell = row.Cell("D");
if (ParseTimeStamp(row, timeStampCell, out long?timeStampValue) && timeStampValue.HasValue)
{
entry.TimeStamp = timeStampValue.Value;
}
// Value
IXLCell valueCell = row.Cell("E");
IXLCell value2Cell = row.Cell("F");
IEntry baseEntry = entry;
if (!TryParse(valueCell, value2Cell, ref baseEntry))
{
continue;
}
//Name
if (isGrouped)
{
IXLCell cellName = row.Cell("F");
if (!string.IsNullOrWhiteSpace(cellName.GetString()))
{
try
{
entry.Name = cellName.GetValue <string>();
}
catch (FormatException exception)
{
Logger.Error($"Unable to parse '{qualityCell.GetString()}' in row {row.RowNumber()} as UInt16", exception);
}
}
}
deltaEntries.Add(entry);
}
return(deltaEntries);
}
public void Store(KeyEntry keyEntry)
{
this.keyEntries.Add(keyEntry.Name, keyEntry);
}
public List <KeyEntry> Read(string Name)
{
List <KeyEntry> keyEntries = new List <KeyEntry>();
if (CommonConfig == null || Workbook == null)
{
return(keyEntries);
}
IXLWorksheet keySheet = Workbook.Worksheets.Worksheet(Name);
IXLRows rows = keySheet.RowsUsed();
bool firstRow = true;
foreach (IXLRow row in rows)
{
if (firstRow)
{
firstRow = false;
continue;
}
KeyEntry entry = new KeyEntry();
// Index
IXLCell indexCell = row.Cell("A");
if (string.IsNullOrWhiteSpace(indexCell.GetString()))
{
Logger.Error($"Empty index cell in row {row.RowNumber()}");
continue;
}
ushort index = ushort.MinValue;
try
{
index = indexCell.GetValue <ushort>();
}
catch (FormatException e)
{
Logger.Error($"Unable to parse index '{indexCell.GetString()}' as int in row {row.RowNumber()}", e);
continue;
}
entry.Index = index;
// Name
IXLCell nameCell = row.Cell("B");
if (string.IsNullOrWhiteSpace(nameCell.GetString()))
{
Logger.Error($"Name is empty in row {row.RowNumber()}");
continue;
}
entry.Name = nameCell.GetString();
// Description
IXLCell descriptionCell = row.Cell("C");
if (string.IsNullOrWhiteSpace(descriptionCell.GetString()))
{
Logger.Info($"Description is empty in row {row.RowNumber()}");
}
entry.Description = descriptionCell.GetString();
// DataType
IXLCell dataTypeCell = row.Cell("D");
if (ReadConfiguration.TryGetNodeID(dataTypeCell.GetString(), out NodeID tempID, CommonConfig))
{
entry.DataType = tempID;
}
public ProtectedBinary GetYubikeyResponse(byte Slot, byte ChallengeLength, ProtectedBinary SecretKeyToVerify, bool AllowRecovery)
{
byte[] resp = new byte[YubiWrapper.yubiRespLen];
var Challenge = GetYubikeyChallenge64(ChallengeLength);
YubiSlot slot = YubiSlot.SLOT2;
if (Slot == 1)
{
slot = YubiSlot.SLOT1;
}
var f = new KeyEntry(slot, Challenge, AllowRecovery);
var result = f.ShowDialog();
if (result == DialogResult.OK)
{
f.Response.CopyTo(resp, 0);
Array.Clear(f.Response, 0, f.Response.Length);
bool verified = true;
if (SecretKeyToVerify != null)
{
byte[] SecretKey = SecretKeyToVerify.ReadData();
HMACSHA1 sha1 = new HMACSHA1(SecretKey);
var hash = sha1.ComputeHash(Challenge);
Array.Clear(SecretKey, 0, SecretKey.Length);
if (hash == null || resp == null || hash.Length == 0)
{
verified = false;
}
else
{
for (int i = 0; i < hash.Length; i++)
{
if (hash[i] != resp[i])
{
verified = false;
break;
}
}
}
Array.Clear(hash, 0, hash.Length);
}
ProtectedBinary respProtected = new ProtectedBinary(true, resp);
Array.Clear(resp, 0, resp.Length);
if (!verified)
{
return(null);
}
return(respProtected);
}
else if (f.RecoveryMode)
{
var recovery = new RecoveryKeyFrm();
if (recovery.ShowDialog() != DialogResult.OK)
{
return(null);
}
return(recovery.Key);
}
return(null);
}
public async Task <long> ListRightPush(KeyEntry key, RedisValue value)
{
return(await _db.ListRightPushAsync(key.FullName, value));
}
private void AddKeyEntry(ref KeyEntry arg)
{
m_keyEntries.Add(arg);
m_changed = true;
}
public void KeyEntry_NotEquals()
{
var key = new KeyEntry(new KerberosKey(password: "******"));
Assert.IsFalse(key.Equals(123));
}
protected BaseKeyViewModel(KeyEntry key, TimeSpan?ttl)
{
Key = key;
Properties = CreatePropertiesViewModel(ttl);
}
private void AddKeyEntry(ref KeyEntry arg)
{
m_keyEntries.Add(arg);
m_changed = true;
}
public async Task UnsortedSetRemove(KeyEntry key, params RedisValue[] values)
{
await _db.SetRemoveAsync(key.FullName, values);
}
