public async Task TransactionHistoryApiTest_GetAnException()
{
// Arrange
string terminalId = "LK429486";
string transactionType = "Credit";
MockTransactionHistoryRepository mockTransactionHistoryRepository = new MockTransactionHistoryRepository();
ApiResult <GenericPaginationResponse <TransactionHistory> > expectedResult = mockTransactionHistoryRepository.GetMockData(transactionType);
PaginationTransactionHistory page = mockTransactionHistoryRepository.GetPagination();
IOptions <Settings> optionsAccessor = Substitute.For <IOptions <Settings> >();
ITransactionHistoryRepository mockRepo = Substitute.For <ITransactionHistoryRepository>();
IDistributedCache mockCache = Substitute.For <IDistributedCache>();
ILoggingFacade loggingFacade = Substitute.For <ILoggingFacade>();
ITransactionHistoryApi terminalListApi = Substitute.For <ITransactionHistoryApi>();
terminalListApi.WhenForAnyArgs(x => x.GetTransactionHistoryAsync(Arg.Any <string>(), Arg.Any <PaginationTransactionHistory>())).DoNotCallBase();
mockRepo.GetTransactionHistoryAsync(terminalId, page).Throws(new Exception());
loggingFacade.WhenForAnyArgs(x => x.LogAsync(Arg.Any <LogLevels>(), Arg.Any <string>(), Arg.Any <CancellationToken>())).DoNotCallBase();
terminalListApi = new TransactionHistoryApi(optionsAccessor, mockRepo, loggingFacade);
// Assert
await Assert.ThrowsAsync <Exception>(() => terminalListApi.GetTransactionHistoryAsync(terminalId, page));
}
public TransactionsController(ITeamRepository teamRepository, IParticipantRepository playerRepository,
ITransactionHistoryRepository transactionRepository)
{
TeamRepository = teamRepository;
ParticipantRepository = playerRepository;
TransactionRepository = transactionRepository;
}
//Would be revisiting to modify the actual way of call method.
public void TestTransactionHistoryRepositoryTest_Success()
{
// Arrange
string terminalId = "LK429486";
string transactionType = "Credit";
MockTransactionHistoryRepository mockTransactionHistoryRepository = new MockTransactionHistoryRepository();
ApiResult <GenericPaginationResponse <TransactionHistory> > expectedResult = mockTransactionHistoryRepository.GetMockData(transactionType);
PaginationTransactionHistory page = mockTransactionHistoryRepository.GetPagination();
ILoggingFacade loggingFacade = Substitute.For <ILoggingFacade>();
loggingFacade.WhenForAnyArgs(x => x.LogAsync(Arg.Any <LogLevels>(), Arg.Any <string>(), Arg.Any <CancellationToken>())).DoNotCallBase();
IOptions <DataContext> optionsAccessor = Substitute.For <IOptions <DataContext> >();
IDatabaseConnectionFactory connectionFactory = Substitute.For <IDatabaseConnectionFactory>();
ITransactionHistoryRepository mockRepo = Substitute.For <ITransactionHistoryRepository>();
mockRepo.GetTransactionHistoryAsync(terminalId, page).ReturnsForAnyArgs(expectedResult.Result);
// Act
var terminalList = mockRepo.GetTransactionHistoryAsync(terminalId, page).Result;
var actualRecord = (IList <TransactionHistory>)terminalList.ReturnedRecords;
string merchInfo = actualRecord.Where(x => x.REQ_TRAN_TYPE == transactionType).FirstOrDefault().REQ_AMT;
//// Assert
Assert.Equal(((IList <TransactionHistory>)actualRecord).Count, 1);
Assert.Equal(merchInfo, "589587");
}
public ApplicationUserService(
IApplicationUserRepository applicationUserRepository,
ITransactionHistoryRepository transactionHistoryRepository,
IUnitOfWork unitOfWork)
{
_applicationUserRepository = applicationUserRepository;
_unitOfWork = unitOfWork;
}
public TransformTransactionHistory(
ITransactionHistoryRepository transactionHistoryRepository,
IAlfrescoHttpClient alfrescoHttpClient,
ITransactionHistoryConfiguration transactionHistoryConfiguration)
{
_transactionHistoryRepository = transactionHistoryRepository;
_alfrescoHttpClient = alfrescoHttpClient;
_transactionHistoryConfiguration = transactionHistoryConfiguration;
}
public TransactionHistoryApi(IOptions <Settings> optionsAccessor,
ITransactionHistoryRepository transactionHistoryRepository,
ILoggingFacade loggingFacade)
{
_loggingFacade = loggingFacade;
_loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "Starting Transaction History API Service",
"TransactionHistoryApi.cs", "TransactionHistoryApi"), CancellationToken.None);
_transactionHistoryRepository = transactionHistoryRepository;
}
public TransactionHistoryBusiness(ITransactionRepository __ITransactionRepository,
ILoggerFactory _loggerFactory, IWalletRepository __IWalletRepository, IAccountRepository __IAccountRepository,
ITransactionHistoryRepository __ITransactionHistoryRepository)
{
_ITransactionRepository = __ITransactionRepository;
_logger = _loggerFactory.CreateLogger <TransactionHistoryBusiness>();
_IWalletRepository = __IWalletRepository;
_IAccountRepository = __IAccountRepository;
_ITransactionHistoryRepository = __ITransactionHistoryRepository;
}
public AdminController(ITeamRepository teamRepository, UserManager <User> userManager, ITransactionHistoryRepository transactionHistoryRepository,
IMapper mapper, IEmailSender emailSender, IEmailViewRenderer emailViewRenderer, IOptions <AppSettings> appSettings)
{
UserManager = userManager;
TeamRepository = teamRepository;
TransactionHistoryRepository = transactionHistoryRepository;
Mapper = mapper;
EmailSender = emailSender;
EmailViewRenderer = emailViewRenderer;
AppSettings = appSettings.Value;
}
public StatisticsService(
ITransactionHistoryRepository transactionHistoryRepository,
IBonusCashInsRepository bonusCashInsRepository,
IPartnersPaymentsRepository partnersPaymentsRepository,
string tokenSymbol)
{
_transactionHistoryRepository = transactionHistoryRepository;
_bonusCashInsRepository = bonusCashInsRepository;
_partnersPaymentsRepository = partnersPaymentsRepository;
_tokenSymbol = tokenSymbol;
}
/// <summary>
///
/// </summary>
/// <param name="configuration"></param>
/// <param name="userRepository"></param>
public SalesController(IConfiguration configuration, IUserRepository userRepository,
ITransactionHistoryRepository transactionHistoryRepository)
{
Guardian.AgainstNull(configuration);
Guardian.AgainstNull(userRepository);
Guardian.AgainstNull(transactionHistoryRepository);
this.configuration = configuration;
this.userRepository = userRepository;
this.transactionHistoryRepository = transactionHistoryRepository;
Messages = new List <NotificationMessage>();
}
public TransactionHistoryService(
ILogger <ITransactionHistoryRepository> logger,
ITransactionHistoryRepository transactionHistoryRepository,
IApiTransactionHistoryRequestModelValidator transactionHistoryModelValidator,
IBOLTransactionHistoryMapper boltransactionHistoryMapper,
IDALTransactionHistoryMapper daltransactionHistoryMapper)
: base(logger,
transactionHistoryRepository,
transactionHistoryModelValidator,
boltransactionHistoryMapper,
daltransactionHistoryMapper)
{
}
public AbstractTransactionHistoryService(
ILogger logger,
ITransactionHistoryRepository transactionHistoryRepository,
IApiTransactionHistoryRequestModelValidator transactionHistoryModelValidator,
IBOLTransactionHistoryMapper bolTransactionHistoryMapper,
IDALTransactionHistoryMapper dalTransactionHistoryMapper)
: base()
{
this.TransactionHistoryRepository = transactionHistoryRepository;
this.TransactionHistoryModelValidator = transactionHistoryModelValidator;
this.BolTransactionHistoryMapper = bolTransactionHistoryMapper;
this.DalTransactionHistoryMapper = dalTransactionHistoryMapper;
this.logger = logger;
}
public AuditLogService(
IIdentityUser identityUser,
ITransactionHistoryRepository transactionHistoryRepository,
IAlfrescoModelComparer alfrescoModelComparer,
IMapper mapper,
ITranslateService translationService
)
{
_identityUser = identityUser;
_transactionHistoryRepository = transactionHistoryRepository;
_alfrescoModelComparer = alfrescoModelComparer;
_mapper = mapper;
_translateService = translationService;
}
public CheckoutController(ITeamRepository teamRepository, UserManager <User> userManager,
IOptions <AppSettings> appSettings, IPaymentService paymentService,
ITransactionHistoryRepository transactionHistoryRepository, IEmailViewRenderer emailViewRenderer,
IMapper mapper, IEmailSender emailSender)
{
TeamRepository = teamRepository;
UserManager = userManager;
AppSettings = appSettings.Value;
PaymentService = paymentService;
TransactionHistoryRepository = transactionHistoryRepository;
EmailViewRenderer = emailViewRenderer;
Mapper = mapper;
EmailSender = emailSender;
}
public MatchingEngine(IDictionaryProxy dictionaryProxy,
IAccountInfoRepository accountInfoRepository, IAssetPairQuoteRepository assetPairQuoteRepository,
IMarketOrderRepository marketOrderRepository, IPendingOrderRepository pendingOrderRepository,
ITransactionHistoryRepository transactionHistoryRepository, IOrderCalculator orderCalculator,
IMatchingEngineEventSubscriber matchingEngineEventSubscriber, IOrderBookService orderBookService)
{
_dictionaryProxy = dictionaryProxy;
_accountInfoRepository = accountInfoRepository;
_assetPairQuoteRepository = assetPairQuoteRepository;
_marketOrderRepository = marketOrderRepository;
_pendingOrderRepository = pendingOrderRepository;
_transactionHistoryRepository = transactionHistoryRepository;
_orderCalculator = orderCalculator;
_matchingEngineEventSubscriber = matchingEngineEventSubscriber;
_orderBookService = orderBookService;
}
public TransactionHandlerService(ILogger <ITransactionHandlerService> logger, IOptions <BotConfiguration> botConfiguration,
IMhcHttpClient mhcHttpClient, ITransactionHistoryRepository transactionHistoryRepository,
ITransactionCheckHistoryRepository transactionCheckHistoryRepository,
IWalletUserRepository walletUserRepository, IUserBalanceRepository userBalanceRepository,
IUserBalanceHistoryRepository userBalanceHistoryRepository, IBotService botService)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_botConfiguration = botConfiguration ?? throw new ArgumentNullException(nameof(botConfiguration));
_mhcHttpClient = mhcHttpClient ?? throw new ArgumentNullException(nameof(mhcHttpClient));
_transactionHistoryRepository = transactionHistoryRepository ?? throw new ArgumentNullException(nameof(transactionHistoryRepository));
_transactionCheckHistoryRepository = transactionCheckHistoryRepository ?? throw new ArgumentNullException(nameof(transactionCheckHistoryRepository));
_walletUserRepository = walletUserRepository ?? throw new ArgumentNullException(nameof(walletUserRepository));
_userBalanceRepository = userBalanceRepository ?? throw new ArgumentNullException(nameof(userBalanceRepository));
_userBalanceHistoryRepository = userBalanceHistoryRepository ?? throw new ArgumentNullException(nameof(userBalanceHistoryRepository));
_botService = botService ?? throw new ArgumentNullException(nameof(botService));
}
public BookingService(
IBookingRepository bookingRepository,
ICarRepository carRepository,
IUserRepository userRepository,
ICarCategoryRepository carCategoryRepository,
ICityRepository cityRepository,
ITransactionHistoryRepository transactionHistoryRepository,
IPaymentMethodRepository paymentMethodRepository)
{
BookingRepository = bookingRepository;
CarRepository = carRepository;
UserRepository = userRepository;
CarCategoryRepository = carCategoryRepository;
CityRepository = cityRepository;
TransactionHistoryRepository = transactionHistoryRepository;
PaymentMethodRepository = paymentMethodRepository;
}
public OperationsQueryService(
ITransactionHistoryRepository transactionHistoryRepository,
IBonusCashInsRepository bonusCashInsRepository,
IPaymentTransfersRepository paymentTransfersRepository,
IPartnersPaymentsRepository partnersPaymentsRepository,
IVoucherPurchasePaymentsRepository voucherPurchasePaymentsRepository,
ICustomerProfileClient customerProfileClient,
ILogFactory logFactory)
{
_transactionHistoryRepository = transactionHistoryRepository;
_bonusCashInsRepository = bonusCashInsRepository;
_paymentTransfersRepository = paymentTransfersRepository;
_partnersPaymentsRepository = partnersPaymentsRepository;
_voucherPurchasePaymentsRepository = voucherPurchasePaymentsRepository;
_customerProfileClient = customerProfileClient;
_log = logFactory.CreateLog(this);
}
///Unit Test for the RetrieveCache()
public async Task TransactionHistoryControllerTest_GetDataFromCache()
{
string terminalId = "LK429486";
string transactionType = "Credit";
MockTransactionHistoryRepository mockTransactionHistoryRepository = new MockTransactionHistoryRepository();
ApiResult <GenericPaginationResponse <Wp.CIS.LynkSystems.Model.TransactionHistory> > expectedResult = mockTransactionHistoryRepository.GetMockData(transactionType);
PaginationTransactionHistory page = mockTransactionHistoryRepository.GetPagination();
TransactionHistoryInput pageinput = new TransactionHistoryInput();
pageinput.LIDValue = terminalId;
pageinput.lidTypeEnum = Wp.CIS.LynkSystems.Model.Enums.LidTypeEnum.Customer;
pageinput.Page = page;
IDistributedCache mockCache = Substitute.For <IDistributedCache>();
ITransactionHistoryRepository mockRepo = Substitute.For <ITransactionHistoryRepository>();
IStringLocalizer <TransactionHistoryController> localizer
= Substitute.For <IStringLocalizer <TransactionHistoryController> >();
ITransactionHistoryApi mockTransactionHistoryApi = Substitute.For <ITransactionHistoryApi>();
ILoggingFacade loggingFacade = Substitute.For <ILoggingFacade>();
IOperation fakeOperation = Substitute.For <Operation>(mockCache);
fakeOperation.WhenForAnyArgs(x => x.RetrieveCache(Arg.Any <string>(), Arg.Any <ICollection <Wp.CIS.LynkSystems.Model.TransactionHistory> >())).DoNotCallBase();
fakeOperation.RetrieveCache("FakeStringID", new GenericPaginationResponse <Wp.CIS.LynkSystems.Model.TransactionHistory>()).ReturnsForAnyArgs(expectedResult.Result);
loggingFacade.WhenForAnyArgs(x => x.LogAsync(Arg.Any <LogLevels>(), Arg.Any <string>(), Arg.Any <CancellationToken>())).DoNotCallBase();
TransactionHistoryController controller = new TransactionHistoryController(mockCache, mockTransactionHistoryApi, localizer, fakeOperation, loggingFacade);
//ACT
var terminalList = await controller.GetTransactionHistory(pageinput);
var actualRecord = ((Microsoft.AspNetCore.Mvc.ObjectResult)terminalList).Value;
//Assert
Assert.Equal(JsonConvert.SerializeObject(actualRecord), JsonConvert.SerializeObject(expectedResult.Result));
}
public DataModel.Response.BaseResponse Delete(string id)
{
try
{
ITransactionHistoryRepository transactionRepository = RepositoryClassFactory.GetInstance().GetTransactionHistoryRepository();
transactionRepository.Delete(id);
return(new BaseResponse
{
ErrorCode = (int)ErrorCode.None,
Message = Resources.Resource.msg_delete_success
});
}
catch (Exception ex)
{
return(new BaseResponse
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public AbstractRequestFormBC(IDbFactory dbFactory, IDbFactory dbDocFactory)
{
this._transactionHistoryRepository = new TransactionHistoryRepository(dbFactory);
this._documentRepository = new DocumentRepository(dbFactory);
this.requestHeaderRepository = new RequestHeaderRepository(dbFactory);
this.activityHistoryRepository = new ActivityHistoryRepository(dbFactory);
this._wlRepo = new WMRepository(dbFactory);
this.employeeRepository = new EmployeeRepository(dbFactory);
this.unitOfWork = new UnitOfWork(dbFactory);
this.fileAttachementRepository = new AttachementRepository <FileTemp>(dbDocFactory);
this.repository = new Repository();
//Adding by default since all work flow get view activity for users
AddActivities(new DefaultActivity <E>(FORM_VIEW));
REQ_APP = _wlRepo.GetReqAppByCode(GetRequestCode());
REQ_CODE = REQ_APP.RequestCode;
ActivityList = _wlRepo.GetActivitiesByReqCode(REQ_APP.RequestCode);
_processFolderName = ConfigurationManager.AppSettings["ProcessFolderName"] ?? "Nagaworld\\";
InitActivityConfiguration();
}
public DataModel.Response.FindAllItemReponse <DataModel.Model.TransactionHistoryModel> GetAlls()
{
try
{
ITransactionHistoryRepository transactionRepository = RepositoryClassFactory.GetInstance().GetTransactionHistoryRepository();
IList <TransactionHistory> transactions = transactionRepository.FindAll();
var _transactions = transactions.Select(n => MapperUtil.CreateMapper().Mapper.Map <TransactionHistory, TransactionHistoryModel>(n)).ToList();
return(new FindAllItemReponse <TransactionHistoryModel>
{
Items = _transactions,
ErrorCode = (int)ErrorCode.None,
Message = string.Empty
});
}
catch (Exception ex)
{
return(new FindAllItemReponse <TransactionHistoryModel>
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public DataModel.Response.InsertResponse Create(DataModel.Model.TransactionHistoryModel transaction)
{
try
{
ITransactionHistoryRepository transactionRepository = RepositoryClassFactory.GetInstance().GetTransactionHistoryRepository();
var _transaction = MapperUtil.CreateMapper().Mapper.Map <TransactionHistoryModel, TransactionHistory>(transaction);
object id = transactionRepository.Insert(_transaction);
return(new InsertResponse
{
InsertID = id.ToString(),
ErrorCode = (int)ErrorCode.None,
Message = Resources.Resource.msg_create_success
});
}
catch (Exception ex)
{
return(new InsertResponse
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public DataModel.Response.FindItemReponse <DataModel.Model.TransactionHistoryModel> FindByID(string id)
{
try
{
ITransactionHistoryRepository transactionRepository = RepositoryClassFactory.GetInstance().GetTransactionHistoryRepository();
TransactionHistory transaction = transactionRepository.FindByID(id);
var _transaction = MapperUtil.CreateMapper().Mapper.Map <TransactionHistory, TransactionHistoryModel>(transaction);
return(new FindItemReponse <TransactionHistoryModel>
{
Item = _transaction,
ErrorCode = (int)ErrorCode.None,
Message = string.Empty
});
}
catch (Exception ex)
{
return(new FindItemReponse <TransactionHistoryModel>
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public TransactionHistoryService(ITransactionHistoryRepository transactionHistoryRepository)
{
_transactionHistoryRepository = transactionHistoryRepository;
}
public TransactionHistoryService(ITransactionHistoryRepository operationHistoryRepository)
{
this.operationHistoryRepository = operationHistoryRepository;
}
public AbstractApiTransactionHistoryRequestModelValidator(ITransactionHistoryRepository transactionHistoryRepository)
{
this.transactionHistoryRepository = transactionHistoryRepository;
}
public ApiTransactionHistoryRequestModelValidator(ITransactionHistoryRepository transactionHistoryRepository)
: base(transactionHistoryRepository)
{
}
public EndowmentRepositories(
IComplianceRoleRepository complianceRoles,
IContactRepository contacts,
IDepositoryRepository depositories,
IGlobalRoleRepository globalRoles,
IModeratorRepository moderators,
IPersonRepository persons,
IProjectRepository projects,
IServiceDataRepository serviceData,
IStatusRepository statuses,
ITransactionRepository transactions,
IUserRepository users,
IProjectQueueRepository projectQueue,
IProjectPriceRepository prices,
IAcceptedProjectRepository acceptedProject,
IHistoryProjectRepository historyProject,
IModeratorLevelRepository moderatorLevel,
ITempDepositoryRepository tempDepository,
IVotingPeriodRepository votingPeriod,
ITempDepositoryHistoryRepository tempDepositoryHistory,
IContactTypesRepository contactTypes,
ITransactionHistoryRepository transactionHistory,
IVotingPeriodReportRepository votingPeriodReport)
{
ComplianceRoles = complianceRoles;
Contacts = contacts;
Depositories = depositories;
GlobalRoles = globalRoles;
Moderators = moderators;
Persons = persons;
Projects = projects;
ServiceData = serviceData;
Statuses = statuses;
Transactions = transactions;
Users = users;
ProjectQueue = projectQueue;
Prices = prices;
AcceptedProject = acceptedProject;
HistoryProject = historyProject;
ModeratorLevel = moderatorLevel;
TempDepository = tempDepository;
VotingPeriod = votingPeriod;
TempDepositoryHistory = tempDepositoryHistory;
ContactTypes = contactTypes;
TransactionHistory = transactionHistory;
VotingPeriodReport = votingPeriodReport;
}
public TransactionHistoryService(IMapper mapper, IRequestData requestData, ITransactionHistoryRepository transactionHistoryRepository)
: base(mapper, requestData)
{
this.transactionHistoryRepository = transactionHistoryRepository;
}
public TransactionHistoryController(ITransactionHistoryRepository transactionHistoryRepository)
{
this.transactionHistoryRepository = transactionHistoryRepository;
}
