public async Task CreateAndSendSignatureJob()
        {
            ClientConfiguration clientConfiguration = null; //As initialized earlier
            var directClient = new DirectClient(clientConfiguration);

            var documentToSign = new Document(
                "Subject of Message",
                "This is the content",
                FileType.Pdf,
                @"C:\Path\ToDocument\File.pdf");

            var exitUrls = new ExitUrls(
                new Uri("http://redirectUrl.no/onCompletion"),
                new Uri("http://redirectUrl.no/onCancellation"),
                new Uri("http://redirectUrl.no/onError")
                );

            var signers = new List <Signer>
            {
                new Signer(new PersonalIdentificationNumber("12345678910")),
                new Signer(new PersonalIdentificationNumber("10987654321"))
            };

            var job = new Job(documentToSign, signers, "SendersReferenceToSignatureJob", exitUrls);

            var directJobResponse = await directClient.Create(job);
        }
        public async Task CreateAndSendSignatureJob()
        {
            ClientConfiguration clientConfiguration = null; //As initialized earlier
            var directClient = new DirectClient(clientConfiguration);

            var documentToSign = new Document(
                "Subject of Message", 
                "This is the content", 
                FileType.Pdf, 
                @"C:\Path\ToDocument\File.pdf");

            var exitUrls = new ExitUrls(
                new Uri("http://redirectUrl.no/onCompletion"), 
                new Uri("http://redirectUrl.no/onCancellation"), 
                new Uri("http://redirectUrl.no/onError")
                );

            var job = new Job(
                documentToSign, 
                new Signer(new PersonalIdentificationNumber("12345678910")), 
                "SendersReferenceToSignatureJob", 
                exitUrls
                );

            var directJobResponse = await directClient.Create(job);
        }
        public async Task RequestNewRedirectUrlUsingSignerUrl()
        {
            ClientConfiguration clientConfiguration = null; //As initialized earlier
            Job job               = null;                   //As created earlier
            var directClient      = new DirectClient(clientConfiguration);
            var directJobResponse = await directClient.Create(job);

            // Step 1:
            foreach (var signer in directJobResponse.Signers)
            {
                //Persist signer URL in sender system
                var signerResponseSignerUrl = signer.SignerUrl;
            }

            // ... some time later ...

            // Step 2: Request new redirect URL for signer
            Uri persistedSignerUrl           = null; //Persisted URL from step 1.
            var signerWithUpdatedRedirectUrl = await directClient
                                               .RequestNewRedirectUrl(
                NewRedirectUrlRequest
                .FromSignerUrl(persistedSignerUrl)
                );

            var newRedirectUrl = signerWithUpdatedRedirectUrl.RedirectUrl;
        }
        public async Task SpecifyingQueues()
        {
            ClientConfiguration clientConfiguration = null; // As initialized earlier
            var directClient = new DirectClient(clientConfiguration);

            var organizationNumber = "123456789";
            var sender             = new Sender(organizationNumber, new PollingQueue("CustomPollingQueue"));

            Document documentToSign = null; // As initialized earlier
            ExitUrls exitUrls       = null; // As initialized earlier

            var signer = new PersonalIdentificationNumber("00000000000");

            var job = new Job(
                documentToSign,
                new List <Signer> {
                new Signer(signer)
            },
                "SendersReferenceToSignatureJob",
                exitUrls,
                sender,
                StatusRetrievalMethod.Polling
                );

            await directClient.Create(job);

            var changedJob = await directClient.GetStatusChange(sender);
        }
        public async Task ConfirmSignatureJob()
        {
            ClientConfiguration clientConfiguration = null; //As initialized earlier
            var directClient = new DirectClient(clientConfiguration);
            JobStatusResponse jobStatusResponse = null;     // Result of requesting job status

            await directClient.Confirm(jobStatusResponse.References.Confirmation);
        }
        public async Task ConfirmSignatureJob()
        {
            ClientConfiguration clientConfiguration = null; //As initialized earlier
            var directClient = new DirectClient(clientConfiguration);
            DirectJobStatusResponse directJobStatusResponse = null; // Result of requesting job status

            await directClient.Confirm(directJobStatusResponse.References.Confirmation);
        }
            public async Task Throws_too_eager_polling_exception_on_too_many_requests()
            {
                var directClient = new DirectClient(GetClientConfiguration())
                {
                    HttpClient = GetHttpClientWithHandler(new FakeHttpClientHandlerForTooManyRequestsResponse())
                };

                await Assert.ThrowsAsync <TooEagerPollingException>(async() => await directClient.GetStatusChange().ConfigureAwait(false)).ConfigureAwait(false);
            }
            public async Task Can_request_new_redirect_url()
            {
                var directClient = new DirectClient(GetClientConfiguration())
                {
                    HttpClient = GetHttpClientWithHandler(new FakeHttpClientHandlerForNewRedirectUrlResponse())
                };

                await directClient.RequestNewRedirectUrl(NewRedirectUrlRequest.FromSignerUrl(new Uri("http://someSignerUrl.no")));
            }
            public async Task Throws_exception_on_no_sender()
            {
                //Arrange
                var clientConfiguration = new ClientConfiguration(Environment.DifiQa, GetPostenTestCertificate());
                var directClient        = new DirectClient(clientConfiguration);
                var directJob           = new Job(DomainUtility.GetDirectDocument(), DomainUtility.GetSigner(), "SendersReference", DomainUtility.GetExitUrls());

                //Act
                await Assert.ThrowsAsync <SenderNotSpecifiedException>(async() => await directClient.Create(directJob).ConfigureAwait(false)).ConfigureAwait(false);
            }
            public async Task Returns_status_response()
            {
                var directClient = new DirectClient(GetClientConfiguration())
                {
                    HttpClient = GetHttpClientWithHandler(new FakeHttpClientHandlerGetStatusResponse())
                };

                var result = await directClient.GetStatusChange().ConfigureAwait(false);

                Assert.NotNull(result);
            }
            public async Task Get_status_throws_unexpected_response_exception_on_server_error()
            {
                //Arrange
                var directClient = new DirectClient(GetClientConfiguration())
                {
                    HttpClient = new HttpClient(new FakeHttpClientHandlerForInternalServerErrorResponse())
                };

                //Act
                await Assert.ThrowsAsync <UnexpectedResponseException>(async() => await directClient.GetStatus(new StatusReference(new Uri("http://statusReference.no"), "StatusQueryToken")).ConfigureAwait(false)).ConfigureAwait(false);
            }
            public async Task Cant_get_signature_job_id_from_empty_response()
            {
                var directClient = new DirectClient(GetClientConfiguration())
                {
                    HttpClient = GetHttpClientWithHandler(new FakeHttpClientHandlerForEmptyQueueResponse())
                };

                var statusChange = await directClient.GetStatusChange().ConfigureAwait(false);

                Assert.Throws <InvalidOperationException>(() => statusChange.JobId);
            }
        private static DirectClient DirectClient(Environment environment)
        {
            var serviceProvider = LoggingUtility.CreateServiceProviderAndSetUpLogging();

            var clientConfig = new ClientConfiguration(environment, GetBringCertificate(), new Sender(BringPublicOrganizationNumber))
            {
                LogRequestAndResponse = true
            };
            var client = new DirectClient(clientConfig, serviceProvider.GetService <ILoggerFactory>());

            return(client);
        }
        public async Task GetDirectJobStatus()
        {
            ClientConfiguration clientConfiguration = null; //As initialized earlier
            var         directClient     = new DirectClient(clientConfiguration);
            JobResponse jobResponse      = null;            //As initialized when creating signature job
            var         statusQueryToken = "0A3BQ54C...";

            var jobStatusResponse =
                await directClient.GetStatus(jobResponse.StatusUrl.Status(statusQueryToken));

            var jobStatus = jobStatusResponse.Status;
        }
            public void Simple_constructor()
            {
                //Arrange
                var clientConfiguration = GetClientConfiguration();

                //Act
                var client = new DirectClient(clientConfiguration);

                //Assert
                Assert.Equal(clientConfiguration, client.ClientConfiguration);
                Assert.NotNull(client.HttpClient);
            }
        public async Task GetDirectJobStatus()
        {
            ClientConfiguration clientConfiguration = null; //As initialized earlier
            var directClient = new DirectClient(clientConfiguration);
            JobResponse jobResponse = null; //As initialized when creating signature job
            var statusQueryToken = "0A3BQ54C...";

            var jobStatusResponse =
                await directClient.GetStatus(jobResponse.ResponseUrls.Status(statusQueryToken));

            var jobStatus = jobStatusResponse.Status;
        }
            public async Task Returns_empty_object_on_empty_queue()
            {
                var fakeEmptyQueueResponse = new FakeHttpClientHandlerForEmptyQueueResponse();
                var directClient           = new DirectClient(GetClientConfiguration())
                {
                    HttpClient = GetHttpClientWithHandler(fakeEmptyQueueResponse)
                };

                var actualResponse = await directClient.GetStatusChange().ConfigureAwait(false);

                Assert.Throws <InvalidOperationException>(() => actualResponse.JobId);
                Assert.Null(actualResponse.JobReference);
            }
        public InstagramClient(string userName, string password, Device device)
        {
            _password   = password;
            _userName   = userName;
            this.device = device;

            EnsureAuthentication();

            Friendship = new FriendshipClient(wrapper, device);
            Direct     = new DirectClient(wrapper, device);
            Account    = new AccountClient(wrapper, device);
            Media      = new MediaClient(wrapper, device);
        }
            public async Task Returns_status_response()
            {
                //Arrange
                var directClient = new DirectClient(GetClientConfiguration())
                {
                    HttpClient = new HttpClient(new FakeHttpClientHandlerGetStatusResponse())
                };

                //Act
                var result = await directClient.GetStatus(new StatusReference(new Uri("http://statusReference.no"), "StatusQueryToken")).ConfigureAwait(false);

                //Assert
                Assert.NotNull(result);
            }
示例#20
0
        public void Connect()
        {
            client = new Client(serverIp, serverPort, '~', '|');
            client.OnReceivedEvent       += Client_receivedEvent;
            client.OnConnectionLostEvent += Client_serverDisconnectedEvent;
            if (client.Connect(out long pingMs, out EndPointId endPointId))
            {
                Start();
                Console.WriteLine("Connection established with: " + pingMs + " ping ms");
                IsConnected = true;

                directClient = new DirectClient(serverIp, serverPort + 1, '|');
                directClient.OnReceivedEvent += ReceivedEvent;
                directClient.Start();
            }
        }
        public async Task GetXadesAndPades()
        {
            ClientConfiguration clientConfiguration = null; //As initialized earlier
            var directClient = new DirectClient(clientConfiguration);
            JobStatusResponse jobStatusResponse = null;     // Result of requesting job status

            if (jobStatusResponse.Status == JobStatus.CompletedSuccessfully)
            {
                var padesByteStream = await directClient.GetPades(jobStatusResponse.References.Pades);
            }

            var signature = jobStatusResponse.GetSignatureFor(new PersonalIdentificationNumber("00000000000"));

            if (signature.Equals(SignatureStatus.Signed))
            {
                var xadesByteStream = await directClient.GetXades(signature.XadesReference);
            }
        }
        public async Task PollForStatus()
        {
            ClientConfiguration clientConfiguration = null; // As initialized earlier
            var directClient = new DirectClient(clientConfiguration);

            Document documentToSign = null; // As initialized earlier
            ExitUrls exitUrls = null; // As initialized earlier

            var signer = new PersonalIdentificationNumber("12345678910");

            var job = new Job(
                documentToSign,
                new List<Signer> {new Signer(signer)},
                "SendersReferenceToSignatureJob",
                exitUrls,
                statusRetrievalMethod: StatusRetrievalMethod.Polling
                );

            await directClient.Create(job);

            var changedJob = await directClient.GetStatusChange();

            if (changedJob.Status == JobStatus.NoChanges)
            {
                // Queue is empty. Additional polling will result in blocking for a defined period.
            }

            // Repeat the above until signer signs the document

            changedJob = await directClient.GetStatusChange();

            if (changedJob.Status == JobStatus.CompletedSuccessfully)
            {
                // Get PAdES
            }

            if (changedJob.GetSignatureFrom(signer).SignatureStatus.Equals(SignatureStatus.Signed))
            {
                // Get XAdES
            }

            // Confirm status change to avoid receiving it again
            await directClient.Confirm(changedJob.References.Confirmation);
        }
            public async Task SendsSuccessfully()
            {
                //Arrange
                var clientConfiguration = CoreDomainUtility.GetClientConfiguration();
                var directClient        = new DirectClient(clientConfiguration)
                {
                    HttpClient = new HttpClient(new FakeHttpClientHandlerForDirectCreateResponse())
                    {
                        BaseAddress = new Uri("http://fakesignatureserviceroot.digipost.no")
                    }
                };
                var directJob = DomainUtility.GetDirectJob();

                //Act
                var result = await directClient.Create(directJob).ConfigureAwait(false);

                //Assert
                Assert.NotNull(result);
            }
        public async Task RequestNewRedirectUrlUsingSignerResponse()
        {
            ClientConfiguration clientConfiguration = null; //As initialized earlier
            Job job               = null;                   //As created earlier
            var directClient      = new DirectClient(clientConfiguration);
            var directJobResponse = await directClient.Create(job);

            var signerFromResponse = directJobResponse
                                     .Signers
                                     .First(s => s
                                            .Identifier
                                            .IsSameAs(new PersonalIdentificationNumber("12345678910"))
                                            );

            var signerWithUpdatedRedirectUrl = await directClient
                                               .RequestNewRedirectUrl(signerFromResponse);

            var newRedirectUrl = signerWithUpdatedRedirectUrl.RedirectUrl;
        }
        public async Task GetXadesAndPades()
        {
            ClientConfiguration clientConfiguration = null; //As initialized earlier
            var directClient = new DirectClient(clientConfiguration);
            JobStatusResponse jobStatusResponse = null; // Result of requesting job status

            switch (jobStatusResponse.Status)
            {
                case JobStatus.Rejected:
                    //Signature job was rejected by the signer. Xades and Pades cannot be requested.
                    break;
                case JobStatus.Failed:
                    //Signature job failed, Xades and Pades cannot be requested.
                    break;
                case JobStatus.Signed:
                    var xadesByteStream = await directClient.GetXades(jobStatusResponse.References.Xades);
                    var padesByteStream = await directClient.GetPades(jobStatusResponse.References.Pades);
                    break;
            }
        }
        public async Task PollForStatus()
        {
            ClientConfiguration clientConfiguration = null; // As initialized earlier
            var directClient = new DirectClient(clientConfiguration);

            // Repeat the polling until signer signs the document, but ensure to do this at a
            // reasonable interval. If you are processing the result a few times a day in your
            // system, only poll a few times a day.
            var change = await directClient.GetStatusChange();

            switch (change.Status)
            {
            case JobStatus.NoChanges:
                // Queue is empty. Additional polling will result in blocking for a defined period.
                break;

            case JobStatus.CompletedSuccessfully:
                // Get PAdES
                // Get XAdES
                break;

            case JobStatus.Failed:
                break;

            case JobStatus.InProgress:
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            // Confirm status change to avoid receiving it again
            await directClient.Confirm(change.References.Confirmation);

            var pollingWillResultInBlock = change.NextPermittedPollTime > DateTime.Now;

            if (pollingWillResultInBlock)
            {
                //Wait until next permitted poll time has passed before polling again.
            }
        }
        static void Main(string[] args)
        {
            var bringTumbprint = "2d 7f 30 dd 05 d3 b7 fc 7a e5 97 3a 73 f8 49 08 3b 20 40 ed";
            var organizationNumberQaOrganization = "988015814";

            DirectClient client = new DirectClient(
                new ClientConfiguration(Environment.DifiQa, bringTumbprint, new Sender(organizationNumberQaOrganization)));

            var currentDirectory = new DirectoryInfo(System.Environment.CurrentDirectory).Parent.Parent ;
            
            var document = File.ReadAllBytes(Path.Combine(currentDirectory.FullName, "Dokument.pdf"));

            var result = client.Create(
                new DirectJob(
                    new Document("Subject", "message", "TheFileName", FileType.Pdf, document),
                    new Signer("01013300001"),
                    "TheReference",
                    new ExitUrls(new Uri("http://exiturl.no"), new Uri("http://exiturl.no"), new Uri("http://exiturl.no"))
                    )
                )
                .Result;
       }
 public TestHelper(DirectClient directClient)
 {
     _directClient = directClient;
 }
        public async Task GetXadesAndPades()
        {
            ClientConfiguration clientConfiguration = null; //As initialized earlier
            var directClient = new DirectClient(clientConfiguration);
            JobStatusResponse jobStatusResponse = null; // Result of requesting job status

            if (jobStatusResponse.Status == JobStatus.CompletedSuccessfully)
            {
                var padesByteStream = await directClient.GetPades(jobStatusResponse.References.Pades);
            }

            var signature = jobStatusResponse.GetSignatureFrom(new PersonalIdentificationNumber("12345678910"));

            if (signature.Equals(SignatureStatus.Signed))
            {
                var xadesByteStream = await directClient.GetXades(signature.XadesReference);
            }
        }