Salihozkara/core layer

src/GitHunter.Application.Shared/ApplicationSharedModule.cs

@@ -1,9 +1,10 @@
-using GitHunter.Core.Shared;
+using GitHunter.Core;
+using GitHunter.Core.Modules;
 using Volo.Abp.Modularity;
 
-namespace GitHunter.Application.Shared;
+namespace GitHunter.Application;
 
 [DependsOn(typeof(CoreSharedModule))]
-public class ApplicationSharedModule : AbpModule
+public class ApplicationSharedModule : GitHunterModule
 {
 }

src/GitHunter.Application.Shared/GitHunter.Application.Shared.csproj

@@ -2,6 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>net7.0</TargetFramework>
+        <RootNamespace>GitHunter.Application</RootNamespace>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
     </PropertyGroup>

src/GitHunter.Application/ApplicationModule.cs

@@ -1,5 +1,5 @@
-using GitHunter.Application.Shared;
-using GitHunter.Core;
+using GitHunter.Core;
+using GitHunter.Core.Modules;
 using Volo.Abp.Modularity;
 
 namespace GitHunter.Application;
@@ -8,6 +8,6 @@ namespace GitHunter.Application;
     typeof(ApplicationSharedModule),
     typeof(CoreModule)
 )]
-public class ApplicationModule : AbpModule
+public class ApplicationModule : GitHunterModule
 {
 }

src/GitHunter.Application/GitHunter.Application.csproj

@@ -2,6 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>net7.0</TargetFramework>
+        <RootNamespace>GitHunter.Application</RootNamespace>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
     </PropertyGroup>

src/GitHunter.Core.Shared/CoreSharedModule.cs

@@ -1,13 +1,14 @@
-using Volo.Abp.Autofac;
+using GitHunter.Core.Modules;
+using Volo.Abp.Autofac;
 using Volo.Abp.AutoMapper;
 using Volo.Abp.Modularity;
 
-namespace GitHunter.Core.Shared;
+namespace GitHunter.Core;
 
 [DependsOn(
     typeof(AbpAutofacModule),
     typeof(AbpAutoMapperModule)
 )]
-public class CoreSharedModule : AbpModule
+public class CoreSharedModule : GitHunterModule
 {
 }

src/GitHunter.Core.Shared/DependencyProcesses/IDependencyProcess.cs

@@ -0,0 +1,5 @@
+namespace GitHunter.Core.DependencyProcesses;
+
+public interface IDependencyProcess
+{
+}

src/GitHunter.Core.Shared/DependencyProcesses/IProcessDependency.cs

@@ -0,0 +1,6 @@
+namespace GitHunter.Core.DependencyProcesses;
+
+public interface IProcessDependency
+{
+    bool Check();
+}

src/GitHunter.Core.Shared/DependencyProcesses/IProcessDependencyChecker.cs

@@ -0,0 +1,8 @@
+using System.Reflection;
+
+namespace GitHunter.Core.DependencyProcesses;
+
+public interface IProcessDependencyChecker
+{
+    bool CheckDependency(Assembly assembly);
+}

src/GitHunter.Core.Shared/DependencyProcesses/ProcessDependencyAttribute.cs

@@ -0,0 +1,10 @@
+namespace GitHunter.Core.DependencyProcesses;
+
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+public class ProcessDependencyAttribute<T> : ProcessDependencyAttribute  where T : IProcessDependency
+{
+    public ProcessDependencyAttribute()
+    {
+        DependencyProcess = typeof(T);
+    }
+}

src/GitHunter.Core.Shared/DependencyProcesses/a.cs

@@ -0,0 +1,6 @@
+namespace GitHunter.Core.DependencyProcesses;
+
+public abstract class ProcessDependencyAttribute : Attribute
+{
+    public Type DependencyProcess { get; protected set; }
+}

src/GitHunter.Core.Shared/Git/IGitManager.cs

@@ -0,0 +1,6 @@
+namespace GitHunter.Core.Git;
+
+public interface IGitManager
+{
+
+}

src/GitHunter.Core.Shared/GitHunter.Core.Shared.csproj

@@ -2,6 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>net7.0</TargetFramework>
+        <RootNamespace>GitHunter.Core</RootNamespace>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
     </PropertyGroup>

src/GitHunter.Core.Shared/Modules/GitHunterModule.cs

@@ -0,0 +1,18 @@
+using System.Reflection;
+using Volo.Abp.Modularity;
+
+namespace GitHunter.Core.Modules;
+
+public class GitHunterModule : AbpModule
+{
+    public static bool IsGitHunterModule(Type type)
+    {
+        var typeInfo = type.GetTypeInfo();
+
+        return
+            typeInfo.IsClass &&
+            !typeInfo.IsAbstract &&
+            !typeInfo.IsGenericType &&
+            typeof(GitHunterModule).GetTypeInfo().IsAssignableFrom(type);
+    }
+}

src/GitHunter.Core.Shared/Processes/IProcessManager.cs

@@ -0,0 +1,10 @@
+namespace GitHunter.Core.Processes;
+
+public interface IProcessManager
+{
+    Task<ProcessResult> RunAsync(string command, string arguments, string? workingDirectory = null);
+
+    Task<ProcessResult> RunAsync(ProcessStartInfo processStartInfo);
+
+    Task<bool> KillAllProcessesAsync();
+}

src/GitHunter.Core.Shared/Processes/ProcessResult.cs

@@ -0,0 +1,8 @@
+namespace GitHunter.Core.Processes;
+
+public class ProcessResult
+{
+    public int ExitCode { get; set; }
+    public string? Output { get; set; }
+    public string? Error { get; set; }
+}

src/GitHunter.Core.Shared/Processes/ProcessStartInfo.cs

@@ -0,0 +1,22 @@
+namespace GitHunter.Core.Processes;
+
+public class ProcessStartInfo
+{
+    public ProcessStartInfo(string command, string arguments, string? workingDirectory = null, Action? exited = null,
+        Action<string>? outputDataReceived = null, Action<string>? errorDataReceived = null)
+    {
+        Command = command;
+        Arguments = arguments;
+        Exited = exited;
+        WorkingDirectory = workingDirectory;
+        OutputDataReceived = outputDataReceived;
+        ErrorDataReceived = errorDataReceived;
+    }
+
+    public string Command { get; private set; }
+    public string Arguments { get; private set; }
+    public string? WorkingDirectory { get; private set; }
+    public Action<string>? OutputDataReceived { get; private set; }
+    public Action<string>? ErrorDataReceived { get; private set; }
+    public Action? Exited { get; private set; }
+}

src/GitHunter.Core/CoreModule.cs

@@ -1,9 +1,47 @@
-using GitHunter.Core.Shared;
+using GitHunter.Core.DependencyProcesses;
+using GitHunter.Core.Modules;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Volo.Abp;
 using Volo.Abp.Modularity;
 
 namespace GitHunter.Core;
 
 [DependsOn(typeof(CoreSharedModule))]
-public class CoreModule : AbpModule
+public class CoreModule : GitHunterModule
 {
+    public override void PreConfigureServices(ServiceConfigurationContext context)
+    {
+        // var services = context.Services;
+        // // var processDependencyChecker = services.GetRequiredService<ProcessDependencyChecker>();
+        // var processDependencyOptions = services.GetRequiredService<IOptions<ProcessDependencyOptions>>().Value;
+        //
+        // var modules = services.GetSingletonInstance<IModuleLoader>()
+        //     .LoadModules(
+        //         services,
+        //         processDependencyOptions.StartupModule,
+        //         new AbpApplicationCreationOptions(context.Services).PlugInSources
+        //     );
+
+
+    }
+
+    public override void OnApplicationInitialization(ApplicationInitializationContext context)
+    {
+
+        using (var scope = context.ServiceProvider.CreateScope())
+        {
+            var processDependencyChecker = scope.ServiceProvider.GetRequiredService<ProcessDependencyChecker>();
+            var processDependencyOptions = scope.ServiceProvider.GetRequiredService<IOptions<ProcessDependencyOptions>>().Value;
+            var modules = ModuleHelper.FindGitHunterModuleTypes(processDependencyOptions.StartupModule);
+
+            foreach (var assembly in modules.Select(m=>m.Assembly))
+            {
+                processDependencyChecker?.CheckDependency(assembly);
+            }
+        }
+
+        base.OnApplicationInitialization(context);
+    }
 }

src/GitHunter.Core/DependencyProcesses/ProcessDependencyChecker.cs

@@ -0,0 +1,24 @@
+using System.Reflection;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.DependencyInjection;
+
+namespace GitHunter.Core.DependencyProcesses;
+
+public class ProcessDependencyChecker : IProcessDependencyChecker, ISingletonDependency
+{
+    private readonly IServiceProvider _serviceProvider;
+
+    public ProcessDependencyChecker(IServiceProvider serviceProvider)
+    {
+        _serviceProvider = serviceProvider;
+    }
+
+    public bool CheckDependency(Assembly assembly)
+    {
+        var dependenciesTypes = assembly.GetTypes().Where(t => typeof(IDependencyProcess).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract).ToList();
+        var dependenciesAttributes = dependenciesTypes.SelectMany(t => t.GetCustomAttributes(typeof(ProcessDependencyAttribute<>))).ToList();
+        var dependencies = dependenciesAttributes.Cast<ProcessDependencyAttribute>().Select(t=>(IProcessDependency)ActivatorUtilities.CreateInstance(_serviceProvider, t.DependencyProcess)).ToList();
+
+        return dependencies.All(d => d.Check());
+    }
+}

src/GitHunter.Core/DependencyProcesses/ProcessDependencyOptions.cs

@@ -0,0 +1,6 @@
+namespace GitHunter.Core.DependencyProcesses;
+
+public class ProcessDependencyOptions
+{
+    public Type StartupModule { get; set; }
+}

src/GitHunter.Core/Git/GitManager.cs

@@ -0,0 +1,10 @@
+using GitHunter.Core.DependencyProcesses;
+using Volo.Abp.DependencyInjection;
+
+namespace GitHunter.Core.Git;
+
+[ProcessDependency<GitProcessDependency>]
+public class GitManager : IGitManager, IDependencyProcess, ITransientDependency
+{
+
+}

src/GitHunter.Core/Git/GitProcessDependency.cs

@@ -0,0 +1,13 @@
+using GitHunter.Core.DependencyProcesses;
+
+namespace GitHunter.Core.Git;
+
+public class GitProcessDependency : IProcessDependency
+{
+    public bool Check()
+    {
+        var environmentVariable = Environment.GetEnvironmentVariable("PATH");
+        var paths = environmentVariable?.Split(';');
+        return paths != null && paths.Any(path => File.Exists(Path.Combine(path, "git.exe")));
+    }
+}

src/GitHunter.Core/GitHunter.Core.csproj

@@ -2,6 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>net7.0</TargetFramework>
+        <RootNamespace>GitHunter.Core</RootNamespace>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
     </PropertyGroup>

src/GitHunter.Core/Modules/ModuleHelper.cs

@@ -0,0 +1,58 @@
+using System.Reflection;
+using Volo.Abp.Modularity;
+
+namespace GitHunter.Core.Modules;
+
+internal static class ModuleHelper
+{
+    public static IEnumerable<Type> FindGitHunterModuleTypes(Type startupModuleType)
+    {
+        if(!GitHunterModule.IsGitHunterModule(startupModuleType))
+        {
+            throw new ArgumentException("Given type is not an GitHunter module: " + startupModuleType.AssemblyQualifiedName);
+        }
+        var moduleTypes = new List<Type>();
+        AddModuleAndDependenciesRecursively(moduleTypes, startupModuleType);
+        return moduleTypes;
+    }
+
+    private static List<Type> FindDependedModuleTypes(ICustomAttributeProvider moduleType)
+    {
+        var dependencies = new List<Type>();
+
+        var dependencyDescriptors = moduleType
+            .GetCustomAttributes(false)
+            .OfType<IDependedTypesProvider>();
+
+        foreach (var descriptor in dependencyDescriptors)
+        {
+            foreach (var dependedModuleType in descriptor.GetDependedTypes())
+            {
+                dependencies.AddIfNotContains(dependedModuleType);
+            }
+        }
+
+        return dependencies;
+    }
+
+    private static void AddModuleAndDependenciesRecursively(
+        ICollection<Type> moduleTypes,
+        Type moduleType)
+    {
+        if(!GitHunterModule.IsGitHunterModule(moduleType))
+            return;
+
+        if (moduleTypes.Contains(moduleType))
+        {
+            return;
+        }
+
+
+        moduleTypes.Add(moduleType);
+
+        foreach (var dependedModuleType in FindDependedModuleTypes(moduleType))
+        {
+            AddModuleAndDependenciesRecursively(moduleTypes, dependedModuleType);
+        }
+    }
+}