public async Task ExchangeService_CanConstructClient()
{
var InvalidData = new ExchangeExternalServiceData()
{
PublicKey = "test",
PairedDate = DateTime.Now,
};
var externalServiceData = new ExternalServiceData()
{
Type = ExchangeService.ExchangeServiceType,
Name = "something"
};
externalServiceData.Set(InvalidData);
var exchangeService = GetExternalService(externalServiceData);
await Assert.ThrowsAnyAsync <Exception>(async() => await exchangeService.ConstructClient());
var validData = new ExchangeExternalServiceData()
{
PublicKey = "test",
PairedDate = DateTime.Now,
ExchangeName = "Binance",
PrivateKey = "aa"
};
externalServiceData.Set(validData);
Assert.NotNull(exchangeService.ConstructClient());
}
BuildModel(
EditSmtpExternalServiceViewModel viewModel, ExternalServiceData mainModel)
{
if (ModelState.IsValid && !string.IsNullOrEmpty(viewModel.TestEmail))
{
var data = new ExternalServiceData();
data.Set(viewModel);
data.Type = ExternalServiceType;
var smtpService = new SmtpService(data);
var error = await SendTestEmail(smtpService, viewModel.TestEmail);
if (string.IsNullOrEmpty(error))
{
viewModel.TestEmail = string.Empty;
}
else
{
ModelState.AddModelError(nameof(viewModel.TestEmail), error);
}
}
if (!ModelState.IsValid)
{
return(null, viewModel);
}
mainModel.Set(viewModel);
return(mainModel, null);
}
public void ExchangeService_CanInitiate()
{
//import for service discovery to be able to initiate without constructor
_ = new ExchangeService();
Assert.Throws <ArgumentException>(() =>
{
_ = new ExchangeService(new ExternalServiceData()
{
Type = "invalid"
});
});
var data = new ExchangeExternalServiceData()
{
PublicKey = "test",
PairedDate = DateTime.Now
};
var externalServiceData = new ExternalServiceData()
{
Type = ExchangeService.ExchangeServiceType,
Name = "something"
};
externalServiceData.Set(data);
var exchangeService = new ExchangeService(externalServiceData);
Assert.Equal(exchangeService.GetData().PublicKey, data.PublicKey);
Assert.Equal(exchangeService.GetData().PairedDate, data.PairedDate);
}
protected override Task <(ExternalServiceData ToSave, SmtpExternalServiceData showViewModel)> BuildModel(
SmtpExternalServiceData viewModel, ExternalServiceData mainModel)
{
if (!ModelState.IsValid)
{
return(Task.FromResult <(ExternalServiceData ToSave, SmtpExternalServiceData showViewModel)>((null,
viewModel)));
}
mainModel.Set(viewModel);
return(Task.FromResult <(ExternalServiceData ToSave, SmtpExternalServiceData showViewModel)>((mainModel,
null)));
}
public void ExchangeService_CanConstructClient()
{
var data = new ExchangeExternalServiceData()
{
PublicKey = "test",
PairedDate = DateTime.Now
};
var externalServiceData = new ExternalServiceData()
{
Type = ExchangeService.ExchangeServiceType,
Name = "something"
};
externalServiceData.Set(data);
var exchangeService = new ExchangeService(externalServiceData);
Assert.NotNull(exchangeService.ConstructClient());
}
protected override async Task <(ExternalServiceData ToSave, Pop3ExternalServiceData showViewModel)> BuildModel(Pop3ExternalServiceData viewModel, ExternalServiceData mainModel)
{
if (!ModelState.IsValid)
{
return(null, viewModel);
}
mainModel.Set(viewModel);
var imapService = new Pop3Service(mainModel);
var testConnection = await imapService.CreateClientAndConnect();
if (testConnection == null)
{
ModelState.AddModelError(string.Empty, "Could not connect successfully");
return(null, viewModel);
}
testConnection.Dispose();
return(mainModel, null);
}
BuildModel(EditDynamicServiceDataViewModel viewModel, ExternalServiceData mainModel)
{
if (string.IsNullOrEmpty(viewModel.RecipeActionId) && string.IsNullOrEmpty(viewModel.RecipeActionGroupId))
{
ModelState.AddModelError(string.Empty, "please select a recipe action or a recipe action group ");
}
if (!ModelState.IsValid)
{
var recipes = await _recipeManager.GetRecipes(new RecipesQuery()
{
UserId = _userManager.GetUserId(User)
});
var recipe = string.IsNullOrEmpty(viewModel.RecipeId)
? null
: recipes.SingleOrDefault(recipe1 =>
recipe1.Id.Equals(viewModel.RecipeId, StringComparison.InvariantCultureIgnoreCase));
return(null, new EditDynamicServiceDataViewModel()
{
Value = viewModel.Value,
RecipeId = viewModel.RecipeId,
RecipeActionId = viewModel.RecipeActionId,
RecipeActionGroupId = viewModel.RecipeActionGroupId,
Recipes = new SelectList(recipes, nameof(Recipe.Id), nameof(Recipe.Name), viewModel.RecipeId),
RecipeActions = recipe == null? null : new SelectList(recipe.RecipeActions, nameof(RecipeAction.Id), nameof(RecipeAction.ActionId), viewModel.RecipeActionId),
RecipeActionGroups = recipe == null? null : new SelectList(recipe.RecipeActionGroups, nameof(RecipeActionGroup.Id), nameof(RecipeActionGroup.Id), viewModel.RecipeActionGroupId),
});
}
mainModel.Set(viewModel);
return(mainModel, null);
}
public virtual void SetData(T data)
{
_data.Set(data);
}
BuildModel(EditBtcPayServerDataViewModel viewModel, ExternalServiceData mainModel)
{
if (viewModel.Action == "unpair")
{
viewModel.Seed = null;
}
//current External Service data
var oldData = mainModel.Get <BtcPayServerExternalServiceData>();
if (oldData.Seed == viewModel.Seed && oldData.Server == viewModel.Server)
{
viewModel.LastCheck = oldData.LastCheck;
viewModel.MonitoredInvoiceStatuses = oldData.MonitoredInvoiceStatuses;
viewModel.PairedDate = oldData.PairedDate;
}
else
{
viewModel.PairedDate = DateTime.Now;
}
mainModel.Set((BtcPayServerExternalServiceData)viewModel);
var service = new BtcPayServerService(mainModel);
if (!ModelState.IsValid)
{
var serviceData = service.GetData();
return(null, new EditBtcPayServerDataViewModel()
{
Seed = serviceData.Seed ?? new Mnemonic(Wordlist.English, WordCount.Twelve).ToString(),
Server = serviceData.Server,
PairingUrl = await service.GetPairingUrl(mainModel.Name),
Paired = await service.CheckAccess()
});
}
if (!await service.CheckAccess())
{
viewModel.Seed = viewModel.Seed ?? new Mnemonic(Wordlist.English, WordCount.Twelve).ToString();
service.SetData(viewModel);
viewModel.PairingUrl = await service.GetPairingUrl(mainModel.Name);
viewModel.Paired = false;
if (!string.IsNullOrEmpty(viewModel.PairingCode))
{
var client = service.ConstructClient();
await client.AuthorizeClient(new PairingCode(viewModel.PairingCode));
if (!await service.CheckAccess())
{
ModelState.AddModelError(string.Empty, "Could not pair with pairing code");
return(null, viewModel);
}
}
ModelState.AddModelError(string.Empty, "Cannot proceed until paired");
return(null, viewModel);
}
return(mainModel, null);
}
public void SetData(T data)
{
_data.Set(data);
}