/// <summary>
 /// Method for notifying the connected application of a consumption
 /// </summary>
 /// <param name="message">The message that was consumed</param>
 private void NotifyConsumption(ConsumeResult <EDXLDistribution, T> message)
 {
     if (TestBedAdapter.GetInstance().State == TestBedAdapter.States.Enabled || TestBedAdapter.GetInstance().State == TestBedAdapter.States.Debug)
     {
         // Make sure this message is allowed to be received from the topic
         if (TestBedAdapter.GetInstance().State == TestBedAdapter.States.Debug || TestBedAdapter.GetInstance().AllowedTopicsReceive.Contains(message.Topic))
         {
             _consumerHandler?.Invoke(message.Key.senderID, message.Topic, message.Value);
         }
     }
     else
     {
         _messageQueue.Enqueue(message);
     }
 }
 /// <summary>
 /// Method for sending the given message over the given topic
 /// </summary>
 /// <param name="message">The message to be send</param>
 /// <param name="topic">The name of the topic to send the message over</param>
 internal void SendMessage(T message, string topic)
 {
     // Only send the message whenever the adapter is enabled
     if (TestBedAdapter.GetInstance().State == TestBedAdapter.States.Enabled || TestBedAdapter.GetInstance().State == TestBedAdapter.States.Debug)
     {
         // Make sure this message is allowed to be sent on the topic
         if (TestBedAdapter.GetInstance().State == TestBedAdapter.States.Debug || TestBedAdapter.GetInstance().AllowedTopicsSend.Contains(topic))
         {
             // Send the message
             Message <EDXLDistribution, T> m = new Message <EDXLDistribution, T>()
             {
                 Key   = CreateKey(),
                 Value = message,
             };
             Task <DeliveryResult <EDXLDistribution, T> > task = _producer.ProduceAsync(topic, m);
             task.ContinueWith(t =>
             {
                 if (t.IsFaulted)
                 {
                     OnError?.Invoke(this, new Error(ErrorCode.Local_Fail, t.Exception.ToString()));
                 }
             });
             // Wait for sending this message if the settings property was set
             if (_configuration.Settings.sendsync)
             {
                 task.Wait();
             }
         }
         else
         {
             throw new CommunicationException($"cannot send message, since the topic ({topic}) is restricted");
         }
     }
     else
     {
         // If this isn't the case, report and queue the message for sending later
         TestBedAdapter.GetInstance().Log(log4net.Core.Level.Notice, $"Could not send message to topic {topic}, because adapter is disabled! Enqueuing message for sending later.");
         _messageQueue.Enqueue(new KeyValuePair <T, string>(message, topic));
     }
 }
        /// <summary>
        /// Method for letting the adapter upload the file at the given path to the large file service
        /// </summary>
        /// <param name="filePath">The path directing to the file to upload</param>
        /// <param name="dataType">The type of file that is going to be uploaded</param>
        /// <param name="obfuscate">Indication if this should be a private upload, therefore generating a obfuscated link to the uploaded file</param>
        /// <param name="sendToTestbed">Indication if the adapter should automatically update the test-bed via the <see cref="eu.driver.model.core.LargeDataUpdate"/> message</param>
        /// <returns>The <see cref="Task"/> handling the upload, resulting in a <see cref="HttpRequestMessage"/>, or null if the file couldn't be found</returns>
        public Task <HttpResponseMessage> Upload(string filePath, DataType dataType, bool obfuscate, bool sendToTestbed)
        {
            // Make sure the file actually exists
            if (System.IO.File.Exists(filePath))
            {
                // Retrieve the large file service client for the upload
                System.Net.Http.HttpClient client = TestBedAdapter.GetInstance().GetLargeFileServiceClient();

                // Create and enter the POST parameters
                MultipartFormDataContent content = new MultipartFormDataContent();
                // the file to upload
                StreamContent file = new StreamContent(System.IO.File.OpenRead(filePath));
                file.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("form-data")
                {
                    Name     = "uploadFile",
                    FileName = System.IO.Path.GetFileName(filePath),
                };
                content.Add(file);
                // the indication if this upload needs to be obfuscated or not
                content.Add(new StringContent(obfuscate.ToString().ToLower()), "private");

                // Send the POST
                Task <HttpResponseMessage> res = client.PostAsync("/upload", content);

                // Wait for the task whenever this adapter needs to send the update as well
                if (sendToTestbed)
                {
                    WaitForUploadCompletion(System.IO.Path.GetFileName(filePath), dataType, res);
                }

                return(res);
            }
            else
            {
                return(null);
            }
        }