apollo_commons_ruby 0.7.0

data/lib/apollo_commons_ruby/TemplatesRakefile.rb

@@ -0,0 +1,816 @@
+require 'fileutils'
+require 'git'
+require 'rubygems'
+require_relative 'ResolveTemplate'
+require_relative 'TemplatesHelper'
+# require "google/cloud/translate"
+
+def create_template_from_file (configuration, template_group, language, view, template_name, template_path, is_apollo_config, tenant_id, project_id)
+  begin
+
+    puts "template_name #{template_name}"
+    #Parsing Presentation
+    presentation_file_path = file_of_name_in_dir_path(template_path,"presentation")
+    puts "presentation_file_path #{presentation_file_path}"
+    presentation = read_data_from_file_path(presentation_file_path)
+
+    #template should fail if presentation file is not present at all
+    if presentation_file_path == nil
+      raise "ERROR: Presentation file not found at path: #{presentation_file_path}"
+    end
+
+    if presentation_file_path.end_with? ".json"
+      #if presentation file is json, then enforce proper json
+      if !JSON.is_valid_json?(presentation)
+        raise "ERROR: Presentation is not a valid JSON"
+      end
+      presentation = JSON.parse(presentation).to_json
+      presentation = ResolveTemplate.new.resolveLang(presentation.to_json, configuration,language)
+      presentation = JSON.parse(presentation, :quirks_mode => true)
+    end
+    if presentation_file_path.end_with? ".html"
+      presentation = ResolveTemplate.new.resolveLang(presentation, configuration, language)
+      presentation = Base64.encode64(presentation).newline
+    else
+      presentation = ResolveTemplate.new.resolveLang(presentation, configuration, language)
+      presentation = Base64.encode64(presentation.newline).newline
+    end
+
+    #Parsing Default Content
+    default_content_file_path = file_of_name_in_dir_path(template_path,"defaultContent")
+    #many templates will not support defaultContent, hence initializing a default value
+    default_content = {}
+    if !(default_content_file_path == nil)
+      #Default Content file is present
+      begin
+        default_content = read_data_from_file_path(default_content_file_path)
+      rescue Exception => e
+        #Mostly this should not happen, but a sanity check
+        puts "ERROR: default content file not found #{e}"
+      end
+      #If default content is read from file, it should be definitely be of JSON format because i.e. what the API expects
+      if !JSON.is_valid_json?(default_content)
+        #If not, throw exception
+        raise "ERROR: default content is not a valid JSON"
+      else
+        #Convert json file read to hash so that it is passed to API in json form
+        default_content = JSON.parse(default_content)
+        default_content = ResolveTemplate.new.resolveEnv(default_content.to_json, configuration, tenant_id, project_id)
+        default_content = JSON.parse(default_content)
+      end
+    end
+    default_content_string = default_content.to_json
+
+    transformer_file_path = file_of_name_in_dir_path(configuration.template_group_dir_path_for_template(template_group), "clientTransformer")
+
+    isClientTransformerFound = false
+    if !(transformer_file_path == nil)
+
+      isClientTransformerFound = true
+
+      begin
+        client_transformer = get_client_transformer_without_require(transformer_file_path)
+      rescue Exception => e
+        #Mostly this should not happen, but a sanity check
+        puts "ERROR: client transformer file not found #{e}"
+      end
+
+
+      if client_transformer == nil
+        client_transformer = "";
+      end
+
+      client_transformer = client_transformer.newline.tabs
+
+    end
+
+    #Parsing data template
+    data_template_file_path = file_of_name_in_dir_path(template_path,"dataTemplate")
+    puts "data_template_file_path #{data_template_file_path}"
+    #many templates will not support dataTemplate, hence initializing a default value
+    data_template = "{}"
+    if !(data_template_file_path == nil)
+      #data template file is present
+      begin
+        data_template = read_data_from_file_path(data_template_file_path)
+      rescue Exception => e
+        #Mostly this should not happen, but a sanity check
+        puts "ERROR: data template file not found #{e}"
+      end
+      if data_template_file_path.end_with? ".json" and !data_template.newline.empty?
+        #if data template file is json, then enforce proper json
+        if !JSON.is_valid_json?(data_template)
+          raise "ERROR: data template is not a valid JSON"
+        end
+        data_template = "#{data_template}"
+      end
+    end
+
+    #Parsing client transformer specific to individual template
+    specific_client_transformer_file_path = file_of_name_in_dir_path(template_path,"clientTransformer")
+    puts "specific_client_transformer_file_path #{specific_client_transformer_file_path}"
+    specific_client_transformer = "{}";
+    if !(specific_client_transformer_file_path == nil)
+      begin
+        specific_client_transformer = get_client_transformer_without_require(specific_client_transformer_file_path)
+      rescue Exception => e
+        puts "ERROR: specific client transformer file not found #{e}"
+      end
+      if isClientTransformerFound
+        client_transformer = client_transformer + "\n" + specific_client_transformer
+      elsif specific_client_transformer
+        client_transformer = specific_client_transformer
+        isClientTransformerFound = true
+      end
+    end
+
+    #Parsing attrs json	
+    attrs_json_file_path = file_of_name_in_dir_path(template_path, "attrs")	
+    puts "attrs_json_file_path #{attrs_json_file_path}"	
+    #many templates will not have attrs json, hence initializing a default value	
+    attrs_json = "{}"	
+    if !(attrs_json_file_path == nil)	
+      #attrs file is present	
+      begin	
+        attrs_json = read_data_from_file_path(attrs_json_file_path)	
+      rescue Exception => e	
+        #Mostly this should not happen, but a sanity check	
+        puts "ERROR: attrs file not found #{e}"	
+      end	
+      if attrs_json_file_path.end_with? ".json" and !attrs_json.newline.empty?	
+        #if attrs file is json, then enforce proper json	
+        if !JSON.is_valid_json?(attrs_json)	
+          raise "ERROR: attrs is not a valid JSON"	
+        end	
+        attrs_json = "#{attrs_json}"	
+      end	
+    end	
+
+    if isClientTransformerFound
+      client_transformer = client_transformer.newline.tabs
+      if client_transformer.scan(/^\s*<%.*%>\s*$/).length == 0
+        client_transformer = "<% #{client_transformer} %>"
+      end
+      if JSON.is_valid_json?(data_template)
+        data_template_hash_new = Hash.new
+        data_template_hash_new["__transformer"] = client_transformer
+        data_template_hash = JSON.parse(data_template)
+        data_template_hash_new.merge!(data_template_hash)
+        data_template = data_template_hash_new.to_json
+      else
+        data_template = "#{client_transformer}#{data_template}"
+      end
+    end
+
+    data_template = ResolveTemplate.new.resolveEnv(data_template, configuration, tenant_id, project_id)
+    data_template = ResolveTemplate.new.resolveLang(data_template, configuration, language)
+    data_template = Base64.encode64(data_template.newline).newline
+
+    if is_apollo_config
+      Template.new(template_name, default_content_string, data_template, presentation, attrs_json)
+    else
+      Template.new(template_name, default_content, data_template, presentation, attrs_json)
+    end
+  rescue Exception => e
+    puts "ERROR: Template loading from #{template_group} failed with error: #{e}"
+  end
+end
+
+def create_template_mapping_payload(template_group, language, view_type, templateMappings, version)
+  body = {
+      "templateGroup" => template_group,
+      "language" => language,
+      "viewType" => view_type,
+      "templateMappings" => templateMappings,
+      "version" => version
+    }
+end
+
+def get_parsed_template_group_details(configuration,template_group)
+  template_group_details_file_path = configuration.template_group_details_file_path_for_template(template_group)
+  template_group_details = read_json_data_from_file_path(template_group_details_file_path)
+  return JSON.parse(template_group_details)
+end
+
+def verify_and_get_template_version(version)
+  allowed_versions = {"v2" => "iOS_v2", "v3" => "iOS_v3"}
+  if version == nil
+    return nil
+  end
+
+  if allowed_versions.has_value?(version)
+    return version
+  end
+
+  if allowed_versions.key?(version)
+    return allowed_versions[version]
+  end
+
+  raise "Unsupported template version: #{version}"
+end
+
+def perform_git_checks
+  current_branch = `git rev-parse --abbrev-ref HEAD`
+  if current_branch.eql?("master")
+    raise "Rake update in Prod can be performed only from master branch."
+  end
+
+  system("git fetch origin master > /dev/null 2>&1") or raise "Unable to fetch origin/master from git remote"
+  master = `git rev-parse master`
+  origin_master = `git rev-parse origin/master`
+
+  if !master.eql?(origin_master)
+    raise "Master is not in sync with Origin. Pull changes from remote and retry."
+  end
+end
+
+def get_client_transformer_without_require(file)
+    input_file_path = file.to_s
+    final_transformer_output = ""
+    line_number_of_require_in_input_file = 0
+    line_numbers_to_delete = []
+    terminate_processing_of_require_line = false
+    #Filter require lines and compute the path to transformer from the line
+    File.readlines(input_file_path).each do |require_line|
+      line_number_of_require_in_input_file += 1
+      is_requires = require_line.index("require ") == 0
+      #Iterate through the require lines, until the match is not found.
+      #Ignore rest of the lines that match 'require'.
+      if is_requires and !terminate_processing_of_require_line then
+        #Mark the lines that contain 'require' in the top part of the file
+        line_numbers_to_delete << line_number_of_require_in_input_file
+        require_line.slice! "require "
+        require_line = require_line.strip
+        require_line = require_line.gsub('"', '')
+        if !file_exists?(require_line)
+          raise "ERROR: Transformer file #{require_line} not found"
+        end
+        transformer_output = read_plain_text_data_from_file_path(require_line)
+        if (transformer_output == "")
+          raise "ERROR: Transformer file #{require_line} empty"
+        end
+        #Append transformers in the order of the require statements
+        final_transformer_output = final_transformer_output +  transformer_output + "\n"
+      else
+        terminate_processing_of_require_line = true
+      end
+    end
+    current_file_output = read_plain_text_data_from_file_path(input_file_path)
+    if final_transformer_output == "" then
+      current_file_output
+    else
+      current_line_number = 0
+      #Strip off 'require' commands from the current file's data(does not modify the file) present in the form of a variable
+      client_transformer_with_no_require_lines = ""
+      current_file_output.each_line do |line|
+        current_line_number += 1
+        should_remove_line = line_numbers_to_delete.include? current_line_number
+        #Remove the line if we had marked it for removal earlier
+        client_transformer_with_no_require_lines << line unless should_remove_line
+      end
+      #Prepend all the transformers to the script to be updated to the script that does not have 'require' command
+      client_transformer_with_no_require_lines = final_transformer_output + "\n" + client_transformer_with_no_require_lines
+      client_transformer_with_no_require_lines
+    end
+end
+
+def update_existing_translations(source_path, language_resource_path)
+  if (!file_exists?(language_resource_path))
+    log_error("Update Failed! No translation resource found at path [ #{language_resource_path} ]")
+    abort()
+  end
+
+  if (!file_exists?(source_path))
+    log_error("No source file found at path [ #{source_path} ]")
+    abort()
+  end
+
+  source_file_plain_text_data = read_plain_text_data_from_file_path(source_path)
+
+  new_translations = Hash.new
+  source_file_plain_text_data.split("\r\n").each { |value|
+    key_value_array = value.split(',')
+    # puts "Value: #{value} key_value_array: #{key_value_array}"
+    # abort()
+    if key_value_array.length >= 2
+      key = key_value_array[0]
+      key_value_array.delete_at(0)
+      value = key_value_array.join
+
+      new_translations[key] = value
+    else
+      log_error("Terminating! Found incorrect translation key,pair [ #{key_value_array}]")
+      abort()
+    end
+  }
+
+  old_translations = read_raw_json_data_from_file_path(language_resource_path);
+
+  new_translations.each { |key, value|
+    if old_translations.has_key?(key)
+      old_translations[key] = value
+      log_info("Updated translation for key [ #{key} ] with value: [ #{value} ]")
+    else
+      log_error("Key #{key} does not exist in existing translations. Ignoring it")
+    end
+  }
+
+  if new_translations.length > 0
+    log_info("Writing updated translations to file at path [ #{language_resource_path}]")
+    write_data_to_file(language_resource_path, old_translations)
+  else
+    log_info("Translations not updated due to no new updates")
+  end
+
+end
+
+desc "Available options"
+task :default do
+  puts "'rake update_one_template environment=Staging template_group=MCCS-grant-VOUCHER version=v2 scope_id=1001' to build the template for a template group. Version is optional. scope_id is required for templates. It will build for all languages and view_type present in the template group. If you want to build specifically for a view type or language or template_name, specify language or view_type or template_name as query param"
+end
+
+
+# $LINE_REPLACEMENT_DETAILS_LIST = Array.new
+# $TRANSLATOR = Google::Cloud::Translate.new(
+#     project_id: "zeta-pay",
+#     credentials: "./keyfile.json"
+# )
+
+def get_translated_line(text, target_language)
+    return $TRANSLATOR.translate text, to: target_language
+end
+
+def is_alpha_char(char)
+    return char == "s" || char == "f" || char == "d"
+end
+
+def is_numeric_char(char)
+    return char == "1" || char == "2" || char == "3" || char == "4" || char == "5" || char == "6" || char == "7" || char == "8" || char == "9"
+end
+
+def format_translated_line(text)
+    text = text.to_s.gsub("&#39;", " ")
+    text = text.to_s.gsub("&quot;", "\"")
+    text = text.to_s.gsub("&lt;", "<")
+    text = text.to_s.gsub("&gt;", ">")
+    index = 0
+    output = ""
+    length = text.length
+    while index < length
+        char = text[index]
+        if (char == "%" && index + 1 < length && text[index + 1] == " " && index + 2 < length && is_alpha_char(text[index + 2]))
+            output = output + " " + "%" + text[index + 2]
+            index = index + 2
+        elsif (char == "%" && index + 1 < length && text[index + 1] == " " && index + 2 < length && is_numeric_char(text[index + 2]) &&
+            index + 3 < length && text[index + 3] == " " && index + 4 < length && text[index + 4] == "$" &&
+            index + 5 < length && text[index + 5] == " " && index + 6 < length && is_alpha_char(text[index + 6]))
+            output = output + " " + "%" + text[index + 2] + "$" + text[index + 6]
+            index = index + 6
+        elsif (char == "\\" && index + 1 < length && text[index + 1] == " " && index + 2 < length && text[index + 2] == "n")
+            output = output + "\n"
+            index = index + 2
+        elsif (char == " " && index + 1 < length && text[index + 1] == "%" && index + 2 < length && text[index + 2] == " " &&
+            index + 3 < length && text[index + 3] == "%")
+            output = output + "%% "
+            index = index + 3
+        elsif (char == "<" && index + 1 < length && text[index + 1] == "%" && index + 2 < length && text[index + 2] == " " &&
+            index + 3 < length && text[index + 3] == "=")
+            output = output + "<%= "
+            index = index + 3
+        else
+            output = output + text[index]
+        end
+        index = index + 1
+    end
+    return output
+end
+
+def modify_file_line(line_replacement_details)
+  file_path = line_replacement_details.file_path
+  modified_file = IO.readlines(file_path).map do |line|
+      get_appropriate_line(line, line_replacement_details)
+  end
+  File.open(file_path, 'w') do |file|
+      file.puts modified_file
+  end
+end
+
+def get_appropriate_line(line, line_replacement_details)
+  if (line.strip.start_with?(line_replacement_details.redundant_line_prefix.strip))
+      return line_replacement_details.updated_line
+  end
+  return line
+end
+
+def change_line_in_file(line_replacement_list)
+  line_replacement_list.each do |line_replacement_details|
+      modify_file_line(line_replacement_details)
+  end
+end
+
+def get_modified_replacement_property(line_replacement_details)
+  file_path = line_replacement_details.file_path
+  redundant_line_prefix = line_replacement_details.redundant_line_prefix
+  updated_line = line_replacement_details.updated_line.to_s[0...-2]
+  return LineReplacementProperties.new(file_path, redundant_line_prefix, updated_line)
+end
+
+
+def add_translations_for_language(module_name, languages)
+    languages.split(",").each do |language|
+    if ("en-EN" == language)
+        puts "Default language is English. No need for translations"
+        next
+    end
+    target_language = language.split("-")[0]
+    target_file = language.split("-")[1] + ".json"
+        base_path = "./Resources/"
+        File.delete(base_path + target_file) if File.exist?(base_path + target_file)
+        puts "Removing file #{target_file}" if File.exist?(base_path + target_file)
+        file_name = "EN.json"
+        target_file_path = base_path + target_file
+        FileUtils.cp(base_path + file_name, target_file_path)
+        IO.readlines(target_file_path).map do |line|
+            trimmed_line = line.strip
+            if trimmed_line.length != 0
+                begin
+                    value = trimmed_line.split(":")[1]
+                    translated_line = format_translated_line(get_translated_line(value, target_language))
+                    if (!translated_line.to_s.end_with? ",")
+                       translated_line = translated_line + ","
+                    end
+                    formatted_line = trimmed_line.split(":")[0] + ": " + translated_line.to_s.strip
+                    puts "Translated Line #{formatted_line}"
+                    $LINE_REPLACEMENT_DETAILS_LIST.push(LineReplacementProperties.new(target_file_path, line, line.gsub(trimmed_line, formatted_line)))
+                rescue
+                    puts "Translation failed. Using the default line in place"
+                    $LINE_REPLACEMENT_DETAILS_LIST.push(LineReplacementProperties.new(target_file_path, line, line))
+                end
+            end
+        end
+    #Remove ending }
+    $LINE_REPLACEMENT_DETAILS_LIST.pop()
+    #Modify the last element which has , appended to it
+    $LINE_REPLACEMENT_DETAILS_LIST.push(get_modified_replacement_property($LINE_REPLACEMENT_DETAILS_LIST.pop()))
+    change_line_in_file($LINE_REPLACEMENT_DETAILS_LIST)
+      end
+end
+
+def deploy_all_templates()
+  # current_dir = Dir.pwd
+  # if !current_dir.include? "/Users/ios-ci/.jenkins/jobs/"
+  #   puts "This rake command is no more supported. Please use jenkins build http://iosci.corp.zeta.in:8080/job/"
+  #   return nil
+  # end
+
+  environment = ENV['environment']
+  if environment == nil
+    puts "`environment` has to be passed. Environment = `Prod`/'PreProd'/`Staging`"
+    return
+  end
+
+  if environment.eql?("Prod")
+    #perform_git_checks
+  end
+
+  require 'ostruct'
+  require 'parallel'
+  configuration = Configuration.new(environment)
+  template_groups = directory_list(configuration.base_folder_path)
+  total_tasks_size = 0
+  if template_groups
+    total_tasks_size = template_groups.size
+  end
+  puts "Total number of tasks to execute: #{total_tasks_size}"
+  puts "\n\n"
+  iter = 0
+  tasks = []
+  template_groups.each do |template_group|
+    #template_group = "MCCS-grant-VOUCHER"
+    shouldIgnore = false;
+    iter+=1
+    if shouldIgnore
+      puts "Task #{iter}/#{total_tasks_size}: Ignoring for templateGroup #{template_group} because already done in previous build"
+      next
+    else
+      puts "Task #{iter}/#{total_tasks_size}: Scheduling deployment for template_group #{template_group}"
+    end
+    ENV['environment'] = environment
+    ENV['template_group'] = template_group
+
+    task_to_schedule = OpenStruct.new
+    task_to_schedule.environment = ENV['environment']
+    task_to_schedule.template_group = ENV['template_group']
+    task_to_schedule.language = ENV['language']
+    task_to_schedule.view_type = ENV['view_type']
+    task_to_schedule.template_name = ENV['template_name']
+    task_to_schedule.version = ENV['version']
+    task_to_schedule.should_update_inbox = false
+    task_to_schedule.tenant_id = ENV['tenant_id']
+    task_to_schedule.project_id = ENV['project_id']
+    if ENV['scope_id'] === nil
+      raise "scope_id is mandatory for deploying templates."
+    end
+    task_to_schedule.scope_id = ENV['scope_id']
+    task_to_schedule.task_id = iter
+    tasks << task_to_schedule
+  end
+  puts "STARTING DEPLOYMENT NOW"
+  results = Parallel.map(tasks, progress: "DEPLOYING ALL TEMPLATES", :in_processes => 1) do |task|
+    begin
+      deploy_one_template(task)
+    rescue Exception => e
+      puts "Error for template " + task.template_group + " " + e.backtrace.to_s
+      File.open("templateScopeError.txt", "a") do |f|
+        f.puts(task.template_group )
+     end
+    end
+  end
+  puts "DONE!"
+end
+
+def deploy_one_template(task)
+  environment = task.environment
+  template_group = task.template_group
+  language = task.language
+  view_type = task.view_type
+  template_name = task.template_name
+  version = task.version
+  scope_id = task.scope_id
+  should_update_inbox = task.should_update_inbox
+  tenant_id = task.tenant_id
+  project_id = task.project_id
+
+  configuration = Configuration.new(environment)
+  return if configuration == nil
+
+  version = verify_and_get_template_version(version)
+
+  didOnce = false
+  template_group_details = get_parsed_template_group_details(configuration,template_group)
+
+  languages = []
+  if language == nil
+    languages = template_group_details["supportedLanguages"]
+  else
+    languages.push(language)
+  end
+
+  specific_language_folders = []
+  dir_path = configuration.template_group_dir_path_for_template(template_group)
+  specific_language_folders = directory_list(dir_path)
+
+  if languages.empty?
+    return "No language found"
+  end
+
+  puts "languages #{languages}"
+
+  languageMappings = template_group_details["languageMappings"]
+
+  languages.each do |language|
+    template_language_folder = language
+    if !specific_language_folders.include?(language)
+      template_language_folder = "common"
+    end
+
+    viewTypes = []
+    if view_type == nil
+      dir_path = configuration.language_dir_path_for_template(template_group, template_language_folder)
+      viewTypes = directory_list(dir_path)
+    else
+      viewTypes.push(view_type)
+    end
+
+    if viewTypes.empty?
+      return "No view types found"
+    end
+
+    puts "viewTypes #{viewTypes}"
+
+    viewTypes.each do |view_type|
+
+      allTemplateVariants = Set.new
+
+      selectedTemplateMappingsInbox = []
+      scopeConfigsMercury = []
+      dir_path = ""
+      if version == nil
+        dir_path = configuration.view_type_dir_path_for_template(template_group, template_language_folder, view_type)
+      else
+        dir_path = configuration.view_type_dir_path_for_template_with_version(template_group, template_language_folder, view_type, version)
+      end
+      allProbableTemplateNames = all_directory_and_sub_directory_with_character_not_in_dir_path(dir_path, "_")
+      puts "For ViewType #{view_type} allProbableTemplateNames #{allProbableTemplateNames}"
+      if !(template_name == nil)
+        selectedProbableTemplateNames = allProbableTemplateNames.select{|key,value| key == template_name }
+      else
+        selectedProbableTemplateNames = allProbableTemplateNames
+      end
+
+      if selectedProbableTemplateNames.empty?
+        puts "Error: No template names found"
+        next
+      end
+
+      if !languageMappings.nil?
+        languageMappingForLanguage = languageMappings[language];
+      else
+        languageMappingForLanguage = nil;
+      end
+      puts "languageMapping For #{language} =  #{languageMappingForLanguage}"
+
+      selectedProbableTemplateNames.each do |key, value|
+        if !language.eql?("EN") && !key.eql?("default") && !languageMappingForLanguage.nil? && !languageMappingForLanguage.include?(key)
+          puts "#{key} not included in languageMappings for #{language}"
+          next
+        end
+        template_mapping = template_mapping_in_dir_path_file_path_with_character(dir_path, value.clone, "_")
+        key = ResolveTemplate.new.resolveEnv(key.dup, configuration, tenant_id, project_id)
+        template_mapping_inbox = ResolveTemplate.new.resolveEnv(template_mapping.dup, configuration, tenant_id, project_id)
+        selectedTemplateMappingsInbox.push(TemplateMapping.new(key, value, template_mapping_inbox))
+      end
+
+      if !didOnce
+        puts "\n**Updating template group**\n\n"
+        if should_update_inbox
+          update_template_group_inbox(environment, configuration, template_group, scope_id, tenant_id, project_id)
+        end
+        upsert_template_group_apollo_config(environment, configuration, scope_id, template_group, view_type, version, tenant_id, project_id)
+        didOnce = true
+      end
+
+      puts "\n**Updating Templates for language #{language} view_type #{view_type}**\n"
+
+      if should_update_inbox
+        puts "\n*Insert default template in inbox*\n"
+        selectedTemplateMappingsInbox.each do |template_mapping|
+          template_mapping_hash = template_mapping.create_hash
+          if template_mapping_hash["template_name"] == "default"
+            if version == nil
+              puts "\n*For template_name #{template_mapping_hash["template_name"]}*\n"
+              templates = create_template_from_file(configuration, template_group, language, view_type, template_mapping_hash["template_name"], template_mapping_hash["template_path"], false, tenant_id, project_id).create_hash
+            else
+              puts "\n*For template_name #{template_mapping_hash["template_name"]}*\n"
+              version_path = "#{dir_path}"
+              templates = create_template_from_file(configuration, template_group, language, view_type, template_mapping_hash["template_name"], template_mapping_hash["template_path"], false, tenant_id, project_id).create_hash
+            end
+          end
+          request_payload = CreateTemplatePayload.new(template_group, language, view_type, templates, version)
+          puts "\n*Insert Call*\n"
+          invoke_API(environment, configuration.post_insert_templates_url, HTTP::POST, nil, request_payload.to_json)
+        end
+      end
+
+      #Update Templates
+      puts "\n*Update templates API Call*\n"
+
+      selectedTemplateMappingsInbox.each do |template_mapping|
+        inbox_template_name = scope_id
+        if version == nil
+          template_mapping_hash = template_mapping.create_hash
+          puts "\n*For template_name #{template_mapping_hash["template_name"]}*\n"
+          templates = create_template_from_file(configuration, template_group, language, view_type, inbox_template_name, template_mapping_hash["template_path"], false, tenant_id, project_id).create_hash
+          apollo_config_templates = create_template_from_file(configuration, template_group, language, view_type, template_mapping_hash["template_name"], template_mapping_hash["template_path"], true, tenant_id, project_id).create_hash
+        else
+          template_mapping_hash = template_mapping.create_hash
+          puts "\n*For template_name #{template_mapping_hash["template_name"]}*\n"
+          version_path = "#{dir_path}"
+          templates = create_template_from_file(configuration, template_group, language, view_type, inbox_template_name, template_mapping_hash["template_path"], false, tenant_id, project_id).create_hash
+          apollo_config_templates = create_template_from_file(configuration, template_group, language, view_type, template_mapping_hash["template_name"], template_mapping_hash["template_path"], true, tenant_id, project_id).create_hash
+        end
+        if should_update_inbox
+          request_payload = CreateTemplatePayload.new(template_group, language, view_type, templates, version)
+          puts "\n*Insert Call*\n"
+          invoke_API(environment, configuration.post_insert_templates_url, HTTP::POST, nil, request_payload.to_json)
+          puts "\n*Update Call*\n"
+          invoke_API(environment, configuration.post_update_templates_url, HTTP::POST, nil, request_payload.to_json)
+        end
+        upsert_templates_apollo_config(environment, configuration, scope_id, template_group, language, view_type, apollo_config_templates, version)
+      end
+
+      #Upsert Template Mappings
+      puts "\n*Upsert template mapping API Call*\n"
+      query_params = {
+        :templateGroup => template_group,
+        :language => language,
+        :viewType => view_type
+      }
+      if should_update_inbox
+        get_templates_for_view_response = invoke_API(environment, configuration.get_templates_for_view_url, HTTP::GET, query_params)
+        allTemplateMappingsInbox = get_templates_for_view_response["mappings"]
+        if allTemplateMappingsInbox == nil
+          allTemplateMappingsInbox = {}
+        end
+        if !allTemplateMappingsInbox.key?(scope_id)
+          allTemplateMappingsInbox.merge!("#{scope_id}": scope_id)
+        end
+        selectedTemplateMappingsInbox.each do |template_mapping|
+          template_mapping_hash = template_mapping.create_mapping
+          allTemplateMappingsInbox.merge!(template_mapping_hash)
+        end
+        request_payload = create_template_mapping_payload(template_group, language, view_type, allTemplateMappingsInbox, version)
+        invoke_API(environment, configuration.post_upsert_template_mappings_url, HTTP::POST, nil, request_payload.to_json)
+      end
+
+      templateMappingsPayload = {}
+      selectedTemplateMappingsInbox.each do |template_mapping|
+        template_mapping_hash = template_mapping.create_mapping
+        templateMappingsPayload.merge!(template_mapping_hash)
+      end
+      upsert_template_mappings_apollo_config(environment, configuration, scope_id, template_group, language, view_type, templateMappingsPayload, version)
+      puts "DONE FOR #{task.task_id}: #{template_group} \n"
+    end
+
+  end
+end
+
+def update_template_group_inbox(environment, configuration, template_group, scope_id, tenant_id, project_id)
+  query_params = {
+    :templateGroup => template_group
+  }
+  puts "\n*Fetching template group details API call*\n"
+  template_group_details_response = invoke_API(environment, configuration.get_template_group_details_url, HTTP::GET, query_params)
+
+  shouldMakeUpdateTemplateGroupCall = false
+
+  if template_group_details_response["templateGroup"] == template_group
+    shouldMakeUpdateTemplateGroupCall = true
+  end
+
+  template_group_details = get_parsed_template_group_details(configuration,template_group)
+
+  transformer_file_path = configuration.transfomer_file_path_for_template(template_group)
+  transformer_data = read_data_from_file_path(transformer_file_path)
+  transformer_data = ResolveTemplate.new.resolveEnv(transformer_data, configuration, tenant_id, project_id)
+
+  field_ordering = template_group_details["fieldOrdering"]
+  expected_data = template_group_details["expectedData"]
+
+  # TODO: Handle case where field_ordering is not empty.
+  field_ordering = ["appID"]
+
+  request_payload = {
+    :templateGroup => template_group,
+    :expectedData => expected_data,
+    :fieldOrdering => field_ordering,
+    :transformer => transformer_data
+  }
+
+  puts "\n*Update template group API call*\n"
+  if shouldMakeUpdateTemplateGroupCall
+    invoke_API(environment, configuration.post_update_template_group_url, HTTP::POST, nil, request_payload.to_json)
+  else
+    invoke_API(environment, configuration.post_insert_template_group_url, HTTP::POST, nil, request_payload.to_json)
+  end
+end
+
+def upsert_template_group_apollo_config(environment, configuration, scope_id, template_group, view, version, tenant_id, project_id)
+
+  template_group_details = get_parsed_template_group_details(configuration, template_group)
+
+  transformer_file_path = configuration.transfomer_file_path_for_template(template_group)
+  transformer_data = read_data_from_file_path(transformer_file_path)
+  transformer_data = ResolveTemplate.new.resolveEnv(transformer_data, configuration, tenant_id, project_id)
+
+  field_ordering = template_group_details["fieldOrdering"]
+  expected_data = template_group_details["expectedData"]
+
+  request_payload = {
+    :expectedData => expected_data,
+    :fieldOrdering => field_ordering,
+    :transformer => transformer_data,
+    :version => version
+  }
+
+  url = configuration.apollo_config_base_url + "/scopes/#{scope_id}/templateGroups/#{template_group}"
+
+  puts "\n*[Apollo-config]: Upsert template group API call*\n"
+  invoke_API(environment, url, HTTP::POST, nil, request_payload.to_json)
+end
+
+def upsert_template_mappings_apollo_config(environment, configuration, scope_id, template_group, language, view, mappings, version)
+
+  request_payload = {
+    :mappings => mappings,
+    :version => version
+  }
+
+  url = configuration.apollo_config_base_url + "/scopes/#{scope_id}/templateGroups/#{template_group}/languages/#{language}/views/#{view}/mappings/"
+
+  puts "\n*[Apollo-config]: Upsert template mappings API call*\n"
+  invoke_API(environment, url, HTTP::POST, nil, request_payload.to_json)
+end
+
+def upsert_templates_apollo_config(environment, configuration, scope_id, template_group, language, view, templates, version)
+
+  request_payload = {
+    :templates => templates,
+    :version => version
+  }
+
+  url = configuration.apollo_config_base_url + "/scopes/#{scope_id}/templateGroups/#{template_group}/languages/#{language}/views/#{view}/templates/"
+
+  puts "\n*[Apollo-config]: Upsert templates API call*\n"
+  invoke_API(environment, url, HTTP::POST, nil, request_payload.to_json)
+end