virtengine_api 0.1.0

data/lib/megam/core/account_collection.rb

@@ -0,0 +1,122 @@
+module Megam
+    class AccountCollection
+        include Enumerable
+
+        attr_reader :iterator
+        def initialize
+            @accounts = Array.new
+            @accounts_by_name = Hash.new
+            @insert_after_idx = nil
+        end
+
+        def all_accounts
+            @accounts
+        end
+
+        def [](index)
+            @accounts[index]
+        end
+
+        def []=(index, arg)
+            is_account_hash(arg)
+            @accounts[index] = arg
+            @accounts_by_name[arg[:email]] = index
+        end
+
+        def <<(*args)
+            args.flatten.each do |a|
+                is_account_hash(a)
+                @accounts << a
+                @accounts_by_name[a[:email]] = @accounts.length - 1
+            end
+            self
+        end
+
+        # 'push' is an alias method to <<
+        alias_method :push, :<<
+
+        def insert(accounts)
+            is_account_hash(accounts)
+            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
+                @accounts.insert(@insert_after_idx + 1, accounts)
+                # update name -> location mappings and register new node
+                @accounts_by_name.each_key do |key|
+                    @accounts_by_name[key] += 1 if @accounts_by_name[key] > @insert_after_idx
+                end
+                @accounts_by_name[accounts[:email]] = @insert_after_idx + 1
+                @insert_after_idx += 1
+            else
+                @accounts << accounts
+                @accounts_by_name[accounts[:email]] = @accounts.length - 1
+            end
+        end
+
+        def each
+            @accounts.each do |accounts|
+                yield accounts
+            end
+        end
+
+        def each_index
+            @accounts.each_index do |i|
+                yield i
+            end
+        end
+
+        def empty?
+            @accounts.empty?
+        end
+
+        def lookup(accounts)
+            lookup_by = nil
+            if accounts.kind_of?(Hash)
+                lookup_by = accounts[:email]
+            elsif accounts.kind_of?(String)
+                lookup_by = accounts
+            else
+                raise ArgumentError, "Must pass a Megam::Account or String to lookup"
+            end
+            res = @accounts_by_name[lookup_by]
+            unless res
+                raise ArgumentError, "Cannot find a node matching #{lookup_by} (did you define it first?)"
+            end
+            @accounts[res]
+        end
+
+        def to_s
+            @accounts.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 |accounts_list|
+                accounts_array = accounts_list.kind_of?(Array) ? accounts_list : [ accounts_list ]
+                accounts_array.each do |accounts|
+                    collection.insert(accounts)
+
+                end
+            end
+            collection
+        end
+
+        private
+
+        def is_account_hash(arg)
+            unless arg.kind_of?(Hash)
+                raise ArgumentError, "Members must be a Hash"
+            end
+            true
+        end
+    end
+end

data/lib/megam/core/addons.rb

@@ -0,0 +1,169 @@
+module Megam
+    class Addons < Megam::RestAdapter
+        def initialize(o)
+            @id = nil
+            @provider_id = nil
+            @account_id = nil
+            @provider_name = nil
+            @options = []
+            @created_at = nil
+            @some_msg = {}
+            super(o)
+        end
+
+        def addons
+            self
+        end
+
+        def id(arg=nil)
+            if arg != nil
+                @id = arg
+            else
+                @id
+            end
+        end
+
+        def provider_id(arg=nil)
+            if arg != nil
+                @provider_id= arg
+            else
+                @provider_id
+            end
+        end
+
+        def account_id(arg=nil)
+            if arg != nil
+                @account_id= arg
+            else
+                @account_id
+            end
+        end
+
+        def provider_name(arg=nil)
+            if arg != nil
+                @provider_name = arg
+            else
+                @provider_name
+            end
+        end
+
+        def options(arg=[])
+            if arg != []
+                @options = arg
+            else
+                @options
+            end
+        end
+
+        def created_at(arg=nil)
+            if arg != nil
+                @created_at = arg
+            else
+                @created_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["provider_id"] = provider_id
+            index_hash["account_id"] = account_id
+            index_hash["provider_name"] = provider_name
+            index_hash["options"] = options
+            index_hash["created_at"] = created_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,
+                "provider_id" => provider_id,
+                "account_id" => account_id,
+                "provider_name" => provider_name ,
+                "options" => options,
+                "created_at" => created_at
+            }
+            result
+        end
+
+        #
+        def self.json_create(o)
+            adn = new({})
+            adn.id(o["id"]) if o.has_key?("id")
+            adn.provider_id(o["provider_id"]) if o.has_key?("provider_id")
+            adn.account_id(o["account_id"]) if o.has_key?("account_id")
+            adn.provider_name(o["provider_name"]) if o.has_key?("provider_name")
+            adn.options(o["options"]) if o.has_key?("options")
+            adn.created_at(o["created_at"]) if o.has_key?("created_at")
+            #success or error
+            adn.some_msg[:code] = o["code"] if o.has_key?("code")
+            adn.some_msg[:msg_type] = o["msg_type"] if o.has_key?("msg_type")
+            adn.some_msg[:msg]= o["msg"] if o.has_key?("msg")
+            adn.some_msg[:links] = o["links"] if o.has_key?("links")
+            adn
+        end
+
+        def self.from_hash(o)
+            adn = self.new(o)
+            adn.from_hash(o)
+            adn
+        end
+
+        def from_hash(o)
+            @id        = o[:id] if o.has_key?(:id)
+            @provider_id = o[:provider_id] if o.has_key?(:provider_id)
+            @account_id = o[:account_id] if o.has_key?(:account_id)
+            @provider_name   = o[:provider_name] if o.has_key?(:provider_name)
+            @options     = o[:options] if o.has_key?(:options)
+            @created_at   = o[:created_at] if o.has_key?(:created_at)
+            self
+        end
+
+        def self.create(params)
+            acct = from_hash(params)
+            acct.create
+        end
+
+        # Create the addons via the REST API
+        def create
+            megam_rest.post_addons(to_hash)
+        end
+
+        # Load all addons -
+        # returns a AddonsCollection
+        # don't return self. check if the Megam::AddonsCollection is returned.
+
+        # Show a particular addon by  provider_name,
+        # Megam::Addon
+        def self.show(params)
+            pre = self.new(params)
+            pre.megam_rest.get_addon(params["provider"])
+        end
+
+
+        def to_s
+            Megam::Stuff.styled_hash(to_hash)
+        end
+
+    end
+end

data/lib/megam/core/addons_collection.rb

@@ -0,0 +1,121 @@
+module Megam
+    class AddonsCollection
+        include Enumerable
+
+        attr_reader :iterator
+        def initialize
+            @addons = Array.new
+            @addons_by_name = Hash.new
+            @insert_after_idx = nil
+        end
+
+        def all_addons
+            @addons
+        end
+
+        def [](index)
+            @addons[index]
+        end
+
+        def []=(index, arg)
+            is_megam_addons(arg)
+            @addons[index] = arg
+            @addons_by_name[arg.account_id] = index
+        end
+
+        def <<(*args)
+            args.flatten.each do |a|
+                is_megam_addons(a)
+                @addons << a
+                @addons_by_name[a.account_id] =@addons.length - 1
+            end
+            self
+        end
+
+        # 'push' is an alias method to <<
+        alias_method :push, :<<
+
+        def insert(addons)
+            is_megam_addons(addons)
+            if @insert_after_idx
+                # in the middle of executing a run, so any predefs inserted now should
+                # be placed after the most recent addition done by the currently executing
+                # addons
+                @addons.insert(@insert_after_idx + 1, addons)
+                # update name -> location mappings and register new addons
+                @addons_by_name.each_key do |key|
+                    @addons_by_name[key] += 1 if@addons_by_name[key] > @insert_after_idx
+                end
+                @addons_by_name[addons.account_id] = @insert_after_idx + 1
+                @insert_after_idx += 1
+            else
+                @addons << addons
+                @addons_by_name[addons.account_id] =@addons.length - 1
+            end
+        end
+
+        def each
+            @addons.each do |addons|
+                yield addons
+            end
+        end
+
+        def each_index
+            @addons.each_index do |i|
+                yield i
+            end
+        end
+
+        def empty?
+            @addons.empty?
+        end
+
+        def lookup(addons)
+            lookup_by = nil
+            if Addons.kind_of?(Megam::Addons)
+                lookup_by = addons.account_id
+            elsif addons.kind_of?(String)
+                lookup_by = addons
+            else
+                raise ArgumentError, "Must pass a Megam::Addons or String to lookup"
+            end
+            res =@addons_by_name[lookup_by]
+            unless res
+                raise ArgumentError, "Cannot find a addons matching #{lookup_by} (did you define it first?)"
+            end
+            @addons[res]
+        end
+
+        def to_s
+            @addons.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 |addons_list|
+                addons_array = addons_list.kind_of?(Array) ? addons_list : [ addons_list ]
+                addons_array.each do |addons|
+                    collection.insert(addons)
+                end
+            end
+            collection
+        end
+
+        private
+
+        def is_megam_addons(arg)
+            unless arg.kind_of?(Megam::Addons)
+                raise ArgumentError, "Members must be Megam::addons's"
+            end
+            true
+        end
+    end
+end

data/lib/megam/core/assemblies.rb

@@ -0,0 +1,191 @@
+module Megam
+    class Assemblies < Megam::RestAdapter
+        def initialize(o)
+            @id = nil
+            @accounts_id = nil
+            @org_id = nil
+            @name = nil
+            @password = nil
+            @assemblies = []
+            @inputs = []
+            @created_at = nil
+            @some_msg = {}
+            super(o)
+        end
+
+        def assemblies
+            self
+        end
+
+        def id(arg=nil)
+            if arg != nil
+                @id = arg
+            else
+                @id
+            end
+        end
+
+        def accounts_id(arg=nil)
+            if arg != nil
+                @accounts_id = arg
+            else
+                @accounts_id
+            end
+        end
+
+        def org_id(arg=nil)
+            if arg != nil
+                @org_id = arg
+            else
+                @org_id
+            end
+        end
+
+        def password(arg=nil)
+            if arg != nil
+                @password = arg
+            else
+                @password
+            end
+        end
+
+        def name(arg=nil)
+            if arg != nil
+                @name = arg
+            else
+                @name
+            end
+        end
+
+        def assemblies(arg=[])
+            if arg != []
+                @assemblies = arg
+            else
+                @assemblies
+            end
+        end
+
+        def inputs(arg=[])
+            if arg != []
+                @inputs = arg
+            else
+                @inputs
+            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["org_id"] = org_id
+            index_hash["name"] = name
+            index_hash["accounts_id"] = accounts_id
+            index_hash["inputs"] = inputs
+            index_hash["assemblies"] = assemblies
+            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,
+                "name" => name,
+                "accounts_id" => accounts_id,
+                "org_id" => org_id,
+                "assemblies" => assemblies,
+                "inputs" => inputs,
+                "created_at" => created_at
+            }
+            result
+        end
+
+        def self.json_create(o)
+            asm = new({})
+            asm.id(o["id"]) if o.has_key?("id")
+            asm.name(o["name"]) if o.has_key?("name")
+            asm.accounts_id(o["accounts_id"]) if o.has_key?("accounts_id")
+            asm.org_id(o["org_id"]) if o.has_key?("org_id")
+            asm.assemblies(o["assemblies"]) if o.has_key?("assemblies") #this will be an array? can hash store array?
+            asm.inputs(o["inputs"]) if o.has_key?("inputs")
+            asm.created_at(o["created_at"]) if o.has_key?("created_at")
+            asm.some_msg[:code] = o["code"] if o.has_key?("code")
+            asm.some_msg[:msg_type] = o["msg_type"] if o.has_key?("msg_type")
+            asm.some_msg[:msg]= o["msg"] if o.has_key?("msg")
+            asm.some_msg[:links] = o["links"] if o.has_key?("links")
+            asm
+        end
+
+        def self.from_hash(o)
+            asm = self.new(o)
+            asm.from_hash(o)
+            asm
+        end
+
+        def from_hash(o)
+            @id                = o[:id] if o.has_key?(:id)
+            @name              = o[:name] if o.has_key?(:name)
+            @accounts_id       = o[:accounts_id] if o.has_key?(:accounts_id)
+            @org_id            = o[:org_id] if o.has_key?(:org_id)
+            @assemblies        = o[:assemblies] if o.has_key?(:assemblies)
+            @inputs            = o[:inputs] if o.has_key?(:inputs)
+            @created_at        = o[:created_at] if o.has_key?(:created_at)
+            self
+        end
+
+        def self.create(params)
+            asm = from_hash(params)
+            asm.create
+        end
+
+        # Create the node via the REST API
+        def create
+            megam_rest.post_assemblies(to_hash)
+        end
+
+        # Load a account by email_p
+        def self.show(o)
+            asm = self.new(o)
+            asm.megam_rest.get_one_assemblies(o[:assemblies_id])
+        end
+
+        def self.list(params)
+            asm = self.new(params)
+            asm.megam_rest.get_assemblies
+        end
+
+        def to_s
+            Megam::Stuff.styled_hash(to_hash)
+        end
+
+    end
+end