diff --git a/src/cli/one_helper.rb b/src/cli/one_helper.rb
new file mode 100644
index 0000000000..9ba77d22d4
--- /dev/null
+++ b/src/cli/one_helper.rb
@@ -0,0 +1,218 @@
+require 'cli_helper'
+
+require 'OpenNebula'
+include OpenNebula
+
+module OpenNebulaHelper
+    XML={
+        :name  => "xml",
+        :short => "-x",
+        :large => "--xml",
+        :description => "Show the resource in xml format"
+    }
+    
+    class OneHelper        
+        def initialize
+            @client = OpenNebula::Client.new
+            @translation_hash = nil
+        end
+
+        def create_resource(template, options)
+            resource = factory
+
+            rc = resource.allocate(template)
+            if OpenNebula.is_error?(rc) 
+                return -1, rc.message 
+            else
+                puts "ID: #{resource.id.to_s}" if options[:verbose]
+                return 0
+            end
+        end
+        
+        def list_pool(options)
+            user_flag = options[:filter_flag] ? options[:filter_flag] : -2
+            pool = factory_pool(user_flag)
+
+            rc = pool.info
+            return -1, rc.message if OpenNebula.is_error?(rc)
+            
+            if options[:xml]
+                return 0, pool.to_xml(true)
+            else
+                generate_translation_hash
+                format_pool(pool, options)
+                return 0
+            end
+        end
+        
+        def show_resource(id, options)
+            resource = retrieve_resource(id)
+            return -1, resource.message if OpenNebula.is_error?(resource)
+            
+            if options[:xml]
+                return 0, resource.to_xml(true)
+            else
+                generate_translation_hash
+                format_resource(resource)
+                return 0
+            end
+        end
+        
+        def perform_action(id, args, options, verbose, &block)
+            resource = retrieve_resource(id)
+            return -1, resource.message if OpenNebula.is_error?(resource)
+
+            rc = block.call(resource)
+            if OpenNebula.is_error?(rc)
+                return -1, rc.message
+            else
+                rname=Object.const_get(self.class.name)::RESOURCE
+                puts "#{rname} #{id} #{verbose}" if options[:verbose]
+                return 0
+            end
+        end
+        
+        def perform_actions(ids,args,options,verbose,&block)
+            exit_code = 0
+            ids.each do |id|
+                rc = perform_action(id,args,options,verbose,&block)
+
+                unless rc[0]==0
+                    puts rc[1]
+                    exit_code=rc[0]
+                end
+            end
+
+            exit_code
+        end
+        
+        ########################################################################
+        # Formatters for arguments
+        ########################################################################
+        def to_id(name, pool=nil)
+            return 0, name if name.match(/^[0123456789]+$/)
+            
+            user_flag = -2
+            pool = pool ? pool : factory_pool(user_flag)
+            
+            rc = pool.info
+            return -1, rc.message if OpenNebula.is_error?(rc)
+            
+            objects=pool.select {|object| object.name==name }
+            
+            if objects.length>0
+                if objects.length>1
+                    rname=Object.const_get(self.class.name)::RESOURCE
+                    return -1, "There are multiple #{rname}s with name #{name}."
+                else
+                    result=objects.first.id
+                end
+            else
+                rname=Object.const_get(self.class.name)::RESOURCE
+                return -1,  "#{rname} named #{name} not found."
+            end
+            
+            return 0, result
+        end
+        
+        def list_to_id(names)
+            user_flag = -2
+            pool = factory_pool(user_flag)
+            
+            rc = pool.info
+            return -1, rc.message if OpenNebula.is_error?(rc)
+            
+            result = names.split(',').collect { |name|
+                rc = to_id(name)
+                unless rc.first==0
+                    return rc
+                end
+                rc[1]
+            }
+            
+            return 0, result
+        end
+        
+        def filterflag_to_i(str)
+            filter_flag = case str
+            when "a", "all" then "-2"
+            when "m", "mine" then "-3"
+            when "g", "group" then "-1"
+            else
+                if str.match(/^[0123456789]+$/)
+                    str
+                else
+                    generate_translation_hash
+                    user = @translation_hash[:users].select { |k,v| v==str }
+                    user.length > 0 ? user.first.first : "-2"
+                end
+            end
+            
+            return 0, filter_flag
+        end
+        
+        private
+        
+        def retrieve_resource(id)
+            resource = factory(id)
+    
+            rc = resource.info
+            OpenNebula.is_error?(rc) ? rc : resource
+        end
+        
+        def generate_translation_hash
+            @translation_hash ||= {
+                :users => generate_user_translation,
+                :groups => generate_group_translation
+            }
+
+        end
+        
+        def generate_user_translation
+            user_pool = UserPool.new(@client)
+            user_pool.info
+            
+            hash = Hash.new
+            user_pool.each { |user|
+                hash[user["ID"]]=user["NAME"]
+            }
+            hash
+        end
+        
+        
+        def generate_group_translation
+            group_pool = GroupPool.new(@client)
+            group_pool.info
+
+            hash = Hash.new
+            group_pool.each { |group|
+                hash[group["ID"]]=group["NAME"]
+            }
+            hash
+        end
+    end
+    
+    def OpenNebulaHelper.public_to_str(str)
+        if str.to_i == 1 
+            public_str = "Y" 
+        else 
+            public_str = "N" 
+        end
+    end
+    
+    def OpenNebulaHelper.uid_to_str(uid, hash={})
+        if hash[:users] && hash[:users][uid]
+            hash[:users][uid]
+        else
+            uid
+        end
+    end
+    
+    def OpenNebulaHelper.gid_to_str(gid, hash={})
+        if hash[:groups] && hash[:groups][gid]
+            hash[:groups][gid]
+        else
+            gid
+        end
+    end
+end
\ No newline at end of file
diff --git a/src/cli/one_helper/onevnet_helper.rb b/src/cli/one_helper/onevnet_helper.rb
new file mode 100644
index 0000000000..8908004882
--- /dev/null
+++ b/src/cli/one_helper/onevnet_helper.rb
@@ -0,0 +1,100 @@
+require 'one_helper'
+
+class OneVNetHelper < OpenNebulaHelper::OneHelper
+    RESOURCE = "VNET"
+    
+    def create_resource(template_file, options)
+        template=File.read(template_file)
+        super(template, options)
+    end
+    
+    private
+    
+    def factory(id=nil)
+        if id
+            OpenNebula::VirtualNetwork.new_with_id(id, @client)
+        else
+            xml=OpenNebula::VirtualNetwork.build_xml
+            OpenNebula::VirtualNetwork.new(xml, @client)
+        end
+    end
+    
+    def factory_pool(user_flag=-2)
+        OpenNebula::VirtualNetworkPool.new(@client, user_flag)
+    end
+    
+    def format_resource(vn)
+        str_h1="%-80s"
+        CLIHelper.print_header(str_h1 % ["VIRTUAL NETWORK #{vn.id.to_s} INFORMATION"])
+            
+        str="%-10s: %-20s"
+        puts str % ["ID: ", vn.id.to_s]
+        puts str % ["UID: ", vn["UID"]]
+        puts str % ["PUBLIC", OpenNebulaHelper.public_to_str(vn['PUBLIC'])]
+        puts
+        CLIHelper.print_header(str_h1 % ["VIRTUAL NETWORK TEMPLATE"], false)
+
+        puts vn.template_str(false)
+
+        leases_str = vn.template_like_str('/VNET/LEASES', false)
+
+        if !leases_str.empty?
+            puts
+            CLIHelper.print_header(str_h1 % ["LEASES INFORMATION"], false)
+            puts leases_str
+        end
+    end
+    
+    def format_pool(pool, options)
+        st=CLIHelper::ShowTable.new(nil, @translation_hash) do
+            column :ID, "ONE identifier for Virtual Network", :size=>4 do |d,e|
+                d["ID"]
+            end
+
+            column :NAME, "Name of the Virtual Network", :left, :size=>15 do |d,e|
+                d["NAME"]
+            end
+
+            column :USER, "Username of the Virtual Network owner", :left, :size=>8 do |d,e|
+                OpenNebulaHelper.uid_to_str(d["UID"],e)
+            end
+            
+            column :GROUP, "Group of the Virtual Network", :left, :size=>8 do |d,e|
+                OpenNebulaHelper.gid_to_str(d["GID"],e)
+            end
+            
+            column :TYPE, "Type of Virtual Network", :size=>6 do |d,e|
+                OneVNetHelper.type_to_str(d["TYPE"])
+            end
+            
+            column :SIZE, "Size of the Virtual Network", :size=>6 do |d,e|
+                d["SIZE"]
+            end
+            
+            column :BRIDGE, "Bridge associated to the Virtual Network", :size=>6 do |d,e|
+                d["BRIDGE"]
+            end
+            
+            column :PUBLIC, "Whether the Virtual Network is public or not", :size=>1 do |d,e|
+                OpenNebulaHelper.public_to_str(d['PUBLIC'])
+            end
+            
+            column :LEASES, "Number of this Virtual Network's given leases", :size=>7 do |d,e|
+                d["TOTAL_LEASES"]
+            end
+            
+            default :ID, :USER, :GROUP, :NAME, :TYPE, :BRIDGE, :PUBLIC, :LEASES
+        end
+
+        st.show(pool, options)
+    end
+    
+    # TBD move this method to VirtualNetwork.rb (OCA)
+    def self.type_to_str(type)
+        if type=="0"
+            return "Ranged"
+        elsif type=="1"
+            return "Fixed"
+        end
+    end
+end
\ No newline at end of file