iugusdk 1.0.0.alpha.1 → 1.0.0.alpha.2

data/app/controllers/iugu/account_controller.rb

@@ -1,4 +1,7 @@
 class Iugu::AccountController < Iugu::AccountSettingsController
+
+  before_filter(:only => [:destroy, :cancel_destruction, :update]) { |c| c.must_be :owner, :id }
+  before_filter(:only => [:generate_new_token]) { |c| c.must_be :owner, :account_id }
   
   def index
     render 'iugu/settings/accounts'
@@ -8,51 +11,33 @@ class Iugu::AccountController < Iugu::AccountSettingsController
     if params[:id]
       @account = current_user.accounts.find(params[:id])
     else
-      @account = current_user_account
+      @account = current_user_account.account
     end
     @primary_domain = @account.account_domains.where(:primary => true).first if @account
     render 'iugu/settings/account'
   end
 
   def destroy
-    begin
-      if account = current_user.accounts.find(params[:id])
-        if account.account_users.find_by_user_id(current_user.id).is?(:owner)
-          account.destroy
-          notice = I18n.t("iugu.account_destruction_in") + account.destruction_job.run_at.to_s
-        else
-          notice = I18n.t("errors.messages.only_owners_can_destroy_accounts")
-        end
-      end
-    rescue
-      notice = I18n.t("iugu.notices.account_not_found")
-    end
-    redirect_to(account_settings_path, :notice => notice)
+    account = current_user.accounts.find(params[:id])
+    account.destroy
+    redirect_to(account_settings_path, :notice => I18n.t("iugu.account_destruction_in") + account.destruction_job.run_at.to_s)
   end
 
   def cancel_destruction
-    begin
-      current_user.accounts.find(params[:id]).cancel_destruction if params[:id]
-      notice = I18n.t("iugu.account_destruction_undone")
-    rescue
-      notice = I18n.t("iugu.notices.account_not_found")
-    end
+    current_user.accounts.find(params[:id]).cancel_destruction
+    notice = I18n.t("iugu.account_destruction_undone")
     redirect_to(account_settings_path, :notice => notice)
   end
 
   def select
-    select_account(current_user, params[:id])
+    set_account(current_user, params[:id])
     redirect_to(account_settings_path, :notice => "Account selected")
   end
 
   def update
-    begin
-      @account = Account.find(params[:id])
-      @account.update_attributes(params[:account])
-      redirect_to account_view_path(params[:id]), :notice => I18n.t("iugu.notices.account_updated")
-    rescue
-      raise ActionController::RoutingError.new('Not Found')
-    end
+    @account = Account.find(params[:id])
+    @account.update_attributes(params[:account])
+    redirect_to account_view_path(params[:id]), :notice => I18n.t("iugu.notices.account_updated")
   end
 
   def create
@@ -60,4 +45,15 @@ class Iugu::AccountController < Iugu::AccountSettingsController
     redirect_to account_settings_path
   end
 
+  def generate_new_token
+    if IuguSDK::enable_account_api_token == true
+      @account = current_user.accounts.find(params[:account_id])
+      @account.update_api_token
+      redirect_to account_view_path(params[:account_id]), :notice => I18n.t("iugu.notices.new_token_generated")
+    else
+      raise ActionController::RoutingError.new('Not found')
+    end
+
+  end
+
 end

data/app/controllers/iugu/account_domains_controller.rb

@@ -1,16 +1,25 @@
 class Iugu::AccountDomainsController < Iugu::AccountSettingsController
 
+  before_filter :custom_domain_enabled?, :except => [:update_subdomain, :index]
+
+  before_filter(:only => [:index, :create, :destroy, :instruction, :verify, :primary, :update_subdomain]) { |c| c.must_be [:owner, :admin], :account_id }
+
   def index
-    @account = current_user.accounts.find(params[:account_id])
-    @account_domains = @account.account_domains.where(:account_id => params[:account_id])
-    @account_domain = AccountDomain.new
+    unless IuguSDK::enable_custom_domain == false && IuguSDK::enable_subdomain == false
+      @account = current_user.accounts.find(params[:account_id])
+      @account_domains = @account.account_domains.where(:account_id => params[:account_id])
+      @account_domain = AccountDomain.new
+    else
+      raise ActionController::RoutingError.new("Not found")
+    end
   end
 
   def create
     @account = current_user.accounts.find(params[:account_id])
-    if @account.account_domains << @domain = AccountDomain.create(params[:account_domain])
-      redirect_to account_domains_instructions_path(:account_id => params[:account_id], :domain_id => @domain.id)#, :notice => notice = I18n.t("iugu.notices.domain_created")
+    if @account.account_domains << @account_domain = AccountDomain.create(params[:account_domain])
+      redirect_to account_domains_instructions_path(:account_id => params[:account_id], :domain_id => @account_domain.id)#, :notice => notice = I18n.t("iugu.notices.domain_created")
     else
+      @account_domains = @account.account_domains.where(:account_id => params[:account_id])
       render :index
     end
   end
@@ -60,5 +69,26 @@ class Iugu::AccountDomainsController < Iugu::AccountSettingsController
       redirect_to account_domains_index_path(params[:account_id]), :notice => I18n.t("iugu.notices.domain_not_found")
     end
   end
+
+  def update_subdomain
+    if IuguSDK::enable_subdomain == true
+      @account = current_user.accounts.find(params[:account_id])
+      if @account.update_attributes(params[:account])
+        redirect_to account_domains_index_path(@account.id), :notice => I18n.t("iugu.notices.subdomain_updated")
+      else
+        @account_domains = @account.account_domains.where(:account_id => params[:account_id])
+        @account_domain = AccountDomain.new
+        render :index
+      end
+    else
+      raise ActionController::RoutingError.new('Not found')
+    end
+  end
+
+  private
+
+  def custom_domain_enabled?
+    raise ActionController::RoutingError.new('Not found') if IuguSDK::enable_custom_domain == false
+  end
   
 end

data/app/controllers/iugu/account_roles_controller.rb

@@ -1,13 +1,10 @@
 class Iugu::AccountRolesController < Iugu::SettingsController
 
+  before_filter(:only => [:edit, :update]) { |c| c.must_be [:owner, :admin], :id }
+
   def edit
     @account = current_user.accounts.find(params[:id])
     @account_user = @account.account_users.find_by_user_id(params[:user_id])
-    if current_user.is?(:owner, @account) || current_user.is?(:admin, @account)
-      render 'iugu/account_roles/edit'
-    else
-      render :file => "#{Rails.root}/public/422.html", :status => 550
-    end
   end
 
   def update

data/app/controllers/iugu/account_users_controller.rb

@@ -1,5 +1,7 @@
 class Iugu::AccountUsersController < Iugu::AccountSettingsController
 
+  before_filter(:only => [:destroy, :cancel_destruction]) { |c| c.must_be [:owner, :admin], :account_id }
+
   def index
     @account = Account.find(params[:account_id])
     @account_users = @account.account_users
@@ -17,24 +19,16 @@ class Iugu::AccountUsersController < Iugu::AccountSettingsController
     else
       raise ActionController::RoutingError.new('Not Found')
     end
-    if current_user.is?(:owner, @account) || current_user.is?(:owner, @account)
-      raise ActionController::RoutingError.new('Access Denied') if @account_user.user_id == current_user.id || @account_user.is?(:owner)
-      @account_user.destroy
-    else
-      raise ActionController::RoutingError.new('Access Denied')
-    end
+    raise ActionController::RoutingError.new('Access Denied') if @account_user.user_id == current_user.id || @account_user.is?(:owner)
+    @account_user.destroy
     redirect_to account_users_index_path(params[:account_id]), :notice => I18n.t("iugu.account_user_destruction_in") + @account_user.destruction_job.run_at.to_s
   end
 
   def cancel_destruction
     if @account_user = AccountUser.find_by_account_id_and_user_id(params[:account_id], params[:user_id])
       @account = Account.find(params[:account_id])
-      if current_user.is?(:owner, @account) || current_user.is?(:owner, @account) 
-        @account_user.cancel_destruction
-        redirect_to account_users_index_path(params[:account_id]), :notice => I18n.t("iugu.account_user_destruction_undone")
-      else
-        raise ActionController::RoutingError.new('Access Denied')
-      end
+      @account_user.cancel_destruction
+      redirect_to account_users_index_path(params[:account_id]), :notice => I18n.t("iugu.account_user_destruction_undone")
     else
       raise ActionController::RoutingError.new('Not Found')
     end

data/app/controllers/iugu/confirmations_controller.rb

@@ -1,2 +1,3 @@
 class Iugu::ConfirmationsController < Devise::ConfirmationsController
+  after_filter :select_account, :only => :show
 end

data/app/controllers/iugu/invitations_controller.rb

@@ -1,18 +1,23 @@
 class Iugu::InvitationsController < Iugu::SettingsController
-  before_filter :check_permissions
+
+  before_filter(:only => [:new, :create]) { |c| c.must_be [:owner, :admin], :account_id } 
 
   def new
     @user_invitation = UserInvitation.new
-    @account_id = params[:account_id]
+    @account = Account.find(params[:account_id])
   end
 
   def create
     params[:user_invitation][:roles] = params[:user_invitation][:roles].try(:join, ',')
-    @user_invitation = UserInvitation.new(params[:user_invitation])
-    @user_invitation.invited_by = current_user.id
-    @user_invitation.account_id = params[:account_id]
-    @user_invitation.save
-    redirect_to account_users_index_path(params[:account_id]), :notice => I18n.t("iugu.notices.user_invited")
+    params[:user_invitation][:account_id] = params[:account_id]
+    params[:user_invitation][:invited_by] = current_user.id
+    @user_invitation = UserInvitation.create(params[:user_invitation])
+    unless @user_invitation.new_record?
+      redirect_to account_users_index_path(params[:account_id]), :notice => I18n.t("iugu.notices.user_invited")
+    else
+      @account = Account.find(params[:account_id])
+      render :new
+    end
   end
 
   def edit
@@ -25,25 +30,14 @@ class Iugu::InvitationsController < Iugu::SettingsController
 
   def update
     if @user_invitation = UserInvitation.find_by_invitation_token(params[:invitation_token])
-      @user_invitation.accept(current_user)
-      redirect_to root_path
+      if @user_invitation.accept(current_user)
+        redirect_to root_path
+      else
+        redirect_to root_path, :notice => I18n.t("iugu.notices.you_are_already_member_of_this_account")
+      end
     else
       raise ActionController::RoutingError.new('Not Found')
     end
   end
 
-
-  private
-
-  def check_permissions
-    if params[:account_id]
-      begin
-        account = current_user.accounts.find(params[:account_id])
-      rescue
-        raise ActionController::RoutingError.new('Access denied')
-      end
-      raise ActionController::RoutingError.new('Access denied') unless current_user.is?(:owner, account) || current_user.is?(:admin, account)
-    end
-  end
-
 end

data/app/controllers/iugu/omniauth_callbacks_controller.rb

@@ -3,12 +3,14 @@ class Iugu::OmniauthCallbacksController < Devise::OmniauthCallbacksController
   def method_missing(provider)
     if !User.omniauth_providers.index(provider).nil?
       if current_user 
+        raise ActionController::RoutingError.new("Not found") unless IuguSDK::enable_social_linking
         current_user.find_or_create_social(env["omniauth.auth"])
         redirect_to after_sign_in_path_for( current_user )
       else
+        raise ActionController::RoutingError.new("Not found") unless IuguSDK::enable_social_login
         if user = User.find_or_create_by_social(env["omniauth.auth"])
-          select_account user
           sign_in user
+          select_account
           redirect_to after_sign_in_path_for( user )
         else
           redirect_to (env["omniauth.origin"] || root_path), :notice => I18n.t('errors.messages.email_already_in_use')

data/app/controllers/iugu/passwords_controller.rb

@@ -1,2 +1,3 @@
 class Iugu::PasswordsController < Devise::PasswordsController
+  after_filter :select_account, :only => :update
 end

data/app/controllers/iugu/registrations_controller.rb

@@ -1,3 +1,14 @@
 class Iugu::RegistrationsController < Devise::RegistrationsController
+  after_filter :select_account, :only => [:create,:update]
+
+  def try_first
+    @user = User.create_guest
+    @user.remember_me = true
+    sign_in @user
+    select_account
+    flash[:notice] = I18n.t("iugu.notices.guest_login")
+    redirect_to root_path
+    #respond_with @user, :location => sign_up_path_for(@user)
+  end
 end
 

data/app/controllers/iugu/sessions_controller.rb

@@ -1,2 +1,3 @@
 class Iugu::SessionsController < Devise::SessionsController
+  after_filter :select_account, :only => :create 
 end

data/app/controllers/iugu/settings_controller.rb

@@ -8,4 +8,18 @@ class Iugu::SettingsController < ApplicationController
     redirect_to :profile_settings, :notice => flash[:notice]
   end
 
+  def must_be (roles, param_name)
+    access = false
+    @account_user = AccountUser.find_by_user_id_and_account_id(current_user.id, params[param_name])
+    raise ActionController::RoutingError.new("Not Found") unless @account_user
+    if roles.class == Array
+      roles.each do |role|
+        access = true if @account_user.is?(role)
+      end
+    else
+      access = true if @account_user.is?(roles)
+    end
+    raise ActionController::RoutingError.new("Access Denied") if access == false
+  end
+
 end

data/app/mailers/iugu_mailer.rb

@@ -1,7 +1,7 @@
 class IuguMailer < Devise::Mailer
 
-  default from: "Kupz <equipe@kupz.com.br>",
-          reply_to: "Kupz <atendimento@kupz.com.br>"
+  default from: "Iugu <equipe@iugu.com.br>",
+          reply_to: "Iugu <atendimento@iugu.com.br>"
 
   def template_paths
     "iugu/mailer"

data/app/models/account.rb

@@ -8,8 +8,11 @@ class Account < ActiveRecord::Base
                         :run_at => Proc.new { DateTime.now + IuguSDK::delay_account_exclusion }
 
   validates :subdomain, :uniqueness => true, :unless => Proc.new { |a| a.subdomain.blank? }
+  validates :api_token, :uniqueness => true, :if => :api_token?
   validate :subdomain_blacklist
 
+  before_create :set_first_token
+
   def self.get_from_domain(domain)
     AccountDomain.verified.find_by_url(domain).try(:account) || Account.find_by_subdomain(domain.gsub(".#{IuguSDK::application_main_host}",""))
   end
@@ -39,9 +42,21 @@ class Account < ActiveRecord::Base
   def name
     (super.blank? ? "#{I18n.t('iugu.account')} ##{id}" : super)
   end
+  
+  def update_api_token
+    self.update_attribute(:api_token, generate_api_token)
+  end
 
   private
 
+  def set_first_token
+    self.api_token = generate_api_token
+  end
+
+  def generate_api_token
+    Digest::MD5.hexdigest("#{SecureRandom.hex(10)}-#{DateTime.now.to_s}")
+  end
+
   def subdomain_blacklist
     if subdomain
       IuguSDK::custom_domain_invalid_prefixes.each do |invalid_prefix|

data/app/models/account_domain.rb

@@ -5,6 +5,11 @@ class AccountDomain < ActiveRecord::Base
   validates :url, :account_id, :presence => true
   validate :validate_pattern, :validate_blacklist
 
+  before_create :validate_not_repeated
+
+  before_destroy { |record| record.update_attributes(:verified => false, :primary => false) }
+  before_destroy :set_first_domain
+
   scope :verified, where(:verified => true)
 
   def normalize_host
@@ -41,12 +46,15 @@ class AccountDomain < ActiveRecord::Base
     end
     AccountDomain.where(:url => self.url).update_all(:verified => false) if checked == true
     update_attribute(:verified, checked)
+    set_first_domain
     checked
   end
 
   def set_primary
-    AccountDomain.where(:account_id => account_id).update_all(:primary => false)
-    update_attribute(:primary, true)
+    if verified == true
+      AccountDomain.where(:account_id => account_id).update_all(:primary => false)
+      update_attribute(:primary, true)
+    end
   end
 
   private
@@ -64,6 +72,21 @@ class AccountDomain < ActiveRecord::Base
       end
     end
   end
+
+  def validate_not_repeated
+    if url
+      if !AccountDomain.where(:account_id => account_id, :url => url).empty?
+        errors.add(:url, "already used for this account") 
+        false
+      end
+    end
+  end
+
+  def set_first_domain
+    if AccountDomain.where(:account_id => account_id, :primary => true).empty?
+      AccountDomain.where(:account_id => account_id, :verified => true).first.try(:update_attribute, :primary, true)
+    end
+  end
   
   
 end

data/app/models/user.rb

@@ -14,11 +14,15 @@ class User < ActiveRecord::Base
          :recoverable, :rememberable, :validatable, :omniauthable
 
   # Setup accessible (or protected) attributes for your model
-  attr_accessible :email, :password, :password_confirmation, :remember_me, :locale, :name, :birthdate
+  attr_accessible :email, :password, :password_confirmation, :remember_me, :locale, :name, :birthdate, :guest
+
+  before_create :skip_confirmation!, :unless => Proc.new { IuguSDK::enable_user_confirmation }
 
   after_create :create_account_for_user
 
-  validates :email, :email => true
+  before_save :skip_reconfirmation!, :unless => Proc.new { IuguSDK::enable_email_reconfirmation }
+
+  validates :email, :email => true, :unless => :guest?
 
   def destruction_job
     Delayed::Job.find_by_queue("user_#{id}_destroy")
@@ -44,6 +48,17 @@ class User < ActiveRecord::Base
     social_accounts.where("provider = ? AND social_id = ?", auth["provider"], auth["uid"]).first || create_social(auth)
   end
 
+  def self.create_guest(locale = "en")
+    user = User.new({
+      :guest => true,
+      :name => "Guest",
+      :locale => locale
+    })
+    user.skip_confirmation!
+    user.save
+    user
+  end
+
   def self.find_or_create_by_social(auth)
     social_account = SocialAccount.where("provider = ? AND social_id = ?", auth["provider"], auth["uid"]).first
     unless user = social_account.try(:user)
@@ -89,9 +104,10 @@ class User < ActiveRecord::Base
   private
 
   def email_required?
-    !has_social?
+    !(has_social? || guest?)
   end
 
+
   #def self.reconfirmable
   #  true
   #end

data/app/models/user_invitation.rb

@@ -1,5 +1,6 @@
 class UserInvitation < ActiveRecord::Base
   validates :email, :email => true, :presence => true
+  validate :email_already_used?
   before_save :set_token
   before_create :set_sent_at
   after_create :send_email
@@ -20,8 +21,14 @@ class UserInvitation < ActiveRecord::Base
   end
 
   def accept(user)
-    Account.find(account_id).account_users << account_user = AccountUser.create(:user_id => user.id)
-    account_user.set_roles(roles.split(',')) if roles
+    account = Account.find(account_id)
+    if account.account_users.where(:user_id => user.id).empty?
+      account.account_users << account_user = AccountUser.create(:user_id => user.id)
+      account_user.set_roles(roles.split(',')) if roles
+      true
+    else
+      false
+    end
   end
 
   private
@@ -37,5 +44,11 @@ class UserInvitation < ActiveRecord::Base
   def send_email
     IuguMailer.invitation(self).deliver
   end
+
+  def email_already_used?
+    if !AccountUser.joins(:user).where(:account_id => account_id, 'users.email' => email).empty?
+      errors.add(:email, "already used in this account")
+    end
+  end
 end
 

data/app/views/iugu/account_domains/index.html.haml

@@ -1,32 +1,57 @@
 %h2
   = I18n.t("iugu.account_domains") + " (##{@account.id})"
 
-%div
-  = simple_form_for @account_domain, :url => create_domain_path(@account.id) do |f|
-    = f.text_field :url
-    = f.submit I18n.t("iugu.add")
-%br
-%div
-  - @account_domains.each do |domain|
-    %div
-
-      = domain.url
-
-      |
-      - if domain.primary
-        = I18n.t("iugu.primary")
-      - else
-        = link_to I18n.t("iugu.set_primary"), primary_domain_path(:account_id => @account.id, :domain_id => domain.id), :method => :post
-
-      |
-      - if domain.verified
-        = I18n.t("iugu.verified")
-      - else
-        = link_to I18n.t("iugu.not_verified"), account_domains_instructions_path(:account_id => @account.id, :domain_id => domain.id)
-
-      - if current_user.is?(:owner, @account)
+- if IuguSDK::enable_subdomain == true
+  %div
+    = simple_form_for @account, :url => update_subdomain_path(:id => @account.id), :method => :put do |f|
+      - if @account.errors.any?
+        #error_explanation{ :style => "margin-bottom: 15px" }
+          %ul
+            - @account.errors.full_messages.each do |msg|
+              %li
+                = msg
+  
+      = f.label :subdomain
+      = f.text_field :subdomain
+      = f.submit I18n.t("iugu.save")
+
+- if IuguSDK::enable_custom_domain == true
+
+  %div
+    = simple_form_for @account_domain, :url => create_domain_path(@account.id) do |f|
+      - if @account_domain.errors.any?
+        #error_explanation{ :style => "margin-bottom: 15px" }
+          %ul
+            - @account_domain.errors.full_messages.each do |msg|
+              %li
+                = msg
+
+      = f.text_field :url
+      = f.submit I18n.t("iugu.add")
+  %br
+  %div
+    - @account_domains.each do |domain|
+      %div
+
+        = domain.url
+
+        - if domain.primary
+          |
+          = I18n.t("iugu.primary")
+        - else
+          - if domain.verified
+            |
+            = link_to I18n.t("iugu.set_primary"), primary_domain_path(:account_id => @account.id, :domain_id => domain.id), :method => :post
+
         |
-        = link_to I18n.t("iugu.remove"), account_domains_destroy_path(:account_id => @account.id, :domain_id => domain.id), :method => :delete
+        - if domain.verified
+          = I18n.t("iugu.verified")
+        - else
+          = link_to I18n.t("iugu.not_verified"), account_domains_instructions_path(:account_id => @account.id, :domain_id => domain.id)
+
+        - if current_user.is?(:owner, @account)
+          |
+          = link_to I18n.t("iugu.remove"), account_domains_destroy_path(:account_id => @account.id, :domain_id => domain.id), :method => :delete
 
 
 

data/app/views/iugu/account_domains/instructions.html.haml

@@ -1,3 +1,6 @@
+%div
+  Token:
+  = @domain.calculate_token
 %div
   = link_to I18n.t("iugu.verify_domain"), verify_domain_path(:account_id => @account.id, :domain_id => @domain.id), :method => :post
 %div

data/app/views/iugu/account_users/index.html.haml

@@ -16,5 +16,7 @@
           = I18n.t("iugu.removing")
         - else
           = link_to I18n.t("iugu.undo"), account_users_cancel_destruction_path(:account_id => account_user.account_id, :user_id => account_user.user_id), :method => 'delete' 
-      %div
-        = link_to I18n.t("iugu.invite"), new_invite_path(:account_id => @account.id)
+
+- if current_user.is?(:owner, @account) || current_user.is?(:admin, @account)
+  %div
+    = link_to I18n.t("iugu.invite"), new_invite_path(:account_id => @account.id)

data/app/views/iugu/invitations/new.html.haml

@@ -1,12 +1,26 @@
-= simple_form_for @user_invitation, :url => create_invite_path(:account_id => @account_id), :method => :post do |f|
+= simple_form_for @user_invitation, :url => create_invite_path(@account.id), :method => :post do |f|
+  - if @user_invitation.errors.any?
+    #error_explanation{ :style => "margin-bottom: 15px" }
+      %ul
+        - @user_invitation.errors.full_messages.each do |msg|
+          %li
+            = msg
 
   %div
     = f.label :email
     = f.email_field :email
-  - APP_ROLES['roles'].each do |role|
-    %div
-      = check_box_tag "user_invitation[roles][]", role, false, :id => "#{role}_checkbox"
-      = label_tag "#{role}_checkbox", role
+  - if current_user.is?(:owner, @account)
+    - APP_ROLES['roles'].each do |role|
+      %div
+        = check_box_tag "user_invitation[roles][]", role, false, :id => "#{role}_checkbox"
+        = label_tag "#{role}_checkbox", role
+
+  - if current_user.is?(:admin, @account)
+    - APP_ROLES['roles'].each do |role|
+      - unless role == APP_ROLES['owner_role'] || role == APP_ROLES['admin_role'] 
+        %div
+          = check_box_tag "user_invitation[roles][]", role, false, :id => "#{role}_checkbox"
+          = label_tag "#{role}_checkbox", role
 
   %div
     = f.submit I18n.t("iugu.invite")

data/app/views/iugu/registrations/new.html.haml

@@ -8,4 +8,7 @@
     = f.hidden_field :locale, :value => @matched_locale_from_browser
   .actions
     = f.button :submit, "Sign up"
-= render :partial => "devise/shared/links"
+
+= link_to I18n.t("iugu.try_first"), try_first_path, :method => :post
+%br
+= render :partial => "iugu/shared/links"