redmine_remotes 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7ec7641f2a0fa365011119971dbe87875bd2d89a0b1a309f4849498810eb4c2
-  data.tar.gz: 2b5877691f690622b098bbea6551e77b415e4a10727573f4cb9b8d490e78963d
+  metadata.gz: 9520f14afbdb893e412eb0147142ac2ceee118152436f62a8a2d2e9a6b0b48dd
+  data.tar.gz: f388fd2ae10c72cec289ad779a994fd099748e991878e275bba9b2ed645adedc
 SHA512:
-  metadata.gz: 8afb48ab0775f253e431a024e518fa466e6881768e50c47418a15db4e488dd660f3f478973fb373c7ca624aaca1daaeab20cbf60071619a797a5771c07e03d24
-  data.tar.gz: 70c63885ccb1fb9c6273586688128f76b4f1dba485016a1a58d9692caa121b42a465ce7a83d63c4ac4245e0f3e941a919c38d48ff799387bbdacb07111a354e7
+  metadata.gz: d86ac7fb4ba1d2a0c687770f453645ee2738acc6c8110df8f5b85ea716c0ce53cfa744517a130e779183f666cdc2d4263215e229b1305828bddae1b895708c04
+  data.tar.gz: 2477b10e006b1240faa0ddf2374def403e65878686a74f54fc1744e7df08327da7ed541cd1f49d7bd939a9e810f2b29964bfcbabdaed45c8119a8019da3bd868

data/app/controllers/project_remote_issues_controller.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class ProjectRemoteIssuesController < ApplicationController
+  before_action :find_project
+  before_action :find_remote_tracker, only: %i[create new]
+
+  def index
+    @trackers = ::RemoteTracker.order(profile: :asc, root_url: :asc, username: :asc)
+  end
+
+  def new
+    @add_issue = model_class.new(context_params)
+  end
+
+  def create
+    @add_issue = model_class.new(create_params)
+    if @add_issue.save
+      flash[:notice] = "Demanda salva: \##{@add_issue.local_issue.id}"
+      redirect_to url_for(action: 'index', id: @project.identifier, tracker_id: @remote_tracker.id)
+    else
+      render 'new'
+    end
+  end
+
+  private
+
+  def model_class
+    ::RedmineRemotes::Tableless::AddRemoteIssue
+  end
+
+  def context_params
+    { project_id: @project.id, remote_tracker_id: @remote_tracker.id }
+  end
+
+  def create_params
+    params.fetch(model_class.model_name.param_key).permit(
+      :issue_remote_code, :local_tracker_id
+    ).merge(context_params)
+  end
+
+  def find_remote_tracker
+    @remote_tracker = ::RemoteTracker.find(params[:tracker_id])
+  end
+end

data/app/controllers/remote_issues_controller.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class RemoteIssuesController < ApplicationController
+  READ_PERMISSION = 'remote_issue.read'
+  WRITE_PERMISSION = 'remote_issue.write'
+  PERMISSIONS = READ_PERMISSION
+
+  layout 'nonproject_modules'
+  require_permission PERMISSIONS
+
+  active_scaffold :remote_issue do |conf|
+    conf.columns[:tracker].form_ui = :select
+  end
+end

data/app/models/redmine_remotes/tableless/add_remote_issue/_local_issue.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RedmineRemotes
+  module Tableless
+    class AddRemoteIssue < ::EacRailsUtils::TablelessModel
+      private
+
+      def create_local_issue
+        return true if local_issue.save
+
+        fetch_record_errors(local_issue, default_column: :issue_remote_code)
+        false
+      end
+
+      def local_issue_uncached
+        ::Issue.new(
+          subject: local_issue_subject, project: project, tracker: local_tracker,
+          priority: local_issue_priority, author: local_issue_author, status: local_issue_status,
+          created_on: provider_issue.created_on, updated_on: provider_issue.updated_on
+        )
+      end
+
+      def local_issue_priority
+        ::IssuePriority.default
+      end
+
+      def local_issue_subject
+        "[#{provider_issue.code}] #{provider_issue.subject}"
+      end
+
+      def local_issue_author_uncached
+        return nil if provider_issue.blank?
+
+        ::RemoteUser.find_local_user(
+          provider_issue.author_login,
+          remote_tracker
+        )
+      end
+
+      def local_issue_status
+        local_issue_status_from_remote_tracker || local_issue_status_from_local_tracker
+      end
+
+      def local_issue_status_from_remote_tracker
+        ::RemoteIssueStatus.find_local_issue_status(
+          provider_issue.status_name,
+          remote_tracker,
+          local_tracker
+        )
+      end
+
+      def local_issue_status_from_local_tracker
+        local_tracker.default_status
+      end
+    end
+  end
+end

data/app/models/redmine_remotes/tableless/add_remote_issue/_provider_issue.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RedmineRemotes
+  module Tableless
+    class AddRemoteIssue < ::EacRailsUtils::TablelessModel
+      private
+
+      def provider_issue_uncached
+        return nil unless remote_tracker.present? && issue_remote_code.present?
+
+        remote_tracker.find_remote_issue(issue_remote_code)
+      rescue ::RedmineRemotes::RestProvider::HttpResponse => e
+        errors.add(:issue_remote_code, "Requisição a \"#{e.url}\" retornou com status #{e.status}")
+        puts "====> #{e.body}"
+        nil
+      end
+    end
+  end
+end

data/app/models/redmine_remotes/tableless/add_remote_issue/_remote_issue.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RedmineRemotes
+  module Tableless
+    class AddRemoteIssue < ::EacRailsUtils::TablelessModel
+      private
+
+      def create_remote_issue
+        return true if remote_issue.save
+
+        fetch_record_errors(remote_issue, default_column: :issue_remote_code)
+        false
+      end
+
+      def update_remote_issue_with_issue
+        return true if remote_issue.update(local_issue: local_issue)
+
+        fetch_record_errors(remote_issue, default_column: :issue_remote_code)
+        false
+      end
+
+      def remote_issue_uncached
+        ::RemoteIssue.new(remote_tracker: remote_tracker, remote_code: issue_remote_code)
+      end
+    end
+  end
+end

data/app/models/redmine_remotes/tableless/add_remote_issue.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+require 'eac_ruby_utils/simple_cache'
+require 'eac/model'
+
+module RedmineRemotes
+  module Tableless
+    class AddRemoteIssue < ::EacRailsUtils::TablelessModel
+      include ::EacRubyUtils::SimpleCache
+      include ::Eac::Model
+      ::EacRubyUtils.require_sub(__FILE__)
+
+      attribute :issue_remote_code, ::String
+      attribute :local_tracker_id, ::Integer
+      attribute :project_id, ::Integer
+      attribute :remote_tracker_id, ::Integer
+
+      belongs_to :local_tracker, class_name: 'Tracker'
+      belongs_to :project, class_name: 'Project'
+      belongs_to :remote_tracker, class_name: 'RemoteTracker'
+
+      validates :local_tracker, presence: true
+      validates :remote_tracker, presence: true
+      validates :project, presence: true
+      validates :issue_remote_code, presence: true
+
+      validate :tracker_in_project
+      validate :author_present
+      validate :provider_issue_present
+
+      def save
+        return false unless valid?
+        return false unless create_remote_issue
+        return false unless create_local_issue
+        return false unless update_remote_issue_with_issue
+
+        true
+      end
+
+      def tracker_in_project
+        return unless local_tracker.present? && project.present?
+        return if project.trackers.include?(local_tracker)
+
+        errors.add(:local_tracker, 'is not a tracker of project')
+      end
+
+      def author_present
+        return if provider_issue.blank?
+        return if local_issue_author.present?
+
+        errors.add(:remote_code,
+                   "Usuário local não encontrado para \"#{provider_issue.author_login}\"")
+      end
+
+      def provider_issue_present
+        return if issue_remote_code.blank?
+        return if provider_issue.present?
+
+        errors.add(:remote_code,
+                   "Demanda remota não encontrada com o código \"#{issue_remote_code}\"")
+      end
+    end
+  end
+end

data/app/models/remote_issue.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class RemoteIssue < ActiveRecord::Base
+  include ::RedmineRemotes::Sanitizer
+
+  downcase_columns :remote_code
+
+  belongs_to :remote_tracker, class_name: 'RemoteTracker', inverse_of: :issues
+  belongs_to :local_issue, class_name: 'Issue', inverse_of: :remote_issue
+
+  validates :remote_tracker, presence: true
+  validates :remote_code, presence: true, uniqueness: { scope: [:remote_tracker] }
+
+  def to_s
+    "#{remote_tracker}|#{remote_code}"
+  end
+end

data/app/models/remote_tracker/_jira.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class RemoteTracker < ActiveRecord::Base
+  def jira_find_remote_issue(issue_id)
+    jira_create_instance.find_issue(issue_id)
+  end
+
+  def jira_create_instance
+    ::RedmineRemotes::Jira::Instance.new(root_url, username, password)
+  end
+end

data/app/models/remote_tracker.rb

@@ -4,9 +4,14 @@ require 'eac_ruby_utils/listable'
 require 'validate_url'
 
 class RemoteTracker < ActiveRecord::Base
+  require_relative 'remote_tracker/_jira'
+
   include ::EacRubyUtils::Listable
 
-  lists.add_string :profile, :stub
+  has_many :issues, class_name: 'RemoteIssue', inverse_of: :remote_tracker,
+                    dependent: :restrict_with_error
+
+  lists.add_string :profile, :jira
 
   has_many :issue_statuses, class_name: 'RemoteIssueStatus', inverse_of: :remote_tracker,
                             dependent: :destroy
@@ -23,4 +28,10 @@ class RemoteTracker < ActiveRecord::Base
   def to_s
     "#{root_url} [#{profile_label}, #{username}]"
   end
+
+  def find_remote_issue(issue_id)
+    raise 'Profile blank' if profile.blank?
+
+    send("#{profile}_find_remote_issue", issue_id)
+  end
 end

data/app/models/remote_user.rb

@@ -12,14 +12,16 @@ class RemoteUser < ActiveRecord::Base
   validates :local_user, presence: true
 
   class << self
-    def find_local_user(remote_login, tracker = nil)
-      [tracker, nil].each do |tracker|
+    def find_local_user(remote_login, remote_tracker = nil)
+      [remote_tracker, nil].each do |tracker|
         remote_user = ::RemoteUser.where(
           remote_tracker: tracker,
           remote_login: remote_login_sanitize(remote_login)
         ).first
         return remote_user.local_user if remote_user
       end
+      return remote_tracker.default_local_user if remote_tracker.present?
+
       nil
     end
   end

data/app/views/project_remote_issues/_trackers.html.erb

@@ -0,0 +1,30 @@
+<h3>Trackers</h3>
+<% if @trackers.any? %>
+  <table class="list files">
+    <thead>
+      <tr>
+        <th>Profile</th>
+        <th>Root URL</th>
+        <th>Username</th>
+        <th></th>
+      </tr>
+    </thead>
+    <tbody>
+      <% @trackers.each do |tracker| %>
+        <tr>
+          <td><%= tracker.profile %></td>
+          <td><%= tracker.root_url %></td>
+          <td><%= tracker.username %></td>
+          <td class="buttons">
+            <%= link_to 'Add issue', new_project_remote_issue_path(
+              id: @project.identifier,
+              tracker_id: tracker.id
+            ) %>
+          </td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+<% else %>
+  <p><em>No trackers registered.</em></p>
+<% end %>

data/app/views/project_remote_issues/index.html.erb

@@ -0,0 +1,2 @@
+<h2><%= t(:label_remote_issues) %></h2>
+<%= render partial: 'trackers' %>

data/app/views/project_remote_issues/new.html.erb

@@ -0,0 +1,12 @@
+<h2><%= @tracker %> &#187; Add Remote Issue</h2>
+<%= labelled_form_for @add_issue, :url => create_project_remote_issue_path(
+  id: @project.identifier,
+  tracker_id: @remote_tracker.id
+  ), method: :post do |f| %>
+  <%= error_messages_for 'add_issue' %>
+  <div class="box tabular">
+    <p><%= f.select :local_tracker_id, @project.trackers.map {|t| [t.to_s, t.id]}  %></p>
+    <p><%= f.text_field :issue_remote_code %></p>
+  </div>
+  <%= submit_tag l(:button_save) %>
+<% end %>

data/config/initializers/001_patches.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'redmine_remotes/patches/issue'
 require 'redmine_remotes/patches/issue_status'
 require 'redmine_remotes/patches/tracker'
 require 'redmine_remotes/patches/user'

data/config/initializers/nonproject_modules.rb

@@ -5,6 +5,11 @@
   ::RemoteTrackersController::WRITE_PERMISSION,
   dependencies: [::RemoteTrackersController::READ_PERMISSION]
 )
+::GroupPermission.add_permission(::RemoteIssuesController::READ_PERMISSION)
+::GroupPermission.add_permission(
+  ::RemoteIssuesController::WRITE_PERMISSION,
+  dependencies: [::RemoteIssuesController::READ_PERMISSION]
+)
 ::GroupPermission.add_permission(::RemoteIssueStatusesController::READ_PERMISSION)
 ::GroupPermission.add_permission(
   ::RemoteIssueStatusesController::WRITE_PERMISSION,
@@ -18,6 +23,7 @@
 
 Redmine::MenuManager.map ::RedmineRemotes::SLUG.to_sym do |menu|
   menu.push_controller(:remote_trackers)
+  menu.push_controller(:remote_issues)
   menu.push_controller(:remote_issue_statuses)
   menu.push_controller(:remote_users)
 end

data/config/locales/en.yml

@@ -3,8 +3,12 @@ en:
     listable:
       remote_tracker:
         profile:
-          stub:
-            label: Stub profile
+          jira:
+            label: Jira
+  field_issue_remote_code: Remote issue's code
+  field_local_tracker: Local tracker
+  label_remote_issues: Remote issues
   label_remote_trackers: Remote trackers
   label_remote_issue_statuses: Remote issue statuses
   label_remote_users: Remote users
+  label_remotes: Remotes

data/config/locales/pt-BR.yml

@@ -3,8 +3,12 @@ pt-BR:
     listable:
       remote_tracker:
         profile:
-          stub:
-            label: Stub profile
+          jira:
+            label: Jira
+  field_issue_remote_code: Código da demanda remota
+  field_local_tracker: Tipo de tarefa local
+  label_remote_issues: Demandas remotas
   label_remote_trackers: Trackers remotos
   label_remote_issue_statuses: Situações de demandas remotas
   label_remote_users: Usuários remotos
+  label_remotes: Remotos

data/config/routes.rb

@@ -1,7 +1,14 @@
 # frozen_string_literal: true
 
 RedmineApp::Application.routes.draw do
+  get '/projects/:id/remotes', to: 'project_remote_issues#index'
+  get '/projects/:id/tracker/:tracker_id/new_issue', to: 'project_remote_issues#new',
+                                                     as: 'new_project_remote_issue'
+  post '/projects/:id/tracker/:tracker_id/new_issue', to: 'project_remote_issues#create',
+                                                      as: 'create_project_remote_issue'
+  resources(:project_remote_issues, only: [:index])
   resources(:remote_trackers) { as_routes }
+  resources(:remote_issues) { as_routes }
   resources(:remote_issue_statuses) { as_routes }
   resources(:remote_users) { as_routes }
 end

data/db/migrate/20190912000000_create_remote_issues.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class CreateRemoteIssues < ActiveRecord::Migration
+  def change
+    create_table :remote_issues do |t|
+      t.references :remote_tracker, index: true
+      t.references :local_issue, index: true, nullable: true
+      t.string :remote_code
+    end
+    add_foreign_key :remote_issues, :remote_trackers, column: :remote_tracker_id
+    add_foreign_key :remote_issues, :issues, column: :local_issue_id
+  end
+end

data/init.rb

@@ -7,4 +7,14 @@ Redmine::Plugin.register ::RedmineRemotes::SLUG.to_sym do
   author ::RedmineRemotes::AUTHOR
   description ::RedmineRemotes::SUMMARY
   version ::RedmineRemotes::VERSION
+
+  project_module :redmine_remotes do
+    permission :view_trackers, project_remote_issues: [:index]
+    permission :add_issues, project_remote_issues: %i[new create]
+  end
+
+  Redmine::MenuManager.map :project_menu do |menu|
+    menu.push :remotes_issues, { controller: 'project_remote_issues', action: 'index' },
+              caption: :label_remotes, after: :issues
+  end
 end

data/lib/redmine_remotes/jira/entities/issue.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RedmineRemotes
+  module Jira
+    module Entities
+      class Issue < ::RedmineRemotes::RestProvider::Entity
+        def code
+          data.fetch('key')
+        end
+
+        def created_on
+          fields.fetch('created')
+        end
+
+        def fields
+          data.fetch('fields')
+        end
+
+        def subject
+          fields.fetch('summary')
+        end
+
+        def status_name
+          fields.fetch('status').fetch('name')
+        end
+
+        def updated_on
+          fields.fetch('updated')
+        end
+
+        def author_login
+          fields.fetch('reporter').fetch('key')
+        end
+      end
+    end
+  end
+end

data/lib/redmine_remotes/jira/instance.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RedmineRemotes
+  module Jira
+    class Instance < ::RedmineRemotes::RestProvider::Instance
+      ISSUE_ID_PATTERN = /\A([a-z][a-z0-9]+)\-(\d+)\z/i.freeze
+
+      class << self
+        def parse_issue_id(global_issue_id)
+          m = ISSUE_ID_PATTERN.match(global_issue_id)
+          return nil unless m
+
+          ::OpenStruct.new(provider_issue_id: m[0], project_id: m[1], project_issue_id: m[2])
+        end
+      end
+
+      def build_service_url(service_url_suffix)
+        "#{root_url}/rest/api/latest#{service_url_suffix}"
+      end
+
+      def issue_get_url_suffix(provider_issue_id)
+        "/issue/#{provider_issue_id}"
+      end
+    end
+  end
+end

data/lib/redmine_remotes/patches/issue.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module EacRedmineUsability
+  module Patches
+    module Issue
+      extend ::ActiveSupport::Concern
+
+      included do
+        has_one :remote_issue, class_name: 'RemoteIssue',
+                               inverse_of: :local_issue, dependent: :restrict_with_error,
+                               foreign_key: :local_issue_id
+      end
+    end
+  end
+end
+
+require_dependency 'issue'
+patch = ::EacRedmineUsability::Patches::Issue
+target = ::Issue
+target.send(:include, patch) unless target.included_modules.include?(patch)

data/lib/redmine_remotes/rest_provider/entity.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/simple_cache'
+
+module RedmineRemotes
+  module RestProvider
+    class Entity
+      include ::EacRubyUtils::SimpleCache
+
+      attr_reader :instance, :data
+
+      def initialize(instance, data)
+        @instance = instance
+        @data = data
+      end
+    end
+  end
+end

data/lib/redmine_remotes/rest_provider/http_response.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RedmineRemotes
+  module RestProvider
+    class HttpResponse < ::StandardError
+      class << self
+        def new_from_curl_easy(curl_easy)
+          new(
+            curl_easy.url,
+            curl_easy.status.to_i,
+            curl_easy.body_str
+          )
+        end
+      end
+
+      attr_reader :url, :status, :body
+
+      def initialize(url, status, body)
+        @url = url
+        @status = status
+        @body = body
+      end
+
+      def body_or_raise
+        return body if status == 200
+
+        raise self
+      end
+    end
+  end
+end

data/lib/redmine_remotes/rest_provider/instance.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'curb'
+require 'json'
+
+module RedmineRemotes
+  module RestProvider
+    # Abstract methods
+    #   * parse_issue_id(global_issue_id)
+    #   * self.build_service_url(service_url_suffix)
+    #   * self.issue_get_url_suffix(provider_issue_id)
+    class Instance
+      attr_reader :root_url, :username, :password
+
+      def initialize(root_url, username, password)
+        @root_url = root_url
+        @username = username
+        @password = password
+      end
+
+      def find_issue(global_issue_id)
+        parsed = self.class.parse_issue_id(global_issue_id)
+        parsed.present? ? issue(parsed.provider_issue_id) : nil
+      end
+
+      def issue(provider_issue_id)
+        issue_class.new(self, request(issue_get_url_suffix(provider_issue_id)))
+      end
+
+      def request(service_url_suffix)
+        JSON.parse(curl_perform(service_url_suffix).body_or_raise)
+      end
+
+      def issue_class
+        "#{self.class.name.deconstantize}::Entities::Issue".constantize
+      end
+
+      private
+
+      # @return [RedmineRemotes::RestProvider::HttpResponse]
+      def curl_perform(service_url_suffix)
+        c = ::Curl::Easy.new(build_service_url(service_url_suffix))
+        c.http_auth_types = :basic
+        c.username = username
+        c.password = password
+        c.headers['Accept'] = 'application/json'
+        return ::RedmineRemotes::RestProvider::HttpResponse.new_from_curl_easy(c) if c.perform
+
+        raise 'Curl failed'
+      end
+    end
+  end
+end

data/lib/redmine_remotes/version.rb

@@ -3,7 +3,7 @@
 module RedmineRemotes
   SLUG = 'redmine_remotes'
   NAME = 'Redmine Remotes'
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
   AUTHOR = 'Eduardo Henrique Bogoni'
   SUMMARY = 'Integração do Redmine com trackers diversos.'
 end

data/lib/tasks/redmine_remotes.rake

@@ -8,4 +8,28 @@ namespace :redmine_remotes do
     t.verbose = false
     t.warning = false
   end
+
+  namespace :issues do
+    desc 'Adds a remote issue.'
+    task :add, [:remote_tracker_id, :issue_remote_code, :project_identifier, :local_tracker_id] => :environment do |t, args|
+      remote_tracker = ::RemoteTracker.find(args.remote_tracker_id)
+      ::Rails.logger.info("Remote tracker: #{remote_tracker}")
+
+      project = ::Project.find_by_identifier(args.project_identifier)
+      ::Rails.logger.info("Project: #{project}")
+
+      local_tracker = args.local_tracker_id ? ::Tracker.find(args.local_tracker_id) : project.trackers.first
+      ::Rails.logger.info("Local tracker: #{local_tracker}")
+
+      add = ::RedmineRemotes::Tableless::AddRemoteIssue.new(
+        remote_tracker: remote_tracker, project: project, local_tracker: local_tracker,
+        issue_remote_code: args.issue_remote_code
+      )
+      if add.save
+        ::Rails.logger.info "[Success] Issue ID: \"#{add.local_issue.id}\""
+      else
+        ::Rails.logger.info "[Failed] #{add.errors.messages.pretty_inspect}"
+      end
+    end
+  end
 end

metadata

@@ -1,15 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: redmine_remotes
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Eduardo Henrique Bogoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-18 00:00:00.000000000 Z
+date: 2019-11-28 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: aranha-parsers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: curb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.10
+- !ruby/object:Gem::Dependency
+  name: eac_rails_utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: eac_ruby_utils
   requirement: !ruby/object:Gem::Requirement
@@ -56,12 +110,23 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- app/controllers/project_remote_issues_controller.rb
 - app/controllers/remote_issue_statuses_controller.rb
+- app/controllers/remote_issues_controller.rb
 - app/controllers/remote_trackers_controller.rb
 - app/controllers/remote_users_controller.rb
+- app/models/redmine_remotes/tableless/add_remote_issue.rb
+- app/models/redmine_remotes/tableless/add_remote_issue/_local_issue.rb
+- app/models/redmine_remotes/tableless/add_remote_issue/_provider_issue.rb
+- app/models/redmine_remotes/tableless/add_remote_issue/_remote_issue.rb
+- app/models/remote_issue.rb
 - app/models/remote_issue_status.rb
 - app/models/remote_tracker.rb
+- app/models/remote_tracker/_jira.rb
 - app/models/remote_user.rb
+- app/views/project_remote_issues/_trackers.html.erb
+- app/views/project_remote_issues/index.html.erb
+- app/views/project_remote_issues/new.html.erb
 - config/initializers/000_dependencies.rb
 - config/initializers/001_patches.rb
 - config/initializers/nonproject_modules.rb
@@ -72,12 +137,19 @@ files:
 - db/migrate/20190910182842_create_remote_users.rb
 - db/migrate/20190910203552_create_remote_issue_statuses.rb
 - db/migrate/20190911165556_rename_issue_status_id_to_local_issue_status_id_in_remote_issue_statuses.rb
+- db/migrate/20190912000000_create_remote_issues.rb
 - db/migrate/20190913195930_add_default_local_user_id_to_remote_trackers.rb
 - init.rb
 - lib/redmine_remotes.rb
+- lib/redmine_remotes/jira/entities/issue.rb
+- lib/redmine_remotes/jira/instance.rb
+- lib/redmine_remotes/patches/issue.rb
 - lib/redmine_remotes/patches/issue_status.rb
 - lib/redmine_remotes/patches/tracker.rb
 - lib/redmine_remotes/patches/user.rb
+- lib/redmine_remotes/rest_provider/entity.rb
+- lib/redmine_remotes/rest_provider/http_response.rb
+- lib/redmine_remotes/rest_provider/instance.rb
 - lib/redmine_remotes/sanitizer.rb
 - lib/redmine_remotes/version.rb
 - lib/tasks/redmine_remotes.rake