enfcli 4.1.0.pre.beta → 5.0.1

data/lib/enfcli/commands/user.rb

@@ -1,5 +1,5 @@
 #
-# Copyright 2018 Xaptum,Inc
+# Copyright 2018-2020 Xaptum,Inc
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,170 +14,138 @@
 # limitations under the License.
 #
 require "enfthor"
-require "enfapi"
+require "enfapi/user"
 
 module EnfCli
   module Cmd
+    ##
+    # This class handles the commands that maniupulate users and roles
     class User < EnfThor
       no_commands {
         def display_invites(invites)
           headings = ["Id", "User Name", "Full Name", "Invited By", "Invite Code"]
           rows = invites.map { |hash|
-            [hash[:id], hash[:email], hash[:name], hash[:invited_by], hash[:invite_token]]
+            [hash[:id], hash[:email], hash[:name], hash[:created_by], hash[:invite_token]]
           }
 
           render_table(headings, rows)
         end
 
         def display_users(users)
-          headings = ["Id", "User Name", "Full Name", "Last Login", "Type", "Reset Code", "Reset Time", "Status"]
-          rows = users.map { |hash|
-            [hash[:user_id], hash[:username], hash[:full_name], hash[:last_login], hash[:type], hash[:reset_code],
-             format_date(hash[:reset_time]), hash[:status]]
-          }
+          headings = ["Id", "Name", "Username", "Domain", "Last Login", "Status"]
+          rows = []
+          users.each do |hash|
+            hash[:roles].each do |role|
+              rows.push [hash[:id],
+                         hash[:full_name],
+                         hash[:username],
+                         hash[:domain],
+                         hash[:last_login],
+                         hash[:status]]
+            end
+          end
           render_table(headings, rows)
         end
 
-        def send_invite(options, user_type)
-          # Get options
-          domain_network = options.domain
-
-          # get params
-          name = options[:'name'].join(" ").gsub(/\A"+(.*?)"+\Z/m, '\1')
-          email = options[:'email']
-
-          # call api
-          hash = { :email => email, :full_name => name, :welcome_text => "", :user_type => user_type }
-          data = EnfApi::API.instance.invite domain_network, hash
-          invite = data[:data]
-          display_invites invite
-        end
-      }
-
-      desc "invite-read-only-user", "Invite a domain user"
-      method_option :domain, :default => nil, :type => :string, :aliases => "-d"
-      method_option :'name', :type => :array, :required => true, :banner => "NAME"
-      method_option :'email', :type => :string, :required => true, :banner => "EMAIL"
+        # Display the roles as a table
+        def display_roles(roles)
+          headings = ["Cidr", "Role"]
 
-      def invite_read_only_user
-        try_with_rescue_in_session do
-          # use the domain network of the user
-          domain_network = EnfCli::CTX.instance.session[:domain_network]
-          raise EnfCli::ERROR, "User not in a valid domain!" unless domain_network
-
-          # Get user role
-          user_role = EnfCli::CTX.instance.session[:type]
-
-          # check user roles
-          if user_role == "XAPTUM_ADMIN"
-            raise "--domain is required" unless options[:domain]
-          else
-            say "Warning: Ignoring command option --domain #{options[:domain]}", :yellow if options[:domain]
-            options[:domain] = domain_network
+          rows = roles.map do |role|
+            [role[:cidr], role[:role]]
           end
 
-          send_invite options, "DOMAIN_USER"
+          render_table(headings, rows)
         end
-      end
-
-      desc "invite-domain-admin-user", "Invite a domain administrator"
-      method_option :domain, :default => nil, :type => :string, :aliases => "-d"
-      method_option :'name', :type => :array, :required => true, :banner => "NAME"
-      method_option :'email', :type => :string, :required => true, :banner => "EMAIL"
-
-      def invite_domain_admin_user
-        try_with_rescue_in_session do
-          # use the domain network of the user
-          domain_network = EnfCli::CTX.instance.session[:domain_network]
-          raise EnfCli::ERROR, "User not in a valid domain!" unless domain_network
-
-          # Get user role
-          user_role = EnfCli::CTX.instance.session[:type]
-
-          # check user roles
-          if user_role == "XAPTUM_ADMIN"
-            raise "--domain is required" unless options[:domain]
-          else
-            say "Warning: Ignoring command option --domain #{options[:domain]}", :yellow if options[:domain]
-            options[:domain] = domain_network
-          end
 
-          send_invite options, "DOMAIN_ADMIN"
+        def display_user_details(user)
+          display_users([user])
+          display_roles(user[:roles])
         end
-      end
-
-      desc "invite-enf-admin-user", "Invite an ENF administrator"
-      method_option :'name', :type => :array, :required => true, :banner => "NAME"
-      method_option :'email', :type => :string, :required => true, :banner => "EMAIL"
+      }
 
-      def invite_enf_admin_user
+      desc "send-invite",
+           "Send an invite to a new user or one with a modified role."
+      method_option :email, type: :string, required: true, banner: "EMAIL",
+                            desc: "Full email address of user to invite."
+      method_option :name, type: :array, required: true, banner: "NAME",
+                           desc: "Full name of user to invite."
+      method_option :domain, type: :string, default: nil, banner: "DOMAIN",
+                             aliases: "-d"
+      method_option :network, type: :string, default: nil, banner: "NETWORK",
+                              aliases: "-n"
+      method_option :role, type: :string, default: nil, banner: "ROLE",
+                           aliases: "-r"
+
+      def send_invite
         try_with_rescue_in_session do
-          # Get user role
-          user_role = EnfCli::CTX.instance.session[:type]
-
-          raise EnfCli::ERROR, "Only ENF Administrators can invite ENF Administrator" unless user_role == "XAPTUM_ADMIN"
+          # get params
+          name = options[:name].join(" ").gsub(/\A"+(.*?)"+\Z/m, '\1')
+          email = options[:email]
 
-          options[:domain] = EnfCli::CTX.instance.session[:domain_network]
-          send_invite options, "XAPTUM_ADMIN"
-        end
-      end
+          # get correct domain
+          domain = EnfCli::CTX.instance.session[:domain]
+          raise EnfCli::ERROR, "User not in a valid domain!" unless domain
 
-      desc "invite-iam-admin-user", "Invite an IAM administrator"
-      method_option :'name', :type => :array, :required => true, :banner => "NAME"
-      method_option :'email', :type => :string, :required => true, :banner => "EMAIL"
+          # check if admin
+          if EnfCli::CTX.instance.xaptum_admin?
+            raise EnfCli::ERROR, "--domain is required" unless options[:domain]
 
-      def invite_iam_admin_user
-        try_with_rescue_in_session do
-          # Get user role
-          user_role = EnfCli::CTX.instance.session[:type]
+            domain = options[:domain]
+          elsif options[:domain]
+            say "Warning: Ignoring command option --domain #{options[:domain]}", :yellow
+          end
 
-          raise EnfCli::ERROR, "Only ENF Administrators can invite IAM Administrator" unless user_role == "XAPTUM_ADMIN"
+          invite_hash = { email: email,
+                          full_name: name,
+                          domain: domain }
 
-          options[:domain] = EnfCli::CTX.instance.session[:domain_network]
-          send_invite options, "IAM_ADMIN"
-        end
-      end
+          role = options[:role]
+          role = role.upcase if role
+          network = options[:network]
 
-      desc "invite-captive-admin-user", "Invite a captive administrator"
-      method_option :'captive-domain', :type => :string, :required => true, :banner => "CAPTIVE CONTROL DOMAIN"
-      method_option :'name', :type => :array, :required => true, :banner => "NAME"
-      method_option :'email', :type => :string, :required => true, :banner => "EMAIL"
+          roles_hash = nil
 
-      def invite_captive_admin_user
-        try_with_rescue_in_session do
-          # Get user role
-          user_role = EnfCli::CTX.instance.session[:type]
+          case role
+          when "XAPTUM_ADMIN", "IAM_ADMIN"
+            roles_hash = [{ cidr: "::/0", role: role }]
+          when "DOMAIN_ADMIN", "DOMAIN_USER", "CAPTIVE_ADMIN"
+            roles_hash = [{ cidr: domain, role: role }]
+          when "NETWORK_ADMIN", "NETWORK_USER"
+            roles_hash = [{ cidr: network, role: role }]
+          end
 
-          raise EnfCli::ERROR, "Only ENF Administrators can invite CAPTIVE Administrator" unless user_role == "XAPTUM_ADMIN"
+          if roles_hash
+            invite_hash[:roles] = roles_hash
+          end
 
-          options[:domain] = options[:'captive-domain']
-          send_invite options, "CAPTIVE_ADMIN"
+          resp_data = EnfApi::UserManager.instance.invite invite_hash
+          invite = resp_data[:data]
+          display_invites invite
         end
       end
 
-      desc "cancel-user-invite", "Cancel an invite"
-      method_option :email, :type => :string, :required => true
+      desc "delete-invite", "Delete an invite"
+      method_option :id, type: :string, required: true
 
-      def cancel_user_invite
+      def delete_invite
         try_with_rescue_in_session do
+          id = options[:id]
           # call api
-          EnfApi::API.instance.cancel_invite options.email
-
-          # print success
-          say "Invite Canceled!", :green
+          EnfApi::UserManager.instance.delete_invite id
+          say "Invite: #{id} successfully deleted", :green
         end
       end
 
-      desc "resend-user-invite", "Resend an invite"
-      method_option :email, :type => :string, :required => true
+      desc "resend-invite", "Resend an invite"
+      method_option :id, type: :string, required: true
 
-      def resend_user_invite
+      def resend_invite
         try_with_rescue_in_session do
+          id = options[:id]
           # call api
-          EnfApi::API.instance.resend_invite options.email
-
-          # print success
-          say "Resent invite email!", :green
+          EnfApi::UserManager.instance.resend_invite id
+          say "Resent invite: #{id}!", :green
         end
       end
 
@@ -187,78 +155,155 @@ module EnfCli
       def list_invites
         try_with_rescue_in_session do
           # use the domain network of the user
-          domain_network = EnfCli::CTX.instance.session[:domain_network]
-          raise EnfCli::ERROR, "User not in a valid domain!" unless domain_network
-
-          # Get user role
-          user_role = EnfCli::CTX.instance.session[:type]
+          domain = nil
 
-          # check user roles
-          if user_role == "XAPTUM_ADMIN"
-            domain_network = options[:domain] if options[:domain]
-          else
-            say "Warning: Ignoring command option --domain #{options[:domain]}", :yellow if options[:domain]
+          # only XAPTUM_ADMIN can specify --domain (but doesn't have to)
+          if EnfCli::CTX.instance.xaptum_admin?
+            domain = options[:domain] if options[:domain]
+          elsif options[:domain]
+            say "Warning: Ignoring command option --domain #{options[:domain]}", :yellow
           end
 
           # call the api
-          data = EnfApi::API.instance.list_domain_invites domain_network
+          data = EnfApi::UserManager.instance.list_invites domain
           invites = data[:data]
 
           display_invites invites
         end
       end
 
-      desc "list-users", "List users"
-      method_option :domain, :default => nil, :type => :string, :aliases => "-d"
+      desc "get-user-details", "Get User Details"
+      method_option :email, required: true, type: :string, banner: "EMAIL",
+                            aliases: "-e"
 
-      def list_users
+      def get_user_details
         try_with_rescue_in_session do
-          # use the domain network of the user
-          domain_network = EnfCli::CTX.instance.session[:domain_network]
-          raise EnfCli::ERROR, "User not in a valid domain!" unless domain_network
+          # call the api
+          data = EnfApi::UserManager.instance.get_user options[:email]
+          user = data[:data][0]
+
+          display_user_details user
+        end
+      end
 
-          # Get user role
-          user_role = EnfCli::CTX.instance.session[:type]
+      desc "list-users", "List users"
+      method_option :domain, default: nil, type: :string, banner: "DOMAIN",
+                             aliases: "-d"
+      method_option :network, default: nil, type: :string, banner: "NETWORK",
+                              aliases: "-n"
 
-          # check user roles
-          if user_role == "XAPTUM_ADMIN"
-            domain_network = options[:domain] if options[:domain]
-          else
-            say "Warning: Ignoring command option -d #{options[:domain]}", :yellow if options[:domain]
+      def list_users
+        try_with_rescue_in_session do
+          domain = options[:domain]
+          network = options[:network]
+
+          ## initalize query param
+          query_param = ""
+          if domain
+            query_param = "?domain=#{domain}"
+          elsif network
+            query_param = "?network=#{network}"
           end
 
           # call the api
-          data = EnfApi::API.instance.list_domain_users domain_network
+          data = EnfApi::UserManager.instance.list_users query_param
           users = data[:data]
 
           display_users users
         end
       end
 
+      desc "list-user-roles", "List user roles"
+      method_option :email, type: :string, required: true, banner: "EMAIL"
+      method_option :network, default: nil, type: :string, banner: "NETWORK",
+                              aliases: "-n"
+
+      def list_user_roles
+        try_with_rescue_in_session do
+          # call api
+          data = EnfApi::UserManager.instance.list_user_roles options[:email], options[:network]
+          roles = data[:data]
+
+          # print roles
+          display_roles roles
+        end
+      end
+
+      desc "delete-user-roles", "Remove a user's roles"
+      method_option :email, type: :string, required: true, banner: "EMAIL"
+      method_option :network, default: nil, type: :string, banner: "NETWORK",
+                              aliases: "-n",
+                              desc: 'Can be a /64 cidr or "ALL"'
+      method_option :roles, type: :string, required: true, banner: "ROLES",
+                            aliases: "-r",
+                            desc: "Can be a valid DOMAIN or NETWORK role. " \
+                                  "Can take '*' wildcards."
+
+      def delete_user_roles
+        try_with_rescue_in_session do
+          user_id = options[:email]
+          roles = options[:roles]
+          roles = roles.upcase if roles
+          network = options[:network]
+
+          if roles[0..6] == "NETWORK" && !network
+            raise EnfCli::ERROR, "--network option must be included for --roles=#{roles}"
+          end
+
+          EnfApi::UserManager.instance.delete_user_roles user_id, roles, network
+          say "Role: #{roles} successfully removed from user: #{user_id}", :green
+        end
+      end
+
       desc "deactivate-user", "Deactivate User"
-      method_option :user_id, :required => true, :type => :numeric
+      method_option :email, required: true, type: :string, banner: "EMAIL"
 
       def deactivate_user
         try_with_rescue_in_session do
-
           ## call the api
-          status = { :status => "INACTIVE" }
-          EnfApi::API.instance.update_user_status options[:user_id], status
+          status = { status: "INACTIVE" }
+          EnfApi::UserManager.instance.update_user_status options[:email], status
 
           say "Deactivated user!", :green
         end
       end
 
+      desc "add-user-role", "Add a new role to the specified rule."
+      method_option :email, type: :string, required: true, banner: "EMAIL"
+      method_option :cidr, type: :string, required: true, banner: "CIDR",
+                           desc: "Can be a /64 cidr for NETWORK user or " \
+                           "/48 cidr for DOMAIN user."
+      method_option :role, type: :string, required: true, banner: "ROLE",
+                           aliases: "-r",
+                           desc: "Can be a valid DOMAIN or NETWORK role. ",
+                           enum: ["XAPTUM_ADMIN", "DOMAIN_ADMIN", "DOMAIN_USER", "NETWORK_ADMIN", "NETWORK_USER", "CAPTIVE_ADMIN", "IAM_ADMIN"]
+
+      def add_user_role
+        try_with_rescue_in_session do
+          ## get options
+          email = options[:email]
+          role = options[:role]
+          role = role.upcase if role
+          cidr = EnfCli::IPV6Cidr.new(options[:cidr]).to_s
+
+          ## call api
+          role_hash = [{ cidr: cidr, role: role }]
+          resp = EnfApi::UserManager.instance.add_user_role email, role_hash
+          resp_roles = resp[:data]
+
+          ## display response
+          display_roles resp_roles
+        end
+      end
+
       desc "activate-user", "Activate User"
-      method_option :user_id, :required => true, :type => :numeric
+      method_option :email, required: true, type: :string, banner: "EMAIL"
 
       def activate_user
         try_with_rescue_in_session do
-
           ## call the api
-          status = { :status => "ACTIVE" }
-          EnfApi::API.instance.update_user_status options[:user_id], status
-
+          status = { status: "ACTIVE" }
+          EnfApi::UserManager.instance.update_user_status options[:email], status
           say "Activated user!", :green
         end
       end

data/lib/enfcli/commands/xcr.rb

@@ -1,5 +1,5 @@
 #
-# Copyright 2018 Xaptum,Inc
+# Copyright 2018-2020 Xaptum,Inc
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -26,8 +26,8 @@ module EnfCli
             [hash[:ipv6],
              hash[:name],
              hash[:state],
-             hash[:state] == "OFFLINE" ? "" : hash[:ev_asn_org],
-             hash[:state] == "OFFLINE" ? "" : hash[:ev_remote_ip]]
+             hash[:state] == "OFFLINE" ? "" : hash[:last_event][:asn_org],
+             hash[:state] == "OFFLINE" ? "" : hash[:last_event][:remote_ip]]
           }
           render_table(headings, rows, options.file)
         end
@@ -41,23 +41,23 @@ module EnfCli
         end
 
         def display_domains(domains)
-          headings = ["Name", "Network", "Status"]
+          headings = ["Name", "Cidr", "Status"]
           rows = domains.map { |hash|
-            [hash[:name], hash[:network], hash[:status]]
+            [hash[:name], hash[:cidr], hash[:status]]
           }
           render_table(headings, rows)
         end
 
         def display_networks(networks)
-          headings = ["Name", "Network", "Description", "Status"]
+          headings = ["Name", "Cidr", "Description", "Status"]
           rows = networks.map { |hash|
-            [hash[:name], hash[:network], hash[:description], hash[:status]]
+            [hash[:name], hash[:cidr], hash[:description], hash[:status]]
           }
           render_table(headings, rows)
         end
 
         def display_network(network)
-          network_cidr = network[:network]
+          network_cidr = network[:cidr]
           name = network[:name] || ""
           description = network[:description] || ""
           status = network[:status] || ""
@@ -104,13 +104,26 @@ module EnfCli
       }
 
       desc "list-networks", "List all virtual networks in domain"
+      method_option :domain, type: :string, default: nil, banner: "/48 CIDR",
+                             aliases: "-d"
 
       def list_networks
         try_with_rescue_in_session do
-          domain_id = EnfCli::CTX.instance.session[:domain_id]
+          # get correct domain
+          domain = EnfCli::CTX.instance.session[:domain]
+          raise EnfCli::ERROR, "User not in a valid domain!" unless domain
+
+          # check if admin
+          if EnfCli::CTX.instance.xaptum_admin?
+            raise EnfCli::ERROR, "--domain is required" unless options[:domain]
+
+            domain = options[:domain]
+          elsif options[:domain]
+            say "Warning: Ignoring command option --domain #{options[:domain]}", :yellow
+          end
 
           # Call the api
-          data = EnfApi::API.instance.list_domain_nws domain_id
+          data = EnfApi::API.instance.list_domain_nws domain
           networks = data[:data]
 
           # display table
@@ -120,13 +133,24 @@ module EnfCli
 
       desc "provision-network", "Provision a Network"
       method_option :name, :type => :array, :required => true, :banner => "NAME"
+      method_option :domain, type: :string, default: nil, banner: "/48 CIDR",
+                             aliases: "-d"
       method_option :description, :type => :array, :banner => "DESCRIPTION"
 
       def provision_network
         try_with_rescue_in_session do
-          # verify domain context is set
-          domain_id = EnfCli::CTX.instance.session[:domain_id]
-          raise EnfCli::ERROR, "User's domain not available!" if !domain_id || domain_id < 0
+          # get correct domain
+          domain = EnfCli::CTX.instance.session[:domain]
+          raise EnfCli::ERROR, "User not in a valid domain!" unless domain
+
+          # check if admin
+          if EnfCli::CTX.instance.xaptum_admin?
+            raise EnfCli::ERROR, "--domain is required" unless options[:domain]
+
+            domain = options[:domain]
+          elsif options[:domain]
+            say "Warning: Ignoring command option --domain #{options[:domain]}", :yellow
+          end
 
           # Get options
           description = ""
@@ -136,10 +160,9 @@ module EnfCli
           # Call the api
           hash = {
             :name => network_name,
-            :domain_id => domain_id,
             :description => description,
           }
-          data = EnfApi::API.instance.create_nw hash
+          data = EnfApi::API.instance.create_nw domain, hash
           networks = data[:data]
 
           # display table
@@ -211,10 +234,10 @@ module EnfCli
 
           # call api
           data = { :data => [] }
-          case session[:type]
-          when "XAPTUM_ADMIN"
+
+          if EnfCli::CTX.instance.xaptum_admin?
             data = EnfApi::API.instance.list_domains
-          when "DOMAIN_ADMIN"
+          elsif EnfCli::CTX.instance.has_role?("DOMAIN_ADMIN")
             data = EnfApi::API.instance.get_domain session[:domain_id]
           end
 
@@ -252,13 +275,13 @@ module EnfCli
       end
 
       desc "list-domain-rate-limits", "List domain rate limits"
-      method_option :network, :type => :string, :required => true, :banner => "</48 Network>"
+      method_option :domain, :type => :string, :required => true, :banner => "/48 CIDR"
       method_option :filter, :type => :string, :enum => ["default", "max"]
 
       def list_domain_rate_limits
         try_with_rescue_in_session do
           # Call the api
-          data = EnfApi::API.instance.get_domain_rate_limits options[:network], options[:filter]
+          data = EnfApi::API.instance.get_domain_rate_limits options[:domain], options[:filter]
 
           # Get the limits
           limits = data[:data][0]
@@ -274,7 +297,7 @@ module EnfCli
       end
 
       desc "list-network-rate-limits", "List network rate limits"
-      method_option :network, :type => :string, :required => true
+      method_option :network, :type => :string, :required => true, :banner => "/64 CIDR"
       method_option :filter, :type => :string, :enum => ["default", "max"]
 
       def list_network_rate_limits
@@ -318,12 +341,12 @@ module EnfCli
       end
 
       desc "activate-domain", "Activate a customer's /48 domain"
-      method_option :network, :type => :string, :required => true
+      method_option :domain, :type => :string, :required => true, banner: "/48 CIDR"
 
       def activate_domain
         try_with_rescue_in_session do
           # Call api
-          data = EnfApi::API.instance.update_domain_status options[:network], { :status => "ACTIVE" }
+          data = EnfApi::API.instance.update_domain_status options[:domain], { :status => "ACTIVE" }
           domains = data[:data]
 
           # Display the data
@@ -333,12 +356,12 @@ module EnfCli
       end
 
       desc "deactivate-domain", "Deactivate a customer's /48 domain"
-      method_option :network, :type => :string, :required => true
+      method_option :domain, :type => :string, :required => true, banner: "/48 CIDR"
 
       def deactivate_domain
         try_with_rescue_in_session do
           # Call api
-          data = EnfApi::API.instance.update_domain_status options[:network], { :status => "READY" }
+          data = EnfApi::API.instance.update_domain_status options[:domain], { :status => "READY" }
           domains = data[:data]
 
           # Display the data
@@ -348,12 +371,12 @@ module EnfCli
       end
 
       desc "set-domain-rate-limits", "Update a customer /48 domain's endpoint rate limits"
-      method_option :network, :type => :string, :required => true
+      method_option :domain, :type => :string, :required => true, banner: "/48 CIDR"
       method_option :limit, :type => :string, :enum => ["default", "max"], :required => true
-      method_option :'packets-per-second', :type => :numeric, :required => true
-      method_option :'packets-burst-size', :type => :numeric, :required => true
-      method_option :'bytes-per-second', :type => :numeric, :required => true
-      method_option :'bytes-burst-size', :type => :numeric, :required => true
+      method_option :'packets-per-second', :type => :numeric, :required => true, aliases: "-p"
+      method_option :'packets-burst-size', :type => :numeric, :required => true, aliases: "-P"
+      method_option :'bytes-per-second', :type => :numeric, :required => true, aliases: "-b"
+      method_option :'bytes-burst-size', :type => :numeric, :required => true, aliases: "-B"
 
       def set_domain_rate_limits
         try_with_rescue_in_session do
@@ -364,7 +387,7 @@ module EnfCli
             :bytes_per_second => options["bytes-per-second"],
             :bytes_burst_size => options["bytes-burst-size"],
           }
-          data = EnfApi::API.instance.update_domain_rate_limits options[:network], options[:limit], hash
+          data = EnfApi::API.instance.update_domain_rate_limits options[:domain], options[:limit], hash
           limits = data[:data][0]
 
           # The Api returns only the rate limits object. Have to add type explicitly to display
@@ -378,10 +401,10 @@ module EnfCli
       desc "set-network-rate-limits", "Update a customer /64 network's endpoint rate limits"
       method_option :network, :type => :string, :required => true
       method_option :limit, :type => :string, :enum => ["default", "max"], :required => true
-      method_option :'packets-per-second', :type => :numeric, :required => true
-      method_option :'packets-burst-size', :type => :numeric, :required => true
-      method_option :'bytes-per-second', :type => :numeric, :required => true
-      method_option :'bytes-burst-size', :type => :numeric, :required => true
+      method_option :'packets-per-second', :type => :numeric, :required => true, aliases: "-p"
+      method_option :'packets-burst-size', :type => :numeric, :required => true, aliases: "-P"
+      method_option :'bytes-per-second', :type => :numeric, :required => true, aliases: "-b"
+      method_option :'bytes-burst-size', :type => :numeric, :required => true, aliases: "-B"
 
       def set_network_rate_limits
         try_with_rescue_in_session do
@@ -427,10 +450,10 @@ module EnfCli
       desc "set-endpoint-rate-limits", "Update an ipv6 endpoint rate limits"
       method_option :ipv6, :type => :string, :required => true
       method_option :limit, :type => :string, :enum => ["current", "max"], :required => true
-      method_option :'packets-per-second', :type => :numeric, :required => true
-      method_option :'packets-burst-size', :type => :numeric, :required => true
-      method_option :'bytes-per-second', :type => :numeric, :required => true
-      method_option :'bytes-burst-size', :type => :numeric, :required => true
+      method_option :'packets-per-second', :type => :numeric, :required => true, aliases: "-p"
+      method_option :'packets-burst-size', :type => :numeric, :required => true, aliases: "-P"
+      method_option :'bytes-per-second', :type => :numeric, :required => true, aliases: "-b"
+      method_option :'bytes-burst-size', :type => :numeric, :required => true, aliases: "-B"
 
       def set_endpoint_rate_limits
         try_with_rescue_in_session do
@@ -474,17 +497,13 @@ module EnfCli
       end
 
       desc "list-endpoints", "List all connections in a network"
-      method_option :network, :type => :string, :required => true
+      method_option :network, :type => :string, :required => true, banner: "/48 CIDR"
       method_option :file, :type => :string, :aliases => "-f"
 
       def list_endpoints
         try_with_rescue_in_session do
-          # verify domain context is set
-          domain_id = EnfCli::CTX.instance.session[:domain_id]
-          raise EnfCli::ERROR, "User's domain not available!" if !domain_id || domain_id < 0
-
           # call api
-          data = EnfApi::API.instance.list_nw_connections domain_id, options.network, options.file
+          data = EnfApi::API.instance.list_nw_connections options.network
           cxns = data[:data]
 
           # display table
@@ -550,15 +569,15 @@ module EnfCli
       end
 
       desc "activate-enf-network", "Active a /34 enf network"
-      method_option :network, :type => :string, :required => true
+      method_option :cidr, :type => :string, :required => true
 
       def activate_enfnw
         try_with_rescue_in_session do
           # Call the api
-          EnfApi::API.instance.activate_enfnw options.network
+          EnfApi::API.instance.activate_enfnw options.cidr
 
           # Print success
-          say "Activated Enf Network #{options.network}!", :green
+          say "Activated Enf Network #{options.cidr}!", :green
         end
       end
     end # class