megam_api 0.17 → 0.18

data/lib/megam/core/{node_collection.rb → assemblies_collection.rb}

@@ -14,36 +14,35 @@
 # limitations under the License.
 #
 module Megam
-  class NodeCollection
+  class AssembliesCollection
     include Enumerable
 
-    
     attr_reader :iterator
     def initialize
-      @nodes = Array.new
-      @nodes_by_name = Hash.new
+      @assemblies = Array.new
+      @assemblies_by_name = Hash.new
       @insert_after_idx = nil
     end
 
-    def all_nodes
-      @nodes
+    def all_assemblies
+      @assemblies
     end
 
     def [](index)
-      @nodes[index]
+      @assemblies[index]
     end
 
     def []=(index, arg)
-      is_megam_node(arg)
-      @nodes[index] = arg
-      @nodes_by_name[arg.node_name] = index
+      is_megam_assemblies(arg)
+      @assemblies[index] = arg
+      @assemblies_by_name[arg.assembies_name] = index
     end
 
     def <<(*args)
       args.flatten.each do |a|
-        is_megam_node(a)
-        @nodes << a
-        @nodes_by_name[a.node_name] = @nodes.length - 1
+        is_megam_assemblies(a)
+        @assemblies << a
+        @assemblies_by_name[a.name] = @assemblies.length - 1
       end
       self
     end
@@ -51,62 +50,62 @@ module Megam
     # 'push' is an alias method to <<
     alias_method :push, :<<
 
-    def insert(node)
-      is_megam_node(node)
+    def insert(assemblies)
+      is_megam_assemblies(assemblies)
       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
-        @nodes.insert(@insert_after_idx + 1, node)
+        @assemblies.insert(@insert_after_idx + 1, assemblies)
         # update name -> location mappings and register new node
-        @nodes_by_name.each_key do |key|
-        @nodes_by_name[key] += 1 if @nodes_by_name[key] > @insert_after_idx
+        @assemblies_by_name.each_key do |key|
+        @assemblies_by_name[key] += 1 if @assemblies_by_name[key] > @insert_after_idx
         end
-        @nodes_by_name[node.node_name] = @insert_after_idx + 1
+        @assemblies_by_name[assemblies.name] = @insert_after_idx + 1
         @insert_after_idx += 1
       else
-      @nodes << node
-      @nodes_by_name[node.node_name] = @nodes.length - 1 
+      @assemblies << assemblies
+      @assemblies_by_name[assemblies.name] = @assemblies.length - 1
       end
     end
 
     def each
-      @nodes.each do |node|
-        yield node
+      @assemblies.each do |assemblies|
+        yield assemblies
       end
     end
 
     def each_index
-      @nodes.each_index do |i|
+      @assemblies.each_index do |i|
         yield i
       end
     end
 
     def empty?
-      @nodes.empty?
+      @assemblies.empty?
     end
 
-    def lookup(node)
+    def lookup(assemblies)
       lookup_by = nil
-      if node.kind_of?(Megam::Node)
-      lookup_by = node.node_name
-      elsif node.kind_of?(String)
-      lookup_by = node
+      if assemblies.kind_of?(Megam::Assemblies)
+      lookup_by = assemblies.name
+      elsif assemblies.kind_of?(String)
+      lookup_by = assemblies
       else
-        raise ArgumentError, "Must pass a Megam::Node or String to lookup"
+        raise ArgumentError, "Must pass a Megam::Assemblies or String to lookup"
       end
-      res = @nodes_by_name[lookup_by]
+      res = @assemblies_by_name[lookup_by]
       unless res
         raise ArgumentError, "Cannot find a node matching #{lookup_by} (did you define it first?)"
       end
-      @nodes[res]
+      @assemblies[res]
     end
-    
-     # Transform the ruby obj ->  to a Hash
+
+    # Transform the ruby obj ->  to a Hash
     def to_hash
       index_hash = Hash.new
-      self.each do |node|
-        index_hash[node.node_name] = node.to_s
+      self.each do |assemblies|
+        index_hash[assemblies.name] = assemblies.to_s
       end
       index_hash
     end
@@ -117,31 +116,13 @@ module Megam
       for_json.to_json(*a)
     end
 
-
-=begin
-["json_claz":"Megam::NodeCollection",{
-"id":"NOD362428315933343744",
-"accounts_id":"ACT362211963352121344",
-"json_claz":"Megam::Node",
-"request":{
-"req_id":"NOD362428315933343744",
-"command":"commands"
-},
-"predefs":{
-"name":"",
-"scm":"",
-"war":"",
-"db":"",
-"queue":""
-}
-}]
-=end
     def self.json_create(o)
       collection = self.new()
-      o["results"].each do |nodes_list|
-        nodes_array = nodes_list.kind_of?(Array) ? nodes_list : [ nodes_list ]
-        nodes_array.each do |node|
-          collection.insert(node)
+      o["results"].each do |assemblies_list|
+        assemblies_array = assemblies_list.kind_of?(Array) ? assemblies_list : [ assemblies_list ]
+        assemblies_array.each do |assemblies|
+          collection.insert(assemblies)
+
         end
       end
       collection
@@ -149,11 +130,9 @@ module Megam
 
     private
 
-    
-    
-    def is_megam_node(arg)
-      unless arg.kind_of?(Megam::Node)
-        raise ArgumentError, "Members must be Megam::Node's"
+    def is_megam_assemblies(arg)
+      unless arg.kind_of?(Megam::Assemblies)
+        raise ArgumentError, "Members must be Megam::Assemblies's"
       end
       true
     end

data/lib/megam/core/csar.rb

@@ -13,7 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require 'hashie'
 
 module Megam
   class CSAR < Megam::ServerAPI

data/lib/megam/core/domains.rb

@@ -0,0 +1,129 @@
+# Copyright:: Copyright (c) 2012-2013 Megam Systems, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Megam
+  class Domains < Megam::ServerAPI
+   def initialize(email=nil, api_key=nil)
+     @id = nil
+     @name = nil
+     @created_at = nil
+     super(email, api_key)
+   end
+
+
+def domain
+  self
+end
+
+def id(arg=nil)
+  if arg != nil
+    @id = arg
+  else
+  @id
+  end
+end
+
+
+
+def name(arg=nil)
+  if arg != nil
+     @name = arg
+  else
+    @name
+  end
+end
+
+
+
+def created_at(arg=nil)
+  if arg != nil
+    @created_at = arg
+  else
+  @created_at
+  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["name"] = name
+      index_hash["created_at"] = created_at
+      index_hash
+    end
+
+def to_json(*a)
+  for_json.to_json(*a)
+end
+
+def for_json
+  result = {
+    "id" => id,
+    "name" => name,
+    "created_at" => created_at
+  }
+  result
+end
+
+# Create a Megam::Domains from JSON (used by the backgroud job workers)
+def self.json_create(o)
+  dmn = new
+  dmn.id(o["id"]) if o.has_key?("id")
+  dmn.name(o["name"]) if o.has_key?("name")
+  dmn.created_at(o["created_at"]) if o.has_key?("created_at")
+  dmn
+end
+
+def self.from_hash(o)
+  dmn = self.new(o[:email], o[:api_key])
+  dmn.from_hash(o)
+  dmn
+end
+
+def from_hash(o)
+  @id        = o[:id] if o.has_key?(:id)
+  @name     = o[:name] if o.has_key?(:name)
+  @created_at = o[:created_at] if o.has_key?(:created_at)
+  self
+end
+
+def self.create(o)
+  dmn = from_hash(o)
+  dmn.create
+end
+
+# Load a Domain by email_p
+def self.show(email,api_key=nil)
+  dmn = self.new(email, api_key)
+  dmn.megam_rest.get_domains(email)
+end
+
+
+def create
+      megam_rest.post_domains(to_hash)
+end
+
+def to_s
+      Megam::Stuff.styled_hash(to_hash)
+    end
+
+
+  end
+
+end

data/lib/megam/core/json_compat.rb

@@ -37,6 +37,10 @@ module Megam
     MEGAM_BOLTDEFNSCOLLECTION     = "Megam::BoltDefnCollection".freeze
     MEGAM_REQUEST                 = "Megam::Request".freeze
     MEGAM_REQUESTCOLLECTION       = "Megam::RequestCollection".freeze
+    MEGAM_ORGANIZATION            = "Megam::Organizations".freeze
+    MEGAM_DOMAIN                  = "Megam::Domains".freeze
+    MEGAM_ASSEMBLIES              = "Megam::Assemblies".freeze
+    MEGAM_ASSEMBLIESCOLLECTION    = "Megam::AssembliesCollection".freeze
 
     MEGAM_PREDEF                  = "Megam::Predef".freeze
     MEGAM_PREDEFCOLLECTION        = "Megam::PredefCollection".freeze
@@ -59,9 +63,6 @@ module Megam
     MEGAM_MARKETPLACEADDONCOLLECTION   = "Megam::MarketPlaceAddonsCollection".freeze
     MEGAM_CSAR             = "Megam::CSAR".freeze
     MEGAM_CSARCOLLECTION   = "Megam::CSARCollection".freeze
-    
-
-
     class <<self
       # Increase the max nesting for JSON, which defaults
       # to 19, and isn't enough for some (for example, a Node within a Node)
@@ -77,6 +78,7 @@ module Megam
       # Just call the JSON gem's parse method with a modified :max_nesting field
       def from_json(source, opts = {})
         obj = ::Yajl::Parser.parse(source)
+
         # JSON gem requires top level object to be a Hash or Array (otherwise
         # you get the "must contain two octets" error). Yajl doesn't impose the
         # same limitation. For compatibility, we re-impose this condition.
@@ -98,16 +100,19 @@ module Megam
       # Look at an object that's a basic type (from json parse) and convert it
       # to an instance of Megam classes if desired.
       def map_to_rb_obj(json_obj)
+
         case json_obj
         when Hash
           mapped_hash = map_hash_to_rb_obj(json_obj)
+
           if json_obj.has_key?(JSON_CLAZ) && (class_to_inflate = class_for_json_class(json_obj[JSON_CLAZ]))
           class_to_inflate.json_create(mapped_hash)
+
           else
           mapped_hash
           end
         when Array
-          json_obj.map {|e| map_to_rb_obj(e) }
+          json_obj.map {|e| map_to_rb_obj(e)}
         else
         json_obj
         end
@@ -202,10 +207,18 @@ module Megam
           Megam::MarketPlaceAddons
         when MEGAM_MARKETPLACEADDONCOLLECTION
           Megam::MarketPlaceAddonsCollection
+        when MEGAM_ORGANIZATION
+          Megam::Organizations
         when MEGAM_CSAR
           Megam::CSAR
         when MEGAM_CSARCOLLECTION
           Megam::CSARCollection
+        when MEGAM_DOMAIN
+          Megam::Organizations
+        when MEGAM_ASSEMBLIES
+          Megam::Assemblies
+        when MEGAM_ASSEMBLIESCOLLECTION
+          Megam::AssembliesCollection
         else
         raise JSON::ParserError, "Unsupported `json_class` type '#{json_class}'"
         end

data/lib/megam/core/organizations.rb

@@ -0,0 +1,129 @@
+# Copyright:: Copyright (c) 2012-2013 Megam Systems, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Megam
+  class Organizations < Megam::ServerAPI
+   def initialize(email=nil, api_key=nil)
+     @id = nil
+     @name = nil
+     @created_at = nil
+     super(email, api_key)
+   end
+
+
+def organization
+  self
+end
+
+def id(arg=nil)
+  if arg != nil
+    @id = arg
+  else
+  @id
+  end
+end
+
+
+
+def name(arg=nil)
+  if arg != nil
+     @name = arg
+  else
+    @name
+  end
+end
+
+
+
+def created_at(arg=nil)
+  if arg != nil
+    @created_at = arg
+  else
+  @created_at
+  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["name"] = name
+      index_hash["created_at"] = created_at
+      index_hash
+    end
+
+def to_json(*a)
+  for_json.to_json(*a)
+end
+
+def for_json
+  result = {
+    "id" => id,
+    "name" => name,
+    "created_at" => created_at
+  }
+  result
+end
+
+# Create a Megam::Organization from JSON (used by the backgroud job workers)
+def self.json_create(o)
+  org = new
+  org.id(o["id"]) if o.has_key?("id")
+  org.name(o["name"]) if o.has_key?("name")
+  org.created_at(o["created_at"]) if o.has_key?("created_at")
+  org
+end
+
+def self.from_hash(o)
+  org = self.new(o[:email], o[:api_key])
+  org.from_hash(o)
+  org
+end
+
+def from_hash(o)
+  @id        = o[:id] if o.has_key?(:id)
+  @name     = o[:name] if o.has_key?(:name)
+  @created_at = o[:created_at] if o.has_key?(:created_at)
+  self
+end
+
+def self.create(o)
+  org = from_hash(o)
+  org.create
+end
+
+# Load a organization by email_p
+def self.show(email,api_key=nil)
+  org = self.new(email, api_key)
+  org.megam_rest.get_organizations(email)
+end
+
+
+def create
+      megam_rest.post_organizations(to_hash)
+end
+
+def to_s
+      Megam::Stuff.styled_hash(to_hash)
+    end
+
+
+  end
+
+end