/// <summary>
        ///     Gets the expenditures for a given user for month.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>
        ///     The response object.
        /// </returns>
        public async Task <GetExpenditureForUserForMonthResponse> GetExpenditureForUserForMonth(
            GetExpenditureForUserForMonthRequest request)
        {
            return(await Orchestrate(async delegate {
                var expenditure = await repository.GetExpenditureForUserForMonth(request.UserId);

                return assembler.NewGetExpenditureForUserForMonthResponse(expenditure, request.RequestReference);
            }, request));
        }
        /// <summary>
        ///     Obtains the data required for the expenditure chart.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>The response object.</returns>
        public async Task <GetExpenditureChartDataResponse> GetExpenditureChartData(
            GetExpenditureChartDataRequest request)
        {
            return(await Orchestrate(async delegate {
                var expenditure = await expenditureRepository.GetExpenditureForUserForMonth(request.UserId);
                var data = expenditureDataTransformer.GetRollingExpenditureSum(expenditure);

                return assembler.NewGetExpenditureChartDataResponse(data, request.RequestReference);
            }, request));
        }
        public void SetUp()
        {
            errorHelper                = Substitute.For <IErrorHelper>();
            assembler                  = Substitute.For <IChartAssembler>();
            billRepository             = Substitute.For <IBillRepository>();
            billDataTransformer        = Substitute.For <IBillDataTransformer>();
            expenditureRepository      = Substitute.For <IExpenditureRepository>();
            expenditureDataTransformer = Substitute.For <IExpenditureDataTransformer>();

            validGetBillCategoryChartDataRequest = new GetBillCategoryChartDataRequest
            {
                UserId   = Guid.NewGuid(),
                Username = "******"
            };

            validGetBillPeriodChartDataRequest = new GetBillPeriodChartDataRequest
            {
                UserId   = Guid.NewGuid(),
                Username = "******"
            };

            validGetExpenditureChartDataRequest =
                new GetExpenditureChartDataRequest {
                Month = 1, UserId = Guid.NewGuid(), Username = "******"
            };

            validBills       = new List <BillDataModel>();
            validExpenditure = new List <ExpenditureDataModel>();

            invalidGetBillPeriodChartDataRequest   = new GetBillPeriodChartDataRequest();
            invalidGetBillCategoryChartDataRequest = new GetBillCategoryChartDataRequest();
            invalidGetExpenditureChartDataRequest  = new GetExpenditureChartDataRequest();

            billRepository.GetBillsForUser(validGetBillCategoryChartDataRequest.UserId).Returns(validBills);
            billRepository.GetBillsForUser(validGetBillPeriodChartDataRequest.UserId).Returns(validBills);
            billRepository.GetBillsForUser(Guid.Empty).Throws(new Exception("TEST"));

            expenditureRepository.GetExpenditureForUserForMonth(validGetExpenditureChartDataRequest.UserId)
            .Returns(validExpenditure);
            expenditureRepository.GetExpenditureForUserForMonth(Guid.Empty).Throws(new Exception("TEST"));

            validData = new List <KeyValuePair <string, int> > {
                new KeyValuePair <string, int>("TEST", 1)
            };

            billDataTransformer.GetBillCategoryChartData(validBills).Returns(validData);
            billDataTransformer.GetBillPeriodChartData(validBills).Returns(validData);

            expenditureDataTransformer.GetRollingExpenditureSum(validExpenditure)
            .Returns(
                new List <KeyValuePair <DateTime, double> >
            {
                new KeyValuePair <DateTime, double>(DateTime.Now, 1.0)
            });

            validGetBillPeriodChartDataResponse = new GetBillPeriodChartDataResponse {
                Data = validData
            };
            validGetBillCategoryChartDataResponse = new GetBillCategoryChartDataResponse {
                Data = validData
            };
            validGetExpenditureChartDataResponse =
                new GetExpenditureChartDataResponse
            {
                Data = new List <KeyValuePair <DateTime, double> >
                {
                    new KeyValuePair <DateTime, double>(DateTime.Now, 1.0)
                }
            };

            assembler.NewGetExpenditureChartDataResponse(Arg.Any <IList <KeyValuePair <DateTime, double> > >(), Arg.Any <Guid>()).Returns(validGetExpenditureChartDataResponse);
            assembler.NewGetBillCategoryChartDataResponse(validData, Arg.Any <Guid>()).Returns(validGetBillCategoryChartDataResponse);
            assembler.NewGetBillPeriodChartDataResponse(validData, Arg.Any <Guid>()).Returns(validGetBillPeriodChartDataResponse);

            errorHelper.Create(Arg.Any <Exception>(), Arg.Any <string>(), Arg.Any <Type>(), Arg.Any <string>())
            .Returns(new ResponseErrorWrapper());
            errorHelper.Create(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <Type>(), Arg.Any <string>())
            .Returns(new ResponseErrorWrapper());

            orchestrator = new ChartOrchestrator(
                assembler,
                billRepository,
                billDataTransformer,
                expenditureRepository,
                expenditureDataTransformer,
                errorHelper);
        }
        public void SetUp()
        {
            userId        = Guid.NewGuid();
            expenditureId = Guid.NewGuid();

            validData = new List <ExpenditureDataModel>();

            invalidDeleteExpenditureRequest             = new DeleteExpenditureRequest();
            invalidEditExpenditureRequest               = new EditExpenditureRequest();
            invalidGetExpenditureForUserForMonthRequest = new GetExpenditureForUserForMonthRequest();
            invalidGetExpenditureForUserRequest         = new GetExpenditureForUserRequest();
            invalidGetExpenditureRequest = new GetExpenditureRequest();
            invalidAddExpenditureRequest = new AddExpenditureRequest();

            validExpenditureDataModel =
                new ExpenditureDataModel
            {
                Amount   = 1,
                Category =
                    new CategoryDataModel
                {
                    CreationTime = DateTime.Now,
                    Id           = Guid.NewGuid(),
                    Name         = "TEST"
                },
                CreationTime = DateTime.Now,
                CategoryId   = Guid.NewGuid(),
                DateOccurred = DateTime.Now,
                Description  = "TEST",
                Id           = Guid.NewGuid(),
                UserId       = Guid.NewGuid()
            };

            expenditureProxy = new ExpenditureProxy
            {
                Amount   = 1.0,
                Category =
                    new CategoryProxy {
                    Id = Guid.NewGuid(), Name = "TEST"
                },
                CategoryId   = Guid.NewGuid(),
                DateOccurred = DateTime.Now,
                Description  = "TEST",
                Id           = Guid.NewGuid(),
                UserId       = Guid.NewGuid()
            };

            validDeleteExpenditureRequest =
                new DeleteExpenditureRequest {
                ExpenditureId = Guid.NewGuid(), Username = "******"
            };

            validGetExpenditureForUserForMonthRequest =
                new GetExpenditureForUserForMonthRequest {
                MonthNumber = 1, UserId = userId, Username = "******"
            };

            validAddExpenditureRequest =
                new AddExpenditureRequest {
                Expenditure = expenditureProxy, Username = "******"
            };

            validGetExpenditureForUserRequest = new GetExpenditureForUserRequest {
                UserId = userId, Username = "******"
            };

            validGetExpenditureRequest = new GetExpenditureRequest {
                ExpenditureId = expenditureId, Username = "******"
            };

            validEditExpenditureRequest =
                new EditExpenditureRequest {
                Expenditure = expenditureProxy, Username = "******"
            };

            validGetExpenditureForUserResponse =
                new GetExpenditureForUserResponse {
                Expenditure = new List <ExpenditureProxy> {
                    expenditureProxy
                }
            };
            validGetExpenditureResponse = new GetExpenditureResponse {
                Expenditure = expenditureProxy
            };
            validAddExpenditureResponse = new AddExpenditureResponse {
                Expenditure = expenditureProxy
            };
            validEditExpenditureResponse = new EditExpenditureResponse {
                Expenditure = expenditureProxy
            };
            validDeleteExpenditureResponse = new DeleteExpenditureResponse {
                DeleteSuccess = true
            };
            validGetExpenditureForUserForMonthResponse =
                new GetExpenditureForUserForMonthResponse {
                Data = new List <ExpenditureProxy> {
                    expenditureProxy
                }
            };

            assembler  = Substitute.For <IExpenditureAssembler>();
            repository = Substitute.For <IExpenditureRepository>();

            repository.AddExpenditure(validExpenditureDataModel).Returns(validExpenditureDataModel);
            repository.AddExpenditure(null).Throws(new Exception("TEST"));

            repository.DeleteExpenditure(validDeleteExpenditureRequest.ExpenditureId).Returns(true);
            repository.DeleteExpenditure(invalidDeleteExpenditureRequest.ExpenditureId).Throws(new Exception("TEST"));

            repository.EditExpenditure(validExpenditureDataModel).Returns(validExpenditureDataModel);
            repository.EditExpenditure(null).Throws(new Exception("TEST"));

            repository.GetExpenditure(expenditureId).Returns(validExpenditureDataModel);
            repository.GetExpenditure(Guid.Empty).Throws(new Exception("TEST"));

            repository.GetExpenditureForUser(validGetExpenditureForUserRequest.UserId)
            .Returns(new List <ExpenditureDataModel> {
                validExpenditureDataModel
            });
            repository.GetExpenditureForUser(Guid.Empty).Throws(new Exception("TEST"));

            repository.GetExpenditureForUserForMonth(userId)
            .Returns(new List <ExpenditureDataModel> {
                validExpenditureDataModel
            });
            repository.GetExpenditureForUserForMonth(Guid.Empty).Throws(new Exception("TEST"));

            assembler.NewAddExpenditureResponse(validExpenditureDataModel, validAddExpenditureRequest.RequestReference)
            .Returns(validAddExpenditureResponse);

            assembler.NewDeleteExpenditureResponse(true, validDeleteExpenditureRequest.ExpenditureId)
            .Returns(validDeleteExpenditureResponse);

            assembler.NewEditExpenditureResponse(
                validExpenditureDataModel,
                validEditExpenditureRequest.RequestReference)
            .Returns(validEditExpenditureResponse);

            assembler.NewExpenditureDataModel(expenditureProxy).Returns(validExpenditureDataModel);

            assembler.NewGetExpenditureForUserForMonthResponse(
                Arg.Any <List <ExpenditureDataModel> >(),
                validGetExpenditureForUserForMonthRequest.RequestReference)
            .Returns(validGetExpenditureForUserForMonthResponse);

            assembler.NewGetExpenditureForUserResponse(
                Arg.Any <List <ExpenditureDataModel> >(),
                validGetExpenditureForUserRequest.RequestReference)
            .Returns(validGetExpenditureForUserResponse);

            assembler.NewDeleteExpenditureResponse(true, validDeleteExpenditureRequest.RequestReference)
            .Returns(validDeleteExpenditureResponse);

            assembler.NewGetExpenditureResponse(validExpenditureDataModel, validGetExpenditureRequest.RequestReference)
            .Returns(validGetExpenditureResponse);

            errorHelper = Substitute.For <IErrorHelper>();

            errorHelper.Create(Arg.Any <Exception>(), Arg.Any <string>(), Arg.Any <Type>(), Arg.Any <string>())
            .Returns(new ResponseErrorWrapper());
            errorHelper.Create(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <Type>(), Arg.Any <string>())
            .Returns(new ResponseErrorWrapper());

            orchestrator = new ExpenditureOrchestrator(repository, assembler, errorHelper);
        }