public UnitOfWork(DataContext context)
{
_context = context;
Stores = new StoreRepository(_context);
Products = new ProductRepository(_context);
HasA = new HasARepository(_context);
}
//
// GET: /Store/
public ActionResult Index()
{
var data = new StoreFront();
using (var db = new StoreRepository())
{
data.Categories = db.GetCategories(1);
var prodgroup = new ProductsGroup();
prodgroup.Displayname = "Display ID One";
prodgroup.Products = db.GetProductsByInterest(1);
data.ProductsByInterestsList.Add(prodgroup);
prodgroup = new ProductsGroup();
prodgroup.Displayname = "Display ID Two";
prodgroup.Products = db.GetProductsByInterest(2);
data.ProductsByInterestsList.Add(prodgroup);
prodgroup = new ProductsGroup();
prodgroup.Displayname = "Display ID Three";
prodgroup.Products = db.GetProductsByInterest(3);
data.ProductsByInterestsList.Add(prodgroup);
}
return View(data);
}
public AccountService(RequestContext c,
UserAccountRepository userAccounts,
AuthTokenRepository authTokens,
ApiKeyRepository apiKeys,
StoreUserRelationshipRepository adminUsersXStores,
StoreRepository stores)
{
context = c;
AdminUsers = userAccounts;
AuthTokens = authTokens;
ApiKeys = apiKeys;
AdminUsersXStores = adminUsersXStores;
Stores = stores;
}
/// <summary>
/// Creates a new instance of the store presenter
/// </summary>
/// <param name="view">View to bind to</param>
public StorePresenter(IViewStore view)
{
// Bind to all view events
_view = view;
_view.Add += View_Add;
_view.Get += View_Get;
_view.GetAll += View_GetAll;
_view.Remove += View_Remove;
_view.Edit += View_Edit;
_view.Update += View_Update;
// Create new repository
var sessionFactManager = new SessionFactoryManager();
SessionContext = new SessionContext(sessionFactManager);
_storeRepository = new StoreRepository<Store>(SessionContext);
}
public async Task ShouldCallDeleteAsyncWithRequestRevision_WhenGivenAnIdAndExistingStoreModelWithRequestRevision()
{
// Arrange
var id = "/test";
var revisionContext = new RevisionContext
{
RequestRevision = Guid.NewGuid()
};
var databaseIntegratorMock = GetDataIntegratorMock(1);
var storeRepository = new StoreRepository(databaseIntegratorMock.Object, revisionContext);
// Act
await storeRepository.DeleteAsync(id, default);
// Aseert
databaseIntegratorMock.Verify(integrator => integrator.DeleteAsync(id, revisionContext.RequestRevision, default), Times.Once);
}
public LightningAutomatedPayoutProcessor(
BTCPayNetworkJsonSerializerSettings btcPayNetworkJsonSerializerSettings,
LightningClientFactoryService lightningClientFactoryService,
IEnumerable <IPayoutHandler> payoutHandlers,
UserService userService,
ILoggerFactory logger, IOptions <LightningNetworkOptions> options,
StoreRepository storeRepository, PayoutProcessorData payoutProcesserSettings,
ApplicationDbContextFactory applicationDbContextFactory, BTCPayNetworkProvider btcPayNetworkProvider) :
base(logger, storeRepository, payoutProcesserSettings, applicationDbContextFactory,
btcPayNetworkProvider)
{
_btcPayNetworkJsonSerializerSettings = btcPayNetworkJsonSerializerSettings;
_lightningClientFactoryService = lightningClientFactoryService;
_userService = userService;
_options = options;
_payoutHandler = (LightningLikePayoutHandler)payoutHandlers.FindPayoutHandler(PaymentMethodId);
_network = _btcPayNetworkProvider.GetNetwork <BTCPayNetwork>(_PayoutProcesserSettings.GetPaymentMethodId().CryptoCode);
}
public void TestLog2222()
{
var s = new StoreRepository(dbContext);
var laptopBilgisayar = s.GetSingle(5); var store = laptopBilgisayar;
// var loginSeaTechnology = s.GetSingle(9); var store = loginSeaTechnology;
try
{
var scopes = new[]
{
DriveService.Scope.Drive,
DriveService.Scope.DriveFile
};
var p12File = String.Format("{0}/{1}", @"C:\Users\Yuce\Documents\GitHub\StoreManagement\StoreManagement\StoreManagement.Admin\App_Data\GoogleDrive", store.GoogleDriveCertificateP12FileName);
//string p12File = Path.Combine(GetImportPath(), store.GoogleDriveCertificateP12FileName);
X509Certificate2 certificate = new X509Certificate2(p12File,
store.GoogleDrivePassword, X509KeyStorageFlags.Exportable);
ServiceAccountCredential credential = new ServiceAccountCredential(
new ServiceAccountCredential.Initializer(store.GoogleDriveServiceAccountEmail)
{
Scopes = scopes,
User = store.GoogleDriveUserEmail
}.FromCertificate(certificate));
// Create the service.
var service = new DriveService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "StoreManagement"
});
var listReq = service.Files.List();
FileList files = listReq.Execute();
Console.WriteLine(files.Items.Count());
}
catch (Exception ex)
{
Console.WriteLine("Error " + ex.Message);
}
}
public void DeleteById()
{
try
{
var options = CreateNewContextOptions(); using (var db = new StoreContext(options))
{
var repository = new StoreRepository(db);
StoreTestHelper.PopulateDefaultStoreDataCtx(db);
var item = GenerateModel();
Assert.DoesNotThrow(() => repository.Save(item));
Assert.DoesNotThrow(() => repository.Delete(item.Id));
}
}
catch (Exception ex)
{
LogEventManager.Logger.Error(ex);
throw;
}
}
public MainNav(
AppService appService,
StoreRepository storeRepo,
UIStoresController storesController,
BTCPayNetworkProvider networkProvider,
UserManager <ApplicationUser> userManager,
PaymentMethodHandlerDictionary paymentMethodHandlerDictionary,
CustodianAccountRepository custodianAccountRepository,
PoliciesSettings policiesSettings)
{
_storeRepo = storeRepo;
_appService = appService;
_userManager = userManager;
_networkProvider = networkProvider;
_storesController = storesController;
_paymentMethodHandlerDictionary = paymentMethodHandlerDictionary;
_custodianAccountRepository = custodianAccountRepository;
PoliciesSettings = policiesSettings;
}
public StoresController(
IServiceProvider serviceProvider,
BTCPayServerOptions btcpayServerOptions,
BTCPayServerEnvironment btcpayEnv,
StoreRepository repo,
TokenRepository tokenRepo,
UserManager <ApplicationUser> userManager,
AccessTokenController tokenController,
BTCPayWalletProvider walletProvider,
BTCPayNetworkProvider networkProvider,
RateFetcher rateFactory,
ExplorerClientProvider explorerProvider,
LanguageService langService,
PaymentMethodHandlerDictionary paymentMethodHandlerDictionary,
SettingsRepository settingsRepository,
IAuthorizationService authorizationService,
EventAggregator eventAggregator,
AppService appService,
WebhookNotificationManager webhookNotificationManager,
IDataProtectionProvider dataProtector,
NBXplorerDashboard Dashboard)
{
_RateFactory = rateFactory;
_Repo = repo;
_TokenRepository = tokenRepo;
_UserManager = userManager;
_LangService = langService;
_TokenController = tokenController;
_WalletProvider = walletProvider;
_paymentMethodHandlerDictionary = paymentMethodHandlerDictionary;
_settingsRepository = settingsRepository;
_authorizationService = authorizationService;
_appService = appService;
DataProtector = dataProtector.CreateProtector("ConfigProtector");
WebhookNotificationManager = webhookNotificationManager;
_EventAggregator = eventAggregator;
_NetworkProvider = networkProvider;
_ExplorerProvider = explorerProvider;
_ServiceProvider = serviceProvider;
_BtcpayServerOptions = btcpayServerOptions;
_BTCPayEnv = btcpayEnv;
_Dashboard = Dashboard;
}
public ActionResult Upsert(int storeId, int?id)
{
StoreOfflineModel model = null;
try
{
using (var repository = new StoreRepository())
{
model = repository.FindStoreOfflineModelById(storeId, id);
ViewBag.StartDateTime = id.HasValue ? model.UtcStartDateTimeSaved.ToString(SharedConstants.DATE_TIME_FORMAT) : DateTime.UtcNow.ToString(SharedConstants.DATE_TIME_FORMAT);
ViewBag.Model = JsonConvert.SerializeObject(model);
}
}
catch (Exception ex)
{
SharedLogger.LogError(ex, id);
}
return(View(model));
}
public ActionResult SaveOrEdit(Store store, HttpPostedFileBase certUpload = null)
{
ViewBag.StorePageDesigns = StorePageDesignRepository.GetActiveStoreDesings();
ViewBag.StoreCategories = CategoryRepository.GetCategoriesByType(StoreConstants.StoreType);
if (ModelState.IsValid)
{
store.CreatedDate = DateTime.Now;
if (certUpload != null)
{
store.GoogleDriveCertificateP12FileName = Path.GetFileName(certUpload.FileName);
store.GoogleDriveCertificateP12RawData = GeneralHelper.ToByteArray(certUpload);
}
else
{
if (store.Id != 0)
{
// var oldStore = StoreRepository.GetSingle(store.Id);
// store.GoogleDriveCertificateP12RawData = oldStore.GoogleDriveCertificateP12RawData;
}
}
if (store.Id == 0)
{
store.UpdatedDate = DateTime.Now;
store.CreatedDate = DateTime.Now;
StoreRepository.Add(store);
}
else
{
StoreRepository.Edit(store);
store.UpdatedDate = DateTime.Now;
}
StoreRepository.SaveStore();
return(RedirectToAction("Index"));
}
else
{
return(View(store));
}
}
public PaymentRequestController(
InvoiceController invoiceController,
UserManager <ApplicationUser> userManager,
StoreRepository storeRepository,
PaymentRequestRepository paymentRequestRepository,
PaymentRequestService paymentRequestService,
EventAggregator eventAggregator,
CurrencyNameTable currencies,
InvoiceRepository invoiceRepository)
{
_InvoiceController = invoiceController;
_UserManager = userManager;
_StoreRepository = storeRepository;
_PaymentRequestRepository = paymentRequestRepository;
_PaymentRequestService = paymentRequestService;
_EventAggregator = eventAggregator;
_Currencies = currencies;
_InvoiceRepository = invoiceRepository;
}
public StoresController(
StoreRepository repo,
TokenRepository tokenRepo,
CallbackController callbackController,
UserManager <ApplicationUser> userManager,
AccessTokenController tokenController,
BTCPayWallet wallet,
BTCPayNetworkProvider networkProvider,
IHostingEnvironment env)
{
_Repo = repo;
_TokenRepository = tokenRepo;
_UserManager = userManager;
_TokenController = tokenController;
_Wallet = wallet;
_Env = env;
_Network = networkProvider.GetNetwork("BTC").NBitcoinNetwork;
_CallbackController = callbackController;
}
public UILightningLikePayoutController(ApplicationDbContextFactory applicationDbContextFactory,
UserManager <ApplicationUser> userManager,
BTCPayNetworkJsonSerializerSettings btcPayNetworkJsonSerializerSettings,
IEnumerable <IPayoutHandler> payoutHandlers,
BTCPayNetworkProvider btcPayNetworkProvider,
StoreRepository storeRepository,
LightningClientFactoryService lightningClientFactoryService,
IOptions <LightningNetworkOptions> options, IAuthorizationService authorizationService)
{
_applicationDbContextFactory = applicationDbContextFactory;
_userManager = userManager;
_btcPayNetworkJsonSerializerSettings = btcPayNetworkJsonSerializerSettings;
_payoutHandlers = payoutHandlers;
_btcPayNetworkProvider = btcPayNetworkProvider;
_lightningClientFactoryService = lightningClientFactoryService;
_options = options;
_storeRepository = storeRepository;
_authorizationService = authorizationService;
}
public async Task <IActionResult> ListWebhooks(string storeId, string webhookId)
{
if (webhookId is null)
{
return(Ok((await StoreRepository.GetWebhooks(CurrentStoreId))
.Select(o => FromModel(o, false))
.ToArray()));
}
else
{
var w = await StoreRepository.GetWebhook(CurrentStoreId, webhookId);
if (w is null)
{
return(WebhookNotFound());
}
return(Ok(FromModel(w, false)));
}
}
/// <summary>
/// Makes a sale request.
/// </summary>
/// <param name="items">Items to be sold</param>
/// <param name="installments">Number of installments</param>
/// <param name="card">Customer credit card</param>
/// <param name="operatorIndex">Index of the operator</param>
public void MakeRequest(IEnumerable <AntiFraud.Item> items, int installments, Operators.CreditCard card, int operatorIndex)
{
if (operatorIndex > Store.Operators.Count() - 1)
{
throw new InvalidOperationException("Invalid operator!");
}
// Creates the transaction
var amount = items.Sum(i => i.ItemValue * i.Qty);
var transaction = new Operators.Transaction(amount, card, installments);
var orderId = Guid.NewGuid().ToString();
// Check AntiFraud
if (evaluateAntiFraud(items, transaction, orderId))
{
// Makes request to the operator
var request = new Operators.Request(transaction, orderId);
Operators.Response response;
var op = Store.Operators.ElementAt(operatorIndex);
switch (op.Brand)
{
case OperatorBrandEnum.Cielo:
response = RequestManager.MakeCieloRequest(request);
break;
case OperatorBrandEnum.Stone:
response = RequestManager.MakeStoneRequest(request, Store.MerchantId);
break;
default:
throw new NotImplementedException("Unknown operator!");
}
handleOperatorResponse(response);
}
else
{
transaction.Authorized = false;
transaction.Message = "Transaction denied by the anti-fraud system.";
StoreRepository.SaveTransaction(transaction);
}
}
protected virtual async Task UpdatePickUpAddress(Overture.ServiceModel.Orders.Cart cart, PickUpAddressViewModel pickUpAddressViewModel)
{
if (pickUpAddressViewModel == null || pickUpAddressViewModel.PickUpLocationId == Guid.Empty)
{
return;
}
var shipment = cart.Shipments.FirstOrDefault();
if (shipment == null)
{
return;
}
shipment.PickUpLocationId = pickUpAddressViewModel.PickUpLocationId;
shipment.FulfillmentLocationId = pickUpAddressViewModel.PickUpLocationId;
var store = await StoreRepository.GetStoreAsync(new Store.Parameters.GetStoreParam
{
Id = pickUpAddressViewModel.PickUpLocationId,
CultureInfo = new CultureInfo(cart.CultureName),
Scope = cart.ScopeId
}).ConfigureAwait(false);
var storeAddress = store.FulfillmentLocation.Addresses.FirstOrDefault();
var address = new Address
{
AddressName = store.Name,
City = storeAddress.City,
CountryCode = storeAddress.CountryCode,
FirstName = cart.Customer.FirstName,
LastName = cart.Customer.LastName,
Line1 = storeAddress.Line1,
Line2 = storeAddress.Line2,
PhoneNumber = storeAddress.PhoneNumber,
PostalCode = storeAddress.PostalCode,
RegionCode = storeAddress.RegionCode,
PropertyBag = storeAddress.PropertyBag
};
shipment.Address = address;
}
public StoresController(
StoreRepository repo,
TokenRepository tokenRepo,
UserManager <ApplicationUser> userManager,
AccessTokenController tokenController,
BTCPayWalletProvider walletProvider,
BTCPayNetworkProvider networkProvider,
ExplorerClientProvider explorerProvider,
IHostingEnvironment env)
{
_Repo = repo;
_TokenRepository = tokenRepo;
_UserManager = userManager;
_TokenController = tokenController;
_WalletProvider = walletProvider;
_Env = env;
_NetworkProvider = networkProvider;
_ExplorerProvider = explorerProvider;
}
public StoresController(
IServiceProvider serviceProvider,
BTCPayServerOptions btcpayServerOptions,
BTCPayServerEnvironment btcpayEnv,
StoreRepository repo,
TokenRepository tokenRepo,
UserManager <ApplicationUser> userManager,
AccessTokenController tokenController,
BTCPayWalletProvider walletProvider,
BTCPayNetworkProvider networkProvider,
RateFetcher rateFactory,
ExplorerClientProvider explorerProvider,
LanguageService langService,
PaymentMethodHandlerDictionary paymentMethodHandlerDictionary,
SettingsRepository settingsRepository,
IAuthorizationService authorizationService,
EventAggregator eventAggregator,
CssThemeManager cssThemeManager,
AppService appService,
IWebHostEnvironment webHostEnvironment,
WebhookNotificationManager webhookNotificationManager)
{
_RateFactory = rateFactory;
_Repo = repo;
_TokenRepository = tokenRepo;
_UserManager = userManager;
_LangService = langService;
_TokenController = tokenController;
_WalletProvider = walletProvider;
_paymentMethodHandlerDictionary = paymentMethodHandlerDictionary;
_settingsRepository = settingsRepository;
_authorizationService = authorizationService;
_CssThemeManager = cssThemeManager;
_appService = appService;
_webHostEnvironment = webHostEnvironment;
WebhookNotificationManager = webhookNotificationManager;
_EventAggregator = eventAggregator;
_NetworkProvider = networkProvider;
_ExplorerProvider = explorerProvider;
_ServiceProvider = serviceProvider;
_BtcpayServerOptions = btcpayServerOptions;
_BTCPayEnv = btcpayEnv;
}
public void GetProductsAllTest()
{
var mockSet = new Mock <DbSet <Product> >();
mockSet.As <IQueryable <Product> >().Setup(m => m.Provider).Returns(products.Provider);
mockSet.As <IQueryable <Product> >().Setup(m => m.Expression).Returns(products.Expression);
mockSet.As <IQueryable <Product> >().Setup(m => m.ElementType).Returns(products.ElementType);
mockSet.As <IQueryable <Product> >().Setup(m => m.GetEnumerator()).Returns(products.GetEnumerator());
var mockContext = new Mock <DataContext>();
mockContext.Setup(c => c.Products).Returns(mockSet.Object);
//Act
var repository = new StoreRepository(mockContext.Object);
var actual = repository.GetProducts();
Assert.Equal(6, actual.Count());
Assert.Equal("apple", actual.First().ProductName);
}
public StoresController(
IServiceProvider serviceProvider,
BTCPayServerOptions btcpayServerOptions,
BTCPayServerEnvironment btcpayEnv,
StoreRepository repo,
TokenRepository tokenRepo,
UserManager <ApplicationUser> userManager,
AccessTokenController tokenController,
BTCPayWalletProvider walletProvider,
BTCPayNetworkProvider networkProvider,
RateFetcher rateFactory,
ExplorerClientProvider explorerProvider,
IFeeProviderFactory feeRateProvider,
LanguageService langService,
ChangellyClientProvider changellyClientProvider,
IWebHostEnvironment env, IHttpClientFactory httpClientFactory,
PaymentMethodHandlerDictionary paymentMethodHandlerDictionary,
SettingsRepository settingsRepository,
IAuthorizationService authorizationService,
CssThemeManager cssThemeManager)
{
_RateFactory = rateFactory;
_Repo = repo;
_TokenRepository = tokenRepo;
_UserManager = userManager;
_LangService = langService;
_changellyClientProvider = changellyClientProvider;
_TokenController = tokenController;
_WalletProvider = walletProvider;
_Env = env;
_httpClientFactory = httpClientFactory;
_paymentMethodHandlerDictionary = paymentMethodHandlerDictionary;
_settingsRepository = settingsRepository;
_authorizationService = authorizationService;
_CssThemeManager = cssThemeManager;
_NetworkProvider = networkProvider;
_ExplorerProvider = explorerProvider;
_FeeRateProvider = feeRateProvider;
_ServiceProvider = serviceProvider;
_BtcpayServerOptions = btcpayServerOptions;
_BTCPayEnv = btcpayEnv;
}
public void ReserveGood()
{
try
{
var options = CreateNewContextOptions(); using (var db = new StoreContext(options))
{
var repository =
new StoreRepository(db);
StoreTestHelper.PopulateDefaultStoreDataCtx(db);
var item = db.Set <StoreM>().First();
var good = db.Set <Good>().First();
Assert.DoesNotThrow(() => repository.ReserveGood(item, good));
}
}
catch (Exception ex)
{
LogEventManager.Logger.Error(ex);
throw;
}
}
public void ShouldThrowRecordAlreadyExistsException_WhenStoreModelIsValidAndIdIsAlreadyInUse()
{
// Arrange
var id = "/test";
var json = "{ \"myValue\": \"test\" }";
var payload = JsonDocument.Parse(json).RootElement;
var storeModel = new StoreModel(id, payload);
var revisionContext = new RevisionContext();
var databaseIntegratorMock = GetDataIntegratorMock(0);
var storeRepository = new StoreRepository(databaseIntegratorMock.Object, revisionContext);
// Act
Func <Task> result = () => storeRepository.CreateAsync(storeModel, default);
// Aseert
result.Should().Throw <RecordAlreadyExistsException>();
}
public void GetGoodByArticul()
{
try
{
var options = CreateNewContextOptions(); using (var db = new StoreContext(options))
{
var repository =
new StoreRepository(db);
StoreTestHelper.PopulateDefaultStoreDataCtx(db);
var item = db.Set <Good>().First();
Assert.DoesNotThrow(() => item = repository.GetGoodByArticul(1, item.Articul));
}
}
catch (Exception ex)
{
LogEventManager.Logger.Error(ex);
throw;
}
}
public UILNURLController(InvoiceRepository invoiceRepository,
EventAggregator eventAggregator,
BTCPayNetworkProvider btcPayNetworkProvider,
LightningLikePaymentHandler lightningLikePaymentHandler,
StoreRepository storeRepository,
AppService appService,
UIInvoiceController invoiceController,
LinkGenerator linkGenerator,
LightningAddressService lightningAddressService)
{
_invoiceRepository = invoiceRepository;
_eventAggregator = eventAggregator;
_btcPayNetworkProvider = btcPayNetworkProvider;
_lightningLikePaymentHandler = lightningLikePaymentHandler;
_storeRepository = storeRepository;
_appService = appService;
_invoiceController = invoiceController;
_linkGenerator = linkGenerator;
_lightningAddressService = lightningAddressService;
}
public void repository_should_save_user()
{
var eventStore = Substitute.For<IEventStore>();
var cache = new RepositoryCache();
StoreRepository repository = new StoreRepository(eventStore, cache, new AggregateFactory());
IEnumerable<DomainEvent> eventsToSave = null;
eventStore.WhenForAnyArgs(i => i.SaveEvents(null, Guid.Empty)).Do(i => eventsToSave = i.Arg<IEnumerable<DomainEvent>>());
var user = User.CreateUser(FakeUser.TestLogin, FakeUser.TestPassword, new IdentityGenerator());
repository.Save(user, Guid.NewGuid());
cache.Get(user.Id).Should().Be(user);
var userCreated = eventsToSave.First().As<EventStore.Messages.UserEvents.Created>();
userCreated.Should().NotBeNull();
userCreated.Login.Should().Be(FakeUser.TestLogin);
}
public async Task ShouldNotSetResponseRevisionInRevisionContext_WhenGivenAnIdAndNoExistingStoreModel()
{
// Arrange
var id = "/test";
var revisionContext = new RevisionContext();
var databaseIntegratorMock = GetDataIntegratorMock(null);
var storeRepository = new StoreRepository(databaseIntegratorMock.Object, revisionContext);
// Act
try
{
var result = await storeRepository.ReadAsync(id, default);
}
catch { }
// Assert
revisionContext.ResponseRevision.Should().BeNull();
}
public async Task ShouldSetResponseRevisionInRevisionContext_WhenStoreModelIsValid()
{
// Arrange
var id = "/test";
var json = "{ \"myValue\": \"test\" }";
var payload = JsonDocument.Parse(json).RootElement;
var storeModel = new StoreModel(id, payload);
var revisionContext = new RevisionContext();
var databaseIntegratorMock = GetDataIntegratorMock(1);
var storeRepository = new StoreRepository(databaseIntegratorMock.Object, revisionContext);
// Act
await storeRepository.CreateAsync(storeModel, default);
// Aseert
revisionContext.ResponseRevision.Should().Be(_storeEntity.Revision);
}
public ManageController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
UrlEncoder urlEncoder,
TokenRepository tokenRepository,
BTCPayWalletProvider walletProvider,
StoreRepository storeRepository,
IHostingEnvironment env)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
_TokenRepository = tokenRepository;
_Env = env;
_StoreRepository = storeRepository;
}
public PayJoinEndpointController(BTCPayNetworkProvider btcPayNetworkProvider,
InvoiceRepository invoiceRepository, ExplorerClientProvider explorerClientProvider,
StoreRepository storeRepository, BTCPayWalletProvider btcPayWalletProvider,
PayJoinRepository payJoinRepository,
EventAggregator eventAggregator,
NBXplorerDashboard dashboard,
DelayedTransactionBroadcaster broadcaster,
WalletRepository walletRepository)
{
_btcPayNetworkProvider = btcPayNetworkProvider;
_invoiceRepository = invoiceRepository;
_explorerClientProvider = explorerClientProvider;
_storeRepository = storeRepository;
_btcPayWalletProvider = btcPayWalletProvider;
_payJoinRepository = payJoinRepository;
_eventAggregator = eventAggregator;
_dashboard = dashboard;
_broadcaster = broadcaster;
_walletRepository = walletRepository;
}
public EthereumService(
IHttpClientFactory httpClientFactory,
EventAggregator eventAggregator,
StoreRepository storeRepository,
BTCPayNetworkProvider btcPayNetworkProvider,
SettingsRepository settingsRepository,
InvoiceRepository invoiceRepository,
IConfiguration configuration,
PaymentService paymentService) : base(
eventAggregator)
{
_httpClientFactory = httpClientFactory;
_eventAggregator = eventAggregator;
_storeRepository = storeRepository;
_btcPayNetworkProvider = btcPayNetworkProvider;
_settingsRepository = settingsRepository;
_invoiceRepository = invoiceRepository;
_configuration = configuration;
_paymentService = paymentService;
}
public OnChainAutomatedPayoutProcessor(
ApplicationDbContextFactory applicationDbContextFactory,
ExplorerClientProvider explorerClientProvider,
BTCPayWalletProvider btcPayWalletProvider,
BTCPayNetworkJsonSerializerSettings btcPayNetworkJsonSerializerSettings,
ILoggerFactory logger,
BitcoinLikePayoutHandler bitcoinLikePayoutHandler,
EventAggregator eventAggregator,
StoreRepository storeRepository,
PayoutProcessorData payoutProcesserSettings,
BTCPayNetworkProvider btcPayNetworkProvider) :
base(logger, storeRepository, payoutProcesserSettings, applicationDbContextFactory,
btcPayNetworkProvider)
{
_explorerClientProvider = explorerClientProvider;
_btcPayWalletProvider = btcPayWalletProvider;
_btcPayNetworkJsonSerializerSettings = btcPayNetworkJsonSerializerSettings;
_bitcoinLikePayoutHandler = bitcoinLikePayoutHandler;
_eventAggregator = eventAggregator;
}
public void repository_shouldnt_save_users_with_same_id()
{
var eventStore = Substitute.For<IEventStore>();
var identityGenerator = Substitute.For<IIdentityGenerator>();
var guid = Guid.NewGuid();
identityGenerator.NewId().Returns(i => guid);
var cache = new RepositoryCache();
StoreRepository repository = new StoreRepository(eventStore, cache, new AggregateFactory());
var @event = FakeUser.ArrangeCreated();
var user = User.CreateUser(FakeUser.TestLogin, FakeUser.TestPassword, identityGenerator);
repository.Save(user, Guid.NewGuid());
user = User.CreateUser(FakeUser.TestLogin, FakeUser.TestPassword, identityGenerator);
repository.Invoking(i => i.Save(user, Guid.NewGuid())).ShouldThrow<AggregateVersionException>();
}
private void SaveOrderStatus(OrderModelDto model, ResponseRd response)
{
try
{
using (var repository = new StoreRepository())
{
repository.UpdateOrderMode(model.OrderToStoreId, response.Order.orderIdField, response.Order.statusField,
response.Order.modeField, response.Order.modeChargeField, response.Order.promiseTimeField.ToDateTimeSafe());
if (SettingsData.Store.EnableSendEmail)
{
repository.SaveOrderToStoreEmail(model.OrderToStoreId);
}
}
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
}
}
public ServerController(UserManager <ApplicationUser> userManager,
Configuration.BTCPayServerOptions options,
RateFetcher rateProviderFactory,
SettingsRepository settingsRepository,
NBXplorerDashboard dashBoard,
IHttpClientFactory httpClientFactory,
LightningConfigurationProvider lnConfigProvider,
TorServices torServices,
Services.Stores.StoreRepository storeRepository)
{
_Options = options;
_UserManager = userManager;
_SettingsRepository = settingsRepository;
_dashBoard = dashBoard;
HttpClientFactory = httpClientFactory;
_RateProviderFactory = rateProviderFactory;
_StoreRepository = storeRepository;
_LnConfigProvider = lnConfigProvider;
_torServices = torServices;
}
/// <summary>
/// Sync logic for store table
/// </summary>
private void SyncTable_Store()
{
var localTable = new StoreRepository<Store>(_localSessionContext);
var remoteTable = new StoreRepository<Store>(_remoteSessionContext);
OnSyncStart?.Invoke(this, new SyncStartedArgs("Store"));
#region SyncCode
var count = 0;
var total = localTable.Count();
foreach (var row in localTable.GetAll())
{
// Copy object and save (this removes ID)
var newObject = ObjectCopy.Copy(row);
remoteTable.Save(newObject);
// Save changes to remote
remoteTable.Commit();
// Create a sync record this captures the remote ID value
// so we can update any relationships...
var record = new SyncRecord();
record.Table_Id = "store_table";
record.Local_Id = row.Id;
record.Remote_Id = newObject.Id;
_recordRepository.Save(record);
_recordRepository.Commit();
OnUpdateStatus?.Invoke(this, new ProgressEventArgs("Synced entity " + ++count + "/" + total));
// Remove after successful remove
localTable.Remove(row);
localTable.Commit();
}
#endregion
}
public void SetUp()
{
_context = new DataContext();
_store = new Store() {StoreName = "TestStore"};
_storeRepository = new StoreRepository(_context);
_context.Database.Connection.ConnectionString = "Server=.\\SQLEXPRESS;Database=Pristjek220Data.DataContext; Trusted_Connection=True;";
_context.Database.ExecuteSqlCommand("dbo.TestCleanTable");
}
public StoreManagerClient(IStoreManagerEndpoint endpoint)
{
Stores = new StoreRepository(endpoint);
}
