App42_Ruby_API 0.8.4

data/lib/shopping/Catalogue.rb

@@ -0,0 +1,79 @@
+# -----------------------------------------------------------------------
+#  Copyright © 2012 ShepHertz Technologies Pvt Ltd. All rights reserved.
+# -----------------------------------------------------------------------
+
+require 'App42_Ruby_API/App42Response'
+
+#
+#
+# This Catalogue object is the value object which contains the properties of
+# Catalogue.
+#
+#
+
+module App42
+  module Shopping
+    class Catalogue < App42Response
+      attr_accessor :name, :description, :categoryList
+
+      @name
+      @description
+      @categoryList = Array.new
+    end
+
+    class Category
+      attr_accessor :name, :description, :itemList
+
+      @name
+      @description
+      @itemList = Array.new
+
+      #
+      # This is a constructor that takes no parameter
+      #
+      #
+      def initialize(catalogue)
+        catalogue.categoryList.push(self)
+      end
+
+      #
+      # Returns the Cart Response in JSON format.
+      #
+      # @return the response in JSON format.
+      #
+
+      def to_s
+        return "name : #{@name}" + "description : #{@description}";
+      end
+    end
+
+    class Item
+      attr_accessor :itemId, :name, :description, :url, :price, :tinyUrl
+
+      @itemId
+      @name
+      @description
+      @url
+      @price
+      @tinyUrl
+
+      #
+      #  This is a constructor that takes no parameter
+      #
+      def initialize(category)
+        category.itemList.push(self)
+      end
+
+      #
+      # Returns the Cart Response in JSON format.
+      #
+      # @return the response in JSON format.
+      #
+      #
+
+      def toString
+        return "itemId : #{@itemId}" + "name : #{@name}" + "description : #{@description}" + "url : #{@url}" + "price : #{@price}";
+      end
+    end
+  end
+end

data/lib/shopping/CatalogueResponseBuilder.rb

@@ -0,0 +1,170 @@
+# -----------------------------------------------------------------------
+#  Copyright © 2012 ShepHertz Technologies Pvt Ltd. All rights reserved.
+# -----------------------------------------------------------------------
+
+require 'json/pure'
+require 'App42_Ruby_API/App42ResponseBuilder'
+require 'shopping/Catalogue'
+
+module App42
+  module Shopping
+
+    #
+    #
+    # CatalogueResponseBuilder class converts the JSON response retrieved from the
+    # server to the value object i.e Catalogue
+    #
+    #
+    class CatalogueResponseBuilder < App42ResponseBuilder
+
+      #
+      # Converts the response in JSON format to the value object i.e Catalogue
+      #
+      # @param json
+      #      - response in JSON format
+      #
+      # @return Catalogue object filled with json data
+      #
+      #
+      def buildResponse(json)
+        puts "testing #{json}"
+        cataloguesJSONObject = getServiceJSONObject("catalogues", json);
+
+        catalogueJSONObject = cataloguesJSONObject.fetch("catalogue")
+        catalogue = buildCatalogueObject(catalogueJSONObject);
+
+        catalogue.strResponse=json
+        catalogue.isResponseSuccess = isResponseSuccess(json)
+
+        return catalogue
+      end
+
+      #
+      # Converts the response in JSON format to the list of value objects i.e
+      # Catalogue
+      #
+      # @param response
+      #      - response in JSON format
+      #
+      # @return List of Catalogue object filled with json data
+      #
+      #
+
+      def buildArrayResponse(json)
+        cataloguesJSONObject = getServiceJSONObject("catalogues", json);
+        catalogueList = Array.new
+
+        if cataloguesJSONObject["catalogue"].instance_of?(Array)
+          catalogueJSONArray = cataloguesJSONObject.fetch("catalogue");
+          catalogueJSONArray.length.times do |i|
+            catalogueJSONObj = catalogueJSONArray[i]
+            #          catalogue = Catalogue.new
+            catalogue = buildCatalogueObject(catalogueJSONObj);
+            catalogue.strResponse=json
+            catalogue.isResponseSuccess = isResponseSuccess(json)
+            catalogueList.push(catalogue)
+          end
+        else
+          catalogueJSONObj = cataloguesJSONObject["catalogue"]
+          catalogue = buildCatalogueObject(catalogueJSONObj);
+          catalogue.strResponse=json
+          catalogue.isResponseSuccess = isResponseSuccess(json)
+          catalogueList.push(catalogue)
+        end
+        return catalogueList
+      end
+
+      #
+      # Converts the User JSON object to the value object i.e Catalogue
+      #
+      # @param catalogueJSONObj
+      #      - Catalogue data as JSONObject
+      #
+      # @return Catalogue object filled with json data
+      #
+
+      def buildCatalogueObject(catalogueJSONObj)
+        catalogue = Catalogue.new();
+        categoryList = Array.new
+        catalogue.categoryList = categoryList
+        buildObjectFromJSONTree(catalogue, catalogueJSONObj);
+
+        if catalogueJSONObj.key?("categories") && catalogueJSONObj.fetch("categories").key?("category")
+          #Fetch Category
+
+          if catalogueJSONObj.fetch("categories").fetch("category").instance_of?(Hash)
+            #Single Category
+
+            categoryJSONObj = catalogueJSONObj.fetch("categories").fetch("category");
+            catalogueCategory = App42::Shopping::Category.new(catalogue)
+            itemList = Array.new
+            catalogueCategory.itemList=(itemList)
+            buildObjectFromJSONTree(catalogueCategory, categoryJSONObj);
+
+            #Check for Items Now
+            if(categoryJSONObj.key?("items") && categoryJSONObj.fetch("items").key?("item"))
+
+              if categoryJSONObj.fetch("items").fetch("item").instance_of?(Hash)
+
+                #Single Item
+                itemJSONObj = categoryJSONObj.fetch("items").fetch("item");
+                item = App42::Shopping::Item.new(catalogueCategory)
+                buildObjectFromJSONTree(item, itemJSONObj);
+
+              else
+
+                # Multiple Items
+                categoryJSONArray = categoryJSONObj.fetch("items").fetch("item");
+
+                categoryJSONArray.length.times do |j|
+                  itemJSONObj = categoryJSONArray[j]
+                  item = App42::Shopping::Item.new(catalogueCategory)
+                  buildObjectFromJSONTree(item, itemJSONObj);
+                end
+              end
+            end
+
+          else
+            #Multiple Categories
+
+            itemJSONArray = catalogueJSONObj.fetch("categories").fetch("category");
+
+            itemJSONArray.length.times do |j|
+              categoryJSONObj = itemJSONArray(j)
+              catalogueCategory = App42::Shopping::Category.new(catalogue)
+              buildObjectFromJSONTree(catalogueCategory, categoryJSONObj);
+
+              # Check for Items Now
+              if categoryJSONObj.key?("items") && categoryJSONObj.fetch("items").key?("item")
+
+                if categoryJSONObj.fetch("items").fetch("item").instance_of?(Hash)
+
+                  #Single Item
+                  itemJSONObj = categoryJSONObj.fetch("items").fetch("item");
+                  item = App42::Shopping::Item.new(catalogueCategory)
+                  itemList = Array.new
+                  catalogueCategory.itemList=(itemList)
+                  buildObjectFromJSONTree(item, itemJSONObj);
+
+                else
+
+                  #Multiple Items
+                  categoryJSONArray = categoryJSONObj.fetch("items").fetch("item");
+                  categoryJSONArray.length.times do |j|
+                    itemJSONObj = categoryJSONArray(j)
+                    item = App42::Shopping::Item.new(catalogueCategory)
+                    buildObjectFromJSONTree(item, itemJSONObj);
+                  end
+
+                end
+              end
+            end
+          end
+        end
+
+        return catalogue;
+      end
+
+    end
+  end
+end

data/lib/shopping/CatalogueService.rb

@@ -0,0 +1,649 @@
+# -----------------------------------------------------------------------
+#  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 'shopping/CatalogueResponseBuilder'
+require 'App42_Ruby_API/App42Exception'
+require 'shopping/Catalogue'
+require 'shopping/ItemData'
+
+module App42
+  module Shopping
+    #
+    # This Service provides a complete cloud based catalogue management. An app can keep
+    # all its items based on category on the Cloud. This service provides several utility
+    # methods to manage catalogue on the cloud.
+    #
+    # One can add items with its related information in a particular category. And there can
+    # be several categories in a catalogue. The App developer can create several catalogues if needed.
+    #
+    # The Cart service can be used along with Catalogue service to create an end to end Shopping feature for
+    # a Mobile and Web App.
+    #
+    # @see Cart, ItemData
+    #
+    class CatalogueService
+      #
+      # this is a constructor that takes
+      #
+      # @param apiKey
+      # @param secretKey
+      # @param baseURL
+      #
+      def initialize(api_key, secret_key, base_url)
+        puts "Shopping ->initialize"
+        @api_key = api_key
+        @secret_key = secret_key
+        @base_url = base_url
+        @resource = "catalogue"
+        @version = "1.0"
+      end
+
+      #
+      # Creates a Catalogue for a particular App. Categories can be added to the Catalogue
+      #
+      # @param catalogueName
+      #      - Name of the Catalogue to be created
+      # @param catalogueDescription
+      #      - Description of the catalogue to be createds
+      #
+      # @return Catalogue object
+      #
+      # @raise App42Exception
+      #
+
+      def create_catalogue(catalogueName, catalogueDescription)
+        puts "Create Catalogue Called "
+        puts "Base url #{catalogueDescription}"
+        response = nil;
+        catalogueObj = nil;
+        catalogueObj = Catalogue.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(catalogueName, "catalogueName");
+        util.throwExceptionIfNullOrBlank(catalogueDescription, "catalogueDescription");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          body = {'app42' => {"catalogue"=> {
+            "name" => catalogueName,
+            "description" => catalogueDescription
+            }}}.to_json
+          puts "Body #{body}"
+          query_params = Hash.new
+          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}"
+          response = connection.post(signature, resource_url, query_params, body)
+          catalogue = CatalogueResponseBuilder.new()
+          catalogueObj = catalogue.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return catalogueObj
+      end
+
+      #
+      # Creates a Category for a particular Catalogue e.g. Books, Music etc.
+      #
+      # @param catalogueName
+      #      - Name of the Catalogue for which Category has to be created
+      # @param categoryName
+      #      - Name of the Category that has to be created
+      # @param categoryDescription
+      #      - Description of the category to be created
+      #
+      # @return Catalogue object containing created category information
+      #
+      # @raise App42Exception
+      #
+
+      def create_category(catalogueName, categoryName, categoryDescription)
+        puts "Create Category Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        catalogueObj = nil;
+        catalogueObj = Catalogue.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(catalogueName, "catalogueName");
+        util.throwExceptionIfNullOrBlank(categoryName, "categoryName");
+        util.throwExceptionIfNullOrBlank(categoryDescription, "categoryDescription");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          body = {'app42' => {"catalogue"=> {"categories"=> {"category" =>
+            { "name" => categoryName,
+            "description" => categoryDescription,
+            }}}}}.to_json
+          puts "Body #{body}"
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("body", body)
+          params.store("catalogueName", catalogueName)
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{catalogueName}/category"
+          response = connection.post(signature, resource_url, query_params, body)
+          catalogue = CatalogueResponseBuilder.new()
+          catalogueObj = catalogue.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return catalogueObj
+      end
+
+      #
+      # Creates a Item in a Category for a particular Catelogue
+      #
+      # @param catalogueName
+      #      - Name of the Catalogue to which item has to be added
+      # @param categoryName
+      #      - Name of the Category to which item has to be added
+      # @param itemData
+      #      - Item Information that has to be added
+      #
+      # @return Catalogue object containing added item.
+      #
+      # @raise App42Exception
+      #
+      # @see ItemData
+      #
+
+      def add_item(catalogueName, categoryName, itemData)
+        puts "Add Item Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        catalogueObj = nil;
+        catalogueObj = Catalogue.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(catalogueName, "CatalogueName");
+        util.throwExceptionIfNullOrBlank(categoryName, "CategoryName");
+        util.throwExceptionIfNullOrBlank(itemData, "ItemData");
+        file = File.new(itemData.image())
+        if (FileTest.exists?(file) == false)
+          raise App42Exception.new("The file with the name #{file} not found")
+        end
+        begin
+          puts "file is #{file} and #{itemData.itemId}"
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          post_params=Hash.new
+          query_params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+            'catalogueName' => catalogueName,
+            'categoryName' => categoryName
+          }
+          params = query_params.clone
+          post_params.store("itemId",itemData.itemId)
+          post_params.store("name",itemData.name)
+          post_params.store("description",itemData.description)
+          post_params.store("price",(itemData.price.to_i).to_s)
+          params = params.merge(post_params)
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{catalogueName}/#{categoryName}/item"
+          response = connection.shopMultipart(signature, resource_url, query_params, params, file)
+          catalogue = CatalogueResponseBuilder.new()
+          catalogueObj = catalogue.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return catalogueObj
+      end
+
+      #
+      # Fetches all items for a Catalogue
+      #
+      # @param catalogueName
+      #      - Name of the Catalogue from which item has to be fetched
+      #
+      # @return Catalogue object containing all Items
+      #
+      # @raise App42Exception
+      #
+
+      def get_items(catalogueName)
+        puts "Get Items Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        catalogueObj = nil;
+        catalogueObj = Catalogue.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(catalogueName, "catalogueName");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          puts params
+          params.store("catalogueName", catalogueName)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{catalogueName}"
+          response = connection.get(signature, resource_url, query_params)
+          catalogue = CatalogueResponseBuilder.new
+          catalogueObj = catalogue.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return catalogueObj
+      end
+
+      #
+      # Fetches all items for a Catalogue and Category
+      #
+      # @param catalogueName
+      #      - Name of the Catalogue from which item has to be fetched
+      # @param categoryName
+      #      - Name of the Category from which item has to be fetched
+      #
+      # @return Catalogue object
+      #
+      # @raise App42Exception
+      #
+
+      def get_items_by_category(catalogueName, categoryName)
+        puts "Get Items By Category Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        catalogueObj = nil;
+        catalogueObj = Catalogue.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(catalogueName, "catalogueName");
+        util.throwExceptionIfNullOrBlank(categoryName, "categoryName");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("catalogueName", catalogueName)
+          params.store("categoryName", categoryName)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{catalogueName}/#{categoryName}"
+          response = connection.get(signature, resource_url, query_params)
+          catalogue = CatalogueResponseBuilder.new
+          catalogueObj = catalogue.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return catalogueObj
+      end
+
+      #
+      # Fetches Item by id for a Catalogue and Category
+      #
+      # @param catalogueName
+      #      - Name of the Catalogue from which item has to be fetched
+      # @param categoryName
+      #      - Name of the Category from which item has to be fetched
+      # @param itemId
+      #      - Item id for which information has to be fetched.
+      #
+      # @return Catalogue object
+      #
+      # @raise App42Exception
+      #
+
+      def get_item_by_id(catalogueName, categoryName, itemId)
+        puts "Get Items By ID Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        catalogueObj = nil;
+        catalogueObj = Catalogue.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(catalogueName, "catalogueName");
+        util.throwExceptionIfNullOrBlank(categoryName, "categoryName");
+        util.throwExceptionIfNullOrBlank(itemId, "itemId");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          puts params
+          params.store("catalogueName", catalogueName)
+          params.store("categoryName", categoryName)
+          params.store("itemId", itemId)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{catalogueName}/#{categoryName}/#{itemId}"
+          response = connection.get(signature, resource_url, query_params)
+          catalogue = CatalogueResponseBuilder.new
+          catalogueObj = catalogue.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return catalogueObj
+      end
+
+      #
+      # Removes all Items in a Catalogue
+      #
+      # @param catalogueName
+      #      - Name of the Catalogue from which item has to be removed
+      #
+      # @return Catalogue object containing removed items
+      #
+      # @raise App42Exception
+      #
+
+      def remove_all_items(catalogueName)
+        puts "Remove All Items Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        responseObj = App42Response.new();
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(catalogueName, "catalogueName");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          puts params
+          params.store("catalogueName", catalogueName)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{catalogueName}"
+          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
+
+      #
+      # Removes all Items from a Catalogue and Category
+      #
+      # @param catalogueName
+      #      - Name of the Catalogue from which item has to be removed
+      # @param categoryName
+      #      - Name of the Category from which item has to be removed
+      #
+      # @return Catalogue object containing removed item
+      #
+      # @raise App42Exception
+      #
+
+      def remove_items_by_category(catalogueName, categoryName)
+        puts "Remove Items By Category Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        responseObj = App42Response.new();
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(catalogueName, "catalogueName");
+        util.throwExceptionIfNullOrBlank(categoryName, "categoryName");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          puts params
+          params.store("catalogueName", catalogueName)
+          params.store("categoryName", categoryName)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{catalogueName}/#{categoryName}"
+          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
+
+      #
+      # Removes Item by Id
+      #
+      # @param catalogueName
+      #      - Name of the Catalogue from which item has to be removed
+      # @param categoryName
+      #      - Name of the Category from which item has to be removed
+      # @param itemId
+      #      - Item id which has to be removed
+      #
+      # @return Catalogue object containing removed item
+      #
+      # @raise App42Exception
+      #
+
+      def remove_item_by_id(catalogueName, categoryName, itemId)
+        puts "Remove Items By ID Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        responseObj = App42Response.new();
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(catalogueName, "catalogueName");
+        util.throwExceptionIfNullOrBlank(categoryName, "categoryName");
+        util.throwExceptionIfNullOrBlank(itemId, "itemId");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          puts params
+          params.store("catalogueName", catalogueName)
+          params.store("categoryName", categoryName)
+          params.store("itemId", itemId)
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{catalogueName}/#{categoryName}/#{itemId}"
+          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
+
+      #
+      # Fetches all items for a Catalogue and Category by paging.
+      #
+      # @param catalogueName
+      #      - Name of the Catalogue from which item has to be fetched
+      # @param categoryName
+      #      - Name of the Category from which item has to be fetched
+      # @param max
+      #      - Maximum number of records to be fetched
+      # @param offset
+      #      - From where the records are to be fetched
+      #
+      # @return Catalogue object
+      #
+      # @raise App42Exception
+      #
+
+      def get_items_by_category_by_paging(catalogueName, categoryName, max, offset)
+        puts "Get Items By Category Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        catalogueObj = nil;
+        catalogueObj = Catalogue.new
+        util = Util.new
+        util.validateMax(max);
+        util.throwExceptionIfNullOrBlank(catalogueName, "catalogueName");
+        util.throwExceptionIfNullOrBlank(categoryName, "categoryName");
+        util.throwExceptionIfNullOrBlank(max, "Max");
+        util.throwExceptionIfNullOrBlank(offset, "Offset");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("catalogueName", catalogueName)
+          params.store("categoryName", categoryName)
+          params.store("max", "" + (max.to_i).to_s);
+          params.store("offset", "" + (offset.to_i).to_s);
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/paging/#{catalogueName}/#{categoryName}/#{(max.to_i).to_s}/#{(offset.to_i).to_s}"
+          response = connection.get(signature, resource_url, query_params)
+          catalogue = CatalogueResponseBuilder.new
+          catalogueObj = catalogue.buildResponse(response)
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return catalogueObj
+      end
+
+      #
+      # Fetches count of all items for a Catalogue and Category
+      #
+      # @param catalogueName
+      #      - Name of the Catalogue from which count of item has to be fetched
+      # @param categoryName
+      #      - Name of the Category from which count of item has to be fetched
+      #
+      # @return App42Response object
+      #
+      # @raise App42Exception
+      #
+
+      def get_items_count_by_category(catalogueName, categoryName)
+        puts "get_items_count_by_category Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        responseObj = App42Response.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(catalogueName, "CatalogueName");
+        util.throwExceptionIfNullOrBlank(categoryName, "CategoryName");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("catalogueName", catalogueName);
+          params.store("categoryName", categoryName);
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{catalogueName}/#{categoryName}/count"
+          response = connection.get(signature, resource_url, query_params)
+          responseObj.strResponse = response
+          responseObj.isResponseSuccess = true
+          responseObj = CatalogueResponseBuilder.new()
+          responseObj.getTotalRecords(response);
+        rescue  App42Exception =>e
+          raise e
+        rescue  Exception => e
+          raise App42Exception.new(e)
+        end
+        return responseObj
+      end
+
+      #
+      # Deletes category
+      #
+      # @param catalogueName
+      #      - Name of the Catalogue from which count of item has to be fetched
+      # @param categoryName
+      #      - Name of the Category from which count of item has to be fetched
+      #
+      # @return App42Response object
+      #
+      # @raise App42Exception
+      #
+
+      def delete_category(catalogueName, categoryName)
+        puts "deleteCategory Called "
+        puts "Base url #{@base_url}"
+        response = nil;
+        responseObj = App42Response.new
+        util = Util.new
+        util.throwExceptionIfNullOrBlank(catalogueName, "CatalogueName");
+        util.throwExceptionIfNullOrBlank(categoryName, "CategoryName");
+        begin
+          connection = App42::Connection::RESTConnection.new(@base_url)
+          query_params = Hash.new
+          params = {
+            'apiKey'=> @api_key,
+            'version' => @version,
+            'timeStamp' => util.get_timestamp_utc,
+          }
+          query_params = params.clone
+          params.store("catalogueName", catalogueName);
+          params.store("categoryName", categoryName);
+          puts query_params
+          signature = util.sign(@secret_key, params)
+          resource_url = "#{@version}/#{@resource}/#{catalogueName}/category/#{categoryName}"
+          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
+
+    end
+  end
+end