/// <summary>
        ///     Forespør <see cref="Kvittering" /> for <see cref="Forsendelse">Forsendelser</see>, med mulighet til å samtidig
        ///     <see cref="BekreftAsync">bekrefte</see> på forrige <see cref="Kvittering" /> for å slippe å
        ///     kjøre eget kall for <see cref="BekreftAsync" />. <see cref="Kvittering">Kvitteringer</see> blir tilgjengeliggjort
        ///     etterhvert som de er klare i Meldingsformidler. Det er ikke mulig å etterspørre
        ///     <see cref="Kvittering" /> for en spesifikk forsendelse.
        /// </summary>
        /// <param name="kvitteringsforespørsel"></param>
        /// <param name="forrigeKvittering"></param>
        /// <returns></returns>
        /// <remarks>
        ///     <list type="table">
        ///         <listheader>
        ///             <description>
        ///                 Dersom det ikke er tilgjengelige <see cref="Kvittering">Kvitteringer</see> skal det ventes følgende
        ///                 tidsintervaller før en ny forespørsel gjøres:
        ///             </description>
        ///         </listheader>
        ///         <item>
        ///             <term>normal</term><description>Minimum 10 minutter</description>
        ///         </item>
        ///         <item>
        ///             <term>prioritert</term><description>Minimum 1 minutt</description>
        ///         </item>
        ///     </list>
        /// </remarks>
        public async Task<Kvittering> HentKvitteringOgBekreftForrigeAsync(Kvitteringsforespørsel kvitteringsforespørsel, Forretningskvittering forrigeKvittering)
        {
            if (forrigeKvittering != null)
            {
                await BekreftAsync(forrigeKvittering).ConfigureAwait(false);
            }

            var guidUtility = new GuidUtility();

            Log.Debug($"Utgående kvitteringsforespørsel, messageId '{guidUtility.MessageId}'.");

            var envelopeSettings = new EnvelopeSettings(kvitteringsforespørsel, Databehandler, guidUtility);
            var kvitteringsforespørselEnvelope = new KvitteringsforespørselEnvelope(envelopeSettings);

            ValidateEnvelopeAndThrowIfInvalid(kvitteringsforespørselEnvelope, kvitteringsforespørselEnvelope.GetType().Name);

            var receipt = await RequestHelper.GetReceipt(kvitteringsforespørselEnvelope).ConfigureAwait(false);
            var transportReceiptXml = XmlUtility.TilXmlDokument(receipt.Rådata);

            if (receipt is TomKøKvittering)
            {
                Log.Debug($"{receipt}");
                SecurityValidationOfEmptyQueueReceipt(transportReceiptXml, kvitteringsforespørselEnvelope.Xml());
            }
            else if (receipt is Forretningskvittering)
            {
                Log.Debug($"{receipt}");
                SecurityValidationOfMessageReceipt(transportReceiptXml, kvitteringsforespørselEnvelope);
            }

            return receipt;
        }
 /// <summary>
 ///     Forespør <see cref="Kvittering" /> for <see cref="Forsendelse">Forsendelser</see>.
 ///     <see cref="Kvittering">Kvitteringer</see> blir tilgjengeliggjort etterhvert som de er klare i
 ///     Meldingsformidler. Det er ikke mulig å etterspørre <see cref="Kvittering" /> for en spesifikk
 ///     <see cref="Forsendelse" />.
 /// </summary>
 /// <param name="kvitteringsforespørsel"></param>
 /// <returns></returns>
 /// <remarks>
 ///     <list type="table">
 ///         <listheader>
 ///             <description>
 ///                 Dersom det ikke er tilgjengelige <see cref="Kvittering">Kvitteringer</see> skal det ventes følgende
 ///                 tidsintervaller før en ny forespørsel gjøres:
 ///             </description>
 ///         </listheader>
 ///         <item>
 ///             <term>normal</term><description>Minimum 10 minutter</description>
 ///         </item>
 ///         <item>
 ///             <term>prioritert</term><description>Minimum 1 minutt</description>
 ///         </item>
 ///     </list>
 /// </remarks>
 public async Task<Kvittering> HentKvitteringAsync(Kvitteringsforespørsel kvitteringsforespørsel)
 {
     return await HentKvitteringOgBekreftForrigeAsync(kvitteringsforespørsel, null).ConfigureAwait(false);
 }
 /// <summary>
 ///     Forespør <see cref="Kvittering" /> for <see cref="Forsendelse">Forsendelser</see>, med mulighet til å samtidig
 ///     <see cref="Bekreft">bekrefte</see> på forrige <see cref="Kvittering" /> for å slippe å
 ///     kjøre eget kall for <see cref="Bekreft" />. <see cref="Kvittering">Kvitteringer</see> blir tilgjengeliggjort
 ///     etterhvert som de er klare i Meldingsformidler. Det er ikke mulig å etterspørre
 ///     <see cref="Kvittering" /> for en spesifikk forsendelse.
 /// </summary>
 /// <param name="kvitteringsforespørsel"></param>
 /// <param name="forrigeKvittering"></param>
 /// <returns></returns>
 /// <remarks>
 ///     <list type="table">
 ///         <listheader>
 ///             <description>
 ///                 Dersom det ikke er tilgjengelige <see cref="Kvittering">Kvitteringer</see> skal det ventes følgende
 ///                 tidsintervaller før en ny forespørsel gjøres:
 ///             </description>
 ///         </listheader>
 ///         <item>
 ///             <term>normal</term><description>Minimum 10 minutter</description>
 ///         </item>
 ///         <item>
 ///             <term>prioritert</term><description>Minimum 1 minutt</description>
 ///         </item>
 ///     </list>
 /// </remarks>
 public Kvittering HentKvitteringOgBekreftForrige(Kvitteringsforespørsel kvitteringsforespørsel,
     Forretningskvittering forrigeKvittering)
 {
     return HentKvitteringOgBekreftForrigeAsync(kvitteringsforespørsel, forrigeKvittering).Result;
 }
        /// <summary>
        /// Forespør kvittering for forsendelser med mulighet til å samtidig bekrefte på forrige kvittering for å slippe å kjøre eget kall for bekreft. 
        /// Kvitteringer blir tilgjengeliggjort etterhvert som de er klare i meldingsformidler. Det er ikke mulig å etterspørre kvittering for en 
        /// spesifikk forsendelse. 
        /// </summary>
        /// <param name="kvitteringsforespørsel"></param>
        /// <param name="forrigeKvittering"></param>
        /// <returns></returns>
        /// <remarks>
        /// <list type="table">
        /// <listheader><description>Dersom det ikke er tilgjengelige kvitteringer skal det ventes følgende tidsintervaller før en ny forespørsel gjøres</description></listheader>
        /// <item><term>normal</term><description>Minimum 10 minutter</description></item>
        /// <item><term>prioritert</term><description>Minimum 1 minutt</description></item>
        /// </list>
        /// </remarks>
        public async Task<Kvittering> HentKvitteringOgBekreftForrigeAsync(Kvitteringsforespørsel kvitteringsforespørsel, Forretningskvittering forrigeKvittering)
        {
            if (forrigeKvittering != null)
            {
                Bekreft(forrigeKvittering);
            }

            Logging.Log(TraceEventType.Information, "Henter kvittering for " + kvitteringsforespørsel.Mpc);

            var guidHandler = new GuidUtility();
            var envelopeSettings = new EnvelopeSettings(kvitteringsforespørsel, _databehandler, guidHandler);
            var kvitteringsenvelope = new KvitteringsforespørselEnvelope(envelopeSettings);

            Logging.Log(TraceEventType.Verbose, "Envelope for kvitteringsforespørsel" + Environment.NewLine + kvitteringsenvelope.Xml().OuterXml);

            ValiderKvitteringsEnvelope(kvitteringsenvelope);

            var soapContainer = new SoapContainer(kvitteringsenvelope);
            var kvittering = await SendSoapContainer(soapContainer);

            Logg(TraceEventType.Verbose, Guid.Empty , kvitteringsenvelope.Xml().OuterXml, true, true, "Sendt - Kvitteringsenvelope.xml");

            try
            {
                var valideringAvResponsSignatur = new Responsvalidator(kvittering, kvitteringsenvelope.Xml());
                valideringAvResponsSignatur.ValiderHeaderSignatur();
                valideringAvResponsSignatur.ValiderKvitteringSignatur();
            }
            catch (Exception e)
            {
                return ValiderTransportkvittering(kvittering,kvitteringsenvelope.Xml(),guidHandler);
            }

            return KvitteringFactory.GetForretningskvittering(kvittering);
        }
 /// <summary>
 ///     Forespør <see cref="Kvittering" /> for <see cref="Forsendelse">Forsendelser</see>.
 ///     <see cref="Kvittering">Kvitteringer</see> blir tilgjengeliggjort etterhvert som de er klare i
 ///     Meldingsformidler. Det er ikke mulig å etterspørre <see cref="Kvittering" /> for en spesifikk
 ///     <see cref="Forsendelse" />.
 /// </summary>
 /// <param name="kvitteringsforespørsel"></param>
 /// <returns></returns>
 /// <remarks>
 ///     <list type="table">
 ///         <listheader>
 ///             <description>
 ///                 Dersom det ikke er tilgjengelige <see cref="Kvittering">Kvitteringer</see> skal det ventes følgende
 ///                 tidsintervaller før en ny forespørsel gjøres:
 ///             </description>
 ///         </listheader>
 ///         <item>
 ///             <term>normal</term><description>Minimum 10 minutter</description>
 ///         </item>
 ///         <item>
 ///             <term>prioritert</term><description>Minimum 1 minutt</description>
 ///         </item>
 ///     </list>
 /// </remarks>
 public Kvittering HentKvittering(Kvitteringsforespørsel kvitteringsforespørsel)
 {
     return HentKvitteringOgBekreftForrige(kvitteringsforespørsel, null);
 }
コード例 #6
0
        private Kvittering GetSingleKvittering()
        {
            Thread.Sleep(3000);

            var kvitteringsforespørsel = new Kvitteringsforespørsel(_forsendelse.Prioritet, _forsendelse.MpcId);
            var kvittering = _klient.HentKvittering(kvitteringsforespørsel);
            return kvittering;
        }
        public void NyKlientOgSend()
        {
            var klientKonfig = new Klientkonfigurasjon(Miljø.FunksjoneltTestmiljø);

            Databehandler databehandler = null; //Som initiert tidligere
            Forsendelse forsendelse = null; //Som initiert tidligere

            var sdpKlient = new SikkerDigitalPostKlient(databehandler, klientKonfig);
            var transportkvittering = sdpKlient.Send(forsendelse);

            if (transportkvittering is TransportOkKvittering)
            {
                //Når alt går fint
            }
            else if (transportkvittering is TransportFeiletKvittering)
            {
                var beskrivelse = ((TransportFeiletKvittering) transportkvittering).Beskrivelse;
            }

            ////////////////////////////////////////
            // Eksempel for henting av kvittering
            ////////////////////////////////////////

            var køId = "MpcId";
            var kvitteringsForespørsel = new Kvitteringsforespørsel(Prioritet.Prioritert, køId);
            Console.WriteLine(" > Henter kvittering på kø '{0}'...", kvitteringsForespørsel.Mpc);

            Kvittering kvittering = sdpKlient.HentKvittering(kvitteringsForespørsel);

            if (kvittering is TomKøKvittering)
            {
                Console.WriteLine("  - Kø '{0}' er tom. Stopper å hente meldinger. ", kvitteringsForespørsel.Mpc);
            }

            if (kvittering is TransportFeiletKvittering)
            {
                var feil = ((TransportFeiletKvittering) kvittering).Beskrivelse;
                Console.WriteLine("En feil skjedde under transport.");
            }

            if (kvittering is Leveringskvittering)
            {
                Console.WriteLine("  - En leveringskvittering ble hentet!");
            }

            if (kvittering is Åpningskvittering)
            {
                Console.WriteLine("  - Har du sett. Noen har åpnet et brev. Moro.");
            }

            if (kvittering is Returpostkvittering)
            {
                Console.WriteLine("  - Du har fått en returpostkvittering for fysisk post.");
            }

            if (kvittering is Mottakskvittering)
            {
                Console.WriteLine("  - Kvittering på sending av fysisk post mottatt.");
            }

            if (kvittering is Feilmelding)
            {
                var feil = (Feilmelding)kvittering;
                Console.WriteLine("  - En feilmelding ble hentet :" + feil.Detaljer, true);
            }

            //////////////////////////////////////////
            /// Bekreft
            /////////////////////////////////////////

            sdpKlient.Bekreft((Forretningskvittering)kvittering);
        }
コード例 #8
0
        private static async void HentKvitteringer(SikkerDigitalPostKlient sikkerDigitalPostKlient)
        {
            Log.Debug("");

            Log.Debug(@" > Starter å hente kvitteringer ...");

            Thread.Sleep(3000);

            while (true)
            {
                var kvitteringsForespørsel = new Kvitteringsforespørsel(Prioritet.Prioritert, MpcId);
                Log.Debug($" > Henter kvittering på kø '{kvitteringsForespørsel.Mpc}'...");

                var kvittering = await sikkerDigitalPostKlient.HentKvitteringAsync(kvitteringsForespørsel).ConfigureAwait(false);

                if (kvittering is TomKøKvittering)
                {
                    Console.WriteLine($"  - Kø '{kvitteringsForespørsel.Mpc}' er tom. Stopper å hente meldinger. ");
                    break;
                }

                if (kvittering is TransportFeiletKvittering)
                {
                    var feil = ((TransportFeiletKvittering) kvittering).Beskrivelse;
                    WriteToConsoleWithColor(
                        "En feil skjedde under transport. Forespørsel for kvittering ble ikke godtatt av Meldingsformidler: " +
                        feil, true);
                    break;
                }

                if (kvittering is Leveringskvittering)
                {
                    WriteToConsoleWithColor("  - En leveringskvittering ble hentet!");
                }

                if (kvittering is Åpningskvittering)
                {
                    WriteToConsoleWithColor("  - Har du sett. Noen har åpnet et brev. Moro.");
                }

                if (kvittering is Returpostkvittering)
                    WriteToConsoleWithColor("  - Du har fått en returpostkvittering for fysisk post.");

                if (kvittering is Mottakskvittering)
                    WriteToConsoleWithColor("  - Kvittering på sending av fysisk post mottatt.");

                if (kvittering is Feilmelding)
                {
                    var feil = (Feilmelding) kvittering;
                    WriteToConsoleWithColor("  - En feilmelding ble hentet :" + feil.Detaljer, true);
                }

                Console.WriteLine(@"  - Bekreftelse på mottatt kvittering sendes ...");
                sikkerDigitalPostKlient.Bekreft((Forretningskvittering) kvittering);
                Console.WriteLine(@"   - Kvittering sendt.");
            }
        }
コード例 #9
0
        private static Kvittering HentKvitteringOgBekreft(SikkerDigitalPostKlient sdpKlient, string testBeskrivelse,
            Forsendelse forsendelse)
        {
            const int hentKvitteringMaksAntallGanger = 10;
            var hentKvitteringPåNytt = true;
            var prøvdPåNytt = 0;

            Kvittering kvittering = null;
            while (hentKvitteringPåNytt && (prøvdPåNytt++ <= hentKvitteringMaksAntallGanger))
            {
                Thread.Sleep(1000);
                var kvitteringsforespørsel = new Kvitteringsforespørsel(forsendelse.Prioritet, forsendelse.MpcId);
                kvittering = sdpKlient.HentKvittering(kvitteringsforespørsel);

                if (kvittering == null) { continue; }
                hentKvitteringPåNytt = false;

                sdpKlient.Bekreft((Forretningskvittering)kvittering);

                var konversasjonsId = HentKonversasjonsIdFraKvittering(kvittering);
                if (konversasjonsId != forsendelse.KonversasjonsId)
                {
                    throw new FieldAccessException(
                        string.Format(
                            "Fikk ikke til å hente kvittering for test '{0}' -- det ble hentet feil kvittering eller ingen kvittering. Var du for rask å hente, " +
                            "eller har noe skjedd galt med hvilken kø du henter fra?", testBeskrivelse));
                }
            }
            return kvittering;
        }
        private async Task<int> HentKvitteringOgBekreft(SikkerDigitalPostKlient sdpKlient, string testBeskrivelse, string mpcId,
            Forsendelse forsendelse)
        {
            var hentKvitteringPåNytt = true;
            var prøvdPåNytt = 0;
            
            while (hentKvitteringPåNytt && (prøvdPåNytt++ <= _hentKvitteringerMaksAntallGanger))
            {
                Thread.Sleep(1000);
                var kvitteringsforespørsel = new Kvitteringsforespørsel(Prioritet.Prioritert, mpcId);
                var kvittering = await sdpKlient.HentKvitteringAsync(kvitteringsforespørsel);

                if (kvittering == null) { continue; }

                sdpKlient.Bekreft((Forretningskvittering)kvittering);

                hentKvitteringPåNytt = false;

                var konversasjonsId = Guid.Empty;

                if (kvittering is Feilmelding)
                {
                    var feilmelding = (Feilmelding)kvittering;
                    konversasjonsId = feilmelding.KonversasjonsId;
                    Assert.Fail("Test '{0}' feilet. Feilmelding fra Meldingsformidler: {1}",
                        testBeskrivelse,
                        feilmelding.Detaljer);
                    
                }

                if (kvittering is Leveringskvittering)
                {
                    var leveringskvittering = (Leveringskvittering)kvittering;
                    konversasjonsId = leveringskvittering.KonversasjonsId;
                }

               
                if (konversasjonsId.ToString() != forsendelse.KonversasjonsId.ToString())
                {
                    throw new FieldAccessException(
                        string.Format(
                            "Fikk ikke til å hente kvittering for test '{0}' -- det ble hentet feil kvittering eller ingen kvittering. Var du for rask å hente, " +
                            "eller har noe skjedd galt med hvilken kø du henter fra?", testBeskrivelse));
                }
            }
            return prøvdPåNytt;
        }