ADAM / AIAHTML5

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using MongoDB.Driver;
using MongoDB.Bson;
using AIAHTML5.API.Properties;
using AIAHTML5.API.Constants;
using log4net;
using AIAHTML5.API.Models;
using Newtonsoft.Json;
using System.Collections;
using System.Data.SqlClient;

namespace AIAHTML5.API.Models
{
    public class Users
    {
        private static readonly ILog logger = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
        internal static dynamic GetUserDetailsForAuthenticatedUser(Newtonsoft.Json.Linq.JObject credentials)
        {
            logger.Debug("inside AuthenticateUser for loginId =" + credentials["username"].ToString() + " and password= " + credentials["password"].ToString());
            dynamic userDetails = null;

           
                User user = DBModel.GetUserDetailsByLoginId(credentials["username"].ToString());
                //string userDetails = DBModel.GetUserDetailsByLoginId2(credentials["username"].ToString());

                if (user != null)
                {
                    logger.Debug("userDetails.loginId= " + user.LoginId); // .loginId);

                    userDetails = JsonConvert.SerializeObject(user);
                }
                else
                {
                    userDetails = AIAConstants.USER_NOT_FOUND;
                }

      
            return userDetails;
        }

        internal static dynamic GetUserByEmail(Newtonsoft.Json.Linq.JObject userInfo)
        {
            logger.Debug(" inside GetUserByEmail for emailId = " + userInfo["emailId"]);

          
                User objUser = DBModel.GetUserDetailsByEmailId(userInfo["emailId"].ToString());

                //dynamic userDetails;

                if (objUser!= null)
                {
                    logger.Debug("userDetails.loginId= " + objUser.LoginId);
                    //return userDetails = JsonConvert.SerializeObject(objUser);
                    return objUser;
                }
                else
                {
                    return AIAConstants.USER_NOT_FOUND;
                }
            

        }

        internal static dynamic UpdatePassword(Newtonsoft.Json.Linq.JObject userInfo, string sLoginId, string sEmailId)
        {
          
                int result = DBModel.UpdateUserPassword(userInfo, sLoginId, sEmailId);

                return result;
          
        }

        internal static dynamic UpdateLicenseTerm(Newtonsoft.Json.Linq.JObject userLicenseInfo)
        {
            logger.Debug(" inside UpdateLicenseTerm for AccountNumber = " + userLicenseInfo["licenseeAccountNumber"].ToString() + ", LicenseId: " + userLicenseInfo["userLicenseId"].ToString());
            Newtonsoft.Json.Linq.JObject userInfo = new Newtonsoft.Json.Linq.JObject();

            dynamic result;
            string accountNumber = userLicenseInfo["licenseeAccountNumber"].ToString();

            userInfo.Add("accountNumber", accountNumber);

           
                result = DBModel.UpdateLicenseTermStatus(accountNumber);

                if (result < 0)
                {
                    logger.Fatal("Unable to update LicenseTermAccepted status for AccountNumber =" + accountNumber);
                }

            return result;
        }

        internal static bool checkUserAuthenticity(Newtonsoft.Json.Linq.JObject credentials, User user)
        {
            bool isAuthenticatedUser = DBModel.ValidateUserAuthenticity(credentials["username"].ToString(), credentials["password"].ToString(), user);

            return isAuthenticatedUser;
        }

        internal static User getUserDetails(Newtonsoft.Json.Linq.JObject credentials)
        {
            logger.Debug("inside getUserDetails for loginId =" + credentials["username"].ToString() + " and password= " + credentials["password"].ToString());
            User userDetails = null;

          
                userDetails = DBModel.GetUserDetailsByLoginId(credentials["username"].ToString());

                return userDetails;
        }

        internal static void getLicenseIdForThisUser(int userId, out int licenseId, out int editionId)
        {
            logger.Debug("inside getLicenseIdForThisUser for UserId =" + userId);

            //assigning below variable to avoid compiler error for unassignd out params
            licenseId = 0;
            editionId = 0;

         

                DBModel objModel = new DBModel();
                Hashtable licenseEditionHash = objModel.GetLicenseDetailByUserId(userId);

                if (licenseEditionHash.ContainsKey(AIAConstants.LICENSE_KEY_ID))
                    licenseId = Convert.ToInt32(licenseEditionHash[AIAConstants.LICENSE_KEY_ID]);

                if (licenseEditionHash.ContainsKey(AIAConstants.EDITION_KEY_ID))
                    editionId = Convert.ToInt32(licenseEditionHash[AIAConstants.EDITION_KEY_ID]);
               
           
        }

        internal static int insertLoginDetails(int userId)
        {
            logger.Debug("inside insertLoginDetails for UserId =" + userId);

            int result = 0;
           
                DBModel objModel = new DBModel();

                result = objModel.InsertLoginDetails(userId);
           
                return result;
        }

        internal static bool isUSerActive(User user)
        {
            if (user.IsActive)
                return true;
            else
                return false;
        }

        internal static bool checkIfLicenseExpired(LicenseSubscriptionDetails subscriptionDetail, out string expirationDate)
        {
            expirationDate = string.Empty;
            bool isLicenseExpired = false;

            if (subscriptionDetail!= null)
            {
                DateTime? subscriptionValidThrough = subscriptionDetail.SubscriptionValidThrough;
                if (subscriptionValidThrough != null && subscriptionValidThrough.Value.Date >= DateTime.Now.Date)
                {
                    isLicenseExpired = false;
                }
                else
                {
                    isLicenseExpired = true;
                    expirationDate = subscriptionDetail.SubscriptionValidThrough.Value.Date.ToString("MM/dd/yyyy").ToString();
                }                
            }
            return isLicenseExpired;
        }

        internal static ArrayList getModuleListByLicenseId(int licenseId)
        {
            logger.Debug("inside getModuleListByLicenseId for LicenseId =" + licenseId);

            ArrayList licensedModulesList = new ArrayList();

            

                DBModel objModel = new DBModel();
                licensedModulesList = objModel.GetUserModulesByLicenseId(licenseId);
           

               return licensedModulesList;
        }

        internal static int deletePastWrongAttempts(int userId)
        {
            logger.Debug("inside deletePastWrongAttempts for UserId =" + userId);

            int result = 0;

            
                DBModel objModel = new DBModel();
                result = objModel.DeleteIncorrectLoginAttempts(userId);
               return result;
        }

        internal static int checkNoOfWrongAttempts(int userId)
        {
            logger.Debug("inside checkNoOfWrongAttempts for UserId =" + userId);

            int incorrectLoginAttemptCount = 0;

          
                DBModel objModel = new DBModel();
                incorrectLoginAttemptCount = objModel.GetIncorrectLoginAttempts(userId);
               return incorrectLoginAttemptCount;
        }

        internal static int saveWrongAttemptOfUser(int userId, int previousIncorrectLoginAttempts)
        {
            logger.Debug("inside saveWrongAttemptofUser for UserId =" + userId);
            int result = 0;

          
                DBModel objModel = new DBModel();

                if (previousIncorrectLoginAttempts < 1)
                {
                    result = objModel.InsertIncorrectLoginAttempts(userId);
                }
                else
                {
                    result = objModel.UpdateIncorrectLoginAttempts(userId);
                }
           

            return result;
        }

        internal static bool isLicenseActive(int licenseId)
        {
            logger.Debug("inside isLicenseActive for LicenseId =" + licenseId);
            bool result = false;

              DBModel objModel = new DBModel();
                License userLicense = objModel.GetLicenseDetailsByLicenseId(licenseId);


                if (userLicense.IsActive)
                    result = true;
                else
                    result = false;
           
              return result;
        }

        internal static License getLicenseDetails(int licenseId)
        {
            logger.Debug("inside getLicenseDetails for LicenseId =" + licenseId);

            License userLicense = null;

           
                DBModel objModel = new DBModel();
                userLicense = objModel.GetLicenseDetailsByLicenseId(licenseId);
          
               return userLicense;
        }

        internal static LicenseSubscriptionDetails getLicenseSubscriptionDetails(int licenseId)
        {
            logger.Debug("inside getLicenseSubscriptionDetails for LicenseId =" + licenseId);

            LicenseSubscriptionDetails userSubscriptionDetail = null;

         
                DBModel objModel = new DBModel();
                userSubscriptionDetail = objModel.GetLicenseSubscriptionDetailsByLicenseId(licenseId);
           
            return userSubscriptionDetail;
        }

        internal static void isCredentialCorrect(Newtonsoft.Json.Linq.JObject credentials, User userInfo, out bool isCorrectLoginId, out bool isCorrectPassword)
        {
            isCorrectLoginId = false;
            isCorrectPassword = false;                        

            if (userInfo.Id> 0)
            {
                if (string.Equals(credentials["username"].ToString().ToUpper(), userInfo.LoginId.ToUpper()))
                    isCorrectLoginId = true;

                if (string.Equals(credentials["password"].ToString(), userInfo.Password))
                {
                    isCorrectPassword = true;
                }
            }
        }

        internal static int insertUserLoginLog(string accountNumber, Int16 failureId, string referalUrl, string edition, string httpReferer)
        {
            logger.Debug("inside insertUserLoginLog for accountNumber =" + accountNumber);

            int result = 0;

            
                DBModel objModel = new DBModel();
                result = objModel.InsertUserLoginLog(accountNumber, failureId, null, edition, null);
           
            return result;
        }


        internal static ArrayList getTermsAndConditions()
        {
            logger.Debug("inside getTermsOfServiceText");

            ArrayList arrTermsOfService = new ArrayList();

                DBModel objModel = new DBModel();
                arrTermsOfService = DBModel.GetTermsAndConditions();
          
            return arrTermsOfService;
        }

        internal static ArrayList getAllModulesList()
        {
            logger.Debug("inside getAllModulesList");
            ArrayList modulesList = new ArrayList ();

           
                DBModel objModel = new DBModel();
                modulesList = objModel.GetAllModules();
            
            return modulesList;
        }

        internal static bool checkUserBlockStatus(int userId, out DateTime blockTime)
        {
            logger.Debug("inside isUserBlocked for UserId =" + userId);
            bool isUserBlocked = false;
            blockTime = new DateTime();

                                
                DBModel objModel = new DBModel();
                BlockedUser blockedUser = objModel.GetUserBlockedStatusByUserId(userId);

                if (blockedUser!= null)
                {
                    blockTime = blockedUser.LoginTime;
                    isUserBlocked = true;
                }
                else
                    isUserBlocked = false;
            
            return isUserBlocked;
        }
    }
}