admin_module 0.1.4

data/admin_module.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'admin_module/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "admin_module"
+  spec.version       = AdminModule::VERSION
+  spec.authors       = ["Jeff McAffee"]
+  spec.email         = ["jeff@ktechsystems.com"]
+  spec.description   = %q{Command line interface for Admin Module}
+  spec.summary       = %q{Admin Module CLI}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "cucumber", "~> 1.3.9"
+  spec.add_development_dependency "rspec", "~> 3.2.0"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  #spec.add_development_dependency "pry-byebug", "~> 1.3.3"
+  spec.add_development_dependency "pry", "~> 0.10"
+
+  spec.add_runtime_dependency "nokogiri"
+  spec.add_runtime_dependency "page-object"
+  spec.add_runtime_dependency "thor"
+  spec.add_runtime_dependency "ktutils"
+end

data/bin/admin_module

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler/setup'
+
+# Exit cleanly from an early interrupt
+Signal.trap("INT") { exit 1 }
+
+require 'admin_module'
+
+AdminModule::Runner.new(ARGV.dup).execute!
+

data/lib/admin_module.rb

@@ -0,0 +1,260 @@
+require "admin_module/version"
+require 'admin_module/config_helper'
+require "admin_module/cli"
+require 'admin_module/page_factory'
+require 'admin_module/pages'
+require 'admin_module/guideline'
+require 'admin_module/rulesets'
+require 'admin_module/rules'
+require 'admin_module/stages'
+require 'admin_module/locks'
+require 'admin_module/dc'
+require 'admin_module/snapshots'
+require 'admin_module/tasks'
+require 'admin_module/ppms'
+require 'admin_module/client'
+
+if ENV['DEBUG'].nil?
+  $debug = false
+else
+  $debug = true
+end
+
+class AuthenticationRequired < StandardError
+end
+
+module AdminModule
+  CONFIG_FILE_NAME = '.admin_module'
+
+  class << self
+    attr_accessor :configuration
+    attr_accessor :client
+  end
+
+  ##
+  # Setup admin_module configuration
+  #
+  # Attempts to find and load a configuration file the first time
+  # it's requested. If a config file cannot be found on in the current
+  # directory tree (moving towards trunk, not the leaves), a default
+  # configuration object is created.
+  #
+  # If a block is provided, the configuration object is yielded to the block
+  # after the configuration is loaded/created.
+  #
+
+  def self.configure
+    if self.configuration.nil?
+      unless self.load_configuration
+        self.configuration = Configuration.new
+      end
+    end
+    yield(configuration) if block_given?
+  end
+
+  ##
+  # Walk up the directory tree from current working dir (pwd) till a file
+  # named .admin_module is found
+  #
+  # Returns file path if found, nil if not.
+  #
+
+  def self.find_config_path
+    path = Pathname(Pathname.pwd).ascend{|d| h=d+CONFIG_FILE_NAME; break h if h.file?}
+  end
+
+  ##
+  # Write configuration to disk
+  #
+  # Writes to current working dir (pwd) if path is nil
+  #
+  # Returns path of emitted file
+  #
+
+  def self.save_configuration(path = nil)
+    # If no path provided, see if we can find one in the dir tree.
+    if path.nil?
+      path = find_config_path
+    end
+
+    # Still no path? Use the current working dir.
+    if path.nil?
+      path = Pathname.pwd
+    end
+
+    unless path.to_s.end_with?('/' + CONFIG_FILE_NAME)
+      path = Pathname(path) + CONFIG_FILE_NAME
+    end
+
+    path = Pathname(path).expand_path
+    File.write(path, YAML.dump(configuration))
+
+    path
+  end
+
+  ##
+  # Load the configuration from disk
+  #
+  # Returns true if config file found and loaded, false otherwise.
+  #
+
+  def self.load_configuration(path = nil)
+    # If no path provided, see if we can find one in the dir tree.
+    if path.nil?
+      path = find_config_path
+    end
+
+    return false if path.nil?
+    return false unless Pathname(path).exist?
+
+    File.open(path, 'r') do |f|
+      self.configuration = YAML.load(f)
+      puts "configuration loaded from #{path}" if $debug
+    end
+
+    true
+  end
+
+  class Configuration
+    attr_accessor :default_environment
+    attr_accessor :default_comment
+    attr_accessor :credentials
+    attr_accessor :base_urls
+    attr_accessor :xmlmaps
+    attr_accessor :aliases
+    attr_accessor :page_urls
+
+    # Browser timeout in seconds. Default: 360 (6 mins).
+    attr_accessor :browser_timeout
+
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @default_environment = :dev
+      @current_env = nil
+
+      @default_comment = 'no comment'
+
+      @credentials = {}
+      #@credentials = { dev: [ ENV['HSBC_DEV_USER'], ENV['HSBC_DEV_PASSWORD'] ],
+      #                dev2: [ ENV['HSBC_DEV2_USER'], ENV['HSBC_DEV2_PASSWORD'] ],
+      #                 sit: [ ENV['HSBC_SIT_USER'], ENV['HSBC_SIT_PASSWORD'] ],
+      #                 uat: [ ENV['HSBC_UAT_USER'], ENV['HSBC_UAT_PASSWORD'] ] }
+
+      @base_urls   = { dev: "http://207.38.119.211/fap2Dev/Admin",
+                      dev2: "http://207.38.119.211/fap2Dev2/Admin",
+                       sit: "http://207.38.119.211/fap2SIT/Admin",
+                       uat: "http://207.38.119.211/fap2UAT/Admin" }
+
+      @xmlmaps      = {}
+
+      @aliases      = {}
+
+      @page_urls   = {
+                       'ParametersPage' => "/admin/decision/parameters.aspx",
+                       'ParameterPage'  => "/admin/decision/parameter.aspx",
+                    }
+
+      @browser_timeout = 360
+    end
+
+    ##
+    # Set the current environment.
+    #
+
+    def current_env=(env)
+      env = env.to_sym
+
+      fail "Cannot set current_env to un-configured environment: #{env}" unless @base_urls.key? env
+
+      # This value is NOT included when dumping to YAML.
+      # See Configurtion#encode_with
+      @current_env = env.to_sym
+    end
+
+    ##
+    # Return the current environment.
+    # Will return the default environment if current environment is not set.
+    #
+
+    def current_env
+      return @default_environment if @current_env.nil?
+      @current_env
+    end
+
+    def base_url
+      @base_urls[current_env]
+    end
+
+    def url page_class
+      suffix = @page_urls[page_class.to_s.split('::').last]
+      raise "Unkown page [#{page_class.to_s}]" if suffix.nil?
+      base_url + suffix
+    end
+
+    def xmlmap xmlfile
+      gdlname = xmlmaps[File.basename(xmlfile, '.xml')]
+      if gdlname.nil?
+        errmsg = "No guideline has been mapped for #{File.basename(xmlfile)}"
+        trymsg = "Have you configured your gdl mappings?"
+        trymsg2= " Try: admin_module config add xmlmap <xmlfile> <gdlname>"
+        fail("#{errmsg}\n\n#{trymsg}\n#{trymsg2}") if gdlname.nil?
+      end
+      gdlname
+    end
+
+    def user_credentials
+      @credentials[current_env]
+    end
+
+    ##
+    # Control which instance vars are emitted when dumped to YAML.
+    #
+
+    def encode_with(coder)
+      vars = instance_variables.map { |x| x.to_s }
+      vars = vars - ["@current_env"]
+
+      vars.each do |var|
+        var_val = eval(var)
+        coder[var.gsub('@', '')] = var_val
+      end
+    end
+  end # Configuration
+
+
+  class Runner
+    def initialize(argv, client = AdminModule::Client.new, exit_code = true)
+      @argv = argv
+      AdminModule.client = client
+      @exit_code = exit_code
+    end
+
+    def execute!
+      exit_code = begin
+
+        # Run the Thor app
+        AdminModule::CLI.start(@argv)
+
+        # Thor::Base#start does not have a return value,
+        # assume success if no exception is thrown.
+        0
+      rescue StandardError => e
+        b = e.backtrace
+        b.unshift("#{b.shift}: #{e.message} (#{e.class})")
+        puts(b.map { |s| "\tfrom #{s}"}.join("\n"))
+        1
+      end
+
+      # Return the exit code
+      exit(exit_code) if @exit_code
+    end
+  end
+end
+
+# Call configure to force creation of the configuration object.
+AdminModule.configure
+

data/lib/admin_module/cli.rb

@@ -0,0 +1,54 @@
+##############################################################################
+# File::    cli.rb
+# Purpose:: Admin Module command line interface
+#
+# Author::    Jeff McAffee 06/28/2014
+#
+##############################################################################
+
+require 'thor'
+require 'admin_module/command'
+
+
+module AdminModule
+  class CLI < Thor
+
+    def self.start(*)
+      super
+    rescue Exception => e
+      raise e
+    end
+
+    def initialize(*args)
+      super
+    end
+
+    desc "gdl [COMMAND]", "run a guideline command"
+    subcommand "gdl", AdminModule::Command::Gdl
+
+    desc "config [COMMAND]", "modify configuration values"
+    subcommand "config", AdminModule::Command::Config
+
+    desc "ruleset [COMMAND]", "run a ruleset command"
+    subcommand "ruleset", AdminModule::Command::Ruleset
+
+    desc "rule [COMMAND]", "run a rule command"
+    subcommand "rule", AdminModule::Command::Rule
+
+    desc "lock [COMMAND]", "run a lock command"
+    subcommand "lock", AdminModule::Command::Lock
+
+    desc "stage [COMMAND]", "run a stage command"
+    subcommand "stage", AdminModule::Command::Stage
+
+    desc "dc [COMMAND]", "run a data clearing command"
+    subcommand "dc", AdminModule::Command::Dc
+
+    desc "snapshot [COMMAND]", "run a snapshot command"
+    subcommand "snapshot", AdminModule::Command::Snapshot
+
+    desc "task [COMMAND]", "run a task command"
+    subcommand "task", AdminModule::Command::Task
+  end # CLI
+end # AdminModule
+

data/lib/admin_module/cli/cli_guideline.rb

@@ -0,0 +1,80 @@
+##############################################################################
+# File::    cli.rb
+# Purpose:: filedescription
+#
+# Author::    Jeff McAffee 11/15/2013
+# Copyright:: Copyright (c) 2013, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+##############################################################################
+
+require 'admin_module/pages'
+
+
+class AdminModule::CLI
+  include AdminModule::Pages
+
+
+  ##
+  # Deploy an array of source files to the current environment.
+  #
+  # +source_files+ array of files, each file's basename must be in the configured aliases.
+  # +comments+ to be added to Version Notes area. Defaults to 'auto upload'
+
+  def deploy_files source_files, comments = nil
+    source_files.each do |src|
+      deploy src, File.basename(src, '.xml'), comments
+    end
+  end
+
+  ##
+  # Deploy a source file to a guideline in the current environment.
+  #
+  # +source_file+ full path to xml file to upload
+  # +gdl_name_or_alias+ guideline name (or alias) to version
+  # +comments+ to be added to Version Notes area. Defaults to 'auto upload'
+
+  def deploy source_file, gdl_name_or_alias, comments = nil
+    source_file = Array(source_file)[0]
+    raise IOError.new("Missing source file [#{source_file}]") unless File.exists? source_file
+    source_file = File.expand_path(source_file)
+
+    gdl_name_or_alias = File.basename(source_file, '.xml') if gdl_name_or_alias.nil?
+
+    login
+
+    gdl_name = alias_to_name(gdl_name_or_alias)
+
+    gdl_page_url = GuidelinesPage.new(browser, base_url).
+      open_guideline(gdl_name)
+
+    version_gdl_url = GuidelinePage.new(browser, gdl_page_url).
+      add_version()
+
+    GuidelineVersionPage.new(browser, version_gdl_url).
+      upload(source_file, comments)
+  end
+
+  ##
+  # Retrieve a guideline name from the configured aliases
+
+  def alias_to_name gdl_name_or_alias
+    aliases = AdminModule.configuration.aliases
+
+    gdl_name = aliases[gdl_name_or_alias]
+    gdl_name = gdl_name_or_alias if gdl_name.nil?
+
+    gdl_name
+  end
+
+  ###
+  # Version all guidelines
+
+  def version_all gdl_names, comments = nil
+    login
+
+    version_all_page_url = GuidelinesPage.new(browser, base_url).version_all
+    page = GuidelinesVersionAllPage.new(browser, version_all_page_url)
+
+    page.version gdl_names, comments
+  end
+end

data/lib/admin_module/cli/cli_lock.rb

@@ -0,0 +1,149 @@
+##############################################################################
+# File::    cli_lock.rb
+# Purpose:: filedescription
+# 
+# Author::    Jeff McAffee 11/15/2013
+# Copyright:: Copyright (c) 2013, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+##############################################################################
+
+require 'admin_module/pages'
+
+
+class AdminModule::CLI
+  include AdminModule::Pages
+
+
+  ##
+  # Retrieve lock configuration data from the current environment
+
+  def get_lock lock_name
+    login
+
+    begin
+      lock_def_url = LockDefinitionsPage.new(browser, base_url).
+        modify_lock(lock_name)
+    rescue Watir::Exception::NoValueFoundException => e
+      raise ArgumentError, "Lock [#{lock_name}] not found.\n\n#{e.message}"
+    end
+
+    lock_data = LockDefinitionPage.new(browser, lock_def_url).get_lock_data
+  end
+
+  ##
+  # Return a list of lock names in the current environment
+
+  def current_lock_names
+    login
+    LockDefinitionsPage.new(browser, base_url).locks_options
+  end
+
+  ##
+  # Return configuration data for all locks in the current environment
+
+  def all_locks
+    locks = {}
+
+    current_lock_names.each do |name|
+      locks[name] = get_lock(name)
+    end
+
+    locks
+  end
+
+  ##
+  # Test lock data structure for validity
+  #
+  # Required:
+  #   at least 1 parameter OR dts
+
+  def valid_lock_data? lock_data
+    if !lock_data.key?(:parameters) || lock_data[:parameters].empty?
+      if !lock_data.key?(:dts) || lock_data[:dts].empty?
+        return false
+      end
+    end
+    true
+  end
+
+  ##
+  # Test lock data structure for valid name
+  #
+
+  def lock_data_has_name? lock_data
+    return false unless lock_data.key?(:name)
+    return false if lock_data[:name].empty?
+    true
+  end
+
+  ##
+  # Create a lock in the current environment
+
+  def create_lock lock_data
+    raise ArgumentError, "Invalid lock data: #{lock_data.inspect}" unless valid_lock_data?(lock_data)
+    raise ArgumentError, "Missing lock name: #{lock_data.inspect}" unless lock_data_has_name?(lock_data)
+
+    login
+
+    lock_def_url = LockDefinitionsPage.new(browser, base_url).
+      create_lock(lock_data)
+
+    LockDefinitionPage.new(browser, lock_def_url).set_lock_data lock_data
+  end
+
+  ##
+  # Modify an existing lock in the current environment
+
+  def modify_lock lock_data, lock_name = nil
+    lock_name ||= lock_data[:name]
+    raise ArgumentError, "Invalid lock data: #{lock_data.inspect}" unless valid_lock_data?(lock_data)
+    raise ArgumentError, "Missing lock name" if (lock_name.nil? || lock_name.empty?)
+
+    # Make sure we populate the data's name param if empty so we don't try to write
+    # and save an empty name.
+    if lock_data[:name].nil? || lock_data[:name].empty?
+      lock_data[:name] = lock_name
+    end
+
+    login
+
+    lock_def_url = LockDefinitionsPage.new(browser, base_url).
+      modify_lock(lock_name)
+
+    LockDefinitionPage.new(browser, lock_def_url).set_lock_data lock_data
+  end
+
+  ##
+  # Export all lock configurations in the current environment to a file.
+
+  def export_locks file_name
+    FileUtils.mkdir_p File.dirname(file_name)
+    File.open(file_name, 'w') do |f|
+      # Write array of lock hashes.
+      f << YAML.dump(all_locks)
+    end
+  end
+
+  ##
+  # Import lock configurations into the current environment from a file.
+
+  def import_locks file_name
+    raise IOError, "File not found: #{file_name}" unless File.exists?(file_name)
+
+    locks = {}
+    File.open(file_name, 'r') do |f|
+      # Write array of lock hashes.
+      locks = YAML.load(f)
+    end
+
+    existing_locks = current_lock_names
+
+    locks.each do |name, data|
+      if existing_locks.include?(name)
+        modify_lock(data, name)
+      else
+        create_lock(data)
+      end
+    end
+  end
+end