/// <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); }
public async Task UnsortedSetRemove(KeyEntry key, params RedisValue[] values) { await _db.SetRemoveAsync(key.FullName, values); }