Esempio n. 1
0
        private Req.T_OGDSearchRequest PrepareAdvancedSearch(RisAdvancedQueryParameter param)
        {
            var request = new Req.T_OGDSearchRequest();

            if (!String.IsNullOrWhiteSpace(param.Suchworte))
            {
                request.Suchworte = QueryParser.Parse(param.Suchworte);
            }

            if (!String.IsNullOrWhiteSpace(param.TitelAbkuerzung))
            {
                request.Titel = QueryParser.Parse(param.TitelAbkuerzung);
            }

            if (param.AbschnittTyp != AbschnittTypEnum.NotSpecifiedInQuery)
            {
                var abschnitt = AbschnittParser.Parse(param.Von, param.Bis, param.AbschnittTyp);

                if (null != abschnitt)
                {
                    request.Abschnitt = abschnitt;
                }
            }

            if (!String.IsNullOrWhiteSpace(param.Kundmachungsorgan))
            {
                request.Kundmachungsorgan = new Req.PhraseSearchExpression()
                {
                    Value = param.Kundmachungsorgan
                };
            }

            if (!String.IsNullOrWhiteSpace(param.KundmachungsorganNummer))
            {
                request.Kundmachungsorgannummer = new Req.PhraseSearchExpression()
                {
                    Value = param.KundmachungsorganNummer
                };
            }

            if (!String.IsNullOrWhiteSpace(param.Index))
            {
                request.Index = QueryParser.Parse(param.Index);
            }

            if (param.Unterzeichnungsdatum.HasValue)
            {
                // Does not exist on Service interface
                throw new NotImplementedException();
            }

            if (param.FassungVom.HasValue)
            {
                request.FassungVom          = param.FassungVom.Value.Date;
                request.FassungVomSpecified = true;
            }

            return(request);
        }
        private void ValidateAbschnitt(RisAdvancedQueryParameter p)
        {
            var inputmask = new Dictionary <AbschnittTypEnum, bool>();

            inputmask[AbschnittTypEnum.Paragraph] = !String.IsNullOrWhiteSpace(ParagrafVon) || !String.IsNullOrWhiteSpace(ParagrafBis);
            inputmask[AbschnittTypEnum.Artikel]   = !String.IsNullOrWhiteSpace(ArtikelVon) || !String.IsNullOrWhiteSpace(ArtikelBis);
            inputmask[AbschnittTypEnum.Anlage]    = !String.IsNullOrWhiteSpace(AnlageVon) || !String.IsNullOrWhiteSpace(AnlageBis);

            int countOfAbschnitteSpecified = inputmask.Count(kvp => kvp.Value);

            // If not specified at all, return immediately
            if (0 == countOfAbschnitteSpecified)
            {
                return;
            }

            if (countOfAbschnitteSpecified > 1)
            {
                ValidationMessage += "Paragraph, Artikel, Anlage dürfen jeweils nur ausschließlich eingegeben werden" + Environment.NewLine;
            }
            else
            {
                string           von, bis;
                AbschnittTypEnum typ;
                if (inputmask[AbschnittTypEnum.Paragraph])
                {
                    von = ParagrafVon;
                    bis = ParagrafBis;
                    typ = AbschnittTypEnum.Paragraph;
                }
                else if (inputmask[AbschnittTypEnum.Artikel])
                {
                    von = ArtikelVon;
                    bis = ArtikelBis;
                    typ = AbschnittTypEnum.Artikel;
                }
                else
                {
                    von = AnlageVon;
                    bis = AnlageBis;
                    typ = AbschnittTypEnum.Anlage;
                }

                var abschnitt = AbschnittParser.Parse(von, bis, typ);

                if (null == abschnitt)
                {
                    ValidationMessage += typ.ToString() + " Von-Bis ungültig" + Environment.NewLine;
                }
                else
                {
                    p.Von          = von;
                    p.Bis          = bis;
                    p.AbschnittTyp = typ;
                }
            }
        }
        public void InitializeFromParameter(RisAdvancedQueryParameter param)
        {
            Suchworte       = param.Suchworte;
            TitelAbkuerzung = param.TitelAbkuerzung;

            switch (param.AbschnittTyp)
            {
            case AbschnittTypEnum.Paragraph:
                ParagrafVon = param.Von;
                ParagrafBis = param.Bis;
                break;

            case AbschnittTypEnum.Artikel:
                ArtikelVon = param.Von;
                ArtikelBis = param.Bis;
                break;

            case AbschnittTypEnum.Anlage:
                AnlageVon = param.Von;
                AnlageBis = param.Bis;
                break;
            }

            SelectKundmachungsorgan(param.Kundmachungsorgan);
            KundmachungsorganNummer = param.KundmachungsorganNummer;
            Typ   = param.Typ;
            Index = param.Index;

            if (param.Unterzeichnungsdatum.HasValue)
            {
                Unterzeichnungsdatum = param.Unterzeichnungsdatum.Value.ToString("d");
            }
            if (param.FassungVom.HasValue)
            {
                FassungVom = param.FassungVom.Value.ToString("d");
            }

            SelectImRisSeitListItem(param.ImRisSeit);
        }
        private RisAdvancedQueryParameter Validate()
        {
            var p = new RisAdvancedQueryParameter();

            p.Suchworte       = ValidatePhraseExpressionText(Suchworte, "Suchworte enthält keine gültige Abfrage");
            p.TitelAbkuerzung = ValidatePhraseExpressionText(TitelAbkuerzung, "Titel, Abkürzung enthält keine gültige Abfrage");

            ValidateAbschnitt(p);

            p.Kundmachungsorgan       = SelectedKundmachungsorgan.Text;
            p.KundmachungsorganNummer = KundmachungsorganNummer;

            p.Typ   = ValidatePhraseExpressionText(Typ, "Typ enthält keine gültige Abfrage");
            p.Index = ValidatePhraseExpressionText(Index, "Index enthält keine gültige Abfrage");

            p.Unterzeichnungsdatum = ValidateNonEmptyTextToDate(Unterzeichnungsdatum, "Unterzeichnungsdatum ist kein gültiges Datum");
            p.FassungVom           = ValidateNonEmptyTextToDate(FassungVom, "Fassung vom ist kein gültiges Datum");
            p.ImRisSeit            = SelectedImRisSeitListItem.ImRisSeit;

            bool anyFailures = !String.IsNullOrWhiteSpace(ValidationMessage);

            return(anyFailures ? null : p);
        }