VTSFetcher/VTSFetcher/Services/AnytypeService.cs

using Microsoft.Extensions.Options;
using System.Net.Http;
using System.Text.Json;
using System.Text.Json.Serialization;
using VTSFetcher.Models;
using VTSFetcher.Modelsl;
using VTSFetcher.Repositories.Entities;

namespace VTSFetcher.Services;

public class AnytypeService
{
    // Managed Property names
    const string VtsKeyPropertyName = "VTS_Key";
    const string VtsLinkPropertyName = "VTS_Link";
    const string VtsTypePropertyName = "VTS_Type";
    const string VtsStatusPropertyName = "VTS_Status";
    const string VtsAssigneePropertyName = "VTS_Assignee";
    const string VtsManagerPropertyName = "VTS_Manager";
    const string VtsDueDatePropertyName = "VTS_Due";
    const string VtsSprintPropertyName = "VTS_Sprint";

    private readonly AppSettings _appSettings;

    private Dictionary<string, Property> _managedProperties = new();
    private Dictionary<string, Property[]> _managedTags = new();

    public AnytypeService(IOptions<AppSettings> options)
    {
        _appSettings = options.Value;

        LoadProperties().Wait();
    }

    public async Task<VtsIssue> PublishPageAsync(VtsIssue issue)
    {
        List<PageProperty> pageProperties = new();
        foreach (var propertyName in _managedProperties.Keys)
        {
            var property = _managedProperties[propertyName];
            var pageProperty = GetPageProperty(property, issue);
            if(pageProperty != null)
                pageProperties.Add(pageProperty);
        }
        var page = new AnytypePage
        {
            Name = $"{issue.Key} {issue.Summary}",
            TemplateId = _appSettings.Anytype.TemplateId,
            Properties = pageProperties,
        };
        var options = new JsonSerializerOptions
        {
            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
            PropertyNameCaseInsensitive = true
        };
        var jsingString = JsonSerializer.Serialize(page, options);
        var content = new StringContent(jsingString);

        using var client = new HttpClient();
        HttpRequestMessage request;
        if (string.IsNullOrEmpty(issue.ObjectId))
            request = new HttpRequestMessage(
                HttpMethod.Post,
                $"{_appSettings.Anytype.ApiBaseUrl}/spaces/{_appSettings.Anytype.SpaceId}/objects"
            );
        else
            request = new HttpRequestMessage(
                HttpMethod.Patch,
                $"{_appSettings.Anytype.ApiBaseUrl}/spaces/{_appSettings.Anytype.SpaceId}/objects/{issue.ObjectId}"
            );
        request.Headers.Add("Authorization", $"Bearer {_appSettings.Anytype.ApiKey}");
        request.Headers.Add("Anytype-Version", $"{_appSettings.Anytype.Version}");
        request.Content = content;
        var response = await client.SendAsync(request).ConfigureAwait(false);
        response.EnsureSuccessStatusCode();
        var jsonResponse = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
        var pageResponse = JsonSerializer.Deserialize<AnytypePageResponse>(jsonResponse, options);
        issue.ObjectId = pageResponse.Object.ObjectId;
        issue.Published = DateTimeOffset.Now;
        return issue;
    }
    private async Task LoadProperties()
    {
        using var client = new HttpClient();
        var uri = $"{_appSettings.Anytype.ApiBaseUrl}/spaces/{_appSettings.Anytype.SpaceId}/properties";
        var request = new HttpRequestMessage(HttpMethod.Get, uri);
        request.Headers.Add("Accept", "application/json");
        request.Headers.Add("Authorization", $"Bearer {_appSettings.Anytype.ApiKey}");
        request.Headers.Add("Anytype-Version", $"{_appSettings.Anytype.Version}");

        var response = await client.SendAsync(request).ConfigureAwait(false);
        response.EnsureSuccessStatusCode();

        var jsonResponse = await response.Content.ReadAsStringAsync();
        var jsonSerializerOptions = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
        var anytypePropertyResponse = JsonSerializer.Deserialize<AnytypePropertyResponse>(jsonResponse, jsonSerializerOptions);

        var managedPropertyNameSet = new HashSet<string>(_appSettings.Anytype.Properties, StringComparer.OrdinalIgnoreCase);
        var matchedProperties = anytypePropertyResponse.data
            .Where(d => managedPropertyNameSet.Contains(d.Name)).ToList();
        foreach (var item in matchedProperties)
        {
            _managedProperties.Add(item.Name, item);
            if (!string.Equals(item.Format, "select", StringComparison.OrdinalIgnoreCase))
                continue;
            var tags = await LoadTags(item.Id);
            _managedTags.Add(item.Name, tags);
        }
    }

    private async Task<Property[]> LoadTags(string propertyId)
    {
        using var client = new HttpClient();
        var uri = $"{_appSettings.Anytype.ApiBaseUrl}"
            + $"/spaces/{_appSettings.Anytype.SpaceId}"
            + $"/properties/{propertyId}/tags";
        var request = new HttpRequestMessage(HttpMethod.Get, uri);
        request.Headers.Add("Accept", "application/json");
        request.Headers.Add("Authorization", $"Bearer {_appSettings.Anytype.ApiKey}");
        request.Headers.Add("Anytype-Version", $"{_appSettings.Anytype.Version}");

        var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();

        var jsonResponse = await response.Content.ReadAsStringAsync();
        var jsonSerializerOptions = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
        var anytypeTagsesponse = JsonSerializer.Deserialize<AnytypePropertyResponse>(jsonResponse, jsonSerializerOptions);

        var result = anytypeTagsesponse.data;
        return result;
    }

    private PageProperty? GetPageProperty(Property property, VtsIssue issue)
    {
        var pageProperty = new PageProperty();
        pageProperty.Key = property.Key;
        switch (property.Name)
        {
            case VtsKeyPropertyName:
                pageProperty.Text = issue.Key;
                break;
            case VtsLinkPropertyName:
                pageProperty.Url = $"{_appSettings.VTS.BaseUrl}/browse/{issue.Key}";
                break;
            case VtsTypePropertyName:
                pageProperty.Select = GetTagId(property, issue.Type);
                break;
            case VtsStatusPropertyName:
                pageProperty.Select = GetTagId(property, issue.Status);
                break;
            case VtsAssigneePropertyName:
                pageProperty.Text = $"{issue.Assignee}";
                break;
            case VtsManagerPropertyName:
                pageProperty.Text = $"{issue.Manager}";
                break;
            case VtsDueDatePropertyName:
                if (issue.Due < new DateTime(2000, 1, 1, 0, 0, 0))
                    return null;
                pageProperty.Date = $"{issue.Due.ToString("yyyy-MM-ddT23:59:59Z")}";
                break;
            case VtsSprintPropertyName:
                pageProperty.Text = $"{issue.Sprint}";
                break;
            default:
                break;
        }
        return pageProperty;
    }

    private string GetTagId(Property property, string tagName)
    {
        var tags = _managedTags[property.Name];
        var tag = tags.Where<Property>(t => t.Name == tagName).FirstOrDefault();
       return tag.Id;
    }
}