🎉 Initial commit of the Wallet

DysonNetwork.Wallet/AppDatabase.cs

@@ -0,0 +1,151 @@
+using System.Linq.Expressions;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using DysonNetwork.Shared.Data;
+using DysonNetwork.Shared.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Design;
+using NodaTime;
+using Quartz;
+
+namespace DysonNetwork.Wallet;
+
+public class AppDatabase(
+    DbContextOptions<AppDatabase> options,
+    IConfiguration configuration
+) : DbContext(options)
+{
+    public DbSet<SnWallet> Wallets { get; set; } = null!;
+    public DbSet<SnWalletPocket> WalletPockets { get; set; } = null!;
+    public DbSet<SnWalletOrder> PaymentOrders { get; set; } = null!;
+    public DbSet<SnWalletTransaction> PaymentTransactions { get; set; } = null!;
+    public DbSet<SnWalletFund> WalletFunds { get; set; } = null!;
+    public DbSet<SnWalletFundRecipient> WalletFundRecipients { get; set; } = null!;
+    public DbSet<SnWalletSubscription> WalletSubscriptions { get; set; } = null!;
+    public DbSet<SnWalletGift> WalletGifts { get; set; } = null!;
+    public DbSet<SnWalletCoupon> WalletCoupons { get; set; } = null!;
+
+    public DbSet<SnLottery> Lotteries { get; set; } = null!;
+    public DbSet<SnLotteryRecord> LotteryRecords { get; set; } = null!;
+
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+    {
+        optionsBuilder.UseNpgsql(
+            configuration.GetConnectionString("App"),
+            opt => opt
+                .ConfigureDataSource(optSource => optSource
+                    .EnableDynamicJson()
+                    .ConfigureJsonOptions(new JsonSerializerOptions()
+                    {
+                        NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals,
+                    })
+                )
+                .UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery)
+                .UseNodaTime()
+        ).UseSnakeCaseNamingConvention();
+
+        base.OnConfiguring(optionsBuilder);
+    }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        base.OnModelCreating(modelBuilder);
+
+        modelBuilder.Entity<SnPermissionGroupMember>()
+            .HasKey(pg => new { pg.GroupId, pg.Actor });
+        modelBuilder.Entity<SnPermissionGroupMember>()
+            .HasOne(pg => pg.Group)
+            .WithMany(g => g.Members)
+            .HasForeignKey(pg => pg.GroupId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        modelBuilder.Entity<SnAccountRelationship>()
+            .HasKey(r => new { FromAccountId = r.AccountId, ToAccountId = r.RelatedId });
+        modelBuilder.Entity<SnAccountRelationship>()
+            .HasOne(r => r.Account)
+            .WithMany(a => a.OutgoingRelationships)
+            .HasForeignKey(r => r.AccountId);
+        modelBuilder.Entity<SnAccountRelationship>()
+            .HasOne(r => r.Related)
+            .WithMany(a => a.IncomingRelationships)
+            .HasForeignKey(r => r.RelatedId);
+        
+        modelBuilder.Entity<SnRealmMember>()
+            .HasKey(pm => new { pm.RealmId, pm.AccountId });
+        modelBuilder.Entity<SnRealmMember>()
+            .HasOne(pm => pm.Realm)
+            .WithMany(p => p.Members)
+            .HasForeignKey(pm => pm.RealmId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        modelBuilder.ApplySoftDeleteFilters();
+    }
+
+    public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
+    {
+        this.ApplyAuditableAndSoftDelete();
+        return await base.SaveChangesAsync(cancellationToken);
+    }
+}
+
+public class AppDatabaseRecyclingJob(AppDatabase db, ILogger<AppDatabaseRecyclingJob> logger) : IJob
+{
+    public async Task Execute(IJobExecutionContext context)
+    {
+        var now = SystemClock.Instance.GetCurrentInstant();
+
+        logger.LogInformation("Deleting soft-deleted records...");
+
+        var threshold = now - Duration.FromDays(7);
+
+        var entityTypes = db.Model.GetEntityTypes()
+            .Where(t => typeof(ModelBase).IsAssignableFrom(t.ClrType) && t.ClrType != typeof(ModelBase))
+            .Select(t => t.ClrType);
+
+        foreach (var entityType in entityTypes)
+        {
+            var set = (IQueryable)db.GetType().GetMethod(nameof(DbContext.Set), Type.EmptyTypes)!
+                .MakeGenericMethod(entityType).Invoke(db, null)!;
+            var parameter = Expression.Parameter(entityType, "e");
+            var property = Expression.Property(parameter, nameof(ModelBase.DeletedAt));
+            var condition = Expression.LessThan(property, Expression.Constant(threshold, typeof(Instant?)));
+            var notNull = Expression.NotEqual(property, Expression.Constant(null, typeof(Instant?)));
+            var finalCondition = Expression.AndAlso(notNull, condition);
+            var lambda = Expression.Lambda(finalCondition, parameter);
+
+            var queryable = set.Provider.CreateQuery(
+                Expression.Call(
+                    typeof(Queryable),
+                    "Where",
+                    [entityType],
+                    set.Expression,
+                    Expression.Quote(lambda)
+                )
+            );
+
+            var toListAsync = typeof(EntityFrameworkQueryableExtensions)
+                .GetMethod(nameof(EntityFrameworkQueryableExtensions.ToListAsync))!
+                .MakeGenericMethod(entityType);
+
+            var items = await (dynamic)toListAsync.Invoke(null, [queryable, CancellationToken.None])!;
+            db.RemoveRange(items);
+        }
+
+        await db.SaveChangesAsync();
+    }
+}
+
+public class AppDatabaseFactory : IDesignTimeDbContextFactory<AppDatabase>
+{
+    public AppDatabase CreateDbContext(string[] args)
+    {
+        var configuration = new ConfigurationBuilder()
+            .SetBasePath(Directory.GetCurrentDirectory())
+            .AddJsonFile("appsettings.json")
+            .Build();
+
+        var optionsBuilder = new DbContextOptionsBuilder<AppDatabase>();
+        return new AppDatabase(optionsBuilder.Options, configuration);
+    }
+}
+

DysonNetwork.Wallet/DysonNetwork.Wallet.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+    <PropertyGroup>
+        <TargetFramework>net10.0</TargetFramework>
+        <Nullable>enable</Nullable>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <NoDefaultLaunchSettingsFile>True</NoDefaultLaunchSettingsFile>
+        <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.2" />
+        <PackageReference Include="Quartz" Version="3.15.1" />
+        <PackageReference Include="Quartz.AspNetCore" Version="3.15.1" />
+        <PackageReference Include="Quartz.Extensions.Hosting" Version="3.15.1" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <Content Include="..\.dockerignore">
+        <Link>.dockerignore</Link>
+      </Content>
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\DysonNetwork.Shared\DysonNetwork.Shared.csproj" />
+    </ItemGroup>
+
+</Project>

DysonNetwork.Wallet/Program.cs

@@ -0,0 +1,50 @@
+using DysonNetwork.Shared.Auth;
+using DysonNetwork.Shared.Networking;
+using DysonNetwork.Shared.Registry;
+using DysonNetwork.Wallet;
+using DysonNetwork.Wallet.Startup;
+using Microsoft.EntityFrameworkCore;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.AddServiceDefaults();
+
+// Configure Kestrel and server options
+builder.ConfigureAppKestrel(builder.Configuration);
+
+// Add application services
+builder.Services.AddAppServices(builder.Configuration);
+builder.Services.AddDysonAuth();
+builder.Services.AddRingService();
+builder.Services.AddDriveService();
+builder.Services.AddDevelopService();
+
+builder.Services.AddAppFlushHandlers();
+builder.Services.AddAppBusinessServices(builder.Configuration);
+builder.Services.AddAppScheduledJobs();
+
+builder.AddSwaggerManifest(
+    "DysonNetwork.Wallet",
+    "The payment service of the Solar Network."
+);
+
+var app = builder.Build();
+
+app.MapDefaultEndpoints();
+
+// Run database migrations
+using (var scope = app.Services.CreateScope())
+{
+    var db = scope.ServiceProvider.GetRequiredService<AppDatabase>();
+    await db.Database.MigrateAsync();
+}
+
+// Configure application middleware pipeline
+app.ConfigureAppMiddleware(builder.Configuration);
+
+// Configure gRPC
+app.ConfigureGrpcServices();
+
+app.UseSwaggerManifest("DysonNetwork.Wallet");
+
+app.Run();

DysonNetwork.Wallet/Startup/ApplicationConfiguration.cs

@@ -0,0 +1,32 @@
+using DysonNetwork.Shared.Auth;
+using DysonNetwork.Shared.Networking;
+
+namespace DysonNetwork.Wallet.Startup;
+
+public static class ApplicationConfiguration
+{
+    public static WebApplication ConfigureAppMiddleware(this WebApplication app, IConfiguration configuration)
+    {
+        app.MapOpenApi();
+
+        app.UseRequestLocalization();
+
+        app.ConfigureForwardedHeaders(configuration);
+
+        app.UseWebSockets();
+        app.UseAuthentication();
+        app.UseAuthorization();
+        app.UseMiddleware<RemotePermissionMiddleware>();
+
+        app.MapControllers().RequireRateLimiting("fixed");
+
+        return app;
+    }
+
+    public static WebApplication ConfigureGrpcServices(this WebApplication app)
+    {
+        app.MapGrpcReflectionService();
+
+        return app;
+    }
+}

DysonNetwork.Wallet/Startup/BroadcastEventHandler.cs

@@ -0,0 +1,15 @@
+using NATS.Client.Core;
+
+namespace DysonNetwork.Wallet.Startup;
+
+public class BroadcastEventHandler(
+    INatsConnection nats,
+    ILogger<BroadcastEventHandler> logger,
+    IServiceProvider serviceProvider
+) : BackgroundService
+{
+    protected override Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        return Task.CompletedTask;
+    }
+}

DysonNetwork.Wallet/Startup/ScheduledJobsConfiguration.cs

@@ -0,0 +1,21 @@
+using Quartz;
+
+namespace DysonNetwork.Wallet.Startup;
+
+public static class ScheduledJobsConfiguration
+{
+    public static IServiceCollection AddAppScheduledJobs(this IServiceCollection services)
+    {
+        services.AddQuartz(q =>
+        {
+            q.AddJob<AppDatabaseRecyclingJob>(opts => opts.WithIdentity("AppDatabaseRecycling"));
+            q.AddTrigger(opts => opts
+                .ForJob("AppDatabaseRecycling")
+                .WithIdentity("AppDatabaseRecyclingTrigger")
+                .WithCronSchedule("0 0 0 * * ?"));
+        });
+        services.AddQuartzHostedService(q => q.WaitForJobsToComplete = true);
+
+        return services;
+    }
+}

DysonNetwork.Wallet/Startup/ServiceCollectionExtensions.cs

@@ -0,0 +1,89 @@
+using System.Globalization;
+using Microsoft.AspNetCore.RateLimiting;
+using NodaTime;
+using NodaTime.Serialization.SystemTextJson;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using DysonNetwork.Shared.Cache;
+using DysonNetwork.Shared.Geometry;
+using DysonNetwork.Shared.Registry;
+
+namespace DysonNetwork.Wallet.Startup;
+
+public static class ServiceCollectionExtensions
+{
+    public static IServiceCollection AddAppServices(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddLocalization(options => options.ResourcesPath = "Resources");
+
+        services.AddDbContext<AppDatabase>();
+        services.AddHttpContextAccessor();
+
+        services.AddHttpClient();
+
+        // Register gRPC services
+        services.AddGrpc(options =>
+        {
+            options.EnableDetailedErrors = true; // Will be adjusted in Program.cs
+            options.MaxReceiveMessageSize = 16 * 1024 * 1024; // 16MB
+            options.MaxSendMessageSize = 16 * 1024 * 1024; // 16MB
+        });
+        services.AddGrpcReflection();
+
+        services.AddRingService();
+
+        services.AddControllers().AddJsonOptions(options =>
+        {
+            options.JsonSerializerOptions.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+            options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower;
+            options.JsonSerializerOptions.DictionaryKeyPolicy = JsonNamingPolicy.SnakeCaseLower;
+
+            options.JsonSerializerOptions.ConfigureForNodaTime(DateTimeZoneProviders.Tzdb);
+        });
+        services.AddRazorPages();
+
+        // Configure rate limiting
+        services.AddRateLimiter(options =>
+        {
+            options.AddFixedWindowLimiter("captcha", opt =>
+            {
+                opt.Window = TimeSpan.FromMinutes(1);
+                opt.PermitLimit = 5; // 5 attempts per minute
+                opt.QueueProcessingOrder = System.Threading.RateLimiting.QueueProcessingOrder.OldestFirst;
+                opt.QueueLimit = 2;
+            });
+        });
+
+        services.Configure<RequestLocalizationOptions>(options =>
+        {
+            var supportedCultures = new[]
+            {
+                new CultureInfo("en-US"),
+                new CultureInfo("zh-Hans"),
+            };
+
+            options.SupportedCultures = supportedCultures;
+            options.SupportedUICultures = supportedCultures;
+        });
+
+        return services;
+    }
+
+    public static IServiceCollection AddAppFlushHandlers(this IServiceCollection services)
+    {
+        services.AddSingleton<FlushBufferService>();
+
+        return services;
+    }
+
+    public static IServiceCollection AddAppBusinessServices(this IServiceCollection services,
+        IConfiguration configuration)
+    {
+        services.Configure<GeoOptions>(configuration.GetSection("GeoIP"));
+        services.AddScoped<GeoService>();
+
+        services.AddHostedService<BroadcastEventHandler>();
+
+        return services;
+    }
+}

DysonNetwork.Wallet/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}

DysonNetwork.Zone/DysonNetwork.Zone.csproj

@@ -28,6 +28,7 @@
         <PackageReference Include="Grpc.AspNetCore.Server" Version="2.76.0" />
         <PackageReference Include="Quartz" Version="3.15.1" />
         <PackageReference Include="Quartz.AspNetCore" Version="3.15.1" />
+        <PackageReference Include="Quartz.Extensions.Hosting" Version="3.15.1" />
         <PackageReference Include="SimpleMvcSitemap" Version="4.0.1" />
         <PackageReference Include="System.ServiceModel.Syndication" Version="10.0.2" />
     </ItemGroup>