public async Task <TValue> AddOrUpdate(
TKey key,
Func <TKey, Task <TValue> > addFactory,
Func <TKey, TValue, Task <TValue> > updateFactory,
CancellationToken token)
{
var keyContent = await KeyConverter.Convert(key, token);
var keyRecord = new KeyRecord(
id: keyContent.GetSha1(),
type: KeyType,
content: keyContent);
var valueRecord = await backedStorage.AddOrUpdate(
keyRecord,
addFactory : async _ =>
{
var value = await addFactory(key);
var content = await ValueConverter.Convert(value, token);
var audit = new Audit(diagnosticContext.CorrelationId, diagnosticContext.User);
return(new ValueRecord(ValueType, content, audit));
},
updateFactory : async(_, old) =>
{
var oldValue = await ValueConverter.Convert(old.Content, token);
var newValue = await updateFactory(key, oldValue);
var content = await ValueConverter.Convert(newValue, token);
var audit = new Audit(diagnosticContext.CorrelationId, diagnosticContext.User);
return(new ValueRecord(ValueType, content, audit));
},
token);
return(await ValueConverter.Convert(valueRecord.Content, token));
}
static void AddAKey()
{
bool loop = true;
while (loop)
{
var key = new KeyRecord();
Console.Write("Name: ");
key.Name = ReadNonEmptyLine();
Console.Write("Key: ");
key.Key = ReadNonEmptyLine();
Console.Write("Note: ");
key.Note = Console.ReadLine();
_keyRecordRepo.Create(key);
Console.Write("Record Created. Add another? (Y) ");
if (Console.ReadLine().ToUpper() != "Y")
{
loop = false;
}
Console.WriteLine();
}
}
public async Task <ValueRecord> AddOrGet(
KeyRecord key,
Func <KeyRecord, Task <ValueRecord> > addFactory,
CancellationToken token)
{
var strategy = options.InsertRetry;
var attempt = 1;
while (true)
{
logger.LogDebug("Storage.AddOrGet({KeyId}): {Attempt} begins.", key.Id, attempt);
if (await FindOne(key, token) is Some <ValueRecord>(var found))
{
return(found);
}
if (await InsertOne(key, addFactory, token) is Some <ValueRecord>(var inserted))
{
return(inserted);
}
attempt++;
if (!strategy.CanRetry(attempt))
{
logger.LogDebug("Storage.AddOrGet({KeyId}): {Attempt} won't proceed.", key.Id, attempt);
break;
}
await Task.Delay(strategy.DelayTime(attempt), token);
}
throw new StorageConcurrencyException();
}
public async Task <ValueRecord> AddOrUpdate(
KeyRecord key,
Func <KeyRecord, Task <ValueRecord> > addFactory,
Func <KeyRecord, ValueRecord, Task <ValueRecord> > updateFactory,
CancellationToken token)
{
var strategy = options.UpsertRetry;
var attempt = 1;
while (true)
{
logger.LogDebug("Storage.AddOrUpdate({KeyId}): {Attempt} begins.", key.Id, attempt);
ValueRecord newValue;
if (await TryGet(key, token) is not Some <ValueRecord>(var currentValue))
{
var addedKey = new MongoKeyRecord(key.Id, key.Type, key.Content);
await InsertOne(keyCollection, addedKey, token);
currentValue = null;
newValue = await addFactory(key);
logger.LogDebug("Storage.AddOrUpdate({KeyId}): {Attempt} adding value.", key.Id, attempt);
}
public static bool update<T>(Func<T, bool> predicate, T i)
{
foreach (var x in KeyRecord.FindAll(item => predicate(JustValue(item))))
{
x.value = i;
}
return true;
}
public void Create(KeyRecord key)
{
using (var connection = new SqliteConnection(_databaseConfig.ConnectionString))
{
connection.Execute(
"INSERT INTO KeyRecords (Name, Key, Note) " +
"VALUES (@Name, @Key, @Note);", key);
}
}
public KeyStep(KeystrokesSettings Settings,
KeyRecord KeyRecord)
{
_settings = Settings;
// TODO: Handle Modifiers keys on KeyUp like in KeyOverlay
Text = KeyRecord.Display;
_mergeable = Text.Length == 1;
}
public async Task <Option <TValue> > TryRemove(TKey key, CancellationToken token)
{
var keyContent = await KeyConverter.Convert(key, token);
var keyRecord = new KeyRecord(
id: keyContent.GetSha1(),
type: KeyType,
content: keyContent);
return(await backedStorage.TryRemove(keyRecord, token).MapOption(x => ValueConverter.Convert(x.Content, token)));
}
public void Update(KeyRecord key)
{
using (var connection = new SqliteConnection(_databaseConfig.ConnectionString))
{
connection.Execute(
"UPDATE KeyRecords SET " +
"Name = @Name, " +
"Key = @Key, " +
"Note = @Note " +
"WHERE rowid = @Id;", key);
}
}
public async Task <Option <TValue> > TryGet(TKey key, long index, CancellationToken token)
{
var keyContent = await keyConverter.Convert(key, token);
var keyRecord = new KeyRecord(
id: keyContent.GetSha1(),
type: keyType,
content: keyContent);
var option = await backedStorage.TryGet(keyRecord, index, token);
return(await option.MapOption(x => valueConverter.Convert(x.Content, token)));
}
private void CreateBtn_Click(object sender, System.EventArgs e)
{
KeyRecord key = rivet.CreateKey(Rivet.KeyType.EcdsaDflt, keyName);
if (key != null)
{
// Toast.makeText(this, key.name + " has been created", ToastLength.Long).Show();
Toast.MakeText(Android.App.Application.Context, key.Name + " has been created", ToastLength.Long).Show();
}
else
{
Toast.MakeText(Android.App.Application.Context, "Error creating key: " + rivet.Status, ToastLength.Long).Show();
}
}
public void doCreateKey(View v)
{
KeyRecord key = rivet.CreateKey(Rivet.KeyType.EcdsaDflt, keyName);
if (key != null)
{
// Toast.makeText(this, key.name + " has been created", ToastLength.Long).Show();
Toast.MakeText(Android.App.Application.Context, key.Name + " has been created", ToastLength.Long).Show();
}
else
{
Toast.MakeText(Android.App.Application.Context, "Error creating key: " + rivet.Status, ToastLength.Long).Show();
}
}
public async Task <long> Add(TKey key, TValue value, CancellationToken token)
{
var keyContent = await keyConverter.Convert(key, token);
var keyRecord = new KeyRecord(
id: keyContent.GetSha1(),
type: keyType,
content: keyContent);
var content = await valueConverter.Convert(value, token);
var audit = new Audit(diagnosticContext.CorrelationId, diagnosticContext.User);
var valueRecord = new ValueRecord(valueType, content, audit);
return(await backedStorage.Add(keyRecord, valueRecord, token));
}
static void EditKey()
{
Console.Write("Enter ID of Key Record: ");
if (!int.TryParse(Console.ReadLine(), out int id))
{
Console.WriteLine("Input Invalid.");
}
else
{
KeyRecord record = _keyRecordRepo.GetSingle(id);
if (record == null)
{
Console.WriteLine("Record not found");
}
else
{
string input;
Console.Write($"Name ({record.Name}): ");
input = Console.ReadLine();
if (!string.IsNullOrWhiteSpace(input))
{
record.Name = input;
}
Console.Write($"Key ({record.Key}): ");
input = Console.ReadLine();
if (!string.IsNullOrWhiteSpace(input))
{
record.Key = input;
}
Console.Write($"Note: ");
input = Console.ReadLine();
if (!string.IsNullOrWhiteSpace(input))
{
record.Note = input;
}
_keyRecordRepo.Update(record);
Console.WriteLine("Record Updated.");
}
}
Console.WriteLine();
}
public async Task <ValueRecord> AddOrGet(
KeyRecord key,
Func <KeyRecord, Task <ValueRecord> > addFactory,
CancellationToken token)
{
var strategy = options.UpsertRetry;
var attempt = 1;
while (true)
{
logger.LogDebug("Storage.AddOrGet({KeyId}): {Attempt} begins.", key.Id, attempt);
if (await TryGet(key, token) is Some <ValueRecord>(var currentValue))
{
logger.LogDebug("Storage.AddOrGet({KeyId}): {Attempt} got value.", key.Id, attempt);
return(currentValue);
}
var addedKey = new MongoKeyRecord(key.Id, key.Type, key.Content);
await InsertOne(keyCollection, addedKey, token);
var newValue = await addFactory(key);
if (await AddValue(key, currentValue: null, newValue, token) is Some <ValueRecord>(var added))
{
logger.LogDebug("Storage.AddOrGet({KeyId}): {Attempt} added initial version.", key.Id, attempt);
return(added);
}
attempt++;
if (!strategy.CanRetry(attempt))
{
logger.LogDebug("Storage.AddOrGet({KeyId}): {Attempt} won't proceed.", key.Id, attempt);
break;
}
await Task.Delay(strategy.DelayTime(attempt), token);
}
throw new StorageConcurrencyException();
}
public void Setup()
{
var mongoClientFactoryMock = new Mock <IMongoClientFactory> {
DefaultValue = DefaultValue.Mock
};
var mongoDatabaseMock = new Mock <IMongoDatabase> {
DefaultValue = DefaultValue.Mock
};
mongoClientFactoryMock.Setup(x => x.GetDatabase()).Returns(mongoDatabaseMock.Object);
MongoCollectionMock = MockCollection <MongoRecord>(mongoDatabaseMock);
TestKey = new KeyRecord(id: Guid.NewGuid().ToString(), type: "key", content: new byte[0]);
Provider = new ServiceCollection()
.AddStorage(b => b
.UseMongo(o => o.ConnectionString = "mongodb://127.0.0.1:27017")
.AddMongo <TestKey, TestValue>())
.ReplaceSingleton(_ => mongoClientFactoryMock.Object)
.BuildServiceProvider();
}
public Task <Option <ValueRecord> > TryGet(KeyRecord key, CancellationToken token) => FindOne(key, token);
public void SaveKeyRecord(KeyRecord rowBlockDet, ITransactionContext tx)
{
_kData.WriteInt64(rowBlockDet.KeyOffset, rowBlockDet.BlockOffset);
_kData.WriteInt64(rowBlockDet.KeyOffset + 8, rowBlockDet.RowCount);
}
public Task <Option <ValueRecord> > TryRemove(KeyRecord key, CancellationToken token) => DeleteOne(key, token);
IObservable <IRecordStep> Observe(IMouseKeyHook Hook, CancellationToken CancellationToken, out IObservable <Unit> ShotObservable)
{
var subject = new Subject <IRecordStep>();
var shotSubject = new Subject <Unit>();
ShotObservable = shotSubject;
void OnNext(IRecordStep NextStep)
{
if (_lastStep != null)
{
if (_lastStep.Merge(NextStep))
{
return;
}
subject.OnNext(_lastStep);
}
shotSubject.OnNext(Unit.Default);
_lastStep = NextStep;
}
Hook.MouseClick += (S, E) =>
{
var step = new MouseClickStep(_mouseClickSettings,
_keystrokesSettings, E,
_keymap);
OnNext(step);
};
Hook.MouseDoubleClick += (S, E) =>
{
var step = new MouseClickStep(_mouseClickSettings,
_keystrokesSettings, E,
_keymap);
OnNext(step);
};
Hook.MouseDragStarted += (S, E) =>
{
var step = new MouseDragBeginStep(E.Location,
_mouseClickSettings,
_keystrokesSettings,
_keymap);
OnNext(step);
};
Hook.MouseDragFinished += (S, E) =>
{
var step = new MouseDragStep(E.Location,
_mouseClickSettings,
_keystrokesSettings,
_keymap);
OnNext(step);
};
if (_stepsSettings.IncludeScrolls)
{
// TODO: Event is not firing for touchpad scroll
Hook.MouseWheel += (S, E) =>
{
var step = new ScrollStep(E,
_mouseClickSettings,
_keystrokesSettings,
_keymap);
OnNext(step);
};
}
Hook.KeyDown += (S, E) =>
{
_modifierSingleDown = false;
var record = new KeyRecord(E, _keymap);
var display = record.Display;
if (display == _keymap.Control ||
display == _keymap.Alt ||
display == _keymap.Shift)
{
_modifierSingleDown = true;
}
else
{
OnNext(new KeyStep(_keystrokesSettings, record));
}
};
Hook.KeyUp += (S, E) =>
{
var record = new KeyRecord(E, _keymap);
var display = record.Display;
if (display == _keymap.Control ||
display == _keymap.Alt ||
display == _keymap.Shift)
{
if (_modifierSingleDown)
{
OnNext(new KeyStep(_keystrokesSettings, record));
}
}
};
CancellationToken.Register(() =>
{
shotSubject.OnCompleted();
subject.OnNext(_lastStep);
subject.OnCompleted();
});
return(subject
.Where(M => _recording));
}
