admin_module 0.1.4

data/lib/admin_module/snapshots.rb

@@ -0,0 +1,133 @@
+##############################################################################
+# File::    dc.rb
+# Purpose:: Interface to DataClearing functionality in admin module1
+#
+# Author::    Jeff McAffee 04/01/2015
+##############################################################################
+
+require 'admin_module/pages'
+
+module AdminModule
+
+  class Snapshots
+    attr_reader :page_factory
+
+    def initialize page_factory
+      @page_factory = page_factory
+    end
+
+    def list
+      snapshot_page.get_definitions
+    end
+
+    def rename src, dest
+      src = assert_definition_exists src
+      dest = assert_definition_does_not_exist dest
+
+      snapshot_page
+        .modify(src)
+        .set_name(dest)
+        .save
+    end
+
+    def import file_path
+      assert_file_exists file_path
+
+      defns = {}
+      File.open(file_path, 'r') do |f|
+        # Read array of definition hashes
+        defns = YAML.load(f)
+      end
+
+      existing_defns = list
+
+      defns.each do |name, data|
+        if existing_defns.include?(name)
+          update(data)
+        else
+          create(data)
+        end
+      end
+    end
+
+    def export file_path
+      defns = list
+      export_data = {}
+
+      defns.each do |defn|
+        export_data[defn] = read defn
+      end
+
+      File.open(file_path, 'w') do |f|
+        f.write export_data.to_yaml
+      end
+
+    rescue Exception => e
+      if e.message.include? 'No such file or directory'
+        raise IOError, "No such directory - #{file_path}"
+      else
+        raise e
+      end
+    end
+
+    def read name
+      name = assert_definition_exists name
+
+      snapshot_page
+        .modify(name)
+        .get_definition_data
+    end
+
+  private
+
+    def snapshot_page
+      page_factory.snapshot_definitions_page
+    end
+
+    def assert_definition_exists name
+      unless list.include? name
+        fail ArgumentError.new("A data clearing definition named '#{name}' does not exist")
+      end
+
+      name
+    end
+
+    def assert_definition_does_not_exist name
+      if list.include? name
+        fail ArgumentError.new("A data clearing definition named '#{name}' already exists")
+      end
+
+      name
+    end
+
+    def assert_file_exists file_path
+      raise IOError, "File not found: #{file_path}" unless File.exists?(file_path)
+    end
+
+    def update data
+      name = assert_definition_exists( extract_defn_name(data) )
+
+      snapshot_page
+        .modify(name)
+        .set_definition_data(data)
+        .save
+    end
+
+    def create data
+      name = assert_definition_does_not_exist( extract_defn_name(data) )
+
+      snapshot_page
+        .add
+        .set_definition_data(data)
+        .save
+    end
+
+    def extract_defn_name data
+      name = if data.is_a? Hash
+               data[:name]
+             else
+               String(data)
+             end
+    end
+  end
+end # module

data/lib/admin_module/stages.rb

@@ -0,0 +1,171 @@
+##############################################################################
+# File::    stages.rb
+# Purpose:: filedescription
+# 
+# Author::    Jeff McAffee 2015-03-09
+# Copyright:: Copyright (c) 2015, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+##############################################################################
+
+require 'admin_module/pages'
+
+module AdminModule
+
+  class Stages
+    attr_reader :page_factory
+
+    def initialize page_factory
+      @page_factory = page_factory
+    end
+
+    ##
+    # Return a list of stage names
+
+    def list
+      stages_page.get_stages
+    end
+
+    ##
+    # Retrieve stage configuration data for an existing stage
+
+    def read name
+      stages_page
+        .modify(name)
+        .get_stage_data
+    end
+
+    ##
+    # Update stage configuration data for an existing stage
+
+    def update name, data
+      stages_page
+        .modify(name)
+        .set_stage_data(data)
+        .save
+    end
+
+    ##
+    # Create stage configuration data for a new stage
+
+    def create data
+      # When creating a stage, we need to set its name and save it so
+      # an ID is created in the database to tie the tasks to.
+      #
+      # Foreign key errors will result otherwise.
+      name = data[:name]
+
+      stages_page
+        .add
+        .set_name(name)
+        .save
+
+      # Now, populate the rest of the data.
+      stages_page
+        .modify(name)
+        .set_stage_data(data)
+        .save
+    end
+
+    ##
+    # Delete a stage
+
+    def delete name
+      assert_stage_exists name
+
+      stages_page
+        .delete name
+    end
+
+    def rename src, dest
+      assert_stage_exists src
+      assert_stage_does_not_exist dest
+
+      stages_page
+        .modify(src)
+        .set_name(dest)
+        .save
+    end
+
+    ##
+    # Export data for all stages to a file
+
+    def export file_path
+      stages = list
+      export_data = {}
+
+      stages.each do |stage|
+        export_data[stage] = read stage
+      end
+
+      File.open(file_path, 'w') do |f|
+        f.write export_data.to_yaml
+      end
+
+    rescue Exception => e
+      if e.message.include? 'No such file or directory'
+        raise IOError, "No such directory - #{file_path}"
+      else
+        raise e
+      end
+    end
+
+    ##
+    # Import stage data from a file
+    #
+    # If the stage name doesn't currently exist, a new stage will be created.
+    # If the stage name exists, it will be updated.
+    # If allow_creation is false (default) a stage will NOT be created if it
+    # doesn't exist, existing stages will be updated.
+
+    def import file_path, allow_creation = false
+      raise IOError, "File not found: #{file_path}" unless File.exist? file_path
+
+      import_data = {}
+      File.open(file_path, 'r') do |f|
+        # Read array of stage hashes
+        # FIXME is this REALLY an array?
+        import_data = YAML.load(f)
+      end
+
+      existing_stages = list
+
+      import_data.each do |name, data|
+        if existing_stages.include? name
+          update name, data
+        else
+          if allow_creation
+            create data
+          else
+            puts "Stage '#{name}' does not exist. Skipping import."
+          end
+        end
+      end
+    end
+
+  private
+
+    def stages_page
+      page_factory.stages_page
+    end
+
+    def assert_stage_exists name
+      fail ArgumentError.new("A stage named '#{name}' does not exist") unless list.include? name
+    end
+
+    def assert_stage_does_not_exist name
+      fail ArgumentError.new("A stage named '#{name}' already exists") if list.include? name
+    end
+
+    ##
+    # Test stage data structure for validity
+    #
+    # Required: name
+
+    def valid_stage_data? data
+      if !data.key?(:name) || data[:name].nil? || data[:name].empty?
+        return false
+      end
+      true
+    end
+  end # class
+end # module

data/lib/admin_module/tasks.rb

@@ -0,0 +1,147 @@
+##############################################################################
+# File::    tasks.rb
+# Purpose:: Interface to tasks functionality in admin module
+#
+# Author::    Jeff McAffee 2015-04-19
+#
+##############################################################################
+
+require 'admin_module/pages'
+
+module AdminModule
+
+  class Tasks
+    attr_reader :page_factory
+
+    def initialize(page_factory)
+      @page_factory = page_factory
+    end
+
+    def rename src, dest
+      src = assert_task_exists( extract_task_name(src) )
+      dest = assert_task_does_not_exist( extract_task_name(dest) )
+
+      tasks_page
+        .modify(src)
+        .set_name(dest)
+        .save
+    end
+
+    def list
+      tasks_page.get_tasks
+    end
+
+    def create task
+      task_name = assert_task_does_not_exist( extract_task_name(task) )
+
+      tasks_page
+        .add
+        .set_task_data(task)
+        .save
+    end
+
+    def read task
+      task_name = assert_task_exists( extract_task_name(task) )
+
+      tasks_page
+        .modify( task_name )
+        .get_task_data
+    end
+
+    def update task
+      task_name = assert_task_exists( extract_task_name(task) )
+
+      tasks_page
+        .modify( task_name )
+        .set_task_data(task)
+        .save
+    end
+
+    #
+    # No functionality exists to DELETE tasks.
+    #
+
+    def export file_path
+      tasks = list
+      export_data = {}
+
+      tasks.each do |task|
+        export_data[task] = read task
+      end
+
+      File.open(file_path, 'w') do |f|
+        f.write export_data.to_yaml
+      end
+
+      # Explicitly return (nothing) to avoid polluting stdout (in rake task).
+      return
+
+    rescue Exception => e
+      if e.message.include? 'No such file or directory'
+        raise IOError, "No such directory - #{file_path}"
+      else
+        raise e
+      end
+    end
+
+    ##
+    # Import task configurations into the current environment from a file.
+
+    def import file_path, allow_create = false
+      raise IOError, "File not found: #{file_path}" unless File.exists?(file_path)
+
+      tasks = {}
+      File.open(file_path, 'r') do |f|
+        # Read array of task hashes.
+        tasks = YAML.load(f)
+      end
+
+      existing_tasks = list
+
+      tasks.each do |name, data|
+        if existing_tasks.include?(name)
+          update(data)
+        else
+          if allow_create
+            create(data)
+          else
+            puts "Unable to create #{name}. allow_create = false"
+          end
+        end
+      end
+
+      # Explicitly return (nothing) to avoid polluting stdout (in rake task).
+      return
+    end
+
+  private
+
+    def tasks_page
+      page_factory.tasks_page
+    end
+
+    def extract_task_name task
+      task_name = if task.is_a? Hash
+                    task[:name]
+                  else
+                    String(task)
+                  end
+    end
+
+    def assert_task_exists task_name
+      unless list.include? task_name
+        fail ArgumentError.new("A task named '#{task_name}' does not exist")
+      end
+
+      task_name
+    end
+
+    def assert_task_does_not_exist task_name
+      if list.include? task_name
+        fail ArgumentError.new("A task named '#{task_name}' already exists")
+      end
+
+      task_name
+    end
+  end # class Tasks
+end # module