Implement meeting service

src/Api/Apis/Meetings/Contracts/CreateMeetingContract.cs

@@ -0,0 +1,8 @@
+namespace Api.Apis.Meetings.Contracts;
+
+public record CreateMeetingContract
+{
+    public required string Name { get; set; }
+    public required string Agenda { get; set; }
+    public required DateTime Date { get; set; }
+}

src/Api/Apis/Meetings/CreateMeeting.cs

@@ -0,0 +1,29 @@
+using Api.Abstractions;
+using Api.Apis.Meetings.Contracts;
+using Api.Extensions;
+using Domain.Entities.Meeting;
+using Domain.Primitives;
+using UseCases.Features.Meetings.Create;
+using UseCases.Features.Meetings.Get.ByUser;
+namespace Api.Apis.Meetings;
+
+public class CreateMeetingEndpoint : IEndpoint
+{
+    public void MapEndpoint(IEndpointRouteBuilder app)
+    {
+        app.MapPost($"{Constants.MeetingsApi}/", CreateMeeting)
+            .MapToApiVersion(1)
+            .WithTags(nameof(Constants.MeetingsApi))
+            .Produces<PagedList<Meeting>>()
+            .ProduceProblems(StatusCodes.Status400BadRequest,
+                StatusCodes.Status401Unauthorized,
+                StatusCodes.Status404NotFound);
+    }
+
+    private static async Task<IResult> CreateMeeting(CreateMeetingContract contract, [AsParameters] MeetingServices services)
+    {
+        var userId = services.HttpContextAccessor.GetUserId();
+        await services.Mediator.Send(new CreateMeetingCommand(contract.Name, userId , contract.Agenda, contract.Date));
+        return Results.Ok();
+    }
+}

src/Api/Apis/Meetings/GetMeetingsByUser.cs

@@ -9,9 +9,9 @@ public class GetMeetingsByUserEndpoint : IEndpoint
 {
     public void MapEndpoint(IEndpointRouteBuilder app)
     {
-        app.MapGet($"{Constants.MeetingApi}/", GetCurrentUser)
+        app.MapGet($"{Constants.MeetingsApi}/", GetCurrentUser)
             .MapToApiVersion(1)
-            .WithTags(nameof(Constants.MeetingApi))
+            .WithTags(nameof(Constants.MeetingsApi))
             .Produces<PagedList<Meeting>>()
             .ProduceProblems(StatusCodes.Status400BadRequest,
                 StatusCodes.Status401Unauthorized,

src/Api/Apis/Messengers/Telegram/TelegramServices.cs

@@ -1,5 +1,4 @@
-using Infrastructure.Messengers.Telegram.Bot;
-using Infrastructure.Messengers.Telegram.UpdateListener;
+using Infrastructure.Messengers.Telegram.UpdateListener;
 using MediatR;
 using Telegram.Bot;
 namespace Api.Apis.Messengers.Telegram;

src/Api/Configurations/EndpointConstants.cs

@@ -4,6 +4,6 @@ public static class EndpointConstants
 {
     public const string TelegramApi = "messengers/telegram";
     public const string UserApi = "users";
-    public const string MeetingApi = "meetings";
+    public const string MeetingsApi = "meetings";
     public const string InvitationApi = "invitations";
 }

src/Domain/Entities/Meeting/Meeting.cs

@@ -8,6 +8,8 @@ public class Meeting : Entity
     public UserId CreatorId { get; set; }
     public User.User? Creator { get; set; }
     public required string Name { get; set; }
+    public required long ZoomMeetingId { get; set; }
+    public required string Agenda { get; set; }
     public required DateTime Scheduled { get; set; }
     public required string Url { get; set; }
     public MeetingStatus Status { get; set; } = MeetingStatus.Scheduled;

src/Infrastructure/HostBuilderExtensions.cs

@@ -6,16 +6,16 @@
 using Infrastructure.Database.Abstractions;
 using Infrastructure.Database.Options;
 using Infrastructure.Database.Repositories;
+using Infrastructure.MeetingService.Options;
 using Infrastructure.Messengers.Options;
-using Infrastructure.Messengers.Telegram.Bot;
 using Infrastructure.Messengers.Telegram.ChatDistributor;
-using Infrastructure.Messengers.Telegram.Service;
 using Infrastructure.Messengers.Telegram.UpdateListener;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Options;
 using Telegram.Bot;
+using ZoomNet;
 
 namespace Infrastructure;
 
@@ -26,8 +26,8 @@ public static void ConfigureInfrastructureLayer(this IHostApplicationBuilder hos
         hostBuilder.ConfigureMessengers();
         hostBuilder.ConfigureDatabase();
         hostBuilder.ConfigureMessengers();
+        hostBuilder.ConfigureZoom();
         hostBuilder.RegisterRepositories();
-        hostBuilder.RegisterServices();
     }
 
     private static void ConfigureMessengers(this IHostApplicationBuilder hostBuilder)
@@ -36,6 +36,17 @@ private static void ConfigureMessengers(this IHostApplicationBuilder hostBuilder
         var options = hostBuilder.Services.BuildServiceProvider().GetRequiredService<IOptions<MessengerOptions>>().Value;
         hostBuilder.ConfigureTelegram(options);
     }
+
+    private static void ConfigureZoom(this IHostApplicationBuilder hostBuilder)
+    {
+        var options = hostBuilder.Services.BuildServiceProvider().GetRequiredService<IOptions<MeetingServiceOptions>>().Value;
+
+        hostBuilder.Services.AddSingleton<IZoomClient, ZoomClient>(sp =>
+        {   var connectionInfo = new JwtConnectionInfo(options.ZoomApiKey, options.ZoomApiSecret);
+            var zoomClient = new ZoomClient(connectionInfo);
+            return zoomClient;
+        });
+    }
 
     private static void ConfigureTelegram(this IHostApplicationBuilder hostBuilder, MessengerOptions options)
     {   
@@ -45,8 +56,7 @@ private static void ConfigureTelegram(this IHostApplicationBuilder hostBuilder,
             return telegramBotClient;
         });
         hostBuilder.Services.ConfigureTelegramBot<Microsoft.AspNetCore.Mvc.JsonOptions>(opt => opt.JsonSerializerOptions);
-
-        hostBuilder.Services.AddSingleton<ITelegramBot, TelegramBot>();
+
         hostBuilder.Services.AddSingleton<ITelegramUpdateListener, TelegramUpdateListener>();
         hostBuilder.Services.AddScoped<ITelegramChatDistributor, TelegramTelegramChatDistributor>();
     }
@@ -73,9 +83,4 @@ private static void RegisterRepositories(this IHostApplicationBuilder builder)
        builder.Services.AddScoped<IInvitationRepository, InvitationRepository>();
        builder.Services.AddScoped<IMeetingRepository, MeetingRepository>();
     }
-
-    private static void RegisterServices(this IHostApplicationBuilder builder)
-    {
-        builder.Services.AddSingleton<ITelegramService, TelegramService>();
-    }
 }

src/Infrastructure/Infrastructure.csproj

@@ -27,12 +27,17 @@
       <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.0-preview.7.24405.7" />
       <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.0-preview.7" />
       <PackageReference Include="Serilog" Version="4.0.1" />
+      <PackageReference Include="ZoomNet" Version="0.80.0" />
       <ProjectReference Include="..\Domain\Domain.csproj" />
       <ProjectReference Include="..\Telegram.Bot\Telegram.Bot.csproj" />
     </ItemGroup>
 
     <ItemGroup>
       <Folder Include="Database\Migrations\" />
+      <Folder Include="MeetingService\Zoom\" />
+      <PackageReference Include="ZoomNet" Version="0.80.0" />
+      <ProjectReference Include="..\Telegram.Bot\Telegram.Bot.csproj" />
+      <Folder Include="MeetingService\Zoom\" />
     </ItemGroup>
 
 </Project>

src/Infrastructure/MeetingService/IMeetingService.cs

@@ -0,0 +1,7 @@
+using Meeting = ZoomNet.Models.Meeting;
+namespace Infrastructure.MeetingService;
+
+public interface IMeetingService
+{
+    Task<Meeting?> CreateMeeting(string name, string stringUserId);
+}

src/Infrastructure/MeetingService/MeetingService.cs

@@ -0,0 +1,15 @@
+using Infrastructure.Messengers.Telegram.UpdateListener.Commands;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using ZoomNet;
+using ZoomNet.Models;
+namespace Infrastructure.MeetingService;
+
+public class MeetingService(IZoomClient zoomClient) : IMeetingService
+{
+    public async Task<Meeting?> CreateMeeting(string name, string stringUserId)
+    {
+        return await zoomClient.Meetings.CreateInstantMeetingAsync(stringUserId, name, "agenda");
+    }
+}
+

src/Infrastructure/MeetingService/Options/MeetingServiceOptions.cs

@@ -0,0 +1,7 @@
+namespace Infrastructure.MeetingService.Options;
+
+public sealed record MeetingServiceOptions
+{
+    public required string ZoomApiKey { get; set; }
+    public required string ZoomApiSecret { get; set; }
+}

src/Infrastructure/MeetingService/Options/MeetingServiceOptionsSetup.cs

@@ -0,0 +1,10 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Options;
+namespace Infrastructure.MeetingService.Options;
+
+public class MeetingServiceOptionsSetup(IConfiguration configuration) : IConfigureOptions<MeetingServiceOptions>
+{
+    private const string SectionName = "MeetingService";
+
+    public void Configure(MeetingServiceOptions serviceOptions) => configuration.GetSection(SectionName).Bind(serviceOptions);
+}

src/UseCases/Features/Meetings/Create/CreateMeetingCommand.cs

@@ -0,0 +1,4 @@
+using UseCases.Abstractions.Messaging;
+namespace UseCases.Features.Meetings.Create;
+
+public record CreateMeetingCommand(string Name, string UserId, string Agenda, DateTime Date) : ICommand;

src/UseCases/Features/Meetings/Create/CreateMeetingCommandHandler.cs

@@ -0,0 +1,34 @@
+using Domain.Entities.Meeting;
+using Domain.Entities.User;
+using Infrastructure.MeetingService;
+using UseCases.Abstractions.Messaging;
+namespace UseCases.Features.Meetings.Create;
+
+public class CreateMeetingCommandHandler(IMeetingRepository meetingRepository, IMeetingService meetingService) : ICommandHandler<CreateMeetingCommand>
+{
+    public async Task Handle(CreateMeetingCommand request, CancellationToken cancellationToken)
+    {
+        var creatorId = new UserId(Ulid.Parse(request.UserId));
+
+        var meeting = await meetingService.CreateMeeting(request.Name, request.UserId);
+
+        if (meeting is null)
+        {
+            throw new ApplicationException($"Error creating meeting: {request.UserId}");
+        }
+
+        var dbMeeting = new Meeting
+        {
+            Id = new MeetingId(),
+            ZoomMeetingId = meeting.Id,
+            Agenda = request.Agenda,
+            Name = request.Name,
+            Url = meeting.JoinUrl,
+            Created = DateTime.Now,
+            Scheduled = request.Date,
+            CreatorId = creatorId
+        };
+
+        await meetingRepository.CreateAsync(dbMeeting, cancellationToken);
+    }
+}