cloudmunch_sdk 0.6.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 36a38d8d8e000e50ac9870842a1229e2d5bb9042
-  data.tar.gz: 06423db69134e17de4ce9f144311af581d068ef7
+  metadata.gz: 62f77e9360bb900fb478f2f53f126f0ec8415370
+  data.tar.gz: 64405240eb61c16234e7f5aa043c79f7cd6e235a
 SHA512:
-  metadata.gz: d2e7116f2a090bf75cf02f5faee460401e3c80bf1c31b7b0cdf5f6ca8de9adfe618ef96679bc9b84ce786ce4cea26c13180875e78cee067e42cb7137049468c2
-  data.tar.gz: aa774849017e8e65f594805c94d6c6b4d6536d5ebf117404492690c67b9653b6e1405b3fb429046504bbd7de1fee44c308744be7edd6191d68c4c1abc2ea4b09
+  metadata.gz: cda6786a698876f0742d58857c4b9e0c6a4d5ae4ffbced16dd74ac0cc740f7bf0cac41c3a642822e56bcc89b6d968e1d7872b19d5407367721a32535ffaa73c7
+  data.tar.gz: a7817398062304b3a6f246107eb34c7dbd1da81a926c2a0a6b115acc7c3add3dad4d4ebe257c721de46c3354532fbdc8a2f1f399ecdb4de410e15e89a03f491a

data/lib/cloudmunch_Ruby_sdk_v2/AppAbstract.rb

@@ -62,7 +62,8 @@ class AppAbstract
 
     def getCloudmunchService()
         # @cloudmunchservice = @cloudmunchservice ? @cloudmunchservice : CloudmunchService.new(@var_input)
-        @cloudmunchservice = @cloudmunchservice ? @cloudmunchservice : CloudmunchService.initialize(@appContext)
+#        @cloudmunchservice = @cloudmunchservice ? @cloudmunchservice : CloudmunchService.initialize(@appContext)
+        @cloudmunchservice = self.extend(CloudmunchService)
         return @cloudmunchservice
     end 
     def openJSONFile(fileNameWithPath)
@@ -80,8 +81,7 @@ class AppAbstract
         return serviceProvider
     end
     
-    def getAppContext(var_input)
-        
+    def getAppContext()
         return @appContext
     end
 

data/lib/cloudmunch_Ruby_sdk_v2/CloudmunchService.rb

@@ -8,96 +8,700 @@ require_relative "Util"
 
 module CloudmunchService
   include Util
-  def self.initialize(appcontext)
-   @applicationContext=appcontext
+
+  # def self.initialize(appcontext)
+  #   @appContext=appcontext
+  # end
+
+  def getDataStoreID(insightID, dataStoreName)
+      if insightID.nil? || dataStoreName.nil?
+        log("DEBUG", "insight id and datastore name is needed to get datastore id")
+        return nil
+      end
+
+      paramHash = Hash.new
+      paramHash["insightID"] = insightID
+      paramHash["filter"] = {"name" => dataStoreName} 
+      paramHash["count"]  = 1
+      paramHash["fields"] = "id" 
+
+      dataStore = getInsightDataStores(paramHash)
+      if dataStore.nil? || !dataStore.any?
+        log("DEBUG", "Data store with name "+dataStoreName+" does not exist")
+        return nil
+      else
+        return dataStore[0]["id"]
+      end
   end
 
-   def updateCloudmunchData(context,contextid,data)
-    
-    serverurl=@applicationContext.get_data("{master_url}")+"/applications/"+@applicationContext.get_data("{application}")+"/"+context+"/"+contextid;
-    serverurl=serverurl+"?apikey="+@applicationContext.get_data("{api_key}")
-     uri = URI.parse(serverurl)
-    
-     response= Net::HTTP.post_form(uri,"data" => data.to_json)
-     
-     return response.body
-   end
+  def getReportID(insightID, reportName)
+      if insightID.nil? || reportName.nil?
+        log("DEBUG", "insight id and report name is needed to get report id")
+        return nil
+      end
+
+      paramHash = Hash.new
+      paramHash["insightID"] = insightID
+      paramHash["filter"] = {"name" => reportName} 
+      paramHash["count"]  = 1
+      paramHash["fields"] = "id" 
+
+      report = getInsightReports(paramHash)
+      if report.nil? || !report.any?
+        log("DEBUG", "Report with name "+reportName+" does not exist")
+        return nil
+      else
+        return report[0]["id"]
+      end
+  end
+
+  def getExtractID(insightID, dataStoreID, extractName)
+      if insightID.nil? || dataStoreID.nil? || extractName.nil?
+        log("DEBUG", "insight id, datastore id and extract name is needed to get extract id")
+        return nil
+      end
 
+      extract = nil
+      paramHash = Hash.new
+      paramHash["insightID"]   = insightID
+      paramHash["dataStoreID"] = dataStoreID
+      paramHash["filter"] = {"name" => extractName}
+      paramHash["count"]  = 1
+      paramHash["fields"] = "id" 
 
+      extract = getInsightDataStoreExtracts(paramHash)
+      if extract.nil? || !extract.any?
+        log("DEBUG", "Data store with name "+extractName+" does not exist")
+        return nil
+      else
+        return extract[0]["id"]
+      end
+  end
 
-   def getCloudmunchData(context,contextid,filterdata)
-    if contextid.nil? || contextid.empty?
-     serverurl=@applicationContext.get_data("{master_url}")+"/applications/"+@applicationContext.get_data("{application}")+"/"+context
-     else
-     serverurl=@applicationContext.get_data("{master_url}")+"/applications/"+@applicationContext.get_data("{application}")+"/"+context+"/"+contextid;
+  def getReportCardID(insightID, reportID, cardName)
+      if insightID.nil? || reportID.nil? || cardName.nil?
+        log("DEBUG", "insight id, report id and card name is needed to get report card id")
+        return nil
+      end
+
+      card = nil
+      paramHash = Hash.new
+      paramHash["insightID"] = insightID
+      paramHash["reportID"] = reportID
+      paramHash["filter"] = {"name" => cardName}
+      paramHash["count"]  = 1
+      paramHash["fields"] = "id" 
+
+      card = getInsightReportCards(paramHash)
+      if card.nil? || !card.any?
+        log("DEBUG", "Report with name "+cardName+" does not exist")
+        return nil
+      else
+        return card[0]["id"]
+      end
+  end
+
+  def getKeyMetricID(insightID, reportID, keyMetricName)
+      extract = nil
+      paramHash = Hash.new
+      paramHash["insightID"] = insightID
+      paramHash["reportID"] = reportID
+      paramHash["filter"] = {"name" => keyMetricName}
+      paramHash["count"]  = 1
+      paramHash["fields"] = "id" 
+
+      keyMetric = getInsightReportCards(paramHash)
+      if keyMetric.nil? || !keyMetric.any?
+        log("DEBUG", "Report key metric with name "+keyMetricName+" does not exist")
+        return nil
+      else
+        return keyMetric[0]["id"]
+      end
+  end
+
+  def createInsight(insightName)
+    if !insightName.nil?
+      insightID = nil
+      insightID = getInsightID(insightName)
+      
+      if !insightID.nil?
+        log("DEBUG", "Insight with name "+insightName+" already exists!")
+        return insightID
+      else
+        paramHash = {}
+        paramHash["context"]    = "insights"
+        paramHash["data"]       = {"name" => insightName}
+        insight = updateCloudmunchData(paramHash)
+        
+        if insight["id"].nil?
+          log("DEBUG", "Unable to create insight : "+insightName+"! refer log for more details")
+          return nil
+        else
+          return insight["id"]
+        end
+      end
+    else
+        log("DEBUG", "Insights name is needed for creating an insight")
+        return nil
     end
-    querystring=""
-    if filterdata.nil? || filterdata.empty?
-      serverurl=serverurl+"?apikey="+@applicationContext.get_data("{api_key}")
+  end
+
+  def createInsightDataStore(insightID, dataStoreName)
+    if !dataStoreName.nil? && !dataStoreName.empty? && !insightID.nil?
+      dataStoreID = nil
+      dataStoreID = getDataStoreID(insightID, dataStoreName)
+      
+      if !dataStoreID.nil?
+        log("DEBUG", "Data store with name "+dataStoreName+" already exists!")
+        return dataStoreID
+      else
+        paramHash = {}
+        paramHash["context"]    = "insights"
+        paramHash["contextID"]  = insightID
+        paramHash["subContext"] = "datastores"
+        paramHash["data"]       = {"name" => dataStoreName}
+        dataStore = updateCloudmunchData(paramHash)
+        
+        if dataStore["id"].nil?
+          return nil
+        else
+          return dataStore["id"]
+        end
+      end
     else
-      querystring="filter="+to_json($filerdata);
-      serverurl=serverurl+"?"+querystring+"&apikey="+@applicationContext.get_data("{api_key}")
-    
+        log("DEBUG", "Datastore name and insights id is needed for creating a data store")
+        return nil
+    end
+  end
+
+  def createInsightDataStoreExtract(insightID, dataStoreID, extractName)
+    if !extractName.nil? && !extractName.empty? && !insightID.nil?  && !dataStoreID.nil?
+
+      extractID = nil
+      extractID = getExtractID(insightID, dataStoreID, extractName)
+      
+      if !extractID.nil?
+        return extractID
+      else
+        paramHash = Hash.new
+        paramHash["context"]      = "insights"
+        paramHash["contextID"]    = insightID
+        paramHash["subContext"]   = "datastores"
+        paramHash["subContextID"] = dataStoreID
+        paramHash["leafContext"]  = "extracts"
+        paramHash["data"]         = {"name" => extractName}
+
+        log("DEBUG", "Attempting creation of extract with name " + extractName + "...")
+        extract = updateCloudmunchData(paramHash)
+
+        if extract["id"].nil? then return nil else extract["id"] end
+      end
+    else
+        log("DEBUG", "Extract name, insights id and datastore id is needed for creating an extract")
+        return nil
     end
-   uri = URI.parse(serverurl)
+  end
     
-     return Net::HTTP.get(uri)
-   end
+  def createInsightReportCard(insightID, reportID, cardName)
+    if !cardName.nil? && !cardName.empty? && !insightID.nil?  && !reportID.nil?
 
-   
-   def deleteCloudmunchData(context,contextid)
-    serverurl=@applicationContext.get_data("{master_url}")+"/applications/"+@applicationContext.get_data("{application}")+"/"+context+"/"+contextid;
-   serverurl=serverurl+"?apikey="+@applicationContext.get_data("{api_key}")
-    uri = URI.parse(serverurl)
-    Net::HTTP::Delete(uri)
-   end 
+      cardID = nil
+      cardID = getReportCardID(insightID, reportID, cardName)
+      
+      if !cardID.nil?
+        return cardID
+      else
+        paramHash = Hash.new
+        paramHash["context"]      = "insights"
+        paramHash["contextID"]    = insightID
+        paramHash["subContext"]   = "insight_reports"
+        paramHash["subContextID"] = reportID
+        paramHash["leafContext"]  = "insight_cards"
+        paramHash["data"]         = {"name" => cardName}
 
+        log("DEBUG", "Attempting creation of report card with name " + cardName + "...")
+        card = updateCloudmunchData(paramHash)
 
+        if card["id"].nil? then return nil else card["id"] end
+      end
+    else
+        log("DEBUG", "Extract name, insight id and report id is needed for creating a report card")
+        return nil
+    end
+  end
 
+  def createInsightReportKeyMetric(insightID, reportID, keyMetricName)
+    if !keyMetricName.nil? && !keyMetricName.empty? && !insightID.nil?  && !reportID.nil?
 
-   def self.putCustomDataContext(server, endpoint, param)
-      result = self.http_post(server, endpoint, param)
-      #p result.code.to_s 
-      if result.code.to_s == "200"
-        return true 
+      keyMetricID = nil
+      keyMetricID = getReportKeyMetricID(insightID, reportID, keyMetricName)
+      
+      if !keyMetricID.nil?
+        return keyMetricID
       else
-        return false 
-      end     
-   end
+        paramHash = Hash.new
+        paramHash["context"]      = "insights"
+        paramHash["contextID"]    = insightID
+        paramHash["subContext"]   = "insight_reports"
+        paramHash["subContextID"] = reportID
+        paramHash["leafContext"]  = "insight_cards"
+        paramHash["data"]         = {"name" => keyMetricName}
 
+        log("DEBUG", "Attempting creation of report key metric with name " + keyMetricName + "...")
+        keyMetric = updateCloudmunchData(paramHash)
 
-   def self.getCustomDataContext(server, endpoint, param)
-      return self.http_get(server, endpoint, param)
-   end
+        if keyMetric["id"].nil? then return nil else keyMetric["id"] end
+      end
+    else
+        log("DEBUG", "Key metric name, insight id and report id is needed for creating a report key metric")
+        return nil
+    end
+  end
+
+  def createInsightReport(insightID, reportName)
+    if !reportName.nil? && !reportName.empty? && !insightID.nil?
 
-   def self.http_get(server,path,params)
-      if params.nil?
-       return Net::HTTP.get(server, path)
+      reportID = nil
+      reportID = getExtractID(insightID, reportName)
+      
+      if !reportID.nil?
+        return reportID
       else
-         queryStr =  "#{path}?".concat(params.collect { |k,v| "#{k}=#{CGI::escape(v.to_s)}" }.join('&'))
-         puts ("SDKDEBUG: Calling URL " + server+queryStr)
-         uri = URI(server + "/" + queryStr)
-         return Net::HTTP.get(uri) 
+        paramHash = Hash.new
+        paramHash["context"]     = "insights"
+        paramHash["contextID"]   = insightID
+        paramHash["subContext"]  = "insight_reports"
+        paramHash["data"]        = {"name" => reportName}
+
+        log("DEBUG", "Attempting creation of report with name " + reportName + "...")
+        report = updateCloudmunchData(paramHash)
+
+        if report["id"].nil? then return nil else report["id"] end
       end
-   end
-   
-   def self.http_post(server,path,params)
-        queryStr =  "#{path}?".concat(params.collect { |k,v| "#{k}=#{CGI::escape(v.to_s)}" }.join('&'))
-        puts ("SDKDEBUG: Calling URL " + server+queryStr)
-        if params.nil?
-            return Net::HTTP.post(server, path)
-        else
-            uri = URI(server +  path)
-            return Net::HTTP.post_form(uri, params)
+    else
+        log("DEBUG", "Report name and insight id is needed for creating a report")
+        return nil
+    end
+  end
+
+  def updateInsightDataStoreExtract(insightID, dataStoreID, data)
+    # /applications/{application_id}/insights/{insight_id}/datastores/{datastore_id}
+
+    if (insightID.nil? || insightID.empty?) && (dataStoreID.nil? || dataStoreID.empty?) && data.nil?
+      log("DEBUG", "Insight id, datastore id and data is needed to be update an existing data store")
+      return nil
+    end
+        paramHash = {}
+        paramHash["context"]      = "insights"
+        paramHash["contextID"]    = insightID
+        paramHash["subContext"]   = "datastores"
+        paramHash["subContextID"] = dataStoreID
+        paramHash["data"]         = data
+        return updateCloudmunchData(paramHash)
+  end
+
+  def updateInsightReport(insightID, reportID, data)
+    # /applications/{application_id}/insights/{insight_id}/insight_reports/{insight_report_id}
+
+    if (insightID.nil? || insightID.empty?) && (reportID.nil? || reportID.empty?) && data.nil?
+      log("DEBUG", "Insight id, report id and data is needed to be update an existing report")
+      return nil
+    end
+        paramHash = {}
+        paramHash["context"]      = "insights"
+        paramHash["contextID"]    = insightID
+        paramHash["subContext"]   = "insight_reports"
+        paramHash["subContextID"] = reportID
+        paramHash["data"]         = data
+        return updateCloudmunchData(paramHash)
+  end
+
+  def updateInsightDataStoreExtract(insightID, dataStoreID, extractID, data)
+    # /insights/{insight_id}/datastores/{datastore_id}/extracts/{extract_id}
+
+    if (insightID.nil? || insightID.empty?) && (dataStoreID.nil? || dataStoreID.empty?) && (extractID.nil? || extractID.empty?) && data.nil?
+      log("DEBUG", "Insight id, datastore id, extract id and data is needed to be update an existing extract")
+      return nil
+    end
+        paramHash = {}
+        paramHash["context"]       = "insights"
+        paramHash["contextID"]     = insightID
+        paramHash["subContext"]    = "datastores"
+        paramHash["subContextID"]  = dataStoreID
+        paramHash["leafContext"]   = "extracts"
+        paramHash["leafContextID"] = extractID
+        paramHash["data"]          = data
+        return updateCloudmunchData(paramHash)
+  end
+
+
+  def updateInsightReportCard(insightID, reportID, cardID, data)
+    # /applications/{application_id}/insights/{insight_id}/insight_reports/{insight_report_id}/insight_cards/{insight_card_id}
+
+    if (insightID.nil? || insightID.empty?) && (reportID.nil? || reportID.empty?) && (cardID.nil? || cardID.empty?) && data.nil?
+      log("DEBUG", "Insight id, report id, cardID and data is needed to be update an existing report card")
+      return nil
+    end
+
+    paramHash = {}
+    paramHash["context"]       = "insights"
+    paramHash["contextID"]     = insightID
+    paramHash["subContext"]    = "insight_reports"
+    paramHash["subContextID"]  = reportID
+    paramHash["leafContext"]   = "insight_cards"
+    paramHash["leafContextID"] = cardID
+    paramHash["data"]          = data
+    return updateCloudmunchData(paramHash)
+  end
+
+
+  def updateInsightReportKeyMetric(insightID, reportID, keyMetricID, data)
+    # /applications/{application_id}/insights/{insight_id}/insight_reports/{insight_report_id}/key_metrics/{key_metric_id}
+
+    if (insightID.nil? || insightID.empty?) && (reportID.nil? || reportID.empty?) && (keyMetricID.nil? || keyMetricID.empty?) && data.nil?
+      log("DEBUG", "Insight id, report id, keyMetricID and data is needed to be update an existing report key metric")
+      return nil
+    end
+
+    paramHash = {}
+    paramHash["context"]       = "insights"
+    paramHash["contextID"]     = insightID
+    paramHash["subContext"]    = "insight_reports"
+    paramHash["subContextID"]  = reportID
+    paramHash["leafContext"]   = "key_metrics"
+    paramHash["leafContextID"] = keyMetricID
+    paramHash["data"]          = data
+    return updateCloudmunchData(paramHash)
+  end
+
+  def getInsightReportKeyMetrics(paramHash)
+    # /applications/{application_id}/insights/{insight_id}/insight_reports/{insight_report_id}/key_metrics/{key_metric_id}
+    paramReportId  = paramHash["reportID"].nil? ? nil : paramHash["reportID"]
+    paramInsightID = paramHash["insightID"].nil? ? nil : paramHash["insightID"]
+
+    if paramInsightID.nil? || paramInsightID.empty? || paramReportId.nil? || paramReportId.empty?
+      log("DEBUG", "Insight id and report id is needed to gets its report key metric details")
+      return nil
+    end
+
+    paramFormatted = Hash.new
+    paramFormatted = paramHash
+    paramFormatted["context"]      = "insights"
+    paramFormatted["subContext"]   = "insight_reports"
+    paramFormatted["leafContext"]  = "key_metrics"
+    paramFormatted["contextID"]    = paramInsightID
+    paramFormatted["subContextID"] = paramReportId
+    
+    if !paramHash["keyMetricID"].nil?
+      paramFormatted["leafContextID"] = paramHash["keyMetricID"]
+    end
+
+    return getCloudmunchData(paramFormatted)
+  end
+
+  def updateInsight(insightID, data)
+    # /applications/{application_id}/insights/{insight_id}
+
+    if (insightID.nil? || insightID.empty?) && data.nil?
+      log("DEBUG", "Insight id and data is needed to be update an existing data store")
+      return nil
+    end
+
+    paramHash = {}
+    paramHash["context"]   = "insights"
+    paramHash["contextID"] = insightID
+    paramHash["data"]      = data
+    return updateCloudmunchData(paramHash)
+  end
+
+  def updateCloudmunchData(paramHash, method = "POST") 
+      paramData = Hash.new
+      paramData["data"] = paramHash["data"]
+      
+      serverurl = nil
+      serverurl = generateServerURL(paramHash)
+
+      if serverurl.nil?
+          log("DEBUG", "Unable to generate server url")
+          log("ERROR", "Unable to "+method+" data on cloudmunch")    
+          return nil
+      end
+
+      uri = URI.parse(serverurl)              
+      
+      log("DEBUG", "URI for "+method+" : ")
+      log("DEBUG", uri)          
+      
+      if method.casecmp("post") == 0
+        responseJson = Net::HTTP.post_form(uri,"data" => paramData.to_json)
+      elsif method.casecmp("patch") == 0
+        #code for patch
+      elsif method.casecmp("put") == 0
+        #code for put
+      end
+      return parseResponse(responseJson.body)      
+  end
+
+  def parseResponse(responseJson)
+    requestDetails = (JSON.load(responseJson))['request']
+    responseData   = (JSON.load(responseJson))['data']
+
+    log("DEBUG", "Response : ")
+    log("DEBUG", responseJson)
+    
+    if !requestDetails['status'].nil? && requestDetails['status'].casecmp('success') == 0    
+        return responseData
+    else
+        if !requestDetails['message'].nil?
+          log("ERROR", requestDetails['message'])
         end
-   end
+        return nil
+    end
+  end
 
-   def self.getDataContext(server, endpoint, param)
-      getCustomDataContext(server, endpoint, param)     
-   end
+  def getCloudmunchData(paramHash)
+    serverurl = nil
+    serverurl = generateServerURL(paramHash,true)
 
+    if serverurl.nil?
+        log("DEBUG", "Unable to generate server url")
+        log("ERROR", "Unable to get data from cloudmunch")    
+        return nil
+    end
 
-   def self.updateDataContext(server, endpoint, param)
+    uri = URI.parse(serverurl)              
+    
+    log("DEBUG", "URI for get : ")
+    log("DEBUG", uri)          
+    
+    responseJson = Net::HTTP.get(uri)
+    return parseResponse(responseJson)
+  end
+
+  def getInsights(paramHash)
+    # /insights/{insight_id}
+    paraminsightID = paramHash["insightID"].nil? ? nil : paramHash["insightID"]
+
+    paramFormatted = Hash.new
+    paramFormatted = paramHash
+    paramFormatted["context"] = "insights"
+    
+    if !paraminsightID.nil? && !paraminsightID.empty?
+        paramFormatted["contextID"]  = paramInsightID
+    end    
+
+    return getCloudmunchData(paramFormatted)          
+  end
+
+  def getInsightDataStoreExtracts(paramHash)
+    # /insights/{insight_id}/datastores/{datastore_id}/extracts/{extract_id}
+    paramDataStoreId = paramHash["dataStoreID"].nil? ? nil : paramHash["dataStoreID"]
+    paramInsightID   = paramHash["insightID"].nil? ? nil : paramHash["insightID"]
+
+    serverurl   = nil
+
+    if paramInsightID.nil? || paramInsightID.empty? || paramDataStoreId.nil? || paramDataStoreId.empty?
+      log("DEBUG", "Insight id and datastore id is needed to gets its extract details")
+      return nil
+    end
+
+    paramFormatted = Hash.new
+    paramFormatted = paramHash
+    paramFormatted["context"]      = "insights"
+    paramFormatted["subContext"]   = "datastores"
+    paramFormatted["leafContext"]  = "extracts"
+    paramFormatted["contextID"]    = paramInsightID
+    paramFormatted["subContextID"] = paramDataStoreId
+    
+    if !paramHash["extractID"].nil?
+      paramFormatted["leafContextID"] = paramHash["extractID"]
+    end
+
+    return getCloudmunchData(paramFormatted)
+  end
+
+  def getInsightDataStores(paramHash)
+    # /insights/{insight_id}/datastores/{datastore_id}
+    paramInsightID  = paramHash["insightID"].nil? ? nil : paramHash["insightID"]
+
+    if paramInsightID.nil? || paramInsightID.empty?
+      log("DEBUG", "Insight id is not provided")
+      return nil
+    end
+
+    paramFormatted = Hash.new
+    paramFormatted = paramHash
+    paramFormatted["context"]    = "insights"
+    paramFormatted["subContext"] = "datastores"
+    paramFormatted["contextID"]  = paramInsightID
+    
+    if !paramHash["dataStoreID"].nil?
+      paramFormatted["subContextID"] = paramHash["dataStoreID"]
+    end
+    return getCloudmunchData(paramFormatted)          
+  end
+
+  def getInsightReports(paramHash)
+    # /applications/{application_id}/insights/{insight_id}/insight_reports/{insight_report_id}
+    paramInsightID = paramHash["insightID"].nil? ? nil : paramHash["insightID"]
+
+    if paramInsightID.nil? || paramInsightID.empty?
+      log("DEBUG", "Insight id is needed to gets its report details")
+      return nil
+    end
+
+    paramFormatted = Hash.new
+    paramFormatted = paramHash
+    paramFormatted["context"]    = "insights"
+    paramFormatted["subContext"] = "insight_reports"
+    paramFormatted["contextID"]  = paramInsightID
+    
+    if !paramHash["reportID"].nil?
+      paramFormatted["subContextID"] = paramHash["reportID"]
+    end
+
+    return getCloudmunchData(paramFormatted)
+  end
+
+  def getInsightReportCards(paramHash)
+    # /applications/{application_id}/insights/{insight_id}/insight_reports/{insight_report_id}/insight_cards/{insight_card_id}
+    paramReportId  = paramHash["reportID"].nil? ? nil : paramHash["reportID"]
+    paramInsightID = paramHash["insightID"].nil? ? nil : paramHash["insightID"]
+
+    if paramInsightID.nil? || paramInsightID.empty? || paramReportId.nil? || paramReportId.empty?
+      log("DEBUG", "Insight id and report id is needed to gets its report card details")
+      return nil
+    end
+
+    paramFormatted = Hash.new
+    paramFormatted = paramHash
+    paramFormatted["context"]      = "insights"
+    paramFormatted["subContext"]   = "insight_reports"
+    paramFormatted["leafContext"]  = "insight_cards"
+    paramFormatted["contextID"]    = paramInsightID
+    paramFormatted["subContextID"] = paramReportId
+    
+    if !paramHash["cardID"].nil?
+      paramFormatted["leafContextID"] = paramHash["cardID"]
+    end
+
+    return getCloudmunchData(paramFormatted)
+  end
+
+  def generateServerURL(paramHash, appendQueryParams = nil)
+
+    serverurl = ""
+    
+    if !paramHash["url"].nil?
+        serverurl = @appContext.get_data("{master_url}")+"/"+paramHash["url"]
+    elsif !paramHash["context"].nil?
+        paramContext       = paramHash["context"].nil? ? nil : paramHash["context"]
+        paramContextID     = paramHash["contextID"].nil? ? nil : paramHash["contextID"]
+        paramSubContext    = paramHash["subContext"].nil? ? nil : paramHash["subContext"]
+        paramSubContextID  = paramHash["subContextID"].nil? ? nil : paramHash["subContextID"]
+        paramLeafContext   = paramHash["leafContext"].nil? ? nil : paramHash["leafContext"]
+        paramLeafContextID = paramHash["leafContextID"].nil? ? nil : paramHash["leafContextID"]
+
+        serverurl=@appContext.get_data("{master_url}")+"/applications/"+@appContext.get_data("{application}")+"/"+paramContext
+
+        if !paramContextID.nil? && !paramContextID.empty?
+            serverurl=serverurl+"/"+paramContextID;
+            if !paramSubContext.nil? && !paramSubContext.empty?
+                serverurl=serverurl+"/"+paramSubContext;              
+                if !paramSubContextID.nil? && !paramSubContextID.empty?
+                    serverurl=serverurl+"/"+paramSubContextID;
+                    if !paramLeafContext.nil? && !paramLeafContext.empty?
+                        serverurl=serverurl+"/"+paramLeafContext;
+                        if !paramLeafContextID.nil? && !paramLeafContextID.empty?
+                            serverurl=serverurl+"/"+paramLeafContextID;
+                        end
+                    end
+                end
+            end
+        end
+    else
+        log("DEBUG", "No context provided for get api call");
+        return nil
+    end
+
+    queryString = ""
+    
+    if !appendQueryParams.nil?
+      queryString = queryString + "filter=" + paramHash["filter"].to_json + "&" if !paramHash["filter"].nil?
+      queryString = queryString + "fields=" + paramHash["fields"].to_s    + "&" if !paramHash["fields"].nil?
+      queryString = queryString + "count="  + paramHash["count"].to_s     + "&" if !paramHash["count"].nil?
+      queryString = queryString + "offset=" + paramHash["offset"].to_s    + "&" if !paramHash["offset"].nil?
+      queryString = queryString + "request_category=" + paramHash["requestCategory"].to_s + "&" if !paramHash["requestCategory"].nil?
+      queryString = queryString + "order_by=" + paramHash["orderBy"].to_s + "&" if !paramHash["orderBy"].nil?
+      queryString = queryString + "group_by=" + paramHash["groupBy"].to_s + "&" if !paramHash["groupBy"].nil?
+    end
+    serverurl = serverurl+"?"+queryString+"apikey="+@appContext.get_data("{api_key}")
+    return serverurl
+  end
+
+  def deleteCloudmunchData(paramHash)
+    paramContext = paramHash["context"]
+    paramContextID = paramHash["contextID"]
+
+    if !paramContext.nil? && !paramContext.empty? && !paramContextID.nil? && !paramContextID.empty?
+        serverurl=@appContext.get_data("{master_url}")+"/applications/"+@appContext.get_data("{application}")+"/"+context+"/"+contextID;
+        serverurl=serverurl+"?apikey="+@appContext.get_data("{api_key}")
+        uri = URI.parse(serverurl)
+        Net::HTTP::Delete(uri)
+        return 1
+    else
+        return nil
+    end
+  end 
+   
+  def deleteCloudmunchDataBKUP(context,contextID)
+    serverurl=@appContext.get_data("{master_url}")+"/applications/"+@appContext.get_data("{application}")+"/"+context+"/"+contextID;
+    serverurl=serverurl+"?apikey="+@appContext.get_data("{api_key}")
+    uri = URI.parse(serverurl)
+    Net::HTTP::Delete(uri)
+  end 
+
+  def self.putCustomDataContext(server, endpoint, param)
+    result = self.http_post(server, endpoint, param)
+    #p result.code.to_s 
+    if result.code.to_s == "200"
+      return true 
+    else
+      return false 
+    end     
+  end
+
+  def self.getCustomDataContext(server, endpoint, param)
+      return self.http_get(server, endpoint, param)
+  end
+
+  def self.http_get(server,path,params)
+    if params.nil?
+     return Net::HTTP.get(server, path)
+    else
+       queryStr =  "#{path}?".concat(params.collect { |k,v| "#{k}=#{CGI::escape(v.to_s)}" }.join('&'))
+       puts ("SDKDEBUG: Calling URL " + server+queryStr)
+       uri = URI(server + "/" + queryStr)
+       return Net::HTTP.get(uri) 
+    end
+  end
+ 
+  def self.http_post(server,path,params)
+    queryStr =  "#{path}?".concat(params.collect { |k,v| "#{k}=#{CGI::escape(v.to_s)}" }.join('&'))
+    puts ("SDKDEBUG: Calling URL " + server+queryStr)
+    if params.nil?
+        return Net::HTTP.post(server, path)
+    else
+        uri = URI(server +  path)
+        return Net::HTTP.post_form(uri, params)
+    end
+  end
+
+  def self.getDataContext(server, endpoint, param)
+      getCustomDataContext(server, endpoint, param)     
+  end
+
+  def self.updateDataContext(server, endpoint, param)
       putCustomDataContext(server, endpoint, param)  
-   end
-end
+  end
+end

data/lib/cloudmunch_Ruby_sdk_v2/ServiceProvider.rb

@@ -7,9 +7,7 @@ class ServiceProvider
     end
 
     def load_data(param)
-    	
-    	
-        @SP_data = JSON.parse(param[@providername])["configuration"]
+        @SP_data = param[@providername]["configuration"]
     end     
 
     def get_data(keyname)

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: cloudmunch_sdk
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.0
 platform: ruby
 authors:
+- ganesan krishnamurthy
 - syamk
 - rosmi
-- ganesankrishnamurthy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-12-03 00:00:00.000000000 Z
+date: 2015-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json