/// <summary>
/// Adds the keys.
/// </summary>
/// <returns>The keys.</returns>
/// <param name="identifier">Identifier.</param>
/// <param name="password">Password.</param>
/// <param name="pkSk">Pk sk.</param>
public async Task <bool> AddKey(SecureString identifier, SecureString password, PkSkDto pkSk)
{
Guard.Argument(identifier, nameof(identifier)).NotNull();
Guard.Argument(password, nameof(password)).NotNull();
Guard.Argument(pkSk, nameof(pkSk)).NotNull();
bool added = false;
using (var insecureIdentifier = identifier.Insecure())
{
try
{
var data = await vaultServiceClient.GetDataAsync(identifier, password, $"wallets/{insecureIdentifier.Value}/wallet");
if (data.Data.TryGetValue("storeKeys", out object keys))
{
((JArray)keys).Add(JObject.FromObject(pkSk));
await vaultServiceClient.SaveDataAsync(identifier, password, $"wallets/{insecureIdentifier.Value}/wallet", data.Data);
added = true;
}
}
catch (Exception ex)
{
logger.LogError(ex.Message);
}
}
return(added);
}
public async Task <string> RandomAddress(SecureString identifier, SecureString password)
{
Guard.Argument(identifier, nameof(identifier)).NotNull();
Guard.Argument(password, nameof(password)).NotNull();
string address = null;
using (var insecureIdentifier = identifier.Insecure())
{
try
{
var vault = await vaultServiceClient.GetDataAsync(identifier, password, $"wallets/{insecureIdentifier.Value}/wallet");
if (vault.Data.TryGetValue(StoreName.StoreKeys.ToString(), out object keys))
{
var rnd = new Random();
var pkSks = ((JArray)keys).ToObject <List <KeySetDto> >();
address = pkSks[rnd.Next(pkSks.Count())].Address;
}
}
catch (Exception ex)
{
logger.LogError(ex.Message);
throw ex;
}
}
return(address);
}
/// <summary>
/// Adds message tracking.
/// </summary>
/// <returns>The message tracking.</returns>
/// <param name="identifier">Identifier.</param>
/// <param name="password">Password.</param>
/// <param name="messageTrack">Message track.</param>
public async Task <bool> AddMessageTracking(SecureString identifier, SecureString password, MessageTrackDto messageTrack)
{
Guard.Argument(identifier, nameof(identifier)).NotNull();
Guard.Argument(password, nameof(password)).NotNull();
Guard.Argument(messageTrack, nameof(messageTrack)).NotNull();
bool added = false;
using (var insecureIdentifier = identifier.Insecure())
{
try
{
var found = false;
var data = await vaultServiceClient.GetDataAsync(identifier, password, $"wallets/{insecureIdentifier.Value}/wallet");
if (data.Data.TryGetValue("track", out object msgs))
{
foreach (JObject item in ((JArray)msgs).Children().ToList())
{
var pk = item.GetValue("PublicKey");
found = pk.Value <string>().Equals(messageTrack.PublicKey);
}
if (!found)
{
((JArray)msgs).Add(JObject.FromObject(messageTrack));
}
else
{
((JArray)msgs).Replace(JObject.FromObject(messageTrack));
}
}
else
{
data.Data.Add("track", new List <MessageTrackDto> {
messageTrack
});
}
await vaultServiceClient.SaveDataAsync(identifier, password, $"wallets/{insecureIdentifier.Value}/wallet", data.Data);
added = true;
}
catch (Exception ex)
{
logger.LogError(ex.Message);
}
}
return(added);
}
/// <summary>
/// Wallet profile Profile.
/// </summary>
/// <returns>The profile.</returns>
/// <param name="identifier">Identifier.</param>
/// <param name="password">Password.</param>
public async Task <string> Profile(SecureString identifier, SecureString password)
{
string profile = null;
try
{
using (var id = identifier.Insecure())
{
var data = await vaultServiceClient.GetDataAsync(identifier, password, $"wallets/{id.Value}/wallet");
profile = JsonConvert.SerializeObject(data);
}
}
catch (Exception ex)
{
logger.LogError(ex.Message);
throw;
}
return(profile);
}
/// <summary>
/// Adds the or replace.
/// </summary>
/// <returns>The or replace.</returns>
/// <param name="session">Session.</param>
/// <param name="name">Name.</param>
/// <param name="key">Key.</param>
/// <param name="value">Value.</param>
public async Task <TaskResult <bool> > AddOrReplace(Session session, TEntity value)
{
Guard.Argument(session, nameof(session)).NotNull();
Guard.Argument(value, nameof(value)).NotNull();
using (await addOrReplaceMutex.LockAsync())
{
try
{
var primaryKey = Util.GetPrimaryKeyName(value);
var vault = await vaultServiceClient.GetDataAsync(session.Identifier, session.MasterKey, $"wallets/{session.Identifier.ToUnSecureString()}/wallet");
if (vault.Data.TryGetValue(store.ToString(), out object d))
{
var wallet = (JArray)d;
var jToken = wallet.FirstOrDefault(x => x.Value <string>(primaryKey) == Util.GetPropertyValue(value, primaryKey));
switch (jToken)
{
case null:
wallet.Add(JObject.FromObject(value));
break;
default:
wallet.RemoveAt(wallet.IndexOf(jToken));
wallet.Add(JObject.FromObject(value));
break;
}
}
else
{
vault.Data.Add(store.ToString(), new List <TEntity> {
value
});
}
await vaultServiceClient.SaveDataAsync(session.Identifier, session.MasterKey, $"wallets/{session.Identifier.ToUnSecureString()}/wallet", vault.Data);
}
catch (Exception ex)
{
logger.LogError(ex.Message);
return(TaskResult <bool> .CreateFailure(ex));
}
}
return(TaskResult <bool> .CreateSuccess(true));
}
