From 0e9cd54c2ec4bd7451230657bbcafe57c9a519a9 Mon Sep 17 00:00:00 2001 From: James Doran Date: Mon, 17 Feb 2020 18:06:40 +1030 Subject: [PATCH 01/17] Fixed stackoverflow when finding ancestors (#247) --- .../Services/Extensions/WorkflowExtensions.cs | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/src/core/Elsa.Abstractions/Services/Extensions/WorkflowExtensions.cs b/src/core/Elsa.Abstractions/Services/Extensions/WorkflowExtensions.cs index 1db659d43..0eb90043d 100644 --- a/src/core/Elsa.Abstractions/Services/Extensions/WorkflowExtensions.cs +++ b/src/core/Elsa.Abstractions/Services/Extensions/WorkflowExtensions.cs @@ -58,24 +58,31 @@ namespace Elsa.Services.Extensions /// public static IEnumerable GetInboundActivityPath(this Workflow workflow, string activityId) { - return workflow.GetInboundActivityPathInternal(activityId, activityId).Distinct().ToList(); + var inspectedActivityIDs = new HashSet(); + + return workflow.GetInboundActivityPathInternal(activityId, activityId, inspectedActivityIDs) + .Distinct().ToList(); } private static IEnumerable GetInboundActivityPathInternal(this Workflow workflowInstance, - string activityId, string startingPointActivityId) + string activityId, + string startingPointActivityId, + HashSet inspectedActivityIDs) { foreach (var connection in workflowInstance.GetInboundConnections(activityId)) { // Circuit breaker: Detect workflows that implement repeating flows to prevent an infinite loop here. - if (connection.Source.Activity.Id == startingPointActivityId) + if (inspectedActivityIDs.Contains(connection.Source.Activity.Id)) yield break; yield return connection.Source.Activity.Id; - foreach (var parentActivityId in workflowInstance - .GetInboundActivityPathInternal(connection.Source.Activity.Id, startingPointActivityId) - .Distinct()) + foreach (var parentActivityId in workflowInstance.GetInboundActivityPathInternal(connection.Source.Activity.Id, startingPointActivityId, inspectedActivityIDs) + .Distinct()) + { + inspectedActivityIDs.Add(parentActivityId); yield return parentActivityId; + } } } } From a9a4f78459d3ca66f828ab95f6d2d81b2397bf05 Mon Sep 17 00:00:00 2001 From: Yuhang Ji Date: Thu, 20 Feb 2020 17:30:30 +0800 Subject: [PATCH 02/17] Resolve https://github.com/elsa-workflows/elsa-core/issues/250 (#251) --- src/core/Elsa.Core/Expressions/LiteralEvaluator.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/core/Elsa.Core/Expressions/LiteralEvaluator.cs b/src/core/Elsa.Core/Expressions/LiteralEvaluator.cs index 0902d5fff..68c94a7a0 100644 --- a/src/core/Elsa.Core/Expressions/LiteralEvaluator.cs +++ b/src/core/Elsa.Core/Expressions/LiteralEvaluator.cs @@ -19,7 +19,7 @@ namespace Elsa.Expressions public Task EvaluateAsync(string expression, Type type, WorkflowExecutionContext workflowExecutionContext, CancellationToken cancellationToken) { - if (string.IsNullOrWhiteSpace(expression)) + if (string.IsNullOrEmpty(expression)) return Task.FromResult(default(object)); return Task.FromResult(expression.Parse(type)); From 8ec43230a795b0d249b9779a67b4b59ae1b7b79d Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Thu, 20 Feb 2020 21:24:27 +0100 Subject: [PATCH 03/17] Improve JS value converter to support object target type --- .../Services/JavaScriptExpressionEvaluator.cs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/scripting/Elsa.Scripting.JavaScript/Services/JavaScriptExpressionEvaluator.cs b/src/scripting/Elsa.Scripting.JavaScript/Services/JavaScriptExpressionEvaluator.cs index 85482b5d0..b1faa5fac 100644 --- a/src/scripting/Elsa.Scripting.JavaScript/Services/JavaScriptExpressionEvaluator.cs +++ b/src/scripting/Elsa.Scripting.JavaScript/Services/JavaScriptExpressionEvaluator.cs @@ -76,13 +76,15 @@ namespace Elsa.Scripting.JavaScript.Services if (value.IsNull()) return default; - if (targetType == typeof(bool) && value.IsBoolean()) + var targetIsObject = targetType == typeof(object); + + if (value.IsBoolean()) return value.AsBoolean(); - if (targetType == typeof(DateTime) && value.IsDate()) + if ((targetIsObject || targetType == typeof(DateTime)) && value.IsDate()) return value.AsDate().ToDateTime(); - if (targetType.IsNumeric() && value.IsNumber()) + if ((targetIsObject || targetType.IsNumeric()) && value.IsNumber()) return Convert.ChangeType(value.AsNumber(), targetType); if (targetType == typeof(string)) From 707eed6f6ff356f4ea959e04287760d72bfb3f24 Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Mon, 16 Mar 2020 14:40:00 +0100 Subject: [PATCH 04/17] Update designer package reference to latest v1 --- .../Theme/argon-dashboard/package-lock.json | 24 +++++++++---------- .../Theme/argon-dashboard/package.json | 2 +- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/src/dashboard/Elsa.Dashboard/Theme/argon-dashboard/package-lock.json b/src/dashboard/Elsa.Dashboard/Theme/argon-dashboard/package-lock.json index 6e412cd78..f458b5b65 100644 --- a/src/dashboard/Elsa.Dashboard/Theme/argon-dashboard/package-lock.json +++ b/src/dashboard/Elsa.Dashboard/Theme/argon-dashboard/package-lock.json @@ -2824,9 +2824,9 @@ } }, "handlebars": { - "version": "4.7.2", - "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.2.tgz", - "integrity": "sha512-4PwqDL2laXtTWZghzzCtunQUTLbo31pcCJrd/B/9JP8XbhVzpS5ZXuKqlOzsd1rtcaLo4KqAn8nl8mkknS4MHw==", + "version": "4.7.3", + "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.3.tgz", + "integrity": "sha512-SRGwSYuNfx8DwHD/6InAPzD6RgeruWLT+B8e8a7gGs8FWgHzlExpTFMEq2IA6QpAfOClpKHy6+8IqTjeBCu6Kg==", "requires": { "neo-async": "^2.6.0", "optimist": "^0.6.1", @@ -3284,9 +3284,9 @@ "dev": true }, "jsplumb": { - "version": "2.12.8", - "resolved": "https://registry.npmjs.org/jsplumb/-/jsplumb-2.12.8.tgz", - "integrity": "sha512-yYtyDMIPb1eJpv1HLxhD4wVQ0zlOtsvhaH2xcryL1kwKkiCevepK9UKVPUPQ0aZZzzHn7xYWQoZIdZHkSvD1Og==" + "version": "2.12.14", + "resolved": "https://registry.npmjs.org/jsplumb/-/jsplumb-2.12.14.tgz", + "integrity": "sha512-h5AhvDVD2EeIPTheAHnj7hWxUxCw9OooMTl76EhbkUHktjZiqTGVA7Wvl3/deGZaKRymhaG3W5UlSVHENRW7Og==" }, "jsprim": { "version": "1.4.1", @@ -4369,9 +4369,9 @@ } }, "popper.js": { - "version": "1.16.0", - "resolved": "https://registry.npmjs.org/popper.js/-/popper.js-1.16.0.tgz", - "integrity": "sha512-+G+EkOPoE5S/zChTpmBSSDYmhXJ5PsW8eMhH8cP/CQHMFPBG/kC9Y5IIw6qNYgdJ+/COf0ddY2li28iHaZRSjw==" + "version": "1.16.1", + "resolved": "https://registry.npmjs.org/popper.js/-/popper.js-1.16.1.tgz", + "integrity": "sha512-Wb4p1J4zyFTbM+u6WuO4XstYx4Ky9Cewe4DWrel7B0w6VVICvPwdOpotjzcf6eD8TsckVnIMNONQyPIUFOUbCQ==" }, "posix-character-classes": { "version": "0.1.1", @@ -5423,9 +5423,9 @@ "dev": true }, "uglify-js": { - "version": "3.7.5", - "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.7.5.tgz", - "integrity": "sha512-GFZ3EXRptKGvb/C1Sq6nO1iI7AGcjyqmIyOw0DrD0675e+NNbGO72xmMM2iEBdFbxaTLo70NbjM/Wy54uZIlsg==", + "version": "3.8.0", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.8.0.tgz", + "integrity": "sha512-ugNSTT8ierCsDHso2jkBHXYrU8Y5/fY2ZUprfrJUiD7YpuFvV4jODLFmb3h4btQjqr5Nh4TX4XtgDfCU1WdioQ==", "optional": true, "requires": { "commander": "~2.20.3", diff --git a/src/dashboard/Elsa.Dashboard/Theme/argon-dashboard/package.json b/src/dashboard/Elsa.Dashboard/Theme/argon-dashboard/package.json index 3f19230c6..431f0fd25 100644 --- a/src/dashboard/Elsa.Dashboard/Theme/argon-dashboard/package.json +++ b/src/dashboard/Elsa.Dashboard/Theme/argon-dashboard/package.json @@ -37,7 +37,7 @@ "url": "https://github.com/creativetimofficial/argon-dashboard/issues" }, "dependencies": { - "@elsa-workflows/elsa-workflow-designer": "latest" + "@elsa-workflows/elsa-workflow-designer": "0.0.61" }, "devDependencies": { "gulp": "^4.0.2", From 5bf994c485b040f1c62f292828bfd94db060a2a1 Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Fri, 27 Mar 2020 21:11:05 +0100 Subject: [PATCH 05/17] Fix duplicate automapper profiles (#270) --- .../Elsa.AutoMapper.Extensions/ServiceCollectionExtensions.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/utils/Elsa.AutoMapper.Extensions/ServiceCollectionExtensions.cs b/src/utils/Elsa.AutoMapper.Extensions/ServiceCollectionExtensions.cs index f3f04e257..86d3a04d6 100644 --- a/src/utils/Elsa.AutoMapper.Extensions/ServiceCollectionExtensions.cs +++ b/src/utils/Elsa.AutoMapper.Extensions/ServiceCollectionExtensions.cs @@ -18,7 +18,8 @@ namespace Elsa.AutoMapper.Extensions public static IServiceCollection AddAutoMapperProfile(this IServiceCollection services, ServiceLifetime lifetime) where TProfile : Profile { services.AddAutoMapper(lifetime); - return services.AddTransient(); + services.TryAddTransient(typeof(Profile), typeof(TProfile)); + return services; } private static IConfigurationProvider CreateConfigurationProvider(IServiceProvider serviceProvider) From 2da16019f513f10950595691216cea0e1dae6a0d Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Sat, 28 Mar 2020 22:01:35 +0100 Subject: [PATCH 06/17] Update README with .NET Foundation's Code of Conduct --- README.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 9850b12cb..892385f93 100644 --- a/README.md +++ b/README.md @@ -190,4 +190,8 @@ In order to build & run Elsa on your local machine, follow these steps: 2. Run NPM install on all folders containing packages.json (or run `node npm-install.js` - a script in the root that recursively installs the Node packages) 3. Execute gulp build from the directory src\dashboard\Elsa.Dashboard\Theme\argon-dashboard 4. Open a shell and navigate to `src/samples/Sample16` and run `dotnet run`. -5. Navigate to https://localhost:8632/elsa/home \ No newline at end of file +5. Navigate to https://localhost:8632/elsa/home + +# Code of Conduct + +https://dotnetfoundation.org/code-of-conduct From df54e1527e04c28f3b26c147e31159a3431f94ab Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Sat, 28 Mar 2020 22:38:52 +0100 Subject: [PATCH 07/17] Add .gitattributes --- .gitattributes | 10 ++++++++++ .gitignore | 1 - 2 files changed, 10 insertions(+), 1 deletion(-) create mode 100644 .gitattributes diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 000000000..8746ffbcc --- /dev/null +++ b/.gitattributes @@ -0,0 +1,10 @@ +# Auto detect text files and perform LF normalization +* text=auto + +# Custom for Visual Studio +*.cs diff=csharp +*.sln merge=union +*.csproj merge=union +*.vbproj merge=union +*.fsproj merge=union +*.dbproj merge=union \ No newline at end of file diff --git a/.gitignore b/.gitignore index 490152dc5..979e19bba 100644 --- a/.gitignore +++ b/.gitignore @@ -34,7 +34,6 @@ packages/ #Ignore git-related files *.orig -.gitattributes #Rider .idea From 0a5a88d546a8e68335fc20973b2ef564c86662d2 Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Sat, 28 Mar 2020 22:55:09 +0100 Subject: [PATCH 08/17] Add CONTRIBUTING.md --- CONTRIBUTING.md | 45 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 CONTRIBUTING.md diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 000000000..7f97ba10b --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,45 @@ +# Contributing to Elsa Workflows +We love your input! We want to make contributing to this project as easy and transparent as possible, whether it's: + +- Reporting a bug +- Discussing the current state of the code +- Submitting a fix +- Proposing new features +- Becoming a maintainer + +## We develop with Github +We use github to host code, to track issues and feature requests, as well as to accept pull requests. + +## We use [Github Flow](https://guides.github.com/introduction/flow/index.html), So all code changes happen through pull requests +Pull requests are the best way to propose changes to the codebase (we use [Github Flow](https://guides.github.com/introduction/flow/index.html)). We actively welcome your pull requests: + +1. Fork the repo and create your branch from `develop`. +1. Issue that pull request! + +## Any contributions you make will be under the New BSD License +In short, when you submit code changes, your submissions are understood to be under the same [New BSD License](https://github.com/elsa-workflows/elsa-core/blob/master/LICENSE) that covers the project. Feel free to contact the maintainers if that's a concern. + +## Report bugs using Github's [issues](https://github.com/elsa-workflows/elsa-core/issues) +We use GitHub issues to track public bugs. Report a bug by [opening a new issue](https://github.com/elsa-workflows/elsa-core/issues/new); it's that easy! + +## Write bug reports with detail, background, and sample code +**Great Bug Reports** tend to have: + +- A quick summary and/or background +- Steps to reproduce + - Be specific! + - Give sample code if you can. +- What you expected would happen +- What actually happens +- Notes (possibly including why you think this might be happening, or stuff you tried that didn't work) + +People *love* thorough bug reports. I'm not even kidding. + +## Use a Consistent Coding Style +As a default, I am applying [Microsoft's Coding Conventions for .NET](https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference). + +## License +By contributing, you agree that your contributions will be licensed under its [New BSD License](https://github.com/elsa-workflows/elsa-core/blob/master/LICENSE). + +## References +This document was adapted from the following [Gist](https://gist.github.com/briandk/3d2e8b3ec8daf5a27a62) From db2729ffd11a3f43bdc0a3da969a624bc83c0f29 Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Sat, 28 Mar 2020 22:57:35 +0100 Subject: [PATCH 09/17] Update README.md --- README.md | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 892385f93..5172edf2a 100644 --- a/README.md +++ b/README.md @@ -194,4 +194,9 @@ In order to build & run Elsa on your local machine, follow these steps: # Code of Conduct -https://dotnetfoundation.org/code-of-conduct +This project has adopted the code of conduct defined by the Contributor Covenant to clarify expected behavior in our community. +For more information see the [.NET Foundation Code of Conduct](https://dotnetfoundation.org/code-of-conduct). + +### .NET Foundation + +This project is supported by the [.NET Foundation](https://dotnetfoundation.org). From d177dd2ada948b8a720029478655b5671f571fa9 Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Thu, 2 Apr 2020 20:06:28 +0200 Subject: [PATCH 10/17] Update LICENSE --- LICENSE | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LICENSE b/LICENSE index b92caa035..3f9e5379f 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ BSD 3-Clause License -Copyright (c) 2019, Sipke Schoorstra +Copyright (c) 2020, .NET Foundation All rights reserved. Redistribution and use in source and binary forms, with or without From 313787a01f1a26eb62799b56696c3ebc881394ec Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Thu, 2 Apr 2020 22:09:24 +0200 Subject: [PATCH 11/17] Fix missing mapping issues --- .../Models/WorkflowInstance.cs | 1 - .../Entities/ActivityDefinitionEntity.cs | 3 + .../Mapping/EntitiesProfile.cs | 21 +- .../MySql/20200402200706_Update01.Designer.cs | 267 +++++++++++++++++ .../MySql/20200402200706_Update01.cs | 40 +++ .../MySql/MySqlContextModelSnapshot.cs | 11 +- .../20200402200555_Update01.Designer.cs | 270 +++++++++++++++++ .../PostgreSql/20200402200555_Update01.cs | 40 +++ .../PostgreSqlContextModelSnapshot.cs | 11 +- .../20200402200549_Update01.Designer.cs | 275 ++++++++++++++++++ .../SqlServer/20200402200549_Update01.cs | 40 +++ .../SqlServerContextModelSnapshot.cs | 11 +- .../20200402200519_Update01.Designer.cs | 266 +++++++++++++++++ .../Sqlite/20200402200519_Update01.cs | 40 +++ .../Sqlite/SqliteContextModelSnapshot.cs | 24 +- .../README.md | 8 +- 16 files changed, 1309 insertions(+), 19 deletions(-) create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.Designer.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.Designer.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.Designer.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.Designer.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.cs diff --git a/src/core/Elsa.Abstractions/Models/WorkflowInstance.cs b/src/core/Elsa.Abstractions/Models/WorkflowInstance.cs index 6d7bafc37..601ceecd6 100644 --- a/src/core/Elsa.Abstractions/Models/WorkflowInstance.cs +++ b/src/core/Elsa.Abstractions/Models/WorkflowInstance.cs @@ -19,7 +19,6 @@ namespace Elsa.Models public Stack Scopes { get; set; } public Variables Input { get; set; } public HashSet BlockingActivities { get; set; } - public string[] TestItems { get; set; } = new string[0]; public ICollection ExecutionLog { get; set; } public WorkflowFault Fault { get; set; } } diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Entities/ActivityDefinitionEntity.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Entities/ActivityDefinitionEntity.cs index 17c068adb..8eaaadc7e 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Entities/ActivityDefinitionEntity.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Entities/ActivityDefinitionEntity.cs @@ -8,6 +8,9 @@ namespace Elsa.Persistence.EntityFrameworkCore.Entities public string ActivityId { get; set; } public WorkflowDefinitionVersionEntity WorkflowDefinitionVersion { get; set; } public string Type { get; set; } + public string Name { get; set; } + public string DisplayName { get; set; } + public string Description { get; set; } public int Left { get; set; } public int Top { get; set; } public JObject State { get; set; } diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Mapping/EntitiesProfile.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Mapping/EntitiesProfile.cs index bff66f83c..7b409b48c 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Mapping/EntitiesProfile.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Mapping/EntitiesProfile.cs @@ -29,19 +29,28 @@ namespace Elsa.Persistence.EntityFrameworkCore.Mapping CreateMap() .ForMember(d => d.Id, d => d.Ignore()) - .ForMember(d => d.ActivityId, d => d.MapFrom(s => s.Id)); - + .ForMember(d => d.ActivityId, d => d.MapFrom(s => s.Id)) + .ForMember(d => d.WorkflowDefinitionVersion, d => d.Ignore()); + CreateMap() .ForCtorParam("id", p => p.MapFrom(s => s.ActivityId)) .ForMember(d => d.Id, d => d.MapFrom(s => s.ActivityId)); - + CreateMap() .ForMember(d => d.Id, d => d.Ignore()) - .ForMember(d => d.ActivityId, d => d.MapFrom(s => s.Id)); + .ForMember(d => d.ActivityId, d => d.MapFrom(s => s.Id)) + .ForMember(d => d.WorkflowInstance, d => d.Ignore()); CreateMap().ForMember(d => d.Id, d => d.MapFrom(s => s.ActivityId)); - CreateMap().ReverseMap(); - CreateMap().ReverseMap(); + CreateMap() + .ForMember(d => d.Id, d => d.Ignore()) + .ForMember(d => d.WorkflowInstance, d => d.Ignore()) + .ReverseMap(); + + CreateMap() + .ForMember(d => d.Id, d => d.Ignore()) + .ForMember(d => d.WorkflowDefinitionVersion, d => d.Ignore()) + .ReverseMap(); } } diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.Designer.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.Designer.cs new file mode 100644 index 000000000..48561c5b4 --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.Designer.cs @@ -0,0 +1,267 @@ +// +using System; +using Elsa.Persistence.EntityFrameworkCore.DbContexts; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.MySql +{ + [DbContext(typeof(MySqlContext))] + [Migration("20200402200706_Update01")] + partial class Update01 + { + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "3.1.1") + .HasAnnotation("Relational:MaxIdentifierLength", 64); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Description") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("DisplayName") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Left") + .HasColumnType("int"); + + b.Property("Name") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("State") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Top") + .HasColumnType("int"); + + b.Property("Type") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ActivityDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Output") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("State") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Type") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("WorkflowInstanceId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("ActivityInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int"); + + b.Property("ActivityId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("ActivityType") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("WorkflowInstanceId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("BlockingActivities"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int"); + + b.Property("DestinationActivityId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Outcome") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("SourceActivityId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ConnectionDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("DefinitionId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Description") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("IsDisabled") + .HasColumnType("tinyint(1)"); + + b.Property("IsLatest") + .HasColumnType("tinyint(1)"); + + b.Property("IsPublished") + .HasColumnType("tinyint(1)"); + + b.Property("IsSingleton") + .HasColumnType("tinyint(1)"); + + b.Property("Name") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Variables") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Version") + .HasColumnType("int"); + + b.Property("VersionId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.HasKey("Id"); + + b.ToTable("WorkflowDefinitionVersions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("AbortedAt") + .HasColumnType("datetime(6)"); + + b.Property("CorrelationId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("CreatedAt") + .HasColumnType("datetime(6)"); + + b.Property("DefinitionId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("ExecutionLog") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Fault") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("FaultedAt") + .HasColumnType("datetime(6)"); + + b.Property("FinishedAt") + .HasColumnType("datetime(6)"); + + b.Property("Input") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("InstanceId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Scopes") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("StartedAt") + .HasColumnType("datetime(6)"); + + b.Property("Status") + .IsRequired() + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Version") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.ToTable("WorkflowInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Activities") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("Activities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("BlockingActivities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Connections") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.cs new file mode 100644 index 000000000..1dd46202a --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.cs @@ -0,0 +1,40 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.MySql +{ + public partial class Update01 : Migration + { + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.AddColumn( + name: "Description", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "DisplayName", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "Name", + table: "ActivityDefinitions", + nullable: true); + } + + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropColumn( + name: "Description", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "DisplayName", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "Name", + table: "ActivityDefinitions"); + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/MySqlContextModelSnapshot.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/MySqlContextModelSnapshot.cs index 4d4ca1721..2efa8af1f 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/MySqlContextModelSnapshot.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/MySqlContextModelSnapshot.cs @@ -15,7 +15,7 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.MySql { #pragma warning disable 612, 618 modelBuilder - .HasAnnotation("ProductVersion", "3.1.0") + .HasAnnotation("ProductVersion", "3.1.1") .HasAnnotation("Relational:MaxIdentifierLength", 64); modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => @@ -28,9 +28,18 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.MySql b.Property("ActivityId") .HasColumnType("longtext CHARACTER SET utf8mb4"); + b.Property("Description") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("DisplayName") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + b.Property("Left") .HasColumnType("int"); + b.Property("Name") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + b.Property("State") .HasColumnType("longtext CHARACTER SET utf8mb4"); diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.Designer.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.Designer.cs new file mode 100644 index 000000000..911152f8a --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.Designer.cs @@ -0,0 +1,270 @@ +// +using System; +using Elsa.Persistence.EntityFrameworkCore.DbContexts; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.PostgreSql +{ + [DbContext(typeof(PostgreSqlContext))] + [Migration("20200402200555_Update01")] + partial class Update01 + { + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn) + .HasAnnotation("ProductVersion", "3.1.1") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("integer") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("text"); + + b.Property("Description") + .HasColumnType("text"); + + b.Property("DisplayName") + .HasColumnType("text"); + + b.Property("Left") + .HasColumnType("integer"); + + b.Property("Name") + .HasColumnType("text"); + + b.Property("State") + .HasColumnType("text"); + + b.Property("Top") + .HasColumnType("integer"); + + b.Property("Type") + .HasColumnType("text"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ActivityDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("integer") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("text"); + + b.Property("Output") + .HasColumnType("text"); + + b.Property("State") + .HasColumnType("text"); + + b.Property("Type") + .HasColumnType("text"); + + b.Property("WorkflowInstanceId") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("ActivityInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("integer") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("text"); + + b.Property("ActivityType") + .HasColumnType("text"); + + b.Property("WorkflowInstanceId") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("BlockingActivities"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("integer") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("DestinationActivityId") + .HasColumnType("text"); + + b.Property("Outcome") + .HasColumnType("text"); + + b.Property("SourceActivityId") + .HasColumnType("text"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ConnectionDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("integer") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("DefinitionId") + .HasColumnType("text"); + + b.Property("Description") + .HasColumnType("text"); + + b.Property("IsDisabled") + .HasColumnType("boolean"); + + b.Property("IsLatest") + .HasColumnType("boolean"); + + b.Property("IsPublished") + .HasColumnType("boolean"); + + b.Property("IsSingleton") + .HasColumnType("boolean"); + + b.Property("Name") + .HasColumnType("text"); + + b.Property("Variables") + .HasColumnType("text"); + + b.Property("Version") + .HasColumnType("integer"); + + b.Property("VersionId") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("WorkflowDefinitionVersions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("integer") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("AbortedAt") + .HasColumnType("timestamp without time zone"); + + b.Property("CorrelationId") + .HasColumnType("text"); + + b.Property("CreatedAt") + .HasColumnType("timestamp without time zone"); + + b.Property("DefinitionId") + .HasColumnType("text"); + + b.Property("ExecutionLog") + .HasColumnType("text"); + + b.Property("Fault") + .HasColumnType("text"); + + b.Property("FaultedAt") + .HasColumnType("timestamp without time zone"); + + b.Property("FinishedAt") + .HasColumnType("timestamp without time zone"); + + b.Property("Input") + .HasColumnType("text"); + + b.Property("InstanceId") + .HasColumnType("text"); + + b.Property("Scopes") + .HasColumnType("text"); + + b.Property("StartedAt") + .HasColumnType("timestamp without time zone"); + + b.Property("Status") + .IsRequired() + .HasColumnType("text"); + + b.Property("Version") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.ToTable("WorkflowInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Activities") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("Activities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("BlockingActivities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Connections") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.cs new file mode 100644 index 000000000..8c6a85c9d --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.cs @@ -0,0 +1,40 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.PostgreSql +{ + public partial class Update01 : Migration + { + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.AddColumn( + name: "Description", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "DisplayName", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "Name", + table: "ActivityDefinitions", + nullable: true); + } + + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropColumn( + name: "Description", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "DisplayName", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "Name", + table: "ActivityDefinitions"); + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/PostgreSqlContextModelSnapshot.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/PostgreSqlContextModelSnapshot.cs index 640bc9e30..ff7170d31 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/PostgreSqlContextModelSnapshot.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/PostgreSqlContextModelSnapshot.cs @@ -16,7 +16,7 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.PostgreSql #pragma warning disable 612, 618 modelBuilder .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn) - .HasAnnotation("ProductVersion", "3.0.1") + .HasAnnotation("ProductVersion", "3.1.1") .HasAnnotation("Relational:MaxIdentifierLength", 63); modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => @@ -29,9 +29,18 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.PostgreSql b.Property("ActivityId") .HasColumnType("text"); + b.Property("Description") + .HasColumnType("text"); + + b.Property("DisplayName") + .HasColumnType("text"); + b.Property("Left") .HasColumnType("integer"); + b.Property("Name") + .HasColumnType("text"); + b.Property("State") .HasColumnType("text"); diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.Designer.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.Designer.cs new file mode 100644 index 000000000..732fafbb5 --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.Designer.cs @@ -0,0 +1,275 @@ +// +using System; +using Elsa.Persistence.EntityFrameworkCore.DbContexts; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.SqlServer +{ + [DbContext(typeof(SqlServerContext))] + [Migration("20200402200549_Update01")] + partial class Update01 + { + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "3.1.1") + .HasAnnotation("Relational:MaxIdentifierLength", 128) + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn) + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + b.Property("ActivityId") + .HasColumnType("nvarchar(max)"); + + b.Property("Description") + .HasColumnType("nvarchar(max)"); + + b.Property("DisplayName") + .HasColumnType("nvarchar(max)"); + + b.Property("Left") + .HasColumnType("int"); + + b.Property("Name") + .HasColumnType("nvarchar(max)"); + + b.Property("State") + .HasColumnType("nvarchar(max)"); + + b.Property("Top") + .HasColumnType("int"); + + b.Property("Type") + .HasColumnType("nvarchar(max)"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ActivityDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn) + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + b.Property("ActivityId") + .HasColumnType("nvarchar(max)"); + + b.Property("Output") + .HasColumnType("nvarchar(max)"); + + b.Property("State") + .HasColumnType("nvarchar(max)"); + + b.Property("Type") + .HasColumnType("nvarchar(max)"); + + b.Property("WorkflowInstanceId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("ActivityInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + b.Property("ActivityId") + .HasColumnType("nvarchar(max)"); + + b.Property("ActivityType") + .HasColumnType("nvarchar(max)"); + + b.Property("WorkflowInstanceId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("BlockingActivities"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + b.Property("DestinationActivityId") + .HasColumnType("nvarchar(max)"); + + b.Property("Outcome") + .HasColumnType("nvarchar(max)"); + + b.Property("SourceActivityId") + .HasColumnType("nvarchar(max)"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ConnectionDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn) + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + b.Property("DefinitionId") + .HasColumnType("nvarchar(max)"); + + b.Property("Description") + .HasColumnType("nvarchar(max)"); + + b.Property("IsDisabled") + .HasColumnType("bit"); + + b.Property("IsLatest") + .HasColumnType("bit"); + + b.Property("IsPublished") + .HasColumnType("bit"); + + b.Property("IsSingleton") + .HasColumnType("bit"); + + b.Property("Name") + .HasColumnType("nvarchar(max)"); + + b.Property("Variables") + .HasColumnType("nvarchar(max)"); + + b.Property("Version") + .HasColumnType("int"); + + b.Property("VersionId") + .HasColumnType("nvarchar(max)"); + + b.HasKey("Id"); + + b.ToTable("WorkflowDefinitionVersions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn) + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + b.Property("AbortedAt") + .HasColumnType("datetime2"); + + b.Property("CorrelationId") + .HasColumnType("nvarchar(max)"); + + b.Property("CreatedAt") + .HasColumnType("datetime2"); + + b.Property("DefinitionId") + .HasColumnType("nvarchar(max)"); + + b.Property("ExecutionLog") + .HasColumnType("nvarchar(max)"); + + b.Property("Fault") + .HasColumnType("nvarchar(max)"); + + b.Property("FaultedAt") + .HasColumnType("datetime2"); + + b.Property("FinishedAt") + .HasColumnType("datetime2"); + + b.Property("Input") + .HasColumnType("nvarchar(max)"); + + b.Property("InstanceId") + .HasColumnType("nvarchar(max)"); + + b.Property("Scopes") + .HasColumnType("nvarchar(max)"); + + b.Property("StartedAt") + .HasColumnType("datetime2"); + + b.Property("Status") + .IsRequired() + .HasColumnType("nvarchar(max)"); + + b.Property("Version") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.ToTable("WorkflowInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Activities") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("Activities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("BlockingActivities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Connections") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.cs new file mode 100644 index 000000000..13648f962 --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.cs @@ -0,0 +1,40 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.SqlServer +{ + public partial class Update01 : Migration + { + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.AddColumn( + name: "Description", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "DisplayName", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "Name", + table: "ActivityDefinitions", + nullable: true); + } + + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropColumn( + name: "Description", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "DisplayName", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "Name", + table: "ActivityDefinitions"); + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/SqlServerContextModelSnapshot.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/SqlServerContextModelSnapshot.cs index 6bcb53eb2..e77ab1d28 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/SqlServerContextModelSnapshot.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/SqlServerContextModelSnapshot.cs @@ -16,7 +16,7 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.SqlServer { #pragma warning disable 612, 618 modelBuilder - .HasAnnotation("ProductVersion", "3.1.0") + .HasAnnotation("ProductVersion", "3.1.1") .HasAnnotation("Relational:MaxIdentifierLength", 128) .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); @@ -31,9 +31,18 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.SqlServer b.Property("ActivityId") .HasColumnType("nvarchar(max)"); + b.Property("Description") + .HasColumnType("nvarchar(max)"); + + b.Property("DisplayName") + .HasColumnType("nvarchar(max)"); + b.Property("Left") .HasColumnType("int"); + b.Property("Name") + .HasColumnType("nvarchar(max)"); + b.Property("State") .HasColumnType("nvarchar(max)"); diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.Designer.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.Designer.cs new file mode 100644 index 000000000..c6c189920 --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.Designer.cs @@ -0,0 +1,266 @@ +// +using System; +using Elsa.Persistence.EntityFrameworkCore.DbContexts; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite +{ + [DbContext(typeof(SqliteContext))] + [Migration("20200402200519_Update01")] + partial class Update01 + { + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "3.1.1"); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("TEXT"); + + b.Property("Description") + .HasColumnType("TEXT"); + + b.Property("DisplayName") + .HasColumnType("TEXT"); + + b.Property("Left") + .HasColumnType("INTEGER"); + + b.Property("Name") + .HasColumnType("TEXT"); + + b.Property("State") + .HasColumnType("TEXT"); + + b.Property("Top") + .HasColumnType("INTEGER"); + + b.Property("Type") + .HasColumnType("TEXT"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ActivityDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("TEXT"); + + b.Property("Output") + .HasColumnType("TEXT"); + + b.Property("State") + .HasColumnType("TEXT"); + + b.Property("Type") + .HasColumnType("TEXT"); + + b.Property("WorkflowInstanceId") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("ActivityInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("ActivityId") + .HasColumnType("TEXT"); + + b.Property("ActivityType") + .HasColumnType("TEXT"); + + b.Property("WorkflowInstanceId") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("BlockingActivities"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("DestinationActivityId") + .HasColumnType("TEXT"); + + b.Property("Outcome") + .HasColumnType("TEXT"); + + b.Property("SourceActivityId") + .HasColumnType("TEXT"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ConnectionDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("DefinitionId") + .HasColumnType("TEXT"); + + b.Property("Description") + .HasColumnType("TEXT"); + + b.Property("IsDisabled") + .HasColumnType("INTEGER"); + + b.Property("IsLatest") + .HasColumnType("INTEGER"); + + b.Property("IsPublished") + .HasColumnType("INTEGER"); + + b.Property("IsSingleton") + .HasColumnType("INTEGER"); + + b.Property("Name") + .HasColumnType("TEXT"); + + b.Property("Variables") + .HasColumnType("TEXT"); + + b.Property("Version") + .HasColumnType("INTEGER"); + + b.Property("VersionId") + .HasColumnType("TEXT"); + + b.HasKey("Id"); + + b.ToTable("WorkflowDefinitionVersions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("AbortedAt") + .HasColumnType("TEXT"); + + b.Property("CorrelationId") + .HasColumnType("TEXT"); + + b.Property("CreatedAt") + .HasColumnType("TEXT"); + + b.Property("DefinitionId") + .HasColumnType("TEXT"); + + b.Property("ExecutionLog") + .HasColumnType("TEXT"); + + b.Property("Fault") + .HasColumnType("TEXT"); + + b.Property("FaultedAt") + .HasColumnType("TEXT"); + + b.Property("FinishedAt") + .HasColumnType("TEXT"); + + b.Property("Input") + .HasColumnType("TEXT"); + + b.Property("InstanceId") + .HasColumnType("TEXT"); + + b.Property("Scopes") + .HasColumnType("TEXT"); + + b.Property("StartedAt") + .HasColumnType("TEXT"); + + b.Property("Status") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Version") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.ToTable("WorkflowInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Activities") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("Activities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("BlockingActivities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Connections") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.cs new file mode 100644 index 000000000..088614922 --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.cs @@ -0,0 +1,40 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite +{ + public partial class Update01 : Migration + { + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.AddColumn( + name: "Description", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "DisplayName", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "Name", + table: "ActivityDefinitions", + nullable: true); + } + + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropColumn( + name: "Description", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "DisplayName", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "Name", + table: "ActivityDefinitions"); + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/SqliteContextModelSnapshot.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/SqliteContextModelSnapshot.cs index 68b9d2828..78d59d918 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/SqliteContextModelSnapshot.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/SqliteContextModelSnapshot.cs @@ -4,6 +4,7 @@ using Elsa.Persistence.EntityFrameworkCore.DbContexts; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite { @@ -14,20 +15,30 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite { #pragma warning disable 612, 618 modelBuilder - .HasAnnotation("ProductVersion", "3.0.1"); + .HasAnnotation("ProductVersion", "3.1.1"); modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => { b.Property("Id") .ValueGeneratedOnAdd() - .HasColumnType("INTEGER"); + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); b.Property("ActivityId") .HasColumnType("TEXT"); + b.Property("Description") + .HasColumnType("TEXT"); + + b.Property("DisplayName") + .HasColumnType("TEXT"); + b.Property("Left") .HasColumnType("INTEGER"); + b.Property("Name") + .HasColumnType("TEXT"); + b.Property("State") .HasColumnType("TEXT"); @@ -51,7 +62,8 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite { b.Property("Id") .ValueGeneratedOnAdd() - .HasColumnType("INTEGER"); + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); b.Property("ActivityId") .HasColumnType("TEXT"); @@ -126,7 +138,8 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite { b.Property("Id") .ValueGeneratedOnAdd() - .HasColumnType("INTEGER"); + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); b.Property("DefinitionId") .HasColumnType("TEXT"); @@ -167,7 +180,8 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite { b.Property("Id") .ValueGeneratedOnAdd() - .HasColumnType("INTEGER"); + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); b.Property("AbortedAt") .HasColumnType("TEXT"); diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/README.md b/src/persistence/Elsa.Persistence.EntityFrameworkCore/README.md index fc847ad13..90adaa2df 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/README.md +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/README.md @@ -5,10 +5,10 @@ We should generate migration sets per provider as described here: https://docs.m Example commands: ```bash -dotnet ef migrations add InitialCreate --context SqliteContext --output-dir Migrations/Sqlite -dotnet ef migrations add InitialCreate --context SqlServerContext --output-dir Migrations/SqlServer -dotnet ef migrations add InitialCreate --context PostgreSqlContext --output-dir Migrations/PostgreSql -dotnet ef migrations add InitialCreate --context MySqlContext --output-dir Migrations/MySql +dotnet ef migrations add Update01 --context SqliteContext --output-dir Migrations/Sqlite +dotnet ef migrations add Update01 --context SqlServerContext --output-dir Migrations/SqlServer +dotnet ef migrations add Update01 --context PostgreSqlContext --output-dir Migrations/PostgreSql +dotnet ef migrations add Update01 --context MySqlContext --output-dir Migrations/MySql ``` From f3f5b2d931b6d76f81a7c9d30070098ef2092a52 Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Thu, 2 Apr 2020 22:11:13 +0200 Subject: [PATCH 12/17] Fix missing mapping issues (#279) --- .../Models/WorkflowInstance.cs | 1 - .../Entities/ActivityDefinitionEntity.cs | 3 + .../Mapping/EntitiesProfile.cs | 21 +- .../MySql/20200402200706_Update01.Designer.cs | 267 +++++++++++++++++ .../MySql/20200402200706_Update01.cs | 40 +++ .../MySql/MySqlContextModelSnapshot.cs | 11 +- .../20200402200555_Update01.Designer.cs | 270 +++++++++++++++++ .../PostgreSql/20200402200555_Update01.cs | 40 +++ .../PostgreSqlContextModelSnapshot.cs | 11 +- .../20200402200549_Update01.Designer.cs | 275 ++++++++++++++++++ .../SqlServer/20200402200549_Update01.cs | 40 +++ .../SqlServerContextModelSnapshot.cs | 11 +- .../20200402200519_Update01.Designer.cs | 266 +++++++++++++++++ .../Sqlite/20200402200519_Update01.cs | 40 +++ .../Sqlite/SqliteContextModelSnapshot.cs | 24 +- .../README.md | 8 +- 16 files changed, 1309 insertions(+), 19 deletions(-) create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.Designer.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.Designer.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.Designer.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.Designer.cs create mode 100644 src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.cs diff --git a/src/core/Elsa.Abstractions/Models/WorkflowInstance.cs b/src/core/Elsa.Abstractions/Models/WorkflowInstance.cs index 6d7bafc37..601ceecd6 100644 --- a/src/core/Elsa.Abstractions/Models/WorkflowInstance.cs +++ b/src/core/Elsa.Abstractions/Models/WorkflowInstance.cs @@ -19,7 +19,6 @@ namespace Elsa.Models public Stack Scopes { get; set; } public Variables Input { get; set; } public HashSet BlockingActivities { get; set; } - public string[] TestItems { get; set; } = new string[0]; public ICollection ExecutionLog { get; set; } public WorkflowFault Fault { get; set; } } diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Entities/ActivityDefinitionEntity.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Entities/ActivityDefinitionEntity.cs index 17c068adb..8eaaadc7e 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Entities/ActivityDefinitionEntity.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Entities/ActivityDefinitionEntity.cs @@ -8,6 +8,9 @@ namespace Elsa.Persistence.EntityFrameworkCore.Entities public string ActivityId { get; set; } public WorkflowDefinitionVersionEntity WorkflowDefinitionVersion { get; set; } public string Type { get; set; } + public string Name { get; set; } + public string DisplayName { get; set; } + public string Description { get; set; } public int Left { get; set; } public int Top { get; set; } public JObject State { get; set; } diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Mapping/EntitiesProfile.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Mapping/EntitiesProfile.cs index bff66f83c..7b409b48c 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Mapping/EntitiesProfile.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Mapping/EntitiesProfile.cs @@ -29,19 +29,28 @@ namespace Elsa.Persistence.EntityFrameworkCore.Mapping CreateMap() .ForMember(d => d.Id, d => d.Ignore()) - .ForMember(d => d.ActivityId, d => d.MapFrom(s => s.Id)); - + .ForMember(d => d.ActivityId, d => d.MapFrom(s => s.Id)) + .ForMember(d => d.WorkflowDefinitionVersion, d => d.Ignore()); + CreateMap() .ForCtorParam("id", p => p.MapFrom(s => s.ActivityId)) .ForMember(d => d.Id, d => d.MapFrom(s => s.ActivityId)); - + CreateMap() .ForMember(d => d.Id, d => d.Ignore()) - .ForMember(d => d.ActivityId, d => d.MapFrom(s => s.Id)); + .ForMember(d => d.ActivityId, d => d.MapFrom(s => s.Id)) + .ForMember(d => d.WorkflowInstance, d => d.Ignore()); CreateMap().ForMember(d => d.Id, d => d.MapFrom(s => s.ActivityId)); - CreateMap().ReverseMap(); - CreateMap().ReverseMap(); + CreateMap() + .ForMember(d => d.Id, d => d.Ignore()) + .ForMember(d => d.WorkflowInstance, d => d.Ignore()) + .ReverseMap(); + + CreateMap() + .ForMember(d => d.Id, d => d.Ignore()) + .ForMember(d => d.WorkflowDefinitionVersion, d => d.Ignore()) + .ReverseMap(); } } diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.Designer.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.Designer.cs new file mode 100644 index 000000000..48561c5b4 --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.Designer.cs @@ -0,0 +1,267 @@ +// +using System; +using Elsa.Persistence.EntityFrameworkCore.DbContexts; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.MySql +{ + [DbContext(typeof(MySqlContext))] + [Migration("20200402200706_Update01")] + partial class Update01 + { + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "3.1.1") + .HasAnnotation("Relational:MaxIdentifierLength", 64); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Description") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("DisplayName") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Left") + .HasColumnType("int"); + + b.Property("Name") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("State") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Top") + .HasColumnType("int"); + + b.Property("Type") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ActivityDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Output") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("State") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Type") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("WorkflowInstanceId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("ActivityInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int"); + + b.Property("ActivityId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("ActivityType") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("WorkflowInstanceId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("BlockingActivities"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int"); + + b.Property("DestinationActivityId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Outcome") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("SourceActivityId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ConnectionDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("DefinitionId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Description") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("IsDisabled") + .HasColumnType("tinyint(1)"); + + b.Property("IsLatest") + .HasColumnType("tinyint(1)"); + + b.Property("IsPublished") + .HasColumnType("tinyint(1)"); + + b.Property("IsSingleton") + .HasColumnType("tinyint(1)"); + + b.Property("Name") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Variables") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Version") + .HasColumnType("int"); + + b.Property("VersionId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.HasKey("Id"); + + b.ToTable("WorkflowDefinitionVersions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("AbortedAt") + .HasColumnType("datetime(6)"); + + b.Property("CorrelationId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("CreatedAt") + .HasColumnType("datetime(6)"); + + b.Property("DefinitionId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("ExecutionLog") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Fault") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("FaultedAt") + .HasColumnType("datetime(6)"); + + b.Property("FinishedAt") + .HasColumnType("datetime(6)"); + + b.Property("Input") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("InstanceId") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Scopes") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("StartedAt") + .HasColumnType("datetime(6)"); + + b.Property("Status") + .IsRequired() + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("Version") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.ToTable("WorkflowInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Activities") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("Activities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("BlockingActivities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Connections") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.cs new file mode 100644 index 000000000..1dd46202a --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/20200402200706_Update01.cs @@ -0,0 +1,40 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.MySql +{ + public partial class Update01 : Migration + { + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.AddColumn( + name: "Description", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "DisplayName", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "Name", + table: "ActivityDefinitions", + nullable: true); + } + + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropColumn( + name: "Description", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "DisplayName", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "Name", + table: "ActivityDefinitions"); + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/MySqlContextModelSnapshot.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/MySqlContextModelSnapshot.cs index 4d4ca1721..2efa8af1f 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/MySqlContextModelSnapshot.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/MySql/MySqlContextModelSnapshot.cs @@ -15,7 +15,7 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.MySql { #pragma warning disable 612, 618 modelBuilder - .HasAnnotation("ProductVersion", "3.1.0") + .HasAnnotation("ProductVersion", "3.1.1") .HasAnnotation("Relational:MaxIdentifierLength", 64); modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => @@ -28,9 +28,18 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.MySql b.Property("ActivityId") .HasColumnType("longtext CHARACTER SET utf8mb4"); + b.Property("Description") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + + b.Property("DisplayName") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + b.Property("Left") .HasColumnType("int"); + b.Property("Name") + .HasColumnType("longtext CHARACTER SET utf8mb4"); + b.Property("State") .HasColumnType("longtext CHARACTER SET utf8mb4"); diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.Designer.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.Designer.cs new file mode 100644 index 000000000..911152f8a --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.Designer.cs @@ -0,0 +1,270 @@ +// +using System; +using Elsa.Persistence.EntityFrameworkCore.DbContexts; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.PostgreSql +{ + [DbContext(typeof(PostgreSqlContext))] + [Migration("20200402200555_Update01")] + partial class Update01 + { + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn) + .HasAnnotation("ProductVersion", "3.1.1") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("integer") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("text"); + + b.Property("Description") + .HasColumnType("text"); + + b.Property("DisplayName") + .HasColumnType("text"); + + b.Property("Left") + .HasColumnType("integer"); + + b.Property("Name") + .HasColumnType("text"); + + b.Property("State") + .HasColumnType("text"); + + b.Property("Top") + .HasColumnType("integer"); + + b.Property("Type") + .HasColumnType("text"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ActivityDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("integer") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("text"); + + b.Property("Output") + .HasColumnType("text"); + + b.Property("State") + .HasColumnType("text"); + + b.Property("Type") + .HasColumnType("text"); + + b.Property("WorkflowInstanceId") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("ActivityInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("integer") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("text"); + + b.Property("ActivityType") + .HasColumnType("text"); + + b.Property("WorkflowInstanceId") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("BlockingActivities"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("integer") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("DestinationActivityId") + .HasColumnType("text"); + + b.Property("Outcome") + .HasColumnType("text"); + + b.Property("SourceActivityId") + .HasColumnType("text"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ConnectionDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("integer") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("DefinitionId") + .HasColumnType("text"); + + b.Property("Description") + .HasColumnType("text"); + + b.Property("IsDisabled") + .HasColumnType("boolean"); + + b.Property("IsLatest") + .HasColumnType("boolean"); + + b.Property("IsPublished") + .HasColumnType("boolean"); + + b.Property("IsSingleton") + .HasColumnType("boolean"); + + b.Property("Name") + .HasColumnType("text"); + + b.Property("Variables") + .HasColumnType("text"); + + b.Property("Version") + .HasColumnType("integer"); + + b.Property("VersionId") + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("WorkflowDefinitionVersions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("integer") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("AbortedAt") + .HasColumnType("timestamp without time zone"); + + b.Property("CorrelationId") + .HasColumnType("text"); + + b.Property("CreatedAt") + .HasColumnType("timestamp without time zone"); + + b.Property("DefinitionId") + .HasColumnType("text"); + + b.Property("ExecutionLog") + .HasColumnType("text"); + + b.Property("Fault") + .HasColumnType("text"); + + b.Property("FaultedAt") + .HasColumnType("timestamp without time zone"); + + b.Property("FinishedAt") + .HasColumnType("timestamp without time zone"); + + b.Property("Input") + .HasColumnType("text"); + + b.Property("InstanceId") + .HasColumnType("text"); + + b.Property("Scopes") + .HasColumnType("text"); + + b.Property("StartedAt") + .HasColumnType("timestamp without time zone"); + + b.Property("Status") + .IsRequired() + .HasColumnType("text"); + + b.Property("Version") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.ToTable("WorkflowInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Activities") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("Activities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("BlockingActivities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Connections") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.cs new file mode 100644 index 000000000..8c6a85c9d --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/20200402200555_Update01.cs @@ -0,0 +1,40 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.PostgreSql +{ + public partial class Update01 : Migration + { + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.AddColumn( + name: "Description", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "DisplayName", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "Name", + table: "ActivityDefinitions", + nullable: true); + } + + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropColumn( + name: "Description", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "DisplayName", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "Name", + table: "ActivityDefinitions"); + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/PostgreSqlContextModelSnapshot.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/PostgreSqlContextModelSnapshot.cs index 640bc9e30..ff7170d31 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/PostgreSqlContextModelSnapshot.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/PostgreSql/PostgreSqlContextModelSnapshot.cs @@ -16,7 +16,7 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.PostgreSql #pragma warning disable 612, 618 modelBuilder .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn) - .HasAnnotation("ProductVersion", "3.0.1") + .HasAnnotation("ProductVersion", "3.1.1") .HasAnnotation("Relational:MaxIdentifierLength", 63); modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => @@ -29,9 +29,18 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.PostgreSql b.Property("ActivityId") .HasColumnType("text"); + b.Property("Description") + .HasColumnType("text"); + + b.Property("DisplayName") + .HasColumnType("text"); + b.Property("Left") .HasColumnType("integer"); + b.Property("Name") + .HasColumnType("text"); + b.Property("State") .HasColumnType("text"); diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.Designer.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.Designer.cs new file mode 100644 index 000000000..732fafbb5 --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.Designer.cs @@ -0,0 +1,275 @@ +// +using System; +using Elsa.Persistence.EntityFrameworkCore.DbContexts; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.SqlServer +{ + [DbContext(typeof(SqlServerContext))] + [Migration("20200402200549_Update01")] + partial class Update01 + { + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "3.1.1") + .HasAnnotation("Relational:MaxIdentifierLength", 128) + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn) + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + b.Property("ActivityId") + .HasColumnType("nvarchar(max)"); + + b.Property("Description") + .HasColumnType("nvarchar(max)"); + + b.Property("DisplayName") + .HasColumnType("nvarchar(max)"); + + b.Property("Left") + .HasColumnType("int"); + + b.Property("Name") + .HasColumnType("nvarchar(max)"); + + b.Property("State") + .HasColumnType("nvarchar(max)"); + + b.Property("Top") + .HasColumnType("int"); + + b.Property("Type") + .HasColumnType("nvarchar(max)"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ActivityDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn) + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + b.Property("ActivityId") + .HasColumnType("nvarchar(max)"); + + b.Property("Output") + .HasColumnType("nvarchar(max)"); + + b.Property("State") + .HasColumnType("nvarchar(max)"); + + b.Property("Type") + .HasColumnType("nvarchar(max)"); + + b.Property("WorkflowInstanceId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("ActivityInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + b.Property("ActivityId") + .HasColumnType("nvarchar(max)"); + + b.Property("ActivityType") + .HasColumnType("nvarchar(max)"); + + b.Property("WorkflowInstanceId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("BlockingActivities"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + b.Property("DestinationActivityId") + .HasColumnType("nvarchar(max)"); + + b.Property("Outcome") + .HasColumnType("nvarchar(max)"); + + b.Property("SourceActivityId") + .HasColumnType("nvarchar(max)"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ConnectionDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn) + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + b.Property("DefinitionId") + .HasColumnType("nvarchar(max)"); + + b.Property("Description") + .HasColumnType("nvarchar(max)"); + + b.Property("IsDisabled") + .HasColumnType("bit"); + + b.Property("IsLatest") + .HasColumnType("bit"); + + b.Property("IsPublished") + .HasColumnType("bit"); + + b.Property("IsSingleton") + .HasColumnType("bit"); + + b.Property("Name") + .HasColumnType("nvarchar(max)"); + + b.Property("Variables") + .HasColumnType("nvarchar(max)"); + + b.Property("Version") + .HasColumnType("int"); + + b.Property("VersionId") + .HasColumnType("nvarchar(max)"); + + b.HasKey("Id"); + + b.ToTable("WorkflowDefinitionVersions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn) + .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); + + b.Property("AbortedAt") + .HasColumnType("datetime2"); + + b.Property("CorrelationId") + .HasColumnType("nvarchar(max)"); + + b.Property("CreatedAt") + .HasColumnType("datetime2"); + + b.Property("DefinitionId") + .HasColumnType("nvarchar(max)"); + + b.Property("ExecutionLog") + .HasColumnType("nvarchar(max)"); + + b.Property("Fault") + .HasColumnType("nvarchar(max)"); + + b.Property("FaultedAt") + .HasColumnType("datetime2"); + + b.Property("FinishedAt") + .HasColumnType("datetime2"); + + b.Property("Input") + .HasColumnType("nvarchar(max)"); + + b.Property("InstanceId") + .HasColumnType("nvarchar(max)"); + + b.Property("Scopes") + .HasColumnType("nvarchar(max)"); + + b.Property("StartedAt") + .HasColumnType("datetime2"); + + b.Property("Status") + .IsRequired() + .HasColumnType("nvarchar(max)"); + + b.Property("Version") + .HasColumnType("int"); + + b.HasKey("Id"); + + b.ToTable("WorkflowInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Activities") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("Activities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("BlockingActivities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Connections") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.cs new file mode 100644 index 000000000..13648f962 --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/20200402200549_Update01.cs @@ -0,0 +1,40 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.SqlServer +{ + public partial class Update01 : Migration + { + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.AddColumn( + name: "Description", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "DisplayName", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "Name", + table: "ActivityDefinitions", + nullable: true); + } + + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropColumn( + name: "Description", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "DisplayName", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "Name", + table: "ActivityDefinitions"); + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/SqlServerContextModelSnapshot.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/SqlServerContextModelSnapshot.cs index 6bcb53eb2..e77ab1d28 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/SqlServerContextModelSnapshot.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/SqlServer/SqlServerContextModelSnapshot.cs @@ -16,7 +16,7 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.SqlServer { #pragma warning disable 612, 618 modelBuilder - .HasAnnotation("ProductVersion", "3.1.0") + .HasAnnotation("ProductVersion", "3.1.1") .HasAnnotation("Relational:MaxIdentifierLength", 128) .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn); @@ -31,9 +31,18 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.SqlServer b.Property("ActivityId") .HasColumnType("nvarchar(max)"); + b.Property("Description") + .HasColumnType("nvarchar(max)"); + + b.Property("DisplayName") + .HasColumnType("nvarchar(max)"); + b.Property("Left") .HasColumnType("int"); + b.Property("Name") + .HasColumnType("nvarchar(max)"); + b.Property("State") .HasColumnType("nvarchar(max)"); diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.Designer.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.Designer.cs new file mode 100644 index 000000000..c6c189920 --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.Designer.cs @@ -0,0 +1,266 @@ +// +using System; +using Elsa.Persistence.EntityFrameworkCore.DbContexts; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite +{ + [DbContext(typeof(SqliteContext))] + [Migration("20200402200519_Update01")] + partial class Update01 + { + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "3.1.1"); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("TEXT"); + + b.Property("Description") + .HasColumnType("TEXT"); + + b.Property("DisplayName") + .HasColumnType("TEXT"); + + b.Property("Left") + .HasColumnType("INTEGER"); + + b.Property("Name") + .HasColumnType("TEXT"); + + b.Property("State") + .HasColumnType("TEXT"); + + b.Property("Top") + .HasColumnType("INTEGER"); + + b.Property("Type") + .HasColumnType("TEXT"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ActivityDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("ActivityId") + .HasColumnType("TEXT"); + + b.Property("Output") + .HasColumnType("TEXT"); + + b.Property("State") + .HasColumnType("TEXT"); + + b.Property("Type") + .HasColumnType("TEXT"); + + b.Property("WorkflowInstanceId") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("ActivityInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("ActivityId") + .HasColumnType("TEXT"); + + b.Property("ActivityType") + .HasColumnType("TEXT"); + + b.Property("WorkflowInstanceId") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowInstanceId"); + + b.ToTable("BlockingActivities"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER"); + + b.Property("DestinationActivityId") + .HasColumnType("TEXT"); + + b.Property("Outcome") + .HasColumnType("TEXT"); + + b.Property("SourceActivityId") + .HasColumnType("TEXT"); + + b.Property("WorkflowDefinitionVersionId") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.HasIndex("WorkflowDefinitionVersionId"); + + b.ToTable("ConnectionDefinitions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("DefinitionId") + .HasColumnType("TEXT"); + + b.Property("Description") + .HasColumnType("TEXT"); + + b.Property("IsDisabled") + .HasColumnType("INTEGER"); + + b.Property("IsLatest") + .HasColumnType("INTEGER"); + + b.Property("IsPublished") + .HasColumnType("INTEGER"); + + b.Property("IsSingleton") + .HasColumnType("INTEGER"); + + b.Property("Name") + .HasColumnType("TEXT"); + + b.Property("Variables") + .HasColumnType("TEXT"); + + b.Property("Version") + .HasColumnType("INTEGER"); + + b.Property("VersionId") + .HasColumnType("TEXT"); + + b.HasKey("Id"); + + b.ToTable("WorkflowDefinitionVersions"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); + + b.Property("AbortedAt") + .HasColumnType("TEXT"); + + b.Property("CorrelationId") + .HasColumnType("TEXT"); + + b.Property("CreatedAt") + .HasColumnType("TEXT"); + + b.Property("DefinitionId") + .HasColumnType("TEXT"); + + b.Property("ExecutionLog") + .HasColumnType("TEXT"); + + b.Property("Fault") + .HasColumnType("TEXT"); + + b.Property("FaultedAt") + .HasColumnType("TEXT"); + + b.Property("FinishedAt") + .HasColumnType("TEXT"); + + b.Property("Input") + .HasColumnType("TEXT"); + + b.Property("InstanceId") + .HasColumnType("TEXT"); + + b.Property("Scopes") + .HasColumnType("TEXT"); + + b.Property("StartedAt") + .HasColumnType("TEXT"); + + b.Property("Status") + .IsRequired() + .HasColumnType("TEXT"); + + b.Property("Version") + .HasColumnType("INTEGER"); + + b.HasKey("Id"); + + b.ToTable("WorkflowInstances"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Activities") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityInstanceEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("Activities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.BlockingActivityEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowInstanceEntity", "WorkflowInstance") + .WithMany("BlockingActivities") + .HasForeignKey("WorkflowInstanceId"); + }); + + modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ConnectionDefinitionEntity", b => + { + b.HasOne("Elsa.Persistence.EntityFrameworkCore.Entities.WorkflowDefinitionVersionEntity", "WorkflowDefinitionVersion") + .WithMany("Connections") + .HasForeignKey("WorkflowDefinitionVersionId"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.cs new file mode 100644 index 000000000..088614922 --- /dev/null +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/20200402200519_Update01.cs @@ -0,0 +1,40 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite +{ + public partial class Update01 : Migration + { + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.AddColumn( + name: "Description", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "DisplayName", + table: "ActivityDefinitions", + nullable: true); + + migrationBuilder.AddColumn( + name: "Name", + table: "ActivityDefinitions", + nullable: true); + } + + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropColumn( + name: "Description", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "DisplayName", + table: "ActivityDefinitions"); + + migrationBuilder.DropColumn( + name: "Name", + table: "ActivityDefinitions"); + } + } +} diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/SqliteContextModelSnapshot.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/SqliteContextModelSnapshot.cs index 68b9d2828..78d59d918 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/SqliteContextModelSnapshot.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Migrations/Sqlite/SqliteContextModelSnapshot.cs @@ -4,6 +4,7 @@ using Elsa.Persistence.EntityFrameworkCore.DbContexts; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite { @@ -14,20 +15,30 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite { #pragma warning disable 612, 618 modelBuilder - .HasAnnotation("ProductVersion", "3.0.1"); + .HasAnnotation("ProductVersion", "3.1.1"); modelBuilder.Entity("Elsa.Persistence.EntityFrameworkCore.Entities.ActivityDefinitionEntity", b => { b.Property("Id") .ValueGeneratedOnAdd() - .HasColumnType("INTEGER"); + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); b.Property("ActivityId") .HasColumnType("TEXT"); + b.Property("Description") + .HasColumnType("TEXT"); + + b.Property("DisplayName") + .HasColumnType("TEXT"); + b.Property("Left") .HasColumnType("INTEGER"); + b.Property("Name") + .HasColumnType("TEXT"); + b.Property("State") .HasColumnType("TEXT"); @@ -51,7 +62,8 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite { b.Property("Id") .ValueGeneratedOnAdd() - .HasColumnType("INTEGER"); + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); b.Property("ActivityId") .HasColumnType("TEXT"); @@ -126,7 +138,8 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite { b.Property("Id") .ValueGeneratedOnAdd() - .HasColumnType("INTEGER"); + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); b.Property("DefinitionId") .HasColumnType("TEXT"); @@ -167,7 +180,8 @@ namespace Elsa.Persistence.EntityFrameworkCore.Migrations.Sqlite { b.Property("Id") .ValueGeneratedOnAdd() - .HasColumnType("INTEGER"); + .HasColumnType("INTEGER") + .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn); b.Property("AbortedAt") .HasColumnType("TEXT"); diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/README.md b/src/persistence/Elsa.Persistence.EntityFrameworkCore/README.md index fc847ad13..90adaa2df 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/README.md +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/README.md @@ -5,10 +5,10 @@ We should generate migration sets per provider as described here: https://docs.m Example commands: ```bash -dotnet ef migrations add InitialCreate --context SqliteContext --output-dir Migrations/Sqlite -dotnet ef migrations add InitialCreate --context SqlServerContext --output-dir Migrations/SqlServer -dotnet ef migrations add InitialCreate --context PostgreSqlContext --output-dir Migrations/PostgreSql -dotnet ef migrations add InitialCreate --context MySqlContext --output-dir Migrations/MySql +dotnet ef migrations add Update01 --context SqliteContext --output-dir Migrations/Sqlite +dotnet ef migrations add Update01 --context SqlServerContext --output-dir Migrations/SqlServer +dotnet ef migrations add Update01 --context PostgreSqlContext --output-dir Migrations/PostgreSql +dotnet ef migrations add Update01 --context MySqlContext --output-dir Migrations/MySql ``` From e7b838cbfb0b42275a4151569999779a421dfa7f Mon Sep 17 00:00:00 2001 From: Edward Morgan Date: Mon, 6 Apr 2020 17:02:08 +0300 Subject: [PATCH 13/17] Update ForEach.cs (#285) on designer not apper Done and Iterate ways. --- .../Elsa.Activities.ControlFlow/Activities/ForEach.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/activities/Elsa.Activities.ControlFlow/Activities/ForEach.cs b/src/activities/Elsa.Activities.ControlFlow/Activities/ForEach.cs index a0ed42d01..35c643ec5 100644 --- a/src/activities/Elsa.Activities.ControlFlow/Activities/ForEach.cs +++ b/src/activities/Elsa.Activities.ControlFlow/Activities/ForEach.cs @@ -11,7 +11,7 @@ using Elsa.Services.Models; namespace Elsa.Activities.ControlFlow.Activities { - [ActivityDefinition(Category = "Control Flow", Description = "Iterate over a collection.", Icon = "far fa-circle")] + [ActivityDefinition(Category = "Control Flow", Description = "Iterate over a collection.", Icon = "far fa-circle", Outcomes = "[ 'Done', 'Iterate' ]")] public class ForEach : Activity { private readonly IWorkflowExpressionEvaluator expressionEvaluator; @@ -68,4 +68,4 @@ namespace Elsa.Activities.ControlFlow.Activities return Outcome(OutcomeNames.Iterate); } } -} \ No newline at end of file +} From 3618a773e30e11c13d55b82625423eaf3cfa47dd Mon Sep 17 00:00:00 2001 From: Ibrahim Hammad Date: Mon, 6 Apr 2020 16:03:07 +0200 Subject: [PATCH 14/17] Correct sample paths (#284) --- src/samples/README.md | 48 +++++++++++++++++++++---------------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/src/samples/README.md b/src/samples/README.md index d47e593ff..78e0838dd 100644 --- a/src/samples/README.md +++ b/src/samples/README.md @@ -2,27 +2,27 @@ This list of sample implementations showcase a variety of workflows using ELSA. -1. [Hello World: Strongly Typed](src/samples/WorkflowCore.Sample01) - A minimal workflows program defined in code with a strongly-typed workflow class. -2. [Hello World: Fluent Builder](src/samples/WorkflowCore.Sample02) - A minimal workflows program defined in code using fluent workflow builder and Console activities. -3. [Hello World: Workflow Definition](src/samples/WorkflowCore.Sample03) - A minimal workflows program defined as data (workflow definition) and Console activities. -4. [Calculator](src/samples/WorkflowCore.Sample04) - A strongly-typed, long-running workflows program demonstrating scripting, branching and resuming suspended workflows by providing user driven stimuli. -5. [Recurring](src/samples/WorkflowCore.Sample05) - A minimal workflows program defined in code with a strongly-typed workflow class. -6. [HttpRequest/HttpResponse](src/samples/WorkflowCore.Sample06) - Example of a workflow that intercepts a HttpRequest and handles the HttpResponse. -7. [Document Approval](src/samples/WorkflowCore.Sample07) - Example of a Document Approval workflow. -8. [Create and Handle Orders](src/samples/WorkflowCore.Sample08) - Example of a workflow that creates and handles orders. -9. [Calculator: Defined in Json](src/samples/WorkflowCore.Sample9) - A simple console program that loads & executes a workflow designed with the HTML5 workflow designer. -10. [Hellow World: YesSql](src/samples/WorkflowCore.Sample10) - A simple demonstration of using YesSql persistence providers. -11. [Correlation](src/samples/WorkflowCore.Sample11) - Demonstrates workflow correlation. -12. [User Task](src/samples/WorkflowCore.Sample12) - Demonstrates workflow correlation & user tasks. -13. [Activity Output](src/samples/WorkflowCore.Sample13) - A strongly-typed workflows program demonstrating scripting, and branching. -14. [Hellow World: Entity Framework Core](src/samples/WorkflowCore.Sample14) - A simple demonstration of using Entity Framework Core persistence providers. -15. [Hello World: MongoDb](src/samples/WorkflowCore.Sample15) - A simple demonstration of using the MongoDB persistence providers. Docker(optional) -16. [ELSA Dashboard: Web App, MongoDb Persistence](src/samples/WorkflowCore.Sample16) - ELSA Dashboard MVC wep application. -17. [Create Person: Console Application](src/samples/WorkflowCore.Sample17) - Example of a workflow that creates a Person entity. -18. [Email Reminder: Console Application](src/samples/WorkflowCore.Sample18) - Example of a workflow that sends email reminders on a timer until a condition is met. -19. [ELSA Dashboard: Web App, SqlLite Persistence](src/samples/WorkflowCore.Sample19) - Example of created a web application that hosts a ELSA Dashboard. -20. [Reflection Activities](src/samples/WorkflowCore.Sample20) - Demonstrates Reflection activities. -21. [Shopping Cart: Mass Transit & Quartz Scheduling](src/samples/WorkflowCore.Sample21) - Example of a workflow that tracks a shopping cart. Uses Mass Transit and Quartz scheduling. -22. [Hellow World: SQL Server](src/samples/WorkflowCore.Sample22) - A simple demonstration of using Entity Framework Core persistence providers with SQL Server. -23. [Hello World Custom Schema: Sqllite](src/samples/WorkflowCore.Sample23) - A simple demonstration of using Entity Framework Core persistence providers with SqlLite and Custom Schema. -24. [Hello World: MySql with migration](src/samples/WorkflowCore.Sample24) - A simple demonstration of using Entity Framework Core MySql persistence provider. A migration is also demonstrated. \ No newline at end of file +1. [Hello World: Strongly Typed](Sample01) - A minimal workflows program defined in code with a strongly-typed workflow class. +2. [Hello World: Fluent Builder](Sample02) - A minimal workflows program defined in code using fluent workflow builder and Console activities. +3. [Hello World: Workflow Definition](Sample03) - A minimal workflows program defined as data (workflow definition) and Console activities. +4. [Calculator](Sample04) - A strongly-typed, long-running workflows program demonstrating scripting, branching and resuming suspended workflows by providing user driven stimuli. +5. [Recurring](Sample05) - A minimal workflows program defined in code with a strongly-typed workflow class. +6. [HttpRequest/HttpResponse](Sample06) - Example of a workflow that intercepts a HttpRequest and handles the HttpResponse. +7. [Document Approval](Sample07) - Example of a Document Approval workflow. +8. [Create and Handle Orders](Sample08) - Example of a workflow that creates and handles orders. +9. [Calculator: Defined in Json](Sample9) - A simple console program that loads & executes a workflow designed with the HTML5 workflow designer. +10. [Hellow World: YesSql](Sample10) - A simple demonstration of using YesSql persistence providers. +11. [Correlation](Sample11) - Demonstrates workflow correlation. +12. [User Task](Sample12) - Demonstrates workflow correlation & user tasks. +13. [Activity Output](Sample13) - A strongly-typed workflows program demonstrating scripting, and branching. +14. [Hellow World: Entity Framework Core](Sample14) - A simple demonstration of using Entity Framework Core persistence providers. +15. [Hello World: MongoDb](Sample15) - A simple demonstration of using the MongoDB persistence providers. Docker(optional) +16. [ELSA Dashboard: Web App, MongoDb Persistence](Sample16) - ELSA Dashboard MVC wep application. +17. [Create Person: Console Application](Sample17) - Example of a workflow that creates a Person entity. +18. [Email Reminder: Console Application](Sample18) - Example of a workflow that sends email reminders on a timer until a condition is met. +19. [ELSA Dashboard: Web App, SqlLite Persistence](Sample19) - Example of created a web application that hosts a ELSA Dashboard. +20. [Reflection Activities](Sample20) - Demonstrates Reflection activities. +21. [Shopping Cart: Mass Transit & Quartz Scheduling](Sample21) - Example of a workflow that tracks a shopping cart. Uses Mass Transit and Quartz scheduling. +22. [Hellow World: SQL Server](Sample22) - A simple demonstration of using Entity Framework Core persistence providers with SQL Server. +23. [Hello World Custom Schema: Sqllite](Sample23) - A simple demonstration of using Entity Framework Core persistence providers with SqlLite and Custom Schema. +24. [Hello World: MySql with migration](Sample24) - A simple demonstration of using Entity Framework Core MySql persistence provider. A migration is also demonstrated. \ No newline at end of file From 277272f736c2814d68ad667d914e211f324c3a44 Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Mon, 13 Apr 2020 11:41:53 +0200 Subject: [PATCH 15/17] Update Sample24 to use Sqlite --- src/samples/Sample24/Program.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/samples/Sample24/Program.cs b/src/samples/Sample24/Program.cs index 803705de8..fd2fd80dd 100644 --- a/src/samples/Sample24/Program.cs +++ b/src/samples/Sample24/Program.cs @@ -77,10 +77,10 @@ namespace Sample24 { return new ServiceCollection() .AddElsa( - x => x.AddEntityFrameworkStores( + x => x.AddEntityFrameworkStores( options => options - .UseMySql(@"Server=localhost;Database=Elsa_Sample24;uid=developer;pwd=developer", - builder => builder.MigrationsAssembly(typeof(MySqlContext).Assembly.FullName)))) + .UseSqlite(@"Data Source=c:\data\elsa.entity-framework-core.db;Cache=Shared", + builder => builder.MigrationsAssembly(typeof(SqliteContext).Assembly.FullName)))) .AddStartupRunner() .AddConsoleActivities() .AddWorkflow() From c186a490af18ad71c1de0069561fca8151a76506 Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Mon, 13 Apr 2020 12:01:50 +0200 Subject: [PATCH 16/17] Fix AutoMapper issue Due to a bug with registering AutoMapper profiles, only the first mapping profile would get registered. Also merged AutoMapper utilities into Elsa.Core. --- Samples.sln | 10 ------ src/core/Elsa.Core/Elsa.Core.csproj | 1 - .../AutoMapperServiceCollectionExtensions.cs} | 6 ++-- .../ElsaServiceCollectionExtensions.cs | 1 + .../Elsa.Core/Mapping}/NodaTimeProfile.cs | 0 .../DashboardServiceCollectionExtensions.cs | 1 + .../ServiceConfigurationExtensions.cs | 1 + .../EFCoreServiceCollectionExtensions.cs | 1 + .../YesSqlServiceCollectionExtensions.cs | 1 + .../Elsa.AutoMapper.Extensions.csproj | 33 ------------------ src/utils/Elsa.AutoMapper.Extensions/icon.png | Bin 16374 -> 0 bytes 11 files changed, 8 insertions(+), 47 deletions(-) rename src/{utils/Elsa.AutoMapper.Extensions/ServiceCollectionExtensions.cs => core/Elsa.Core/Extensions/AutoMapperServiceCollectionExtensions.cs} (88%) rename src/{utils/Elsa.AutoMapper.Extensions/NodaTime => core/Elsa.Core/Mapping}/NodaTimeProfile.cs (100%) delete mode 100644 src/utils/Elsa.AutoMapper.Extensions/Elsa.AutoMapper.Extensions.csproj delete mode 100644 src/utils/Elsa.AutoMapper.Extensions/icon.png diff --git a/Samples.sln b/Samples.sln index 5640df5c5..0918908dc 100644 --- a/Samples.sln +++ b/Samples.sln @@ -105,10 +105,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Elsa.Scripting.JavaScript", EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Elsa.Scripting.Liquid", "src\scripting\Elsa.Scripting.Liquid\Elsa.Scripting.Liquid.csproj", "{01DC21DD-C6E2-4B21-864E-97D29448F777}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "utils", "utils", "{0D276728-DDA8-46A0-91A9-D44401D66DA9}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Elsa.AutoMapper.Extensions", "src\utils\Elsa.AutoMapper.Extensions\Elsa.AutoMapper.Extensions.csproj", "{102626A4-8BA6-45A8-A69C-F5EB1F155BE7}" -EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Sample18", "src\samples\Sample18\Sample18.csproj", "{616AA0BA-FBDD-4ABE-B688-A3F79F38C698}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Sample19", "src\samples\Sample19\Sample19.csproj", "{2AEA0028-96D6-4823-A88F-24294E4BA4E8}" @@ -281,10 +277,6 @@ Global {01DC21DD-C6E2-4B21-864E-97D29448F777}.Debug|Any CPU.Build.0 = Debug|Any CPU {01DC21DD-C6E2-4B21-864E-97D29448F777}.Release|Any CPU.ActiveCfg = Release|Any CPU {01DC21DD-C6E2-4B21-864E-97D29448F777}.Release|Any CPU.Build.0 = Release|Any CPU - {102626A4-8BA6-45A8-A69C-F5EB1F155BE7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {102626A4-8BA6-45A8-A69C-F5EB1F155BE7}.Debug|Any CPU.Build.0 = Debug|Any CPU - {102626A4-8BA6-45A8-A69C-F5EB1F155BE7}.Release|Any CPU.ActiveCfg = Release|Any CPU - {102626A4-8BA6-45A8-A69C-F5EB1F155BE7}.Release|Any CPU.Build.0 = Release|Any CPU {616AA0BA-FBDD-4ABE-B688-A3F79F38C698}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {616AA0BA-FBDD-4ABE-B688-A3F79F38C698}.Debug|Any CPU.Build.0 = Debug|Any CPU {616AA0BA-FBDD-4ABE-B688-A3F79F38C698}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -369,8 +361,6 @@ Global {6BB5EB72-AD9A-41ED-A6AA-0FF1093EA41B} = {35F44BE9-13D0-417C-A01A-F0787BEE6DC3} {18BE8F72-E528-4617-B1B1-07BD35337DFC} = {9C3C685E-3D7D-4638-A031-24F71CF74B52} {01DC21DD-C6E2-4B21-864E-97D29448F777} = {9C3C685E-3D7D-4638-A031-24F71CF74B52} - {0D276728-DDA8-46A0-91A9-D44401D66DA9} = {DA71CDAA-8DD3-4D5F-9FBD-8E4B37A2D925} - {102626A4-8BA6-45A8-A69C-F5EB1F155BE7} = {0D276728-DDA8-46A0-91A9-D44401D66DA9} {616AA0BA-FBDD-4ABE-B688-A3F79F38C698} = {5E5E1E84-DDBC-40D6-B891-0D563A15A44A} {2AEA0028-96D6-4823-A88F-24294E4BA4E8} = {5E5E1E84-DDBC-40D6-B891-0D563A15A44A} {258F624E-98D7-4498-AE2E-F612D8ECA763} = {B43B546E-23F3-46E8-ACB7-D04F05CDA180} diff --git a/src/core/Elsa.Core/Elsa.Core.csproj b/src/core/Elsa.Core/Elsa.Core.csproj index cf3363d05..d475d368b 100644 --- a/src/core/Elsa.Core/Elsa.Core.csproj +++ b/src/core/Elsa.Core/Elsa.Core.csproj @@ -48,7 +48,6 @@ - diff --git a/src/utils/Elsa.AutoMapper.Extensions/ServiceCollectionExtensions.cs b/src/core/Elsa.Core/Extensions/AutoMapperServiceCollectionExtensions.cs similarity index 88% rename from src/utils/Elsa.AutoMapper.Extensions/ServiceCollectionExtensions.cs rename to src/core/Elsa.Core/Extensions/AutoMapperServiceCollectionExtensions.cs index 86d3a04d6..7a440cb40 100644 --- a/src/utils/Elsa.AutoMapper.Extensions/ServiceCollectionExtensions.cs +++ b/src/core/Elsa.Core/Extensions/AutoMapperServiceCollectionExtensions.cs @@ -3,9 +3,9 @@ using AutoMapper; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection.Extensions; -namespace Elsa.AutoMapper.Extensions +namespace Elsa.Extensions { - public static class ServiceCollectionExtensions + public static class AutoMapperServiceCollectionExtensions { public static IServiceCollection AddAutoMapper(this IServiceCollection services, ServiceLifetime lifetime) { @@ -18,7 +18,7 @@ namespace Elsa.AutoMapper.Extensions public static IServiceCollection AddAutoMapperProfile(this IServiceCollection services, ServiceLifetime lifetime) where TProfile : Profile { services.AddAutoMapper(lifetime); - services.TryAddTransient(typeof(Profile), typeof(TProfile)); + services.TryAddProvider(lifetime); return services; } diff --git a/src/core/Elsa.Core/Extensions/ElsaServiceCollectionExtensions.cs b/src/core/Elsa.Core/Extensions/ElsaServiceCollectionExtensions.cs index 6f1a8206b..ab651ceea 100644 --- a/src/core/Elsa.Core/Extensions/ElsaServiceCollectionExtensions.cs +++ b/src/core/Elsa.Core/Extensions/ElsaServiceCollectionExtensions.cs @@ -5,6 +5,7 @@ using Elsa.Activities; using Elsa.AutoMapper.Extensions; using Elsa.Caching; using Elsa.Expressions; +using Elsa.Extensions; using Elsa.Mapping; using Elsa.Persistence; using Elsa.Persistence.Memory; diff --git a/src/utils/Elsa.AutoMapper.Extensions/NodaTime/NodaTimeProfile.cs b/src/core/Elsa.Core/Mapping/NodaTimeProfile.cs similarity index 100% rename from src/utils/Elsa.AutoMapper.Extensions/NodaTime/NodaTimeProfile.cs rename to src/core/Elsa.Core/Mapping/NodaTimeProfile.cs diff --git a/src/dashboard/Elsa.Dashboard/Extensions/DashboardServiceCollectionExtensions.cs b/src/dashboard/Elsa.Dashboard/Extensions/DashboardServiceCollectionExtensions.cs index e84a5dcde..7f828e69d 100644 --- a/src/dashboard/Elsa.Dashboard/Extensions/DashboardServiceCollectionExtensions.cs +++ b/src/dashboard/Elsa.Dashboard/Extensions/DashboardServiceCollectionExtensions.cs @@ -3,6 +3,7 @@ using Elsa.AutoMapper.Extensions; using Elsa.Dashboard.ActionFilters; using Elsa.Dashboard.Options; using Elsa.Dashboard.Services; +using Elsa.Extensions; using Elsa.Mapping; using Elsa.Runtime; using Elsa.Serialization; diff --git a/src/persistence/Elsa.Persistence.DocumentDb/Extensions/ServiceConfigurationExtensions.cs b/src/persistence/Elsa.Persistence.DocumentDb/Extensions/ServiceConfigurationExtensions.cs index c293b9979..92a48bbd3 100644 --- a/src/persistence/Elsa.Persistence.DocumentDb/Extensions/ServiceConfigurationExtensions.cs +++ b/src/persistence/Elsa.Persistence.DocumentDb/Extensions/ServiceConfigurationExtensions.cs @@ -2,6 +2,7 @@ using System; using Elsa.Persistence.DocumentDb.Services; using Elsa.AutoMapper.Extensions; using Elsa.AutoMapper.Extensions.NodaTime; +using Elsa.Extensions; using Elsa.Persistence.DocumentDb.Mapping; using Microsoft.Extensions.DependencyInjection; diff --git a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Extensions/EFCoreServiceCollectionExtensions.cs b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Extensions/EFCoreServiceCollectionExtensions.cs index c1f582275..8d216c4d9 100644 --- a/src/persistence/Elsa.Persistence.EntityFrameworkCore/Extensions/EFCoreServiceCollectionExtensions.cs +++ b/src/persistence/Elsa.Persistence.EntityFrameworkCore/Extensions/EFCoreServiceCollectionExtensions.cs @@ -1,6 +1,7 @@ using System; using Elsa.AutoMapper.Extensions; using Elsa.AutoMapper.Extensions.NodaTime; +using Elsa.Extensions; using Elsa.Persistence.EntityFrameworkCore.DbContexts; using Elsa.Persistence.EntityFrameworkCore.Mapping; using Elsa.Persistence.EntityFrameworkCore.Services; diff --git a/src/persistence/Elsa.Persistence.YesSql/Extensions/YesSqlServiceCollectionExtensions.cs b/src/persistence/Elsa.Persistence.YesSql/Extensions/YesSqlServiceCollectionExtensions.cs index a8feca36f..37f1752d0 100644 --- a/src/persistence/Elsa.Persistence.YesSql/Extensions/YesSqlServiceCollectionExtensions.cs +++ b/src/persistence/Elsa.Persistence.YesSql/Extensions/YesSqlServiceCollectionExtensions.cs @@ -1,6 +1,7 @@ using System; using Elsa.AutoMapper.Extensions; using Elsa.AutoMapper.Extensions.NodaTime; +using Elsa.Extensions; using Elsa.Persistence.YesSql.Indexes; using Elsa.Persistence.YesSql.Mapping; using Elsa.Persistence.YesSql.Schema; diff --git a/src/utils/Elsa.AutoMapper.Extensions/Elsa.AutoMapper.Extensions.csproj b/src/utils/Elsa.AutoMapper.Extensions/Elsa.AutoMapper.Extensions.csproj deleted file mode 100644 index df427b047..000000000 --- a/src/utils/Elsa.AutoMapper.Extensions/Elsa.AutoMapper.Extensions.csproj +++ /dev/null @@ -1,33 +0,0 @@ - - - - netstandard2.0 - latest - 1.0.0 - Elsa Contributors - - Elsa is a set of workflow libraries and tools that enable super-fast workflowing capabilities in any .NET Core application. - This package provides extension methods that simplify registration of AutoMapper and profiles. - - 2019 - https://github.com/elsa-workflows/elsa-core - https://github.com/elsa-workflows/elsa-core - GitHub - elsa, workflows - icon.png - - - - - True - - - - - - - - - - - diff --git a/src/utils/Elsa.AutoMapper.Extensions/icon.png b/src/utils/Elsa.AutoMapper.Extensions/icon.png deleted file mode 100644 index f978a28829e4f03aa270e4f0f2162bb8c41bed2a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 16374 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 Date: Mon, 13 Apr 2020 12:05:54 +0200 Subject: [PATCH 17/17] Remove reference to deleted project --- Elsa.sln | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/Elsa.sln b/Elsa.sln index 0c0a3f8a0..8b79169d7 100644 --- a/Elsa.sln +++ b/Elsa.sln @@ -54,12 +54,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Persistence.DocumentDb EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Activities.Dropbox", "src\activities\Elsa.Activities.Dropbox\Elsa.Activities.Dropbox.csproj", "{5A3C9D59-21FE-4BE3-A00A-FF3F198EEC97}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "utils", "utils", "{9E1AF14C-0BEC-4BC2-810C-85FC25A9DDD4}" -EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "scripting", "scripting", "{5E230C5F-7A64-4E95-A790-DF40CC66DA31}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.AutoMapper.Extensions", "src\utils\Elsa.AutoMapper.Extensions\Elsa.AutoMapper.Extensions.csproj", "{72DA50EC-8A99-4D4F-BF61-DEF105BDAE10}" -EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Scripting.JavaScript", "src\scripting\Elsa.Scripting.JavaScript\Elsa.Scripting.JavaScript.csproj", "{DA91DAF2-4C59-4468-8F1D-6A500D218A1E}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Scripting.Liquid", "src\scripting\Elsa.Scripting.Liquid\Elsa.Scripting.Liquid.csproj", "{9A2D1E3E-328F-4E02-86F8-84974925C1E3}" @@ -140,10 +136,6 @@ Global {5A3C9D59-21FE-4BE3-A00A-FF3F198EEC97}.Debug|Any CPU.Build.0 = Debug|Any CPU {5A3C9D59-21FE-4BE3-A00A-FF3F198EEC97}.Release|Any CPU.ActiveCfg = Release|Any CPU {5A3C9D59-21FE-4BE3-A00A-FF3F198EEC97}.Release|Any CPU.Build.0 = Release|Any CPU - {72DA50EC-8A99-4D4F-BF61-DEF105BDAE10}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {72DA50EC-8A99-4D4F-BF61-DEF105BDAE10}.Debug|Any CPU.Build.0 = Debug|Any CPU - {72DA50EC-8A99-4D4F-BF61-DEF105BDAE10}.Release|Any CPU.ActiveCfg = Release|Any CPU - {72DA50EC-8A99-4D4F-BF61-DEF105BDAE10}.Release|Any CPU.Build.0 = Release|Any CPU {DA91DAF2-4C59-4468-8F1D-6A500D218A1E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {DA91DAF2-4C59-4468-8F1D-6A500D218A1E}.Debug|Any CPU.Build.0 = Debug|Any CPU {DA91DAF2-4C59-4468-8F1D-6A500D218A1E}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -196,9 +188,7 @@ Global {120E4BF9-4A42-4BB9-A0B2-9597160D6E37} = {8B87D79A-F0DE-4F88-81D3-8C8C69108ADB} {39EBECE7-538B-431C-AAB7-901AB16E6D4A} = {76710230-AC6D-4E54-9A06-15F34C155118} {5A3C9D59-21FE-4BE3-A00A-FF3F198EEC97} = {B43B546E-23F3-46E8-ACB7-D04F05CDA180} - {9E1AF14C-0BEC-4BC2-810C-85FC25A9DDD4} = {DA71CDAA-8DD3-4D5F-9FBD-8E4B37A2D925} {5E230C5F-7A64-4E95-A790-DF40CC66DA31} = {DA71CDAA-8DD3-4D5F-9FBD-8E4B37A2D925} - {72DA50EC-8A99-4D4F-BF61-DEF105BDAE10} = {9E1AF14C-0BEC-4BC2-810C-85FC25A9DDD4} {DA91DAF2-4C59-4468-8F1D-6A500D218A1E} = {5E230C5F-7A64-4E95-A790-DF40CC66DA31} {9A2D1E3E-328F-4E02-86F8-84974925C1E3} = {5E230C5F-7A64-4E95-A790-DF40CC66DA31} {3FC85C9D-CC20-4F54-9936-029F19FBFBE1} = {B43B546E-23F3-46E8-ACB7-D04F05CDA180}