FCC/Extension/GlobalPumpFdc/Support/FControlFusionG/AuthReleaseTokenFactory.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Globalization;

namespace FControlFUSIONCF
{
    interface IReleaseToken
    {
        int TerminalId { get; }

        int AuthorizationId { get; }

        int? ReceiptNo { get; }
    }

    static class AuthReleaseTokenFactory
    {
       /// <summary>
       /// Create a token from components
       /// </summary>
       /// <param name="reservingDeviceId"></param>
       /// <param name="authorizationId"></param>
        /// <param name="receiptNo"></param>
        /// <returns></returns>
        public static IReleaseToken GenerateToken(int reservingDeviceId, int authorizationId, int? receiptNo)
        {
            return new ReleaseToken() { TerminalId = reservingDeviceId, AuthorizationId = authorizationId, ReceiptNo = receiptNo };
        }

        /// <summary>
        /// Create a token from its serializad form
        /// </summary>
        /// <param name="tokenstring"></param>
        /// <returns></returns>
        public static IReleaseToken GenerateToken(string tokenstring)
        {
            var token = new ReleaseToken();

            int terminalId = 0, authorizationId = 0, receiptNo = 0;

            if (TryGetParameter<int>(ReleaseToken.TerminalIdField, tokenstring, out terminalId))
                token.TerminalId = terminalId;
            if (TryGetParameter<int>(ReleaseToken.AuthorizationIdField, tokenstring, out authorizationId))
                token.AuthorizationId = authorizationId;
            if (TryGetParameter<int>(ReleaseToken.ReceiptNoField, tokenstring, out receiptNo))
                token.ReceiptNo = receiptNo;

            return token;
        }

        public static bool TryGetParameter<T>(string parameterName, string source, out T value, string delimiter = ";")
        {
            value = default(T);
            Regex regex = new Regex(String.Format("(\\A|{1}){0}\\s*=\\s*(?<{0}>[^{1}]*)", parameterName, delimiter));
            MatchCollection mc = regex.Matches(source);
            foreach (Match m in mc)
            {
                if (m.Success)
                {
                    try
                    {
                        value = (T)Convert.ChangeType(m.Groups[parameterName].Value, typeof(T), CultureInfo.InvariantCulture);
                        return true;
                    }
                    catch
                    {
                        return false;
                    }
                }
            }
            return false;
        }

        class ReleaseToken : IReleaseToken
        {
            public const string TerminalIdField = "TerminalId";
            public const string AuthorizationIdField = "ReleaseId";
            public const string ReceiptNoField = "ReceiptNo";

            public int TerminalId { get; set; }

            public int AuthorizationId { get; set; }

            public int? ReceiptNo { get; set; }

            public override string ToString()
            {
                if (ReceiptNo.HasValue)
                    return String.Format(CultureInfo.InvariantCulture, "{0}={1};{2}={3};{4}={5}", TerminalIdField, TerminalId,
                                         AuthorizationIdField, AuthorizationId, ReceiptNoField, ReceiptNo);
                else
                    return String.Format(CultureInfo.InvariantCulture, "{0}={1};{2}={3}", TerminalIdField, TerminalId,
                                         AuthorizationIdField, AuthorizationId);
            }
        }
    }
}