├── .gitignore
├── LICENSE
├── README.md
├── docs
└── index.html
├── lib
├── ICSharpCode.SharpZipLib.dll
├── LumenWorks.Framework.IO.dll
├── Microsoft.Data.Tools.Schema.Sql.dll
├── Microsoft.Data.Tools.Utilities.dll
├── Microsoft.SqlServer.Dac.Extensions.dll
├── Microsoft.SqlServer.Dac.dll
├── Microsoft.SqlServer.TransactSql.ScriptDom.dll
├── Microsoft.SqlServer.Types.dll
└── Microsoft.WindowsAzure.Storage.dll
└── src
├── App.config
├── DoIt.config.xml
├── DoIt.csproj
├── DoIt.csproj.user
├── DoIt.sln
├── Extensions.cs
├── Functions
├── ConditionFunctions.cs
├── CsvFunctions.cs
├── DataTableFunctions.cs
├── DatabaseFunctions.cs
├── ExceptionFunctions.cs
├── ForEachFunctions.cs
├── FtpFunctions.cs
├── FunctionsNodeHandlerBase.cs
├── HttpFunctions.cs
├── LocalDiskFunctions.cs
├── LogFunctions.cs
├── MailFunctions.cs
├── ProcessFunctions.cs
├── SetValueFunctions.cs
├── SleepFunctions.cs
├── SqlFunctions.cs
├── StorageFunctions.cs
├── TryFunctions.cs
└── ZipFunctions.cs
├── Program.cs
├── Properties
└── AssemblyInfo.cs
├── RijndaelEnhanced.cs
├── StaticRandom.cs
└── Util.cs
/.gitignore:
--------------------------------------------------------------------------------
1 | ################################################################################
2 | # This .gitignore file was automatically created by Microsoft(R) Visual Studio.
3 | ################################################################################
4 |
5 | /src/bin/AnyCPU/Debug
6 | /src/bin/AnyCPU/Release
7 | /src/bin/x64/Debug
8 | /src/bin/x64/Release
9 | /src/obj/
10 | /src/.vs/DoIt/FileContentIndex
11 | /src/.vs/DoIt/v17
12 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2016 ForLogic
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/lib/ICSharpCode.SharpZipLib.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ForLogic/doit/29bcb33e295149a704958a1fd62a9e3d33e0852f/lib/ICSharpCode.SharpZipLib.dll
--------------------------------------------------------------------------------
/lib/LumenWorks.Framework.IO.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ForLogic/doit/29bcb33e295149a704958a1fd62a9e3d33e0852f/lib/LumenWorks.Framework.IO.dll
--------------------------------------------------------------------------------
/lib/Microsoft.Data.Tools.Schema.Sql.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ForLogic/doit/29bcb33e295149a704958a1fd62a9e3d33e0852f/lib/Microsoft.Data.Tools.Schema.Sql.dll
--------------------------------------------------------------------------------
/lib/Microsoft.Data.Tools.Utilities.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ForLogic/doit/29bcb33e295149a704958a1fd62a9e3d33e0852f/lib/Microsoft.Data.Tools.Utilities.dll
--------------------------------------------------------------------------------
/lib/Microsoft.SqlServer.Dac.Extensions.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ForLogic/doit/29bcb33e295149a704958a1fd62a9e3d33e0852f/lib/Microsoft.SqlServer.Dac.Extensions.dll
--------------------------------------------------------------------------------
/lib/Microsoft.SqlServer.Dac.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ForLogic/doit/29bcb33e295149a704958a1fd62a9e3d33e0852f/lib/Microsoft.SqlServer.Dac.dll
--------------------------------------------------------------------------------
/lib/Microsoft.SqlServer.TransactSql.ScriptDom.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ForLogic/doit/29bcb33e295149a704958a1fd62a9e3d33e0852f/lib/Microsoft.SqlServer.TransactSql.ScriptDom.dll
--------------------------------------------------------------------------------
/lib/Microsoft.SqlServer.Types.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ForLogic/doit/29bcb33e295149a704958a1fd62a9e3d33e0852f/lib/Microsoft.SqlServer.Types.dll
--------------------------------------------------------------------------------
/lib/Microsoft.WindowsAzure.Storage.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ForLogic/doit/29bcb33e295149a704958a1fd62a9e3d33e0852f/lib/Microsoft.WindowsAzure.Storage.dll
--------------------------------------------------------------------------------
/src/App.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
--------------------------------------------------------------------------------
/src/DoIt.config.xml:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ForLogic/doit/29bcb33e295149a704958a1fd62a9e3d33e0852f/src/DoIt.config.xml
--------------------------------------------------------------------------------
/src/DoIt.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Debug
6 | AnyCPU
7 | {724B6B98-D177-4860-9D1D-952B8EECD807}
8 | Exe
9 | Properties
10 | DoIt
11 | DoIt
12 | v4.7.2
13 | 512
14 |
15 |
16 |
17 | AnyCPU
18 | true
19 | full
20 | false
21 | bin\AnyCPU\Debug\
22 | DEBUG;TRACE
23 | prompt
24 | 4
25 |
26 |
27 | AnyCPU
28 | pdbonly
29 | true
30 | bin\AnyCPU\Release\
31 | TRACE
32 | prompt
33 | 4
34 |
35 |
36 | true
37 | bin\x86\Debug\
38 | DEBUG;TRACE
39 | full
40 | x86
41 | prompt
42 | MinimumRecommendedRules.ruleset
43 | true
44 |
45 |
46 | bin\x86\Release\
47 | TRACE
48 | true
49 | pdbonly
50 | x86
51 | prompt
52 | MinimumRecommendedRules.ruleset
53 | true
54 |
55 |
56 | true
57 | bin\x64\Debug\
58 | DEBUG;TRACE
59 | full
60 | x64
61 | prompt
62 | MinimumRecommendedRules.ruleset
63 | true
64 |
65 |
66 | bin\x64\Release\
67 | TRACE
68 | true
69 | pdbonly
70 | x64
71 | prompt
72 | MinimumRecommendedRules.ruleset
73 | true
74 |
75 |
76 |
77 | ..\lib\ICSharpCode.SharpZipLib.dll
78 |
79 |
80 | ..\lib\LumenWorks.Framework.IO.dll
81 |
82 |
83 | False
84 | ..\lib\Microsoft.Data.Tools.Schema.Sql.dll
85 |
86 |
87 | False
88 | ..\lib\Microsoft.Data.Tools.Utilities.dll
89 |
90 |
91 | False
92 | ..\lib\Microsoft.SqlServer.Dac.dll
93 |
94 |
95 | False
96 | ..\lib\Microsoft.SqlServer.Dac.Extensions.dll
97 |
98 |
99 | False
100 | ..\lib\Microsoft.SqlServer.TransactSql.ScriptDom.dll
101 |
102 |
103 | False
104 | ..\lib\Microsoft.SqlServer.Types.dll
105 |
106 |
107 | False
108 | ..\lib\Microsoft.WindowsAzure.Storage.dll
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
125 |
126 |
127 |
128 |
129 |
130 |
131 |
132 |
133 |
134 |
135 |
136 |
137 |
138 |
139 |
140 |
141 |
142 |
143 |
144 |
145 |
146 |
147 |
148 |
149 |
150 |
151 | Designer
152 |
153 |
154 |
155 |
156 | PreserveNewest
157 | Designer
158 |
159 |
160 |
161 |
168 |
--------------------------------------------------------------------------------
/src/DoIt.csproj.user:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | ProjectFiles
5 |
6 |
7 |
8 |
9 |
10 |
--------------------------------------------------------------------------------
/src/DoIt.sln:
--------------------------------------------------------------------------------
1 |
2 | Microsoft Visual Studio Solution File, Format Version 12.00
3 | # Visual Studio 14
4 | VisualStudioVersion = 14.0.24720.0
5 | MinimumVisualStudioVersion = 10.0.40219.1
6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DoIt", "DoIt.csproj", "{724B6B98-D177-4860-9D1D-952B8EECD807}"
7 | EndProject
8 | Global
9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | Debug|Any CPU = Debug|Any CPU
11 | Debug|x64 = Debug|x64
12 | Debug|x86 = Debug|x86
13 | Release|Any CPU = Release|Any CPU
14 | Release|x64 = Release|x64
15 | Release|x86 = Release|x86
16 | EndGlobalSection
17 | GlobalSection(ProjectConfigurationPlatforms) = postSolution
18 | {724B6B98-D177-4860-9D1D-952B8EECD807}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
19 | {724B6B98-D177-4860-9D1D-952B8EECD807}.Debug|Any CPU.Build.0 = Debug|Any CPU
20 | {724B6B98-D177-4860-9D1D-952B8EECD807}.Debug|x64.ActiveCfg = Debug|x64
21 | {724B6B98-D177-4860-9D1D-952B8EECD807}.Debug|x64.Build.0 = Debug|x64
22 | {724B6B98-D177-4860-9D1D-952B8EECD807}.Debug|x86.ActiveCfg = Debug|x86
23 | {724B6B98-D177-4860-9D1D-952B8EECD807}.Debug|x86.Build.0 = Debug|x86
24 | {724B6B98-D177-4860-9D1D-952B8EECD807}.Release|Any CPU.ActiveCfg = Release|Any CPU
25 | {724B6B98-D177-4860-9D1D-952B8EECD807}.Release|Any CPU.Build.0 = Release|Any CPU
26 | {724B6B98-D177-4860-9D1D-952B8EECD807}.Release|x64.ActiveCfg = Release|x64
27 | {724B6B98-D177-4860-9D1D-952B8EECD807}.Release|x64.Build.0 = Release|x64
28 | {724B6B98-D177-4860-9D1D-952B8EECD807}.Release|x86.ActiveCfg = Release|x86
29 | {724B6B98-D177-4860-9D1D-952B8EECD807}.Release|x86.Build.0 = Release|x86
30 | EndGlobalSection
31 | GlobalSection(SolutionProperties) = preSolution
32 | HideSolutionNode = FALSE
33 | EndGlobalSection
34 | GlobalSection(CodealikeProperties) = postSolution
35 | SolutionGuid = 7769ccf6-a193-40a0-8030-81a673b7c3cb
36 | EndGlobalSection
37 | EndGlobal
38 |
--------------------------------------------------------------------------------
/src/Extensions.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Data;
4 | using System.Globalization;
5 | using System.Linq;
6 | using System.Text;
7 | using System.Text.RegularExpressions;
8 |
9 | namespace DoIt
10 | {
11 | public static class Extensions
12 | {
13 | public static Boolean IsMatch(this String str, String pattern)
14 | {
15 | if (String.IsNullOrEmpty(str))
16 | return false;
17 | return Regex.IsMatch(str, pattern, RegexOptions.IgnoreCase);
18 | }
19 |
20 | public static Boolean IsNumber(this Object obj)
21 | {
22 | if (obj is Int16 || obj is Int32 || obj is Int64)
23 | return true;
24 | if (obj is Decimal || obj is Single || obj is Double)
25 | return true;
26 | if (obj is String && !String.IsNullOrEmpty(obj as String) && (obj as String).IsMatch("^((\\+|\\-)?[0-9]+([0-9]*(\\.|\\" + NumberFormatInfo.CurrentInfo.NumberDecimalSeparator + ")?[0-9]+)?)?$"))
27 | return true;
28 | return false;
29 | }
30 |
31 | public static String Concat(this IEnumerable lst, Func valueFunction, String separator = ", ", String format = null, String defaultValue = null, Boolean distinct = true)
32 | {
33 | if (lst == null || lst.Count() == 0)
34 | return defaultValue;
35 | var newlst = (distinct ? lst.Select(item => valueFunction(item)).Distinct() : lst.Select(item => valueFunction(item))).ToList();
36 | var str = new StringBuilder();
37 | foreach (var value in newlst)
38 | {
39 | var valuestr = Convert.ToString(value);
40 | if (!String.IsNullOrEmpty(valuestr))
41 | str.Append(String.IsNullOrEmpty(format) ? valuestr + separator : String.Format("{0:" + format + "}", value) + separator);
42 | }
43 | return String.IsNullOrEmpty(str.ToString()) ? null : str.Remove(str.Length - separator.Length, separator.Length).ToString();
44 | }
45 |
46 | public static String GetFullMessage(this Exception ex, Boolean stackTrace = true, Int32 counter = 1)
47 | {
48 | if (ex == null)
49 | return "";
50 |
51 | var msg = "";
52 | if (ex.InnerException != null)
53 | {
54 | msg += GetFullMessage(ex.InnerException, stackTrace, counter + 1);
55 | msg += Environment.NewLine + Environment.NewLine;
56 | }
57 | msg += counter + " - " + ex.GetType().FullName + ": " + ex.Message + Environment.NewLine;
58 | if (stackTrace)
59 | msg += ex.StackTrace;
60 | return msg;
61 | }
62 |
63 | static String ReplaceAll(this String str, List oldChars, List newChars)
64 | {
65 | if (String.IsNullOrEmpty(str) || oldChars == null || newChars == null)
66 | return str;
67 | var builder = new StringBuilder(str);
68 | foreach (var c in oldChars)
69 | builder.Replace(c, newChars[oldChars.FindIndex(cc => cc == c)]);
70 | return builder.ToString();
71 | }
72 |
73 | public static int Count(this string str, string strToCount)
74 | {
75 | var index = str.IndexOf(strToCount);
76 | var count = 0;
77 | while (index != -1){
78 | count++;
79 | str = str.Remove(index, strToCount.Length);
80 | index = str.IndexOf(strToCount, index);
81 | }
82 | return count;
83 | }
84 |
85 | public static bool StartsWith(this string str, params string[] list)
86 | {
87 | if (str == null || list == null)
88 | return false;
89 | foreach (var item in list)
90 | if (str.StartsWith(item))
91 | return true;
92 | return false;
93 | }
94 |
95 | public static String RemoveAccents(this String str)
96 | {
97 | if (String.IsNullOrEmpty(str))
98 | return str;
99 |
100 | String lst1 = "áéíóúàèìòùäëïöüãõâêîôûçÁÉÍÓÚÀÈÌÒÙÄËÏÖÜÃÕÂÊÎÔÛÇ";
101 | String lst2 = "aeiouaeiouaeiouaoaeioucAEIOUAEIOUAEIOUAOAEIOUC";
102 | return str.ReplaceAll(lst1.ToCharArray().ToList(), lst2.ToCharArray().ToList());
103 | }
104 |
105 | public static String OnlyPathChars(this String str, Boolean toLower = false)
106 | {
107 | if (String.IsNullOrEmpty(str))
108 | return str;
109 | var charsToKeep = "0123456789abcdefghijklmnopqrstuvxwyzABCDEFGHIJKLMNOPQRSTUVXWYZ_- ().";
110 | var result = str.RemoveAccents().OnlyChars(charsToKeep, "_");
111 | return toLower? result.ToLower() : result;
112 | }
113 |
114 | public static String GetFileName(this String str, Boolean toLower = false, Boolean onlyPathChars = true)
115 | {
116 | if (String.IsNullOrEmpty(str))
117 | return str;
118 | var dirSeparators = new char[] { System.IO.Path.DirectorySeparatorChar, System.IO.Path.AltDirectorySeparatorChar };
119 | var array = str.Split(dirSeparators, StringSplitOptions.RemoveEmptyEntries);
120 | var filename = array.LastOrDefault();
121 | if (onlyPathChars)
122 | filename = filename.OnlyPathChars();
123 | return toLower ? filename.ToLower() : filename;
124 | }
125 |
126 | public static String GetFileExtension(this String str, Boolean toLower = false)
127 | {
128 | if (String.IsNullOrEmpty(str))
129 | return null;
130 | var index = str.LastIndexOf('.');
131 | if (index == -1 || index == str.Length - 1)
132 | return null;
133 | var extension = str.Substring(index).OnlyPathChars();
134 | return toLower ? extension.ToLower() : extension;
135 | }
136 |
137 | public static String OnlyChars(this String str, String charListToKeep, String replaceFor = null)
138 | {
139 | if (String.IsNullOrEmpty(str))
140 | return str;
141 | var newStr = new StringBuilder();
142 | foreach (var c in str)
143 | if (charListToKeep.Any(cc => cc == c))
144 | newStr.Append(c);
145 | else if (!String.IsNullOrEmpty(replaceFor))
146 | newStr.Append(replaceFor);
147 | return newStr.ToString();
148 | }
149 |
150 | public static String OnlyNumbers(this String str)
151 | {
152 | return str.OnlyChars("0123456789");
153 | }
154 |
155 | public static String OnlyChars(this String str)
156 | {
157 | return str.OnlyChars("abcdefghijklmnopqrstuvxwyzABCDEFGHIJKLMNOPQRSTUVXWYZ");
158 | }
159 |
160 | public static String OnlyCharsAndNumbers(this String str)
161 | {
162 | return str.OnlyChars("0123456789abcdefghijklmnopqrstuvxwyzABCDEFGHIJKLMNOPQRSTUVXWYZ");
163 | }
164 |
165 | public static StringBuilder Append(this StringBuilder sb, params String[] strValues)
166 | {
167 | if (strValues == null || strValues.Length == 0)
168 | return sb;
169 | foreach (var str in strValues)
170 | sb.Append(str);
171 | return sb;
172 | }
173 |
174 | public static StringBuilder AppendLine(this StringBuilder sb, params Object[] strValues)
175 | {
176 | if (strValues == null || strValues.Length == 0)
177 | return sb;
178 | foreach (var str in strValues)
179 | sb.Append(str);
180 | sb.AppendLine();
181 | return sb;
182 | }
183 |
184 | public static Boolean In(this T obj, params T[] values)
185 | {
186 | if (obj == null || values == null || values.Length == 0)
187 | return false;
188 | foreach (var v in values)
189 | if (obj.Equals(v))
190 | return true;
191 | return false;
192 | }
193 |
194 | public static bool Remove(this List list, Func func)
195 | {
196 | if (list == null || list.Count == 0)
197 | return false;
198 | foreach (var obj in list)
199 | if(func(obj)){
200 | list.Remove(obj);
201 | return true;
202 | }
203 | return false;
204 | }
205 |
206 | public static bool RemoveKey(this Dictionary list, T1 key)
207 | {
208 | if (list == null || list.Count == 0)
209 | return false;
210 | if (!list.ContainsKey(key))
211 | return false;
212 | list.Remove(key);
213 | return true;
214 | }
215 |
216 | public static string Encrypt(this string plainText, string key)
217 | {
218 | var r = new RijndaelEnhanced(key);
219 | return r.Encrypt(plainText);
220 | }
221 |
222 | public static string Decrypt(this string cipherText, string key)
223 | {
224 | var r = new RijndaelEnhanced(key);
225 | return r.Decrypt(cipherText);
226 | }
227 |
228 | #region datatable serializers
229 | static DataColumn[] GetColumns(DataTable dt, params string[] columns)
230 | {
231 | if (dt == null)
232 | return new DataColumn[0];
233 | return columns == null || columns.Length == 0 ?
234 | dt.Columns.Cast().ToArray():
235 | dt.Columns.Cast().Where(c1 => columns.Any(c2 => c2.ToLower() == c1.ColumnName.ToLower())).ToArray();
236 | }
237 |
238 | static string[] GetColumns(DataRow row, params string[] columns)
239 | {
240 | if (row == null)
241 | return new string[0];
242 | if(row.Table == null){
243 | var rs = new string[row.ItemArray.Length];
244 | for(var x=0; x().Select(c => c.ColumnName).ToArray() :
250 | row.Table.Columns.Cast().Where(c1 => columns.Any(c2 => c2.ToLower() == c1.ColumnName.ToLower())).Select(c => c.ColumnName).ToArray();
251 | }
252 |
253 | public static String ToCSV(this DataRow row, params string[] columns)
254 | {
255 | var lstColumns = GetColumns(row, columns);
256 | var sb = new StringBuilder();
257 | for (var x = 0; x < lstColumns.Length; x++)
258 | sb.Append("\"" + lstColumns[x], x < lstColumns.Length - 1 ? "\";" : "\"");
259 | sb.AppendLine();
260 | for (var y = 0; y < lstColumns.Length; y++)
261 | sb.Append("\"" + GetValueToCSV(row[y]), y < lstColumns.Length - 1 ? "\";" : "\"");
262 | sb.AppendLine();
263 | return sb.ToString();
264 | }
265 |
266 | public static String ToCSV(this DataTable dt, params string[] columns)
267 | {
268 | var lstColumns = GetColumns(dt, columns);
269 | var sb = new StringBuilder();
270 | for (var x = 0; x < lstColumns.Length; x++)
271 | sb.Append("\"" + lstColumns[x].ColumnName, x < lstColumns.Length - 1 ? "\";" : "\"");
272 | sb.AppendLine();
273 | for (var x = 0; x < dt.Rows.Count; x++){
274 | for (var y = 0; y < lstColumns.Length; y++)
275 | sb.Append("\"" + GetValueToCSV(dt.Rows[x][y]), y < lstColumns.Length - 1 ? "\";" : "\"");
276 | sb.AppendLine();
277 | }
278 | return sb.ToString();
279 | }
280 |
281 | public static String ToJSON(this DataRow row, params string[] columns)
282 | {
283 | var lstColumns = GetColumns(row, columns);
284 | var sb = new StringBuilder();
285 | sb.Append("{");
286 | for (var y = 0; y < lstColumns.Length; y++)
287 | sb.Append("\"", lstColumns[y], "\":", GetValueToJS(row[y]), y < lstColumns.Length - 1 ? "," : "");
288 | sb.AppendLine("}");
289 | return sb.ToString();
290 | }
291 |
292 | public static String ToJSON(this DataTable dt, params string[] columns)
293 | {
294 | var lstColumns = GetColumns(dt, columns);
295 | var sb = new StringBuilder();
296 | sb.AppendLine("[");
297 | for (var x = 0; x < dt.Rows.Count; x++){
298 | sb.Append("{");
299 | for (var y = 0; y < lstColumns.Length; y++)
300 | sb.Append("\"", lstColumns[y].ColumnName, "\":", GetValueToJS(dt.Rows[x][y]), y < lstColumns.Length - 1 ? "," : "");
301 | sb.Append("}", x < dt.Rows.Count - 1 ? "," : "");
302 | sb.AppendLine();
303 | }
304 | sb.AppendLine("]");
305 | return sb.ToString();
306 | }
307 |
308 | public static String ToXML(this DataRow row, params string[] columns)
309 | {
310 | var lstColumns = GetColumns(row, columns);
311 | var sb = new StringBuilder();
312 | sb.AppendLine("");
313 | for (var y = 0; y < lstColumns.Length; y++){
314 | var value = row[y];
315 | if (value == DBNull.Value || value == null)
316 | sb.AppendLine("<", lstColumns[y], "/>");
317 | else
318 | sb.Append("<", lstColumns[y], ">", GetValueToXML(value), "", lstColumns[y], ">");
319 | }
320 | sb.AppendLine("");
321 | return sb.ToString();
322 | }
323 |
324 | public static String ToXML(this DataTable dt, params string[] columns)
325 | {
326 | var lstColumns = GetColumns(dt, columns);
327 | var sb = new StringBuilder();
328 | sb.AppendLine("");
329 | for (var x = 0; x < dt.Rows.Count; x++){
330 | sb.AppendLine("");
331 | for (var y = 0; y < lstColumns.Length; y++){
332 | var value = dt.Rows[x][y];
333 | if (value == DBNull.Value || value == null)
334 | sb.AppendLine("<", lstColumns[y].ColumnName, "/>");
335 | else
336 | sb.AppendLine("<", lstColumns[y].ColumnName, ">", GetValueToXML(value), "", lstColumns[y].ColumnName, ">");
337 | }
338 | sb.AppendLine("
");
339 | }
340 | sb.AppendLine("");
341 | return sb.ToString();
342 | }
343 |
344 | static String GetValueToCSV(Object data)
345 | {
346 | if (data == null || data == DBNull.Value)
347 | return null;
348 | if (data is Int16 || data is Int32 || data is Int64 || data is Nullable || data is Nullable || data is Nullable)
349 | return Convert.ToString(data);
350 | if (data is Decimal || data is Single || data is Double || data is Nullable || data is Nullable || data is Nullable)
351 | return Convert.ToString(Convert.ToDecimal(Convert.ToDouble(data))).Replace(System.Globalization.NumberFormatInfo.CurrentInfo.NumberGroupSeparator, "").Replace(System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator, ".");
352 | if (data is DateTime || data is Nullable){
353 | var date = Convert.ToDateTime(data);
354 | return date.Hour != 0 || date.Minute != 0 || date.Second != 0 ? Convert.ToDateTime(data).ToString("yyyy-MM-dd HH:mm:ss") : Convert.ToDateTime(data).ToString("yyyy-MM-dd");
355 | }
356 | if (data is Boolean || data is Nullable)
357 | return Convert.ToBoolean(data) ? "True" : "False";
358 | return Convert.ToString(data).Replace("\"", "\\\"").Replace(Environment.NewLine, " ").Replace("\r\n", " ").Replace("\n", " ");
359 | }
360 |
361 | static String GetValueToXML(Object data)
362 | {
363 | var str = GetValueToCSV(data);
364 | return System.Security.SecurityElement.Escape(str);
365 | }
366 |
367 | public static string GetValueToJS(Object data)
368 | {
369 | if (data == null || data == DBNull.Value)
370 | return "null";
371 | if (data is Int16 || data is Int32 || data is Int64 || data is Nullable || data is Nullable || data is Nullable)
372 | return Convert.ToString(data);
373 | if (data is Decimal || data is Single || data is Double || data is Nullable || data is Nullable || data is Nullable)
374 | return Convert.ToString(Convert.ToDecimal(Convert.ToDouble(data))).Replace(System.Globalization.NumberFormatInfo.CurrentInfo.NumberGroupSeparator, "").Replace(System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator, ".");
375 | if (data is DateTime || data is Nullable){
376 | var date = Convert.ToDateTime(data);
377 | return date.Hour != 0 || date.Minute != 0 || date.Second != 0 ? String.Format("\"{0:yyyy-MM-dd HH:mm:ss}\"", date) : String.Format("\"{0:yyyy-MM-dd}\"", date);
378 | }
379 | if (data is Boolean || data is Nullable)
380 | return Convert.ToBoolean(data) ? "true" : "false";
381 | return "\"" + Convert.ToString(data).Replace("\"", "\\\"") + "\"";
382 | }
383 | #endregion
384 |
385 | #region sql
386 | public static String GetSQL(this String sql, params Object[] parameters)
387 | {
388 | if (String.IsNullOrEmpty(sql) || parameters == null || parameters.Length == 0)
389 | return sql;
390 |
391 | var index = -1;
392 | var sqlAux = sql.Replace("?", "@?@");
393 | var counter = 0;
394 | while (true)
395 | {
396 | index = sqlAux.IndexOf("@?@", index + 1);
397 | if (index == -1 || counter >= parameters.Length)
398 | return sqlAux.Replace("@?@", "?");
399 |
400 | var curValue = parameters[counter];
401 | var strValue = null as String;
402 | if (curValue == null)
403 | strValue = "null";
404 | else if (curValue is String)
405 | {
406 | var str = Convert.ToString(curValue);
407 | strValue = String.IsNullOrEmpty(str) ? "null" : "'" + str.Replace("'", "''") + "'";
408 | }
409 | else if (curValue.IsNumber())
410 | {
411 | var number = Convert.ToString(curValue);
412 | strValue = number.Replace(NumberFormatInfo.CurrentInfo.NumberDecimalSeparator, ".");
413 | }
414 | else if (curValue is DateTime)
415 | {
416 | var date = Convert.ToDateTime(curValue);
417 | strValue = "'" + (date.Hour == 0 && date.Minute == 0 && date.Second == 0 && date.Millisecond == 0 ? date.ToString("MM/dd/yyyy") : date.ToString("MM/dd/yyyy HH:mm:ss.fff")) + "'";
418 | }
419 | else if (curValue is Boolean)
420 | {
421 | var boolean = Convert.ToInt32(curValue);
422 | strValue = (boolean == 0 ? "0" : "1");
423 | }
424 |
425 | sqlAux = sqlAux.Remove(index, 3);
426 | sqlAux = sqlAux.Insert(index, strValue);
427 | counter++;
428 | }
429 | }
430 | #endregion
431 | }
432 | }
433 |
--------------------------------------------------------------------------------
/src/Functions/ConditionFunctions.cs:
--------------------------------------------------------------------------------
1 | using ICSharpCode.SharpZipLib.Zip;
2 | using Microsoft.WindowsAzure.Storage;
3 | using System;
4 | using System.Collections.Generic;
5 | using System.Data;
6 | using System.IO;
7 | using System.Linq;
8 | using System.Text;
9 | using System.Threading.Tasks;
10 | using System.Xml;
11 |
12 | namespace DoIt.Functions
13 | {
14 | internal class ConditionFunctions : FunctionsNodeHandlerBase
15 | {
16 | public ConditionFunctions(XmlNode node):base(node){}
17 |
18 | public override bool Execute()
19 | {
20 | if (Node == null)
21 | return false;
22 | var type = Util.GetStr(Node, "type", "").ToLower();
23 | switch(type){
24 | case "has-disk-space": return HasDiskSpace(Node);
25 | case "file-exists": return FileExists(Node);
26 | case "folder-exists": return FolderExists(Node);
27 | case "has-rows": return HasRows(Node);
28 | case "is-datetime": return IsDateTime(Node);
29 | case "if": return If(Node);
30 | }
31 | return false;
32 | }
33 |
34 |
35 | // has disk space
36 | bool HasDiskSpace(XmlNode node){
37 | var min = Util.GetStr(node, "min", "0");
38 | if (!min.IsMatch("^\\d+$"))
39 | return false;
40 | var freeSpace = Util.GetFreeSpace(Util.GetStr(node, "drive", "C:\\"));
41 | var conditionNode = Util.GetChildNode(node, freeSpace / 1024 / 1024 >= Convert.ToInt64(min) ? "True" : "False");
42 | return Program.Shared.ExecuteCommands(conditionNode);
43 | }
44 |
45 | // file exists
46 | bool FileExists(XmlNode node){
47 | var path = Util.GetStr(node, "path", "");
48 | if (string.IsNullOrEmpty(path))
49 | return false;
50 | var conditionNode = Util.GetChildNode(node, File.Exists(Program.Shared.ReplaceTags(path)) ? "True" : "False");
51 | return Program.Shared.ExecuteCommands(conditionNode);
52 | }
53 |
54 | // folder exists
55 | bool FolderExists(XmlNode node){
56 | var path = Util.GetStr(node, "path", "");
57 | if (string.IsNullOrEmpty(path))
58 | return false;
59 | var conditionNode = Util.GetChildNode(node, Directory.Exists(Program.Shared.ReplaceTags(path)) ? "True" : "False");
60 | return Program.Shared.ExecuteCommands(conditionNode);
61 | }
62 |
63 | // has rows
64 | bool HasRows(XmlNode node){
65 | var data = Util.GetStr(node, "data");
66 | var dt = Program.Shared.GetDataTable(Program.Shared.ThreadID(), data);
67 | var conditionNode = Util.GetChildNode(node, dt != null && dt.Rows.Count > 0 ? "True" : "False");
68 | return Program.Shared.ExecuteCommands(conditionNode);
69 | }
70 |
71 | // is date/time
72 | bool IsDateTime(XmlNode node){
73 | var days = Util.GetStr(node, "days", "all");
74 | var time = Util.GetStr(node, "time");
75 | var conditionNode = Util.GetChildNode(node, Util.IsTodayInList(days) && Util.IsTimeToRun(time) ? "True" : "False");
76 | return Program.Shared.ExecuteCommands(conditionNode);
77 | }
78 |
79 | // if
80 | bool If(XmlNode node){
81 | var value1 = Program.Shared.ReplaceTags(Util.GetStr(node, "value1"));
82 | var value2 = Program.Shared.ReplaceTags(Util.GetStr(node, "value2"));
83 | var comparison = Util.GetStr(node, "comparison", "equals").ToLower();
84 | var valueType = Util.GetStr(node, "valueType", "string").ToLower();
85 | var result = false;
86 | if(valueType == "string"){
87 | switch (comparison){
88 | case "equals": result = string.Compare(value1, value2) == 0; break;
89 | case "less": result = string.Compare(value1, value2) < 0; break;
90 | case "greater": result = string.Compare(value1, value2) > 0; break;
91 | }
92 | }else if (valueType == "numeric"){
93 | var v1 = string.IsNullOrEmpty(value1) || !value1.IsNumber() ? null : new Nullable(Convert.ToDecimal(value1));
94 | var v2 = string.IsNullOrEmpty(value2) || !value2.IsNumber() ? null : new Nullable(Convert.ToDecimal(value2));
95 | switch (comparison){
96 | case "equals": result = v1 == v2; break;
97 | case "less": result = v1 < v2; break;
98 | case "greater": result = v1 > v2; break;
99 | }
100 | }else if (valueType == "date"){
101 | var v1 = Util.ParseDateTime(value1);
102 | var v2 = Util.ParseDateTime(value2);
103 | switch (comparison){
104 | case "equals": result = v1 == v2; break;
105 | case "less": result = v1 < v2; break;
106 | case "greater": result = v1 > v2; break;
107 | }
108 | }
109 | return Program.Shared.ExecuteCommands(Util.GetChildNode(node, result ? "True" : "False"));
110 | }
111 | }
112 | }
113 |
--------------------------------------------------------------------------------
/src/Functions/CsvFunctions.cs:
--------------------------------------------------------------------------------
1 | using ICSharpCode.SharpZipLib.Zip;
2 | using LumenWorks.Framework.IO.Csv;
3 | using Microsoft.WindowsAzure.Storage;
4 | using System;
5 | using System.Collections.Generic;
6 | using System.Data;
7 | using System.IO;
8 | using System.Linq;
9 | using System.Text;
10 | using System.Threading.Tasks;
11 | using System.Xml;
12 |
13 | namespace DoIt.Functions
14 | {
15 | internal class CsvFunctions : FunctionsNodeHandlerBase
16 | {
17 | public CsvFunctions(XmlNode node):base(node){}
18 |
19 | public override bool Execute()
20 | {
21 | if (Node == null)
22 | return false;
23 | var path = Program.Shared.ReplaceTags(Util.GetStr(Node, "path"));
24 | var separator = Util.GetStr(Node, "separator", ";");
25 | if (string.IsNullOrEmpty(path))
26 | return false;
27 | var lstNodes = Util.GetChildNodes(Node, "WriteLine", "WriteData", "Load");
28 | foreach (var n in lstNodes)
29 | switch (n.Name.ToLower()){
30 | case "writeline": WriteLine(path, separator, n); break;
31 | case "writedata": WriteData(path, separator, n); break;
32 | case "load": Load(path, separator, n); break;
33 | }
34 | return true;
35 | }
36 |
37 | // write line
38 | void WriteLine(string path, string separator, XmlNode n){
39 | var append = Util.GetStr(n, "append", "true").ToLower() == "true";
40 | var lstColumns = Util.GetChildNodes(n, "Column").Select(n2 => Program.Shared.ReplaceTags(n2.InnerXml)).ToArray();
41 | if (!Directory.Exists(Path.GetDirectoryName(path)))
42 | Directory.CreateDirectory(Path.GetDirectoryName(path));
43 | using (var fw = new FileStream(path, append ? FileMode.Append : FileMode.Create, FileAccess.Write))
44 | using (var sw = new StreamWriter(fw, Encoding.Default)){
45 | for (var x=0; x().ToDictionary(c => c.ColumnName, c => c.ColumnName) :
68 | columnsNodes.Select(n2 => new { Header = Util.GetStr(n2, "header"), Value = Program.Shared.ReplaceTags(n2.InnerXml) }).Where(n2 => !string.IsNullOrEmpty(n2.Value)).ToDictionary(n2 => n2.Header, n2 => n2.Value);
69 | var lastColumn = lstColumns.Keys.LastOrDefault();
70 | if (!Directory.Exists(Path.GetDirectoryName(path)))
71 | Directory.CreateDirectory(Path.GetDirectoryName(path));
72 | using (var fw = new FileStream(path, append ? FileMode.Append : FileMode.Create, FileAccess.Write))
73 | using (var sw = new StreamWriter(fw, Encoding.Default)){
74 | foreach (var c in lstColumns.Keys){
75 | sw.Write("\""+c.Replace("\"","\"\"")+"\"");
76 | if (c != lastColumn)
77 | sw.Write(separator);
78 | }
79 | sw.WriteLine();
80 | var lstRows = string.IsNullOrEmpty(where) ? datatable.Rows.Cast().ToArray() : datatable.Select(where, sort);
81 | foreach (DataRow r in lstRows){
82 | foreach (var c in lstColumns.Keys){
83 | sw.Write("\""+ (r[c] == null || r[c] == DBNull.Value ? "" : Convert.ToString(r[c]).Replace("\"","\"\"")) +"\"");
84 | if (c != lastColumn)
85 | sw.Write(separator);
86 | }
87 | sw.WriteLine();
88 | }
89 | }
90 | }
91 |
92 | // load
93 | void Load(string path, string separator, XmlNode n){
94 | var to = Program.Shared.ReplaceTags(Util.GetStr(n, "to"));
95 | if (string.IsNullOrEmpty(to))
96 | return;
97 | var hasHeaders = Util.GetStr(n, "hasHeaders", "true").ToLower() == "true";
98 | var where = Program.Shared.ReplaceTags(Util.GetStr(n, "where"));
99 | var dt = new DataTable();
100 | using (var sr = new StreamReader(path, Encoding.Default))
101 | using (var csv = new CsvReader(sr, hasHeaders, separator[0])){
102 | if (hasHeaders)
103 | foreach (var h in csv.GetFieldHeaders())
104 | dt.Columns.Add(h);
105 | if (dt.Columns.Count == 0)
106 | for (var x = 0; x < csv.FieldCount; x++)
107 | dt.Columns.Add("Column" + (x+1));
108 | while (csv.ReadNextRecord()){
109 | var rowData = new string[csv.FieldCount];
110 | for (var x = 0; x < rowData.Length; x++)
111 | rowData[x] = csv[x];
112 | dt.Rows.Add(rowData);
113 | }
114 | }
115 | lock (Program.Shared.LockDataTables){
116 | Program.Shared.DataTables[to+";"+Program.Shared.GetSequence()] = dt;
117 | }
118 | }
119 | }
120 | }
121 |
--------------------------------------------------------------------------------
/src/Functions/DataTableFunctions.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Data;
4 | using System.Linq;
5 | using System.Text;
6 | using System.Threading.Tasks;
7 | using System.Xml;
8 |
9 | namespace DoIt.Functions
10 | {
11 | internal class DataTableFunctions : FunctionsNodeHandlerBase
12 | {
13 | public DataTableFunctions(XmlNode node):base(node){}
14 |
15 | public override bool Execute()
16 | {
17 | if (Node == null)
18 | return false;
19 | var lstNodes = Util.GetChildNodes(Node, "Count", "Sum", "Avg", "Max", "Min", "SetRowValue", "GetDataRow", "Diff", "Join", "Intersect", "RemoveRows", "InsertRow", "Filter", "Copy");
20 | foreach (var n in lstNodes)
21 | switch (n.Name.ToLower()){
22 | case "count": Count(n); break;
23 | case "sum": Sum(n); break;
24 | case "avg": Avg(n); break;
25 | case "max": Max(n); break;
26 | case "min": Min(n); break;
27 | case "setrowvalue": SetRowValue(n); break;
28 | case "getdatarow": GetDataRow(n); break;
29 | case "diff": Diff(n); break;
30 | case "join": Join(n); break;
31 | case "intersect": Intersect(n); break;
32 | case "removerows": RemoveRows(n); break;
33 | case "insertrow": InsertRow(n); break;
34 | case "filter": Filter(n); break;
35 | case "copy": Copy(n); break;
36 | }
37 | return true;
38 | }
39 |
40 | // count
41 | void Count(XmlNode n){
42 | var data = Util.GetStr(n, "data");
43 | var where = Util.GetStr(n, "where");
44 | var to = Util.GetStr(n, "to");
45 | var dt = Program.Shared.GetDataTable(Program.Shared.ThreadID(), data);
46 | var count = string.IsNullOrEmpty(where) ? dt.Rows.Count : dt.Select(where).Length;
47 | lock (Program.Shared.LockVariables){
48 | Program.Shared.Variables[to+";"+ Program.Shared.GetSequence()] = count;
49 | }
50 | Program.Shared.WriteLogLine(string.Format("Count set from \"{0}\" where \"{1}\" to variable \"{2}\" (count = {3})", data, where, to, count));
51 | }
52 |
53 | // sum
54 | void Sum(XmlNode n){
55 | var data = Util.GetStr(n, "data");
56 | var column = Util.GetStr(n, "column");
57 | var where = Util.GetStr(n, "where");
58 | var to = Util.GetStr(n, "to");
59 | var dt = Program.Shared.GetDataTable(Program.Shared.ThreadID(), data);
60 | var lstRows = string.IsNullOrEmpty(where) ? dt.Rows.Cast().ToList() : dt.Select(where).ToList();
61 | var sum = lstRows.Where(r => r[column] != DBNull.Value).Sum(r => Convert.ToDecimal(r[column]));
62 | lock (Program.Shared.LockVariables){
63 | Program.Shared.Variables[to+";"+Program.Shared.GetSequence()] = sum;
64 | }
65 | Program.Shared.WriteLogLine(string.Format("Sum set from \"{0}.{1}\" where \"{2}\" to variable \"{3}\" (sum = {4}).", data, column, where, to, sum));
66 | }
67 |
68 | // avg
69 | void Avg(XmlNode n){
70 | var data = Util.GetStr(n, "data");
71 | var column = Util.GetStr(n, "column");
72 | var where = Util.GetStr(n, "where");
73 | var to = Util.GetStr(n, "to");
74 | var dt = Program.Shared.GetDataTable(Program.Shared.ThreadID(), data);
75 | var lstRows = string.IsNullOrEmpty(where) ? dt.Rows.Cast().ToList() : dt.Select(where).ToList();
76 | var avg = lstRows.Where(r => r[column] != DBNull.Value).Average(r => Convert.ToDecimal(r[column]));
77 | lock (Program.Shared.LockVariables){
78 | Program.Shared.Variables[to+";"+Program.Shared.GetSequence()] = avg;
79 | }
80 | Program.Shared.WriteLogLine(string.Format("Avg set from \"{0}.{1}\" where \"{2}\" to variable \"{3}\" (avg = {4})", data, column, where, to, avg));
81 | }
82 |
83 | // max
84 | void Max(XmlNode n){
85 | var data = Util.GetStr(n, "data");
86 | var column = Util.GetStr(n, "column");
87 | var where = Util.GetStr(n, "where");
88 | var to = Util.GetStr(n, "to");
89 | var dt = Program.Shared.GetDataTable(Program.Shared.ThreadID(), data);
90 | var lstRows = string.IsNullOrEmpty(where) ? dt.Rows.Cast().ToList() : dt.Select(where).ToList();
91 | var cType = dt.Columns[column].DataType.Name;
92 | var max = null as object;
93 | if (cType.In("Byte","Int16","Int32","Int64","Decimal","Single","Double"))
94 | max = lstRows.Where(r => r[column] != DBNull.Value).Max(r => Convert.ToDecimal(r[column]));
95 | else if (cType.In("DateTime"))
96 | max = lstRows.Where(r => r[column] != DBNull.Value).Max(r => Convert.ToDateTime(r[column]));
97 | else
98 | max = lstRows.Where(r => r[column] != DBNull.Value).Max(r => Convert.ToString(r[column]));
99 | lock (Program.Shared.LockVariables){
100 | Program.Shared.Variables[to+";"+Program.Shared.GetSequence()] = max;
101 | }
102 | Program.Shared.WriteLogLine(string.Format("Max set from \"{0}.{1}\" where \"{2}\" to variable \"{3}\" (max = {4})", data, column, where, to, max));
103 | }
104 |
105 | // min
106 | void Min(XmlNode n){
107 | var data = Util.GetStr(n, "data");
108 | var column = Util.GetStr(n, "column");
109 | var where = Util.GetStr(n, "where");
110 | var to = Util.GetStr(n, "to");
111 | var dt = Program.Shared.GetDataTable(Program.Shared.ThreadID(), data);
112 | var lstRows = string.IsNullOrEmpty(where) ? dt.Rows.Cast().ToList() : dt.Select(where).ToList();
113 | var cType = dt.Columns[column].DataType.Name;
114 | var min = null as object;
115 | if (cType.In("Byte","Int16","Int32","Int64","Decimal","Single","Double"))
116 | min = lstRows.Where(r => r[column] != DBNull.Value).Min(r => Convert.ToDecimal(r[column]));
117 | else if (cType.In("DateTime"))
118 | min = lstRows.Where(r => r[column] != DBNull.Value).Min(r => Convert.ToDateTime(r[column]));
119 | else
120 | min = lstRows.Where(r => r[column] != DBNull.Value).Min(r => Convert.ToString(r[column]));
121 | lock (Program.Shared.LockVariables){
122 | Program.Shared.Variables[to+";"+Program.Shared.GetSequence()] = min;
123 | }
124 | Program.Shared.WriteLogLine(string.Format("Min set from \"{0}.{1}\" where \"{2}\" to variable \"{3}\" (min = {4})", data, column, where, to, min));
125 | }
126 |
127 | // set row value
128 | void SetRowValue(XmlNode n){
129 | var data = Util.GetStr(n, "data");
130 | var row = Util.GetStr(n, "row");
131 | var where = Program.Shared.ReplaceTags(Util.GetStr(n, "where"));
132 | var lstColumns = Util.GetChildNodes(n, "Column").Select(n2 => new { Name = Util.GetStr(n2, "name"), Type = Util.GetStr(n2, "type"), Value = Program.Shared.ReplaceTags(n2.InnerXml) }).ToArray();
133 | var dt = string.IsNullOrEmpty(data) ? null : Program.Shared.GetDataTable(Program.Shared.ThreadID(), data);
134 | var r1 = string.IsNullOrEmpty(row) ? null : Program.Shared.GetVariable(Program.Shared.ThreadID(), row) as Dictionary;
135 | var r2 = string.IsNullOrEmpty(row) ? null : Program.Shared.GetCurrentRow(Program.Shared.ThreadID(), row);
136 | if (dt == null)
137 | return;
138 | if (r1 != null)
139 | lock (Program.Shared.LockDataTables){
140 | var index = Convert.ToInt32(r1["$RowIndex"]);
141 | var r = index < dt.Rows.Count ? dt.Rows[index] : null;
142 | if (r != null)
143 | foreach (var c in lstColumns){
144 | if (!dt.Columns.Contains(c.Name))
145 | dt.Columns.Add(c.Name, Util.GetType(c.Type));
146 | var value = Util.GetValue(c.Value, c.Type) ?? DBNull.Value;
147 | r[c.Name] = r1[c.Name] = value;
148 | }
149 | }
150 | if (r2 != null)
151 | lock (Program.Shared.LockDataTables)
152 | foreach (var c in lstColumns){
153 | if (!dt.Columns.Contains(c.Name))
154 | dt.Columns.Add(c.Name, Util.GetType(c.Type));
155 | r2[c.Name] = Util.GetValue(c.Value, c.Type) ?? DBNull.Value;
156 | }
157 | if (r1 == null && r2 == null){
158 | var lstRows = string.IsNullOrEmpty(where) ? dt.Rows.Cast().ToArray() : dt.Select(where);
159 | foreach (var c in lstColumns){
160 | lock (Program.Shared.LockDataTables){
161 | if (!dt.Columns.Contains(c.Name))
162 | dt.Columns.Add(c.Name, Util.GetType(c.Type));
163 | foreach (DataRow r in lstRows)
164 | r[c.Name] = Util.GetValue(c.Value, c.Type) ?? DBNull.Value;
165 | }
166 | }
167 | }
168 | }
169 |
170 | // get datarow
171 | void GetDataRow(XmlNode n){
172 | var fromData = Util.GetStr(n, "fromData");
173 | var to = Util.GetStr(n, "to");
174 | var where = Program.Shared.ReplaceTags(Util.GetStr(n, "where"));
175 | var sort = Program.Shared.ReplaceTags(Util.GetStr(n, "sort"));
176 | var index = Util.GetStr(n, "index", "0");
177 | var lst = new Dictionary();
178 | var dt = Program.Shared.GetDataTable(Program.Shared.ThreadID(), fromData);
179 | var rows = dt.Select(where, sort);
180 | var x = index.ToLower() == "last" ? rows.Length - 1 : Convert.ToInt32(index);
181 | var r = rows.Length == 0 || x > rows.Length - 1 ? null : rows[x];
182 | foreach (DataColumn c in dt.Columns)
183 | lst[c.ColumnName] = r == null ? null : r[c];
184 | lst["$RowIndex"] = r == null ? -1 : dt.Rows.IndexOf(r);
185 | lock (Program.Shared.LockVariables){
186 | Program.Shared.Variables[to+";"+Program.Shared.GetSequence()] = lst;
187 | }
188 | }
189 |
190 | // diff
191 | void Diff(XmlNode n){
192 | var to = Util.GetStr(n, "to");
193 | var inData = Util.GetStr(n, "inData");
194 | var notInData = Util.GetStr(n, "notInData");
195 | var columns = Util.GetStr(n, "columns");
196 | var lstColumns = columns.Split(new char[] { ',', ';', ' ' }, StringSplitOptions.RemoveEmptyEntries);
197 | var inDT = Program.Shared.DataTables[inData + ";" + Program.Shared.GetSequence()];
198 | var notInDT = Program.Shared.DataTables[notInData + ";" + Program.Shared.GetSequence()];
199 | var dt = new DataTable();
200 | foreach (DataColumn c in inDT.Columns)
201 | dt.Columns.Add(c.ColumnName, c.DataType);
202 | var lstRows = inDT.Rows.Cast().Where(r1 => !notInDT.Rows.Cast().Any(r2 => lstColumns.All(c => Convert.ToString(r1[c]) == Convert.ToString(r2[c])))).ToList();
203 | foreach (DataRow r in lstRows)
204 | dt.Rows.Add(r.ItemArray);
205 | lock (Program.Shared.LockDataTables){
206 | Program.Shared.DataTables[to+";"+Program.Shared.GetSequence()] = dt;
207 | }
208 | Program.Shared.WriteLogLine("DataTable diff to \"{0}\" comparing columns \"{1}\", in data \"{2}\" / not in data \"{3}\" - Resulting Rows: {4}", to, columns, inData, notInData, dt.Rows.Count);
209 | }
210 |
211 | // join
212 | void Join(XmlNode n){
213 | var data = Util.GetStr(n, "data");
214 | var to = Util.GetStr(n, "to");
215 | var lstData = data.Split(new char[] { ',', ';', ' ' }, StringSplitOptions.RemoveEmptyEntries);
216 | var lstDT = new DataTable[lstData.Length];
217 | for (var x = 0; x < lstData.Length; x++)
218 | lstDT[x] = Program.Shared.GetDataTable(Program.Shared.ThreadID(), lstData[x]);
219 | var dt = new DataTable();
220 | foreach (DataTable d in lstDT)
221 | foreach (DataColumn c in d.Columns)
222 | if (!dt.Columns.Contains(c.ColumnName))
223 | dt.Columns.Add(c.ColumnName, c.DataType);
224 | foreach (DataTable d in lstDT)
225 | foreach (DataRow r in d.Rows){
226 | var newRow = dt.NewRow();
227 | foreach (DataColumn c in d.Columns)
228 | newRow[c.ColumnName] = r[c.ColumnName];
229 | dt.Rows.Add(newRow);
230 | }
231 | lock (Program.Shared.LockDataTables){
232 | Program.Shared.DataTables[to+";"+Program.Shared.GetSequence()] = dt;
233 | }
234 | Program.Shared.WriteLogLine("DataTable join to \"{0}\", from data \"{1}\" - Resulting Rows: {2}", to, data, dt.Rows.Count);
235 | }
236 |
237 | // intersect
238 | void Intersect(XmlNode n){
239 | var data = Util.GetStr(n, "data");
240 | var to = Util.GetStr(n, "to");
241 | var columns = Util.GetStr(n, "columns");
242 | var rowsFrom = Convert.ToInt32(Util.GetStr(n, "rowsFrom", "0"));
243 | var lstData = data.Split(new char[] { ',', ';', ' ' }, StringSplitOptions.RemoveEmptyEntries);
244 | var lstColumns = columns.Split(new char[] { ',', ';', ' ' }, StringSplitOptions.RemoveEmptyEntries);
245 | if (lstData.Length == 0 || lstColumns.Length == 0)
246 | return;
247 | var lstDT = new DataTable[lstData.Length];
248 | for (var x = 0; x < lstData.Length; x++)
249 | lstDT[x] = Program.Shared.GetDataTable(Program.Shared.ThreadID(), lstData[x]);
250 | var dt = new DataTable();
251 | foreach (DataColumn c in lstDT[rowsFrom].Columns)
252 | if (!dt.Columns.Contains(c.ColumnName))
253 | dt.Columns.Add(c.ColumnName, c.DataType);
254 | var lstRows = lstDT[rowsFrom].Rows.Cast().ToArray();
255 | foreach (var r in lstRows){
256 | var rowMatch = true;
257 | for (var x = 0; x < lstDT.Length; x++){
258 | if (x == rowsFrom)
259 | continue;
260 | if(!lstDT[x].Rows.Cast().Any(r2 => lstColumns.All(c => Convert.ToString(r2[c])== Convert.ToString(r[c])))){
261 | rowMatch = false;
262 | break;
263 | }
264 | }
265 | if (rowMatch){
266 | var newRow = dt.NewRow();
267 | foreach (DataColumn col in dt.Columns)
268 | newRow[col.ColumnName] = r[col.ColumnName];
269 | dt.Rows.Add(newRow);
270 | }
271 | }
272 | lock (Program.Shared.LockDataTables){
273 | Program.Shared.DataTables[to+";"+Program.Shared.GetSequence()] = dt;
274 | }
275 | Program.Shared.WriteLogLine("DataTable intersect to \"{0}\", from data \"{1}\" comparing columns \"{2}\" - Resulting Rows: {3}", to, data, columns, dt.Rows.Count);
276 | }
277 |
278 | // remove rows
279 | void RemoveRows(XmlNode n){
280 | var from = Util.GetStr(n, "from");
281 | if (string.IsNullOrEmpty(from))
282 | return;
283 | var where = Program.Shared.ReplaceTags(Util.GetStr(n, "where"));
284 | var dt = Program.Shared.GetDataTable(Program.Shared.ThreadID(), from);
285 | if (dt == null)
286 | return;
287 | if (string.IsNullOrEmpty(where)){
288 | dt.Rows.Clear();
289 | return;
290 | }
291 | var lstRows = dt.Select(where);
292 | foreach (var r in lstRows)
293 | dt.Rows.Remove(r);
294 | }
295 |
296 | // insert a new row
297 | void InsertRow(XmlNode n){
298 | var to = Util.GetStr(n, "to");
299 | if (string.IsNullOrEmpty(to))
300 | return;
301 | var lstColumns = Util.GetChildNodes(n, "Column").Select(n2 => new {Name=Util.GetStr(n2, "name"), Type=Util.GetStr(n2, "type"), Value=Program.Shared.ReplaceTags(n2.InnerXml)}).ToArray();
302 | var dt = Program.Shared.GetDataTable(Program.Shared.ThreadID(), to);
303 | if (dt == null)
304 | return;
305 | var r = dt.NewRow();
306 | foreach (var c in lstColumns){
307 | if (!dt.Columns.Contains(c.Name))
308 | dt.Columns.Add(c.Name, Util.GetType(c.Type));
309 | r[c.Name] = Util.GetValue(c.Value, c.Type);
310 | }
311 | dt.Rows.Add(r);
312 | }
313 |
314 | // filter rows
315 | void Filter(XmlNode n){
316 | var data = Util.GetStr(n, "data");
317 | if (string.IsNullOrEmpty(data))
318 | return;
319 | var to = Util.GetStr(n, "to", data);
320 | var where = Program.Shared.ReplaceTags(Util.GetStr(n, "where"));
321 | var sort = Program.Shared.ReplaceTags(Util.GetStr(n, "sort"));
322 | var dt = Program.Shared.GetDataTable(Program.Shared.ThreadID(), data);
323 | if (dt == null)
324 | return;
325 | var newDT = new DataTable(){TableName=dt.TableName};
326 | foreach (DataColumn c in dt.Columns.Cast().Where(col => string.IsNullOrEmpty(col.Expression)).ToArray())
327 | newDT.Columns.Add(c.ColumnName, c.DataType);
328 | var lstRows = dt.Select(where, sort);
329 | foreach (var r in lstRows)
330 | newDT.Rows.Add(r.ItemArray);
331 | lock (Program.Shared.LockDataTables){
332 | Program.Shared.DataTables[to+";"+Program.Shared.GetSequence()] = newDT;
333 | }
334 | }
335 |
336 | // copy datatable
337 | void Copy(XmlNode n)
338 | {
339 | var data = Util.GetStr(n, "data");
340 | if (string.IsNullOrEmpty(data))
341 | return;
342 | var to = Util.GetStr(n, "to");
343 | if (string.IsNullOrEmpty(to))
344 | return;
345 | var dt = Program.Shared.GetDataTable(Program.Shared.ThreadID(), data);
346 | if (dt == null)
347 | return;
348 | var newDT = dt.Copy();
349 | lock (Program.Shared.LockDataTables){
350 | Program.Shared.DataTables[to+";"+Program.Shared.GetSequence()] = newDT;
351 | }
352 | }
353 | }
354 | }
355 |
--------------------------------------------------------------------------------
/src/Functions/DatabaseFunctions.cs:
--------------------------------------------------------------------------------
1 | using ICSharpCode.SharpZipLib.Zip;
2 | using LumenWorks.Framework.IO.Csv;
3 | using Microsoft.WindowsAzure.Storage;
4 | using System;
5 | using System.Collections.Generic;
6 | using System.Data;
7 | using System.IO;
8 | using System.Linq;
9 | using System.Text;
10 | using System.Threading.Tasks;
11 | using System.Xml;
12 |
13 | namespace DoIt.Functions
14 | {
15 | internal class DatabaseFunctions : FunctionsNodeHandlerBase
16 | {
17 | public DatabaseFunctions(XmlNode node):base(node){}
18 |
19 | public override bool Execute()
20 | {
21 | if (Node == null)
22 | return false;
23 | var id = Util.GetStr(Node, "id");
24 | var lstNodes = Util.GetChildNodes(Node, "Backup", "BackupLog");
25 | foreach (var n in lstNodes)
26 | switch (n.Name.ToLower())
27 | {
28 | case "backup": Backup(n, id); break;
29 | case "backuplog": BackupLog(n, id); break;
30 | }
31 | return true;
32 | }
33 |
34 | void Backup(XmlNode n, string id)
35 | {
36 | var toFile = Program.Shared.ReplaceTags(Util.GetStr(n, "toFile"));
37 | var type = Program.Shared.ReplaceTags(Util.GetStr(n, "type", "bacpac"));
38 | var connStr = Program.Shared.Databases[id];
39 | var dbName = Util.GetConfigData(connStr, "Initial Catalog");
40 | Program.Shared.WriteLogLine("Starting Database Backup.");
41 | if (type.ToLower() == "bacpac"){
42 | var ds = new Microsoft.SqlServer.Dac.DacServices(connStr);
43 | ds.ExportBacpac(toFile, dbName);
44 | }else if (type.ToLower() == "bak"){
45 | var timeout = Util.GetStr(n, "timeout", "1800").IsNumber()?Convert.ToInt32(Util.GetStr(n, "timeout", "1800")):1800;
46 | var withOptions = Util.GetStr(n, "withOptions");
47 | Util.Execute("backup database " + dbName + " to disk='" + toFile + "' " + withOptions, connStr, timeout);
48 | }
49 | Program.Shared.DbBackups.Add(toFile);
50 | var toVar = Util.GetStr(n, "toVar");
51 | if (!string.IsNullOrEmpty(toVar))
52 | lock (Program.Shared.LockVariables) { Program.Shared.Variables[toVar + ";" + Program.Shared.GetSequence()] = toFile; }
53 | Program.Shared.WriteLogLine(String.Format("Finished Database Backup (File: {0}; Size: {1}).", toFile, Util.GetFileSize(new FileInfo(toFile).Length)));
54 | }
55 |
56 | void BackupLog(XmlNode n, string id)
57 | {
58 | var toFile = Program.Shared.ReplaceTags(Util.GetStr(n, "toFile"));
59 | var connStr = Program.Shared.Databases[id];
60 | var dbName = Util.GetConfigData(connStr, "Initial Catalog");
61 | Program.Shared.WriteLogLine("Starting Database Log Backup.");
62 | var timeout = Util.GetStr(n, "timeout", "1800").IsNumber()?Convert.ToInt32(Util.GetStr(n, "timeout", "1800")):1800;
63 | var withOptions = Util.GetStr(n, "withOptions");
64 | Util.Execute("backup log " + dbName + " to disk='" + toFile + "' " + withOptions, connStr, timeout);
65 | Program.Shared.DbBackups.Add(toFile);
66 | var toVar = Util.GetStr(n, "toVar");
67 | if (!string.IsNullOrEmpty(toVar))
68 | lock (Program.Shared.LockVariables) { Program.Shared.Variables[toVar + ";" + Program.Shared.GetSequence()] = toFile; }
69 | Program.Shared.WriteLogLine(String.Format("Finished Database Log Backup (File: {0}; Size: {1}).", toFile, Util.GetFileSize(new FileInfo(toFile).Length)));
70 | }
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/src/Functions/ExceptionFunctions.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Data;
4 | using System.IO;
5 | using System.Linq;
6 | using System.Reflection;
7 | using System.Text;
8 | using System.Xml;
9 |
10 | namespace DoIt.Functions
11 | {
12 | internal class ExceptionFunctions : FunctionsNodeHandlerBase
13 | {
14 | public ExceptionFunctions(XmlNode node):base(node){}
15 |
16 | public override bool Execute()
17 | {
18 | if (Node == null)
19 | return false;
20 | var assembly = Util.GetStr(Node, "assembly");
21 | var type = Util.GetStr(Node, "type", "System.Exception");
22 | var message = Util.GetStr(Node, "message");
23 | var asm = null as Assembly;
24 | if (string.IsNullOrEmpty(assembly))
25 | asm = Assembly.GetExecutingAssembly();
26 | else{
27 | var asmName = Assembly.GetExecutingAssembly().GetReferencedAssemblies().FirstOrDefault(item => item.Name.ToLower() == assembly.ToLower());
28 | asm = asmName != null ? Assembly.Load(asmName) : Assembly.LoadFrom(Path.IsPathRooted(assembly) ? assembly : Path.Combine(AppDomain.CurrentDomain.BaseDirectory, assembly));
29 | }
30 | if (asm == null)
31 | return false;
32 | var exType = Type.GetType(type) ?? asm.GetType(type);
33 | var ctor = exType.GetConstructor(new[]{typeof(string)});
34 | throw ctor.Invoke(new object[]{message}) as Exception;
35 | }
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/src/Functions/ForEachFunctions.cs:
--------------------------------------------------------------------------------
1 | using ICSharpCode.SharpZipLib.Zip;
2 | using LumenWorks.Framework.IO.Csv;
3 | using Microsoft.WindowsAzure.Storage;
4 | using System;
5 | using System.Collections.Generic;
6 | using System.Data;
7 | using System.IO;
8 | using System.Linq;
9 | using System.Text;
10 | using System.Threading;
11 | using System.Threading.Tasks;
12 | using System.Xml;
13 |
14 | namespace DoIt.Functions
15 | {
16 | internal class ForEachFunctions : FunctionsNodeHandlerBase
17 | {
18 | public ForEachFunctions(XmlNode node):base(node){}
19 |
20 | public override bool Execute()
21 | {
22 | var itemFrom = Program.Shared.ReplaceTags(Util.GetStr(Node, "itemFrom"));
23 | if (string.IsNullOrEmpty(itemFrom))
24 | return false;
25 | var where = Program.Shared.ReplaceTags(Util.GetStr(Node, "where"));
26 | var sort = Program.Shared.ReplaceTags(Util.GetStr(Node, "sort"));
27 | var parallel = Convert.ToInt32(Util.GetStr(Node, "parallel", "1"));
28 | var dt = Program.Shared.GetDataTable(Program.Shared.ThreadID(), itemFrom);
29 | if (dt == null)
30 | return false;
31 | var lstRows = string.IsNullOrEmpty(where) && string.IsNullOrEmpty(sort) ? dt.Rows.Cast().ToArray() : dt.Select(where, sort);
32 | if(parallel > 1){
33 | var parentSequence = Program.Shared.GetSequence();
34 | Task task = Task.Run(() => Parallel.ForEach(lstRows, new ParallelOptions{MaxDegreeOfParallelism=parallel}, (r, state) => {
35 | var sequence = parentSequence + "." + Program.Shared.ThreadID();
36 | lock (Program.Shared.LockSequence){
37 | if (Thread.CurrentThread.Name == null){
38 | Thread.CurrentThread.Name = sequence;
39 | Program.Shared.ThreadSequence.Add(sequence);
40 | }
41 | }
42 | var itemID = itemFrom+";"+sequence;
43 | lock(Program.Shared.LockCurrentRows){
44 | Program.Shared.CurrentRows[itemID] = r;
45 | }
46 | var stop = Program.Shared.ExecuteCommands(Node);
47 | lock(Program.Shared.LockCurrentRows){
48 | Program.Shared.CurrentRows.RemoveKey(itemID);
49 | }
50 | if (stop)
51 | state.Stop();
52 | }));
53 | task.Wait();
54 | }else{
55 | var itemID = itemFrom+";"+ Program.Shared.GetSequence();
56 | foreach (DataRow r in lstRows){
57 | lock(Program.Shared.LockCurrentRows)
58 | Program.Shared.CurrentRows[itemID] = r;
59 | if (Program.Shared.ExecuteCommands(Node))
60 | break;
61 | }
62 | lock(Program.Shared.LockCurrentRows)
63 | Program.Shared.CurrentRows.RemoveKey(itemID);
64 | }
65 | return true;
66 | }
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/src/Functions/FtpFunctions.cs:
--------------------------------------------------------------------------------
1 | using ICSharpCode.SharpZipLib.Zip;
2 | using LumenWorks.Framework.IO.Csv;
3 | using Microsoft.WindowsAzure.Storage;
4 | using System;
5 | using System.Collections.Generic;
6 | using System.Data;
7 | using System.IO;
8 | using System.Linq;
9 | using System.Net;
10 | using System.Text;
11 | using System.Text.RegularExpressions;
12 | using System.Threading.Tasks;
13 | using System.Xml;
14 |
15 | namespace DoIt.Functions
16 | {
17 | internal class FtpFunctions : FunctionsNodeHandlerBase
18 | {
19 | public FtpFunctions(XmlNode node):base(node){}
20 |
21 | public override bool Execute()
22 | {
23 | if (Node == null)
24 | return false;
25 | var host = Program.Shared.ReplaceTags(Util.GetStr(Node, "host"));
26 | var port = Program.Shared.ReplaceTags(Util.GetStr(Node, "port", "21"));
27 | var user = Program.Shared.ReplaceTags(Util.GetStr(Node, "user"));
28 | var pass = Program.Shared.ReplaceTags(Util.GetStr(Node, "password"));
29 | var lstNodes = Util.GetChildNodes(Node, "List", "Download", "Upload", "CreateFolder", "DeleteFolder", "DeleteFile");
30 | foreach (var n in lstNodes)
31 | switch (n.Name.ToLower())
32 | {
33 | case "list": List(n, host, port, user, pass); break;
34 | case "download": Download(n, host, port, user, pass); break;
35 | case "upload": Upload(n, host, port, user, pass); break;
36 | case "createfolder": CreateFolder(n, host, port, user, pass); break;
37 | case "deletefolder": DeleteFolder(n, host, port, user, pass); break;
38 | case "deletefile": DeleteFile(n, host, port, user, pass); break;
39 | }
40 | return true;
41 | }
42 |
43 | void List(XmlNode n, string host, string port, string user, string pass)
44 | {
45 | var path = Program.Shared.ReplaceTags(Util.GetStr(n, "path"));
46 | var dt = GetList(host, port, user, pass, path);
47 | var to = Program.Shared.ReplaceTags(Util.GetStr(n, "to"));
48 | lock (Program.Shared.LockDataTables)
49 | Program.Shared.DataTables[to+";"+Program.Shared.GetSequence()] = dt;
50 | }
51 |
52 | void Download(XmlNode n, string host, string port, string user, string pass)
53 | {
54 | var path = Program.Shared.ReplaceTags(Util.GetStr(n, "path"));
55 | var toFile = Program.Shared.ReplaceTags(Util.GetStr(n, "toFile"));
56 | var rqt = GetFtpRequest(host, port, user, pass, WebRequestMethods.Ftp.DownloadFile, path);
57 | using (var rs = rqt.GetResponse() as FtpWebResponse)
58 | using (var stream = rs.GetResponseStream())
59 | using (var fs = new FileStream(toFile, FileMode.Create, FileAccess.Write))
60 | stream.CopyTo(fs);
61 | }
62 |
63 | void Upload(XmlNode n, string host, string port, string user, string pass)
64 | {
65 | var file = Program.Shared.ReplaceTags(Util.GetStr(n, "file"));
66 | var toPath = Program.Shared.ReplaceTags(Util.GetStr(n, "toPath"));
67 | var path = GetPathFromURL(host);
68 | host = host.Replace(path, "");
69 | var filename = Path.GetFileName(toPath);
70 | path = CombinePaths(path, toPath.Replace(filename, ""));
71 | CreateFolder(host, port, user, pass, path);
72 | path = CombinePaths(path, filename);
73 | var rqt = GetFtpRequest(host, port, user, pass, WebRequestMethods.Ftp.UploadFile, path);
74 | using (var fs = new FileStream(file, FileMode.Open, FileAccess.Read))
75 | using (var rs = rqt.GetRequestStream())
76 | fs.CopyTo(rs);
77 | Program.Shared.WriteLogLine($"Ftp file uploaded: {file} to host/path {host}/{toPath}");
78 | }
79 |
80 | void CreateFolder(XmlNode n, string host, string port, string user, string pass)
81 | {
82 | var path = Program.Shared.ReplaceTags(Util.GetStr(n, "path"));
83 | CreateFolder(host, port, user, pass, path);
84 | }
85 |
86 | void DeleteFolder(XmlNode n, string host, string port, string user, string pass)
87 | {
88 | var path = Program.Shared.ReplaceTags(Util.GetStr(n, "path"));
89 | var rqt = GetFtpRequest(host, port, user, pass, WebRequestMethods.Ftp.RemoveDirectory, path);
90 | using (var rs = rqt.GetResponse() as FtpWebResponse)
91 | Program.Shared.WriteLogLine($"Ftp folder deleted: {path} - Response status code: {rs.StatusCode}");
92 | }
93 |
94 | void DeleteFile(XmlNode n, string host, string port, string user, string pass)
95 | {
96 | var path = Program.Shared.ReplaceTags(Util.GetStr(n, "path"));
97 | var rqt = GetFtpRequest(host, port, user, pass, WebRequestMethods.Ftp.DeleteFile, path);
98 | using (var rs = rqt.GetResponse() as FtpWebResponse)
99 | Program.Shared.WriteLogLine($"Ftp folder deleted: {path} - Response status code: {rs.StatusCode}");
100 | }
101 |
102 | DataTable GetList(string host, string port, string user, string pass, string path)
103 | {
104 | var rqt = GetFtpRequest(host, port, user, pass, WebRequestMethods.Ftp.ListDirectoryDetails, path);
105 | var str = null as string;
106 | using (var rs = rqt.GetResponse() as FtpWebResponse)
107 | using (var stream = rs.GetResponseStream())
108 | using (var sr = new StreamReader(stream))
109 | str = sr.ReadToEnd();
110 |
111 | var lst = str.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
112 | var pattern = @"^(?\d+-\d+-\d+\s+\d+:\d+(?:AM|PM))\s+(?|\d+)\s+(?.+)$";
113 | var dt = new DataTable();
114 | dt.Columns.Add("name", typeof(string));
115 | dt.Columns.Add("type", typeof(string));
116 | dt.Columns.Add("length", typeof(long));
117 | dt.Columns.Add("datetime", typeof(DateTime));
118 | foreach (var item in lst){
119 | var m = Regex.Match(item, pattern);
120 | if (!m.Success)
121 | continue;
122 | var d = m.Groups["datetime"].Value.Replace("\t", " ").Replace(" ", " ");
123 | var l = m.Groups["length"].Value;
124 |
125 | var name = m.Groups["name"].Value;
126 | var type = l == "" ? "folder" : "file";
127 | var len = l == "" ? null : new Nullable(Convert.ToInt64(l));
128 | var date = DateTime.ParseExact("08-10-18 06:57PM", "MM-dd-yy hh:mmtt", System.Globalization.CultureInfo.InvariantCulture);
129 | dt.Rows.Add(name, type, len, date);
130 | }
131 | return dt;
132 | }
133 |
134 | FtpWebRequest GetFtpRequest(string host, string port, string user, string pass, string method, string path)
135 | {
136 | var uri = GetUri(host, port, user, pass, path);
137 | var rqt = FtpWebRequest.Create(uri) as FtpWebRequest;
138 | rqt.Method = method;
139 | rqt.EnableSsl = host.ToLower().StartsWith("ftps:");
140 | rqt.Credentials = new NetworkCredential(user, pass);
141 | return rqt;
142 | }
143 |
144 | void CreateFolder(string host, string port, string user, string pass, string path)
145 | {
146 | var lstPaths = path.Split(new char[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);
147 | for (var x = 0; x < lstPaths.Length; x++)
148 | {
149 | var basePath = lstPaths.Where((string str, int index) => index < x).Concat(str => str, "/") ?? "/";
150 | var newFolder = lstPaths[x];
151 | var dt = GetList(host, port, user, pass, basePath);
152 | var rows = dt.Select($"type='folder' and name='{newFolder}'");
153 | if (rows.Length > 0)
154 | continue;
155 | var rqt = GetFtpRequest(host, port, user, pass, WebRequestMethods.Ftp.MakeDirectory, basePath + "/" + newFolder);
156 | using (var rs = rqt.GetResponse() as FtpWebResponse)
157 | Program.Shared.WriteLogLine($"Ftp folder created: {path} - Response status code: {rs.StatusCode}");
158 | }
159 | }
160 |
161 | string GetPathFromURL(string url)
162 | {
163 | var uri = new Uri(url);
164 | return uri.AbsolutePath;
165 | }
166 |
167 | string CombinePaths(params string[] paths)
168 | {
169 | if (paths == null || paths.Length == 0)
170 | return null;
171 | var rs = "";
172 | foreach (var str in paths)
173 | rs += (rs.EndsWith("/") || str.StartsWith("/") ? "" : "/") + str;
174 | return rs;
175 | }
176 |
177 | Uri GetUri(string host, string port, string user, string pass, string path)
178 | {
179 | var uri = new Uri(host);
180 | if (!string.IsNullOrEmpty(path))
181 | {
182 | var builder = new UriBuilder(uri);
183 | builder.Path = path;
184 | uri = builder.Uri;
185 | }
186 | if (!string.IsNullOrEmpty(port) && port.IsMatch("^\\d+$") && port != "21")
187 | {
188 | var value = Convert.ToInt32(port);
189 | var builder = new UriBuilder(uri);
190 | builder.Port = value;
191 | uri = builder.Uri;
192 | }
193 | if (!string.IsNullOrEmpty(uri.Scheme) && uri.Scheme.ToLower() == "ftps")
194 | {
195 | var builder = new UriBuilder(uri);
196 | builder.Scheme = "ftp";
197 | uri = builder.Uri;
198 | }
199 | return uri;
200 | }
201 | }
202 | }
203 |
--------------------------------------------------------------------------------
/src/Functions/FunctionsNodeHandlerBase.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Xml;
3 |
4 | namespace DoIt.Functions
5 | {
6 | internal abstract class FunctionsNodeHandlerBase
7 | {
8 | public XmlNode Node { get; set; }
9 |
10 | public FunctionsNodeHandlerBase(XmlNode node)
11 | {
12 | Node = node;
13 | }
14 |
15 | public abstract bool Execute();
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/src/Functions/HttpFunctions.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.IO;
3 | using System.Linq;
4 | using System.Net;
5 | using System.Net.Http;
6 | using System.Text;
7 | using System.Xml;
8 |
9 | namespace DoIt.Functions
10 | {
11 | internal class HttpFunctions : FunctionsNodeHandlerBase
12 | {
13 | public HttpFunctions(XmlNode node):base(node){}
14 |
15 | public override bool Execute()
16 | {
17 | if (Node == null)
18 | return false;
19 | var lstNodes = Util.GetChildNodes(Node, "Request");
20 | foreach (var n in lstNodes)
21 | switch (n.Name.ToLower()) {
22 | case "request": Request(n); break;
23 | }
24 | return true;
25 | }
26 |
27 | void Request(XmlNode n)
28 | {
29 | var method = Program.Shared.ReplaceTags(Util.GetStr(n, "method", "get"));
30 | var url = Program.Shared.ReplaceTags(Util.GetStr(n, "url"));
31 | var toFile = Program.Shared.ReplaceTags(Util.GetStr(n, "toFile"));
32 | var toVar = Program.Shared.ReplaceTags(Util.GetStr(n, "toVar"));
33 | var hasTo = !string.IsNullOrEmpty(toFile) || !string.IsNullOrEmpty(toVar);
34 | if (string.IsNullOrEmpty(url) || !hasTo)
35 | return;
36 |
37 | var headersNode = Util.GetChildNode(n, "Headers");
38 | var lstHeaders = Util.GetChildNodes(headersNode, "Header");
39 | var bodyNode = Util.GetChildNode(n, "Body");
40 |
41 | var m = GetMethod(method);
42 | using (var msg = new HttpRequestMessage(m, url))
43 | using (var http = new HttpClient())
44 | {
45 | if (lstHeaders != null)
46 | foreach (var hNode in lstHeaders)
47 | {
48 | var headerName = Util.GetStr(hNode, "name");
49 | if (!string.IsNullOrEmpty(headerName))
50 | msg.Headers.Add(headerName, hNode.InnerXml);
51 | }
52 |
53 | if (bodyNode != null)
54 | {
55 | var bType = Util.GetStr(bodyNode, "type");
56 | msg.Content = new StringContent(bodyNode.InnerXml, Encoding.UTF8, bType);
57 | }
58 |
59 | var task = http.SendAsync(msg);
60 | task.Wait();
61 | var rs = task.Result;
62 | if (!string.IsNullOrEmpty(toVar))
63 | {
64 | var t2 = rs.Content.ReadAsStringAsync();
65 | t2.Wait();
66 | lock (Program.Shared.LockVariables)
67 | Program.Shared.Variables[toVar + ";" + Program.Shared.GetSequence()] = t2.Result;
68 | }
69 | if (!string.IsNullOrEmpty(toFile))
70 | {
71 | var t2 = rs.Content.ReadAsStreamAsync();
72 | t2.Wait();
73 | using (var fs = new FileStream(toFile, FileMode.Create, FileAccess.Write))
74 | t2.Result.CopyTo(fs);
75 | }
76 | }
77 | }
78 |
79 | HttpMethod GetMethod(string method)
80 | {
81 | if (string.IsNullOrWhiteSpace(method))
82 | return HttpMethod.Get;
83 | switch (method.ToLower().Trim())
84 | {
85 | case "get": return HttpMethod.Get;
86 | case "post": return HttpMethod.Post;
87 | case "put": return HttpMethod.Put;
88 | case "delete": return HttpMethod.Delete;
89 | }
90 | return HttpMethod.Get;
91 | }
92 | }
93 | }
94 |
--------------------------------------------------------------------------------
/src/Functions/LocalDiskFunctions.cs:
--------------------------------------------------------------------------------
1 | using ICSharpCode.SharpZipLib.Zip;
2 | using LumenWorks.Framework.IO.Csv;
3 | using Microsoft.WindowsAzure.Storage;
4 | using System;
5 | using System.Collections.Generic;
6 | using System.Data;
7 | using System.IO;
8 | using System.Linq;
9 | using System.Text;
10 | using System.Text.RegularExpressions;
11 | using System.Threading.Tasks;
12 | using System.Xml;
13 |
14 | namespace DoIt.Functions
15 | {
16 | internal class LocalDiskFunctions : FunctionsNodeHandlerBase
17 | {
18 | public LocalDiskFunctions(XmlNode node):base(node){}
19 |
20 | public override bool Execute()
21 | {
22 | if (Node == null)
23 | return false;
24 | var lstNodes = Util.GetChildNodes(Node, "ListFiles", "MoveFile", "MoveFolder", "CopyFile", "DeleteFile", "DeleteFolder");
25 | foreach (var n in lstNodes)
26 | switch (n.Name.ToLower()){
27 | case "listfiles": ListFiles(n); break;
28 | case "movefile": MoveFile(n); break;
29 | case "movefolder": MoveFolder(n); break;
30 | case "copyfile": CopyFile(n); break;
31 | case "deletefile": DeleteFile(n); break;
32 | case "deletefolder": DeleteFolder(n); break;
33 | }
34 | return true;
35 | }
36 |
37 | // list files
38 | void ListFiles(XmlNode n){
39 | var to = Util.GetStr(n, "to");
40 | var path = Program.Shared.ReplaceTags(Util.GetStr(n, "path"));
41 | if (string.IsNullOrEmpty(path))
42 | return;
43 | var searchPattern = Util.GetStr(n, "searchPattern");
44 | var allDirectories = Util.GetStr(n, "allDirectories", "false") == "true";
45 | var fetchAttributes = Util.GetStr(n, "fetchAttributes", "false") == "true";
46 | var where = Program.Shared.ReplaceTags(Util.GetStr(n, "where"));
47 | var sort = Util.GetStr(n, "sort");
48 | var regex = Util.GetStr(n, "regex");
49 | var dt = new DataTable();
50 | dt.Columns.Add("full_path", typeof(string));
51 | dt.Columns.Add("directory", typeof(string));
52 | dt.Columns.Add("filename", typeof(string));
53 | dt.Columns.Add("extension", typeof(string));
54 | dt.Columns.Add("creation_time", typeof(DateTime));
55 | dt.Columns.Add("last_write_time", typeof(DateTime));
56 | dt.Columns.Add("length", typeof(long));
57 | if (Directory.Exists(path)){
58 | var lst = Directory.GetFiles(path, searchPattern, allDirectories ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
59 | if (!string.IsNullOrEmpty(regex))
60 | lst = lst.Where(file => Regex.IsMatch(file, regex)).ToArray();
61 | foreach (var file in lst){
62 | var lstData = new List