//http://academicplanner.codeplex.com/

//Microsoft Public License (Ms-PL)
using System;
using System.Text.RegularExpressions;

namespace AcademicPlanner.Framework.Libraries.Validation
{
  /// <summary>
  /// Provides static validation methods for <c>string</c>s.
  /// </summary>
  /// <version>1.0</version>
  /// <since>1.0</since>
  public static class StringValidator
  {
    /// <summary>
    /// Regular expression for a valid email address: "^(([A-Za-z0-9]+_+)|([A-Za-z0-9]+-+)|([A-Za-z0-9]+.+)|([A-Za-z0-9]+++))*[A-Za-z0-9]+@((w+-+)|(w+.))*w{1,63}.[a-zA-Z]{2,6}$".
    /// </summary>
    /// <version>1.0</version>
    /// <since>1.0</since>
    public static readonly string EMAIL_REGEXP = @"^(([A-Za-z0-9]+_+)|([A-Za-z0-9]+-+)|([A-Za-z0-9]+.+)|([A-Za-z0-9]+++))*[A-Za-z0-9]+@((w+-+)|(w+.))*w{1,63}.[a-zA-Z]{2,6}$";

    /// <summary>
    /// Regular expression for words with letters only: "^([a-zA-Z]+s*)+$".
    /// </summary>
    /// <version>1.0</version>
    /// <since>1.0</since>
    public static readonly string ALPHA_REGEXP = @"^([a-zA-Z]+s*)+$";

    /// <summary>
    /// Regurlar expression for words with letters and digits and "_" only: "^([a-zA-Z0-9_]+s*)+$".
    /// </summary>
    /// <version>1.0</version>
    /// <since>1.0</since>
    public static readonly string ALNUM_REGEXP = @"^([a-zA-Z0-9_]+s*)+$";


    /// <summary>
    /// Checks whether the given <c>string</c> is blank or not i.e.
    /// it contains at least one character.
    /// </summary>
    /// <param name="pVal">The <c>string</c> to check.</param>
    /// <returns>Whether the <c>string</c> is blank or not.</returns>
    /// <seealso cref="M:ContainsAtLeast"/>
    /// <version>1.0</version>
    /// <since>1.0</since>
    public static bool IsNotBlank(string pVal)
    {
      return ContainsAtLeast(pVal, 1);
    }

    /// <summary>
    /// Checks whether the given <c>string</c> is a valid email address or not i.e.
    /// it matches the <c>EMAIL_REGEXP</c> regualar expression.
    /// </summary>
    /// <param name="pVal">The <c>string</c> to check.</param>
    /// <returns>Whether the <c>string</c> is a valid email address or not.</returns>
    /// <seealso cref="M:Matches"/>
    /// <seealso cref="P:EMAIL_REGEXP"/>
    /// <version>1.0</version>
    /// <since>1.0</since>
    public static bool IsEmailAddress(string pVal)
    {
      return Matches(pVal, EMAIL_REGEXP);
    }

    /// <summary>
    /// Checks whether the given <c>string</c> matches the given regualar expression.
    /// </summary>
    /// <param name="pVal">The <c>string</c> to check.</param>
    /// <param name="pRegex">The regular expression to check against.</param>
    /// <returns>Whether the <c>string</c> matches the given regualar expression.</returns>
    /// <version>1.0</version>
    /// <since>1.0</since>
    public static bool Matches(string pVal, string pRegex)
    {
      return Regex.IsMatch(pVal, pRegex);
    }

    /// <summary>
    /// Checks whether the given <c>string</c> is words with letters only i.e.
    /// it matches the <c>ALPHA_REGEXP</c> regualar expression.
    /// </summary>
    /// <param name="pVal">The <c>string</c> to check.</param>
    /// <returns>Whether the <c>string</c> is words with letters only or not.</returns>
    /// <seealso cref="M:Matches"/>
    /// <seealso cref="P:ALPHA_REGEXP"/>
    /// <version>1.0</version>
    /// <since>1.0</since>
    public static bool IsAlpha(string pVal)
    {
      return Matches(pVal, ALPHA_REGEXP);
    }

    /// <summary>
    /// Checks whether the given <c>string</c> is words with letters and digits only i.e.
    /// it matches the <c>ALNUM_REGEXP</c> regualar expression.
    /// </summary>
    /// <param name="pVal">The <c>string</c> to check.</param>
    /// <returns>Whether the <c>string</c> is words with letters and digits only or not.</returns>
    /// <seealso cref="M:Matches"/>
    /// <seealso cref="P:ALNUM_REGEXP"/>
    /// <version>1.0</version>
    /// <since>1.0</since>
    public static bool IsAlphaNumeric(string pVal)
    {
      return Matches(pVal, ALNUM_REGEXP);
    }

    /// <summary>
    /// Checks whether the given <c>string</c> contains at least the the given
    /// number of characters.
    /// </summary>
    /// <param name="pVal">The <c>string</c> to check.</param>
    /// <param name="pMinChars">The minimum number of characters the <c>string</c> should have.</param>
    /// <returns>Whether the <c>string</c> contains at least the the given number of characters.</returns>
    /// <version>1.0</version>
    /// <since>1.0</since>
    public static bool ContainsAtLeast(string pVal, int pMinChars)
    {
      return (pVal.Trim().Length >= pMinChars);
    }

    /// <summary>
    /// Checks whether the given <c>string</c> contains at most the the given
    /// number of characters.
    /// </summary>
    /// <param name="pVal">The <c>string</c> to check.</param>
    /// <param name="pMaxChars">The maximum number of characters the <c>string</c> should have.</param>
    /// <returns>Whether the <c>string</c> contains at most the the given number of characters.</returns>
    /// <version>1.0</version>
    /// <since>1.0</since>
    public static bool ContainsAtMost(string pVal, int pMaxChars)
    {
      return (pVal.Trim().Length <= pMaxChars);
    }

    /// <summary>
    /// Checks whether two <c>string</c>s are identical i.e. have the same characters
    /// after trimming.
    /// </summary>
    /// <param name="pVal">The first <c>string</c>.</param>
    /// <param name="pComparee">The second <c>string</c>.</param>
    /// <returns>Whether the two <c>string</c>s are identical or not.</returns>
    /// <version>1.0</version>
    /// <since>1.0</since>
    public static bool IsIdenticalTo(string pVal, string pComparee)
    {
      return pVal.Trim().Equals(pComparee.Trim());
    }
  }
}

   
     

   
 

///////////////////////////////////////////////////////////////////////////////////////////////
//
//    This File is Part of the CallButler Open Source PBX (http://www.codeplex.com/callbutler
//
//    Copyright (c) 2005-2008, Jim Heising
//    All rights reserved.
//
//    Redistribution and use in source and binary forms, with or without modification,
//    are permitted provided that the following conditions are met:
//
//    * Redistributions of source code must retain the above copyright notice,
//      this list of conditions and the following disclaimer.
//
//    * Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions and the following disclaimer in the documentation and/or
//      other materials provided with the distribution.
//
//    * Neither the name of Jim Heising nor the names of its contributors may be
//      used to endorse or promote products derived from this software without specific prior
//      written permission.
//
//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//    IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
//    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
//    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
//    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
//    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//    POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////////////////////

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using System.Xml;

namespace WOSI.Utilities
{
    public class StringUtils
    {
        public static string CleanTelephoneNumber(string inputString)
        {
            return Regex.Replace(inputString, @"[()-.s]", "");
        }
    }
}        
        

   
     

   
 
///////////////////////////////////////////////////////////////////////////////////////////////
//
//    This File is Part of the CallButler Open Source PBX (http://www.codeplex.com/callbutler
//
//    Copyright (c) 2005-2008, Jim Heising
//    All rights reserved.
//
//    Redistribution and use in source and binary forms, with or without modification,
//    are permitted provided that the following conditions are met:
//
//    * Redistributions of source code must retain the above copyright notice,
//      this list of conditions and the following disclaimer.
//
//    * Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions and the following disclaimer in the documentation and/or
//      other materials provided with the distribution.
//
//    * Neither the name of Jim Heising nor the names of its contributors may be
//      used to endorse or promote products derived from this software without specific prior
//      written permission.
//
//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//    IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
//    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
//    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
//    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
//    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//    POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////////////////////

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using System.Xml;

namespace WOSI.Utilities
{
    public class StringUtils
    {
        /// <summary>
        /// Determines whether the supplied <paramref name="number"/> is an integer.
        /// </summary>
        /// <param name="number">The object to check.</param>
        /// <returns>
        /// <see lang="true"/> if the supplied <paramref name="number"/> is an integer.
        /// </returns>
        public static bool IsInteger(object number)
        {
            return (number is Int32 || number is Int16 || number is Int64 || number is UInt32
                || number is UInt16 || number is UInt64 || number is Byte || number is SByte);
        }

        /// <summary>
        /// Determines whether the supplied <paramref name="number"/> is a decimal number.
        /// </summary>
        /// <param name="number">The object to check.</param>
        /// <returns>
        /// <see lang="true"/> if the supplied <paramref name="number"/> is a decimal number.
        /// </returns>
        public static bool IsDecimal(object number)
        {

            return (number is Single || number is Double || number is Decimal);
        }

        /// <summary>
        /// Determines whether the supplied <paramref name="number"/> is of numeric type.
        /// </summary>
        /// <param name="number">The object to check.</param>
        /// <returns>
        ///   <c>true</c> if the specified object is of numeric type; otherwise, <c>false</c>.
        /// </returns>
        public static bool IsNumber(object number)
        {
            return (IsInteger(number) || IsDecimal(number));
        }
        public static string FormatPhoneNumber(string inputString)
        {
            string outputNumber = "";
            string numberString = "";

            // Remove any spaces
            //inputString = inputString.Replace(" ", "");

            // Get number count
            int numberCount = 0;

            foreach (Char numberChar in inputString)
            {
                if (Char.IsNumber(numberChar))
                {
                    numberCount++;
                    numberString += numberChar.ToString();
                }
            }

            if (Regex.IsMatch(inputString, @"(?<First>2[0-4]d|25[0-5]|[01]?dd?).(?<Second>2[0-4]d|25[0-5]|[01]?dd?).(?<Third>2[0-4]d|25[0-5]|[01]?dd?).(?<Fourth>2[0-4]d|25[0-5]|[01]?dd?)"))
            {
                outputNumber = inputString;
            }
            else if (numberCount == 7)
            {
                outputNumber = numberString.Substring(0, 3) + "-" + numberString.Substring(3, 4);
            }
            else if (numberCount == 10)
            {
                outputNumber = "(" + numberString.Substring(0, 3) + ") " + numberString.Substring(3, 3) + "-" + numberString.Substring(6, 4);
            }
            else if (numberCount == 11)
            {
                outputNumber = numberString.Substring(0, 1) + " (" + numberString.Substring(1, 3) + ") " + numberString.Substring(4, 3) + "-" + numberString.Substring(7, 4);
            }
            else
                outputNumber = inputString;

            return outputNumber;
        }
    }
}