feat(导入导出): 实现用户数据导入导出功能

添加导出控制器和服务，支持将用户数据导出为JSON文件
添加导入控制器和服务，支持从JSON文件导入用户数据
更新路由配置，添加导入导出相关端点
更新测试夹具和添加控制器测试

Author: Wpc-121

app/controllers/exports_controller.rb

@@ -0,0 +1,15 @@
+class ExportsController < ApplicationController
+  before_action :authorize_request
+
+  def create
+    export_service = UserExportService.new(@current_user)
+    export_data = export_service.export
+
+    filename = "everydocs_export_#{Time.current.strftime('%Y%m%d_%H%M%S')}.json"
+
+    send_data export_data.to_json,
+      filename: filename,
+      type: 'application/json',
+      disposition: 'attachment'
+  end
+end

app/controllers/imports_controller.rb

@@ -0,0 +1,140 @@
+class ImportsController < ApplicationController
+  before_action :authorize_request
+
+  DRY_RUN_HEADER = 'X-Dry-Run'
+
+  def create
+    import_data = params[:import] || params[:file]
+
+    if import_data.blank?
+      render json: {
+        success: false,
+        errors: ['Missing import data. Please provide either: ' \
+                 '1) JSON file as multipart/form-data with key "file", or ' \
+                 '2) JSON object in request body with key "import"']
+      }, status: :unprocessable_entity
+      return
+    end
+
+    json_data = parse_import_data(import_data)
+
+    if json_data.nil?
+      render json: {
+        success: false,
+        errors: ['Invalid import data format']
+      }, status: :unprocessable_entity
+      return
+    end
+
+    dry_run = request.headers[DRY_RUN_HEADER] == 'true' ||
+              params[:dry_run] == 'true' ||
+              params[:dry_run] == true
+
+    import_service = UserImportService.new(@current_user, json_data, dry_run: dry_run)
+
+    valid = import_service.validate
+    result = import_service.execute if valid
+
+    if valid && result
+      render_success_response(import_service, dry_run)
+    else
+      render_error_response(import_service)
+    end
+  rescue JSON::ParserError => e
+    render json: {
+      success: false,
+      errors: ["Invalid JSON format: #{e.message}"]
+    }, status: :unprocessable_entity
+  end
+
+  def preview
+    import_data = params[:import] || params[:file]
+
+    if import_data.blank?
+      render json: {
+        success: false,
+        errors: ['Missing import data']
+      }, status: :unprocessable_entity
+      return
+    end
+
+    json_data = parse_import_data(import_data)
+
+    if json_data.nil?
+      render json: {
+        success: false,
+        errors: ['Invalid import data format']
+      }, status: :unprocessable_entity
+      return
+    end
+
+    import_service = UserImportService.new(@current_user, json_data, dry_run: true)
+    import_service.validate
+
+    data = json_data['data'] || {}
+
+    render json: {
+      success: true,
+      dry_run: true,
+      preview: {
+        schema_version: json_data['schema_version'],
+        exported_at: json_data['exported_at'],
+        source_user: json_data['user'],
+        data_counts: {
+          folders: data['folders']&.size || 0,
+          tags: data['tags']&.size || 0,
+          people: data['people']&.size || 0,
+          states: data['states']&.size || 0,
+          documents: data['documents']&.size || 0
+        },
+        encrypted_documents: data['documents']&.count { |d| d['encrypted_flag'] } || 0
+      },
+      warnings: import_service.warnings,
+      errors: import_service.errors
+    }, status: :ok
+  rescue JSON::ParserError => e
+    render json: {
+      success: false,
+      errors: ["Invalid JSON format: #{e.message}"]
+    }, status: :unprocessable_entity
+  end
+
+  private
+
+  def parse_import_data(data)
+    if data.is_a?(ActionDispatch::Http::UploadedFile)
+      JSON.parse(data.read)
+    elsif data.is_a?(String)
+      JSON.parse(data)
+    elsif data.is_a?(Hash)
+      data
+    else
+      nil
+    end
+  end
+
+  def render_success_response(import_service, dry_run)
+    response = {
+      success: true,
+      dry_run: dry_run,
+      imported_data: import_service.imported_data,
+      warnings: import_service.warnings
+    }
+
+    if dry_run
+      response[:message] = 'Dry run completed successfully. ' \
+                           'No data was actually imported. ' \
+                           'Send request without X-Dry-Run header to perform actual import.'
+    end
+
+    render json: response, status: :ok
+  end
+
+  def render_error_response(import_service)
+    render json: {
+      success: false,
+      errors: import_service.errors,
+      warnings: import_service.warnings
+    }, status: :unprocessable_entity
+  end
+end

app/services/user_export_service.rb

@@ -0,0 +1,102 @@
+class UserExportService
+  SCHEMA_VERSION = 1
+
+  def initialize(user)
+    @user = user
+  end
+
+  def export
+    {
+      schema_version: SCHEMA_VERSION,
+      exported_at: Time.current.iso8601,
+      user: {
+        name: @user.name,
+        email: @user.email
+      },
+      data: {
+        folders: export_folders,
+        tags: export_tags,
+        people: export_people,
+        states: export_states,
+        documents: export_documents
+      }
+    }
+  end
+
+  def export_as_json
+    export.to_json
+  end
+
+  private
+
+  def export_folders
+    folders = @user.folders.order(:created_at)
+    folders.map do |folder|
+      {
+        name: folder.name,
+        parent_folder_name: folder.folder&.name,
+        created_at: folder.created_at.iso8601,
+        updated_at: folder.updated_at.iso8601
+      }
+    end
+  end
+
+  def export_tags
+    tags = @user.tags.order(:created_at)
+    tags.map do |tag|
+      {
+        name: tag.name,
+        color: tag.color,
+        created_at: tag.created_at.iso8601,
+        updated_at: tag.updated_at.iso8601
+      }
+    end
+  end
+
+  def export_people
+    people = @user.people.order(:created_at)
+    people.map do |person|
+      {
+        name: person.name,
+        created_at: person.created_at.iso8601,
+        updated_at: person.updated_at.iso8601
+      }
+    end
+  end
+
+  def export_states
+    states = @user.states.order(:created_at)
+    states.map do |state|
+      {
+        name: state.name,
+        created_at: state.created_at.iso8601,
+        updated_at: state.updated_at.iso8601
+      }
+    end
+  end
+
+  def export_documents
+    documents = @user.documents.order(:created_at)
+    documents.map do |doc|
+      doc_data = {
+        title: doc.title,
+        description: doc.description,
+        document_date: doc.document_date.iso8601,
+        version: doc.version&.to_s,
+        encrypted_flag: doc.encrypted_flag,
+        folder_name: doc.folder&.name,
+        state_name: doc.state&.name,
+        person_name: doc.person&.name,
+        tag_names: doc.tags.pluck(:name),
+        created_at: doc.created_at.iso8601,
+        updated_at: doc.updated_at.iso8601
+      }
+
+      unless doc.encrypted_flag
+        doc_data[:document_text] = doc.document_text
+      end
+
+      doc_data
+    end
+  end
+end