zuora_connect 0 → 3.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b69457446868cd3b97d81d5753a967f002d58dfc750c2a4cae9b880a590c741
-  data.tar.gz: e27a81b4e9f30562ff67632d57c3b9e798e76677b5b4ee7c2698473a349bb111
+  metadata.gz: 7efc37130319f941b541835b6b7186c2638d24b0e5cf64c239d53a5aecf1eb3e
+  data.tar.gz: ffbe881cbf369a0091b5f2d001344ed9a943cf8828f64b0f97e7fa79161ac60b
 SHA512:
-  metadata.gz: cb57173d9c5ef615f65d42a1fb6034f47c9878840063d3d243b774ed036e3b30f82a86943b1cfccf9a6534d69849a47468a51b1978e6720a012320025120e9ae
-  data.tar.gz: 53cad727a3c349daf72ee6f3b77c6dfebfe658f41470feb2bc259c4cd5dda994f28f00291d8fa6b14e2feda38df2acc033fef79d8875c5a8c0e6acbef083581b
+  metadata.gz: 24eda6ee0b68e6fbaa7a34825fa82fad61bba1cd514396ba54690478335f9d11169c863f77b5e9bad3b5a28544a93a69e5dbb4c1e51b553917c7bd3b5fc3e967
+  data.tar.gz: 75c2f63d6fc26ead3c21ed85547843ef601726c8f81af49b871d822a290ac6d3cb387853e70f06453ee9b042de6c9c2c17611135da2bfc65a7b8b22b6a5f78c8

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2016 Matthew Ingle
+Copyright 2021 Zuora, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,219 @@
+# Connect Gem
+
+[![Gem Version](https://badge.fury.io/rb/zuora_connect.svg)](https://badge.fury.io/rb/zuora_connect)
+
+## Requirements
+This gem requires a postgres database
+
+## Install
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'zuora_connect'
+```
+
+Then execute `bundle install` in your terminal
+
+## How to contribute to this repository
+https://confluence.zuora.com/pages/viewpage.action?spaceKey=ZCP&title=Pushing+to+GIT
+
+## Configuration
+
+### Settings
+This gem can be configured by adding `connect.rb` to the `config/initializers` folder. An example file and the available options can be seen below.
+```ruby
+ZuoraConnect.configure do |config|
+  config.url = ""
+  config.delayed_job = false
+  config.default_time_zone = Time.zone
+  config.default_locale = :en
+  config.timeout = 5.minutes
+  config.private_key = ""
+  config.mode = "Production"
+  config.dev_mode_logins = { "target_login" => {"tenant_type" => "Zuora", "username" => "user", "password" => "pass", "url" => "url"} }
+  config.dev_mode_options = {"name" => {"config_name" => "name", "datatype" => "type", "value" => "value"}}
+  config.dev_mode_mode = "Universal"
+end
+```
+
+|        Option        |                         Description                         | Required |                                      Values                                            |           Default           |                  Example                   |
+| -------------------- | ----------------------------------------------------------- | -------- | -------------------------------------------------------------------------------------- | --------------------------- | ------------------------------------------ |
+| url                  | URL for the gem to connect to                               | Optional | https://connect.zuora.com <br/> https://connect-staging.zuora.com <br/> localhost:3000 | "https://connect.zuora.com" | config.url = `"https://connect.zuora.com"` |
+| delayed_job          | Used to indicate if Delayed Job is used by this Application | Optional | true or false | `true`| `config.delayed_job - true`|
+| default_time_zone    | Used to indicate the default timezone for the application   | Optional | A valid time zone object | `Time.zone`| `config.default_time_zone = Time.zone`     |
+| default_locale       | Used to indicate the default locale for the application     | Optional | A valid locale| `:en`| `config.default_locale = :en`|
+| private_key| Used to indicate the private key to use when decrypting the data payload|Required for Production| A valid private key| `nil`|`config.private_key = File.open(#{Rails.root/private_key})`|
+| timeout|Used to indicate the amount of time the current session stays active before syncing with ZuoraConnect| Optional |ActiveSupport::Duration |`5.minutes`|`config.timeout = 1.hour`|
+| mode|Used to indicate current environment the gem should run against|Optional |Production or Development|`"Production"`|`config.mode = "Development"`|
+| dev_mode_appinstance|Used to indicate the schema name to use when in development mode|Optional|String|`"1"` |`config.dev_mode_appinstance = "1"`|
+| dev_mode_admin|Used to indicate if admin mode should be turned on in development mode. This will cause all admin calls to be evaluated to true when displaying admin only elements in your application.|Optional|true or false|`false`|`config.dev_mode_admin = true`|
+| dev_mode_pass|Used to mock up the users ZuoraConnect password|Optional |String|`"Test"`|`config.dev_mode_pass = "password1"`|
+| dev_mode_user|Used to mock up the users ZuoraConnect username|Optional|String|`"Test"`|`config.dev_mode_user = "User1"`|
+| dev_mode_logins|Used to mock up the login payload from ZuoraConnect|Optional|Hash|`nil`| `config.dev_mode_logins=  { "target_login" => {"tenant_type" => "Zuora","username" => "user","password" => "pass","url" => "url"}}`
+| dev_mode_mode|Used to mock up the mode passed from ZuoraConnect|Optional |String|`"Universal" `|`config.dev_mode_mode = "Mode2"`|
+| dev_mode_options|Used to mock up the options payload from ZuoraConnect|Optional |Hash|`nil`|'config.dev_mode_options ={"name" => {"config_name" => "name","datatype" => "type","value" => "value"}}'|
+
+
+### Controller Setup
+The following controllers should have the below lines added to them
+
+#### Application Controller ( `controllers/application_controller.rb`)
+```ruby
+before_action :authenticate_connect_app_request
+after_action :persist_connect_app_session
+```
+
+#### Admin controllers
+```ruby
+before_action :check_connect_admin!
+```
+
+#### Admin actions inside a controllers
+
+```ruby
+before_action :check_connect_admin!, :only => [:logs]
+```
+#### API Controller
+```ruby
+before_action :authenticate_app_api_request
+```
+
+An explanation of the available before_filters and what they do can be found below
+
+|             Name             |                                                                                                                                       Description                                                                                                                                       |
+| ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| authenticate_app_api_request | Authenticates the incoming request, handles data segmentation, and creates the @appinstance global variable                                                                                                                                                                             |
+| persist_connect_app_session  | Saves the current user session for use after every request so that every request does not require authentication with Connect. Instead authentication to Connect is done based on the timeout value of the session set in the configuration steps above                                 |
+| check_connect_admin          | Checks if the user is labeled as an admin as deemed by the encrypted request payload coming from Connect. This filter is used to lock down certain functionality that only the Developer should have access to. <br/> Returns false if the user is not an admin                          |
+| check_connect_admin!         | The filter works the same as the above but instead raises an exception `ZuoraConnect::Exceptions::AccessDenied`                                                                                                                                                                         |
+| authenticate_app_api_request | Authenticates the incoming API request based on the token passed in. The token must match a token associate to one of the available app instances. This token is stored on the app instance object as api_token. More information can be found in the API authentication section below. |
+
+## Usage
+
+The Connect gem provides an integration with ZuoraConnect by allowing the application to read data from Connect and make the appropriate API calls.
+
+### Data Segmentation
+
+The Connect Gem provides an integration with ZuoraConnect by allowing the application to read data from Connect and make the appropriate API calls.
+
+### The App Instance object
+
+#### Methods and Attributes
+
+|     Name     |    Type     | Description  |           Example           |
+| ------------ | ----------- | ------------ | --------------------------- |
+| new_session  | `Method`    |              | @appinstance.new_sesion     |
+| updateOption | `Method`    |              | @appinstance.updateOption() |
+| options      | `Attribute` |              | @appinstance.options        |
+| mode         | `Attribute` |              | @appinstance.mode           |
+| logins       | `Attribute` |              | @appinstance.logins         |
+| task_data    | `Attribute` |              | @appinstance.task_data      |
+| token        | `Attribute` | `DEPRECATED` | @appinstance.token          |
+| api_token    | `Attribute` |              | @appinstance.api_token      |
+
+#### Accessing the Object
+
+The `@appinstance` object is accessible in every View and Controller in your application. In order to access `@appinstance` in a Model it must be pulled out of the current thread by doing the following:
+```ruby
+@appinstance = Thread.current[:appinstance]
+```
+### Login Object
+
+All Login information available to your app is passed from connect in a hash in the form `{:target_login => data, :source_login => data}`. It is important to note that target_login and source_login can be variable and that any number of logins can be passed to your application as defined by Connect. For example the following use case could exist: `{:zuora_login => data, :system1_login => data,:system2_login => data}`. This information can be retrieved by the @appinstance object through a call similiar to this `@appinstance.system2_login`. This removes the requirement of using `@appinstance.logins `and looping through the returned hash if you are aware of the logins that Connect will be sending your application.
+
+Each login is mapped as a login object associated to the `@appinstance` object. Every attribute associated to this object passed from Connect is available on this object as an attribute. At a minimum the below attributes will be available
+
+
+|    Name     |                Description                 |
+| ----------- | ------------------------------------------ |
+| tenant_type | Login type such as "Zuora" or "Salesforce" |
+| username    | The username                               |
+| password    | The password                               |
+| url         | Endpoint or URL                            |
+
+#### Zuora logins
+The Connect Gem has built-in integration with the Zuora gem and automatically creates a ZuoraLogin object for every Zuora login. This can be accessed by executing something similiar to the following:
+```ruby
+@appinstance.target_login.client.rest_call
+```
+
+### Admin authentication
+
+#### Controller
+
+Authentication is done through a before filter. Reference the above section on controller setup
+
+#### View
+
+`is_app_admin?` is a view helper that returns true if the user is an admin
+
+### API Authentication
+
+In order to allow direct access to the application without Connect for API calls the :authenticate_app_api_request before filter must be used in your controller and both authenticate_connect_app_request and persist_connect_app_session filters should be skipped to avoid collision.
+
+When making an API call to your application the token associated to the `@appinstance` object must be passed in as the password in a basic auth header with the username being the users Connect username or in the access_token param
+
+## Rails Console
+
+By Default all queries executed from Rails Console will filter against schemas that are named “Public” and your current system $user. You can verify this by executing `ActiveRecord::Base.connection.schema_search_path` in rails console which should return “”$user", public"
+
+The Connect Gem will create/use schemas tied to the TaskIds coming out of Connect. In Development mode this TaskId will default to 1. To query data out in development mode you would open up rails console and execute `ActiveRecord::Base.connection.schema_search_path = 1` before proceeding to subsequent queries
+
+## Delayed Job
+
+In order to use delayed job the configuration option “delayed_job” must be set to true for jobs to be picked up by your workers
+
+### Installation
+1. Set `config.delayed_job = true` in `config/initializers/connect.rb`
+2. Add the following line to the connect.rb init file `Dir["#{Rails.root}/lib/workers/*.rb"].each {|file| require file }`
+3. Add the following gems to your gem file
+```ruby
+gem "delayed_job"
+gem "delayed_job_active_record"
+gem "daemons"
+gem "delayed_job_web" #Optional if a web interface is needed for job management
+```
+4. Run `rails generate delayed_job:active_record` in the terminal
+5. Add `config.active_job.queue_adapter = :delayed_job` to `config/application.rb`
+
+### Usage
+
+#### Creating a Worker Class
+
+Add a worker file based on the following template to lib/workers/worker.rb
+```ruby
+class Worker
+  attr_accessor :schema
+  def initialize(instance_id,var2)
+    @instance_id = instance_id
+    @var2 = var2
+    @schema = ActiveRecord::Base.connection.schema_search_path
+  end
+
+  def perform()
+    @appinstance = ZuoraConnect::AppInstance.find(@instance_id)
+    @appinstance.new_session()
+  end
+end
+```
+
+#### Queueing Jobs
+
+Jobs can be queued anywhere in the code base by using the following code `Delayed::Job.enqueue(Worker.new(@appinstance.id, var2))`. Note that instead of passing in the @appinstance object we always pass in the id. This must happen for schema segmentation to work correctly. This can be disregarded if your worker is not processing data specific to a users app instance.
+
+Reference [here](https://github.com/collectiveidea/delayed_job) for more information on Running Jobs and creating workers
+
+#### Starting the delayed job daemon
+
+Run `bin/delayed_job -n 2 restart` in your terminal to start 2 processes that will pick up all queued jobs
+
+### License Information
+IN THE EVENT YOU ARE AN EXISTING ZUORA CUSTOMER, USE OF THIS SOFTWARE IS GOVERNED BY THE MIT LICENSE SET FORTH BELOW AND NOT THE MASTER SUBSCRIPTION AGREEMENT OR OTHER COMMERCIAL AGREEMENT ENTERED INTO BETWEEN YOU AND ZUORA (“AGREEMENT”). FOR THE AVOIDANCE OF DOUBT, ZUORA’S OBLIGATIONS WITH RESPECT TO TECHNICAL SUPPORT, UPTIME, INDEMNIFICATION, AND SECURITY SET FORTH IN THE AGREEMENT DO NOT APPLY TO THE USE OF THIS SOFTWARE.
+
+Copyright 2021 Zuora, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -15,7 +15,7 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
 load 'rails/tasks/engine.rake'
 
 

data/app/assets/javascripts/hallway_wrapper/after.js

@@ -4,12 +4,31 @@ window.define = previousDefine;
 if (isHallway()) {
   $( document ).ajaxError(function( event, jqxhr, settings, thrownError ) {
     if ( jqxhr.status === 401) {
-      window.location.href = '/apps/newlogin.do?retURL=' + window.location.pathname;
+      fetch("https://" + window.location.host + "/apps/v1/navigation").then(response => {
+        if (response.status === 401) {
+          deleteAllCookies();
+          window.location.href = '/apps/newlogin.do?retURL=' + window.location.pathname;
+        }
+      });
     }
   });
 }
 
 function isHallway() {
-  var regex = new RegExp("^/services/");
-  return window.location.pathname.match(regex);
+  var regex = new RegExp("(?<=\\/)services\\/.*");
+  if (regex.test(window.location.pathname)) {
+    return window.location.pathname.match(regex)[0]
+  }
+  return null;
+}
+
+function deleteAllCookies() {
+  var cookies = document.cookie.split(";");
+
+  for (var i = 0; i < cookies.length; i++) {
+    var cookie = cookies[i];
+    var eqPos = cookie.indexOf("=");
+    var name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
+    document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/";
+  }
 }

data/app/controllers/concerns/zuora_connect/authenticate.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ZuoraConnect
+  # Methods for authenticating and setting the app instance for the current user
+  module Authenticate
+    extend ActiveSupport::Concern
+
+    def setup_instance_via_dev_mode
+      app_instance_id = ZuoraConnect.configuration.dev_mode_appinstance
+      session['appInstance'] = app_instance_id
+      session["#{app_instance_id}::admin"] = ZuoraConnect.configuration.dev_mode_admin
+
+      values = {
+        id: app_instance_id,
+        access_token: ZuoraConnect.configuration.dev_mode_user,
+        refresh_token: ZuoraConnect.configuration.dev_mode_pass,
+        token: ZuoraConnect.configuration.dev_mode_pass + ZuoraConnect.configuration.dev_mode_pass,
+        api_token: ZuoraConnect.configuration.dev_mode_pass + ZuoraConnect.configuration.dev_mode_pass
+      }
+
+      @appinstance = ZuoraConnect::AppInstance.find_by(id: app_instance_id)
+      ZuoraConnect::ZuoraUser.current_user_id = 0
+      zuora_org_ids = cookies['Zuora-Org-Ids'] || request.headers['Zuora-Org-Ids']
+      ZuoraConnect::ZuoraUser.current_org_ids = zuora_org_ids.split('|') if zuora_org_ids
+      if @appinstance.blank?
+        Apartment::Tenant.switch!('public')
+        begin
+          Apartment::Tenant.create(app_instance_id)
+        rescue Apartment::TenantExists
+          Apartment::Tenant.drop(app_instance_id)
+          retry
+        end
+        @appinstance = ZuoraConnect::AppInstance.new
+      end
+      @appinstance.assign_attributes(values)
+      @appinstance.save(validate: false)
+    end
+  end
+end

data/app/controllers/zuora_connect/api/v1/app_instance_controller.rb

@@ -43,7 +43,12 @@ module ZuoraConnect
 
     def cache_bust
       if defined?(Redis.current)
+        @appinstance.fetch_connect_data   #Fetch data and set in database if kms key is used
+        @appinstance.cache_app_instance(force_cache: true)  #Update cache in redis
         Redis.current.del("AppInstance:#{@appinstance.id}")
+        @appinstance.cache_app_instance(force_cache: true)  #Update cache in redis
+        #TODO: Could be a chance another thread cache back to old value, but will eventually cache will get consitent, move to nolonger needing redis cache
+
         respond_to do |format|
           format.json {render json: {}, status: :ok}
         end

data/app/controllers/zuora_connect/application_controller.rb

@@ -1,8 +1,43 @@
 module ZuoraConnect
   class ApplicationController < ActionController::Base
     protect_from_forgery with: :exception
-    before_action :authenticate_connect_app_request
-    after_action :persist_connect_app_session
+    before_action :authenticate_connect_app_request, except: [:ldap_login]
+    after_action :persist_connect_app_session, except: [:ldap_login]
+    skip_before_action :verify_authenticity_token, :only => [:ldap_login]
+    
+    def ldap_login
+      if !ZuoraConnect::AppInstance::INTERNAL_HOSTS.include?(request.headers.fetch("HOST", nil)) 
+        render 'zuora_connect/application/ldap_login', locals: {
+            title: 'Internal Auth Failure',
+            message: 'Internal Auth Failure'
+          }, :layout => false
+      end
 
+      require 'net-ldap'
+
+      username = request.parameters['ldap_username']
+      password = request.parameters['ldap_password']
+
+      begin
+        if ZuoraConnect::LDAP::Adapter.valid_credentials?(username, password)
+          id = ZuoraConnect::AppInstance.first.id
+          session["appInstance"] = ZuoraConnect::AppInstance.first.id
+          session["#{id}::admin"] = true
+          respond_to do |format|
+            format.html { redirect_to '/admin/app_instances' }
+          end
+        else
+          render 'zuora_connect/application/ldap_login', locals: {
+            title: 'LDAP Authentication Failed',
+            message: 'Invalid username or password'
+          }, :layout => false
+        end
+      rescue Net::LDAP::Error
+        render 'zuora_connect/application/ldap_login', locals: {
+          title: 'LDAP Authentication Net Error',
+          message: 'Failed to connect to server while authenticating the LDAP credentials. Please retry later.'
+        }, :layout => false
+      end
+    end
   end
 end

data/app/controllers/zuora_connect/static_controller.rb

@@ -1,31 +1,27 @@
 module ZuoraConnect
+  require "resolv"
   class StaticController < ApplicationController
-    before_action :authenticate_connect_app_request, :except => [:metrics, :health, :session_error, :invalid_app_instance_error, :initialize_app]
-    before_action :clear_connect_app_session,        :only =>   [:metrics, :health, :session_error, :invalid_app_instance_error, :initialize_app]
-    after_action :persist_connect_app_session,       :except => [:metrics, :health, :session_error, :invalid_app_instance_error, :initialize_app]
-    
-    skip_before_action :verify_authenticity_token, :only => [:initialize_app]
+    before_action :authenticate_connect_app_request, :except => [:health, :initialize_app, :provision, :instance_user, :instance_drop]
+    before_action :clear_connect_app_session,        :only =>   [:health, :initialize_app, :provision, :instance_user, :instance_drop]
+    after_action :persist_connect_app_session,       :except => [:health, :initialize_app, :provision, :instance_user, :instance_drop]
 
-    def session_error
-      respond_to do |format|
-        format.html
-        format.json { render json: { message: "Session Error", status: 500 }, status: 500 }
-      end
-    end
+    skip_before_action :verify_authenticity_token, :only => [:initialize_app, :provision, :instance_drop]
+    http_basic_authenticate_with name: ENV['PROVISION_USER'], password: ENV['PROVISION_SECRET'], :only => [:provision, :instance_user, :instance_drop]
 
-    def invalid_app_instance_error
-      respond_to do |format|
-        format.html
-        format.json {render json: { message: "Invalid App Instance", status: 500 }, status: 500 }
+    def health
+      if params[:error].present?
+        begin
+          raise ZuoraConnect::Exceptions::Error.new('This is an error')
+        rescue => ex
+          case params[:error]
+          when 'Log'
+            Rails.logger.error("Error in Health", ex)
+          when 'Exception'
+            raise
+          end
+        end
       end
-    end
 
-    def metrics
-      type = params[:type].present? ? params[:type] : "versions"
-      render json: ZuoraConnect::AppInstance.get_metrics(type).to_json, status: 200
-    end
-
-    def health
       render json: {
         message: "Alive",
         status: 200
@@ -35,14 +31,133 @@ module ZuoraConnect
     def initialize_app
       begin
         authenticate_connect_app_request
+        unless performed?
+          @appinstance.new_session(:session => @appinstance.data_lookup(:session => session))
+          render json: {
+            message: 'Success',
+            status: 200
+          }, status: 200
+        end
+      rescue => ex
+        Rails.logger.error("Failed to Initialize application", ex)
+        if performed?
+          Rails.logger.error("Failed to Initialize application #{performed?}", ex)
+        else
+          render json: {
+            message: "Failure initializing app instance",
+            status: 500
+          }, status: 500
+        end
+      end
+    end
+
+    def provision
+      if ZuoraConnect.configuration.disable_provisioning
+        render(json: { status: 403, message: 'Provisioning is suspended' }, status: 403) && return
+      end
+
+      create_new_instance
+      unless performed?
         render json: {
-          message: "Success",
-          status: 200
+          status: 200,
+          message: 'Success',
+          app_instance_id: @appinstance.id
         }, status: 200
-      rescue
+      end
+    rescue StandardError => e
+      message = 'Failed to provision new instance'
+      if performed?
+        Rails.logger.error("#{message}: #{performed?}", e)
+      else
+        Rails.logger.error(message, e)
+        render json: {
+          status: 500,
+          message: message
+        }, status: 500
+      end
+    end
+
+    def instance_user
+      ZuoraConnect::AppInstance.read_master_db do
+        ZuoraConnect.logger.with_fields = {} if ZuoraConnect.logger.is_a?(Ougai::Logger)
+        Rails.logger.with_fields = {} if Rails.logger.is_a?(Ougai::Logger)
+
+        if defined?(ElasticAPM) && ElasticAPM.running? && ElasticAPM.respond_to?(:set_label)
+          ElasticAPM.set_label(:trace_id, request.uuid)
+        end
+
+        unless params[:id].present?
+          render json: {
+            status: 400,
+            message: 'No app instance id provided'
+          }, status: :bad_request
+          return
+        end
+
+        @appinstance = ZuoraConnect::AppInstance.find(params[:id]).new_session
+      end
+
+      zuora_client = @appinstance.send(ZuoraConnect::AppInstance::LOGIN_TENANT_DESTINATION).client
+      client_describe, = zuora_client.rest_call(
+        url: zuora_client.rest_endpoint('genesis/user/info').gsub('v1/', ''),
+        session_type: zuora_client.class == ZuoraAPI::Oauth ? :bearer : :basic
+      )
+
+      render json: {
+        status: 200,
+        message: 'Success',
+        user_id: client_describe['coreUserId'],
+        username: client_describe['username'],
+        email: client_describe['workEmail']
+      }, status: 200
+    rescue ActiveRecord::RecordNotFound
+      render json: {
+        status: 400,
+        message: 'No app instance found'
+      }, status: :bad_request
+    rescue StandardError => e
+      Rails.logger.error('Error occurred getting user details', e)
+      render json: {
+        status: 500,
+        message: 'Failed to get user details'
+      }, status: 500
+    end
+
+    def instance_drop
+      host = request.headers.fetch("HOST", nil)
+      if host.present? && (ZuoraConnect::AppInstance::INTERNAL_HOSTS.include?(host) || host =~ Resolv::IPv4::Regex)
+        ZuoraConnect::AppInstance.read_master_db do
+          instance_id = params[:id]
+          @appinstance = ZuoraConnect::AppInstance.find(instance_id)
+          if @appinstance.drop_instance
+            ZuoraConnect::AppInstance.destroy(instance_id)
+            msg = Apartment::Tenant.drop(instance_id)
+
+            if msg.error_message.present?
+              render json: { "message" => msg.error_message }, status: :bad_request
+            else
+              render json: {
+                status: 200,
+                message: 'Success',
+                app_instance_id: instance_id
+              }, status: 200
+            end
+          else
+            render json: { "message" => @appinstance.drop_message }, status: :bad_request
+          end
+        end
+      else
+        render json: { "message" => "Host #{host} is not internal" }, status: :bad_request
+      end
+    rescue StandardError => e
+      message = 'Failed to drop instance'
+      if performed?
+        Rails.logger.error("#{message}: #{performed?}", e)
+      else
+        Rails.logger.error(message, e)
         render json: {
-          message: "Failure initializing app instance",
-          status: 500
+          status: 500,
+          message: message
         }, status: 500
       end
     end

data/app/helpers/zuora_connect/LDAP/adapter.rb

@@ -0,0 +1,16 @@
+module ZuoraConnect
+  module LDAP
+    module Adapter
+      def self.valid_credentials?(login, password_plaintext)
+        options = {
+          login: login,
+          password: password_plaintext,
+          ldap_auth_username_builder: proc { |attribute, login, _| "#{attribute}=#{login}" },
+          admin: true
+        }
+        ldap_connection = ZuoraConnect::LDAP::Connection.new(options)
+        ldap_connection.authorized?
+      end
+    end
+  end
+end