public async Task <CatalogItem> Create(int catalogId, CatalogItemKind itemKind, string name, int value)
        {
            var item = new CatalogItem
            {
                CatalogId = catalogId,
                Kind      = itemKind,
                Name      = name,
                Value     = value
            };

            return(await Create(item));
        }
        private async Task VerifyCatalogItem(CatalogItemKind validCatalogItemKind, int catalogItemId)
        {
            var catalogItem = await CatalogItemService.Get(catalogItemId);

            if (catalogItem == null)
            {
                throw new EntityNotFoundException(
                          $"CatalogItemId:{catalogItemId} doesn't exist",
                          nameof(catalogItemId));
            }

            if (!catalogItem.Kind.Equals(validCatalogItemKind))
            {
                throw new ArgumentException(
                          $"CatalogItem can't be set because it has a different kind. Necessary kind:{validCatalogItemKind}, catalog item kind:{catalogItem.Kind}");
            }
        }
        public async Task <PricelistAM> CreatePricelistBlank(
            CatalogKind catalogKind         = CatalogKind.Cargo,
            CatalogItemKind catalogItemKind = CatalogItemKind.Weight)
        {
            var catalogItems = await CatalogService.GetCatalogItems(catalogKind, catalogItemKind);

            var result = new PricelistAM();

            foreach (var catalogItem in catalogItems)
            {
                var price = new PriceAM
                {
                    CatalogItemId        = catalogItem.Id,
                    CommissionPercentage = Price.DefaultComissionPercentage,
                    Name = catalogItem.Name
                };

                result.Items.Add(price);
            }

            return(result);
        }
 public async Task <ICollection <CatalogItem> > GetByKind(int catalogId, CatalogItemKind kind)
 {
     return(await Entities.Where(
                e => e.CatalogId.Equals(catalogId) &&
                e.Kind.Equals(kind)).ToListAsync());
 }
        public async Task <ICollection <CatalogItem> > GetByKind(CatalogKind catalogKind, CatalogItemKind itemKind)
        {
            var catalog = await CatalogService.GetByKind(catalogKind);

            if (catalog == null)
            {
                throw new EntityNotFoundException(
                          $"can't find catalogItem with catalogKind:{catalogKind}",
                          nameof(catalogKind));
            }

            return(await Repository.GetByKind(catalog.Id, itemKind));
        }
        public async Task <List <CatalogItemAM> > GetCatalogItems(CatalogKind catalogKind, CatalogItemKind catalogItemKind)
        {
            var domainItems = await DomainCatalogItemService.GetByKind(catalogKind, catalogItemKind);

            var result = new List <CatalogItemAM>();

            foreach (var domainItem in domainItems)
            {
                result.Add(FromDomainEntity(domainItem));
            }

            return(result);
        }