Redmine

      [:text_gs_available,             Redmine::Thumbnail.gs_available?],

      [:text_markdown_converter_available, Redmine::Markdownizer.available?]

        elsif @content = @attachment.markdownized_preview_content

          render :action => 'markdownized'

  cattr_accessor :markdownized_previews_storage_path

  @@markdownized_previews_storage_path = File.join(Rails.root, "tmp", "markdownized_previews")

  def markdownized_previewable?

    readable? && Redmine::Markdownizer.available? && Redmine::Markdownizer.supports?(filename)

  end

  def markdownized_preview_content

    return nil unless markdownized_previewable?

    target = markdownized_preview_cache_path

    if Redmine::Markdownizer.convert(diskfile, target)

      File.read(target, :mode => "rb")

    end

  rescue => e

    if logger

      logger.error(

        "An error occured while generating markdownized preview for #{disk_filename} " \

          "to #{target}\nException was: #{e.message}"

      )

    end

    nil

  end

  def markdownized_preview_cache_path

    File.join(self.class.markdownized_previews_storage_path, "#{digest}_#{filesize}.md")

  end

    FileUtils.rm_f(markdownized_preview_cache_path)

<%= render :layout => 'layouts/file' do %>

  <%= render :partial => 'common/markup',

             :locals => {:markup_text_formatting => 'common_mark', :markup_text => @content} %>

<% end %>

  # Preview for Microsoft Office documents

  #

  # Absolute path (e.g. /usr/local/bin/markitdown) to the MarkItDown command

  # used to convert supported attachments to Markdown for preview.

  #markdown_converter_command:

  text_markdown_converter_available: MarkItDown available (optional)

  text_markdown_converter_available: MarkItDownが利用可能 (オプション)

* MarkItDown (to enable preview for Microsoft Office documents)

  To install, run: `pip install 'markitdown[all]'`

# frozen_string_literal: true

# Redmine - project management software

# Copyright (C) 2006-  Jean-Philippe Lang

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

require 'fileutils'

require 'tempfile'

require 'timeout'

module Redmine

  module Markdownizer

    extend Redmine::Utils::Shell

    COMMAND = (Redmine::Configuration['markdown_converter_command'] || 'markitdown').freeze

    MAX_PREVIEW_SIZE = 100.kilobytes

    SUPPORTED_EXTENSIONS = %w(.doc .docx .xls .xlsx .ppt .pptx).freeze

    def self.supports?(filename)

      SUPPORTED_EXTENSIONS.include?(File.extname(filename.to_s).downcase)

    end

    def self.convert(source, target)

      return nil unless available?

      return target if File.exist?(target)

      directory = File.dirname(target)

      FileUtils.mkdir_p(directory)

      cmd = "#{shell_quote COMMAND} #{shell_quote source}"

      pid = nil

      output = Tempfile.new('markdownized-preview')

      begin

        Timeout.timeout(Redmine::Configuration['thumbnails_generation_timeout'].to_i) do

          pid = Process.spawn(cmd, out: output.path)

          _, status = Process.wait2(pid)

          unless status.success?

            logger.error("Markdown conversion failed (#{status.exitstatus}):\nCommand: #{cmd}")

            return nil

          end

        end

      rescue Timeout::Error

        Process.kill('KILL', pid) if pid

        logger.error("Markdown conversion timed out:\nCommand: #{cmd}")

        return nil

      rescue => e

        logger.error("Markdown conversion failed:\nCommand: #{cmd}\nException was: #{e.message}")

        return nil

      ensure

        output.close

      end

      preview = File.binread(output.path, MAX_PREVIEW_SIZE + 1) || +""

      File.binwrite(target, preview.byteslice(0, MAX_PREVIEW_SIZE))

      target

    ensure

      output&.unlink

    end

    def self.available?

      return @available if defined?(@available)

      begin

        `#{shell_quote COMMAND} --version`

        @available = $?.success?

      rescue

        @available = false

      end

      logger.warn("Markdown converter command (#{COMMAND}) not available") unless @available

      @available

    end

    def self.logger

      Rails.logger

    end

  end

end

  def test_show_msword

    skip unless Redmine::Markdownizer.available?

    set_tmp_attachments_directory

    a = Attachment.new(

      :container => Issue.find(1),

      :file => uploaded_test_file(

        'msword.docx',

        'application/vnd.openxmlformats-officedocument.wordprocessingml.document'

      ),

      :author => User.find(1)

    )

    assert a.save

    get(:show, :params => {:id => a.id})

    assert_response :success

    assert_equal 'text/html', @response.media_type

    assert_select 'div.filecontent.wiki', :text => /Redmine is a flexible project management web application/

    assert_select '.nodata', :count => 0

  end

  def test_markdownized_previewable_should_be_true_for_supported_extensions

    skip unless Redmine::Markdownizer.available?

    attachment = Attachment.new(

      :container => Issue.find(1),

      :file => uploaded_test_file(

        "msword.docx",

        "application/vnd.openxmlformats-officedocument.wordprocessingml.document"

      ),

      :author => User.find(1)

    )

    assert attachment.save

    assert_equal true, attachment.markdownized_previewable?

  end

  def test_markdownized_previewable_should_be_false_for_non_supported_extensions

    skip unless Redmine::Markdownizer.available?

    attachment = Attachment.new(

      :container => Issue.find(1),

      :file => uploaded_test_file("testfile.txt", "text/plain"),

      :author => User.find(1)

    )

    assert attachment.save

    assert_equal false, attachment.markdownized_previewable?

  end

  def test_delete_from_disk_should_delete_markdownized_preview_cache

    attachment = Attachment.create!(

      :container => Issue.find(1),

      :file => uploaded_test_file(

        "msword.docx",

        "application/vnd.openxmlformats-officedocument.wordprocessingml.document"

      ),

      :author => User.find(1)

    )

    preview = attachment.markdownized_preview_cache_path

    FileUtils.mkdir_p(File.dirname(preview))

    File.write(preview, "preview")

    assert File.exist?(preview)

    attachment.send(:delete_from_disk!)

    assert_not File.exist?(preview)

  end