Пример #1
0
        public async Task OnGet(string Wyszukiwarka = null)
        {
            if (Wyszukiwarka == null)
            {
                Wyszukiwarka = "tegonapewnoniema";
            }

            StringBuilder param = new StringBuilder();

            if (Wyszukiwarka != null)
            {
                param.Append(Wyszukiwarka);
            }
            Przepisy = await _baza.Przepis.Where(u => u.Nazwa.ToLower().Contains(Wyszukiwarka.ToLower())).ToListAsync();

            Kategorie1 = await _baza.Przepis.Where(u => u.Kategoria_1.ToLower().Contains(Wyszukiwarka.ToLower())).ToListAsync();

            Kategorie2 = await _baza.Przepis.Where(u => u.Kategoria_2.ToLower().Contains(Wyszukiwarka.ToLower())).ToListAsync();

            Kategorie3 = await _baza.Przepis.Where(u => u.Kategoria_3.ToLower().Contains(Wyszukiwarka.ToLower())).ToListAsync();

            Przepisy.AddRange(Kategorie1);
            Przepisy.AddRange(Kategorie2);
            Przepisy.AddRange(Kategorie3);
            Przepisy = Przepisy.GroupBy(x => x.Id).Select(x => x.First()).ToList();
        }
Пример #2
0
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);
            searchIngredient.Text = "Znalezione przepisy";
            List <String> szukane = e.Parameter as List <String>;

            List <SkladnikiPrzepisu> sk = await App.MobileService.GetTable <SkladnikiPrzepisu>().Where(x => x.Skladnik == szukane.First()).ToListAsync();

            foreach (var s in szukane.Skip(1))
            {
                try
                {
                    var one = await App.MobileService.GetTable <SkladnikiPrzepisu>().Where(x => x.Skladnik == s).ToListAsync();

                    //one.Intersect(sk);
                    sk = one;
                } catch (ArgumentOutOfRangeException ex) { }
            }

            sk.ForEach(s => SkladnikiPrzepisu.Add(s));

            foreach (var p in SkladnikiPrzepisu)
            {
                List <Przepis> przepisy = await App.MobileService.GetTable <Przepis>().Where(x => x.Id == p.Przepis).ToListAsync();

                przepisy.ForEach(x => Przepisy.Add(x));
            }
            if (sk.Count() == 0)
            {
                searchIngredient.Text = "Nie znaleziono przepisu";
            }
        }
 public DodajPrzepisViewModel(MainWindowViewModel parentVM, int?idPrzepisu)
 {
     ParentVM = parentVM;
     wypiszKategorie();
     wypiszNazwySkladnikow();
     wypiszJednostki();
     idEdytowanegoPrzepisu = idPrzepisu;
     if (idPrzepisu != null)
     {
         isEdit       = true;
         windowTitle  = "Edytuj przepis";
         btnDodajText = "Zapisz";
         EntityMethods en = new EntityMethods();
         Przepisy      p  = en.pobierzPrzepis((int)idPrzepisu);
         nazwa       = p.NAZWA;
         opis        = p.OPIS;
         notatki     = p.NOTATKI;
         iloscPorcji = p.ILOSC_PORCJI.ToString();
         int?czasWM  = p.CZAS_PRZYRZADZENIA;
         int?godziny = czasWM / 60;
         czasH = godziny.ToString();
         int?minuty = czasWM - godziny * 60;
         czasM = minuty.ToString();
         string kategoria = en.kategoriaPrzepisu((int)idPrzepisu);
         kategorieSelection = kategorie.First(x => x == kategoria);
         byte[] zdj = new byte[0];
         zdj     = (byte[])p.ZDJECIE;
         zdjecie = null;
         if (zdj != null && zdj.Length > 0)
         {
             MemoryStream stream = new MemoryStream(zdj);
             zdjecie = BitmapFrame.Create(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
         }
         listaSkladnikow = new ObservableCollection <SkladnikPrzepisu>();
         foreach (SkladnikPrzepisu sp in en.skladnikiPrzepisu((int)idPrzepisu))
         {
             listaSkladnikow.Add(sp);
         }
     }
     else
     {
         windowTitle  = "Dodaj nowy przepis";
         btnDodajText = "Dodaj";
     }
 }
Пример #4
0
        private void wydrukujPrzepis()
        {
            PrintDialog printDialog = new PrintDialog();

            if (printDialog.ShowDialog() == true)
            {
                FlowDocument  doc = new FlowDocument();
                Section       sec = new Section();
                EntityMethods en  = new EntityMethods();
                Przepisy      p   = en.pobierzPrzepis(listaPrzepisowSelection.ID);
                Paragraph     pg  = new Paragraph();
                Bold          bld = new Bold();
                bld.Inlines.Add(new Run(p.NAZWA));
                pg.Inlines.Add(bld);
                pg.Inlines.Add(new Run("\n\n" + "Kategoria: " + en.kategoriaPrzepisu(p.ID_KATEGORII.Value)));
                pg.Inlines.Add(new Run("\nIlość porcji: " + p.ILOSC_PORCJI.ToString()));
                int?czasM   = p.CZAS_PRZYRZADZENIA;
                int?godziny = czasM / 60;
                int?minuty  = czasM - godziny * 60;
                pg.Inlines.Add(new Run("\nCzas przyrządzenia: " + godziny + " h " + minuty + " m "));
                pg.Inlines.Add(new Run("\n\nOpis:\n" + p.OPIS));
                string skladniki = "";
                List <SkladnikPrzepisu> listaSkladnikow = en.skladnikiPrzepisu(p.ID_PRZEPISU);
                foreach (SkladnikPrzepisu s in listaSkladnikow)
                {
                    if (String.IsNullOrWhiteSpace(s.ILOSC.ToString()) && String.IsNullOrWhiteSpace(s.JEDNOSTKA))
                    {
                        skladniki += s.NAZWA + "\n";
                    }
                    else
                    {
                        skladniki += s.NAZWA + " - " + s.ILOSC.ToString() + " " + s.JEDNOSTKA + "\n";
                    }
                }
                pg.Inlines.Add(new Run("\n\nSkładniki:\n" + skladniki));
                if (!String.IsNullOrWhiteSpace(p.NOTATKI))
                {
                    pg.Inlines.Add(new Run("\nNotatki:\n" + p.NOTATKI));
                }
                sec.Blocks.Add(pg);
                doc.Blocks.Add(sec);
                IDocumentPaginatorSource idpSource = doc;
                printDialog.PrintDocument(idpSource.DocumentPaginator, "Drukowanie przepisu");
            }
        }
        private void dodajPrzepisAkcja()
        {
            EntityMethods en = new EntityMethods();

            ElementGrid pTest = null;

            if (ParentVM.listaPrzepisow.Count > 0)
            {
                try
                {
                    pTest = ParentVM.listaPrzepisow.First(x => x.NAZWA == nazwa);
                }
                catch (Exception)
                {
                    pTest = null;
                }
            }
            if (pTest == null)
            {
                Przepisy p = new Przepisy();
                p.NAZWA        = nazwa;
                p.NOTATKI      = notatki;
                p.OPIS         = opis;
                p.ILOSC_PORCJI = Double.Parse(iloscPorcji);
                p.ID_KATEGORII = en.idKategoriiPrzepisu(kategorieSelection);
                int czas = 0;
                if (czasH != null)
                {
                    czas = Int32.Parse(czasH) * 60 + Int32.Parse(czasM);
                }
                else
                {
                    czas = Int32.Parse(czasM);
                }
                p.CZAS_PRZYRZADZENIA = czas;
                if (isEdit == false)
                {
                    string path  = ((BitmapImage)zdjecie).UriSource.OriginalString;
                    byte[] image = File.ReadAllBytes(path);
                    p.ZDJECIE = image;

                    idEdytowanegoPrzepisu = en.dodajPrzepis(p);
                }
                else
                {
                    if (zdjecie.GetType() == typeof(BitmapImage))
                    {
                        string path  = ((BitmapImage)zdjecie).UriSource.OriginalString;
                        byte[] image = File.ReadAllBytes(path);
                        p.ZDJECIE = image;
                    }
                    else
                    {
                        p.ZDJECIE = null;
                    }

                    p.ID_PRZEPISU = (int)idEdytowanegoPrzepisu;

                    en.edytujPrzepis(p);

                    en.czyscPrzepisySkladniki((int)idEdytowanegoPrzepisu);
                }

                List <Przepisy_Skladniki> lista = new List <Przepisy_Skladniki>();
                foreach (SkladnikPrzepisu sp in listaSkladnikow)
                {
                    Przepisy_Skladniki ps = new Przepisy_Skladniki();
                    ps.L_ID_PRZEPISU = (int)idEdytowanegoPrzepisu;
                    if (sp.ILOSC != null)
                    {
                        ps.ILOSC = sp.ILOSC;
                    }
                    if (!String.IsNullOrWhiteSpace(sp.JEDNOSTKA))
                    {
                        ps.ID_JEDNOSTKI = en.pobierzIdJednostki(sp.JEDNOSTKA);
                    }
                    ps.L_ID_SKLADNIKA = en.idSkladnika(sp.NAZWA);
                    en.dodajPrzepisySkladniki(ps);
                }

                ParentVM.wypiszPrzepisy((int)idEdytowanegoPrzepisu);
                CloseAction();
            }
            else
            {
                MessageBoxShow mb = new MessageBoxShow();
                mb.pokazMessageBox("Informacja", "Został już dodany taki przepis.", MessageBoxTyp.Normalny, MessageBoxIkona.Informacyjna);
            }
        }