App42_Ruby_API 0.8.4

data/lib/user/User.rb

@@ -0,0 +1,102 @@
+# -----------------------------------------------------------------------
+#  Copyright © 2012 ShepHertz Technologies Pvt Ltd. All rights reserved.
+# -----------------------------------------------------------------------
+
+require 'App42_Ruby_API/App42Response'
+
+#
+#
+# This User object is the value object which contains the properties of User
+# along with the setter & getter for those properties.
+#
+#
+
+module App42
+  module User
+    class User < App42Response
+      attr_accessor :userName, :password,:email, :profile, :accountLocked, :roleList
+
+      @userName
+      @password
+      @email
+      @profile
+      @roleList = Array.new()
+      @accountLocked = false
+      #
+      # Returns the User Response in JSON format.
+      #
+      # @return the response in JSON format.
+      #
+      #
+      def to_s
+        return strResponse
+      end
+
+      #
+      # An enum that contains the User Gender either MALE or FEMALE.
+      #
+      #
+
+      class UserGender
+        unless (const_defined?(:MALE))
+          MALE ="Male"
+        end
+        unless (const_defined?(:FEMALE))
+          FEMALE = "Female"
+        end
+
+        #
+        # Sets the value of the UserGender. MALE or FEMALE.
+        #
+        # @param value
+        # - the value of UserGender either MALE or FEMALE.
+        #
+        def enum(string)
+          return UserGender.const_get(string)
+        end
+
+        #
+        # Returns the value of the UserGender. MALE or FEMALE.
+        #
+        # @return the value of UserGender.
+        #
+        #
+
+        def isAvailable(string)
+          if(string == "Male")
+            return "Male"
+          elsif(string == "Female")
+            return "Female";
+          else
+            return nil
+          end
+        end
+
+      end
+    end
+
+    class Profile
+      attr_accessor :firstName, :lastName,:mobile,:line1,:line2,:city,:state,:country,:pincode,:homeLandLine,:officeLandLine,:sex,:dateOfBirth
+      @firstName
+      @lastName
+      @mobile
+      @line1
+      @line2
+      @city
+      @state
+      @country
+      @pincode
+      @homeLandLine
+      @officeLandLine
+      @sex
+      @dateOfBirth
+      #
+      # This is a constructor that takes no parameter
+      #
+      def initialize(user)
+        user.profile = (self)
+      end
+
+    end
+  end
+end

data/lib/user/UserResponseBuilder.rb

@@ -0,0 +1,105 @@
+# -----------------------------------------------------------------------
+#  Copyright © 2012 ShepHertz Technologies Pvt Ltd. All rights reserved.
+# -----------------------------------------------------------------------
+
+require 'json/pure'
+require 'App42_Ruby_API/App42ResponseBuilder'
+require 'user/User'
+
+module App42
+  module User
+    #
+    #
+    # UserResponseBuilder class converts the JSON response retrieved from the
+    # server to the value object i.e User
+    #
+    #
+    class UserResponseBuilder < App42ResponseBuilder
+
+      #
+      # Converts the response in JSON format to the value object i.e User
+      #
+      # @param json
+      #     - response in JSON format
+      #
+      # @return User object filled with json data
+      #
+      def buildResponse(json)
+        users_JSON_obj = getServiceJSONObject("users", json)
+        users_JSON_obj = users_JSON_obj["user"]
+        user = buildUserObject(users_JSON_obj);
+        user.strResponse=json
+        user.isResponseSuccess = isResponseSuccess(json)
+        return user
+      end
+
+      #
+      # Converts the User JSON object to the value object i.e User
+      #
+      # @param userJSONObj
+      #      - user data as JSONObject
+      #
+      # @return User object filled with json data
+      #
+      #
+
+      def buildUserObject(userJSONObj)
+        user = User.new
+        buildObjectFromJSONTree(user,userJSONObj)
+
+        if userJSONObj.key?('profile')
+          profileJSONObj = userJSONObj["profile"]
+          profile = App42::User::Profile.new(user)
+          buildObjectFromJSONTree(profile, profileJSONObj);
+        end
+
+        if userJSONObj.key?("role")
+          roleList = Array.new
+          if userJSONObj.fetch("role").instance_of?(Array)
+            roleArr = userJSONObj.fetch("role");
+            roleArr.length.times do |i|
+              roleList.push(roleArr.fetch(i))
+            end
+          else
+            roleList.push(userJSONObj.fetch("role"));
+          end
+          user.roleList = roleList
+        end
+        return user;
+      end
+
+      #
+      # Converts the response in JSON format to the list of value objects i.e User
+      #
+      # @param json
+      #      - response in JSON format
+      #
+      # @return List of User object filled with json data
+      #
+
+      def buildArrayResponse(json)
+        usersJSONObj = getServiceJSONObject("users", json);
+        userList = Array.new
+
+        if usersJSONObj["user"].instance_of?(Array)
+          userJSONArray = usersJSONObj["user"]
+          userJSONArray.length.times do |i|
+            userJSONObject = userJSONArray[i]
+            user = buildUserObject(userJSONObject);
+            user.strResponse=json
+            user.isResponseSuccess = isResponseSuccess(json)
+            userList.push(user)
+          end
+        else
+          userJSONObject = usersJSONObj["user"]
+          user = buildUserObject(userJSONObject);
+          user.strResponse=json
+          user.isResponseSuccess = isResponseSuccess(json)
+          userList.push(user)
+        end
+        return userList
+      end
+
+    end
+  end
+end

data/lib/user/UserService.rb

@@ -0,0 +1,1209 @@
+# -----------------------------------------------------------------------
+#  Copyright © 2012 ShepHertz Technologies Pvt Ltd. All rights reserved.
+# -----------------------------------------------------------------------
+
+require 'rubygems'
+require 'connection/RESTConnection'
+require 'util/util'
+require 'json/pure'
+require 'App42_Ruby_API/App42Response'
+require 'user/UserResponseBuilder'
+require 'user/User'
+
+
+module App42
+  module User
+    #
+    # Creates User for the App. App42 Cloud API's provides a complete User
+    # Management for any Mobile or Web App. It supports User registration,
+    # retrieval, state management e.g. lock, delete and Authentication.
+    #
+    # Along with User Management the platform provides API's for persistent
+    # SessionManagement
+    #
+    # @see SessionService
+    # @see User
+    # @see App42Response
+    #
+    class UserService
+      #
+      # this is a constructor that takes
+      #
+      # @param apiKey
+      # @param secretKey
+      # @param baseURL
+      #
+      def initialize(api_key, secret_key, base_url)
+        puts "UserService->initialize"
+        @api_key = api_key
+        @secret_key = secret_key
+        @base_url = base_url
+        @resource = "user"
+        @version = "1.0"
+      end
+
+      #
+      # Create User for the App
+      #
+      # @param uName
+      #      - UserName which should be unique for the App
+      # @param pwd
+      #      - Password for the User
+      # @param emailAddress
+      #      - Email address of the user
+      #
+      # @return The created User Object.
+      #
+      # @raise App42Exception
+      #
+
+      # Variable should be snake case
+      def create_user(user_name, pwd, email_address)
+        puts "Create User Called "
+        puts "Base url #{@base_url}"
+        response, usr = nil
+        usr, util = User.new, Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        util.throwExceptionIfNullOrBlank(pwd, "Password")
+        util.throwExceptionIfEmailNotValid(email_address, "EmailAddress")
+        util.throwExceptionIfNullOrBlank(email_address, "EmailAddress")
+        begin
+          connection = App42::Connection::RESTConnection.new @base_url
+          body = {'app42' => {"user"=> {
+            "userName" => user_name,
+            "password" => pwd,
+            "email" => email_address
+            }}}.to_json
+          puts "Body #{body}"
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("body", body)
+          puts params
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}"
+          response = connection.post(signature, resource_url, query_params, body)
+          user = UserResponseBuilder.new
+          usr = user.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return usr
+      end
+
+      #
+      # Gets user details based on userName
+      #
+      # @param userName
+      #      - UserName which should be unique for the App
+      #
+      # @return Returns User Object
+      #
+      # @raise App42Exception
+      #
+
+      def get_user(user_name)
+        puts "Get User Called "
+        puts "Base url #{@base_url}"
+        response, usr = nil
+        usr, util  = User.new, Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("userName", user_name)
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{user_name}"
+          response = connection.get(signature, resource_url, query_params)
+          user = UserResponseBuilder.new
+          usr = user.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return usr
+      end
+
+      #
+      # Gets All users details
+      #
+      # @return Returns the list that contains all User Object
+      #
+      # @raise App42Exception
+      #
+
+      def get_all_users()
+        puts "Get All Users Called"
+        puts "Base url #{@base_url}"
+        response, userList = nil
+        user_list, util = [], Util.new
+
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}"
+          response = connection.get(signature, resource_url, query_params)
+          user = UserResponseBuilder.new
+          user_list = user.buildArrayResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return user_list
+      end
+
+      #
+      # Gets user details based on emailId
+      #
+      # @param emailId
+      #      - EmailId of the user to be retrieved
+      #
+      # @return Returns User Object
+      #
+      # @raise App42Exception
+      #
+
+      def get_user_by_email_id(email_id)
+        puts "Get All Users Called"
+        puts "Base url #{@base_url}"
+        response, usr = nil
+        usr, util = User.new, Util.new
+        util.throwExceptionIfEmailNotValid(email_id, "EmailId")
+        util.throwExceptionIfNullOrBlank(email_id, "EmailId")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("emailId", email_id)
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/email/#{email_id}"
+          response = connection.get(signature, resource_url, query_params)
+          user = UserResponseBuilder.new
+          usr = user.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return usr
+      end
+
+      #
+      # Deletes a particular user based on userName.
+      #
+      # @param userName
+      #      - UserName which should be unique for the App
+      #
+      # @return App42Response Object if user deleted successfully
+      #
+      # @raise App42Exception
+      #
+
+      def delete_user(user_name)
+        puts "Delete User Called "
+        puts "Base url #{@base_url}"
+        response ,response_obj, util = nil, App42Response.new, Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("userName", user_name)
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{user_name}"
+          response = connection.delete(signature, resource_url, query_params)
+          response_obj.strResponse=(response)
+          response_obj.isResponseSuccess=(true)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return response_obj
+      end
+
+      #
+      # Creates or Updates User Profile. First time the Profile for the user is
+      # created and in future calls user profile will be updated. This will
+      # always update the profile with new value passed in profile object. Call
+      # to this method should have all the values you want to retain in user
+      # profile object, otherwise old values of profile will get updated with
+      # null.
+      #
+      # Method only updates the profile of user, passing email/password in user
+      # object does not have any significance for this method call.
+      #
+      # @param user
+      #       - User for which profile has to be updated, this should
+      # contain the userName and profile object in it.
+      #
+      # @return User Object with updated Profile information
+      #
+      # @raise App42Exception
+      #
+      # @see Profile
+      #
+
+      def create_or_update_profile(user)
+        puts "Base url #{@base_url}"
+        response = nil
+        userResponse = nil
+        userResponse = User.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(user, "User")
+        util.throwExceptionIfNullOrBlank(user.userName, "UserName")
+        util.throwExceptionIfNullOrBlank(user.profile, "Profile Data")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          profile = user.profile()
+          profileObj = {}
+          profileObj.store("firstName", profile.firstName())
+          profileObj.store("lastName", profile.lastName())
+          profileObj.store("sex", profile.sex())
+          profileObj.store("mobile", profile.mobile())
+          profileObj.store("line1", profile.line1())
+          profileObj.store("line2", profile.line2())
+          profileObj.store("city", profile.city())
+          profileObj.store("state", profile.state())
+          profileObj.store("country", profile.country())
+          profileObj.store("pincode", profile.pincode())
+          profileObj.store("homeLandLine", profile.homeLandLine())
+          profileObj.store("officeLandLine", profile.officeLandLine())
+          if profile.dateOfBirth != nil
+            profileObj.store("dateOfBirth", util.get_timestamp_utc_from_date(profile.dateOfBirth))
+          end
+          body = {
+            'app42'=>{"user"=>{
+            "userName"=>user.userName,
+            "profileData"=>profileObj
+            }
+            }
+          }.to_json
+          puts "Body #{body}"
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("body", body)
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/profile"
+          response = connection.put(signature, resource_url, query_params, body)
+          user = UserResponseBuilder.new
+          userResponse = user.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise e
+        end
+        return userResponse
+      end
+
+      #
+      # Authenticate user based on userName and password
+      #
+      # @param user_name
+      #      - UserName which should be unique for the App
+      # @param pwd
+      #      - Password for the User
+      #
+      # @return Whether the user is authenticated or not.
+      #
+      # @raise App42Exception
+      # if authentication fails or username/password is blank or null
+      #
+
+      def authenticate(uName, pwd)
+        puts "authenticateUser Called "
+        puts "Base url #{@base_url}"
+        response,usr = nil
+        usr, util = User.new, Util.new
+        util.throwExceptionIfNullOrBlank(uName, "UserName")
+        util.throwExceptionIfNullOrBlank(pwd, "Password")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          body = {'app42' => {"user"=> {
+            "userName" => uName,
+            "password" => pwd
+            }}}.to_json
+          puts "Body #{body}"
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("body", body)
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/authenticate"
+          response = connection.post(signature, resource_url, query_params, body)
+          user = UserResponseBuilder.new
+          usr = user.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise e
+        end
+        return usr
+      end
+
+      #
+      # Gets All the locked users details
+      #
+      # @return Returns the list that contains locked User Objects
+      #
+      # @raise App42Exception
+      #
+
+      def get_locked_users()
+        puts "Get Locked Users Called"
+        puts "Base url #{@base_url}"
+        response, user_list = nil
+        user_list, util = [], Util.new
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/locked"
+          response = connection.get(signature, resource_url, query_params)
+          user = UserResponseBuilder.new
+          user_list = user.buildArrayResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return user_list
+      end
+
+      #
+      # Updates the User based on userName.
+      # Note: Only email can be updated. Username cannot be updated.
+      #
+      # @param uName
+      #      - UserName which should be unique for the App
+      # @param emailAddress
+      #      - Email address of the user
+      #
+      # @return updated User Object
+      #
+      # @raise App42Exception
+      #
+
+      def update_email(user_name,  email_id)
+        puts "Update User Called "
+        puts "Base url #{@base_url}"
+        response, usr = nil
+        usr, util = User.new, Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        util.throwExceptionIfNullOrBlank(email_id, "EmailAddress")
+        util.throwExceptionIfNullOrBlank(email_id, "Email Address")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          body = {'app42' => {"user"=> {
+            "userName" => user_name,
+            "email" => email_id
+            }}}.to_json
+          puts "Body #{body}"
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("body", body)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}"
+          response = connection.put(signature, resource_url, query_params, body)
+          user = UserResponseBuilder.new
+          usr = user.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return usr
+      end
+
+      #
+      # Locks the user based on the userName. Apps can use these feature to lock a user because of reasons specific to their
+      # usercase e.g. If payment not received and the App wants the user to be inactive
+      #
+      # @param uName
+      #      - UserName which should be unique for the App
+      #
+      # @return Returns the locked User Object
+      #
+      # @raise App42Exception
+      #
+
+      def lock_user(user_name)
+        puts "Lock User Called "
+        puts "Base url #{@base_url}"
+        response, usr = nil
+        usr, util = User.new, Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          body = {'app42' => {"user"=> {
+            "userName" => user_name
+            }}}.to_json
+          puts "Body #{body}"
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("body", body)
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/lock"
+          response = connection.put(signature, resource_url, query_params, body)
+          user = UserResponseBuilder.new
+          usr = user.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return usr
+      end
+
+      #
+      # Unlock the user based on the userName. Apps can use these feature to unlock a user because of reasons specific to their
+      # usercase e.g. If payment received and the App wants to the user to be active.
+      #
+      # @param uName
+      #      - UserName which should be unique for the App
+      #
+      # @return Returns the unlocked User Object
+      #
+      # @raise App42Exception
+      #
+
+      def unlock_user(user_name)
+        puts "unlockUser Called "
+        puts "Base url #{@base_url}"
+        response, usr = nil
+        usr, util = User.new, Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          body = {'app42' => {"user"=> {
+            "userName" => user_name
+            }}}.to_json
+          puts "Body #{body}"
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("body", body)
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/unlock"
+          response = connection.put(signature, resource_url, query_params, body)
+          user = UserResponseBuilder.new
+          usr = user.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return usr
+      end
+
+      #
+      # Gets All users By Paging
+      #
+      # @param max
+      #      - Maximum number of records to be fetched
+      # @param offset
+      #     - From where the records are to be fetched
+      #
+      # @return Returns User Information
+      #
+      # @raise App42Exception
+      #
+
+      def get_all_users_by_paging(max, offset)
+        puts "getAllUsersByPaging Called "
+        puts "Base url #{@base_url}"
+        response, usr = nil
+        user_list, util = User.new, Util.new
+        util.validateMax(max)
+        util.throwExceptionIfNullOrBlank(max, "Max")
+        util.throwExceptionIfNullOrBlank(offset, "Offset")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("max", "" + (max.to_i).to_s)
+          params.store("offset", "" + (offset.to_i).to_s)
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/paging/#{(max.to_i).to_s}/#{(offset.to_i).to_s}"
+          response = connection.get(signature, resource_url, query_params)
+          user = UserResponseBuilder.new
+          user_list = user.buildArrayResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return user_list
+      end
+
+      #
+      # Gets All the locked users By paging details
+      #
+      # @param max
+      #      - Maximum number of records to be fetched
+      # @param offset
+      #      - From where the records are to be fetched
+      #
+      # @return Returns User Information
+      #
+      # @raise App42Exception
+      #
+
+      def get_locked_users_by_paging(max, offset)
+        puts "get_locked_users_by_paging Called "
+        puts "Base url #{@base_url}"
+        response, user, user_list, util = nil,nil, User.new, Util.new
+        util.validateMax(max)
+        util.throwExceptionIfNullOrBlank(max, "Max")
+        util.throwExceptionIfNullOrBlank(offset, "Offset")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("max", "" + (max.to_i).to_s)
+          params.store("offset", "" + (offset.to_i).to_s)
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/locked/#{(max.to_i).to_s}/#{(offset.to_i).to_s}"
+          response = connection.get(signature, resource_url, query_params)
+          user = UserResponseBuilder.new
+          user_list = user.buildArrayResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return user_list
+      end
+
+      #
+      # Change the password for user based on the userName.
+      #
+      # @param uName
+      #      - UserName which should be unique for the App
+      # @param oldPwd
+      #      - Old Password for the user for authentication
+      # @param newPwd
+      #      - New Password for the user to change
+      #
+      # @return App42Response Object if updated successfully
+      #
+      # @raise App42Exception
+      #
+
+      def change_user_password(user_name, old_password, new_password)
+        puts "changeUserPassword Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        responseObj = App42Response.new()
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        util.throwExceptionIfNullOrBlank(old_password, "Old Password")
+        util.throwExceptionIfNullOrBlank(new_password, "New Password")
+        responseObj = App42Response.new
+        if(old_password == new_password)
+          raise App42Exception.new("Old password and new password are same")
+        end
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          body = {'app42' => {"user"=> {
+            "userName" => user_name,
+            "oldPassword" => old_password,
+            "newPassword" => new_password
+            }}}.to_json
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("body", body)
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/changeUserPassword"
+          response = connection.put(signature, resource_url, query_params, body)
+          responseObj.strResponse=(response)
+          responseObj.isResponseSuccess=(true)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+      #
+      # Gets the count of all the users
+      #
+      # @return Returns the count of all User exists
+      #
+      # @raise App42Exception
+      #
+
+      def get_all_users_count
+        puts "getAllUsersCount Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        responseObj, util = App42Response.new, Util.new
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/count/all"
+          response = connection.get(signature, resource_url, query_params)
+          responseObj.strResponse=(response)
+          responseObj.isResponseSuccess=(true)
+          responseObj = UserResponseBuilder.new()
+          responseObj.getTotalRecords(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+      #
+      # Gets the count of all the locked users
+      #
+      # @return Returns the count of locked User exists
+      #
+      # @raise App42Exception
+      #
+
+      def get_locked_users_count()
+        puts "getLockedUsersCount Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        responseObj = App42Response.new()
+        util = Util.new
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/count/locked"
+          response = connection.get(signature, resource_url, query_params)
+          responseObj.strResponse=(response)
+          responseObj.isResponseSuccess=(true)
+          responseObj = UserResponseBuilder.new()
+          responseObj.getTotalRecords(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+      #
+      # Create User for the App
+      #
+      # @param uName
+      #      - UserName which should be unique for the App
+      # @param pwd
+      #      - Password for the User
+      # @param emailAddress
+      #      - Email address of the user
+      # @param roleList
+      #      - list of roles to be assigned to User
+      #
+      # @return The created User Object.
+      #
+      # @raise App42Exception
+      #
+
+      def create_user_with_role(user_name, pwd, email_address, role_list)
+        puts "Create User Called "
+        puts "Base url #{@base_url}"
+        response, usr = nil
+        usr, util = User.new, Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        util.throwExceptionIfNullOrBlank(pwd, "Password")
+        util.throwExceptionIfEmailNotValid(email_address, "EmailAddress")
+        util.throwExceptionIfNullOrBlank(email_address, "EmailAddress")
+        util.throwExceptionIfNullOrBlank(role_list, "RoleList")
+        raise App42Exception.new("RoleList cannot be empty.Please assign at least one role") if role_list.size == 0
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          role_array = []
+          for role in role_list do
+            role_array.push(role)
+          end
+          body = {'app42' => {"user"=> {
+            "email" => email_address,
+            "password" => pwd,
+            "userName" => user_name, "roles" => {
+            "role" => role_array
+            }}}}.to_json
+          puts "Body #{body}"
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("body", body)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/role"
+          response = connection.post(signature, resource_url, query_params, body)
+          user = UserResponseBuilder.new()
+          usr = user.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return usr
+      end
+
+      #
+      # Get Roles based on userName
+      #
+      # @param userName
+      #      - UserName which should be unique for the App
+      #
+      # @return Returns User Object
+      #
+      # @raise App42Exception
+      #
+
+      def get_roles_by_user(user_name)
+        puts "getRolesByUser Called "
+        puts "Base url #{@base_url}"
+        response, user = nil
+        usr, util = User.new, Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("userName", user_name)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{user_name}/roles"
+          response = connection.get(signature, resource_url, query_params)
+          user = UserResponseBuilder.new()
+          usr = user.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return usr
+      end
+
+      #
+      # Get Users based on Role
+      #
+      # @param role
+      #      - Role which should be unique for the App
+      #
+      # @return Returns User Object
+      #
+      # @raise App42Exception
+      #
+
+      def get_users_by_role(role)
+        puts "get_users_by_role Called "
+        puts "Base url #{@base_url}"
+        response, usr = nil
+        userList, util = [], Util.new
+        util.throwExceptionIfNullOrBlank(role, "Role")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("role", role)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/role/#{role}"
+          response = connection.get(signature, resource_url, query_params)
+          user = UserResponseBuilder.new()
+          userList = user.buildArrayResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return userList
+      end
+
+      #
+      # Revokes the specified role from the user.
+      #
+      # @param userName
+      #      - UserName which should be unique for the App
+      #
+      # @return App42Response Object if user deleted successfully
+      #
+      # @raise App42Exception
+      #
+
+      def revoke_role(user_name, role)
+        puts "revoke_role Called "
+        puts "Base url #{@base_url}"
+        response, responseObj, util = nil, App42Response.new, Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        util.throwExceptionIfNullOrBlank(role, "Role")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("role", role)
+          params.store("userName", user_name)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{user_name}/revoke/#{role}"
+          response = connection.delete(signature, resource_url, query_params)
+          responseObj.strResponse=(response)
+          responseObj.isResponseSuccess=(true)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+      #
+      # Revokes the specified role from the user.
+      #
+      # @param userName
+      #      - UserName which should be unique for the App
+      #
+      # @return App42Response Object if user deleted successfully
+      #
+      # @raise App42Exception
+      #
+
+      def revoke_all_roles(user_name)
+        puts "revoke_all_roles Called "
+        puts "Base url #{@base_url}"
+        response, response_obj, util = nil, App42Response.new, Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("userName", user_name)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{user_name}/revoke"
+          response = connection.delete(signature, resource_url, query_params)
+          response_obj.strResponse=(response)
+          response_obj.isResponseSuccess=(true)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return response_obj
+      end
+
+      #
+      # Get Users based on Profile Data
+      #
+      # @param profileData
+      #      - Profile Data key/value for which Users need to be retrieved
+      #
+      # @return Returns Arraylist of User Object for that particular role
+      #
+      # @raise App42Exception
+      #
+
+      def get_users_by_profile_data(profileData)
+        puts "get_users_by_profile_data Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        userList = nil
+        userList = []
+        util = Util.new
+        parameters = ""
+        parameters = fill_params_with_profile_data(profileData)
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/profile/#{parameters}"
+          response = connection.get(signature, resource_url, query_params)
+          user = UserResponseBuilder.new()
+          userList = user.buildArrayResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return userList
+      end
+
+      #
+      # Updates the User based on userName. Note: Only email can be updated.
+      # Username cannot be updated.
+      #
+      # @param uName
+      #      - UserName which should be unique for the App
+      # @param emailAddress
+      #      - Email address of the user
+      #
+      # @return updated User Object
+      #
+      # @raise App42Exception
+      #
+
+      def reset_user_password(user_name,password)
+        puts "resetUserPassword Called "
+        puts "Base url #{@base_url}"
+        response = nil
+        responseObj, util = App42Response.new, Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        util.throwExceptionIfNullOrBlank(password, "password")
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          body = {'app42' => {"user"=> {
+            "userName" => user_name,
+            "password" => password
+            }}}.to_json
+          puts "Body #{body}"
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("body", body)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/resetUserPassword"
+          response = connection.put(signature, resource_url, query_params, body)
+          responseObj.strResponse=(response)
+          responseObj.isResponseSuccess=(true)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+      #
+      # Add Role for the App
+      #
+      # @param uName
+      #      - UserName which should be unique for the App
+      # @param roleList
+      #      - list of roles to be added to User
+      #
+      # @return The created User Object.
+      #
+      # @raise App42Exception
+      #
+
+      def assign_roles(user_name, role_list)
+        puts "assignRoles Called "
+        puts "Base url #{@base_url}"
+        response, usr = nil
+        usr, util = User.new, Util.new
+        util.throwExceptionIfNullOrBlank(user_name, "UserName")
+        util.throwExceptionIfNullOrBlank(role_list, "RoleList")
+        raise App42Exception.new("RoleList cannot be empty.Please assign at least one role") if role_list.size == 0
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          body = {'app42' => {"user"=> {
+            "userName" => user_name, "roles" => {
+            "role" => role_list
+            }}}}.to_json
+          puts "Body #{body}"
+          query_params = {}
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("body", body)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/assignrole"
+          response = connection.post(signature, resource_url, query_params, body)
+          user = UserResponseBuilder.new()
+          usr = user.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return usr
+      end
+
+      #
+      # Builds a Parameter string from the profileData.
+      #
+      # @param profileData
+      #      - User.Profile object that contains User's Profile information
+      #
+      # @return String Object which contains the parameter string.
+      #
+      # @raise App42Exception
+      #
+
+      def fill_params_with_profile_data(profileData)
+        profileDataCond = ""
+        if profileData.city != nil && !profileData.city != ""
+          profileDataCond += "city:"+ profileData.city()+"!"
+        end
+        if profileData.country != nil && !profileData.country != ""
+          profileDataCond += "country:"+ profileData.country()+"!"
+        end
+        if profileData.dateOfBirth != nil && !profileData.dateOfBirth != ""
+          profileDataCond += "date_of_birth:"+ profileData.dateOfBirth()+"!"
+        end
+        if profileData.firstName != nil && !profileData.firstName != ""
+          profileDataCond += "first_name:"+ profileData.firstName()+"!"
+        end
+        if profileData.lastName != nil && !profileData.lastName != ""
+          profileDataCond += "last_name:"+ profileData.lastName()+"!"
+        end
+        if profileData.homeLandLine != nil && !profileData.homeLandLine != ""
+          profileDataCond += "home_land_line:"+ profileData.homeLandLine()+"!"
+        end
+        if profileData.line1 != nil && !profileData.line1 != ""
+          profileDataCond += "line1:"+ profileData.line1()+"!"
+        end
+        if profileData.line2() != nil && !profileData.line2 != ""
+          profileDataCond += "line2:"+ profileData.line2()+"!"
+        end
+        if profileData.mobile != nil && !profileData.mobile != ""
+          profileDataCond += "mobile:"+ profileData.mobile()+"!"
+        end
+        if profileData.officeLandLine() != nil && !profileData.officeLandLine.equals("")
+          profileDataCond += "office_land_line:"+ profileData.officeLandLine()+"!"
+        end
+        if profileData.pincode != nil && !profileData.pincode != ""
+          profileDataCond += "pincode:"+ profileData.pincode()+"!"
+        end
+        if profileData.sex != nil && !profileData.sex != ""
+          profileDataCond += "sex:"+ profileData.sex()+"!"
+        end
+        if profileData.state != nil && !profileData.state != ""
+          profileDataCond += "state:"+ profileData.state()+"!"
+        end
+        return profileDataCond
+      end
+
+    end
+  end
+end