Partner.cs

using MyWarehouse.Domain.Common;
using MyWarehouse.Domain.Products;
using MyWarehouse.Domain.Transactions;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;

namespace MyWarehouse.Domain.Partners
{
    /// <summary>
    /// Simplified entity. In product context a partner would contain more fine grained name fields,
    /// a complex address representation, phone number, invoicing/tax details, etc.
    /// </summary>
    public class Partner : MyEntity
    {
        [Required]
        [StringLength(PartnerInvariants.NameMaxLength)]
        public string Name { get; private set; }

        [Required]
        public Address Address { get; private set; }

        public virtual IReadOnlyCollection<Transaction> Transactions => _transactions.AsReadOnly();
        private List<Transaction> _transactions = new List<Transaction>();

        private Partner() // EF
        {}

        public Partner(string name, Address address)
        {
            UpdateName(name);
            UpdateAddress(address);
        }

        /// <summary>
        /// Generate a new sales transaction with this partner.
        /// </summary>
        public Transaction SellTo(IEnumerable<(Product product, int quantity)> items)
            => CreateTransaction(items, TransactionType.Sales);

        /// <summary>
        /// Generate a new procurement transaction with this partner.
        /// </summary>
        public Transaction ProcureFrom(IEnumerable<(Product product, int quantity)> items)
            => CreateTransaction(items, TransactionType.Procurement);

        public void UpdateName(string value)
        {
            if (string.IsNullOrWhiteSpace(value))
                throw new ArgumentException("Name cannot be empty.");

            if (value.Length > PartnerInvariants.NameMaxLength)
                throw new ArgumentException($"Length of value ({value.Length}) exceeds maximum name length ({ProductInvariants.NameMaxLength}).");

            Name = value;
        }

        public void UpdateAddress(Address address)
        {
            Address = address ?? throw new ArgumentNullException(nameof(address));
        }

        private Transaction CreateTransaction(IEnumerable<(Product product, int quantity)> items, TransactionType transactionType)
        {
            if (items == null)
                throw new ArgumentNullException(nameof(items));

            if (!items.Any() || items.Any(x => x.product == null || x.quantity < 1))
                throw new ArgumentException("List of items must be a non-empty list of non-null products and quantities of at least 1.", nameof(items));

            var transaction = new Transaction(
                type: transactionType,
                partner: this
            );

            foreach (var (product, quantity) in items)
            {
                transaction.AddTransactionLine(product, quantity);
            }

            _transactions.Add(transaction);

            return transaction;
        }
    }
}