ToolBox

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.IO;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

/**//// <summary>
///
/// Date: 08.7.16
/// Description: Class that has commonly used static methods
/// </summary>
public static class ToolBox
{
    "FindGridViewColumnIndex"#region "FindGridViewColumnIndex"
    public static int FindGridViewColumnIndex(GridView pGridView, string pAccessibleHeaderText)
    {
        for (int index = 0; index < pGridView.Columns.Count; index++)
        {
            if (String.Compare(pGridView.Columns[index].AccessibleHeaderText, pAccessibleHeaderText, true) == 0)
                return index;
        }
        return -1;
    }
    #endregion

    "ConvertTrueAndFalseToYesAndNo"#region "ConvertTrueAndFalseToYesAndNo"
    public static string ConvertTrueAndFalseToYesAndNo(bool pTrueAndFalse)
    {
        if (pTrueAndFalse)
        {
            return "Yes";
        }
        else
        {
            return "No";
        }
    }
    #endregion

    "GetMoneyFormatting"#region "GetMoneyFormatting"
    public static string GetMoneyFormatting(object pMoney)
    {
        return string.Format("{0:C}", pMoney);
    }
    #endregion

    "GetDateFormatting"#region "GetDateFormatting"
    public static string GetDateFormatting(object pDate)
    {
        return string.Format("{0:d}", pDate);
    }
    #endregion

    "ReloadCurrentPage"#region "ReloadCurrentPage"
    public static void ReloadCurrentPage()
    {
        HttpContext.Current.Response.Redirect(HttpContext.Current.Request.Url.ToString());
    }
    #endregion

    "FindGridViewButtonControl"#region "FindGridViewButtonControl"
    private static IButtonControl FindGridViewButtonControl(GridViewRowEventArgs pGridViewRowEventArgs, ControlCollection pControlCollection, string pCommandName)
    {
        foreach (Control c in pControlCollection)
        {
            if (c is IButtonControl)
            {
                if ((c as IButtonControl).CommandName == pCommandName)
                {
                    return c as IButtonControl;
                }
                else
                {
                    if (c.HasControls())
                    {
                        IButtonControl ibc = FindGridViewButtonControl(pGridViewRowEventArgs, c.Controls, pCommandName);
                        if (ibc != null)
                        {
                            return ibc;
                        }
                    }
                }
            }
            else
            {
                if (c.HasControls())
                {
                    IButtonControl ibc = FindGridViewButtonControl(pGridViewRowEventArgs, c.Controls, pCommandName);
                    if (ibc != null)
                    {
                        return ibc;
                    }
                }
            }
        }
        return null;
    }
    #endregion

    "FindGridViewButtonControl"#region "FindGridViewButtonControl"
    public static IButtonControl FindGridViewButtonControl(GridViewRowEventArgs pGridViewRowEventArgs, GridViewButtonControlType pGridViewButtonControlType)
    {
        return FindGridViewButtonControl(pGridViewRowEventArgs, pGridViewRowEventArgs.Row.Controls, pGridViewButtonControlType.ToString());
    }
    #endregion

    "Properties"#region "Properties"
    public enum GridViewButtonControlType
    {
        Edit,
        Delete
    }
    #endregion

    "ReloadTemplateCaches"#region "ReloadTemplateCaches"
    public static void ReloadTemplateCaches()
    {
        DirectoryInfo di = new DirectoryInfo(HttpContext.Current.Server.MapPath("~") + "\\" + ConfigurationManager.AppSettings["TemplateFolder"]);
        IEnumerable<FileInfo> fis = GetFilesRecursively(di);
        if (fis != null)
        {
            foreach (FileInfo fi in fis)
            {
                string t = ReadFileText(fi.FullName);
                if (t != null)
                {
                    HttpContext.Current.Cache.Remove(fi.Name);
                    HttpContext.Current.Cache.Insert(fi.Name, t);
                }
            }
        }
    }
    #endregion

    "ReloadTemplateCache"#region "ReloadTemplateCache"
    public static void ReloadTemplateCache(string pFileName)
    {
        FileInfo fi = new FileInfo(HttpContext.Current.Server.MapPath("~") + "\\" + ConfigurationManager.AppSettings["TemplateFolder"] + "\\" + pFileName);
        string t = ReadFileText(fi.FullName);
        if (t != null)
        {
            HttpContext.Current.Cache.Remove(fi.Name);
            HttpContext.Current.Cache.Insert(fi.Name, t);
        }
    }
    #endregion

    "GetTemplateCache"#region "GetTemplateCache"
    public static string GetTemplateCache(string pFileName)
    {
        try
        {
            return Convert.ToString(HttpContext.Current.Cache[pFileName]);
        }
        catch
        {
            return null;
        }
    }
    #endregion

    "TemplateCacheDoesExist"#region "TemplateCacheDoesExist"
    public static bool TemplateCacheDoesExist(string pFileName)
    {
        if (HttpContext.Current.Cache[pFileName] == null)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    #endregion

    "ReplaceTemplateContent"#region "ReplaceTemplateContent"
    public static string ReplaceTemplateContent(string pTagName, string pReplaceWith, string pTarget)
    {
        return RelaceMatch("<" + ConfigurationManager.AppSettings["TemplateSeparator"] + ">" + pTagName + "</" + ConfigurationManager.AppSettings["TemplateSeparator"] + ">", pReplaceWith, pTarget);
    }
    #endregion

    "ReplaceMatches"#region "ReplaceMatches"
    public static List<string> ReplaceMatches(string pFindPattern, string pReplacePattern, string pTarget)
    {
        List<string> l = new List<string>();
        Regex r = new Regex(pFindPattern);
        MatchCollection mc = r.Matches(pTarget);
        foreach (Match m in mc)
        {
            l.Add(Regex.Replace(m.Value, pFindPattern, pReplacePattern));
        }
        return l;
    }
    #endregion

    "RelaceMatch"#region "RelaceMatch"
    public static string RelaceMatch(string pFindPattern, string pReplacePattern, string pTarget)
    {
        return Regex.Replace(pTarget, pFindPattern, pReplacePattern);
    }
    #endregion

    "FindMatches"#region "FindMatches"
    public static List<string> FindMatches(string pFindPattern, string pTarget)
    {
        List<string> l = new List<string>();
        Regex r = new Regex(pFindPattern);
        MatchCollection mc = r.Matches(pTarget);
        foreach (Match m in mc)
        {
            l.Add(m.Value);
        }
        return l;
    }
    #endregion

    "FindMatch"#region "FindMatch"
    public static string FindMatch(string pFindPattern, string pTarget)
    {
        Regex r = new Regex(pFindPattern);
        Match m = r.Match(pTarget);
        return m.Value;
    }
    #endregion

    "ReadFileText"#region "ReadFileText"
    public static string ReadFileText(string pPath)
    {
        try
        {
            return File.ReadAllText(pPath);
        }
        catch
        {
            return null;
        }
    }
    #endregion

    "GetFilesRecursively"#region "GetFilesRecursively"
    public static IEnumerable<FileInfo> GetFilesRecursively(DirectoryInfo pDirectoryInfo)
    {
        return GetFilesRecursively(pDirectoryInfo, "*.*");
    }
    #endregion

    "GetFilesRecursively"#region "GetFilesRecursively"
    public static IEnumerable<FileInfo> GetFilesRecursively(DirectoryInfo pDirectoryInfo, string pSearchPattern)
    {
        try
        {
            return TryGetFilesRecursively(pDirectoryInfo, pSearchPattern);
        }
        catch
        {
            return null;
        }
    }
    #endregion

    "TryGetFilesRecursively"#region "TryGetFilesRecursively"
    private static IEnumerable<FileInfo> TryGetFilesRecursively(DirectoryInfo pDirectoryInfo, string pSearchPattern)
    {
        foreach (DirectoryInfo di in pDirectoryInfo.GetDirectories())
        {
            foreach (FileInfo fi in GetFilesRecursively(di, pSearchPattern))
            {
                yield return fi;
            }
        }
        foreach (FileInfo fi in pDirectoryInfo.GetFiles(pSearchPattern))
        {
            yield return fi;
        }
    }
    #endregion
}