from .net 6 to .net 8 update

lisandro-iraguen · Feb 10, 2024 · f430b24 · f430b24
1 parent 82eb162
commit f430b24
Show file tree

Hide file tree

Showing 82 changed files with 1,683 additions and 614 deletions.
diff --git a/Api/Api.csproj b/Api/Api.csproj
@@ -1,15 +1,24 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <AzureFunctionsVersion>v4</AzureFunctionsVersion>
+    <OutputType>Exe</OutputType>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Azure.Identity" Version="1.10.4" />
     <PackageReference Include="Azure.Security.KeyVault.Secrets" Version="4.3.0" />
     <PackageReference Include="CardanoSharp.Koios.Client" Version="2.1.0" />
-    <PackageReference Include="Microsoft.AspNetCore.AzureKeyVault.HostingStartup" Version="2.0.4" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Core" Version="2.2.0" />
     <PackageReference Include="Microsoft.Azure.Functions.Extensions" Version="1.1.0" />
-    <PackageReference Include="Microsoft.NET.Sdk.Functions" Version="4.2.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker" Version="1.20.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http" Version="3.1.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="1.16.2" />
+    <PackageReference Include="Microsoft.ApplicationInsights.WorkerService" Version="2.21.0" />
+    <PackageReference Include="Microsoft.Azure.Functions.Worker.ApplicationInsights" Version="1.0.0" />
+    <PackageReference Include="Microsoft.JSInterop" Version="8.0.1" />
+    <PackageReference Include="Topshelf" Version="4.3.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Data\Data.csproj" />
@@ -19,7 +28,11 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
     <None Update="local.settings.json">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <CopyToPublishDirectory>Never</CopyToPublishDirectory>
     </None>
   </ItemGroup>
-</Project>
+  <ItemGroup>
+    <Using Include="System.Threading.ExecutionContext" Alias="ExecutionContext" />
+  </ItemGroup>
+</Project>
diff --git a/Api/Controllers/DevelopersController.cs b/Api/Controllers/DevelopersController.cs
@@ -0,0 +1,34 @@
+using Api.Services.Developers;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Http;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using System.Net;
+
+namespace ApiNet8.Controllers
+{
+    public class DevelopersController
+    {
+        private readonly ILogger _logger;
+        private readonly IWebData _webDevelopers;
+
+        public DevelopersController(ILoggerFactory loggerFactory, IWebData webDevelopersData)
+        {
+            _logger = loggerFactory.CreateLogger<DevelopersController>();
+            _webDevelopers = webDevelopersData;
+        }
+
+        [Function("Developers")]
+        public HttpResponseData Run([HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequestData req)
+        {
+            _logger.LogInformation("C# HTTP trigger function processed a request.");
+            var webDevelopers = _webDevelopers.GetWebDevelopersData();
+            var response = req.CreateResponse(HttpStatusCode.OK);
+            response.Headers.Add("Content-Type", "application/json");
+            response.WriteString(JsonConvert.SerializeObject(webDevelopers.Result));
+            return response;
+        }
+
+
+    }
+}
diff --git a/Api/Controllers/TransactionController.cs b/Api/Controllers/TransactionController.cs
@@ -0,0 +1,113 @@
+using Api.Services.Developers;
+using Api.Services.Transaction;
+using Azure;
+using Data.Wallet;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Http;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using System.Net;
+
+namespace ApiNet8.Controllers
+{
+    public class TransactionController
+    {
+        private readonly ILogger _logger;
+        private readonly ITransactionService _transactionService;
+
+        public TransactionController(ILoggerFactory loggerFactory, ITransactionService transactionService)
+        {
+            _logger = loggerFactory.CreateLogger<TransactionController>();
+            _transactionService = transactionService;
+        }
+
+        [Function("TxBuilder")]
+        public async Task<HttpResponseData> RunTxBuilderAsync([HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequestData req)
+        {
+            _logger.LogInformation("C# HTTP trigger function processed a request.");
+            string walletFrom = req.Query["walletFrom"];
+            string walletTo = req.Query["walletto"];
+            string value = req.Query["value"];
+            var response = req.CreateResponse(HttpStatusCode.OK);
+
+
+            if (string.IsNullOrEmpty(walletFrom)) response = req.CreateResponse(HttpStatusCode.BadRequest);            
+            if (string.IsNullOrEmpty(walletTo))   response = req.CreateResponse(HttpStatusCode.BadRequest);            
+            if (string.IsNullOrEmpty(value))      response = req.CreateResponse(HttpStatusCode.BadRequest);
+
+            try
+            {
+                ulong transferValue = ulong.Parse(value);
+                var transact = await _transactionService.BuildTransaction(walletFrom, walletTo, transferValue);
+                response.Headers.Add("Content-Type", "application/json");
+                response.WriteString(JsonConvert.SerializeObject(transact));
+                return response;
+            }
+            catch (Exception e)
+            {
+                response = req.CreateResponse(HttpStatusCode.BadRequest);
+            }
+
+            return response;
+
+        }
+
+        [Function("TxFee")]
+        public async Task<HttpResponseData> RunTxFeeAsync([HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequestData req)
+        {
+            _logger.LogInformation("C# HTTP trigger function processed a request.");
+            string walletFrom = req.Query["walletFrom"];
+            string walletTo = req.Query["walletto"];
+            string value = req.Query["value"];
+            var response = req.CreateResponse(HttpStatusCode.OK);
+
+
+            if (string.IsNullOrEmpty(walletFrom)) response = req.CreateResponse(HttpStatusCode.BadRequest);
+            if (string.IsNullOrEmpty(walletTo)) response = req.CreateResponse(HttpStatusCode.BadRequest);
+            if (string.IsNullOrEmpty(value)) response = req.CreateResponse(HttpStatusCode.BadRequest);
+
+            try
+            {
+                ulong transferValue = ulong.Parse(value);
+                var fee = await _transactionService.CalculateFee(walletFrom, walletTo, transferValue);
+                response.Headers.Add("Content-Type", "application/json");
+                response.WriteString(JsonConvert.SerializeObject(fee));
+                return response;
+            }
+            catch (Exception e)
+            {
+                response = req.CreateResponse(HttpStatusCode.BadRequest);
+            }
+
+            return response;
+
+        }
+
+
+        [Function("TxSign")]
+        public async Task<HttpResponseData> RunTxSignAsync([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req)
+        {
+            _logger.LogInformation("C# HTTP trigger function processed a request.");
+            var response = req.CreateResponse(HttpStatusCode.OK);
+
+            try
+            {
+                string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
+                var requestData = JsonConvert.DeserializeObject<TxRequest>(requestBody);
+                var transaction = await _transactionService.SignTransaction(requestData.transactionCbor, requestData.witness);
+                response.Headers.Add("Content-Type", "application/json");
+                response.WriteString(JsonConvert.SerializeObject(transaction));
+                return response;
+            }
+            catch (Exception e)
+            {
+                response = req.CreateResponse(HttpStatusCode.BadRequest);
+            }
+
+            return response;
+
+        }
+
+    }
+}
diff --git a/Api/Controllers/WalletController.cs b/Api/Controllers/WalletController.cs
@@ -0,0 +1,73 @@
+using Api.Services.Wallet;
+using CardanoSharp.Wallet.Extensions;
+using CardanoSharp.Wallet.Extensions.Models.Transactions.TransactionWitnesses;
+using Data.Wallet;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Http;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using System.Net;
+
+namespace ApiNet8.Controllers
+{
+    public class WalletController
+    {
+        private readonly ILogger _logger;
+        private readonly IWalletData _walletData;
+
+        public WalletController(ILoggerFactory loggerFactory, IWalletData walletData)
+        {
+            _logger = loggerFactory.CreateLogger<WalletController>();
+            _walletData = walletData;
+        }
+
+        [Function("WalletsData")]
+        public async Task<HttpResponseData> RunAsync([HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequestData req)
+        {
+            _logger.LogInformation("C# HTTP trigger function processed a request.");
+            var products = await _walletData.GetWalletData();
+            var response = req.CreateResponse(HttpStatusCode.OK);
+            response.Headers.Add("Content-Type", "application/json");
+            response.WriteString(JsonConvert.SerializeObject(products));
+            return response;
+        }
+
+
+        [Function("WitnessGet")]
+        public async Task<HttpResponseData> RunAsync2([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req, [FromBody] AddWitnessRequest request)
+        {
+            _logger.LogInformation("C# HTTP trigger function processed a request.");
+
+            var transaction = request.TxCbor;
+            if (transaction == null)
+            {
+                throw new InvalidOperationException("Could not deserialize txCbor");
+            }
+
+            var witnessSet = request.WitnessCbor.HexToByteArray().DeserializeTransactionWitnessSet();
+
+            foreach (var vkeyWitness in witnessSet.VKeyWitnesses)
+            {
+                transaction.TransactionWitnessSet.VKeyWitnesses.Add(vkeyWitness);
+            }
+            foreach (var nativeScript in witnessSet.NativeScripts)
+            {
+                transaction.TransactionWitnessSet.NativeScripts.Add(nativeScript);
+            }
+            foreach (var bootstrap in witnessSet.BootStrapWitnesses)
+            {
+                transaction.TransactionWitnessSet.BootStrapWitnesses.Add(bootstrap);
+            }
+            var response = req.CreateResponse(HttpStatusCode.OK);
+            response.Headers.Add("Content-Type", "application/json");
+
+            var result = new AddWitnessResponse();
+            result.Request = request;
+            result.TxCbor = transaction;
+            var responseContent = JsonConvert.SerializeObject(result);
+            await response.WriteStringAsync(responseContent);
+            return response;
+        }
+
+    }
+}
diff --git a/Api/Controllers/WebPriceController.cs b/Api/Controllers/WebPriceController.cs
@@ -0,0 +1,33 @@
+using Api.Services.Developers;
+using Api.Services.Oracle;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Azure.Functions.Worker.Http;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using System.Net;
+
+namespace ApiNet8.Controllers
+{
+    public class WebPriceController
+    {
+        private readonly ILogger _logger;
+        private readonly IPriceServices _webPriceSerices;
+
+        public WebPriceController(ILoggerFactory loggerFactory, IPriceServices webPriceSerices)
+        {
+            _logger = loggerFactory.CreateLogger<WebPriceController>();
+            _webPriceSerices = webPriceSerices;
+        }
+
+        [Function("BinanceP2P")]
+        public HttpResponseData Run([HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequestData req)
+        {
+            _logger.LogInformation("C# HTTP trigger function processed a request.");
+            var webDevelopers = _webPriceSerices.DollarApiCall();
+            var response = req.CreateResponse(HttpStatusCode.OK);
+            response.Headers.Add("Content-Type", "application/json");
+            response.WriteString(JsonConvert.SerializeObject(webDevelopers.Result));
+            return response;
+        }
+    }
+}
diff --git a/Api/Program.cs b/Api/Program.cs
@@ -0,0 +1,51 @@
+using Api;
+using Api.Services.Developers;
+using Api.Services.Oracle;
+using Api.Services.Policy;
+using Api.Services.Transaction;
+using Api.Services.Wallet;
+using CardanoSharp.Koios.Client;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Configuration.Json;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+class Program
+{
+
+
+    public static async Task Main(string[] args)
+    {
+        var builder = Host
+          .CreateDefaultBuilder(args)
+          .ConfigureFunctionsWorkerDefaults()
+          .ConfigureAppConfiguration((hostingContext, config) =>
+           {
+               config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
+                   .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
+                   .AddEnvironmentVariables();
+           })
+         .ConfigureServices((hostContext, builder) =>
+         {
+             var configuration = (IConfigurationRoot) hostContext.Configuration;
+             var localSettingsJsonProvider = configuration.Providers.LastOrDefault(provider => provider.GetType() == typeof(JsonConfigurationProvider));
+             if (localSettingsJsonProvider != null)
+             {
+                 var koiosURL = configuration["KoiosURL"];
+                 builder.AddKoios(configuration["KoiosURL"]);
+             }
+
+
+             builder.AddSingleton<IWalletData, WalletData>();
+             builder.AddSingleton<IWebData, WebDeveloperData>();
+             builder.AddSingleton<IPriceServices, PriceServices>();
+             builder.AddSingleton<IPolicyManager, PolicyManager>();
+             builder.AddSingleton<ITransactionService, TransactionService>();
+
+         });
+
+        await builder.Build().RunAsync();
+    }
+
+}