virtengine_api 0.1.0

data/lib/megam/core/backups.rb

@@ -0,0 +1,259 @@
+module Megam
+    class Backups < Megam::RestAdapter
+        def initialize(o)
+            @id = nil
+            @account_id = nil
+            @asm_id = nil
+            @org_id = nil
+            @tosca_type = nil
+            @inputs = []
+            @outputs = []
+            @labels = []
+            @name= nil
+            @status=nil
+            @image_id=nil
+            @created_at = nil
+            @some_msg = {}
+            super(o)
+        end
+
+        def backups
+            self
+        end
+        def id(arg=nil)
+            if arg != nil
+                @id = arg
+            else
+                @id
+            end
+        end
+
+        def account_id(arg=nil)
+            if arg != nil
+                @account_id = arg
+            else
+                @account_id
+            end
+        end
+
+        def asm_id(arg=nil)
+            if arg != nil
+                @asm_id = arg
+            else
+                @asm_id
+            end
+        end
+
+        def org_id(arg=nil)
+            if arg != nil
+                @org_id = arg
+            else
+                @org_id
+            end
+        end
+
+        def tosca_type(arg = nil)
+            if !arg.nil?
+                @tosca_type = arg
+            else
+                @tosca_type
+            end
+        end
+
+        def inputs(arg = [])
+            if arg != []
+                @inputs = arg
+            else
+                @inputs
+            end
+        end
+        def labels(arg=[])
+          if arg != []
+             @labels=arg
+          else
+             @labels
+           end
+       end
+
+        def outputs(arg = [])
+            if arg != []
+                @outputs = arg
+            else
+                @outputs
+            end
+        end
+
+        def name(arg=nil)
+            if arg != nil
+                @name = arg
+            else
+                @name
+            end
+        end
+
+        def status(arg=nil)
+            if arg != nil
+                @status = arg
+            else
+                @status
+            end
+        end
+
+        def image_id(arg=nil)
+            if arg != nil
+                @image_id = arg
+            else
+                @image_id
+            end
+        end
+
+        def created_at(arg=nil)
+            if arg != nil
+                @created_at = arg
+            else
+                @created_at
+            end
+        end
+
+        def error?
+            crocked  = true if (some_msg.has_key?(:msg_type) && some_msg[:msg_type] == "error")
+        end
+
+
+        def some_msg(arg=nil)
+            if arg != nil
+                @some_msg = arg
+            else
+                @some_msg
+            end
+        end
+
+
+        # Transform the ruby obj ->  to a Hash
+        def to_hash
+            index_hash = Hash.new
+            index_hash["json_claz"] = self.class.name
+            index_hash["id"] = id
+            index_hash["account_id"] = account_id
+            index_hash["asm_id"] = asm_id
+            index_hash["org_id"] = org_id
+            index_hash["labels"] = labels
+            index_hash["tosca_type"] = tosca_type
+            index_hash["inputs"] = inputs
+            index_hash["outputs"] = outputs
+            index_hash["name"] = name
+            index_hash["status"] = status
+            index_hash["image_id"] = image_id
+            index_hash["created_at"] = created_at
+            index_hash["some_msg"] = some_msg
+            index_hash
+        end
+
+        # Serialize this object as a hash: called from JsonCompat.
+        # Verify if this called from JsonCompat during testing.
+        def to_json(*a)
+            for_json.to_json(*a)
+        end
+
+        def for_json
+            result = {
+                "id" => id,
+                "account_id" => account_id,
+                "asm_id" => asm_id,
+                "org_id" => org_id,
+                "tosca_type" => tosca_type,
+                "inputs" => inputs,
+                "outputs" => outputs,
+                "name" => name,
+                "status" => status,
+                "image_id" => image_id,
+                "created_at" => created_at,
+                "labels" =>labels,
+            }
+            result
+        end
+
+        def self.json_create(o)
+            sps = new({})
+            sps.id(o["id"]) if o.has_key?("id")
+            sps.account_id(o["account_id"]) if o.has_key?("account_id")
+            sps.asm_id(o["asm_id"]) if o.has_key?("asm_id")
+            sps.org_id(o["org_id"]) if o.has_key?("org_id") #this will be an array? can hash store array?
+            sps.tosca_type(o['tosca_type']) if o.key?('tosca_type')
+            sps.inputs(o['inputs']) if o.key?('inputs')
+            sps.outputs(o['outputs']) if o.key?('outputs')
+            sps.name(o["name"]) if o.has_key?("name")
+            sps.status(o["status"]) if o.has_key?("status")
+            sps.image_id(o["image_id"]) if o.has_key?("image_id")
+            sps.created_at(o["created_at"]) if o.has_key?("created_at")
+            sps.labels(o["labels"]) if o.key?("labels")
+            sps.some_msg[:code] = o["code"] if o.has_key?("code")
+            sps.some_msg[:msg_type] = o["msg_type"] if o.has_key?("msg_type")
+            sps.some_msg[:msg]= o["msg"] if o.has_key?("msg")
+            sps.some_msg[:links] = o["links"] if o.has_key?("links")
+            sps
+        end
+
+        def self.from_hash(o)
+            sps = self.new(o)
+            sps.from_hash(o)
+            sps
+        end
+
+        def from_hash(o)
+            @id       = o[:id] if o.has_key?(:id)
+            @account_id       = o[:account_id] if o.has_key?(:account_id)
+            @asm_id        = o[:asm_id] if o.has_key?(:asm_id)
+            @org_id        = o[:org_id] if o.has_key?(:org_id)
+            @tosca_type        = o[:tosca_type] if o.key?(:tosca_type)
+            @inputs            = o[:inputs] if o.key?(:inputs)
+            @outputs           = o[:outputs] if o.key?(:outputs)
+            @name            = o[:name] if o.has_key?(:name)
+            @status            = o[:status] if o.has_key?(:status)
+            @image_id          = o[:image_id] if o.has_key?(:image_id)
+            @created_at        = o[:created_at] if o.has_key?(:created_at)
+            @labels            = o[:labels] if o.key?(:labels)
+            self
+        end
+
+        def self.create(params)
+            sps = from_hash(params)
+            sps.create
+        end
+
+        def self.update(params)
+            sps = from_hash(params)
+            sps.update
+        end
+
+        # Create the node via the REST API
+        def create
+            megam_rest.post_backups(to_hash)
+        end
+
+        def self.listall(params)
+            sps = self.new(params)
+            sps.megam_rest.list_backups
+        end
+
+        # Load a account by email_p
+        def self.list(o)
+            sps = self.new(o)
+            sps.megam_rest.get_backups(o[:id])
+        end
+
+        def self.show(o)
+            sps = self.new(o)
+            sps.megam_rest.get_one_backup(o[:id])
+        end
+
+        def update
+            megam_rest.update_backups(to_hash)
+        end
+
+        def to_s
+            Megam::Stuff.styled_hash(to_hash)
+        end
+
+    end
+end

data/lib/megam/core/backups_collection.rb

@@ -0,0 +1,122 @@
+module Megam
+  class BackupsCollection
+    include Enumerable
+
+    attr_reader :iterator
+    def initialize
+      @backups = Array.new
+      @backups_by_name = Hash.new
+      @insert_after_idx = nil
+    end
+
+    def all_backups
+      @backups
+    end
+
+    def [](index)
+      @backups[index]
+    end
+
+    def []=(index, arg)
+      is_megam_backups(arg)
+      @backups[index] = arg
+      @backups_by_name[arg.account_id] = index
+    end
+
+    def <<(*args)
+      args.flatten.each do |a|
+        is_megam_backups(a)
+        @backups << a
+        @backups_by_name[a.account_id] = @backups.length - 1
+      end
+      self
+    end
+
+    # 'push' is an alias method to <<
+    alias_method :push, :<<
+
+    def insert(backups)
+      is_megam_backups(backups)
+      if @insert_after_idx
+        # in the middle of executing a run, so any nodes inserted now should
+        # be placed after the most recent addition done by the currently executing
+        # node
+        @backups.insert(@insert_after_idx + 1, backups)
+        # update name -> location mappings and register new node
+        @backups_by_name.each_key do |key|
+        @backups_by_name[key] += 1 if @backups_by_name[key] > @insert_after_idx
+        end
+        @backups_by_name[backups.account_id] = @insert_after_idx + 1
+        @insert_after_idx += 1
+      else
+      @backups << backups
+      @backups_by_name[backups.account_id] = @backups.length - 1
+      end
+    end
+
+    def each
+      @backups.each do |backups|
+        yield backups
+      end
+    end
+
+    def each_index
+      @backups.each_index do |i|
+        yield i
+      end
+    end
+
+    def empty?
+      @backups.empty?
+    end
+
+    def lookup(backups)
+      lookup_by = nil
+      if events.kind_of?(Megam::Backups)
+      lookup_by = backups.account_id
+    elsif backups.kind_of?(String)
+      lookup_by = backups
+      else
+        raise ArgumentError, "Must pass a Megam::Backups or String to lookup"
+      end
+      res = @backups_by_name[lookup_by]
+      unless res
+        raise ArgumentError, "Cannot find a node matching #{lookup_by} (did you define it first?)"
+      end
+      @backups[res]
+    end
+
+    def to_s
+        @backups.join(", ")
+    end
+
+    def for_json
+        to_a.map { |item| item.to_s }
+    end
+
+    def to_json(*a)
+        Megam::JSONCompat.to_json(for_json, *a)
+    end
+
+    def self.json_create(o)
+      collection = self.new()
+      o["results"].each do |backups_list|
+        backups_array = backups_list.kind_of?(Array) ? backups_list : [ backups_list ]
+        backups_array.each do |backups|
+          collection.insert(backups)
+
+        end
+      end
+      collection
+    end
+
+    private
+
+    def is_megam_backups(arg)
+      unless arg.kind_of?(Megam::Backups)
+        raise ArgumentError, "Members must be Megam::Backups's"
+      end
+      true
+    end
+  end
+end

data/lib/megam/core/balances.rb

@@ -0,0 +1,187 @@
+module Megam
+    class Balances < Megam::RestAdapter
+        def initialize(o)
+            @id = nil
+            @account_id = nil
+            @credit = nil
+            @biller_credit = nil
+            @created_at = nil
+            @updated_at = nil
+            @some_msg = {}
+            super(o)
+        end
+
+        def balances
+            self
+        end
+
+        def id(arg=nil)
+            if arg != nil
+                @id = arg
+            else
+                @id
+            end
+        end
+
+        def account_id(arg=nil)
+            if arg != nil
+                @account_id= arg
+            else
+                @account_id
+            end
+        end
+
+
+        def credit(arg=nil)
+            if arg != nil
+                @credit = arg
+            else
+                @credit
+            end
+        end
+
+        def biller_credit(arg=nil)
+            if arg != nil
+                @biller_credit = arg
+            else
+                @biller_credit
+            end
+        end
+
+        def created_at(arg=nil)
+            if arg != nil
+                @created_at = arg
+            else
+                @created_at
+            end
+        end
+
+        def updated_at(arg=nil)
+            if arg != nil
+                @updated_at = arg
+            else
+                @updated_at
+            end
+        end
+
+        def some_msg(arg=nil)
+            if arg != nil
+                @some_msg = arg
+            else
+                @some_msg
+            end
+        end
+
+        def error?
+            crocked  = true if (some_msg.has_key?(:msg_type) && some_msg[:msg_type] == "error")
+        end
+
+        # Transform the ruby obj ->  to a Hash
+        def to_hash
+            index_hash = Hash.new
+            index_hash["json_claz"] = self.class.name
+            index_hash["id"] = id
+            index_hash["account_id"] = account_id
+            index_hash["credit"] = credit
+            index_hash["biller_credit"] = biller_credit
+            index_hash["created_at"] = created_at
+            index_hash["updated_at"] = updated_at
+            index_hash
+        end
+
+        # Serialize this object as a hash: called from JsonCompat.
+        # Verify if this called from JsonCompat during testing.
+        def to_json(*a)
+            for_json.to_json(*a)
+        end
+
+        def for_json
+            result = {
+                "id" => id,
+                "account_id" => account_id,
+                "credit" => credit,
+                "biller_credit" => biller_credit,
+                "created_at" => created_at,
+                "updated_at" => updated_at
+            }
+            result
+        end
+
+        def self.json_create(o)
+            balances = new({})
+            balances.id(o["id"]) if o.has_key?("id")
+            balances.account_id(o["account_id"]) if o.has_key?("account_id")
+            balances.credit(o["credit"]) if o.has_key?("credit")
+            balances.biller_credit(o["biller_credit"]) if o.has_key?("biller_credit")
+            balances.created_at(o["created_at"]) if o.has_key?("created_at")
+            balances.updated_at(o["updated_at"]) if o.has_key?("updated_at")
+            #success or error
+            balances.some_msg[:code] = o["code"] if o.has_key?("code")
+            balances.some_msg[:msg_type] = o["msg_type"] if o.has_key?("msg_type")
+            balances.some_msg[:msg]= o["msg"] if o.has_key?("msg")
+            balances.some_msg[:links] = o["links"] if o.has_key?("links")
+            balances
+        end
+
+        def self.from_hash(o)
+            balances = self.new(o)
+            balances.from_hash(o)
+            balances
+        end
+
+        def from_hash(o)
+            @id        = o[:id] if o.has_key?(:id)
+            @account_id = o[:account_id] if o.has_key?(:account_id)
+            @credit   = o[:credit] if o.has_key?(:credit)
+            @biller_credit   = o[:biller_credit] if o.has_key?(:biller_credit)
+            @created_at   = o[:created_at] if o.has_key?(:created_at)
+            @updated_at   = o[:updated_at] if o.has_key?(:updated_at)
+            self
+        end
+
+        def self.create(params)
+            acct = from_hash(params,params["email"], params["api_key"], params["host"])
+            acct.create
+        end
+
+        # Create the predef via the REST API
+        def create
+            megam_rest.post_balances(to_hash)
+        end
+
+        # Load all balances -
+        # returns a BalanceCollection
+        # don't return self. check if the Megam::BalanceCollection is returned.
+        def self.list(params)
+            balance = self.new(params)
+            balance.megam_rest.get_balances
+        end
+
+        # Show a particular balance by name,
+        # Megam::Balance
+        def self.show(params)
+            pre = self.new(params)
+            pre.megam_rest.get_balance(params["email"])
+        end
+
+        def self.delete(p_name,tmp_email=nil, tmp_api_key=nil, tmp_host=nil)
+            pre = self.new(tmp_email,tmp_api_key,tmp_host)
+            pre.megam_rest.delete_balance(p_name)
+        end
+
+        def self.update(params)
+            asm = from_hash(params)
+            asm.update
+        end
+
+        # Create the node via the REST API
+        def update
+            megam_rest.update_balance(to_hash)
+        end
+
+        def to_s
+            Megam::Stuff.styled_hash(to_hash)
+        end
+
+    end
+end