public IDisposable BindAddCommand(byte[] key, RedisTargetInfo targetInfo)
{
_model.AddCommand = ReactiveCommand.CreateFromObservable(
() => ExecuteAdd(key, targetInfo),
null,
RxApp.MainThreadScheduler);
return(_model.AddCommand
.SubscribeWithLog(wasAdded =>
{
if (wasAdded)
{
ExecuteScanCommand();
UpdateBadge(key, targetInfo);
}
}));
}
private IObservable <List <ZSetStructItemModel> > ExecuteDelete(
byte[] key, RedisTargetInfo targetInfo, List <ZSetStructItemModel> items)
{
return(_dialogManager.Open(new ConfirmDialogModel
{
TitleText = "Delete set entries?",
MessageText = "Do you want to delete selected set entries?",
ConfirmText = "Delete",
CancelText = "Cancel"
})
.SelectMany(confirmed =>
{
if (!confirmed)
{
return Observable.Return(new List <ZSetStructItemModel>());
}
return _clientAccessor.With(targetInfo, client =>
{
var deletedItems = new List <ZSetStructItemModel>();
client.Multi();
try
{
foreach (var item in items)
{
if (item.IsChecked)
{
client.ZRem(ustring.Make(key).ToString(), item.Value);
deletedItems.Add(item);
}
}
client.Exec();
}
catch
{
client.Discard();
throw;
}
return deletedItems;
});
}));
}
private IObservable <(ZSetStructItemModel, ZSetStructItemModel)> ExecuteEdit(
byte[] key, RedisTargetInfo targetInfo, ZSetStructItemModel zsetItem)
{
var editedSetItem = new ZSetStructItemModel
{
Score = zsetItem.Score,
Value = zsetItem.Value,
IsChecked = zsetItem.IsChecked,
IsEnabled = zsetItem.IsEnabled,
CheckAction = zsetItem.CheckAction,
EditAction = zsetItem.EditAction
};
return(_dialogManager.Open(EditorDialogModel.ReplaceZSetItem(
double.Parse(zsetItem.Score), zsetItem.Value, target =>
{
return _clientAccessor.With(targetInfo, client =>
{
var isValueEmpty = string.IsNullOrEmpty(target.Value);
var alreadyExists = !isValueEmpty &&
zsetItem.Score != target.Score.ToString(CultureInfo.InvariantCulture) &&
zsetItem.Value != target.Value &&
client.ZScore(ustring.Make(key).ToString(), target.Value) != null;
if (!isValueEmpty && !alreadyExists)
{
client.Multi();
client.ZRem(ustring.Make(key).ToString(), zsetItem.Value);
client.ZAdd(ustring.Make(key).ToString(), Tuple.Create(target.Score, target.Value));
client.Exec();
editedSetItem.Score = target.Score.ToString(CultureInfo.InvariantCulture);
editedSetItem.Value = target.Value;
}
return new EditorResult
{
ValueError = isValueEmpty
? "Value is empty"
: (alreadyExists ? "Value already exists" : null),
Action = target.Action
};
});
}))
.Select(wasEdited => wasEdited ? (zsetItem, editedSetItem) : (null, null)));
}
public IObservable <RedisResultInfo> Execute(
RedisTargetInfo targetInfo, RedisCommandInfo commandInfo)
{
return(_clientAccessor.With(targetInfo, client =>
{
// TODO: async
return client.Call(commandInfo.Name, commandInfo.Args);
})
.Select(data => RedisResultInfo.MapResult(
targetInfo,
commandInfo,
data))
.Catch <RedisResultInfo, RedisException>(exception => Observable.Return(
new RedisResultInfo.Error(
targetInfo,
commandInfo,
exception))));
}
private IObservable <IList <HashStructItemModel> > ExecuteScan(
byte[] key, RedisTargetInfo targetInfo, string pattern)
{
return(_clientAccessor.With(targetInfo, client => client.HScan(ustring.Make(key).ToString(), 0, pattern)) // TODO: async
.Select(scan =>
{
return scan.Items.Select(tuple =>
new HashStructItemModel
{
Key = tuple.Item1,
Value = tuple.Item2,
IsChecked = false,
IsEnabled = true,
CheckAction = CheckItem,
EditAction = EditItem
}).ToList();
}));
}
private IObservable <(SetStructItemModel, SetStructItemModel)> ExecuteEdit(
byte[] key, RedisTargetInfo targetInfo, SetStructItemModel setItem)
{
var editedSetItem = new SetStructItemModel
{
Value = setItem.Value,
IsChecked = setItem.IsChecked,
IsEnabled = setItem.IsEnabled,
CheckAction = setItem.CheckAction,
EditAction = setItem.EditAction
};
return(_dialogManager.Open(EditorDialogModel.ReplaceSetItem(
setItem.Value, target =>
{
return _clientAccessor.With(targetInfo, client =>
{
var isValueEmpty = string.IsNullOrEmpty(target.Value);
var alreadyExists = !isValueEmpty &&
setItem.Value != target.Value &&
client.SIsMember(ustring.Make(key).ToString(), target.Value);
if (!isValueEmpty && !alreadyExists)
{
client.Multi();
client.SRem(ustring.Make(key).ToString(), setItem.Value);
client.SAdd(ustring.Make(key).ToString(), target.Value);
client.Exec();
editedSetItem.Value = target.Value;
}
return new EditorResult
{
ValueError = isValueEmpty
? "Value is empty"
: (alreadyExists ? "Value already exists" : null),
Action = target.Action
};
});
}))
.Select(wasEdited => wasEdited ? (setItem, editedSetItem) : (null, null)));
}
public IDisposable BindEditCommand(byte[] key, RedisTargetInfo targetInfo)
{
_model.EditCommand = ReactiveCommand.CreateFromObservable <SetStructItemModel, (SetStructItemModel, SetStructItemModel)>(
setItem => ExecuteEdit(key, targetInfo, setItem ?? _model.SetItems.First(item => item.IsChecked)),
_model.WhenAnyValue(m => m.IsEditAvailable),
RxApp.MainThreadScheduler);
return(_model.EditCommand
.SubscribeWithLog(tuple =>
{
var(oldSetItem, newSetItem) = tuple;
if (oldSetItem != null && newSetItem != null)
{
var index = _model.SetItems.IndexOf(oldSetItem);
newSetItem.IsChecked = false;
_model.SetItems[index] = newSetItem;
}
}));
}
public IObservable <RedisResultInfo> Execute(
RedisTargetInfo targetInfo, RedisBatchInfo batchInfo)
{
return(_clientAccessor.With(targetInfo, client =>
{
return Observable.Create <RedisResultInfo>(observer =>
{
foreach (var commandInfo in batchInfo.CommandInfos)
{
try
{
// TODO: async
var data = client.Call(commandInfo.Name, commandInfo.Args);
if (commandInfo.IsExec && batchInfo.IsTransaction)
{
observer.OnNext(
RedisResultInfo.MapResult(
targetInfo, batchInfo, commandInfo, data));
}
else
{
observer.OnNext(
RedisResultInfo.MapResult(
targetInfo, commandInfo, data));
}
}
catch (RedisException e)
{
observer.OnNext(new RedisResultInfo.Error(
targetInfo, commandInfo, e));
}
}
observer.OnCompleted();
return Disposable.Empty;
});
}));
}
public IDisposable BindEditCommand(byte[] key, RedisTargetInfo targetInfo)
{
_model.EditCommand = ReactiveCommand.CreateFromObservable <HashStructItemModel, HashStructItemModel>(
hashItem => ExecuteEdit(key, targetInfo, hashItem ?? _model.HashItems.First(item => item.IsChecked)),
_model.WhenAnyValue(m => m.IsEditAvailable),
RxApp.MainThreadScheduler);
return(_model.EditCommand
.SubscribeWithLog(editedHashItem =>
{
if (editedHashItem != null)
{
var index = _model.HashItems
.Select((item, i) => new { Item = item, Index = i })
.First(tuple => tuple.Item.Key == editedHashItem.Key)
.Index;
editedHashItem.IsChecked = false;
_model.HashItems[index] = editedHashItem;
}
}));
}
private IObservable <string[]> GetQuickAccessItems(
string text)
{
if (!string.IsNullOrWhiteSpace(text) && !text.Contains("*"))
{
text = text.Trim() + "*";
}
RedisTargetInfo targetInfo = null;
if (_model.IsDatabaseTargetSelected)
{
targetInfo = _model.SelectedDatabaseTarget.DatabaseInfo;
}
if (_model.IsServerTargetSelected)
{
targetInfo = _model.SelectedServerTarget.ServerInfo;
}
if (!string.IsNullOrWhiteSpace(text) && targetInfo != null)
{
return(_clientAccessor.With(targetInfo, client =>
{
var scan = client.Scan(0, text);
if (scan != null)
{
var items = scan.Items
.ToArray();
return Observable.Return(items);
}
return Observable.Return(new string[0]);
}));
}
return(Observable.Return(new string[0]));
}
private IObservable <bool> ExecuteAdd(byte[] key, RedisTargetInfo targetInfo)
{
return(_dialogManager.Open(EditorDialogModel.AddSetItem(target =>
{
return _clientAccessor.With(targetInfo, client =>
{
var isValueEmpty = string.IsNullOrEmpty(target.Value);
var isValueDuplicate = !isValueEmpty && client.SIsMember(ustring.Make(key).ToString(), target.Value);
if (!isValueEmpty && !isValueDuplicate)
{
client.SAdd(ustring.Make(key).ToString(), target.Value);
}
return new EditorResult
{
ValueError = isValueEmpty ? "Value is empty"
: (isValueDuplicate ? "Value already exists" : null),
Action = target.Action
};
});
})));
}
public IDisposable BindLength(byte[] key, RedisTargetInfo targetInfo)
{
return(UpdateBadge(key, targetInfo));
}
private IObservable <Unit> SetValue(
RedisTargetInfo targetInfo, byte[] key, string text)
{
return(_clientAccessor.With(targetInfo, client => client.Set(ustring.Make(key).ToString(), text))
.Select(_ => Unit.Default)); // TODO: async
}
private IObservable <string> GetValue(
RedisTargetInfo targetInfo, byte[] key)
{
return(_clientAccessor.With(targetInfo, client => client.Get(ustring.Make(key).ToString()))); // TODO: async
}
