/// <summary>
        ///     Splits the provided transaction into two. The provided transactions is removed, and two new transactions are
        ///     created. Both transactions must add up to the existing transaction amount.
        /// </summary>
        /// <exception cref="System.ArgumentNullException">
        /// </exception>
        public void SplitTransaction(Transaction originalTransaction, decimal splinterAmount1, decimal splinterAmount2,
                                     BudgetBucket splinterBucket1, BudgetBucket splinterBucket2)
        {
            if (originalTransaction == null)
            {
                throw new ArgumentNullException(nameof(originalTransaction));
            }

            if (splinterBucket1 == null)
            {
                throw new ArgumentNullException(nameof(splinterBucket1));
            }

            if (splinterBucket2 == null)
            {
                throw new ArgumentNullException(nameof(splinterBucket2));
            }

            StatementModel.SplitTransaction(
                originalTransaction,
                splinterAmount1,
                splinterAmount2,
                splinterBucket1,
                splinterBucket2);
        }
        private static decimal GetBudgetModelTotalForBucket(BudgetModel budgetModel, BudgetBucket bucket)
        {
            if (bucket is PayCreditCardBucket)
            {
                // Ignore
                return(0);
            }

            if (bucket is IncomeBudgetBucket)
            {
                throw new InvalidOperationException(
                          "Code Error: Income bucket detected when Bucket Spending only applies to Expenses.");
            }

            // Use budget values instead
            if (bucket is SurplusBucket)
            {
                return(budgetModel.Surplus);
            }

            var budget = budgetModel.Expenses.FirstOrDefault(e => e.Bucket == bucket);

            if (budget != null)
            {
                return(budget.Amount);
            }

            return(0);
        }
        public void ValidateShouldThrowGivenNullStringBuilder()
        {
            BudgetBucket subject = Arrange();

            subject.Validate(null);
            Assert.Fail();
        }
        public void CtorShouldAllocateUpperCaseCode()
        {
            BudgetBucket subject = Arrange("Foo", "Bar");

            Assert.AreEqual("FOO", subject.Code);
            Assert.AreNotEqual("Foo", subject.Code);
        }
        public void Comparable_PhoneBucketIsEqualToAnotherInstance()
        {
            SpentMonthlyExpenseBucket phoneBucket = StatementModelTestData.PhoneBucket;
            BudgetBucket phooneBucket2            = Arrange(TestDataConstants.PhoneBucketCode, "Foo");

            Assert.IsTrue(phoneBucket.CompareTo(phooneBucket2) == 0);
        }
        public void SettingCodeShouldConvertToUpperCase()
        {
            BudgetBucket subject = Arrange("Foo", "Bar");

            subject.Code = "White";
            Assert.AreNotEqual("White", subject.Code);
            Assert.AreEqual("WHITE", subject.Code);
        }
        public void ValidateShouldRetrunFalseGivenLongCode()
        {
            BudgetBucket subject = Arrange();

            subject.Code = "ABC345678";
            bool result = subject.Validate(new StringBuilder());

            Assert.IsFalse(result);
        }
        public void TwoReferencesToTheSameObjectAreEqual()
        {
            BudgetBucket subject1 = Arrange("Foo", "Name");
            BudgetBucket subject2 = subject1;

            Assert.AreEqual(subject1, subject2);
            Assert.IsTrue(subject1 == subject2);
            Assert.AreEqual(subject1.GetHashCode(), subject2.GetHashCode());
        }
        public void TwoReferencesToDifferentObjectsAreNotEqual()
        {
            BudgetBucket subject1 = Arrange("Foo", "Name");
            BudgetBucket subject2 = Arrange("Ben", "Is Awesome");

            Assert.AreNotEqual(subject1, subject2);
            Assert.IsTrue(subject1 != subject2);
            Assert.AreNotEqual(subject1.GetHashCode(), subject2.GetHashCode());
        }
 /// <summary>
 ///     Returns a hash code for this instance.
 /// </summary>
 /// <returns>
 ///     A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
 /// </returns>
 public override int GetHashCode()
 {
     unchecked
     {
         // ReSharper disable NonReadonlyMemberInGetHashCode - Properties are only set by persistence
         return(((BudgetBucket?.GetHashCode() ?? 0) * 397) ^ (StoredInAccount?.GetHashCode() ?? 0));
         // ReSharper restore NonReadonlyMemberInGetHashCode
     }
 }
        public void TestInitialise()
        {
            this.testData = new FixedBudgetProjectBucket(FixedProjectCode, "Foo bar dum-de-dum", 1000);
            PrivateAccessor.SetProperty(this.testData, "Created", this.testDataCreatedDate);

            var subject = new Mapper_BudgetBucketDto_BudgetBucket(new BudgetBucketFactory());

            this.result = subject.ToDto(this.testData);
        }
        public void TwoBucketsAreDifferentIfCodesAreDifferent()
        {
            BudgetBucket subject1 = Arrange("Foo1", "Name");
            BudgetBucket subject2 = Arrange("Foo2", "Name");

            Assert.AreNotEqual(subject1, subject2);
            Assert.IsTrue(subject1 != subject2);
            Assert.AreNotEqual(subject1.GetHashCode(), subject2.GetHashCode());
        }
        public void TwoBucketsAreTheSameIfCodesAreEqual()
        {
            BudgetBucket subject1 = Arrange("Foo", "Name");
            BudgetBucket subject2 = Arrange("Foo", "Name");

            Assert.AreEqual(subject1, subject2);
            Assert.IsTrue(subject1 == subject2);
            Assert.AreEqual(subject1.GetHashCode(), subject2.GetHashCode());
        }
        /// <summary>
        ///     Validates the bucket provided is valid for use with this LedgerBucket. There is an explicit relationship between
        ///     <see cref="BudgetBucket" />s and <see cref="LedgerBucket" />s.
        /// </summary>
        /// <exception cref="System.NotSupportedException">
        ///     Invalid budget bucket used, only Spent-Monthly-Expense-Bucket can be
        ///     used with an instance of Spent-Monthly-Ledger.
        /// </exception>
        protected override void ValidateBucketSet(BudgetBucket bucket)
        {
            if (bucket is SpentMonthlyExpenseBucket)
            {
                return;
            }

            throw new NotSupportedException(
                      "Invalid budget bucket used, only Spent-Monthly-Expense-Bucket can be used with an instance of Spent-Monthly-Ledger.");
        }
        public void ValidateWillReturnFalseWhenCodeIsTooLong()
        {
            BudgetBucket subject = Arrange();

            subject.Description = "FooBarHo";
            var builder = new StringBuilder();

            Assert.IsFalse(subject.Validate(builder));
            Assert.IsTrue(builder.Length > 0);
        }
        /// <summary>
        ///     Validates the bucket provided is valid for use with this LedgerBucket. There is an explicit relationship between
        ///     <see cref="BudgetBucket" />s and <see cref="LedgerBucket" />s.
        /// </summary>
        /// <exception cref="System.NotSupportedException">
        ///     Invalid budget bucket used, only the Surplus bucket can be used with an
        ///     instance of Surplus-Ledger.
        /// </exception>
        protected override void ValidateBucketSet(BudgetBucket bucket)
        {
            if (bucket is SurplusBucket)
            {
                return;
            }

            throw new NotSupportedException(
                      "Invalid budget bucket used, only the Surplus bucket can be used with an instance of Surplus-Ledger.");
        }
        public void ValidateWillReturnFalseWhenNameIsNull()
        {
            BudgetBucket subject = Arrange();

            subject.Code = "Foo";
            var builder = new StringBuilder();

            Assert.IsFalse(subject.Validate(builder));
            Assert.IsTrue(builder.Length > 0);
        }
Exemple #18
0
        internal virtual void SplitTransaction(
            [NotNull] Transaction originalTransaction,
            decimal splinterAmount1,
            decimal splinterAmount2,
            [NotNull] BudgetBucket splinterBucket1,
            [NotNull] BudgetBucket splinterBucket2)
        {
            ThrowIfDisposed();
            if (originalTransaction == null)
            {
                throw new ArgumentNullException(nameof(originalTransaction));
            }

            if (splinterBucket1 == null)
            {
                throw new ArgumentNullException(nameof(splinterBucket1));
            }

            if (splinterBucket2 == null)
            {
                throw new ArgumentNullException(nameof(splinterBucket2));
            }

            var splinterTransaction1 = originalTransaction.Clone();
            var splinterTransaction2 = originalTransaction.Clone();

            splinterTransaction1.Amount = splinterAmount1;
            splinterTransaction2.Amount = splinterAmount2;

            splinterTransaction1.BudgetBucket = splinterBucket1;
            splinterTransaction2.BudgetBucket = splinterBucket2;

            if (splinterAmount1 + splinterAmount2 != originalTransaction.Amount)
            {
                throw new ArgumentException("The two new amounts do not add up to the original transaction value.");
            }

            RemoveTransaction(originalTransaction);

            this.changeHash = Guid.NewGuid();
            if (AllTransactions == null)
            {
                AllTransactions = new List <Transaction>();
            }
            List <Transaction> mergedTransactions =
                AllTransactions.ToList().Merge(new[] { splinterTransaction1, splinterTransaction2 }).ToList();

            AllTransactions = mergedTransactions;
            splinterTransaction1.PropertyChanged += OnTransactionPropertyChanged;
            splinterTransaction2.PropertyChanged += OnTransactionPropertyChanged;
            this.duplicates = null;
            UpdateDuration();
            Filter(this.currentFilter);
        }
        public void TestInitialise()
        {
            this.testData = new FixedBudgetBucketDto
            {
                Code              = FixedBudgetProjectBucket.CreateCode(TestDataCode),
                Description       = "Foo bar tiddle-de-dum",
                FixedBudgetAmount = 2000
            };
            var subject = new Mapper_BudgetBucketDto_BudgetBucket(new BudgetBucketFactory());

            this.result = subject.ToModel(this.testData);
        }
        private static Func <BudgetModel, decimal> BuildIncomeFinder(BudgetBucket bucket)
        {
            return(b =>
            {
                var first = b.Incomes.FirstOrDefault(e => e.Bucket == bucket);
                if (first == null)
                {
                    return 0;
                }

                return first.Amount;
            });
        }
Exemple #21
0
        /// <summary>
        ///     Validates the bucket provided is valid for use with this LedgerBucket. There is an explicit relationship between
        ///     <see cref="BudgetBucket" />s and <see cref="LedgerBucket" />s.
        /// </summary>
        /// <exception cref="System.NotSupportedException">
        ///     Invalid budget bucket used, only Saved-Up-For-Expense-Buckets or
        ///     Savings-Commitment-Buckets can be used with an instance of Saved-Up-For-Ledger.
        /// </exception>
        protected override void ValidateBucketSet(BudgetBucket bucket)
        {
            if (bucket is SavedUpForExpenseBucket)
            {
                return;
            }
            if (bucket is SavingsCommitmentBucket)
            {
                return;
            }

            throw new NotSupportedException(
                      "Invalid budget bucket used, only Saved-Up-For-Expense-Buckets or Savings-Commitment-Buckets can be used with an instance of Saved-Up-For-Ledger.");
        }
Exemple #22
0
        public void FetchBudgetBucketWithValidParamsShouldReturnBucketObject()
        {
            BankImportUtilities subject = CreateSubject();

            string[] testArray      = CreateTestArray();
            var      expectedResult = new SpentMonthlyExpenseBucket("FUEL", "Fuel");

            BucketRepositoryMock.Setup(m => m.GetByCode("FUEL")).Returns(expectedResult);

            BudgetBucket result = subject.FetchBudgetBucket(testArray, 2, BucketRepositoryMock.Object);

            BucketRepositoryMock.Verify();
            Assert.AreSame(expectedResult, result);
        }
Exemple #23
0
        /// <summary>
        ///     Initializes a new instance of the <see cref="RulesGroupedByBucket" /> class.
        /// </summary>
        /// <param name="bucket">The bucket.</param>
        /// <param name="rules">The rules.</param>
        /// <exception cref="System.ArgumentNullException">
        /// </exception>
        public RulesGroupedByBucket([NotNull] BudgetBucket bucket, [NotNull] IEnumerable <MatchingRule> rules)
        {
            if (bucket == null)
            {
                throw new ArgumentNullException(nameof(bucket));
            }

            if (rules == null)
            {
                throw new ArgumentNullException(nameof(rules));
            }

            Bucket = bucket;
            Rules  = new ObservableCollection <MatchingRule>(rules.ToList());
        }
        public void ShowDialog(Transaction transaction, Guid correlationId)
        {
            Transaction         = transaction;
            this.originalBucket = Transaction.BudgetBucket;
            Buckets             = this.bucketRepo.Buckets.Where(b => b.Active);

            MessengerInstance.Send(
                new ShellDialogRequestMessage(
                    BudgetAnalyserFeature.Transactions,
                    this,
                    ShellDialogType.SaveCancel)
            {
                CorrelationId = correlationId,
                Title         = "Edit Transaction"
            });
        }
Exemple #25
0
        /// <summary>
        ///     Initializes a new instance of the <see cref="TransactionGroupedByBucket" /> class.
        /// </summary>
        /// <param name="transactions">The transactions.</param>
        /// <param name="groupByThisBucket">The group by this bucket.</param>
        /// <exception cref="System.ArgumentNullException">
        /// </exception>
        public TransactionGroupedByBucket([NotNull] IEnumerable <Transaction> transactions,
                                          [NotNull] BudgetBucket groupByThisBucket)
        {
            if (transactions == null)
            {
                throw new ArgumentNullException(nameof(transactions));
            }

            if (groupByThisBucket == null)
            {
                throw new ArgumentNullException(nameof(groupByThisBucket));
            }

            Bucket       = groupByThisBucket;
            Transactions =
                new ObservableCollection <Transaction>(
                    transactions.Where(t => t.BudgetBucket == groupByThisBucket).OrderBy(t => t.Date));
        }
        private static decimal GetLedgerBalanceForBucket(BudgetModel budgetModel, LedgerEntryLine applicableLine,
                                                         BudgetBucket bucket)
        {
            if (bucket is SurplusBucket)
            {
                return(applicableLine.CalculatedSurplus);
            }

            var ledger = applicableLine.Entries.FirstOrDefault(e => e.LedgerBucket.BudgetBucket == bucket);

            if (ledger != null)
            {
                return(ledger.Balance);
            }

            // The Ledger line might not actually have a ledger for the given bucket.
            return(GetBudgetModelTotalForBucket(budgetModel, bucket));
        }
        public BucketDtoType SerialiseType([NotNull] BudgetBucket bucket)
        {
            if (bucket == null)
            {
                throw new ArgumentNullException(nameof(bucket));
            }

            if (bucket is IncomeBudgetBucket)
            {
                return(BucketDtoType.Income);
            }

            if (bucket is FixedBudgetProjectBucket)
            {
                return(BucketDtoType.FixedBudgetProject);
            }

            if (bucket is SurplusBucket)
            {
                return(BucketDtoType.Surplus);
            }

            if (bucket is PayCreditCardBucket)
            {
                return(BucketDtoType.PayCreditCard);
            }

            if (bucket is SavedUpForExpenseBucket)
            {
                return(BucketDtoType.SavedUpForExpense);
            }

            if (bucket is SpentMonthlyExpenseBucket)
            {
                return(BucketDtoType.SpentMonthlyExpense);
            }

            if (bucket is SavingsCommitmentBucket)
            {
                return(BucketDtoType.SavingsCommitment);
            }

            throw new NotSupportedException("Unsupported bucket type detected: " + bucket.GetType().FullName);
        }
Exemple #28
0
        internal void ReassignFixedProjectTransactions([NotNull] FixedBudgetProjectBucket bucket,
                                                       [NotNull] BudgetBucket reassignmentBucket)
        {
            ThrowIfDisposed();
            if (bucket == null)
            {
                throw new ArgumentNullException(nameof(bucket));
            }

            if (reassignmentBucket == null)
            {
                throw new ArgumentNullException(nameof(reassignmentBucket));
            }

            foreach (var transaction in AllTransactions.Where(t => t.BudgetBucket == bucket))
            {
                transaction.BudgetBucket = reassignmentBucket;
            }
        }
        /// <summary>
        ///     Builds a <see cref="BudgetBucketDto" /> based on the model passed in.
        /// </summary>
        public BudgetBucketDto BuildDto(BudgetBucket bucket)
        {
            BudgetBucketDto dto;
            var fixedProjectBucket = bucket as FixedBudgetProjectBucket;
            if (fixedProjectBucket != null)
            {
                dto = new FixedBudgetBucketDto
                {
                    Created = fixedProjectBucket.Created,
                    FixedBudgetAmount = fixedProjectBucket.FixedBudgetAmount
                };
            }
            else
            {
                dto = new BudgetBucketDto();
            }

            dto.Type = SerialiseType(bucket);
            return dto;
        }
        /// <summary>
        ///     Builds a <see cref="BudgetBucketDto" /> based on the model passed in.
        /// </summary>
        public BudgetBucketDto BuildDto(BudgetBucket bucket)
        {
            BudgetBucketDto dto;
            var             fixedProjectBucket = bucket as FixedBudgetProjectBucket;

            if (fixedProjectBucket != null)
            {
                dto = new FixedBudgetBucketDto
                {
                    Created           = fixedProjectBucket.Created,
                    FixedBudgetAmount = fixedProjectBucket.FixedBudgetAmount
                };
            }
            else
            {
                dto = new BudgetBucketDto();
            }

            dto.Type = SerialiseType(bucket);
            return(dto);
        }
 public BudgetBucketChosenEventArgs(Guid correlationId, BudgetBucket bucket, Account storeInThisAccount)
     : this(correlationId, bucket)
 {
     StoreInThisAccount = storeInThisAccount;
 }
 // ReSharper disable once RedundantAssignment
 partial void DtoFactory(ref BudgetBucketDto dto, BudgetBucket model)
 {
     dto = this.bucketFactory.BuildDto(model);
 }
 // ReSharper disable once RedundantAssignment
 partial void ModelFactory(BudgetBucketDto dto, ref BudgetBucket model)
 {
     model = this.bucketFactory.BuildModel(dto);
 }