Initial commit carried over from private repo. This is V2.

code/MessengerApi.Contracts/Client/IMessengerClient.cs

@@ -0,0 +1,30 @@
+namespace MessengerApi.Contracts
+{
+    /// <summary>
+    /// Exists for mocking reason. This is implemented by <see cref="MessengerClient"/>.
+    /// </summary>
+    public interface IMessengerClient
+    {
+        /// <summary>
+        /// Receives pending messages from the messenger API.
+        /// </summary>
+        /// <param name="credentials">Credentials to the API.</param>
+        IEnumerable<InboxMessage> GetMessages();
+
+        /// <summary>
+        /// Acknowledges message reception to the server.
+        /// </summary>
+        void AckMessage(InboxMessage message);
+
+        /// <summary>
+        /// Sends a message.
+        /// </summary>
+        /// <param name="credentials">Credentials to the API.</param>
+        void SendMessage(OutboxMessage outboxMessage);
+
+        /// <summary>
+        /// Returns user ids for allowed message recipients.
+        /// </summary>
+        Contact[] GetYellowPages();
+    }
+}

code/MessengerApi.Contracts/Client/MessengerClient.cs

@@ -0,0 +1,150 @@
+using portaloggy;
+using System.Text;
+using System.Text.Json.Nodes;
+
+namespace MessengerApi.Contracts
+{
+    public class MessengerClient : IMessengerClient
+    {
+        private readonly HttpClient _httpClient;
+        private readonly ILogger _logger;
+
+        private DateTime _lastReceivedUtc;
+        private Credentials _credentials;
+
+        public MessengerClient(Credentials credentials, HttpClient httpClient = null, ILogger logger = null)
+        {
+            _credentials = credentials;
+            _httpClient = httpClient ?? new HttpClient();
+            _logger = logger ?? new ConsoleLogger();
+            _lastReceivedUtc = DateTime.MinValue.ToUniversalTime();
+        }
+
+        public IEnumerable<InboxMessage> GetMessages()
+        {
+            var since = Uri.EscapeDataString(this._lastReceivedUtc.ToString("o"));
+            var url = $"{_credentials.ApiUrl}/receive?sinceUtc={since}";
+            var request = new HttpRequestMessage(HttpMethod.Get, url);
+            request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _credentials.ApiKey);
+            
+            _logger.Debug($"Sending query to {url} with content {request.ToString()} to obtain messages.");
+
+            var response = _httpClient.Send(request);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                _logger.Error(response.ReasonPhrase);
+                throw new HttpRequestException("Can't receive.", null, response.StatusCode);
+            }
+
+            var responseContent = response.Content
+                .ReadAsStringAsync()
+                .GetAwaiter()
+                .GetResult();
+
+            if (!string.IsNullOrWhiteSpace(responseContent))
+            {
+                _logger.Debug($"Received response of {responseContent}.");
+            }
+
+            if (string.IsNullOrWhiteSpace(responseContent))
+            {
+                return Enumerable.Empty<InboxMessage>().ToArray();
+            }
+
+            var json = JsonNode.Parse(responseContent);
+            var messages = new List<InboxMessage>();
+
+            foreach (var item in json["messages"].AsArray())
+            {
+                if (item["id"].GetValue<int>() == -1)
+                {
+                    continue;
+                }
+
+                messages.Add(new InboxMessage
+                {
+                    Id = item["id"].GetValue<Guid>(),
+                    Payload = item["payload"].ToJsonString(),
+                    PayloadId = item["payloadId"].ToJsonString(),
+                    PayloadType = item["payloadType"].ToJsonString(),
+                    Sender = item["sender"].GetValue<Guid>(),
+                    SenderTimestamp = item["senderTimestamp"].GetValue<DateTime>()
+                });
+            }
+
+            _lastReceivedUtc = DateTime.UtcNow.Subtract(TimeSpan.FromSeconds(10));
+            _logger.Debug($"Received {messages.Count} messages and last check timestamp is set to {_lastReceivedUtc.ToString("s")}.");
+
+            return messages.ToArray();
+        }
+
+        public void SendMessage(OutboxMessage outboxMessage)
+        {
+            var body = new JsonObject();
+
+            if(outboxMessage.ToUserId.HasValue)
+            {
+                body.Add("toUserId", JsonValue.Create<Guid>(outboxMessage.ToUserId.Value));
+            }
+
+            if(outboxMessage.Payload != null)
+            {
+                body.Add("payload", JsonValue.Create<string>(outboxMessage.Payload));
+            }
+
+            var content = new StringContent(body.ToString(), Encoding.UTF8, "application/json");
+
+            var url = $"{_credentials.ApiUrl}/send";
+            var request = new HttpRequestMessage(HttpMethod.Post, url);
+            request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _credentials.ApiKey);
+
+            _logger.Debug($"Sending query to {url} with content {body.ToString()} to obtain messages.");
+
+            var response = _httpClient.Send(request);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                _logger.Error(response.ReasonPhrase);
+                throw new HttpRequestException("Can't send.", null, response.StatusCode);
+            }
+        }
+
+        public Contact[] GetYellowPages()
+        {
+            var url = $"{_credentials.ApiUrl}/yellowpages";
+            var request = new HttpRequestMessage(HttpMethod.Get, url);
+            request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _credentials.ApiKey);
+
+            _logger.Debug($"Sending query to {url} with content {request.ToString()}.");
+
+            var response = _httpClient.Send(request);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                _logger.Error(response.ReasonPhrase);
+                throw new HttpRequestException("Can't receive.", null, response.StatusCode);
+            }
+
+            var responseContent = response.Content
+                .ReadAsStringAsync()
+                .GetAwaiter()
+                .GetResult();
+
+            var json = JsonNode.Parse(responseContent);
+
+            var contacts = json["users"].AsArray().Select(x => new Contact
+            {
+                Id = x["id"].GetValue<Guid>(),
+                Name = x["name"].GetValue<string>()
+            }).ToArray();
+
+            return contacts;
+        }
+
+        public void AckMessage(InboxMessage message)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

code/MessengerApi.Contracts/Contact.cs

@@ -0,0 +1,9 @@
+namespace MessengerApi.Contracts
+{
+    public class Contact
+    {
+        public Guid Id { get; set; }
+
+        public string Name { get; set; }
+    }
+}

code/MessengerApi.Contracts/Credentials.cs

@@ -0,0 +1,15 @@
+namespace MessengerApi.Contracts
+{
+    public class Credentials
+    {
+        public string ApiKey { get; private set; }
+
+        public string ApiUrl { get; private set; }
+
+        public Credentials(string apiKey, string apiUrl)
+        {
+            ApiKey = apiKey;
+            ApiUrl = apiUrl;
+        }
+    }
+}

code/MessengerApi.Contracts/Messages/InboxMessage.cs

@@ -0,0 +1,20 @@
+namespace MessengerApi.Contracts
+{
+    /// <summary>
+    /// Message when received is inbox. For server apps, this is request-type of message. For clients, this is a response-type of message.
+    /// </summary>
+    public class InboxMessage
+    {
+        public Guid Id { get; set; }
+
+        public Guid Sender { get; set; }
+
+        public DateTime? SenderTimestamp { get; set; }
+
+        public string PayloadId { get; set; }
+
+        public string PayloadType { get; set; }
+
+        public string Payload { get; set; }
+    }
+}

code/MessengerApi.Contracts/Messages/OutboxMessage.cs

@@ -0,0 +1,20 @@
+namespace MessengerApi.Contracts
+{
+    /// <summary>
+    /// Outbox type of message. A server-app will treat this as a response. A client app will treat this as a request.
+    /// </summary>
+    public class OutboxMessage
+    {
+        public Guid? ToUserId { get; set; }
+
+        public string PayloadId { get; set; }
+
+        public string PayloadType { get; set; }
+
+        public string Payload { get; set; }
+
+        public DateTime? PayloadTimestamp { get; set; }
+
+        public int? PayloadLifespanInSeconds { get; set; }
+    }
+}

code/MessengerApi.Contracts/MessengerApi.Contracts.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>net9.0</TargetFramework>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>disable</Nullable>
+		<GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+		<PackageOutputPath>$(OutputPath)</PackageOutputPath>
+		<AssemblyVersion>$([System.DateTime]::UtcNow.ToString("yyyy.MM.dd.HHmm"))</AssemblyVersion>
+		<PackageVersion>$([System.DateTime]::UtcNow.ToString("yyyy.MM.dd.HHmm"))</PackageVersion>
+		<BaseOutputPath>..\out\</BaseOutputPath>
+		<ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="portaloggy" />
+	</ItemGroup>
+</Project>