Community.Activities/Activities/Database/UiPath.Database.Activities/DatabaseExecute.cs at a3369e135ddc22df5b3b62e75027ae8afeb382c2 · UiPath/Community.Activities · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
using System;
using System.Activities;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Security;
using System.Threading;
using System.Threading.Tasks;
using UiPath.Shared.Activities;
using UiPath.Database.Activities.Properties;
using System.Activities.Validation;

namespace UiPath.Database.Activities
{
    public abstract class DatabaseExecute : AsyncTaskCodeActivity
    {
        private const int _defaultTimeout = 30000;

        protected DatabaseConnection DbConnection = null;

        [DefaultValue(null)]
        [LocalizedCategory(nameof(Resources.ConnectionConfiguration))]
        [LocalizedDisplayName(nameof(Resources.Activity_DatabaseExecute_Property_ProviderName_Name))]
        [LocalizedDescription(nameof(Resources.Activity_DatabaseExecute_Property_ProviderName_Description))]
        public InArgument<string> ProviderName { get; set; }

        [LocalizedCategory(nameof(Resources.ConnectionConfiguration))]
        [DefaultValue(null)]
        [LocalizedDisplayName(nameof(Resources.Activity_DatabaseExecute_Property_ConnectionString_Name))]
        [LocalizedDescription(nameof(Resources.Activity_DatabaseExecute_Property_ConnectionString_Description))]
        public InArgument<string> ConnectionString { get; set; }

        [DefaultValue(null)]
        [LocalizedCategory(nameof(Resources.ConnectionConfiguration))]
        [LocalizedDisplayName(nameof(Resources.Activity_DatabaseExecute_Property_ConnectionSecureString_Name))]
        [LocalizedDescription(nameof(Resources.Activity_DatabaseExecute_Property_ConnectionSecureString_Description))]
        public InArgument<SecureString> ConnectionSecureString { get; set; }

        [LocalizedCategory(nameof(Resources.ConnectionConfiguration))]
        [LocalizedDisplayName(nameof(Resources.Activity_DatabaseExecute_Property_ExistingDbConnection_Name))]
        [LocalizedDescription(nameof(Resources.Activity_DatabaseExecute_Property_ExistingDbConnection_Description))]
        public InArgument<DatabaseConnection> ExistingDbConnection { get; set; }

        [DefaultValue(CommandType.Text)]
        [LocalizedDisplayName(nameof(Resources.Activity_DatabaseExecute_Property_CommandType_Name))]
        [LocalizedDescription(nameof(Resources.Activity_DatabaseExecute_Property_CommandType_Description))]
        public CommandType CommandType { get; set; }

        [LocalizedCategory(nameof(Resources.Input))]
        [LocalizedDisplayName(nameof(Resources.Activity_DatabaseExecute_Property_Parameters_Name))]
        [LocalizedDescription(nameof(Resources.Activity_DatabaseExecute_Property_Parameters_Description))]
        [Browsable(true)]
        public Dictionary<string, Argument> Parameters { get; set; } = new Dictionary<string, Argument>();

        [DefaultValue(null)]
        [LocalizedCategory(nameof(Resources.Common))]
        [LocalizedDisplayName(nameof(Resources.Activity_DatabaseExecute_Property_ContinueOnError_Name))]
        [LocalizedDescription(nameof(Resources.Activity_DatabaseExecute_Property_ContinueOnError_Description))]
        public InArgument<bool> ContinueOnError { get; set; }

        [DefaultValue(null)]
        [LocalizedCategory(nameof(Resources.Common))]
        [LocalizedDisplayName(nameof(Resources.Activity_DatabaseExecute_Property_TimeoutMS_Name))]
        [LocalizedDescription(nameof(Resources.Activity_DatabaseExecute_Property_TimeoutMS_Description))]
        public InArgument<int> TimeoutMS { get; set; }

        protected sealed override Task<Action<AsyncCodeActivityContext>> ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
        {
            if(TimeoutMS.Expression is null)
            {
                TimeoutMS.Set(context, _defaultTimeout);
            }

            return ExecuteInternalAsync(context, cancellationToken);
        }
        protected abstract Task<Action<AsyncCodeActivityContext>> ExecuteInternalAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken);

        protected override void CacheMetadata(CodeActivityMetadata metadata)
        {
            base.CacheMetadata(metadata);

            if (!ExistingDbConnection.IsEmpty())
            {
                return;
            }

            if (ConnectionSecureString.IsEmpty() && ConnectionString.IsEmpty())
            {
                var validationError = new ValidationError(Resources.ValidationError_ConnectionMustNotBeNull, false);
                metadata.AddValidationError(validationError);
                return;
            }
            if (!ConnectionSecureString.IsEmpty() && !ConnectionString.IsEmpty())
            {
                var validationError = new ValidationError(Resources.ValidationError_ConnectionMustBeSet, false);
                metadata.AddValidationError(validationError);
                return;
            }
            if(ProviderName.IsEmpty())
            {
                var validationError = new ValidationError(Resources.ValidationError_ProviderNull, false, nameof(ProviderName));
                metadata.AddValidationError(validationError);
            }
        }
    }
}