/// <summary>
/// The format x path.
/// </summary>
/// <param name="resolver">
/// The resolver.
/// </param>
/// <param name="nodes">
/// The nodes.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string FormatXPath(IXmlNamespaceResolver resolver, params string[] nodes)
{
if (nodes == null)
{
return(string.Empty);
}
StringBuilder builder = null;
var leftString = RetrieveDefaultNamespacePrefix(resolver);
foreach (var str2 in nodes)
{
if (TStringHelper.IsNullOrWhiteSpace(str2))
{
builder = TStringHelper.CombineStrings(builder, "/");
}
else if (str2.IndexOf(':') >= 0)
{
var delimiter = "/";
builder = TStringHelper.CombineStrings(builder, str2, delimiter);
}
else
{
var str4 = "/";
var str5 = ":";
builder = TStringHelper.CombineStrings(builder, TStringHelper.CombineStrings(leftString, str2, str5), str4);
}
}
return(TStringHelper.StringToEmpty(builder));
}
/// <summary>
/// The calculate and check hash.
/// </summary>
/// <param name="filePath">
/// The file path.
/// </param>
/// <param name="savedHash">
/// The saved hash.
/// </param>
/// <param name="expectedHash">
/// The expected hash.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public static bool CalculateAndCheckHash(string filePath, out string savedHash, out string expectedHash)
{
using (var stream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var flag = DoCalculateAndCheckHash(stream, out savedHash, out expectedHash);
savedHash = TStringHelper.StringToEmpty(savedHash).ToUpper();
expectedHash = TStringHelper.StringToEmpty(expectedHash).ToUpper();
return(flag);
}
}
/// <summary>
/// The calculate and save hash.
/// </summary>
/// <param name="filePath">
/// The file path.
/// </param>
/// <param name="hash">
/// The hash.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public static bool CalculateAndSaveHash(string filePath, out string hash)
{
FileSystemPhysical.FileMakeWritable(filePath);
using (var stream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read))
{
var flag = DoCalculateAndSaveHash(stream, out hash);
hash = TStringHelper.StringToEmpty(hash).ToUpper();
return(flag);
}
}
/// <summary>
/// The retrieve request string.
/// </summary>
/// <param name="type">
/// The type.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string RetrieveRequestString(DataEventType type)
{
var str = RetrieveTransactionCode(type);
if (string.IsNullOrEmpty(str))
{
return(null);
}
var delimiter = "/";
return(TStringHelper.CombineStrings(str, RetrieveTranscauseCode(type), delimiter));
}
/// <summary>
/// The calculate and check hash.
/// </summary>
/// <param name="stream">
/// The stream.
/// </param>
/// <param name="savedHash">
/// The saved hash.
/// </param>
/// <param name="expectedHash">
/// The expected hash.
/// </param>
/// <param name="resetPosition">
/// The reset position.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public static bool CalculateAndCheckHash(
Stream stream,
out string savedHash,
out string expectedHash,
bool resetPosition = true)
{
expectedHash = savedHash = null;
var flag = DoResetPosition(stream, resetPosition) &&
DoCalculateAndCheckHash(stream, out savedHash, out expectedHash);
savedHash = TStringHelper.StringToEmpty(savedHash).ToUpper();
expectedHash = TStringHelper.StringToEmpty(expectedHash).ToUpper();
return(flag);
}
/// <summary>
/// The bytes to hex string.
/// </summary>
/// <param name="bytes">
/// The bytes.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string BytesToHexString(byte[] bytes)
{
StringBuilder builder = null;
if (bytes != null)
{
foreach (var num in bytes)
{
string delimiter = null;
builder = TStringHelper.CombineStrings(builder, num.ToString("x2").ToUpper(), delimiter);
}
}
return(TStringHelper.StringToEmpty(builder));
}
/// <summary>
/// The do read config value.
/// </summary>
/// <param name="name">
/// The name.
/// </param>
/// <param name="value">
/// The value.
/// </param>
/// <param name="rawRead">
/// The raw read.
/// </param>
/// <typeparam name="T">
/// </typeparam>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
private static bool DoReadConfigValue <T>(string name, ref T value, bool rawRead)
{
Func <Match, int> func = null;
try
{
var bTrimFirst = true;
var input = TStringHelper.StringToNull(AppSettings[name], bTrimFirst);
if (input != null)
{
if (!rawRead)
{
var matchCollection = regexEnvironmentVariable.Matches(input);
if ((matchCollection != null) && (matchCollection.Count > 0))
{
var builder = new StringBuilder(input);
if (func == null)
{
func = row => row.Index;
}
foreach (var match in matchCollection.EnumerateMatches().OrderByDescending(func))
{
var str2 = match.Groups[1].Value;
var str3 = !string.IsNullOrEmpty(str2)
? TStringHelper.StringToEmpty(Environment.GetEnvironmentVariable(str2))
: string.Empty;
builder.Remove(match.Index, match.Length);
builder.Insert(match.Index, str3);
}
input = builder.ToString();
}
}
value = ConversionHelper.StringToValue <T>(input);
return(true);
}
}
catch
{
}
return(false);
}
/// <summary>
/// The retrieve attribute.
/// </summary>
/// <param name="xmlNode">
/// The xml node.
/// </param>
/// <param name="attributeName">
/// The attribute name.
/// </param>
/// <param name="trimToNull">
/// The trim to null.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string RetrieveAttribute(this XElement xmlNode, string attributeName, bool trimToNull = false)
{
var attribute = xmlNode.Attribute(attributeName);
if (attribute == null)
{
return(null);
}
if (!trimToNull)
{
return(attribute.Value);
}
var bTrimFirst = true;
return(TStringHelper.StringToNull(attribute.Value, bTrimFirst));
}
// разрешить все ссылки на имена обрабатываемых полей
// public void ResolveAllowedFields(PolicySearchFieldNameResolver resolver)
// {
// if (converters != null)
// {
// foreach (var converter in converters)
// converter.AllowedFields.ResolveFields(resolver);
// }
// }
// разрешить все ссылки на имена обрабатываемых полей
// public void ResolveAllowedFields()
// {
// ResolveAllowedFields(FieldNameResolver);
// }
// провести подготовку строки, задав тонкие настройки
/// <summary>
/// The prepare string.
/// </summary>
/// <param name="s">
/// The s.
/// </param>
/// <param name="field">
/// The field.
/// </param>
/// <param name="flagged">
/// The flagged.
/// </param>
/// <param name="emptyToNull">
/// The empty to null.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
/// <exception cref="InvalidCastException">
/// </exception>
public string PrepareString(
string s,
FieldTypes field = FieldTypes.Undefined,
bool flagged = false,
bool emptyToNull = false)
{
if (s != null)
{
/*
* следует учитывать, что после преобразований какие-то буквы могут исчезнуть, а какие-то добавиться
* в результате может сложиться новая последовательность символов, которая сама по себе подлежит преобразованию
* наша цель: получить некий "конечный" результат, то есть такой, который уже не будет меняться, если к нему снова и снова применить все те же преобразования
*
* для этого будем повторять преобразования в цикле до тех пор, пока хоть что-то в строке меняется (разумеется, с защитой от зацикливания)
* поначалу предполагалось сделать кеш готовых значений, но тесты показали, что в этом нет особого смысла, потому что наличие цикла добавило всего 2-3% времени на обработку файла
*/
ushort cycles = 0;
var original_s = s;
do
{
// текущее значение строки
var saved_s = s;
// преобразование к верхнему регистру
if (GlobalUpper)
{
s = s.ToUpper();
}
// применить настраиваемые преобразования
if (converters != null)
{
foreach (var converter in converters)
{
s = converter.Convert(s, field, flagged);
}
}
// убрать боковые пробелы
if (GlobalTrim)
{
s = s.Trim();
}
// убрать лишние пробелы
if (GlobalCompact)
{
s = TStringHelper.CompactString(s);
}
// прерываем цикл, когда никаких изменений в строке больше нет
if (string.Compare(s, saved_s, StringComparison.Ordinal) == 0)
{
break;
}
// защита от зацикливания
if (++cycles > 10000)
{
throw new InvalidCastException(
string.Format(
"TextRules.PrepareString: зацикливание! field: {0}, flagged: {1}, string: {2}",
field,
flagged,
original_s));
}
}while (true);
// привести пустую строку к null
if (emptyToNull)
{
s = TStringHelper.StringToNull(s);
}
}
return(s);
}
// public static void SerializeObject(Stream stream, object obj, IXmlNamespaceResolver resolver = new IXmlNamespaceResolver())
// {
// XmlSerializer serializer = new XmlSerializer(obj.GetType());
// XmlSerializerNamespaces namespaces = ResolveNamespacesForSerializer(resolver, false);
// if (namespaces != null)
// {
// serializer.Serialize(stream, obj, namespaces);
// }
// else
// {
// serializer.Serialize(stream, obj);
// }
// }
// public static void SerializeObject(XmlWriter xmlWriter, object obj, IXmlNamespaceResolver resolver = new IXmlNamespaceResolver())
// {
// XmlSerializer serializer = new XmlSerializer(obj.GetType());
// XmlSerializerNamespaces namespaces = ResolveNamespacesForSerializer(resolver, false);
// if (namespaces != null)
// {
// serializer.Serialize(xmlWriter, obj, namespaces);
// }
// else
// {
// serializer.Serialize(xmlWriter, obj);
// }
// }
/// <summary>
/// The split x path.
/// </summary>
/// <param name="xpath">
/// The xpath.
/// </param>
/// <returns>
/// The <see cref="IEnumerable"/>.
/// </returns>
/// <exception cref="ArgumentException">
/// </exception>
public static IEnumerable <string> SplitXPath(this string xpath)
{
List <string> list = null;
char ch;
var bTrimFirst = true;
xpath = TStringHelper.StringToNull(xpath, bTrimFirst);
if (xpath == null)
{
return(list);
}
var length = xpath.Length;
var startIndex = 0;
var num3 = 0;
var none = QuotationMark.None;
Label_0023:
ch = xpath[num3];
var ch2 = ch;
if (ch2 <= '\'')
{
switch (ch2)
{
case '"':
switch (none)
{
case QuotationMark.None:
none = QuotationMark.DoubleQuotes;
goto Label_00D1;
case QuotationMark.Apostrophe:
goto Label_00D1;
case QuotationMark.DoubleQuotes:
none = QuotationMark.None;
goto Label_00D1;
}
goto Label_00D1;
case '\'':
switch (none)
{
case QuotationMark.None:
none = QuotationMark.Apostrophe;
goto Label_00D1;
case QuotationMark.Apostrophe:
none = QuotationMark.None;
goto Label_00D1;
}
goto Label_00D1;
}
}
else if (((ch2 == '/') || (ch2 == '\\')) && (none == QuotationMark.None))
{
var str = xpath.Substring(startIndex, num3 - startIndex);
if (string.IsNullOrEmpty(str) && (list != null))
{
throw new ArgumentException("пустой узел в x-path выражении");
}
if (list == null)
{
list = new List <string>();
}
list.Add(str);
startIndex = num3 + 1;
}
Label_00D1:
if (++num3 < length)
{
goto Label_0023;
}
if (none != QuotationMark.None)
{
throw new ArgumentException("незакрытая кавычка в x-path выражении");
}
if (list == null)
{
list = new List <string>();
}
list.Add(xpath.Substring(startIndex, num3 - startIndex));
return(list);
}
/// <summary>
/// Initializes a new instance of the <see cref="StringMatchingBase"/> class.
/// </summary>
/// <param name="matcher">
/// The matcher.
/// </param>
protected StringMatchingBase(string matcher)
{
this.matcher = TStringHelper.StringToNull(matcher);
}
/// <summary>
/// The select file infos.
/// </summary>
/// <param name="folderPath">
/// The folder path.
/// </param>
/// <param name="searchMask">
/// The search mask.
/// </param>
/// <param name="searchMode">
/// The search mode.
/// </param>
/// <param name="sortMode">
/// The sort mode.
/// </param>
/// <returns>
/// The <see cref="IEnumerable"/>.
/// </returns>
/// <exception cref="ArgumentException">
/// </exception>
public static IEnumerable <FileInfo> SelectFileInfos(
string folderPath,
string searchMask = "",
TreeCollectMode searchMode = 0,
EntriesSortMode sortMode = 0)
{
IEnumerable <FileInfo> files;
var bTrimFirst = true;
folderPath = TStringHelper.StringToEmpty(folderPath, bTrimFirst);
if (!FolderExists(folderPath))
{
return(null);
}
var folderInfo = new DirectoryInfo(folderPath);
switch (searchMode)
{
case TreeCollectMode.RootOnly:
files = folderInfo.GetFiles(CorrectFileSearchMask(searchMask));
break;
case TreeCollectMode.LeavesOnly:
{
var list = new List <FileInfo>();
DoCollectFinalFiles(list, folderInfo, CorrectFileSearchMask(searchMask));
files = list;
break;
}
case TreeCollectMode.Everywhere:
files = folderInfo.GetFiles(CorrectFileSearchMask(searchMask), SearchOption.AllDirectories);
break;
default:
throw new ArgumentException(string.Format("режим поиска файлов не поддерживается: {0}", searchMode));
}
switch (sortMode)
{
case EntriesSortMode.Unsorted:
return(files);
case EntriesSortMode.NameAscending:
return(from f in files orderby f.FullName select f);
case EntriesSortMode.NameDescending:
return(from f in files orderby f.FullName descending select f);
case EntriesSortMode.CreationPointAscending:
return(from f in files orderby f.CreationTimeUtc select f);
case EntriesSortMode.CreationPointDescending:
return(from f in files orderby f.CreationTimeUtc descending select f);
case EntriesSortMode.ModificationPointAscending:
return(from f in files orderby f.LastWriteTimeUtc select f);
case EntriesSortMode.ModificationPointDescending:
return(from f in files orderby f.LastWriteTimeUtc descending select f);
}
throw new ArgumentException(string.Format("режим сортировки при поиске файлов не поддерживается: {0}", sortMode));
}
/// <summary>
/// The join prefix.
/// </summary>
/// <param name="message">
/// The message.
/// </param>
/// <param name="prefix">
/// The prefix.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string JoinPrefix(string message, string prefix)
{
string delimiter = null;
return(TStringHelper.CombineStrings(prefix, message, delimiter));
}
/// <summary>
/// The retrieve data event type.
/// </summary>
/// <param name="transactionCode">
/// The transaction code.
/// </param>
/// <param name="transcauseCode">
/// The transcause code.
/// </param>
/// <returns>
/// The <see cref="DataEventType"/>.
/// </returns>
public static DataEventType RetrieveDataEventType(string transactionCode, string transcauseCode)
{
switch (TStringHelper.StringToEmpty(transactionCode))
{
case "ZA1":
string str2;
if (((str2 = TStringHelper.StringToEmpty(transcauseCode)) == null) || !(str2 == "301"))
{
break;
}
return(DataEventType.IssueOrReissuancePolicyAnnounce);
case "ZA7":
return(DataEventType.NotificationOfReceiveAnnounce);
case "A04":
string str3;
if (((str3 = TStringHelper.StringToEmpty(transcauseCode)) == null) || !(str3 == "П01"))
{
break;
}
return(DataEventType.IssuePolicy);
case "A08":
switch (TStringHelper.StringToEmpty(transcauseCode))
{
case "П01":
return(DataEventType.IssuePolicy);
case "П02":
return(DataEventType.DeregisterPolicy);
case "П03":
return(DataEventType.RegisterPolicy);
case "П04":
return(DataEventType.ChangePolicyPartial);
case "П05":
return(DataEventType.ChangePolicyEmployment);
case "П06":
return(DataEventType.ChangePolicyComplete);
}
break;
case "A03":
string str5;
if (((str5 = TStringHelper.StringToEmpty(transcauseCode)) == null) || !(str5 == "П07"))
{
break;
}
return(DataEventType.DecommitPolicyENP);
case "A13":
string str6;
if (((str6 = TStringHelper.StringToEmpty(transcauseCode)) == null) || !(str6 == "П09"))
{
break;
}
return(DataEventType.RecommitPolicyENP);
case "A24":
string str7;
if (((str7 = TStringHelper.StringToEmpty(transcauseCode)) == null) || !(str7 == "П10"))
{
break;
}
return(DataEventType.ResolvePolicyDublicates);
case "A37":
string str8;
if (((str8 = TStringHelper.StringToEmpty(transcauseCode)) == null) || !(str8 == "П11"))
{
break;
}
return(DataEventType.ResolvePolicyCollisions);
case "ZP1":
return(DataEventType.QueryPersonInsurance);
case "ZP2":
return(DataEventType.QueryPersonsRegistrating);
case "ZP3":
return(DataEventType.QueryPersonsDeregistrating);
case "ZP4":
return(DataEventType.QueryPersonsDeadAbroad);
case "ZP5":
return(DataEventType.QueryDublicates);
}
return(DataEventType.Undefined);
}
/// <summary>
/// The retrieve request struct.
/// </summary>
/// <param name="type">
/// The type.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string RetrieveRequestStruct(DataEventType type)
{
var delimiter = "_";
return(TStringHelper.CombineStrings(RetrieveRequestCode(type), RetrieveRequestStructCode(type), delimiter));
}
/// <summary>
/// The validation handler.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="args">
/// The args.
/// </param>
private void ValidationHandler(object sender, ValidationEventArgs args)
{
var errorDelimiter = XmlValidator.errorDelimiter;
errorMessage = TStringHelper.CombineStrings(errorMessage, args.Message, errorDelimiter);
}
/// <summary>
/// The plain whitespaces.
/// </summary>
/// <param name="s">
/// The s.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string PlainWhitespaces(this string s)
{
return(TStringHelper.ReplaceAny(s, ' ', new[] { '\t', '\r', '\n' }));
}
/// <summary>
/// The retrieve short info.
/// </summary>
/// <returns>
/// The <see cref="string" />.
/// </returns>
public string RetrieveShortInfo()
{
return(TStringHelper.CombineStrings(BeginPacket.RetrieveShortInfo(), EndPacket.RetrieveShortInfo(), ", "));
}