public async Task <Country> UpdateCountryAsync(int id, string name, bool save = true)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException($"Country name could not be null or empty!");
            }

            if (string.IsNullOrWhiteSpace(name))
            {
                throw new ArgumentException($"Country name could not be WhiteSpace!");
            }

            var country = await FindCountryByIDAsync(id);

            if (country == null)
            {
                throw new ArgumentException($"Country with ID {id} does not exist!");
            }
            else
            {
                country.Name = name;
                try
                {
                    context.Update(country);
                    await context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    throw;
                }
            }
            return(country);
        }
        public async Task <Address> UpdateAddressAsync(int id, string addressString, bool save = true)
        {
            if (string.IsNullOrEmpty(addressString))
            {
                throw new ArgumentNullException($"Address could not be null or empty!");
            }

            if (string.IsNullOrWhiteSpace(addressString))
            {
                throw new ArgumentException($"Address could not be WhiteSpace!");
            }

            var address = await FindAddressByIDAsync(id);

            if (address == null)
            {
                throw new ArgumentException($"Address with ID {id} does not exist!");
            }
            else
            {
                address.Name = addressString;
                try
                {
                    context.Update(address);
                    await context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    throw;
                }
            }
            return(address);
        }
        public async Task <Purchase> UpdatePurchaseAsync(
            int purchaseId,
            int supplierId,
            int warehouseId,
            DateTime purchaseDate,
            DateTime deliveryDate,
            DateTime deadlineDate,
            bool save = true)
        {
            var purchase = await FindPurchaseByIDAsync(purchaseId);

            if (purchase == null)
            {
                throw new ArgumentException($"Purchase with ID {purchaseId} does not exist!");
            }
            else
            {
                purchase.SupplierID   = supplierId;
                purchase.WarehouseID  = warehouseId;
                purchase.PurchaseDate = purchaseDate;
                purchase.DeliveryDate = deliveryDate;
                purchase.DeadlineDate = deadlineDate;
                try
                {
                    context.Update(purchase);
                    await context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    throw;
                }
            }
            return(purchase);
        }
        public async Task <Warehouse> UpdateWarehouseAsync(
            int id,
            string warehouseName,
            int countryID,
            int cityID,
            int addressID,
            bool save = true)
        {
            if (string.IsNullOrEmpty(warehouseName))
            {
                throw new ArgumentException($"WarehouseName could not be null or empty!");
            }

            if (string.IsNullOrWhiteSpace(warehouseName))
            {
                throw new ArgumentException($"WarehouseName could not be WhiteSpace!");
            }

            if (this.context.Cities.Find(cityID) == null)
            {
                throw new ArgumentException($"City with ID {cityID} does not exist!");
            }

            if (this.context.Countries.Find(countryID) == null)
            {
                throw new ArgumentException($"Country with ID {cityID} does not exist!");
            }

            if (this.context.Addresses.Find(addressID) == null)
            {
                throw new ArgumentException($"Address with ID {cityID} does not exist!");
            }

            var warehouse = await FindWarehouseByIDAsync(id);

            if (warehouse == null)
            {
                throw new ArgumentException($"Warehouse with ID {id} does not exist!");
            }
            else
            {
                warehouse.Name      = warehouseName;
                warehouse.CountryID = countryID;
                warehouse.CityID    = cityID;
                warehouse.AddressID = addressID;
                try
                {
                    context.Update(warehouse);
                    await context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    throw;
                }
            }
            return(warehouse);
        }
        public async Task <Supplier> UpdateSupplierAsync(
            int id,
            string supplierName,
            string uin,
            int countryId,
            int cityId,
            int addressId,
            string userId,
            bool isDeleted,
            bool save = true)
        {
            if (string.IsNullOrEmpty(supplierName))
            {
                throw new ArgumentNullException($"supplierName could not be null or empty!");
            }

            if (string.IsNullOrWhiteSpace(supplierName))
            {
                throw new ArgumentException($"supplierName could not be WhiteSpace!");
            }

            var supplier = await FindSupplierByIDAsync(id);

            if (supplier == null)
            {
                throw new ArgumentException($"Supplier with ID {id} does not exist!");
            }
            else
            {
                supplier.Name        = supplierName;
                supplier.UIN         = uin;
                supplier.CountryID   = countryId;
                supplier.CityID      = cityId;
                supplier.AddressID   = addressId;
                supplier.StoreUserId = userId;
                supplier.IsDeleted   = isDeleted;
                try
                {
                    context.Update(supplier);
                    await context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    throw;
                }
            }

            return(supplier);
        }