SemianiakaVY/elsa-core
1
0
Fork 0
Code Issues Pull requests Actions 1 Packages Projects Releases Wiki Activity

Removing IO module (moved to Extensions)

Browse source
This commit is contained in:
lucas.hipolito 2025-08-01 15:04:20 +02:00
parent 34ad766cad
commit 4eac2967a1
34 changed files with 2 additions and 1281 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Directory.Packages.props
View file

@ -4,7 +4,7 @@
<CentralPackageTransitivePinningEnabled>false</CentralPackageTransitivePinningEnabled>
</PropertyGroup>
<PropertyGroup>
<ElsaStudioVersion>3.6.0-preview.1165</ElsaStudioVersion>
<ElsaStudioVersion>3.6.0-preview.1170</ElsaStudioVersion>
<MicrosoftVersion>9.0.7</MicrosoftVersion>
<ResilienceVersion>9.7.0</ResilienceVersion>
</PropertyGroup>
@ -179,7 +179,7 @@
<CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
</PropertyGroup>
<PropertyGroup>
<ElsaStudioVersion>3.5.0-preview.1092</ElsaStudioVersion>
<ElsaStudioVersion>3.6.0-preview.1170</ElsaStudioVersion>
<MicrosoftVersion>9.0.7</MicrosoftVersion>
</PropertyGroup>
<ItemGroup>

24
Elsa.sln
View file

@ -237,14 +237,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Caching", "src\modules
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "http", "http", "{C55015F0-E9DF-4BF9-8131-D7539E938220}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "io", "io", "{7FD1FD1E-5778-4065-AAA5-1F878129EF77}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.IO", "src\modules\Elsa.IO\Elsa.IO.csproj", "{EB24F9FE-D7BD-4FCC-907E-AE400288C2A5}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.IO.Compression", "src\modules\Elsa.IO.Compression\Elsa.IO.Compression.csproj", "{9CA02818-F7EB-4A0B-B27B-BC74ACD499C9}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.IO.Http", "src\modules\Elsa.IO.Http\Elsa.IO.Http.csproj", "{C583AF05-D517-4B7F-8955-6B61500ED3D8}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Http", "src\modules\Elsa.Http\Elsa.Http.csproj", "{E0B22AB7-7CB5-6D17-562C-4A989DC61F8A}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Expressions.CSharp", "src\modules\Elsa.Expressions.CSharp\Elsa.Expressions.CSharp.csproj", "{16C3FBDE-A832-E3CD-5FBF-F51744D1F79B}"
@ -467,18 +459,6 @@ Global
{E7137FB0-1988-4562-AD8D-D0D9D2EE85F6}.Debug|Any CPU.Build.0 = Debug|Any CPU
{E7137FB0-1988-4562-AD8D-D0D9D2EE85F6}.Release|Any CPU.ActiveCfg = Release|Any CPU
{E7137FB0-1988-4562-AD8D-D0D9D2EE85F6}.Release|Any CPU.Build.0 = Release|Any CPU
{EB24F9FE-D7BD-4FCC-907E-AE400288C2A5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{EB24F9FE-D7BD-4FCC-907E-AE400288C2A5}.Debug|Any CPU.Build.0 = Debug|Any CPU
{EB24F9FE-D7BD-4FCC-907E-AE400288C2A5}.Release|Any CPU.ActiveCfg = Release|Any CPU
{EB24F9FE-D7BD-4FCC-907E-AE400288C2A5}.Release|Any CPU.Build.0 = Release|Any CPU
{9CA02818-F7EB-4A0B-B27B-BC74ACD499C9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{9CA02818-F7EB-4A0B-B27B-BC74ACD499C9}.Debug|Any CPU.Build.0 = Debug|Any CPU
{9CA02818-F7EB-4A0B-B27B-BC74ACD499C9}.Release|Any CPU.ActiveCfg = Release|Any CPU
{9CA02818-F7EB-4A0B-B27B-BC74ACD499C9}.Release|Any CPU.Build.0 = Release|Any CPU
{C583AF05-D517-4B7F-8955-6B61500ED3D8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{C583AF05-D517-4B7F-8955-6B61500ED3D8}.Debug|Any CPU.Build.0 = Debug|Any CPU
{C583AF05-D517-4B7F-8955-6B61500ED3D8}.Release|Any CPU.ActiveCfg = Release|Any CPU
{C583AF05-D517-4B7F-8955-6B61500ED3D8}.Release|Any CPU.Build.0 = Release|Any CPU
{6F14B066-DF7B-2409-59D8-CCCA90A4974C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{6F14B066-DF7B-2409-59D8-CCCA90A4974C}.Debug|Any CPU.Build.0 = Debug|Any CPU
{6F14B066-DF7B-2409-59D8-CCCA90A4974C}.Release|Any CPU.ActiveCfg = Release|Any CPU
@ -596,10 +576,6 @@ Global
{66E2E2CF-967F-4564-89E8-F46FA973C99B} = {986E5482-0482-448C-B9E4-EC67A9474B85}
{0A04B1FD-06C0-4271-A910-A08C263DBC44} = {0354F050-3992-4DD4-B0EE-5FBA04AC72B6}
{9B80A705-2E31-4012-964A-83963DCDB384} = {0354F050-3992-4DD4-B0EE-5FBA04AC72B6}
{7FD1FD1E-5778-4065-AAA5-1F878129EF77} = {5BA4A8FA-F7F4-45B3-AEC8-8886D35AAC79}
{EB24F9FE-D7BD-4FCC-907E-AE400288C2A5} = {7FD1FD1E-5778-4065-AAA5-1F878129EF77}
{9CA02818-F7EB-4A0B-B27B-BC74ACD499C9} = {7FD1FD1E-5778-4065-AAA5-1F878129EF77}
{C583AF05-D517-4B7F-8955-6B61500ED3D8} = {7FD1FD1E-5778-4065-AAA5-1F878129EF77}
{02EA681E-C7D8-13C7-8484-4AC65E1B71E8} = {5BA4A8FA-F7F4-45B3-AEC8-8886D35AAC79}
{6F14B066-DF7B-2409-59D8-CCCA90A4974C} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
{C55015F0-E9DF-4BF9-8131-D7539E938220} = {5BA4A8FA-F7F4-45B3-AEC8-8886D35AAC79}

208
src/modules/Elsa.IO.Compression/Activities/CreateZipArchive.cs
View file

@ -1,208 +0,0 @@
using System.IO.Compression;
using System.Text.Json.Serialization;
using Elsa.Extensions;
using Elsa.IO.Contracts;
using Elsa.IO.Extensions;
using Elsa.Workflows;
using Elsa.Workflows.Attributes;
using Elsa.Workflows.Models;
using Elsa.Workflows.UIHints;
using Microsoft.Extensions.Logging;
namespace Elsa.IO.Compression.Activities;
/// <summary>
/// Creates a ZIP archive from a collection of entries.
/// </summary>
[Activity("Elsa", "Compression", "Creates a ZIP archive from a collection of entries.", DisplayName = "Create Zip Archive")]
public class CreateZipArchive : CodeActivity<Stream>
{
private const string DefaultArchiveName = "archive.zip";
private const string ZipExtension = ".zip";
private const string DefaultEntryNameFormat = "entry_{0}";
/// <inheritdoc />
[JsonConstructor]
public CreateZipArchive(string? source = null, int? line = null) : base(source, line)
{
}
/// <summary>
/// The entries to include in the ZIP archive. Can be byte[], Stream, file path, file URL, base64 string, ZipEntry objects, or arrays of these types.
/// </summary>
[Input(
Description = "The entries to include in the ZIP archive. Can be byte[], Stream, file path, file URL, base64 string, ZipEntry objects, or arrays of these types",
UIHint = InputUIHints.MultiLine
)]
public Input<object?> Entries { get; set; } = null!;
/// <summary>
/// The compression level for the Zip Entries. Default is Optimal
/// </summary>
[Input(
Description = "The compression level for the Zip Entries. Default is Optimal",
UIHint = InputUIHints.DropDown
)]
public Input<CompressionLevel> CompressionLevel { get; set; } = new(System.IO.Compression.CompressionLevel.Optimal);
/// <inheritdoc />
protected override async ValueTask ExecuteAsync(ActivityExecutionContext context)
{
var entriesInput = Entries.Get(context);
var resolver = context.GetRequiredService<IContentResolver>();
var logger = context.GetRequiredService<ILogger<CreateZipArchive>>();
var entries = ParseEntries(entriesInput);
var zipStream = await CreateZipStreamFromEntries(entries, resolver, context, logger);
Result.Set(context, zipStream);
}
private static IEnumerable<object> ParseEntries(object? entriesInput)
{
return entriesInput switch
{
null => [],
IEnumerable<object> enumerable => enumerable,
Array array => array.Cast<object>(),
_ => [entriesInput]
};
}
private async Task<Stream> CreateZipStreamFromEntries(
IEnumerable<object> entries,
IContentResolver resolver,
ActivityExecutionContext context,
ILogger logger)
{
var zipStream = new MemoryStream();
try
{
using var zipArchive = new ZipArchive(zipStream, ZipArchiveMode.Update, leaveOpen: true);
var entryIndex = 0;
var compressionLevel = CompressionLevel.Get(context);
foreach (var entryContent in entries)
{
try
{
await ProcessZipEntry(entryContent, zipArchive, resolver, context, entryIndex, compressionLevel);
}
catch (Exception ex)
{
logger.LogWarning(ex, "Failed to add entry {EntryIndex} to ZIP archive. Reason: {ExceptionMessage}",
entryIndex, ex.Message);
}
entryIndex++;
}
}
catch (Exception ex)
{
logger.LogError(ex, "Failed to create ZIP archive");
await zipStream.DisposeAsync();
throw;
}
// Reset stream position for reading
zipStream.Position = 0;
return zipStream;
}
/// <summary>
/// Processes a single zip entry and adds it to the archive.
/// </summary>
private static async Task ProcessZipEntry(
object entryContent,
ZipArchive zipArchive,
IContentResolver resolver,
ActivityExecutionContext context,
int entryIndex,
CompressionLevel compressionLevel)
{
var binaryContent = await resolver.ResolveAsync(entryContent, context.CancellationToken);
var entryName = binaryContent.Name?.GetNameAndExtension()
?? string.Format(DefaultEntryNameFormat, entryIndex + 1);
// Get a unique name following Windows convention
entryName = GetUniqueEntryName(zipArchive, entryName);
var archiveEntry = zipArchive.CreateEntry(entryName, compressionLevel);
await using var entryStream = archiveEntry.Open();
await binaryContent.Stream.CopyToAsync(entryStream, context.CancellationToken);
await entryStream.FlushAsync(context.CancellationToken);
if (entryContent is not Stream)
{
await binaryContent.Stream.DisposeAsync();
}
}
private static string GetUniqueEntryName(ZipArchive zipArchive, string originalName)
{
var filenameWithoutExtension = Path.GetFileNameWithoutExtension(originalName);
var extension = Path.GetExtension(originalName);
var originalExists = false;
var highestIndex = 0;
foreach (var entry in zipArchive.Entries)
{
if (!entry.Name.Equals(originalName, StringComparison.OrdinalIgnoreCase))
{
continue;
}
originalExists = true;
var entryNameWithoutExtension = Path.GetFileNameWithoutExtension(entry.Name);
var entryExtension = Path.GetExtension(entry.Name);
// Only process entries with the same extension
if (!entryExtension.Equals(extension, StringComparison.OrdinalIgnoreCase))
continue;
// Check if this entry follows our naming pattern
highestIndex = HighestEntryNameIndex(entryNameWithoutExtension, filenameWithoutExtension, highestIndex);
}
if (!originalExists)
{
return originalName;
}
return $"{filenameWithoutExtension}({highestIndex + 1}){extension}";
}
private static int HighestEntryNameIndex(string entryNameWithoutExtension, string filenameWithoutExtension,
int highestIndex)
{
if (!entryNameWithoutExtension.StartsWith(filenameWithoutExtension, StringComparison.OrdinalIgnoreCase) ||
entryNameWithoutExtension.Length <= filenameWithoutExtension.Length ||
entryNameWithoutExtension[filenameWithoutExtension.Length] != '(')
{
return highestIndex;
}
// Extract the number between parentheses
var closingParenIndex = entryNameWithoutExtension.LastIndexOf(')');
if (closingParenIndex <= filenameWithoutExtension.Length + 1)
{
return highestIndex;
}
var indexStr = entryNameWithoutExtension.Substring(
filenameWithoutExtension.Length + 1,
closingParenIndex - filenameWithoutExtension.Length - 1);
if (int.TryParse(indexStr, out var index))
{
highestIndex = Math.Max(highestIndex, index);
}
return highestIndex;
}
}

6
src/modules/Elsa.IO.Compression/Common/Constants.cs
View file

@ -1,6 +0,0 @@
namespace Elsa.IO.Compression.Common;
public static class Constants
{
public const float ZipEntryStrategyPriority = 0.5f;
}

23
src/modules/Elsa.IO.Compression/Elsa.IO.Compression.csproj
View file

@ -1,23 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<Description>
Provides compression and archiving activities for Elsa Workflows.
</Description>
<PackageTags>elsa module compression zip archive workflows</PackageTags>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.Http" />
<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
<PackageReference Include="Microsoft.Extensions.Options" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Elsa.Workflows.Core\Elsa.Workflows.Core.csproj" />
<ProjectReference Include="..\Elsa.Workflows.Runtime\Elsa.Workflows.Runtime.csproj" />
<ProjectReference Include="..\Elsa.IO\Elsa.IO.csproj" />
<ProjectReference Include="..\..\common\Elsa.Features\Elsa.Features.csproj" />
</ItemGroup>
</Project>

20
src/modules/Elsa.IO.Compression/Extensions/ModuleExtensions.cs
View file

@ -1,20 +0,0 @@
using Elsa.IO.Compression.Features;
using Elsa.Features.Services;
// ReSharper disable once CheckNamespace
namespace Elsa.Extensions;
/// <summary>
/// Provides extensions to install the <see cref="CompressionFeature"/> feature.
/// </summary>
public static class ModuleExtensions
{
/// <summary>
/// Install the <see cref="CompressionFeature"/> feature.
/// </summary>
public static IModule UseCompression(this IModule module, Action<CompressionFeature>? configure = default)
{
module.Configure(configure);
return module;
}
}

33
src/modules/Elsa.IO.Compression/Features/CompressionFeature.cs
View file

@ -1,33 +0,0 @@
using Elsa.Extensions;
using Elsa.Features.Abstractions;
using Elsa.Features.Attributes;
using Elsa.Features.Services;
using Elsa.IO.Compression.Models;
using Elsa.IO.Compression.Services.Strategies;
using Elsa.IO.Features;
using Elsa.IO.Services.Strategies;
using JetBrains.Annotations;
using Microsoft.Extensions.DependencyInjection;
namespace Elsa.IO.Compression.Features;
/// <summary>
/// Configures compression activities and services.
/// </summary>
[UsedImplicitly]
[DependsOn(typeof(IOFeature))]
public class CompressionFeature(IModule module) : FeatureBase(module)
{
/// <inheritdoc />
public override void Configure()
{
Module.AddActivitiesFrom<CompressionFeature>();
Module.AddVariableTypeAndAlias<ZipEntry>("ZipEntry", "Compression");
}
/// <inheritdoc />
public override void Apply()
{
Services.AddScoped<IContentResolverStrategy, ZipEntryContentStrategy>();
}
}

3
src/modules/Elsa.IO.Compression/FodyWeavers.xml
View file

@ -1,3 +0,0 @@
<Weavers xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="FodyWeavers.xsd">
<ConfigureAwait />
</Weavers>

11
src/modules/Elsa.IO.Compression/Models/ZipEntry.cs
View file

@ -1,11 +0,0 @@
using JetBrains.Annotations;
namespace Elsa.IO.Compression.Models;
/// <summary>
/// Represents a zip entry with content and metadata.
/// </summary>
/// <param name="Content">The content of the zip entry. Can be byte[], Stream, file path, file URL, or base64 string.</param>
/// <param name="EntryName">The name of the entry in the zip archive.</param>
[UsedImplicitly]
public record ZipEntry(object Content, string? EntryName = null);

44
src/modules/Elsa.IO.Compression/Services/Strategies/ZipEntryContentStrategy.cs
View file

@ -1,44 +0,0 @@
using Elsa.IO.Compression.Common;
using Elsa.IO.Compression.Models;
using Elsa.IO.Contracts;
using Elsa.IO.Extensions;
using Elsa.IO.Models;
using Elsa.IO.Services.Strategies;
using Microsoft.Extensions.DependencyInjection;
namespace Elsa.IO.Compression.Services.Strategies;
/// <summary>
/// Strategy for resolving ZipEntry content with proper entry names.
/// </summary>
public class ZipEntryContentStrategy(IServiceProvider serviceProvider) : IContentResolverStrategy
{
/// <inheritdoc />
public float Priority => Constants.ZipEntryStrategyPriority;
/// <inheritdoc />
public bool CanResolve(object content) => content is ZipEntry;
/// <inheritdoc />
public async Task<BinaryContent> ResolveAsync(object content, CancellationToken cancellationToken = default)
{
var zipEntry = (ZipEntry)content;
var resolver = serviceProvider.GetRequiredService<IContentResolver>();
var innerContent = await resolver.ResolveAsync(zipEntry.Content, cancellationToken);
if (string.IsNullOrEmpty(zipEntry.EntryName))
{
return innerContent;
}
var innerContentName = innerContent.Name?.GetNameAndExtension();
var innerContentExtension = Path.GetExtension(innerContentName);
innerContent.Name = !string.IsNullOrWhiteSpace(innerContentExtension)
? Path.HasExtension(zipEntry.EntryName) ? zipEntry.EntryName : zipEntry.EntryName + innerContentExtension
: innerContent.Name;
return innerContent;
}
}

14
src/modules/Elsa.IO.Http/Common/Constants.cs
View file

@ -1,14 +0,0 @@
namespace Elsa.IO.Http.Common;
public static class Constants
{
/// <summary>
/// The name of the HTTP client used for IO operations.
/// </summary>
public const string IOFeatureHttpClient = "IOFeatureHttpClient";
public static class StrategyPriorities
{
public const float Uri = 2.5f;
}
}

21
src/modules/Elsa.IO.Http/Elsa.IO.Http.csproj
View file

@ -1,21 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<Description>
Provides http capabilities to IO modules in Elsa Workflows.
</Description>
<PackageTags>elsa module io http</PackageTags>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\Elsa.Http\Elsa.Http.csproj" />
<ProjectReference Include="..\Elsa.IO.Compression\Elsa.IO.Compression.csproj" />
<ProjectReference Include="..\Elsa.IO\Elsa.IO.csproj" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.Http" />
<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
</ItemGroup>
</Project>

29
src/modules/Elsa.IO.Http/Features/IOHttpFeature.cs
View file

@ -1,29 +0,0 @@
using Elsa.Features.Abstractions;
using Elsa.Features.Attributes;
using Elsa.Features.Services;
using Elsa.IO.Compression.Features;
using Elsa.IO.Features;
using Elsa.IO.Http.Common;
using Elsa.IO.Http.Services.Strategies;
using Elsa.IO.Services.Strategies;
using JetBrains.Annotations;
using Microsoft.Extensions.DependencyInjection;
namespace Elsa.IO.Http.Features;
/// <summary>
/// Configures HTTP-based IO services.
/// </summary>
[UsedImplicitly]
[DependsOn(typeof(IOFeature))]
[DependencyOf(typeof(CompressionFeature))]
public class IOHttpFeature(IModule module) : FeatureBase(module)
{
/// <inheritdoc />
public override void Apply()
{
Services.AddHttpClient(Constants.IOFeatureHttpClient);
Services.AddScoped<IContentResolverStrategy, UrlContentStrategy>();
}
}

3
src/modules/Elsa.IO.Http/FodyWeavers.xml
View file

@ -1,3 +0,0 @@
<Weavers xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="FodyWeavers.xsd">
<ConfigureAwait />
</Weavers>

78
src/modules/Elsa.IO.Http/Services/Strategies/UrlContentStrategy.cs
View file

@ -1,78 +0,0 @@
using Elsa.Extensions;
using Elsa.IO.Extensions;
using Elsa.IO.Http.Common;
using Elsa.IO.Models;
using Elsa.IO.Services.Strategies;
using Microsoft.Extensions.Logging;
namespace Elsa.IO.Http.Services.Strategies;
/// <summary>
/// Strategy for handling URL content by downloading from HTTP/HTTPS URLs.
/// </summary>
public class UrlContentStrategy(ILogger<UrlContentStrategy> logger, IHttpClientFactory httpClientFactory) : IContentResolverStrategy
{
/// <inheritdoc />
public float Priority => Constants.StrategyPriorities.Uri;
/// <inheritdoc />
public bool CanResolve(object content) => content is string str && (str.StartsWith("http://") || str.StartsWith("https://"));
/// <inheritdoc />
public async Task<BinaryContent> ResolveAsync(object content, CancellationToken cancellationToken = default)
{
var url = (string)content;
try
{
var httpClient = httpClientFactory.CreateClient();
var response = await httpClient.GetAsync(url, cancellationToken);
response.EnsureSuccessStatusCode();
var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
var filename = ExtractFilenameFromResponse(response, url);
var contentType = response.Content.Headers.ContentType?.MediaType;
return new BinaryContent
{
Name = filename.GetNameAndExtension(contentType.GetExtensionFromContentType()),
Stream = stream
};
}
catch (Exception ex)
{
logger.LogError(ex, "Failed to download file from URL: {Url}", url);
throw;
}
}
/// <summary>
/// Extracts a filename from the HTTP response, either from Content-Disposition header or URL.
/// </summary>
private string ExtractFilenameFromResponse(HttpResponseMessage response, string url)
{
var filename = response.GetFilename();
if (!string.IsNullOrWhiteSpace(filename))
{
return filename;
}
try
{
var uri = new Uri(url);
var path = uri.AbsolutePath;
filename = Path.GetFileName(path);
if (!string.IsNullOrEmpty(filename) && Path.HasExtension(filename))
{
return filename;
}
}
catch (Exception ex)
{
logger.LogDebug(ex, "Failed to extract filename from URL: {Url}", url);
}
return "download";
}
}

38
src/modules/Elsa.IO/Common/Constants.cs
View file

@ -1,38 +0,0 @@
namespace Elsa.IO.Common;
/// <summary>
/// IO module constants.
/// </summary>
public static class Constants
{
/// <summary>
/// Priorities for content resolver strategies.
/// </summary>
public static class StrategyPriorities
{
/// <summary>
/// Stream content priority.
/// </summary>
public const float Stream = 0.0f;
/// <summary>
/// Byte array content priority.
/// </summary>
public const float ByteArray = 1.0f;
/// <summary>
/// Base64 content priority.
/// </summary>
public const float Base64 = 2.0f;
/// <summary>
/// File path content priority.
/// </summary>
public const float FilePath = 3.0f;
/// <summary>
/// Text content priority.
/// </summary>
public const float Text = 100.0f;
}
}

17
src/modules/Elsa.IO/Contracts/IContentResolver.cs
View file

@ -1,17 +0,0 @@
namespace Elsa.IO.Contracts;
using Elsa.IO.Models;
/// <summary>
/// Provides methods to resolve various content types to BinaryContent.
/// </summary>
public interface IContentResolver
{
/// <summary>
/// Resolves arbitrary content to a BinaryContent object that includes the content stream and metadata.
/// </summary>
/// <param name="content">The content to resolve. Can be byte[], Stream, file path, file URL, base64 string, or plain text.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>A BinaryContent object containing the content stream and associated metadata.</returns>
Task<BinaryContent> ResolveAsync(object content, CancellationToken cancellationToken = default);
}

21
src/modules/Elsa.IO/Elsa.IO.csproj
View file

@ -1,21 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<Description>
Provides IO services for resolving various content types to streams.
</Description>
<PackageTags>elsa module io content streams</PackageTags>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
<PackageReference Include="Microsoft.Extensions.Http" />
<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\common\Elsa.Features\Elsa.Features.csproj" />
</ItemGroup>
</Project>

166
src/modules/Elsa.IO/Extensions/ContentTypeExtensions.cs
View file

@ -1,166 +0,0 @@
namespace Elsa.IO.Extensions;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
public static class ContentTypeExtensions
{
private static readonly Dictionary<string, string> MimeMapping = new(StringComparer.OrdinalIgnoreCase);
private static readonly Dictionary<string, HashSet<string>> ContentTypeToExtensionsMap = new(StringComparer.OrdinalIgnoreCase);
static ContentTypeExtensions()
{
// Define all mappings in a single place
AddMapping(".txt", "text/plain");
AddMapping(".html", "text/html");
AddMapping(".htm", "text/html");
AddMapping(".css", "text/css");
AddMapping(".js", "application/javascript");
AddMapping(".json", "application/json");
AddMapping(".xml", "application/xml");
AddMapping(".jpg", "image/jpeg");
AddMapping(".jpeg", "image/jpeg");
AddMapping(".png", "image/png");
AddMapping(".gif", "image/gif");
AddMapping(".svg", "image/svg+xml");
AddMapping(".pdf", "application/pdf");
AddMapping(".doc", "application/msword");
AddMapping(".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
AddMapping(".xls", "application/vnd.ms-excel");
AddMapping(".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
AddMapping(".ppt", "application/vnd.ms-powerpoint");
AddMapping(".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation");
AddMapping(".zip", "application/zip");
AddMapping(".csv", "text/csv");
}
private static void AddMapping(string extension, string contentType)
{
// Map extension to content type
MimeMapping[extension] = contentType;
// Map content type to extension(s)
if (!ContentTypeToExtensionsMap.TryGetValue(contentType, out var extensions))
{
extensions = new(StringComparer.OrdinalIgnoreCase);
ContentTypeToExtensionsMap[contentType] = extensions;
}
extensions.Add(extension);
}
public static string GetExtensionFromContentType(this string? contentType)
{
if (string.IsNullOrEmpty(contentType))
return ".bin";
if (contentType.EndsWith("/pdf") || contentType == "application/pdf")
return ".pdf";
if (ContentTypeToExtensionsMap.TryGetValue(contentType, out var extensions) && extensions.Any())
{
// Return the first extension for this content type
return extensions.First();
}
return DetermineExtensionFromMimeType(contentType);
}
public static string GetContentTypeFromExtension(this string filePath)
{
var extension = filePath.GetFileExtension();
return MimeMapping.GetValueOrDefault(extension, "application/octet-stream");
}
public static string GetNameAndExtension(this string fileName, string? extension = ".bin")
{
var currentExtension = fileName.GetFileExtension();
if (!string.IsNullOrWhiteSpace(currentExtension))
{
return fileName;
}
return fileName + extension;
}
public static string GetFileExtension(this string filePath)
{
return Path.GetExtension(filePath).ToLowerInvariant();
}
public static bool IsBase64String(this string s)
{
if (string.IsNullOrWhiteSpace(s))
return false;
s = s.Trim();
// Length must be divisible by 4
if (s.Length % 4 != 0)
return false;
// Check padding position and count
var paddingIndex = s.IndexOf('=');
switch (paddingIndex)
{
// Padding cannot be at index 0
case 0:
// Padding must be at the end
case > 0 when paddingIndex < s.Length - 2:
// All characters after first '=' must also be '='
case > 0 when s[paddingIndex..].Any(c => c != '='):
return false;
}
// Check for valid Base64 characters
for (var i = 0; i < paddingIndex; i++)
{
var c = s[i];
var isValid =
c is >= 'A' and <= 'Z' ||
c is >= 'a' and <= 'z' ||
c is >= '0' and <= '9' ||
c == '+' || c == '/';
if (!isValid)
return false;
}
// Additional check for short strings that are just lowercase+numbers
// This catches "whatever" and similar false positives
if (s.Length <= 10 && s.All(c => char.IsLower(c) || char.IsDigit(c)))
return false;
// Try actual decoding
try
{
_ = Convert.FromBase64String(s);
return true;
}
catch
{
return false;
}
}
private static string DetermineExtensionFromMimeType(string mimeType)
{
if (mimeType.Contains("/pdf"))
return ".pdf";
if (mimeType.Contains("image/"))
return ".img";
if (mimeType.Contains("text/"))
return ".txt";
if (mimeType.Contains("audio/"))
return ".audio";
if (mimeType.Contains("video/"))
return ".video";
if (mimeType.StartsWith("file/") || mimeType.StartsWith("@file/"))
{
var extension = mimeType[(mimeType.IndexOf('/') + 1)..];
if (!string.IsNullOrWhiteSpace(extension))
return "." + extension;
}
return ".bin";
}
}

18
src/modules/Elsa.IO/Extensions/FilePathExtensions.cs
View file

@ -1,18 +0,0 @@
namespace Elsa.IO.Extensions;
public static class FilePathExtensions
{
public static string CleanFilePath(this string filePath)
{
// Clean up the path - trim quotes and whitespace that might come from copy-paste
filePath = filePath.Trim().Trim('"', '\'');
// Replace backslashes with forward slashes on Unix/Mac systems
if (Path.DirectorySeparatorChar == '/')
{
filePath = filePath.Replace('\\', '/');
}
return filePath;
}
}

19
src/modules/Elsa.IO/Extensions/ModuleExtensions.cs
View file

@ -1,19 +0,0 @@
using Elsa.Extensions;
using Elsa.Features.Services;
using Elsa.IO.Features;
namespace Elsa.IO.Extensions;
/// <summary>
/// Provides extension methods for configuring IO services.
/// </summary>
public static class ModuleExtensions
{
/// <summary>
/// Installs the IO module.
/// </summary>
public static IModule UseIO(this IModule module, Action<IOFeature>? configure = null)
{
return module.Use(configure);
}
}

26
src/modules/Elsa.IO/Features/IOFeature.cs
View file

@ -1,26 +0,0 @@
using Elsa.Features.Abstractions;
using Elsa.Features.Services;
using Elsa.IO.Contracts;
using Elsa.IO.Services;
using Elsa.IO.Services.Strategies;
using Microsoft.Extensions.DependencyInjection;
namespace Elsa.IO.Features;
/// <summary>
/// A feature that installs IO services for resolving various content types to streams.
/// </summary>
public class IOFeature(IModule module) : FeatureBase(module)
{
/// <inheritdoc />
public override void Apply()
{
Services.AddScoped<IContentResolverStrategy, StreamContentStrategy>();
Services.AddScoped<IContentResolverStrategy, ByteArrayContentStrategy>();
Services.AddScoped<IContentResolverStrategy, Base64ContentStrategy>();
Services.AddScoped<IContentResolverStrategy, FilePathContentStrategy>();
Services.AddScoped<IContentResolverStrategy, TextContentStrategy>();
Services.AddScoped<IContentResolver, ContentResolver>();
}
}

1
src/modules/Elsa.IO/FodyWeavers.xml
View file

@ -1 +0,0 @@
<Weavers xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="FodyWeavers.xsd" />

33
src/modules/Elsa.IO/Models/BinaryContent.cs
View file

@ -1,33 +0,0 @@
using System.Collections.Generic;
using System.IO;
using Elsa.IO.Extensions;
namespace Elsa.IO.Models;
/// <summary>
/// Represents normalized binary content with metadata.
/// </summary>
public class BinaryContent
{
/// <summary>
/// Gets or sets the name of the content.
/// </summary>
public string? Name { get; set; }
/// <summary>
/// Gets the content type (MIME type) based on file extension.
/// </summary>
public string? ContentType => !string.IsNullOrWhiteSpace(Name)
? Path.GetExtension(Name).GetContentTypeFromExtension()
: null;
/// <summary>
/// Gets or sets optional metadata headers.
/// </summary>
public IDictionary<string, object> Headers { get; set; } = new Dictionary<string, object>();
/// <summary>
/// Gets or sets the content stream.
/// </summary>
public Stream Stream { get; init; } = null!;
}

34
src/modules/Elsa.IO/Services/ContentResolver.cs
View file

@ -1,34 +0,0 @@
using Elsa.IO.Contracts;
using Elsa.IO.Models;
using Elsa.IO.Services.Strategies;
namespace Elsa.IO.Services;
/// <summary>
/// Resolves various content types to BinaryContent using a strategy pattern.
/// </summary>
public class ContentResolver : IContentResolver
{
private readonly IEnumerable<IContentResolverStrategy> _strategies;
/// <summary>
/// Initializes a new instance of the <see cref="ContentResolver"/> class.
/// </summary>
public ContentResolver(IEnumerable<IContentResolverStrategy> strategies)
{
_strategies = strategies.OrderBy(s => s.Priority).ToList();
}
/// <inheritdoc />
public async Task<BinaryContent> ResolveAsync(object content, CancellationToken cancellationToken = default)
{
var strategy = _strategies.FirstOrDefault(s => s.CanResolve(content));
if (strategy == null)
{
throw new ArgumentException($"Unsupported content type: {content.GetType().Name}");
}
return await strategy.ResolveAsync(content, cancellationToken);
}
}

62
src/modules/Elsa.IO/Services/Strategies/Base64ContentStrategy.cs
View file

@ -1,62 +0,0 @@
using Elsa.IO.Common;
using Elsa.IO.Extensions;
using Elsa.IO.Models;
namespace Elsa.IO.Services.Strategies;
/// <summary>
/// Strategy for handling base64 encoded content.
/// </summary>
public class Base64ContentStrategy : IContentResolverStrategy
{
/// <inheritdoc />
public float Priority => Constants.StrategyPriorities.Base64;
/// <inheritdoc />
public bool CanResolve(object content)
{
return content is string str && IsBase64String(str);
}
/// <inheritdoc />
public Task<BinaryContent> ResolveAsync(object content, CancellationToken cancellationToken = default)
{
var str = content.ToString()!;
var extension = ".bin";
string? name = null;
if (IsUriDataBase64String(str))
{
var dataUrlParts = str.Split(';');
if (dataUrlParts.Length > 0 && dataUrlParts[0].StartsWith("data:"))
{
var contentType = dataUrlParts[0][5..];
extension = contentType.GetExtensionFromContentType();
name = "data" + extension;
}
str = str[(str.IndexOf("base64,", StringComparison.Ordinal) + 7)..];
}
var base64Bytes = Convert.FromBase64String(str);
var stream = new MemoryStream(base64Bytes);
return Task.FromResult(new BinaryContent
{
Name = name?.GetNameAndExtension(extension) ?? "data.bin",
Stream = stream,
});
}
private static bool IsBase64String(string base64)
{
return IsUriDataBase64String(base64)
|| base64.IsBase64String();
}
private static bool IsUriDataBase64String(string base64)
{
return base64.StartsWith("data:") && base64.Contains("base64");
}
}

31
src/modules/Elsa.IO/Services/Strategies/ByteArrayContentStrategy.cs
View file

@ -1,31 +0,0 @@
using Elsa.IO.Common;
using Elsa.IO.Models;
namespace Elsa.IO.Services.Strategies;
/// <summary>
/// Strategy for handling byte array content.
/// </summary>
public class ByteArrayContentStrategy : IContentResolverStrategy
{
/// <inheritdoc />
public float Priority => Constants.StrategyPriorities.ByteArray;
/// <inheritdoc />
public bool CanResolve(object content) => content is byte[];
/// <inheritdoc />
public Task<BinaryContent> ResolveAsync(object content, CancellationToken cancellationToken = default)
{
var bytes = (byte[])content;
var stream = new MemoryStream(bytes);
var result = new BinaryContent
{
Stream = stream,
Name = "data.bin",
};
return Task.FromResult(result);
}
}

89
src/modules/Elsa.IO/Services/Strategies/FilePathContentStrategy.cs
View file

@ -1,89 +0,0 @@
using Elsa.IO.Common;
using Elsa.IO.Extensions;
using Elsa.IO.Models;
namespace Elsa.IO.Services.Strategies;
/// <summary>
/// Strategy for handling file path content by reading from the filesystem.
/// </summary>
public class FilePathContentStrategy : IContentResolverStrategy
{
/// <inheritdoc />
public float Priority => Constants.StrategyPriorities.FilePath;
/// <inheritdoc />
public bool CanResolve(object content)
{
if (content is not string filePath)
{
return false;
}
filePath = filePath.CleanFilePath();
try
{
if (Path.IsPathRooted(filePath) && File.Exists(filePath))
{
return true;
}
var normalized = Path.GetFullPath(filePath);
if (File.Exists(normalized))
{
return true;
}
var combined = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), filePath));
return File.Exists(combined);
}
catch (Exception)
{
return false;
}
}
/// <inheritdoc />
public Task<BinaryContent> ResolveAsync(object content, CancellationToken cancellationToken = default)
{
try
{
var filePath = (string)content;
filePath = ResolveActualPath(filePath);
var fileName = Path.GetFileName(filePath);
var fileStream = File.OpenRead(filePath);
var result = new BinaryContent
{
Name = fileName.GetNameAndExtension(),
Stream = fileStream
};
return Task.FromResult(result);
}
catch (Exception ex) when (ex is not FileNotFoundException)
{
throw new FileNotFoundException($"Error opening file: {content}", content.ToString(), ex);
}
}
private string ResolveActualPath(string filePath)
{
filePath = filePath.CleanFilePath();
if (Path.IsPathRooted(filePath) && File.Exists(filePath))
return filePath;
var normalized = Path.GetFullPath(filePath);
if (File.Exists(normalized))
return normalized;
var combined = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), filePath));
if (File.Exists(combined))
return combined;
throw new FileNotFoundException($"Could not find file at path: {filePath}", filePath);
}
}

29
src/modules/Elsa.IO/Services/Strategies/IContentResolverStrategy.cs
View file

@ -1,29 +0,0 @@
namespace Elsa.IO.Services.Strategies;
using Elsa.IO.Models;
/// <summary>
/// Defines a strategy for resolving specific content types to BinaryContent.
/// </summary>
public interface IContentResolverStrategy
{
/// <summary>
/// The priority of the strategy.
/// </summary>
float Priority { get; }
/// <summary>
/// Determines if this strategy can handle the specified content.
/// </summary>
/// <param name="content">The content to check.</param>
/// <returns>True if this strategy can handle the content, false otherwise.</returns>
bool CanResolve(object content);
/// <summary>
/// Resolves the content to a BinaryContent object that includes the content stream and metadata.
/// </summary>
/// <param name="content">The content to resolve.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>A BinaryContent object containing the content stream and associated metadata.</returns>
Task<BinaryContent> ResolveAsync(object content, CancellationToken cancellationToken = default);
}

37
src/modules/Elsa.IO/Services/Strategies/StreamContentStrategy.cs
View file

@ -1,37 +0,0 @@
using Elsa.IO.Common;
using Elsa.IO.Extensions;
using Elsa.IO.Models;
namespace Elsa.IO.Services.Strategies;
/// <summary>
/// Strategy for handling Stream content.
/// </summary>
public class StreamContentStrategy : IContentResolverStrategy
{
/// <inheritdoc />
public float Priority => Constants.StrategyPriorities.Stream;
/// <inheritdoc />
public bool CanResolve(object content) => content is Stream;
/// <inheritdoc />
public Task<BinaryContent> ResolveAsync(object content, CancellationToken cancellationToken = default)
{
var stream = (Stream)content;
string? name = null;
if (stream is FileStream fileStream)
{
name = Path.GetFileName(fileStream.Name);
}
var result = new BinaryContent
{
Stream = stream,
Name = name?.GetNameAndExtension() ?? "data.bin",
};
return Task.FromResult(result);
}
}

31
src/modules/Elsa.IO/Services/Strategies/TextContentStrategy.cs
View file

@ -1,31 +0,0 @@
using System.Text;
using Elsa.IO.Common;
using Elsa.IO.Models;
namespace Elsa.IO.Services.Strategies;
/// <summary>
/// Strategy for handling plain text content by encoding as UTF-8.
/// </summary>
public class TextContentStrategy : IContentResolverStrategy
{
/// <inheritdoc />
public float Priority => Constants.StrategyPriorities.Text;
/// <inheritdoc />
public bool CanResolve(object content) => content is string;
/// <inheritdoc />
public Task<BinaryContent> ResolveAsync(object content, CancellationToken cancellationToken = default)
{
var textContent = (string)content;
var textBytes = Encoding.UTF8.GetBytes(textContent);
var stream = new MemoryStream(textBytes);
return Task.FromResult(new BinaryContent
{
Name = "text.txt",
Stream = stream
});
}
}

43
src/modules/Elsa.MongoDb/HostedServices/ConfigureMongoDbSerializers.cs
View file

@ -1,43 +0,0 @@
using System.Text.Json;
using System.Text.Json.Nodes;
using Elsa.MongoDb.Serializers;
using Elsa.Workflows;
using Elsa.Workflows.Activities.Flowchart.Models;
using Elsa.Workflows.Memory;
using JetBrains.Annotations;
using Microsoft.Extensions.Hosting;
using MongoDB.Bson.Serialization.Serializers;
using static MongoDB.Bson.Serialization.BsonSerializer;
namespace Elsa.MongoDb.HostedServices;
/// <summary>
/// A hosted service that configures and registers custom MongoDB serializers for various types.
/// </summary>
/// <remarks>
/// This class implements <see cref="IHostedService"/> and is responsible for registering serializers to handle
/// specific types such as <see cref="object"/>, <see cref="Type"/>, <see cref="Variable"/>, <see cref="Version"/>,
/// <see cref="JsonElement"/>, <see cref="JsonNode"/>, and <see cref="FlowScope"/>.
/// It uses helper methods to register these serializers during the application's startup process.
/// </remarks>
[UsedImplicitly]
public class ConfigureMongoDbSerializers(IPayloadSerializer payloadSerializer) : IHostedService
{
public Task StartAsync(CancellationToken cancellationToken)
{
TryRegisterSerializer(typeof(object), new PolymorphicSerializer());
TryRegisterSerializer(typeof(Type), new TypeSerializer());
TryRegisterSerializer(typeof(Variable), new VariableSerializer());
TryRegisterSerializer(typeof(Version), new VersionSerializer());
TryRegisterSerializer(typeof(JsonElement), new JsonElementSerializer());
TryRegisterSerializer(typeof(JsonNode), new JsonNodeBsonConverter());
TryRegisterSerializer(typeof(FlowScope), new FlowScopeSerializer(payloadSerializer));
return Task.CompletedTask;
}
public Task StopAsync(CancellationToken cancellationToken)
{
return Task.CompletedTask;
}
}

52
src/modules/Elsa.MongoDb/Serializers/FlowScopeSerializer.cs
View file

@ -1,52 +0,0 @@
using Elsa.Workflows;
using Elsa.Workflows.Activities.Flowchart.Models;
using MongoDB.Bson;
using MongoDB.Bson.Serialization;
namespace Elsa.MongoDb.Serializers;
/// <summary>
/// Serializes a <see cref="FlowScope"/>.
/// </summary>
public class FlowScopeSerializer(IPayloadSerializer payloadSerializer) : IBsonSerializer<FlowScope?>
{
/// <inheritdoc />
public Type ValueType => typeof(FlowScope);
void IBsonSerializer.Serialize(BsonSerializationContext context, BsonSerializationArgs args, object value) => Serialize(context, args, (FlowScope)value);
object IBsonSerializer.Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) => Deserialize(context, args);
/// <inheritdoc />
public void Serialize(BsonSerializationContext context, BsonSerializationArgs args, FlowScope? value)
{
if (value is null)
context.Writer.WriteNull();
else
{
var json = payloadSerializer.Serialize(value);
context.Writer.WriteString(json);
}
}
/// <inheritdoc />
public FlowScope Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var reader = context.Reader;
var bsonType = reader.GetCurrentBsonType();
if (bsonType == BsonType.Null)
{
reader.ReadNull();
return new();
}
if(bsonType == BsonType.String)
{
var json = context.Reader.ReadString();
return string.IsNullOrEmpty(json) ? new() : payloadSerializer.Deserialize<FlowScope>(json);
}
return new();
}
}

15
src/modules/Elsa.Workflows.Runtime.ProtoActor/Extensions/ProtoOutputExtensions.cs
View file

@ -1,15 +0,0 @@
using Elsa.Workflows.Runtime.ProtoActor.ProtoBuf;
namespace Elsa.Workflows.Runtime.ProtoActor.Extensions;
internal static class ProtoOutputExtensions
{
public static IDictionary<string, object> DeserializeOutput(this Output output) => output.Data.Deserialize();
public static Output SerializeOutput(this IDictionary<string, object> output)
{
var result = new Output();
output.Serialize(result.Data);
return result;
}
}