Ejemplo 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);
        }
Ejemplo n.º 2
0
        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;
                }
            }
        }
Ejemplo n.º 3
0
        public void TestVonOnly()
        {
            var abschnitt = AbschnittParser.Parse("1", "", AbschnittTypEnum.Paragraph);

            Assert.That(abschnitt, Is.Not.Null);
            Assert.That(abschnitt.NummerVon, Is.EqualTo("1"));
            Assert.That(abschnitt.BuchstabeVon, Is.EqualTo(""));
            Assert.That(abschnitt.BuchstabeBis, Is.EqualTo(""));
            Assert.That(abschnitt.NummerBisSpecified, Is.False);
        }
Ejemplo n.º 4
0
        public void BaseCompound(string numberString)
        {
            int    nummer;
            string buchstabe;

            bool ok = AbschnittParser.Parse(numberString, out nummer, out buchstabe);

            Assert.That(ok, Is.True);
            Assert.That(nummer, Is.EqualTo(6));
            Assert.That(buchstabe, Is.EqualTo("a"));
        }
Ejemplo n.º 5
0
        public void BaseNumberOnly(string numberString)
        {
            int    nummer;
            string buchstabe;

            bool ok = AbschnittParser.Parse(numberString, out nummer, out buchstabe);

            Assert.That(ok, Is.True);
            Assert.That(nummer, Is.EqualTo(1));
            Assert.That(buchstabe.Length, Is.EqualTo(0));
        }
Ejemplo n.º 6
0
        public void TestVonBisWithInvalidBis()
        {
            var abschnitt = AbschnittParser.Parse("1", "c", AbschnittTypEnum.Paragraph);

            Assert.That(abschnitt, Is.Null);
        }
Ejemplo n.º 7
0
        public void TestEmptyVon()
        {
            var abschnitt = AbschnittParser.Parse("", "1a", AbschnittTypEnum.Paragraph);

            Assert.That(abschnitt, Is.Null);
        }