You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1018 lines
36 KiB
1018 lines
36 KiB
using Common.Model;
|
|
using Common.Model.Config;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Configuration;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Mail;
|
|
using System.Reflection;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace Common.Helper
|
|
{
|
|
public static class Utilities
|
|
{
|
|
private static readonly Random Random = new Random();
|
|
private static readonly string MsisdnPrefix = ApplicationConfig.ReadWebConfig("MsisdnPrefix");
|
|
private static readonly string MsisdnLengthSetting = ApplicationConfig.ReadWebConfig("MsisdnLength");
|
|
private static EncryptionParameters _encryptionParams;
|
|
|
|
private static JsonResponse response = new JsonResponse();
|
|
private static List<string> lstSupportType { get; set; }
|
|
private static List<string> lstTransferType { get; set; }
|
|
private static List<string> lstActionType { get; set; }
|
|
|
|
//private static List<string> lstScheduleType { get; set; }
|
|
/// <summary>
|
|
/// Private method to initialize encryption parameters
|
|
/// </summary>
|
|
private static void InitializeEncryptionParameters()
|
|
{
|
|
_encryptionParams = new EncryptionParameters()
|
|
{
|
|
PassPhrase = ApplicationConfig.ReadWebConfig("symmetricKey"),
|
|
HashAlgorithm = "SHA1",
|
|
SaltValue = "sw!ftT3ch",
|
|
PasswordIterations = 2,
|
|
InitVector = "@1B2c3D4e5F6g7H8",
|
|
KeySize = 256
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encrypt string
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private static string Encrypt(EncryptionParameters encrypt)
|
|
{
|
|
byte[] initVectorBytes = Encoding.ASCII.GetBytes(encrypt.InitVector);
|
|
byte[] saltValueBytes = Encoding.ASCII.GetBytes(encrypt.SaltValue);
|
|
|
|
// Convert our plaintext into a byte array.
|
|
byte[] plainTextBytes = Encoding.UTF8.GetBytes(encrypt.PlainText);
|
|
PasswordDeriveBytes password = new PasswordDeriveBytes
|
|
(
|
|
encrypt.PassPhrase,
|
|
saltValueBytes,
|
|
encrypt.HashAlgorithm,
|
|
encrypt.PasswordIterations
|
|
);
|
|
|
|
byte[] keyBytes = password.GetBytes(encrypt.KeySize / 8);
|
|
|
|
// Create uninitialized Rijndael encryption object.
|
|
RijndaelManaged symmetricKey = new RijndaelManaged();
|
|
|
|
symmetricKey.Mode = CipherMode.CBC;
|
|
|
|
ICryptoTransform encryptor = symmetricKey.CreateEncryptor
|
|
(
|
|
keyBytes,
|
|
initVectorBytes
|
|
);
|
|
|
|
// Define memory stream which will be used to hold encrypted data.
|
|
MemoryStream memoryStream = new MemoryStream();
|
|
|
|
// Define cryptographic stream (always use Write mode for encryption).
|
|
CryptoStream cryptoStream = new CryptoStream
|
|
(
|
|
memoryStream,
|
|
encryptor,
|
|
CryptoStreamMode.Write
|
|
);
|
|
|
|
// Start encrypting.
|
|
cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
|
|
|
|
// Finish encrypting.
|
|
cryptoStream.FlushFinalBlock();
|
|
|
|
// Convert our encrypted data from a memory stream into a byte array.
|
|
byte[] cipherTextBytes = memoryStream.ToArray();
|
|
|
|
// Close both streams.
|
|
memoryStream.Close();
|
|
cryptoStream.Close();
|
|
|
|
// Convert encrypted data into a base64-encoded string.
|
|
string cipherText = Convert.ToBase64String(cipherTextBytes);
|
|
|
|
// Return encrypted string.
|
|
return cipherText;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generate random 5 digit OTP
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public static string GenerateOTP()
|
|
{
|
|
string[] strChar = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
|
|
|
|
string otpChar = strChar[Random.Next(0, 9)] + strChar[Random.Next(0, 9)] + strChar[Random.Next(0, 9)] + strChar[Random.Next(0, 9)] + strChar[Random.Next(0, 9)] + strChar[Random.Next(0, 9)];
|
|
|
|
return otpChar;
|
|
}
|
|
/// <summary>
|
|
/// Decrypt string
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private static string Decrypt(EncryptionParameters decrypt)
|
|
{
|
|
byte[] initVectorBytes = Encoding.ASCII.GetBytes(decrypt.InitVector);
|
|
byte[] saltValueBytes = Encoding.ASCII.GetBytes(decrypt.SaltValue);
|
|
|
|
// Convert our ciphertext into a byte array.
|
|
byte[] cipherTextBytes = Convert.FromBase64String(decrypt.CipherText);
|
|
|
|
PasswordDeriveBytes password = new PasswordDeriveBytes
|
|
(
|
|
decrypt.PassPhrase,
|
|
saltValueBytes,
|
|
decrypt.HashAlgorithm,
|
|
decrypt.PasswordIterations
|
|
);
|
|
|
|
// Use the password to generate pseudo-random bytes for the encryption key. Specify the
|
|
// size of the key in bytes (instead of bits).
|
|
byte[] keyBytes = password.GetBytes(decrypt.KeySize / 8);
|
|
|
|
// Create uninitialized Rijndael encryption object.
|
|
RijndaelManaged symmetricKey = new RijndaelManaged();
|
|
|
|
// It is reasonable to set encryption mode to Cipher Block Chaining
|
|
symmetricKey.Mode = CipherMode.CBC;
|
|
|
|
ICryptoTransform decryptor = symmetricKey.CreateDecryptor
|
|
(
|
|
keyBytes,
|
|
initVectorBytes
|
|
);
|
|
|
|
// Define memory stream which will be used to hold encrypted data.
|
|
MemoryStream memoryStream = new MemoryStream(cipherTextBytes);
|
|
|
|
// Define cryptographic stream (always use Read mode for encryption).
|
|
CryptoStream cryptoStream = new CryptoStream
|
|
(
|
|
memoryStream,
|
|
decryptor,
|
|
CryptoStreamMode.Read
|
|
);
|
|
|
|
byte[] plainTextBytes = new byte[cipherTextBytes.Length];
|
|
|
|
// Start decrypting.
|
|
int decryptedByteCount = cryptoStream.Read
|
|
(
|
|
plainTextBytes,
|
|
0,
|
|
plainTextBytes.Length
|
|
);
|
|
|
|
// Close both streams.
|
|
memoryStream.Close();
|
|
cryptoStream.Close();
|
|
|
|
// Convert decrypted data into a string.
|
|
string plainText = Encoding.UTF8.GetString
|
|
(
|
|
plainTextBytes,
|
|
0,
|
|
decryptedByteCount
|
|
);
|
|
|
|
// Return decrypted string.
|
|
return plainText;
|
|
}
|
|
|
|
public static string DecryptData(string key, string encrypedData)
|
|
{
|
|
if (string.IsNullOrEmpty(encrypedData))
|
|
{
|
|
return "";
|
|
}
|
|
|
|
string decData = null;
|
|
byte[][] keys = GetHashKeys(key);
|
|
|
|
try
|
|
{
|
|
decData = DecryptStringFromBytes_Aes(encrypedData, keys[0], keys[1]);
|
|
}
|
|
catch (CryptographicException) { }
|
|
catch (ArgumentNullException) { }
|
|
|
|
return decData;
|
|
}
|
|
|
|
private static byte[][] GetHashKeys(string key)
|
|
{
|
|
byte[][] result = new byte[2][];
|
|
Encoding enc = Encoding.UTF8;
|
|
|
|
SHA256 sha2 = new SHA256CryptoServiceProvider();
|
|
|
|
byte[] rawKey = enc.GetBytes(key);
|
|
byte[] rawIV = enc.GetBytes(key);
|
|
|
|
byte[] hashKey = sha2.ComputeHash(rawKey);
|
|
byte[] hashIV = sha2.ComputeHash(rawIV);
|
|
|
|
Array.Resize(ref hashIV, 16);
|
|
|
|
result[0] = hashKey;
|
|
result[1] = hashIV;
|
|
|
|
return result;
|
|
}
|
|
|
|
private static string DecryptStringFromBytes_Aes(string cipherTextString, byte[] Key, byte[] IV)
|
|
{
|
|
byte[] cipherText = Convert.FromBase64String(cipherTextString);
|
|
//final byte[] plainTextBytes = (orignalText)
|
|
|
|
if (cipherText == null || cipherText.Length <= 0)
|
|
throw new ArgumentNullException("cipherText");
|
|
if (Key == null || Key.Length <= 0)
|
|
throw new ArgumentNullException("Key");
|
|
if (IV == null || IV.Length <= 0)
|
|
throw new ArgumentNullException("IV");
|
|
|
|
string plaintext = null;
|
|
|
|
using (Aes aesAlg = Aes.Create())
|
|
{
|
|
aesAlg.Mode = CipherMode.CBC;
|
|
aesAlg.KeySize = 256;
|
|
aesAlg.BlockSize = 128;
|
|
aesAlg.Padding = PaddingMode.PKCS7;
|
|
|
|
aesAlg.Key = Key;
|
|
aesAlg.IV = new byte[16];
|
|
|
|
ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
|
|
|
|
using (MemoryStream msDecrypt = new MemoryStream(cipherText))
|
|
{
|
|
using (CryptoStream csDecrypt =
|
|
new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
|
|
{
|
|
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
|
|
{
|
|
plaintext = srDecrypt.ReadToEnd();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return plaintext;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generate Random 4 digit Pin
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public static string GenerateRandomPin()
|
|
{
|
|
string[] strChar = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
|
|
|
|
string otpChar = strChar[Random.Next(0, 9)] + strChar[Random.Next(0, 9)] + strChar[Random.Next(0, 9)] + strChar[Random.Next(0, 9)] + strChar[Random.Next(0, 9)] + strChar[Random.Next(0, 9)];
|
|
|
|
return otpChar;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encrypt plain text to cipher text.
|
|
/// </summary>
|
|
/// <param name="plainText"></param>
|
|
/// <returns></returns>
|
|
public static string EncryptString(string plainText)
|
|
{
|
|
InitializeEncryptionParameters();
|
|
|
|
EncryptionParameters _encrypt = new EncryptionParameters()
|
|
{
|
|
PlainText = plainText,
|
|
PassPhrase = _encryptionParams.PassPhrase,
|
|
HashAlgorithm = _encryptionParams.HashAlgorithm,
|
|
SaltValue = _encryptionParams.SaltValue,
|
|
PasswordIterations = _encryptionParams.PasswordIterations,
|
|
InitVector = _encryptionParams.InitVector,
|
|
KeySize = _encryptionParams.KeySize
|
|
};
|
|
|
|
var s = Utilities.Encrypt(_encrypt);
|
|
return s;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decrypt encrypted/cipher text to plain text.
|
|
/// </summary>
|
|
/// <param name="cipherText"></param>
|
|
/// <returns></returns>
|
|
public static string DecryptString(string cipherText)
|
|
{
|
|
try
|
|
{
|
|
InitializeEncryptionParameters();
|
|
|
|
EncryptionParameters _decrypt = new EncryptionParameters()
|
|
{
|
|
CipherText = cipherText,
|
|
PassPhrase = _encryptionParams.PassPhrase,
|
|
HashAlgorithm = _encryptionParams.HashAlgorithm,
|
|
SaltValue = _encryptionParams.SaltValue,
|
|
PasswordIterations = _encryptionParams.PasswordIterations,
|
|
InitVector = _encryptionParams.InitVector,
|
|
KeySize = _encryptionParams.KeySize
|
|
};
|
|
|
|
return Utilities.Decrypt(_decrypt);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check for email validity
|
|
/// </summary>
|
|
/// <param name="email"></param>
|
|
/// <returns></returns>
|
|
public static bool IsValidEmail(this string email)
|
|
{
|
|
return Regex.IsMatch(email ?? "", ApplicationConfig.ReadWebConfig("regex"), RegexOptions.IgnoreCase);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check for residence card number
|
|
/// </summary>
|
|
/// <param name="residenceCardNo"></param>
|
|
/// <returns></returns>
|
|
public static bool IsValidNumber(this string residenceCardNo)
|
|
{
|
|
return Regex.IsMatch(residenceCardNo ?? "", ApplicationConfig.ReadWebConfig("regexResidenceCard"), RegexOptions.IgnoreCase);
|
|
}
|
|
|
|
public static bool IsValidMobileNumber(this string mobile)
|
|
{
|
|
return Regex.IsMatch(mobile ?? "", ApplicationConfig.ReadWebConfig("regexMobile"), RegexOptions.IgnoreCase);
|
|
}
|
|
|
|
public static bool IsValidDrivingNumber(this string drivingNo)
|
|
{
|
|
return Regex.IsMatch(drivingNo ?? "", ApplicationConfig.ReadWebConfig("regexDrivingLiscence"), RegexOptions.IgnoreCase);
|
|
}
|
|
public static bool IsCheckAdditionalId()
|
|
{
|
|
var additionalid = ApplicationConfig.ReadWebConfig("CheckAdditinalID");
|
|
|
|
if (additionalid != null && additionalid.Equals("Y"))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check for 4 digit pin number
|
|
/// </summary>
|
|
/// <param name="pin"></param>
|
|
/// <returns></returns>
|
|
public static bool IsValidPin(this string pin)
|
|
{
|
|
if (!string.IsNullOrEmpty(pin))
|
|
{
|
|
int iPin;
|
|
|
|
if (pin.Length != 4)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return int.TryParse(pin, out iPin);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check Wether the Mobile Number is Valid or not
|
|
/// </summary>
|
|
/// <param name="msisdn"></param>
|
|
/// <returns></returns>
|
|
public static bool IsValidMsisdn(this string msisdn)
|
|
{
|
|
int minPrefix = 2;
|
|
int maxPrefix = 4;
|
|
int chkFlag = 0;
|
|
if (!string.IsNullOrEmpty(msisdn))
|
|
{
|
|
long iMsisdn;
|
|
var splitMsisdnLength = MsisdnLengthSetting.Split('|').ToList();
|
|
|
|
if (splitMsisdnLength.Contains(msisdn.Length.ToString()))
|
|
{
|
|
var splitPrefix = MsisdnPrefix.Split('|').ToList();
|
|
for (int i = minPrefix; i <= maxPrefix; i++)
|
|
{
|
|
if (splitPrefix.Contains(msisdn.Substring(0, i))) //checking prefix
|
|
{
|
|
chkFlag = 1;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
if (chkFlag == 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return long.TryParse(msisdn, out iMsisdn);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static bool IsValidARCFormat(string idType, string vin)
|
|
{
|
|
if (idType == ApplicationConfig.ReadWebConfig("kycVerificationIdType") || idType == ApplicationConfig.ReadWebConfig("kycNationalIdType"))
|
|
{
|
|
var number = vin.Split('-');
|
|
if (number.Length != 2)
|
|
{
|
|
return false;
|
|
}
|
|
else if (number[0].Length != 6 || number[1].Length != 7)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generate Random Password
|
|
/// </summary>
|
|
/// <param name="length"></param>
|
|
/// <returns></returns>
|
|
public static string GenerateRandomPassword(int length)
|
|
{
|
|
const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
|
|
return new string(Enumerable.Repeat(chars, length)
|
|
.Select(s => s[Random.Next(s.Length)]).ToArray());
|
|
}
|
|
|
|
public static string GetTimestamp(DateTime value)
|
|
{
|
|
return value.ToString("yyyyMMddHHmmssffff");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Used to send email
|
|
/// </summary>
|
|
/// <param name="emailParameters"></param>
|
|
/// <returns></returns>
|
|
public static JsonResponse SendEmail(SendEmailParameters emailParameters)
|
|
{
|
|
MailMessage mail = new MailMessage();
|
|
SmtpClient SmtpServer = new SmtpClient();
|
|
try
|
|
{
|
|
SmtpServer.Host = ApplicationConfig.ReadWebConfig("smtp");
|
|
SmtpServer.Port = Convert.ToInt16(ApplicationConfig.ReadWebConfig("port"));
|
|
SmtpServer.Credentials = new System.Net.NetworkCredential(ApplicationConfig.ReadWebConfig("mailFrom"), ApplicationConfig.ReadWebConfig("emailPwd"));
|
|
SmtpServer.EnableSsl = Convert.ToBoolean(ApplicationConfig.ReadWebConfig("enableSSL"));
|
|
|
|
mail.From = new MailAddress(ApplicationConfig.ReadWebConfig("mailFrom"), ApplicationConfig.ReadWebConfig("mailSender"));
|
|
mail.To.Add(emailParameters.ToEmails);
|
|
if (!string.IsNullOrEmpty(emailParameters.CcEmails))
|
|
mail.CC.Add(emailParameters.CcEmails);
|
|
if (!string.IsNullOrEmpty(emailParameters.BccEmails))
|
|
mail.Bcc.Add(emailParameters.BccEmails);
|
|
mail.Subject = emailParameters.MsgSubject;
|
|
mail.IsBodyHtml = true;
|
|
mail.Body = emailParameters.MsgBody;
|
|
SmtpServer.Send(mail);
|
|
|
|
response.SetResponseMessage(HttpStatusCode.OK, "Message sent successfully");
|
|
}
|
|
catch (SmtpFailedRecipientsException ex)
|
|
{
|
|
for (int i = 0; i < ex.InnerExceptions.Length; i++)
|
|
{
|
|
SmtpStatusCode status = ex.InnerExceptions[i].StatusCode;
|
|
if (status == SmtpStatusCode.MailboxBusy || status == SmtpStatusCode.MailboxUnavailable)
|
|
{
|
|
// Console.WriteLine("Delivery failed - retrying in 5 seconds.");
|
|
System.Threading.Thread.Sleep(5000);
|
|
SmtpServer.Send(mail);
|
|
response.SetResponseMessage(HttpStatusCode.OK, "Message sent successfully");
|
|
}
|
|
else
|
|
{
|
|
response.SetResponseMessage(HttpStatusCode.BadRequest, ex.InnerExceptions[i].FailedRecipient);
|
|
|
|
// Console.WriteLine("Failed to deliver message to {0}", ex.InnerExceptions[i].FailedRecipient);
|
|
//throw ex;
|
|
//smtpMail.Status = "N";
|
|
//GetStatic.EmailNotificationLog(smtpMail);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
response.SetResponseMessage(HttpStatusCode.BadRequest, ex.Message);
|
|
}
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To check the properties of a class for Null/Empty values
|
|
/// </summary>
|
|
/// <param name="obj">The instance of the class</param>
|
|
/// <returns>Result of the evaluation</returns>
|
|
public static bool IsAnyNullOrEmpty(object obj)
|
|
{
|
|
//Step 1: Set the count variable to check for the count of 2.
|
|
int count = 0;
|
|
try
|
|
{
|
|
//Step 2: Check if the incoming object has values or not.
|
|
if (obj != null)
|
|
{
|
|
//Step 3: Iterate over the properties and check for null values based on the type.
|
|
foreach (PropertyInfo pi in obj.GetType().GetProperties())
|
|
{
|
|
if (count >= 2)
|
|
{
|
|
return true;
|
|
}
|
|
dynamic value;
|
|
if (pi.PropertyType == typeof(string))
|
|
{
|
|
value = (string)pi.GetValue(obj);
|
|
if (!string.IsNullOrEmpty(value))
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
else if (pi.PropertyType == typeof(int))
|
|
{
|
|
value = (int)pi.GetValue(obj);
|
|
if (value > 0)
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
else if (pi.PropertyType == typeof(List<string>))
|
|
{
|
|
value = (List<string>)pi.GetValue(obj);
|
|
if (value != null)
|
|
{
|
|
if (value.Count > 0)
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
else if (pi.PropertyType == typeof(bool))
|
|
{
|
|
value = pi.GetValue(obj);
|
|
if (value != null)
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
//Step 4: Check if the count variable is >2 that means there is atleast one parameter passed in the body
|
|
if (count >= 2)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw ex;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static string ConvertToUnixTimestamp(string str)
|
|
{
|
|
try
|
|
{
|
|
DateTime date = Convert.ToDateTime(str);
|
|
DateTime origin = new DateTime(1970, 1, 1, 0, 0, 0, 0);
|
|
TimeSpan diff = date - origin;
|
|
return Math.Floor(diff.TotalSeconds).ToString();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
public static bool ConvertToGlobalFormat(string param)
|
|
{
|
|
try
|
|
{
|
|
if (string.IsNullOrEmpty(param))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
DateTime dt;
|
|
string[] formats = { "yyyy-MM-dd", "yyyy/MM/dd", "MM/dd/yyyy", "MM-dd-yyyy", "dd/MM/yyyy" };
|
|
if (DateTime.TryParseExact(param, formats, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out dt))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static String ShowDecimal(String strVal)
|
|
{
|
|
if (strVal != "")
|
|
return String.Format("{0:0,0.00}", double.Parse(strVal));
|
|
else
|
|
return strVal;
|
|
}
|
|
|
|
public static bool IsSupportTypeValid(string str)
|
|
{
|
|
var lstSupportType = LoadSupportType();
|
|
return lstSupportType.Contains(str) ? true : false;
|
|
}
|
|
|
|
private static List<string> LoadSupportType()
|
|
{
|
|
if (lstSupportType == null)
|
|
{
|
|
lstSupportType = new List<string>();
|
|
lstSupportType.Add("feedback");
|
|
lstSupportType.Add("enquiry");
|
|
}
|
|
return lstSupportType;
|
|
}
|
|
|
|
public static bool IsTransferTypeValid(string type)
|
|
{
|
|
var lstTransferType = LoadTransferType();
|
|
return lstTransferType.Contains(type) ? true : false;
|
|
}
|
|
|
|
private static List<string> LoadTransferType()
|
|
{
|
|
if (lstTransferType == null)
|
|
{
|
|
lstTransferType = new List<string>();
|
|
lstTransferType.Add("offer");
|
|
lstTransferType.Add("request");
|
|
}
|
|
return lstTransferType;
|
|
}
|
|
|
|
public static bool IsActionTypeValid(string type)
|
|
{
|
|
var lstActionType = LoadActionType();
|
|
return lstActionType.Contains(type) ? true : false;
|
|
}
|
|
|
|
private static List<string> LoadActionType()
|
|
{
|
|
if (lstActionType == null)
|
|
{
|
|
lstActionType = new List<string>();
|
|
lstActionType.Add("accept");
|
|
lstActionType.Add("reject");
|
|
}
|
|
return lstActionType;
|
|
}
|
|
|
|
//public static bool IsScheduleTypeValid(string type)
|
|
//{
|
|
// var lstScheduleType = LoadScheduleType();
|
|
// return lstScheduleType.Contains(type) ? true : false;
|
|
//}
|
|
//private static List<string> LoadScheduleType()
|
|
//{
|
|
// if (lstScheduleType == null)
|
|
// {
|
|
// lstScheduleType = new List<string>();
|
|
// lstScheduleType.Add("0");
|
|
// lstScheduleType.Add("1");
|
|
// }
|
|
// return lstScheduleType;
|
|
//}
|
|
public static int GetOriginalLengthInBytes(string base64string)
|
|
{
|
|
if (string.IsNullOrEmpty(base64string)) { return 0; }
|
|
|
|
var characterCount = base64string.Length;
|
|
var paddingCount = base64string.Substring(characterCount - 2, 2)
|
|
.Count(c => c == '=');
|
|
return (3 * (characterCount / 4)) - paddingCount;
|
|
}
|
|
|
|
public static string[] SelectDistinct(this string[] array)
|
|
{
|
|
return array.Distinct().ToArray();
|
|
}
|
|
|
|
public static string ReadWebConfig(string key, string defValue)
|
|
{
|
|
var Key = ConfigurationManager.AppSettings[key] ?? defValue;
|
|
return Key;
|
|
}
|
|
|
|
public static bool CheckDateType(string date)
|
|
{
|
|
DateTime dt;
|
|
string[] formats = { "yyyy-MM-dd" };
|
|
if (!DateTime.TryParseExact(date, formats,
|
|
System.Globalization.CultureInfo.InvariantCulture,
|
|
DateTimeStyles.None, out dt))
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public static KYCConfigDto GetKYCSettings(KycRequest obj)
|
|
{
|
|
KYCConfigDto dt = new KYCConfigDto() { Config = new TrustDocConfig(), Options = new List<KYCOption>() };
|
|
KYCConfig referenceMaps = new KYCConfig();
|
|
|
|
//string mappingPath = mappingPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, obj.DeviceType.ToLower().Equals("android") ? "config\\KycConfig-uat.json" : ConfigurationManager.AppSettings["KycConfigFilePath"].ToString());
|
|
|
|
string mappingPath = mappingPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ConfigurationManager.AppSettings["KycConfigFilePath"].ToString());
|
|
using (StreamReader reader = File.OpenText(mappingPath))
|
|
{
|
|
var jsonS = reader.ReadToEnd();
|
|
referenceMaps = Newtonsoft.Json.JsonConvert.DeserializeObject<KYCConfig>(jsonS);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(obj.DeviceType))
|
|
{
|
|
dt.Config = referenceMaps.Config.Where(x => x.DeviceType.ToLower().Equals(obj.DeviceType.ToLower())).SingleOrDefault();
|
|
|
|
}
|
|
|
|
dt.Options = referenceMaps.Options;
|
|
|
|
return dt;
|
|
}
|
|
|
|
public static List<Option> GetPaymetMethods()
|
|
{
|
|
List<Option> options = new List<Option>();
|
|
|
|
string mappingPath = mappingPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ConfigurationManager.AppSettings["PaymentConfigFilePath"].ToString());
|
|
using (StreamReader reader = File.OpenText(mappingPath))
|
|
{
|
|
var jsonS = reader.ReadToEnd();
|
|
options = Newtonsoft.Json.JsonConvert.DeserializeObject<List<Option>>(jsonS);
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
public static List<ReferenceMap> GetReferenceMaps()
|
|
{
|
|
List<ReferenceMap> referenceMaps = new List<ReferenceMap>();
|
|
|
|
string mappingPath = mappingPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ConfigurationManager.AppSettings["MappingFilePath"].ToString());
|
|
|
|
using (StreamReader reader = File.OpenText(mappingPath))
|
|
{
|
|
var jsonS = reader.ReadToEnd();
|
|
referenceMaps = Newtonsoft.Json.JsonConvert.DeserializeObject<List<Model.Config.ReferenceMap>>(jsonS);
|
|
}
|
|
|
|
return referenceMaps;
|
|
}
|
|
|
|
public static List<ReferenceMap> GetReferenceMaps(MappingType type)
|
|
{
|
|
var lstReferences = GetReferenceMaps().Where(x => x.Type.Equals(type.ToString()));
|
|
|
|
return lstReferences.ToList();
|
|
}
|
|
|
|
public static Mapping GetMapping(MappingType type, string keyValue = "")
|
|
{
|
|
Mapping map = new Mapping();
|
|
try
|
|
{
|
|
if (string.IsNullOrEmpty(keyValue))
|
|
{
|
|
return new Mapping();
|
|
}
|
|
|
|
var lstReferences = GetReferenceMaps().Where(x => x.Type.Equals(type.ToString())).SingleOrDefault();
|
|
|
|
map = lstReferences.Mappings.FirstOrDefault(x => (!String.IsNullOrEmpty(x.field) ? x.field.Trim().ToUpper() : "").Equals(keyValue.ToUpper().Trim()));
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw e;
|
|
}
|
|
return map != null ? map : new Mapping();
|
|
}
|
|
|
|
#region LANGUAGE MAPPING
|
|
|
|
public static List<LanguageMap> GetReferenceLangMaps()
|
|
{
|
|
|
|
List<LanguageMap> referenceMaps = new List<LanguageMap>();
|
|
|
|
string mappingPath = mappingPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ConfigurationManager.AppSettings["LangFilePath"].ToString());
|
|
|
|
using (StreamReader reader = File.OpenText(mappingPath))
|
|
{
|
|
var jsonS = reader.ReadToEnd();
|
|
referenceMaps = Newtonsoft.Json.JsonConvert.DeserializeObject<List<LanguageMap>>(jsonS);
|
|
}
|
|
|
|
|
|
return referenceMaps;
|
|
}
|
|
#endregion
|
|
|
|
|
|
public static LanguageMap GetLanguageMapping(string keyValue, string lang = "en")
|
|
{
|
|
LanguageMap map = new LanguageMap();
|
|
try
|
|
{
|
|
if (string.IsNullOrEmpty(keyValue))
|
|
{
|
|
return new LanguageMap();
|
|
}
|
|
|
|
if (lang.Equals("np"))
|
|
{
|
|
lang = "ne";
|
|
}
|
|
else if (lang.Equals("bd"))
|
|
{
|
|
lang = "bn";
|
|
}
|
|
else if (lang.Equals("vn"))
|
|
{
|
|
lang = "vi";
|
|
}
|
|
|
|
map = GetReferenceLangMaps().FirstOrDefault(x => x.Key.ToUpper().Equals(keyValue.ToUpper())
|
|
&& (!String.IsNullOrEmpty(x.Lang) ? x.Lang.Trim().ToUpper() : "EN").Equals(lang.ToUpper().Trim()));
|
|
|
|
if (map != null && string.IsNullOrEmpty(map.Message))
|
|
{
|
|
map = GetReferenceLangMaps().FirstOrDefault(x => x.Key.ToUpper().Equals(keyValue.ToUpper()) && x.Lang.Trim().ToUpper().Equals("EN"));
|
|
}
|
|
else if (map == null)
|
|
{
|
|
map = GetReferenceLangMaps().FirstOrDefault(x => x.Key.ToUpper().Equals(keyValue.ToUpper()) && x.Lang.Trim().ToUpper().Equals("EN"));
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw e;
|
|
}
|
|
return map != null ? map : new LanguageMap();
|
|
}
|
|
|
|
// Reflection
|
|
public static List<KeyValuePair> GetPropertiesNameOfClass(this object atype)
|
|
{
|
|
if (atype == null) return new List<KeyValuePair>();
|
|
Type t = atype.GetType();
|
|
PropertyInfo[] props = t.GetProperties(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
|
|
List<KeyValuePair> dict = new List<KeyValuePair>();
|
|
foreach (PropertyInfo prp in props)
|
|
{
|
|
object propValue = prp.GetValue(atype, new object[] { });
|
|
|
|
dict.Add(new KeyValuePair { Key = prp.Name, Value = propValue != null ? propValue.ToString() : "" });
|
|
}
|
|
|
|
var bankId = GetPropertyValue(atype, "agent.id");
|
|
dict.Add(new KeyValuePair { Key = "agent.id", Value = bankId != null ? bankId.ToString() : "" });
|
|
|
|
var bankname = GetPropertyValue(atype, "agent.name");
|
|
dict.Add(new KeyValuePair { Key = "agent.name", Value = bankname != null ? bankname.ToString() : "" });
|
|
|
|
var branch = GetPropertyValue(atype, "agent.branch.id");
|
|
dict.Add(new KeyValuePair { Key = "agent.branch.id", Value = branch != null ? branch.ToString() : "" });
|
|
|
|
var accountno = GetPropertyValue(atype, "agent.accountNo");
|
|
dict.Add(new KeyValuePair { Key = "agent.accountNo", Value = accountno != null ? accountno.ToString() : "" });
|
|
return dict;
|
|
}
|
|
|
|
|
|
public static object GetPropertyValue(object src, string propName)
|
|
{
|
|
if (src == null)
|
|
return null;
|
|
if (propName == null) throw new ArgumentException("Value cannot be null.", "propName");
|
|
|
|
if (propName.Contains("."))//complex type nested
|
|
{
|
|
var temp = propName.Split(new char[] { '.' }, 2);
|
|
return GetPropertyValue(GetPropertyValue(src, temp[0]), temp[1]);
|
|
}
|
|
else
|
|
{
|
|
var prop = src.GetType().GetProperty(propName);
|
|
return prop != null ? prop.GetValue(src, null) : null;
|
|
}
|
|
}
|
|
|
|
public static string GetFullName(string fname, string mname, string lname)
|
|
{
|
|
string fullName = string.Empty;
|
|
fullName = string.Format("{0} {1}", (!string.IsNullOrEmpty(mname)) ? fname + " " + mname : fname, lname);
|
|
return fullName;
|
|
}
|
|
|
|
public static string getUKFormattedNumber(this string number)
|
|
{
|
|
string finalNo = number;
|
|
if (!number.Contains("+44"))
|
|
{
|
|
string mobileFirst = number.Substring(0, 1);
|
|
if (mobileFirst == "0")
|
|
{
|
|
if (number.Length == 11)
|
|
{
|
|
finalNo = "+44" + number.Substring(1, number.Length - 1);
|
|
return finalNo;
|
|
}
|
|
else if (number.Length < 11)
|
|
{
|
|
finalNo = $"+44{number}";
|
|
}
|
|
}
|
|
else if (number.Substring(0, 1) != "0" && number.Length == 10)
|
|
{
|
|
finalNo = $"+44{number}";
|
|
}
|
|
}
|
|
else if (number.Contains("+44"))
|
|
{
|
|
string MobN = number.Substring(4, 1);
|
|
if (MobN == "0" && number.Length > 14)
|
|
{
|
|
finalNo = number.Remove(4, 1);
|
|
}
|
|
}
|
|
if (!finalNo.Substring(0, 1).Contains("+"))
|
|
{
|
|
|
|
finalNo = $"+{finalNo}";
|
|
}
|
|
return finalNo;
|
|
}
|
|
}
|
|
}
|