Example #1
0
        public async Task <SayfaliListe <ArkadaslikTeklif> > ListeGetirTekliflerAsync(ArkadaslikSorgusu sorguNesnesi)
        {
            if (!propertyMappingService.ValidMappingsExistsFor <ArkadaslarimListeDto, ArkadaslikTeklif>(sorguNesnesi.SiralamaCumlesi))
            {
                throw new ArgumentException("Sıralama bilgisi yanlış!");
            }

            if (!typeHelperService.TryHastProperties <ArkadaslarimListeDto>(sorguNesnesi.Alanlar))
            {
                throw new ArgumentException("Gösterilmek istenen alanlar hatalı!");
            }


            var siralamaBilgisi = propertyMappingService.GetPropertyMapping <ArkadaslarimListeDto, ArkadaslikTeklif>();

            sorgu = sorgu.SiralamayiAyarla(sorguNesnesi.SiralamaCumlesi, siralamaBilgisi);

            sorgu = sorgu.Where(teklif => teklif.TeklifEdenNo == sorguNesnesi.KullaniciNo || teklif.TeklifEdilenNo == sorguNesnesi.KullaniciNo);

            if (sorguNesnesi.KabulEdilenler == true)
            {
                sorgu = sorgu.Where(teklif => teklif.Karar == true);
            }
            if (sorguNesnesi.TeklifEdenler == true)
            {
                sorgu = sorgu.Where(teklif => teklif.TeklifEdilenNo == sorguNesnesi.KullaniciNo);
            }
            if (sorguNesnesi.TeklifEdilenler == true)
            {
                sorgu = sorgu.Where(teklif => teklif.TeklifEdenNo == sorguNesnesi.KullaniciNo);
            }
            if (sorguNesnesi.CevapBeklenenler == true)
            {
                sorgu = sorgu.Where(teklif => teklif.Karar == null);
            }
            if (sorguNesnesi.Silinenler == true)
            {
                sorgu = sorgu.Where(teklif => teklif.IptalEdildi == true);
            }
            if (sorguNesnesi.Cevaplananlar == true)
            {
                sorgu = sorgu.Where(teklif => teklif.Karar != null);
            }
            if (!string.IsNullOrWhiteSpace(sorguNesnesi.AramaCumlesi))
            {
                sorgu = AramaCumlesiniAyarla(sorguNesnesi);
            }


            //sorgu = sorgu.Where(ark => ark.IptalEdildi == null || ark.IptalEdildi.Value != true);

            var sonuc = await SayfaliListe <ArkadaslikTeklif> .SayfaListesiYarat(sorgu, sorguNesnesi.Sayfa, sorguNesnesi.SayfaBuyuklugu);

            return(sonuc);
        }
Example #2
0
        public async Task <SayfaliListe <Mesaj> > ListeleKullaniciyaGelenMesajlarAsync(MesajSorgu sorguNesnesi)
        {
            if (sorguNesnesi.KullaniciNo == null)
            {
                throw new ArgumentException("Sisteme giriş yapmış kullanıcı bilgisi yok");
            }

            if (!propertyMappingService.ValidMappingsExistsFor <MesajListeDto, Mesaj>(sorguNesnesi.SiralamaCumlesi))
            {
                throw new ArgumentException("Sıralama bilgisi yanlış!");
            }

            if (!typeHelperService.TryHastProperties <MesajListeDto>(sorguNesnesi.Alanlar))
            {
                throw new ArgumentException("Gösterilmek istenen alanlar hatalı!");
            }


            if (!string.IsNullOrEmpty(sorguNesnesi.AramaCumlesi))
            {
                var anahtarKelimeler = sorguNesnesi.AramaCumlesi.Split(' ');
                if (anahtarKelimeler.Length > 0)
                {
                    //Anahtar kelimeler ile ne aranmak isteniyorsa buraya yaz
                }
            }

            if (sorguNesnesi.GelenMesajlar == true)
            {
                Sorgu = Sorgu.Where(m => m.AlanNo == sorguNesnesi.KullaniciNo.Value);
            }
            else if (sorguNesnesi.GidenMesajlar == true)
            {
                Sorgu = Sorgu.Where(m => m.GonderenNo == sorguNesnesi.KullaniciNo.Value);
            }

            if (sorguNesnesi.OkunmamisMesajlar == true)
            {
                Sorgu = Sorgu.Where(m => m.Okundu == false);
            }

            Sorgu = Sorgu.Where(m => (m.GonderenNo == sorguNesnesi.KullaniciNo && m.GonderenSildi == false) || (m.AlanNo == sorguNesnesi.KullaniciNo && m.AlanSildi == false));
            var siralamaBilgisi = propertyMappingService.GetPropertyMapping <MesajListeDto, Mesaj>();

            var siralanmisSorgu = Sorgu.SiralamayiAyarla(sorguNesnesi.SiralamaCumlesi, siralamaBilgisi);
            var sonuc           = await SayfaliListe <Mesaj> .SayfaListesiYarat(siralanmisSorgu, sorguNesnesi.Sayfa, sorguNesnesi.SayfaBuyuklugu);

            return(sonuc);
        }
        public async Task <SayfaliListe <Kullanici> > ListeGetirKullanicilarTumuAsync(KullaniciSorgu sorguNesnesi)
        {
            if (!propertyMappingService.ValidMappingsExistsFor <KullaniciListeDto, Kullanici>(sorguNesnesi.SiralamaCumlesi))
            {
                throw new ArgumentException("Sıralama bilgisi yanlış!");
            }

            if (!typeHelperService.TryHastProperties <KullaniciListeDto>(sorguNesnesi.Alanlar))
            {
                throw new ArgumentException("Gösterilmek istenen alanlar hatalı!");
            }


            if (!string.IsNullOrEmpty(sorguNesnesi.AramaCumlesi))
            {
                var anahtarKelimeler = sorguNesnesi.AramaCumlesi.Split(' ');
                if (anahtarKelimeler.Length > 0)
                {
                    switch (anahtarKelimeler.Length)
                    {
                    case 1:
                        var tekKelime = anahtarKelimeler[0].Trim().ToLower();
                        Sorgu = Sorgu.Where(k => k.Kisi.Ad.ToLower().Contains(tekKelime) || k.Kisi.Soyad.ToLower().Contains(tekKelime));
                        break;

                    case 2:
                        var ad    = anahtarKelimeler[0].Trim().ToLower();
                        var soyad = anahtarKelimeler[1].Trim().ToLower();
                        Sorgu = Sorgu.Where(k => k.Kisi.Ad.ToLower().Contains(ad) && k.Kisi.Soyad.ToLower().Contains(soyad));
                        break;

                    case 3:
                        var ad2     = anahtarKelimeler[0].Trim().ToLower();
                        var soyad2  = anahtarKelimeler[1].Trim().ToLower();
                        var digerAd = anahtarKelimeler[2].Trim().ToLower();
                        Sorgu = Sorgu.Where(k => k.Kisi.Ad.ToLower().Contains(ad2) && k.Kisi.DigerAd.ToLower().Contains(digerAd) && k.Kisi.Soyad.ToLower().Contains(soyad2));
                        break;
                    }
                }
            }
            var siralamaBilgisi = propertyMappingService.GetPropertyMapping <KullaniciListeDto, Kullanici>();
            var siralanmisSorgu = Sorgu.SiralamayiAyarla(sorguNesnesi.SiralamaCumlesi, siralamaBilgisi);
            var sonuc           = await SayfaliListe <Kullanici> .SayfaListesiYarat(siralanmisSorgu, sorguNesnesi.Sayfa, sorguNesnesi.SayfaBuyuklugu);

            return(sonuc);
        }
        public async Task <SayfaliListe <KisiCinsiyet> > ListeGetirCinsiyetAsync(CinsiyetSorgu sorguNesnesi = null)
        {
            if (sorguNesnesi != null)
            {
                if (!propertyMappingService.ValidMappingsExistsFor <CinsiyetDto, KisiCinsiyet>(sorguNesnesi.SiralamaCumlesi))
                {
                    throw new ArgumentException("Sıralama bilgisi yanlış!");
                }

                if (!typeHelperService.TryHastProperties <CinsiyetDto>(sorguNesnesi.Alanlar))
                {
                    throw new ArgumentException("Gösterilmek istenen alanlar hatalı!");
                }


                if (!string.IsNullOrEmpty(sorguNesnesi.AramaCumlesi))
                {
                    var anahtarKelimeler = sorguNesnesi.AramaCumlesi.Split(' ');
                    if (anahtarKelimeler.Length > 0)
                    {
                        switch (anahtarKelimeler.Length)
                        {
                        case 1:
                            Sorgu = Sorgu.Where(k => k.CinsiyetAdi.Contains(anahtarKelimeler[0]));
                            break;

                        default:
                            Sorgu = Sorgu;
                            break;
                        }
                    }
                }
                var siralamaBilgisi = propertyMappingService.GetPropertyMapping <CinsiyetDto, KisiCinsiyet>();
                var siralanmisSorgu = Sorgu.SiralamayiAyarla(sorguNesnesi.SiralamaCumlesi, siralamaBilgisi);
                var siraliSonuc     = await SayfaliListe <KisiCinsiyet> .SayfaListesiYarat(siralanmisSorgu, sorguNesnesi.Sayfa, sorguNesnesi.SayfaBuyuklugu);

                return(siraliSonuc);
            }
            else
            {
                var sonuc = await Sorgu.SayfaListesiYarat <KisiCinsiyet>();

                return(sonuc);
            }
        }
Example #5
0
        public async Task <SayfaliListe <Soru> > ListeGetirSorularAsync(SoruSorgu sorguNesnesi)
        {
            if (sorguNesnesi.DersNo == null && sorguNesnesi.KonuNo == null && sorguNesnesi.BirimNo == null && sorguNesnesi.ProgramNo == null && sorguNesnesi.DonemNo == null && sorguNesnesi.DersGrubuNo == null)
            {
                throw new Exception("Kriterler eksik");
            }

            if (!propertyMappingService.ValidMappingsExistsFor <SoruListeDto, Soru>(sorguNesnesi.SiralamaCumlesi))
            {
                throw new ArgumentException("Sıralama bilgisi yanlış!");
            }

            if (!typeHelperService.TryHastProperties <SoruListeDto>(sorguNesnesi.Alanlar))
            {
                throw new ArgumentException("Gösterilmek istenen alanlar hatalı!");
            }
            FiltreleriAyarla(sorguNesnesi);
            store.Sorgu = store.Sorgu.Where(s => s.Silindi == null);
            SayfaliListe <Soru> sonuc = await Listele(sorguNesnesi);

            return(sonuc);
        }