Pro_User

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Models
{
    public class Pro_UserMaster
    {
        public string Mode { get; set; }
        public int UserId { get; set; }
        public string ContactNo { get; set; }
        public string UserName { get; set; }
        public string EmailId { get; set; }
        public string Sex { get; set; }
        private DateTime _Birthdate = Convert.ToDateTime("01/01/1900");
        public DateTime Birthdate
        {
            get { return _Birthdate; }
            set { _Birthdate = value; }
        }
        public string Birthdate1 { get; set; }
        public bool Status { get; set; }
        public bool Flag { get; set; }
        public string AboutYou { get; set; }
        public string Intrestes { get; set; }
        public string Hobbies { get; set; }
        public string Favoritemovies { get; set; }
        public string LookingFor { get; set; }
        public string ProfilePic { get; set; }
        public string Latitude { get; set; }
        public string Longitude { get; set; }
        public bool IsOnline { get; set; }

        public int? page { get; set; }
        public string MultiIDs { get; set; }
        public string SortBy { get; set; }
        public string SortOrder { get; set; }
        public string SearchField { get; set; }
        public string SearchValue { get; set; }
        public string Name { get; set; }
        public string IsActive { get; set; }
        public string CreatedFrom { get; set; }
        public string CreatedTo { get; set; }
        private DateTime _CreatedOn = Convert.ToDateTime("01/01/1900");
        public DateTime CreatedOn
        {
            get { return _CreatedOn; }
            set { _CreatedOn = value; }
        }
        public string DeviceId { get; set; }
        public string DeviceType { get; set; }
        public string ContentType { get; set; }
        public int ChatCount { get; set; }
    }
}

DB_Helper

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.Common;
using System.Linq;
using System.Web;
using System.Data.SqlClient;
using System.IO;

namespace Models
{
    public class DBHelper
    {
        #region "Private Members"

        private string _ConnString;
        private DbConnection _Connection;
        private DbCommand _Command;
        private DbProviderFactory _Factory = null;

        #endregion

        #region "Cunstructor"
        ///<summary>
        /// Cunstructor
        ///</summary>      
        public DBHelper()
        {
            this._ConnString = string.Empty;
            this.CreateConnection();
        }
        #endregion

        #region "Properties"

        /// <summary>
        /// Gets or Sets the Connection string for the database
        /// </summary>
        public string ConnString
        {
            get { return _ConnString; }
            set
            {
                if (value != string.Empty)
                {
                    _ConnString = value;
                }
            }
        }

        /// <summary>
        /// Gets the Connection object for the database
        /// </summary>
        public DbConnection Connection
        {
            get { return _Connection; }
        }

        /// <summary>
        /// Gets the Command object for the database
        /// </summary>
        public DbCommand Command
        {
            get { return _Command; }
        }

        #endregion

        # region "Methods"

        public void CreateConnection()
        {
            CreateDBObjects(ConfigurationManager.ConnectionStrings["ConnString"].ToString(),
                ConfigurationManager.ConnectionStrings["ConnString"].ProviderName);
        }

        /// <summary>
        /// Determines the correct provider to use and sets up the Connection and Command
        /// objects for use in other methods
        /// </summary>
        /// <param name="connectString">The full Connection string to the database</param>
        /// <param name="providerlist">The enum value of providers from dbutilities.Providers</param>
        public void CreateDBObjects(string connectString, string strProvider)
        {
            _Factory = DbProviderFactories.GetFactory(strProvider);
            _Connection = _Factory.CreateConnection();
            _Command = _Factory.CreateCommand();

            _Connection.ConnectionString = connectString;
            _Command.Connection = Connection;
        }

        #region "Parameters"

        /// <summary>
        /// Creates a parameter and adds it to the Command object
        /// </summary>
        /// <param name="name">The parameter name</param>
        /// <param name="value">The paremeter value</param>
        /// <returns></returns>
        public int AddParameter(string name, object value)
        {
            DbParameter parm = _Factory.CreateParameter();
            parm.ParameterName = name;
            parm.Value = value;
            return Command.Parameters.Add(parm);
        }

        /// <summary>
        /// Creates a parameter and adds it to the Command object
        /// </summary>
        /// <param name="parameter">A parameter object</param>      
        public int AddParameter(DbParameter parameter)
        {
            return Command.Parameters.Add(parameter);
        }

        /// <summary>
        /// Creates a parameter and adds it to the Command object
        /// </summary>
        /// <param name="name">A parameter Name</param>
        /// <param name="Value">A parameter Value</param>
        /// <param name="dbType">A parameter data type</param>
        public int AddParameter(string name, object value, DbType dbtype)
        {
            DbParameter parm = _Factory.CreateParameter();
            parm.ParameterName = name;
            parm.Value = value;
            parm.DbType = dbtype;
            return Command.Parameters.Add(parm);
        }

        /// <summary>
        /// Creates a parameter and adds it to the Command object
        /// </summary>
        /// <param name="name">A parameter Name</param>
        /// <param name="Value">A parameter Value</param>
        /// <param name="dbType">A parameter data type</param>
        /// <param name="size">A prameter size in int</param>
        public int AddParameter(string name, object value, DbType dbtype, int size)
        {
            DbParameter parm = _Factory.CreateParameter();
            parm.ParameterName = name;
            parm.Value = value;
            parm.DbType = dbtype;
            parm.Size = size;
            return Command.Parameters.Add(parm);
        }

        /// <summary>
        /// Creates a parameter and adds it to the Command object
        /// </summary>
        /// <param name="name">A parameter Name</param>
        /// <param name="Value">A parameter Value</param>
        /// <param name="dbType">A parameter data type</param>
        /// <param name="Direction">A prameter Direction</param>
        public int AddParameter(string name, object value, DbType dbtype, ParameterDirection direction)
        {
            DbParameter parm = _Factory.CreateParameter();
            parm.ParameterName = name;
            parm.Value = value;
            parm.DbType = dbtype;
            parm.Direction = direction;
            return Command.Parameters.Add(parm);
        }

        /// <summary>
        /// Creates a parameter and adds it to the Command object
        /// </summary>
        /// <param name="name">A parameter Name</param>
        /// <param name="Value">A parameter Value</param>
        /// <param name="dbType">A parameter data type</param>
        /// <param name="size">A prameter size in int</param>
        /// <param name="Direction">A prameter Direction</param>
        public int AddParameter(string name, object value, DbType dbtype, int size, ParameterDirection direction)
        {
            DbParameter parm = _Factory.CreateParameter();
            parm.ParameterName = name;
            parm.Value = value;
            parm.DbType = dbtype;
            parm.Size = size;
            parm.Direction = direction;
            return Command.Parameters.Add(parm);
        }

        #endregion

        #region "DB Transactions"

        /// <summary>
        /// Starts a transaction for the Command object
        /// </summary>
        private void BeginTransaction()
        {
            if (Connection.State.Equals(ConnectionState.Closed))
            {
                Connection.Open();
            }
            Command.Transaction = Connection.BeginTransaction();
        }

        /// <summary>
        /// Commits a transaction for the Command object
        /// </summary>
        private void CommitTransaction()
        {
            Command.Transaction.Commit();
            Connection.Close();
        }

        /// <summary>
        /// Rolls back the transaction for the Command object
        /// </summary>
        private void RollbackTransaction()
        {
            Command.Transaction.Rollback();
            Connection.Close();
        }

        #endregion

        #region "Execute DB Functions"

        /// <summary>
        /// Executes a statement that does not return a result set, such as an INSERT, UPDATE, DELETE, or a data definition statement
        /// </summary>
        /// <param name="query">The query, either SQL or Procedures</param>
        /// <param name="Commandtype">The Command type, text, storedprocedure, or tabledirect</param>
        /// <param name="Connectionstate">The Connection state</param>
        /// <returns>An integer value</returns>
        public int ExecuteNonQuery(string commandText, CommandType commandType)
        {
            Command.CommandText = commandText;
            Command.CommandType = commandType;
            int i = -1;

            try
            {
                if (Connection.State.Equals(ConnectionState.Closed))
                {
                    Connection.Open();
                }

                //BeginTransaction();

                i = Command.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                //RollbackTransaction();
                throw (ex);
            }
            finally
            {
                //CommitTransaction();
                Command.Parameters.Clear();

                if (Connection.State.Equals(ConnectionState.Open))
                {
                    Connection.Close();
                    Connection.Dispose();
                }
            }

            return i;
        }

        /// <summary>
        /// Executes a statement that returns a single value.
        /// If this method is called on a query that returns multiple rows and columns, only the first column of the first row is returned.
        /// </summary>
        /// <param name="query">The query, either SQL or Procedures</param>
        /// <param name="Commandtype">The Command type, text, storedprocedure, or tabledirect</param>
        /// <param name="Connectionstate">The Connection state</param>
        /// <returns>An object that holds the return value(s) from the query</returns>
        public object ExecuteScaler(string commandText, CommandType commandType)
        {
            Command.CommandText = commandText;
            Command.CommandType = commandType;
            object obj = null;
            try
            {
                if (Connection.State.Equals(ConnectionState.Closed))
                {
                    Connection.Open();
                }

                BeginTransaction();
                obj = Command.ExecuteScalar();
            }
            catch (Exception ex)
            {
                RollbackTransaction();
                throw (ex);
            }
            finally
            {
                CommitTransaction();
                Command.Parameters.Clear();

                if (Connection.State.Equals(ConnectionState.Open))
                {
                    Connection.Close();
                    Connection.Dispose();
                    Command.Dispose();
                }
            }

            return obj;
        }

        /// <summary>
        /// Executes a SQL statement that returns a result set.
        /// </summary>
        /// <param name="query">The query, either SQL or Procedures</param>
        /// <param name="Commandtype">The Command type, text, storedprocedure, or tabledirect</param>
        /// <param name="Connectionstate">The Connection state</param>
        /// <returns>A datareader object</returns>
        public DbDataReader ExecuteReader(string query, CommandType Commandtype)
        {
            //this.CreateConnection();
            Command.CommandText = query;
            Command.CommandType = Commandtype;
            DbDataReader reader = null;
            try
            {
                if (Connection.State.Equals(ConnectionState.Closed))
                {
                    Connection.Open();
                }
                reader = Command.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                throw (ex);
            }
            finally
            {
                Command.Parameters.Clear();
            }

            return reader;
        }

        /// <summary>
        /// Generates a dataset
        /// </summary>
        /// <param name="query">The query, either SQL or Procedures</param>
        /// <param name="Commandtype">The Command type, text, storedprocedure, or tabledirect</param>
        /// <param name="Connectionstate">The Connection state</param>
        /// <returns>A dataset containing data from the database</returns>
        public DataSet GetDataSet(string query, CommandType Commandtype)
        {
            DbDataAdapter adapter = _Factory.CreateDataAdapter();
            Command.CommandText = query;
            Command.CommandType = Commandtype;
            adapter.SelectCommand = Command;
            DataSet ds = new DataSet();
            try
            {
                adapter.Fill(ds);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                Command.Parameters.Clear();

                if (Connection.State.Equals(ConnectionState.Open))
                {
                    Connection.Close();
                    Connection.Dispose();
                    Command.Dispose();
                }
            }
            return ds;
        }

        /// <summary>
        /// Generates a dataset
        /// </summary>
        /// <param name="query">The query, either SQL or Procedures</param>
        /// <param name="Commandtype">The Command type, text, storedprocedure, or tabledirect</param>
        /// <param name="Connectionstate">The Connection state</param>
        /// <returns>A dataset containing data from the database</returns>
        public DataSet GetDataSet(string query, CommandType Commandtype, string tableName)
        {
            DbDataAdapter adapter = _Factory.CreateDataAdapter();
            Command.CommandText = query;
            Command.CommandType = Commandtype;
            adapter.SelectCommand = Command;
            DataSet ds = new DataSet();
            try
            {
                adapter.Fill(ds, tableName);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                Command.Parameters.Clear();

                if (Connection.State.Equals(ConnectionState.Open))
                {
                    Connection.Close();
                    Connection.Dispose();
                    Command.Dispose();
                }
            }
            return ds;
        }

        #endregion

        #endregion
    }
}

User_Dal.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Demo.Repository;
using Demo.Models;
using PagedList;
using System.Data;
using System.Data.Common;
using Demo.Models;
using System.Data.SqlClient;
using System.Configuration;
using Demo.Helpers;
using System.Threading;
using Demo.PushNotification;

namespace Repository
{
    public class UserRepository
    {
        #region "Declaration"

        private static DBHelper objDBHelper = new DBHelper();
        private string SPName = "SP_UserMaster";
        private string key = "Users";

        #endregion

        #region "Add Parameter"
        private void AddParameter(Pro_UserMaster objPro_UserMaster)
        {
            objDBHelper.Command.Parameters.Clear();
            objDBHelper.AddParameter("@Mode", objPro_UserMaster.Mode);
            objDBHelper.AddParameter("@UserId", objPro_UserMaster.UserId, DbType.Int32);
            objDBHelper.AddParameter("@ContactNo", objPro_UserMaster.ContactNo);
            objDBHelper.AddParameter("@UserName", objPro_UserMaster.UserName);
            objDBHelper.AddParameter("@EmailId", objPro_UserMaster.EmailId);
            objDBHelper.AddParameter("@Sex", objPro_UserMaster.Sex);
            objDBHelper.AddParameter("@Status", objPro_UserMaster.Status);
            objDBHelper.AddParameter("@Birthdate", objPro_UserMaster.Birthdate);
            objDBHelper.AddParameter("@AboutYou", objPro_UserMaster.AboutYou);
            objDBHelper.AddParameter("@Intrestes", objPro_UserMaster.Intrestes);
            objDBHelper.AddParameter("@Hobbies", objPro_UserMaster.Hobbies);
            objDBHelper.AddParameter("@Favoritemovies", objPro_UserMaster.Favoritemovies);
            objDBHelper.AddParameter("@LookingFor", objPro_UserMaster.LookingFor);
            objDBHelper.AddParameter("@ProfilePic", objPro_UserMaster.ProfilePic);
            objDBHelper.AddParameter("@CreatedOn", objPro_UserMaster.CreatedOn);
            objDBHelper.AddParameter("@DeviceId", objPro_UserMaster.DeviceId);
            objDBHelper.AddParameter("@DeviceType", objPro_UserMaster.DeviceType);

            objDBHelper.AddParameter("@MultiIDs", objPro_UserMaster.MultiIDs);
            objDBHelper.AddParameter("@SortBy", objPro_UserMaster.SortBy);
            objDBHelper.AddParameter("@SortOrder", objPro_UserMaster.SortOrder);
            objDBHelper.AddParameter("@SearchField", objPro_UserMaster.SearchField);
            objDBHelper.AddParameter("@SearchValue", objPro_UserMaster.SearchValue);
            objDBHelper.AddParameter("@Name", objPro_UserMaster.Name);
            objDBHelper.AddParameter("@IsActive", objPro_UserMaster.IsActive);
            objDBHelper.AddParameter("@CreatedFrom", objPro_UserMaster.CreatedFrom);
            objDBHelper.AddParameter("@CreatedTo", objPro_UserMaster.CreatedTo);
        }
        #endregion

        #region "Functions"
        public IEnumerable<Pro_UserMaster> GetUsers(Pro_UserMaster objPro_UserMaster)
        {
            objDBHelper = new DBHelper();
            List<Pro_UserMaster> obj_Pro_UserMasterList = new List<Pro_UserMaster>();
            try
            {
                AddParameter(objPro_UserMaster);
                using (SqlDataReader SqlReader = (SqlDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    while (SqlReader.Read())
                    {
                        Pro_UserMaster obj_Pro_UserMaster = new Pro_UserMaster();
                        obj_Pro_UserMaster.UserId = CommanLogic.GetIntValue(SqlReader["UserId"], 0);
                        obj_Pro_UserMaster.UserName = CommanLogic.GetStringValue(SqlReader["UserName"], string.Empty);
                        obj_Pro_UserMaster.ContactNo = CommanLogic.GetStringValue(SqlReader["ContactNo"], string.Empty);
                        obj_Pro_UserMaster.EmailId = CommanLogic.GetStringValue(SqlReader["EmailId"], string.Empty);
                        obj_Pro_UserMaster.Sex = CommanLogic.GetStringValue(SqlReader["Sex"], string.Empty);
                        DateTime date = CommanLogic.GetDateTimeValue(SqlReader["Birthdate"]);
                        obj_Pro_UserMaster.Birthdate1 = string.Format("{0:dd/MM/yyyy}", date);
                        obj_Pro_UserMaster.Birthdate = CommanLogic.GetDateTimeValue(SqlReader["Birthdate"]);
                        obj_Pro_UserMaster.AboutYou = CommanLogic.GetStringValue(SqlReader["AboutYou"]);
                        obj_Pro_UserMaster.Intrestes = CommanLogic.GetStringValue(SqlReader["Intrestes"]);
                        obj_Pro_UserMaster.Hobbies = CommanLogic.GetStringValue(SqlReader["Hobbies"]);
                        obj_Pro_UserMaster.Favoritemovies = CommanLogic.GetStringValue(SqlReader["Favoritemovies"]);
                        obj_Pro_UserMaster.Status = CommanLogic.GetBoolValue(SqlReader["Status"]);
                        obj_Pro_UserMasterList.Add(obj_Pro_UserMaster);
                    }
                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return obj_Pro_UserMasterList;
        }

        public IEnumerable<Pro_UserMaster> GetUsersByIDs(string ListofUsers)
        {
            objDBHelper = new DBHelper();
            List<Pro_UserMaster> obj_Pro_UserMasterList = new List<Pro_UserMaster>();
            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", "SelectListofUsers");
                objDBHelper.AddParameter("@MultiIDs", ListofUsers);
                using (SqlDataReader SqlReader = (SqlDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    while (SqlReader.Read())
                    {
                        Pro_UserMaster obj_Pro_UserMaster = new Pro_UserMaster();
                        obj_Pro_UserMaster.UserId = CommanLogic.GetIntValue(SqlReader["UserId"], 0);
                        obj_Pro_UserMaster.UserName = CommanLogic.GetStringValue(SqlReader["UserName"], string.Empty);
                        obj_Pro_UserMaster.ContactNo = CommanLogic.GetStringValue(SqlReader["ContactNo"], string.Empty);
                        obj_Pro_UserMaster.EmailId = CommanLogic.GetStringValue(SqlReader["EmailId"], string.Empty);
                        obj_Pro_UserMaster.Sex = CommanLogic.GetStringValue(SqlReader["Sex"], string.Empty);
                        DateTime date = CommanLogic.GetDateTimeValue(SqlReader["Birthdate"]);
                        obj_Pro_UserMaster.Birthdate1 = string.Format("{0:dd/MM/yyyy}", date);
                        obj_Pro_UserMaster.Birthdate = CommanLogic.GetDateTimeValue(SqlReader["Birthdate"]);
                        obj_Pro_UserMaster.AboutYou = CommanLogic.GetStringValue(SqlReader["AboutYou"]);
                        obj_Pro_UserMaster.Intrestes = CommanLogic.GetStringValue(SqlReader["Intrestes"]);
                        obj_Pro_UserMaster.Hobbies = CommanLogic.GetStringValue(SqlReader["Hobbies"]);
                        obj_Pro_UserMaster.Favoritemovies = CommanLogic.GetStringValue(SqlReader["Favoritemovies"]);
                        obj_Pro_UserMaster.Status = CommanLogic.GetBoolValue(SqlReader["Status"]);
                        obj_Pro_UserMasterList.Add(obj_Pro_UserMaster);
                    }
                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return obj_Pro_UserMasterList;
        }

        public object GetUserCount()
        {
            objDBHelper = new DBHelper();
            try
            {
                objDBHelper.AddParameter("@Mode", "GetUserCount");
                return (objDBHelper.ExecuteScaler(SPName, CommandType.StoredProcedure));
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                CacheHelper.Clear(key);
                objDBHelper = null;
            }
        }

        public object SaveUser(Pro_UserMaster user)
        {
            objDBHelper = new DBHelper();
            try
            {
                if (user.UserId > 0)
                    user.Mode = "UPDATE";
                else
                    user.Mode = "INSERT";

                AddParameter(user);
                return objDBHelper.ExecuteScaler(SPName, CommandType.StoredProcedure);

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                CacheHelper.Clear(key);
                objDBHelper = null;
            }
        }

        public Pro_UserMaster GetUserById(int id)
        {
            objDBHelper = new DBHelper();
            Pro_UserMaster objUser = new Pro_UserMaster();
            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", "SelectUserById");
                objDBHelper.AddParameter("@UserId", id);

                using (DbDataReader dr = (DbDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (dr.Read())
                    {
                        objUser.UserId = CommanLogic.GetIntValue(dr["UserId"], 0);
                        objUser.UserName = CommanLogic.GetStringValue(dr["UserName"], string.Empty);
                        objUser.ContactNo = CommanLogic.GetStringValue(dr["ContactNo"], string.Empty);
                        objUser.EmailId = CommanLogic.GetStringValue(dr["EmailId"], string.Empty);
                        objUser.Sex = CommanLogic.GetStringValue(dr["Sex"], string.Empty);
                        //DateTime date = Convert.ToDateTime(dr["Birthdate"]);
                        //objUser.Birthdate1 = string.Format("{0:dd/MM/yyyy}", date);
                        //objUser.Birthdate = CommanLogic.GetDateTimeValue(dr["Birthdate"]);
                        DateTime date = CommanLogic.GetDateTimeValue(dr["Birthdate"]);
                        objUser.Birthdate = date.Date;
                        objUser.AboutYou = CommanLogic.GetStringValue(dr["AboutYou"]);
                        objUser.Intrestes = CommanLogic.GetStringValue(dr["Intrestes"]);
                        objUser.Hobbies = CommanLogic.GetStringValue(dr["Hobbies"]);
                        objUser.Favoritemovies = CommanLogic.GetStringValue(dr["Favoritemovies"]);
                        objUser.Status = CommanLogic.GetBoolValue(dr["Status"]);                      
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return objUser;
        }

        public Pro_UserMaster_Api GetUserProfile(int UserId)
        {
            objDBHelper = new DBHelper();
            Pro_UserMaster_Api objUser = new Pro_UserMaster_Api();
            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", "SelectUserProfile");
                objDBHelper.AddParameter("@UserId", UserId);

                using (DbDataReader dr = (DbDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (dr.Read())
                    {
                        objUser.UserId = CommanLogic.GetIntValue(dr["UserId"], 0);
                        objUser.UserName = CommanLogic.GetStringValue(dr["UserName"], string.Empty);
                        objUser.ContactNo = CommanLogic.GetStringValue(dr["ContactNo"], string.Empty);
                        objUser.EmailId = CommanLogic.GetStringValue(dr["EmailId"], string.Empty);
                        objUser.Sex = CommanLogic.GetStringValue(dr["Sex"], string.Empty);

                        DateTime dt = CommanLogic.GetDateTimeValue(dr["Birthdate"]);
                        if (dt.ToString() == "1/1/1900 12:00:00 AM")
                            objUser.Birthdate = "";
                        else
                            objUser.Birthdate = string.Format("{0:yyyy-MM-dd}", dt);
                        objUser.AboutYou = CommanLogic.GetStringValue(dr["AboutYou"]);
                        objUser.Intrestes = CommanLogic.GetStringValue(dr["Intrestes"]);
                        objUser.Hobbies = CommanLogic.GetStringValue(dr["Hobbies"]);
                        objUser.Favoritemovies = CommanLogic.GetStringValue(dr["Favoritemovies"]);
                        objUser.LookingFor = CommanLogic.GetStringValue(dr["LookingFor"]);
                        objUser.Status = CommanLogic.GetBoolValue(dr["Status"]);
                        //objUser.DeviceId = CommanLogic.GetStringValue(dr["DeviceId"]);
                        //objUser.DeviceType = CommanLogic.GetStringValue(dr["DeviceType"]);
                        if (!string.IsNullOrEmpty(dr["ProfilePic"].ToString()))
                        {
                            objUser.ImagePath = ConstantValues.RootUrl + "ProfilePicture/" + CommanLogic.GetStringValue(dr["ProfilePic"], string.Empty);
                            objUser.ThumbImagePath = ConstantValues.RootUrl + "ProfilePicture/Thumb_" + CommanLogic.GetStringValue(dr["ProfilePic"], string.Empty);
                        }
                        else
                        {
                            objUser.ImagePath = "";
                            objUser.ThumbImagePath = "";
                        }
                        objUser.RegistrationDate = Convert.ToDateTime(new UserRepository().Getdate());
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return objUser;
        }

        public Pro_UserMaster_Api GetFeaturedMember(int UserId)
        {
            objDBHelper = new DBHelper();
            Pro_UserMaster_Api objUser = new Pro_UserMaster_Api();
            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", "SelectFeaturedMember");
                objDBHelper.AddParameter("@UserId", UserId);

                using (DbDataReader dr = (DbDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (dr.Read())
                    {
                        int U_id = Convert.ToInt32(CommanLogic.GetIntValue(dr["UserId"]));

                        if (U_id == 0)
                        {
                            objUser.UserId = 0;
                        }
                        else
                        {
                            objUser.UserId = CommanLogic.GetIntValue(dr["UserId"], 0);
                            objUser.UserName = CommanLogic.GetStringValue(dr["UserName"], string.Empty);
                            objUser.ContactNo = CommanLogic.GetStringValue(dr["ContactNo"], string.Empty);
                            objUser.EmailId = CommanLogic.GetStringValue(dr["EmailId"], string.Empty);
                            objUser.Sex = CommanLogic.GetStringValue(dr["Sex"], string.Empty);
                            DateTime dt = CommanLogic.GetDateTimeValue(dr["Birthdate"]);
                            objUser.Birthdate = string.Format("{0:dd/MM/yyyy}", dt);
                            objUser.AboutYou = CommanLogic.GetStringValue(dr["AboutYou"]);
                            objUser.Intrestes = CommanLogic.GetStringValue(dr["Intrestes"]);
                            objUser.Hobbies = CommanLogic.GetStringValue(dr["Hobbies"]);
                            objUser.Favoritemovies = CommanLogic.GetStringValue(dr["Favoritemovies"]);
                            objUser.Latitude = CommanLogic.GetStringValue(dr["Latitude"]);
                            objUser.Longitude = CommanLogic.GetStringValue(dr["Longitude"]);
                            objUser.Status = CommanLogic.GetBoolValue(dr["Status"]);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return objUser;
        }

        public object MultiProcess(string strMultiVal, string strMode)
        {
            objDBHelper = new DBHelper();

            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", strMode);
                objDBHelper.AddParameter("@MultiIDs", strMultiVal);
                return (objDBHelper.ExecuteScaler(SPName, CommandType.StoredProcedure));
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                CacheHelper.Clear(key);
                objDBHelper = null;
            }
        }
        public object DeleteUser(int userId)
        {
            objDBHelper = new DBHelper();
            try
            {
                objDBHelper.AddParameter("@UserId", userId);
                objDBHelper.AddParameter("@Mode", "DeleteUser");
                return (objDBHelper.ExecuteScaler(SPName, CommandType.StoredProcedure));
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                CacheHelper.Clear(key);
                objDBHelper = null;
            }
        }
        #endregion

        #region "Web Api Services"
        public object AuthentucateUser(string EmailId, string ContactNo)
        {
            objDBHelper = new DBHelper();
            try
            {
                objDBHelper.AddParameter("@Mode", "AuthenticateUser");
                objDBHelper.AddParameter("@EmailId", EmailId);
                objDBHelper.AddParameter("@ContactNo", ContactNo);
                return (objDBHelper.ExecuteScaler(SPName, CommandType.StoredProcedure));
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                CacheHelper.Clear(key);
                objDBHelper = null;
            }
        }

        public bool USerExists(string EmailId)
        {
            objDBHelper = new DBHelper();
            try
            {
                objDBHelper.AddParameter("@Mode", "AuthenticateUser");
                objDBHelper.AddParameter("@EmailId", EmailId);
           
                return (Convert.ToBoolean(objDBHelper.ExecuteScaler(SPName, CommandType.StoredProcedure)));
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                CacheHelper.Clear(key);
                objDBHelper = null;
            }
        }

        public Pro_UserDetail InsertUser(Pro_UserMaster user)
        {
            objDBHelper = new DBHelper();
            Pro_UserDetail objUser = new Pro_UserDetail();
            try
            {
                user.Mode = "INSERT";
                user.CreatedOn = DateTime.UtcNow;
                AddParameter(user);

                using (DbDataReader dr = (DbDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (dr.Read())
                    {
                        objUser.Message = CommanLogic.GetStringValue(dr["MSG"]);
                        objUser.UserId = CommanLogic.GetIntValue(dr["UserId"], 0);
                        objUser.CreatedOn = Convert.ToString(CommanLogic.GetDateTimeValue(dr["CreatedOn"]).ToString("yyyy-MM-dd HH:mm:ss"));
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return objUser;
        }
        public object SaveProfile(Pro_UserMaster user)
        {
            objDBHelper = new DBHelper();
            try
            {
                AddParameter(user);

                int UserId = Convert.ToInt32(objDBHelper.ExecuteScaler(SPName, CommandType.StoredProcedure));
                if (UserId > 0)
                {
                    new Thread(() =>
                    {
                        Thread.CurrentThread.IsBackground = true;
                        /* run your code here */
                        new PushHelper().SendUpdateProfilePushnotification(UserId);
                    }).Start();
                }

                return (UserId);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                //CacheHelper.Clear(key);
                objDBHelper = null;
            }
        }

        public string GetProfilePic(int UserId)
        {
            string ProfilePic = string.Empty;
            objDBHelper = new DBHelper();
            Pro_UserMaster objUser = new Pro_UserMaster();
            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", "GetProfilePic");
                objDBHelper.AddParameter("@UserId", UserId);

                using (DbDataReader dr = (DbDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (dr.Read())
                    {
                        ProfilePic = CommanLogic.GetStringValue(dr["Profilepic"], string.Empty);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return ProfilePic;
        }

        public Pro_ChatNewsCount InsertLatLongAndUserStatus(Pro_UserMaster user)
        {
            objDBHelper = new DBHelper();
            Pro_ChatNewsCount objuser = new Pro_ChatNewsCount();
            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", "InsertLatLongAndUserStatus");
                objDBHelper.AddParameter("@Latitude", user.Latitude);
                objDBHelper.AddParameter("@Longitude", user.Longitude);
                objDBHelper.AddParameter("@UserId", user.UserId);
                objDBHelper.AddParameter("@CreatedOn", user.CreatedOn);
                using (DbDataReader dr = (DbDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (dr.Read())
                    {
                        objuser.NewsCount = CommanLogic.GetIntValue(dr["NewsCount"], 0);
                        objuser.chatCount = CommanLogic.GetIntValue(dr["chatCount"], 0);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                CacheHelper.Clear(key);
                objDBHelper = null;
            }
            return objuser;
        }



        public int UserStatus(Pro_UserMaster user)
        {
            objDBHelper = new DBHelper();
            int userUpdated = -1;
            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", "USERSTATUS");
                objDBHelper.AddParameter("@UserId", user.UserId);
                objDBHelper.AddParameter("@IsOnline",user.IsOnline);

                using (DbDataReader dr = (DbDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (dr.Read())
                    {
                        userUpdated = CommanLogic.GetIntValue(dr["RTNVAL"], 0);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                CacheHelper.Clear(key);
                objDBHelper = null;
            }
            return userUpdated;
        }

        public int UpdatePrivacySetting(Pro_UserPrivacySetting user)
        {
            objDBHelper = new DBHelper();
            int _updatePrivacySetting = -1;
            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", "UpdatePrivacySetting");
                objDBHelper.AddParameter("@UserId", user.UserId);
                objDBHelper.AddParameter("@PrivacySetting", user.PrivacySetting);

                using (DbDataReader dr = (DbDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (dr.Read())
                    {
                        _updatePrivacySetting = CommanLogic.GetIntValue(dr["RTNVAL"], 0);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                CacheHelper.Clear(key);
                objDBHelper = null;
            }
            return _updatePrivacySetting;
        }

        public Pro_Status GetUserStatus(int userid, int ChatId)
        {
            objDBHelper = new DBHelper();
            Pro_Status objStatus = new Pro_Status();
            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", "GetUserStatus");
                objDBHelper.AddParameter("@UserId", userid);
                objDBHelper.AddParameter("@ChatId", ChatId);

                using (DbDataReader dr = (DbDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (dr.Read())
                    {
                        objStatus.IsOnline = CommanLogic.GetBoolValue(dr["IsOnline"]);
                        objStatus.IsTyping = CommanLogic.GetBoolValue(dr["IsTyping"]);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                CacheHelper.Clear(key);
                objDBHelper = null;
            }
            return objStatus;
        }


        public string Getdate()
        {
            return Convert.ToDateTime(DateTime.UtcNow).ToString("yyyy-MM-dd HH:mm:ss");
        }

        public bool Truncate()
        {
            SqlConnection con = new SqlConnection();
            con.ConnectionString = ConfigurationManager.ConnectionStrings["ConnString"].ToString();
            con.Open();
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = con;
            cmd.CommandText = "Truncate table ChatHistoryMaster Truncate table ContactDetail Truncate table GroupMaster Truncate table NewsMaster " +
                              "Truncate table PictureMaster Truncate table PictureShareMaster Truncate table PrivacySetting " +
                              "Truncate table UserContactMaster Truncate table UserMaster Truncate table VideoShareMaster " +
                              "Truncate table VideosMaster Truncate table WebPosterChat Truncate table WebPosterChatShareMaster";
            cmd.CommandType = System.Data.CommandType.Text;
            cmd.ExecuteNonQuery();
            return true;
        }

        public List<Pro_UserSearchDetail> GetUserBySerachName(Pro_UserMaster objPro_UserMaster)
        {
            objDBHelper = new DBHelper();
            List<Pro_UserSearchDetail> objPro_UserList = new List<Pro_UserSearchDetail>();
            try
            {
                objPro_UserMaster.Mode = "SearchByUserName";
                AddParameter(objPro_UserMaster);
                using (SqlDataReader SqlReader = (SqlDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    while (SqlReader.Read())
                    {
                        Pro_UserSearchDetail obj_Pro_User = new Pro_UserSearchDetail();
                        obj_Pro_User.UserId = CommanLogic.GetIntValue(SqlReader["UserId"], 0);
                        obj_Pro_User.UserName = CommanLogic.GetStringValue(SqlReader["UserName"], string.Empty);
                        obj_Pro_User.AboutYou = CommanLogic.GetStringValue(SqlReader["AboutYou"], string.Empty);
                        obj_Pro_User.ContactNo = CommanLogic.GetStringValue(SqlReader["ContactNo"], string.Empty);
                        obj_Pro_User.PrivacyType = CommanLogic.GetIntValue(SqlReader["PrivacySetting"], 0);
                        //if (!string.IsNullOrEmpty(SqlReader["ProfilePic"].ToString()))
                        //{
                        //    obj_Pro_User.ImagePath = ConstantValues.RootUrl + "ProfilePicture/" + CommanLogic.GetStringValue(SqlReader["ProfilePic"], string.Empty);
                        //    obj_Pro_User.ThumbImagePath = ConstantValues.RootUrl + "ProfilePicture/Thumb_" + CommanLogic.GetStringValue(SqlReader["ProfilePic"], string.Empty);
                        //}
                        //else
                        //{
                        //    obj_Pro_User.ImagePath = "";
                        //    obj_Pro_User.ThumbImagePath = "";
                        //}
                        objPro_UserList.Add(obj_Pro_User);
                    }

                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return objPro_UserList;
        }

        public int AuthenticateUserForRestore(Pro_UserMaster objPro_UserMaster)
        {
            objDBHelper = new DBHelper();
            int Result = 0;
            try
            {
                objPro_UserMaster.Mode = "AuthenticateUserForRestore";
                AddParameter(objPro_UserMaster);
                using (SqlDataReader SqlReader = (SqlDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (SqlReader.Read())
                    {
                        Result = CommanLogic.GetIntValue(SqlReader["retnval"], 0);
                    }

                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return Result;
        }

        public int RestoreUser(Pro_UserMaster objPro_UserMaster)
        {
            objDBHelper = new DBHelper();
            int Result = 0;
            try
            {
                objPro_UserMaster.Mode = "RestoreUser";
                AddParameter(objPro_UserMaster);
                using (SqlDataReader SqlReader = (SqlDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (SqlReader.Read())
                    {
                        Result = CommanLogic.GetIntValue(SqlReader["UserId"], 0);
                    }

                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return Result;
        }

        public int CheckByContactNo(Pro_UserMaster objPro_UserMaster)
        {
            objDBHelper = new DBHelper();
            int Result = 0;
            try
            {
                objPro_UserMaster.Mode = "CheckByContactNo";
                AddParameter(objPro_UserMaster);
                using (SqlDataReader SqlReader = (SqlDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (SqlReader.Read())
                    {
                        Result = CommanLogic.GetIntValue(SqlReader["UserId"], 0);
                    }

                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return Result;
        }

        public Pro_CheckForContact GetUserDetails(int id)
        {
            objDBHelper = new DBHelper();
            Pro_CheckForContact obj_Pro_User = new Pro_CheckForContact();
            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", "GetUserDetails");
                objDBHelper.AddParameter("@UserId", id);
             
                using (DbDataReader dr = (DbDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (dr.Read())
                    {
                        obj_Pro_User.UserId = CommanLogic.GetIntValue(dr["UserId"], 0);
                        obj_Pro_User.UserName = CommanLogic.GetStringValue(dr["UserName"], string.Empty);
                        obj_Pro_User.AboutYou = CommanLogic.GetStringValue(dr["AboutYou"], string.Empty);
                        obj_Pro_User.ContactNo = CommanLogic.GetStringValue(dr["ContactNo"], string.Empty);
                        //if (!string.IsNullOrEmpty(dr["ProfilePic"].ToString()))
                        //{
                        //    obj_Pro_User.ImagePath = ConstantValues.RootUrl + "ProfilePicture/" + CommanLogic.GetStringValue(dr["ProfilePic"], string.Empty);
                        //    obj_Pro_User.ThumbImagePath = ConstantValues.RootUrl + "ProfilePicture/Thumb_" + CommanLogic.GetStringValue(dr["ProfilePic"], string.Empty);
                        //}
                        //else
                        //{
                        //    obj_Pro_User.ImagePath = "";
                        //    obj_Pro_User.ThumbImagePath = "";
                        //}
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return obj_Pro_User;
        }
        #endregion

        #region "Pushnotification"
     
        public List<Pro_UserMaster> GetFriendsListWithDeviceDetails(int UserId)
        {
            objDBHelper = new DBHelper();
            List<Pro_UserMaster> objuserList = new List<Models.Pro_UserMaster>();
            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", "GetFriendsListWithDeviceDetails");
                objDBHelper.AddParameter("@UserId", UserId);

                using (DbDataReader dr = (DbDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    while(dr.Read())
                    {
                        Pro_UserMaster objuser = new Pro_UserMaster();
                        objuser.UserId = CommanLogic.GetIntValue(dr["ContactId"],0);
                        objuser.UserName = CommanLogic.GetStringValue(dr["UserName"], string.Empty);
                        objuser.DeviceId = CommanLogic.GetStringValue(dr["DeviceId"], string.Empty);
                        objuser.DeviceType = CommanLogic.GetStringValue(dr["DeviceType"], string.Empty);
                        objuserList.Add(objuser);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return objuserList;
        }

        public Pro_UserMaster GetDeviceDetail(int WPUserId,int UserId)
        {
            objDBHelper = new DBHelper();
            Pro_UserMaster objuser = new Pro_UserMaster();
            try
            {
                objDBHelper.Command.Parameters.Clear();
                objDBHelper.AddParameter("@Mode", "GetDeviceDetail");
                objDBHelper.AddParameter("@UserId", UserId);
                objDBHelper.AddParameter("@WpUserId", WPUserId);

                using (DbDataReader dr = (DbDataReader)objDBHelper.ExecuteReader(SPName, CommandType.StoredProcedure))
                {
                    if (dr.Read())
                    {
                        //objuser.UserId = CommanLogic.GetIntValue(dr["ContactId"], 0);
                        objuser.UserName = CommanLogic.GetStringValue(dr["UserName"], string.Empty);
                        objuser.DeviceId = CommanLogic.GetStringValue(dr["DeviceId"], string.Empty);
                        objuser.DeviceType = CommanLogic.GetStringValue(dr["DeviceType"], string.Empty);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            { objDBHelper = null; }

            return objuser;
        }
        #endregion
    }
}