Skip to content
Navigation Menu
{{ message }}
forked from BlogEngine/BlogEngine.NET
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathUtils.cs
More file actions
1667 lines (1468 loc) · 58 KB
/
Copy pathUtils.cs
File metadata and controls
1667 lines (1468 loc) · 58 KB
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
107
108
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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
namespace BlogEngine.Core
{
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Mail;
using System.Reflection;
using System.Security;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Web;
using System.Web.Configuration;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using System.Xml;
using System.DirectoryServices;
using BlogEngine.Core.Web.Controls;
using BlogEngine.Core.Web.Extensions;
using System.Net.Sockets;
/// <summary>
/// Utilities for the entire solution to use.
/// </summary>
public static class Utils
{
#region Constants and Fields
/// <summary>
/// The cookie name for forcing the main theme on a mobile device.
/// </summary>
public const String ForceMainThemeCookieName = "forceMainTheme";
/// <summary>
/// The folder name where files are stored in the XmlFileSystemProvider.
/// </summary>
/// <value>"files"</value>
public const string FilesFolder = "files";
/// <summary>
/// The pattern.
/// </summary>
private const string Pattern = "<head.*<link( [^>]*title=\"{0}\"[^>]*)>.*</head>";
/// <summary>
/// The application's relative web root.
/// </summary>
private static string applicationRelativeWebRoot;
/// <summary>
/// The href regex.
/// </summary>
private static readonly Regex HrefRegex = new Regex(
"href=\"(.*)\"", RegexOptions.IgnoreCase | RegexOptions.Compiled);
/// <summary>
/// The regex between tags.
/// </summary>
private static readonly Regex RegexBetweenTags = new Regex(@">\s+", RegexOptions.Compiled);
/// <summary>
/// The regex line breaks.
/// </summary>
private static readonly Regex RegexLineBreaks = new Regex(@"\n\s+", RegexOptions.Compiled);
/// <summary>
/// The regex mobile.
/// </summary>
private static readonly Regex RegexMobile =
new Regex(BlogConfig.MobileServices, RegexOptions.IgnoreCase | RegexOptions.Compiled);
/// <summary>
/// The regex strip html.
/// </summary>
private static readonly Regex RegexStripHtml = new Regex("<[^>]*>", RegexOptions.Compiled);
/// <summary>
/// Boolean for returning whether or not BlogEngine is currently running on Mono.
/// </summary>
private static readonly bool isMono = (Type.GetType("Mono.Runtime") != null);
#endregion
#region Events
/// <summary>
/// Occurs after an e-mail has been sent. The sender is the MailMessage object.
/// </summary>
public static event EventHandler<EventArgs> EmailFailed;
/// <summary>
/// Occurs after an e-mail has been sent. The sender is the MailMessage object.
/// </summary>
public static event EventHandler<EventArgs> EmailSent;
/// <summary>
/// Occurs when a message will be logged. The sender is a string containing the log message.
/// </summary>
public static event EventHandler<EventArgs> OnLog;
#endregion
#region Properties
/// <summary>
/// Gets the absolute root of the website.
/// </summary>
/// <value>A string that ends with a '/'.</value>
public static Uri AbsoluteWebRoot
{
get { return Blog.CurrentInstance.AbsoluteWebRoot; }
}
/// <summary>
/// Gets the relative URL of the blog feed. If a Feedburner username
/// is entered in the admin settings page, it will return the
/// absolute Feedburner URL to the feed.
/// </summary>
public static string FeedUrl
{
get
{
return !string.IsNullOrEmpty(BlogSettings.Instance.AlternateFeedUrl)
? BlogSettings.Instance.AlternateFeedUrl
: $"{AbsoluteWebRoot}syndication.axd";
}
}
/// <summary>
/// Gets a value indicating whether we're running under Linux or a Unix variant.
/// </summary>
/// <value><c>true</c> if Linux/Unix; otherwise, <c>false</c>.</value>
public static bool IsLinux
{
get
{
var p = (int)Environment.OSVersion.Platform;
return (p == 4) || (p == 128);
}
}
/// <summary>
/// Gets a value indicating whether the client is a mobile device.
/// </summary>
/// <value><c>true</c> if this instance is mobile; otherwise, <c>false</c>.</value>
public static bool IsMobile
{
get
{
var context = HttpContext.Current;
if (context != null)
{
var request = context.Request;
if (request.Browser.IsMobileDevice)
{
return true;
}
if (!string.IsNullOrEmpty(request.UserAgent) && RegexMobile.IsMatch(request.UserAgent))
{
return true;
}
}
return false;
}
}
/// <summary>
/// Gets a value indicating whether we're running under Mono.
/// </summary>
/// <value><c>true</c> if Mono; otherwise, <c>false</c>.</value>
public static bool IsMono
{
get
{
return isMono;
}
}
/// <summary>
/// Gets the relative root of the current blog instance.
/// </summary>
/// <value>A string that ends with a '/'.</value>
public static string RelativeWebRoot
{
get
{
return Blog.CurrentInstance.RelativeWebRoot;
}
}
/// <summary>
/// Gets the application's relative root.
/// </summary>
/// <value>A string that ends with a '/'.</value>
public static string ApplicationRelativeWebRoot
{
get
{
return applicationRelativeWebRoot ??
(applicationRelativeWebRoot =
VirtualPathUtility.ToAbsolute(BlogConfig.VirtualPath));
}
}
/// <summary>
/// Returns the relative webroot if possible if the hostname of this blog instance matches the
/// hostname of the site aggregation blog. If the hostname is different, then the
/// absolute webroot is returned.
/// </summary>
public static string RelativeOrAbsoluteWebRoot
{
get
{
if (Blog.CurrentInstance.DoesHostnameDifferFromSiteAggregationBlog)
return AbsoluteWebRoot.ToString();
else
return RelativeWebRoot.ToString();
}
}
/// <summary>
/// Gets if the current HTTP request is a homepage request, taking the blog
/// instance into consideration.
/// </summary>
public static bool IsCurrentRequestForHomepage
{
get
{
HttpContext context = HttpContext.Current;
// Because the homepage uses querystring values to render non-homepage content
// such as posts by tag, posts by date range, posts by author, etc, if there
// are any of these known parameters, this will be considered not a homepage request.
// Marketing tools such as Google AdWords and campaign tracking in Google Analytics
// will add their own query string parameters, so it is important to still render
// the home page even if these third-party tracking parameters are present.
string[] knownQueryParameters =
{
"id", "name", "tag", "year", "month", "date", "calendar", "apml", "page"
};
if (context.Request.QueryString.AllKeys
.Where(x => x != null)
.Any(x => knownQueryParameters.Any(y => x.Equals(y, StringComparison.OrdinalIgnoreCase))))
return false;
string path = context.Request.Path;
// If this is a virtual folder for a blog instance, unless "default.aspx" is
// actually in the URL, default.aspx won't be reported in path, so we check
// to see if path is the root of RelativeWebRoot (the blog instance's
// relative web root).
if (RelativeWebRoot.Equals(VirtualPathUtility.AppendTrailingSlash(path), StringComparison.OrdinalIgnoreCase))
return true;
else if (path.Equals($"{RelativeWebRoot}default.aspx", StringComparison.OrdinalIgnoreCase))
return true;
return false;
}
}
#endregion
#region Public Methods
/// <summary>
/// Returns whether the main theme should be forced for the current mobile device.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// A <see cref="Boolean"/> instance.
/// </returns>
public static Boolean ShouldForceMainTheme(HttpRequest request)
{
var forceMainThemeCookie = request.Cookies[ForceMainThemeCookieName];
if (forceMainThemeCookie == null)
{
return false;
}
if (String.IsNullOrEmpty(forceMainThemeCookie.Value))
{
return false;
}
Boolean forceMainTheme;
if (Boolean.TryParse(forceMainThemeCookie.Value, out forceMainTheme))
{
return forceMainTheme;
}
return false;
}
/// <summary>
/// Parse the string representation of an enum field to a strongly typed enum value.
/// </summary>
public static T ParseEnum<T>(string value, T defaultValue) where T : struct, IConvertible
{
if (!typeof(T).IsEnum)
throw new ArgumentException("T must be an enumerated type");
if (string.IsNullOrEmpty(value))
return defaultValue;
foreach (T item in Enum.GetValues(typeof(T)))
{
if (item.ToString().Equals(value, StringComparison.OrdinalIgnoreCase))
return item;
}
return defaultValue;
}
private static Regex _identifierForDisplayRgx = new Regex(
@" (?<=[A-Z])(?=[A-Z][a-z]) # UC before me, UC lc after me
| (?<=[^A-Z])(?=[A-Z]) # Not UC before me, UC after me
| (?<=[A-Za-z])(?=[^A-Za-z]) # Letter before me, non letter after me
", RegexOptions.IgnorePatternWhitespace
);
/// <summary>
/// Format's an identifier (e.g. variable, enum field value) for display purposes,
/// by adding a space before each capital letter. A value like EditOwnUser becomes
/// "Edit Own User". If multiple capital letters are in identifier, these letters
/// will be treated as one word (e.g. XMLEditor becomes "XML Editor", not
/// "X M L Editor").
/// </summary>
/// <param name="fieldName">An identifier ready to be formatted for display.</param>
/// <returns>The identifier for display purposes.</returns>
/// <remarks>Credit: http://stackoverflow.com/questions/3103730</remarks>
public static string FormatIdentifierForDisplay(string fieldName)
{
StringBuilder sb = new StringBuilder();
foreach (string part in _identifierForDisplayRgx.Split(fieldName))
{
if (sb.Length > 0) { sb.Append(" "); }
sb.Append(part);
}
return sb.ToString();
}
/// <summary>
/// Selects a listitem by value, case insensitively.
/// </summary>
/// <param name="control">The ListControl</param>
/// <param name="value">The value to select</param>
/// <returns>The ListItem found and selected</returns>
public static ListItem SelectListItemByValue(ListControl control, string value)
{
control.ClearSelection();
control.SelectedIndex = -1;
foreach (ListItem li in control.Items)
{
if (string.Equals(value, li.Value, StringComparison.OrdinalIgnoreCase))
{
li.Selected = true;
return li;
}
}
return null;
}
/// <summary>
/// Converts an object to its JSON representation.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static string ConvertToJson(object obj)
{
return new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(obj);
}
/// <summary>
/// Adds a JavaScript reference to the HTML head tag.
/// </summary>
/// <param name="page">
/// The page to add the JavaScript include to.
/// </param>
/// <param name="url">
/// The url string.
/// </param>
/// <param name="placeInBottom">
/// The place In Bottom.
/// </param>
/// <param name="addDeferAttribute">
/// The add Defer Attribute.
/// </param>
public static void AddJavaScriptInclude(System.Web.UI.Page page, string url, bool placeInBottom = false, bool addDeferAttribute = false)
{
if (placeInBottom)
{
var deferAttr = (addDeferAttribute ? " defer=\"defer\"" : string.Empty);
var script = $"<script type=\"text/javascript\"{deferAttr} src=\"{url}\"></script>";
page.ClientScript.RegisterStartupScript(page.GetType(), url.GetHashCode().ToString(), script);
}
else
{
var script = new HtmlGenericControl("script");
script.Attributes["type"] = "text/javascript";
script.Attributes["src"] = url;
if (addDeferAttribute)
{
script.Attributes["defer"] = "defer";
}
string itemsKey = "next-script-insert-position";
HttpContext context = HttpContext.Current;
// Inserting scripts in the beginning of the HEAD tag so any user
// scripts that may rely on our scripts (jQuery, etc) have these
// scripts available to them. Also maintaining order so subsequent
// scripts are added after scripts we already added.
int? nextInsertPosition = context == null ? null : context.Items[itemsKey] as int?;
if (!nextInsertPosition.HasValue) { nextInsertPosition = 0; }
page.Header.Controls.AddAt(nextInsertPosition.Value, script);
if (context != null) { context.Items[itemsKey] = ++nextInsertPosition; }
}
}
/// <summary>
/// This method returns all code assemblies in app_code
/// If app_code has subdirectories for c#, vb.net etc
/// Each one will come back as a separate assembly
/// So we can support extensions in multiple languages
/// </summary>
/// <returns>
/// List of code assemblies
/// </returns>
public static IEnumerable<Assembly> CodeAssemblies()
{
var codeAssemblies = new List<Assembly>();
CompilationSection s = null;
var assemblyName = "__code";
try
{
try
{
s = (CompilationSection)WebConfigurationManager.GetSection("system.web/compilation");
}
catch (SecurityException)
{
// No read permissions on web.config due to the trust level (must be High or Full)
}
if (s != null && s.CodeSubDirectories != null && s.CodeSubDirectories.Count > 0)
{
for (var i = 0; i < s.CodeSubDirectories.Count; i++)
{
assemblyName = $"App_SubCode_{s.CodeSubDirectories[i].DirectoryName}";
codeAssemblies.Add(Assembly.Load(assemblyName));
}
}
else
{
assemblyName = "App_Code";
codeAssemblies.Add(Assembly.Load(assemblyName));
}
}
catch (FileNotFoundException)
{
/*ignore - code directory has no files*/
}
try
{
codeAssemblies.AddRange(GetCompiledExtensions());
}
catch (Exception ex)
{
Log("Error loading compiled assemblies: " + ex.Message);
}
return codeAssemblies;
}
/// <summary>
/// Converts a relative URL to an absolute one.
/// </summary>
/// <param name="relativeUri">
/// The relative Uri.
/// </param>
/// <returns>
/// The absolute Uri.
/// </returns>
public static Uri ConvertToAbsolute(Uri relativeUri)
{
return ConvertToAbsolute(relativeUri.ToString());
}
/// <summary>
/// Converts a relative URL to an absolute one.
/// </summary>
/// <param name="relativeUri">
/// The relative Uri.
/// </param>
/// <returns>
/// The absolute Uri.
/// </returns>
public static Uri ConvertToAbsolute(string relativeUri)
{
if (String.IsNullOrEmpty(relativeUri))
{
throw new ArgumentNullException(nameof(relativeUri));
}
var absolute = AbsoluteWebRoot.ToString();
var index = absolute.LastIndexOf(RelativeWebRoot);
return new Uri(absolute.Substring(0, index) + relativeUri);
}
/// <summary>
/// Downloads a web page from the Internet and returns the HTML as a string. .
/// </summary>
/// <param name="url">
/// The URL to download from.
/// </param>
/// <returns>
/// The HTML or null if the URL isn't valid.
/// </returns>
[Obsolete("Use the RemoteFile class instead.")]
public static string DownloadWebPage(Uri url)
{
try
{
var remoteFile = new RemoteFile(url, true);
return remoteFile.GetFileAsString();
}
catch (Exception)
{
return null;
}
}
/// <summary>
/// Extract file name from given physical server path
/// </summary>
/// <param name="path">
/// The Server path.
/// </param>
/// <returns>
/// The File Name.
/// </returns>
public static string ExtractFileNameFromPath(string path)
{
return Path.GetFileName(path);
}
/// <summary>
/// Finds semantic links in a given HTML document.
/// </summary>
/// <param name="type">
/// The type of link. Could be foaf, apml or sioc.
/// </param>
/// <param name="html">
/// The HTML to look through.
/// </param>
/// <returns>
/// A list of Uri.
/// </returns>
public static List<Uri> FindLinks(string type, string html)
{
var matches = Regex.Matches(
html, string.Format(Pattern, type), RegexOptions.IgnoreCase | RegexOptions.Singleline);
var urls = new List<Uri>();
foreach (var hrefMatch in
matches.Cast<Match>().Where(match => match.Groups.Count == 2).Select(match => match.Groups[1].Value).
Select(link => HrefRegex.Match(link)).Where(hrefMatch => hrefMatch.Groups.Count == 2))
{
Uri url;
var value = hrefMatch.Groups[1].Value;
if (Uri.TryCreate(value, UriKind.Absolute, out url))
{
urls.Add(url);
}
}
return urls;
}
/// <summary>
/// Converts all the relative paths in the specified content to absolute.
/// </summary>
/// <param name="content">
/// The content.
/// </param>
/// <param name="publishable">
/// The publishable.
/// </param>
public static string ConvertPublishablePathsToAbsolute(string content, IPublishable publishable)
{
content = content.Replace(
string.Format("\"{0}image.axd", publishable.Blog.AbsoluteWebRoot.AbsolutePath), "\"" + publishable.Blog.AbsoluteWebRoot + "image.axd");
content = content.Replace(
string.Format("\"{0}file.axd", publishable.Blog.AbsoluteWebRoot.AbsolutePath), "\"" + publishable.Blog.AbsoluteWebRoot + "file.axd");
content = content.Replace($"href=\"{publishable.Blog.RelativeWebRoot}", $"href=\"{publishable.Blog.AbsoluteWebRoot}");
content = content.Replace("href=\"/", $"href=\"{publishable.Blog.AbsoluteWebRoot}");
return content;
}
/// <summary>
/// Finds the semantic documents from a URL based on the type.
/// </summary>
/// <param name="url">
/// The URL of the semantic document or a document containing semantic links.
/// </param>
/// <param name="type">
/// The type. Could be "foaf", "apml" or "sioc".
/// </param>
/// <returns>
/// A dictionary of the semantic documents. The dictionary is empty if no documents were found.
/// </returns>
public static Dictionary<Uri, XmlDocument> FindSemanticDocuments(Uri url, string type)
{
var list = new Dictionary<Uri, XmlDocument>();
// ignoreRemoteDownloadSettings is set to true for the
// RemoteFile instance for backwards compatibility.
var remoteFile = new RemoteFile(url, true);
var content = remoteFile.GetFileAsString();
if (!string.IsNullOrEmpty(content))
{
var upper = content.ToUpperInvariant();
if (upper.Contains("</HEAD") && upper.Contains("</HTML"))
{
var urls = FindLinks(type, content);
foreach (var xmlUrl in urls)
{
var doc = LoadDocument(url, xmlUrl);
if (doc != null)
{
list.Add(xmlUrl, doc);
}
}
}
else
{
var doc = LoadDocument(url, url);
if (doc != null)
{
list.Add(url, doc);
}
}
}
return list;
}
/// <summary>
/// Returns the default culture. This is either the culture specified in the blog settings,
/// or the default culture installed with the operating system.
/// </summary>
/// <returns>
/// The default culture.
/// </returns>
public static CultureInfo GetDefaultCulture()
{
var settingsCulture = BlogSettings.Instance.Culture;
if (String.IsNullOrWhiteSpace(settingsCulture) ||
settingsCulture.Equals("Auto", StringComparison.OrdinalIgnoreCase))
{
return CultureInfo.InstalledUICulture;
}
return CultureInfo.CreateSpecificCulture(settingsCulture);
}
/// <summary>
/// Gets the sub domain.
/// </summary>
/// <param name="url">
/// The URL to get the sub domain from.
/// </param>
/// <returns>
/// The sub domain.
/// </returns>
public static string GetSubDomain(Uri url)
{
if (url.HostNameType == UriHostNameType.Dns)
{
var host = url.Host;
if (host.Split('.').Length > 2)
{
var lastIndex = host.LastIndexOf(".");
var index = host.LastIndexOf(".", lastIndex - 1);
return host.Substring(0, index);
}
}
return null;
}
/// <summary>
/// Encrypts a string using the SHA256 algorithm.
/// </summary>
/// <param name="plainMessage">
/// The plain Message.
/// </param>
/// <returns>
/// The hash password.
/// </returns>
public static string HashPassword(string plainMessage)
{
var data = Encoding.UTF8.GetBytes(plainMessage);
using (HashAlgorithm sha = new SHA256Managed())
{
sha.TransformFinalBlock(data, 0, data.Length);
return Convert.ToBase64String(sha.Hash);
}
}
/// <summary>
/// The body regex.
/// </summary>
private static readonly Regex BodyRegex = new Regex(@"\[UserControl:(.*?)\]", RegexOptions.Compiled | RegexOptions.IgnoreCase);
/// <summary>
/// Injects any user controls if one is referenced in the text.
/// </summary>
/// <param name="containerControl">The control that the user controls will be injected in to.</param>
/// <param name="content">The string to parse for user controls.</param>
public static void InjectUserControls(System.Web.UI.Control containerControl, string content)
{
var currentPosition = 0;
var matches = BodyRegex.Matches(content);
var containerControls = containerControl.Controls;
var page = containerControl.Page;
foreach (Match match in matches)
{
// Add literal for content before custom tag should it exist.
if (match.Index > currentPosition)
{
containerControls.Add(new LiteralControl(content.Substring(currentPosition, match.Index - currentPosition)));
}
// Now lets add our user control.
try
{
var all = match.Groups[1].Value.Trim();
Control usercontrol;
if (!all.EndsWith(".ascx", StringComparison.OrdinalIgnoreCase))
{
var index = all.IndexOf(".ascx", StringComparison.OrdinalIgnoreCase) + 5;
usercontrol = page.LoadControl(all.Substring(0, index));
var parameters = page.Server.HtmlDecode(all.Substring(index));
var type = usercontrol.GetType();
var paramCollection = parameters.Split(new[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
foreach (var param in paramCollection)
{
var paramSplit = param.Split('=');
var name = paramSplit[0].Trim();
var value = paramSplit[1].Trim();
var property = type.GetProperty(name);
property.SetValue(
usercontrol,
Convert.ChangeType(value, property.PropertyType, CultureInfo.InvariantCulture),
null);
}
}
else
{
usercontrol = page.LoadControl(all);
}
containerControls.Add(usercontrol);
// Now we will update our position.
// currentPosition = myMatch.Index + myMatch.Groups[0].Length;
}
catch (Exception)
{
// Whoopss, can't load that control so lets output something that tells the developer that theres a problem.
containerControls.Add(
new LiteralControl($"ERROR - UNABLE TO LOAD CONTROL : {match.Groups[1].Value}"));
}
currentPosition = match.Index + match.Groups[0].Length;
}
// Finally we add any trailing static text.
containerControls.Add(
new LiteralControl(content.Substring(currentPosition, content.Length - currentPosition)));
}
private static readonly Regex emailRegex = new Regex(
@"^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$", RegexOptions.IgnoreCase);
private static readonly Regex validIpV4AddressRegex = new Regex(@"^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$", RegexOptions.IgnoreCase);
private static readonly Regex validHostnameRegex = new Regex(@"^(([a-z]|[a-z][a-z0-9\-]*[a-z0-9])\.)*([a-z]|[a-z][a-z0-9\-]*[a-z0-9])$", RegexOptions.IgnoreCase);
/// <summary>
/// Email address by user name
/// </summary>
/// <param name="userName">User name</param>
/// <returns>Email Address</returns>
public static string GetUserEmail(string userName)
{
int count;
var userCollection = System.Web.Security.Membership.Provider.GetAllUsers(0, 999, out count);
var users = userCollection.Cast<System.Web.Security.MembershipUser>().ToList();
var user = users.FirstOrDefault(u => u.UserName.Equals(userName, StringComparison.OrdinalIgnoreCase));
if(user != null)
{
return user.Email;
}
return userName;
}
/// <summary>
/// Validates an email address.
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
public static bool IsEmailValid(string email)
{
if (!string.IsNullOrWhiteSpace(email))
{
return emailRegex.IsMatch(email.Trim());
}
return false;
}
/// <summary>
/// Validates a host name.
/// </summary>
/// <param name="hostname"></param>
/// <returns></returns>
public static bool IsHostnameValid(string hostname)
{
if (!string.IsNullOrWhiteSpace(hostname))
{
return validHostnameRegex.IsMatch(hostname.Trim());
}
return false;
}
/// <summary>
/// Validates an IPv4 address.
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public static bool IsIpV4AddressValid(string address)
{
if (!string.IsNullOrWhiteSpace(address))
{
return validIpV4AddressRegex.IsMatch(address.Trim());
}
return false;
}
/// <summary>
/// Validates an IPv6 address.
/// </summary>
/// <param name="address"></param>
/// <returns></returns>
public static bool IsIpV6AddressValid(string address)
{
if (!string.IsNullOrWhiteSpace(address))
{
IPAddress ip;
if (IPAddress.TryParse(address, out ip))
{
return ip.AddressFamily == AddressFamily.InterNetworkV6;
}
}
return false;
}
/// <summary>
/// Run through all code assemblies and creates object
/// instance for types marked with extension attribute
/// </summary>
public static void LoadExtensions()
{
var codeAssemblies = CodeAssemblies();
var sortedExtensions = new List<SortedExtension>();
foreach (Assembly a in codeAssemblies)
{
var types = a.GetTypes();
Type extensionsAttribute = typeof(ExtensionAttribute);
sortedExtensions.AddRange(
from type in types
let attributes = type.GetCustomAttributes(extensionsAttribute, false)
from attribute in attributes
where (attribute.GetType() == extensionsAttribute)
let ext = (ExtensionAttribute)attribute
select new SortedExtension(ext.Priority, type.Name, type.FullName));
sortedExtensions.Sort(
(e1, e2) =>
e1.Priority == e2.Priority
? string.CompareOrdinal(e1.Name, e2.Name)
: e1.Priority.CompareTo(e2.Priority));
foreach (var x in sortedExtensions.Where(x => ExtensionManager.ExtensionEnabled(x.Name)))
{
a.CreateInstance(x.Type);
}
}
// initialize comment rules and filters
CommentHandlers.Listen();
}
/// <summary>
/// Sends a message to any subscribed log listeners.
/// </summary>
/// <param name="message">
/// The message to be logged.
/// </param>
public static void Log(object message)
{
if (OnLog != null)
{
OnLog(message, EventArgs.Empty);
}
}
/// <summary>
/// Sends a message to any subscribed log listeners.
/// </summary>
/// <param name="format">A format string</param>
/// <param name="args">Arguments to replace in the format string</param>
public static void Log(string format, params object[] args)
{
if (OnLog != null)
{
OnLog(string.Format(format, args), EventArgs.Empty);
}
}
/// <summary>
/// Sends a message to any subscribed log listeners.
/// </summary>
/// <param name="methodName"></param>
/// <param name="ex"></param>
public static void Log(string methodName, Exception ex)
{
Log($"{methodName}: {ex.Message}");
}
/// <summary>
/// Generates random password for password reset
/// </summary>
/// <returns>
/// Random password
/// </returns>
public static string RandomPassword()
{
var chars = "abcdefghijklmnopqrstuvwxyz1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
var password = string.Empty;
var random = new Random();
for (var i = 0; i < 8; i++)
{
var x = random.Next(1, chars.Length);
if (!password.Contains(chars.GetValue(x).ToString()))
{
password += chars.GetValue(x);
}
else
{
i--;
}
}
return password;
You can’t perform that action at this time.