DesignService.cs

using AppBoxCore;
using AppBoxDesign;
using AppBoxServer.Design;
using AppBoxStore;

namespace AppBoxServer;

/// <summary>
/// 设计时服务
/// </summary>
internal sealed class DesignService : IService
{
    static DesignService()
    {
        //注册设计时序列化器
        DesignTypeSerializer.Register();
    }

    private static readonly ModelId DeveloperPermissionId =
        ModelId.Make(Consts.SYS_APP_ID, ModelType.Permission, 2, ModelLayer.SYS);

    public async ValueTask<AnyValue> InvokeAsync<T>(ReadOnlyMemory<char> method, T args)
        where T : struct, IAnyArgs
    {
        //验证Developer权限
        if (!RuntimeContext.HasPermission(DeveloperPermissionId))
            throw new Exception("Must login as a developer");

        switch (method.Span)
        {
            case DesignMethods.LoadMetadataReference:
                return MetadataReferenceLoader.LoadMetadataReference(args.GetInt()!.Value, args.GetString()!,
                    args.GetString());
            case "LoadAllApplication":
                return AnyValue.From(await MetaStore.DownloadApplicationsAsync());
            case "LoadAllFolder":
                return AnyValue.From(await MetaStore.DownloadFoldersAsync());
            case "LoadAllModel":
                return AnyValue.From(await MetaStore.DownloadModelsAsync());
            case "LoadModelCode":
                return AnyValue.From(await MetaStore.Provider.DownloadModelCodeAsync(args.GetLong()!.Value));
            case DesignMethods.CreateApplication:
                await MetaStore.Provider.CreateApplicationAsync((ApplicationModel)args.GetObject()!, null);
                return AnyValue.Empty;
            case DesignMethods.DeleteApplication:
                await MetaStore.Provider.DeleteApplicationAsync((ApplicationModel)args.GetObject()!);
                return AnyValue.Empty;
            case "GenModelId":
                return (long)(await MetaStore.Provider.GenModelIdAsync(
                    args.GetInt()!.Value, (ModelType)args.GetInt()!.Value, (ModelLayer)args.GetInt()!.Value));
            case DesignMethods.LoadModelIdCounter:
                return AnyValue.From(
                    await MetaStore.Provider.LoadModelIdCounter(args.GetInt()!.Value, args.GetBool()!.Value));
            case DesignMethods.UpsertModelIdCounter:
                await MetaStore.Provider.UpsertModelIdCounterAsync(args.GetInt()!.Value, args.GetBool()!.Value,
                    (byte[])args.GetObject()!);
                return AnyValue.Empty;
            case "CheckoutLoadAll":
                return AnyValue.From(await CheckoutService.LoadAllAsync());
            case "Checkout":
                return AnyValue.From(await CheckoutService.CheckoutAsync(args.GetList<CheckoutInfo>()));
            case "StageLoadAll":
                return AnyValue.From(await StagedService.LoadStagedAsync());
            case "StageLoadCode":
                return AnyValue.From(await StagedService.DownloadCodeAsync(args.GetLong()!.Value));
            case "StageSaveModel":
                await StagedService.SaveModelAsync((ModelBase)args.GetObject()!);
                return AnyValue.Empty;
            case "StageSaveFolder":
                await StagedService.SaveFolderAsync((ModelFolder)args.GetObject()!);
                return AnyValue.Empty;
            case "StageSaveCode":
                await StagedService.SaveCodeAsync((IAsyncEnumerable<IBlobChunk>)args.GetObject()!,
                    args.GetLong()!.Value);
                return AnyValue.Empty;
            case "StageDeleteModel":
                await StagedService.DeleteModelAsync(args.GetLong()!.Value);
                return AnyValue.Empty;
            case "GetEntityRows":
                return await GetEntityRows(args);
            case "Publish":
                await PublishService.PublishAsync((PublishPackage)args.GetObject()!, args.GetString());
                return AnyValue.Empty;
            case "UploadServiceAssembly":
                await PublishService.UploadServiceAssembly((IAsyncEnumerable<IBlobChunk>)args.GetObject()!,
                    args.GetString()!, args.GetBool()!.Value);
                return AnyValue.Empty;
            case "UploadAppAssembly":
                await PublishService.UploadAppAssembly((IAsyncEnumerable<IBlobChunk>)args.GetObject()!,
                    args.GetString()!, args.GetBool()!.Value);
                return AnyValue.Empty;
            case "UploadViewAssemblyMap":
                await PublishService.UploadViewAssemblyMap((IAsyncEnumerable<IBlobChunk>)args.GetObject()!);
                return AnyValue.Empty;
            case DesignMethods.UploadExtAssembly:
                return AnyValue.From(await ExternalLibraryManager.UploadLibrary(
                    (IAsyncEnumerable<IBlobChunk>)args.GetObject()!, args.GetString()!, args.GetString()!));
            case DesignMethods.GetExtLibraries:
                return AnyValue.From(await ExternalLibraryManager.GetExternalLibraries(args.GetString()!));
            case DesignMethods.DebugUploadService:
                await DebugService.UploadAssembly((IAsyncEnumerable<IBlobChunk>)args.GetObject()!, args.GetString()!);
                return AnyValue.Empty;
            case DesignMethods.DebugStart:
                DebugService.Start((DebugStartRequest)args.GetObject()!);
                return AnyValue.Empty;
            case DesignMethods.DebugResume:
                DebugService.Resume();
                return AnyValue.Empty;
            case DesignMethods.DebugExit:
                DebugService.Exit();
                return AnyValue.Empty;
            case DesignMethods.DebugEvaluate:
                return AnyValue.From(await DebugService.Evaluate(args.GetString()!));
            case DesignMethods.DebugListChildren:
                return AnyValue.From(await DebugService.ListChildren(args.GetString()!));
            default:
                throw new Exception($"Unknown design method: {method}");
        }
    }

    #region ====Entity====

    private static async ValueTask<AnyValue> GetEntityRows<T>(T args) where T : struct, IAnyArgs
    {
        ModelId modelId = args.GetString()!;
        var pageSize = args.GetInt()!.Value;

        var model = await RuntimeContext.GetModelAsync<EntityModel>(modelId);
        if (model.SqlStoreOptions == null)
            throw new NotSupportedException("Only support SqlStore now.");

        var fields = model.Members
            .Where(m => m.Type == EntityMemberType.EntityField)
            .Cast<EntityFieldMember>()
            .ToArray();

        var q = new DynamicQuery() { ModelId = modelId };
        var t = new EntityExpression(modelId, null);
        q.Selects = new DynamicQuery.SelectItem[fields.Length];
        for (var i = 0; i < fields.Length; i++)
        {
            q.Selects[i] = new DynamicQuery.SelectItem(fields[i].Name, t.F(fields[i].Name),
                DataCell.DataTypeFromEntityFieldType(fields[i].FieldType));
        }

        q.PageSize = pageSize;
        q.PageIndex = 0;

        var query = new SqlDynamicQuery(q);
        var res = await query.ToDataTableAsync();
        return AnyValue.From(res);
    }

    #endregion
}