コード例 #1
0
        public async Task <List <StanAktualnyDto> > Handle(StanAktualnyMagazynuQuery request, CancellationToken cancellationToken)
        {
            var listaProduktow = await _produktRepository.GetList(request.PrzedsiebiorstwoId);

            var stanAktualny = await wydanieService.GetStanMagazynu(request.MagazynId, request.PrzedsiebiorstwoId);

            return(stanAktualny.GroupBy(x => x.ProduktId).Select((x, idx) => new StanAktualnyDto
            {
                Id = idx + 1,
                ProduktId = x.Key,
                Nazwa = listaProduktow.Single(p => p.Id == x.Key).Nazwa,
                Skrot = listaProduktow.Single(p => p.Id == x.Key).Skrot,
                JednostkaMiary = listaProduktow.Single(p => p.Id == x.Key).JednostkaMiary.Nazwa,
                Ilosc = x.Sum(pd => pd.Ilosc),
                WartoscNetto = x.Sum(pd => pd.WartoscNetto),
                WartoscVat = x.Sum(pd => pd.WartoscVat),
                WartoscBrutto = x.Sum(pd => pd.WartoscBrutto)
            }).ToList());
        }
コード例 #2
0
        public async Task <Guid> Handle(GenerujDokumentWydaniaCommand request, CancellationToken cancellationToken)
        {
            var rezerwacje = await _rezerwacjaRepository.GetList(request.PrzedsiebiorstwoId);

            var rezerwacja = rezerwacje.Single(x => x.Id == request.RezerwacjaId);
            var produkty   = await _produktRepository.GetList(request.PrzedsiebiorstwoId);

            var magazynId = produkty.First(x => x.Id == rezerwacja.PozycjeRezerwacji.First().ProduktId).MagazynId;

            return(await _mediator.Send(new WydajCommand(request.PrzedsiebiorstwoId, new WydanieCreateModel
            {
                Data = DateTime.Now,
                MagazynId = magazynId,
                Pozycje = rezerwacja.PozycjeRezerwacji.Select(x => new PozycjaWydaniaModel
                {
                    ProduktId = x.ProduktId,
                    Ilosc = x.Ilosc
                }).ToList()
            })));
        }
コード例 #3
0
        public async Task <List <ProduktDto> > Handle(ProduktListQuery request, CancellationToken cancellationToken)
        {
            var result = await _produktRepository.GetList(request.PrzedsiebiorstwoId);

            return(result.Select(x => new ProduktDto
            {
                Id = x.Id,
                Skrot = x.Skrot,
                Nazwa = x.Nazwa,
                JednostkaMiary = new JednostkaMiaryDto
                {
                    Id = x.JednostkaMiary.Id,
                    Name = x.JednostkaMiary.Nazwa
                },
                Kategoria = new KategoriaDto
                {
                    Id = x.Kategoria.Id,
                    Name = x.Kategoria.Nazwa
                }
            }).ToList());
        }
コード例 #4
0
        public async Task<Guid> Handle(PrzesunCommand request, CancellationToken cancellationToken)
        {
            var stanyAktualne = await _stanyAktualneService.GetStanMagazynu(request.Model.MagazynWydajacyId, request.PrzedsiebiorstwoId);
            var orderedStanyAktualne = stanyAktualne.Where(x => x.Ilosc > 0)
                .OrderBy(x => x.CenaNetto).ThenBy(x => x.CenaBrutto).ToList();

            var produkty = await _produktRepository.GetList(request.PrzedsiebiorstwoId);

            var pozycjeDokumentuWydania = new List<PozycjaDokumentu>();
            var pozycjeDokumentuPrzyjecia = new List<PozycjaDokumentu>();
            foreach (var p in request.Model.Pozycje)
            {
                var iloscDoWydania = p.Ilosc;
                for (var i = 0; i < orderedStanyAktualne.Count(x => x.ProduktId == p.ProduktId) && iloscDoWydania > 0; i++)
                {
                    var stan = orderedStanyAktualne.Where(x => x.ProduktId == p.ProduktId).ToList()[i];
                    var iloscWydawana = iloscDoWydania > stan.Ilosc ? stan.Ilosc : iloscDoWydania;
                    var pozycjaDokumentuWydania = new PozycjaDokumentu
                    {
                        Id = Guid.NewGuid(),
                        CenaNetto = stan.CenaNetto,
                        CenaBrutto = stan.CenaBrutto,
                        Ilosc = iloscWydawana,
                        ProduktId = stan.ProduktId,
                        StawkaVat = stan.StawkaVat,
                        WartoscNetto = decimal.Round(stan.Ilosc * iloscWydawana),
                        WartoscVat = decimal.Round(stan.Ilosc * iloscWydawana * stan.StawkaVat.GetStawkaVat()),
                        WartoscBrutto = decimal.Round(stan.Ilosc * iloscWydawana) + decimal.Round(stan.Ilosc * iloscWydawana * stan.StawkaVat.GetStawkaVat())
                    };
                    pozycjeDokumentuWydania.Add(pozycjaDokumentuWydania);

                    var pozycjaDokumentuPrzyjecia = new PozycjaDokumentu
                    {
                        Id = Guid.NewGuid(),
                        CenaNetto = stan.CenaNetto,
                        CenaBrutto = stan.CenaBrutto,
                        Ilosc = iloscWydawana,
                        ProduktId = await UtworzProduktNaMagazyniePrzyjecia(produkty, p.ProduktId, request.Model.MagazynPrzyjmujacyId),
                        StawkaVat = stan.StawkaVat,
                        WartoscBrutto = pozycjaDokumentuWydania.WartoscBrutto,
                        WartoscNetto = pozycjaDokumentuWydania.WartoscNetto,
                        WartoscVat = pozycjaDokumentuWydania.WartoscVat
                    };
                    pozycjeDokumentuPrzyjecia.Add(pozycjaDokumentuPrzyjecia);

                    iloscDoWydania -= pozycjaDokumentuWydania.Ilosc;
                }

                if (iloscDoWydania > 0)
                {
                    throw new BussinessException("Niewystarczający stan magazynowy");
                }
            }

            var dokumentMinus = new Dokument
            {
                Id = Guid.NewGuid(),
                Data = request.Model.Data,
                MagazynId = request.Model.MagazynWydajacyId,
                Numer = $"MM-/{await GetLicznikDokumentu(request.PrzedsiebiorstwoId, request.Model.Data.Year)}/{request.Model.Data.Year}",
                TypDokumentu = TypDokumentu.PrzesuniecieMiedzymagazynoweUjemne,
                PozycjeDokumentu = pozycjeDokumentuWydania
            };

            var dokumentPlus = new Dokument
            {
                Id = Guid.NewGuid(),
                Data = request.Model.Data,
                MagazynId = request.Model.MagazynPrzyjmujacyId,
                Numer = $"MM+/{await GetLicznikDokumentu(request.PrzedsiebiorstwoId, request.Model.Data.Year)}/{request.Model.Data.Year}",
                TypDokumentu = TypDokumentu.PrzesuniecieMiedzymagazynoweDodatnie,
                PozycjeDokumentu = pozycjeDokumentuPrzyjecia
            };

            await _dokumentRepository.Save(dokumentMinus);
            await _dokumentRepository.Save(dokumentPlus);

            return dokumentMinus.Id;
        }