mirror of
https://github.com/scinote-eln/scinote-web.git
synced 2024-11-16 14:17:00 +08:00
244 lines
7.9 KiB
Ruby
244 lines
7.9 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
module TinyMceImages
|
|
extend ActiveSupport::Concern
|
|
|
|
# rubocop:disable Metrics/BlockLength:
|
|
included do
|
|
has_many :tiny_mce_assets,
|
|
as: :object,
|
|
class_name: :TinyMceAsset,
|
|
dependent: :destroy
|
|
|
|
before_validation :extract_base64_images
|
|
before_save :clean_tiny_mce_image_urls
|
|
after_create :ensure_extracted_image_object_references
|
|
|
|
def prepare_for_report(field)
|
|
description = self[field]
|
|
|
|
# Check tinymce for old format
|
|
description = TinyMceAsset.update_old_tinymce(description, self)
|
|
|
|
tiny_mce_assets.each do |tm_asset|
|
|
next unless tm_asset&.image&.attached?
|
|
|
|
html_description = Nokogiri::HTML(description)
|
|
tm_asset_to_update = html_description.css(
|
|
"img[data-mce-token=\"#{Base62.encode(tm_asset.id)}\"]"
|
|
)[0]
|
|
next unless tm_asset_to_update
|
|
|
|
tm_asset = tm_asset.image.representation(resize_to_limit: Constants::LARGE_PIC_FORMAT).processed
|
|
|
|
width_attr = tm_asset_to_update.attributes['width']
|
|
height_attr = tm_asset_to_update.attributes['height']
|
|
|
|
if width_attr && height_attr && (width_attr.value.to_i >= Constants::LARGE_PIC_FORMAT[0] ||
|
|
height_attr.value.to_i >= Constants::LARGE_PIC_FORMAT[1])
|
|
width_attr.value = tm_asset.image.blob.metadata['width'].to_s
|
|
height_attr.value = tm_asset.image.blob.metadata['height'].to_s
|
|
end
|
|
|
|
tm_asset_to_update.attributes['src'].value = convert_to_base64(tm_asset.image)
|
|
description = html_description.css('body').inner_html.to_s
|
|
end
|
|
description
|
|
end
|
|
|
|
def tinymce_render(field)
|
|
TinyMceAsset.generate_url(self[field], self)
|
|
end
|
|
|
|
def shareable_tinymce_render(field)
|
|
TinyMceAsset.generate_url(self[field], self, is_shared_object: true)
|
|
end
|
|
|
|
# Takes array of old/new TinyMCE asset ID pairs
|
|
# and updates references in assosiated object's description
|
|
def reassign_tiny_mce_image_references(images = [])
|
|
object_field = Extends::RICH_TEXT_FIELD_MAPPINGS[self.class.name]
|
|
|
|
return unless object_field
|
|
|
|
description = read_attribute(object_field)
|
|
|
|
return unless description
|
|
|
|
# Check tinymce for old format
|
|
description = TinyMceAsset.update_old_tinymce(description, self)
|
|
|
|
parsed_description = Nokogiri::HTML(description)
|
|
images.each do |image|
|
|
old_id = image[0]
|
|
new_id = image[1]
|
|
image = parsed_description.at_css("img[data-mce-token=\"#{Base62.encode(old_id)}\"]")
|
|
|
|
unless image
|
|
Rails.logger.error "TinyMCE Asset with id #{old_id} not in text"
|
|
next
|
|
end
|
|
|
|
image['data-mce-token'] = Base62.encode(new_id)
|
|
end
|
|
update(object_field => parsed_description.css('body').inner_html.to_s)
|
|
end
|
|
|
|
def clone_tinymce_assets(target, team)
|
|
cloned_img_ids = []
|
|
tiny_mce_assets.each do |tiny_img|
|
|
next unless tiny_img.image.attached? && tiny_img.image.service.exist?(tiny_img.image.blob.key)
|
|
|
|
tiny_img_clone = TinyMceAsset.create(
|
|
estimated_size: tiny_img.estimated_size,
|
|
object: target,
|
|
team: team
|
|
)
|
|
|
|
tiny_img.duplicate_file(tiny_img_clone)
|
|
target.tiny_mce_assets << tiny_img_clone
|
|
cloned_img_ids << [tiny_img.id, tiny_img_clone.id]
|
|
end
|
|
target.reassign_tiny_mce_image_references(cloned_img_ids)
|
|
end
|
|
|
|
def copy_unknown_tiny_mce_images(user)
|
|
asset_team_id = Team.search_by_object(self).id
|
|
return unless asset_team_id
|
|
|
|
object_field = Extends::RICH_TEXT_FIELD_MAPPINGS[self.class.name]
|
|
|
|
image_changed = false
|
|
parsed_description = Nokogiri::HTML(read_attribute(object_field))
|
|
parsed_description.css('img').each do |image|
|
|
asset = image['data-mce-token'].presence && TinyMceAsset.find_by(id: Base62.decode(image['data-mce-token']))
|
|
|
|
if asset
|
|
next if asset.object == self
|
|
next unless asset.can_read?(user)
|
|
else
|
|
image_type = nil
|
|
begin
|
|
uri = URI.parse(image['src'])
|
|
if uri.scheme != 'https'
|
|
uri.scheme = Rails.application.config.force_ssl ? 'https' : 'http'
|
|
end
|
|
image_type = FastImage.type(uri.to_s).to_s
|
|
next unless image_type
|
|
|
|
new_image = Down.download(uri.to_s, max_size: Rails.configuration.x.file_max_size_mb.megabytes)
|
|
rescue StandardError => e
|
|
Rails.logger.error e.message
|
|
next
|
|
end
|
|
|
|
new_image_filename = Asset.generate_unique_secure_token + '.' + image_type
|
|
end
|
|
|
|
new_asset = TinyMceAsset.create(
|
|
object: self,
|
|
team_id: asset_team_id
|
|
)
|
|
|
|
new_asset.transaction do
|
|
new_asset.save!
|
|
if asset
|
|
asset.duplicate_file(new_asset)
|
|
else
|
|
new_asset.image.attach(io: new_image, filename: new_image_filename)
|
|
end
|
|
end
|
|
|
|
image['src'] = ''
|
|
image['class'] = 'img-responsive'
|
|
image['data-mce-token'] = Base62.encode(new_asset.id)
|
|
image_changed = true
|
|
end
|
|
update(object_field => parsed_description.css('body').inner_html.to_s) if image_changed
|
|
rescue StandardError => e
|
|
Rails.logger.error "Object: #{self.class.name}, id: #{id}, error: #{e.message}"
|
|
end
|
|
|
|
private
|
|
|
|
def clean_tiny_mce_image_urls
|
|
object_field = Extends::RICH_TEXT_FIELD_MAPPINGS[self.class.name]
|
|
return unless changed.include?(object_field.to_s)
|
|
|
|
image_changed = false
|
|
parsed_description = Nokogiri::HTML(read_attribute(object_field))
|
|
parsed_description.css('img[data-mce-token]').each do |image|
|
|
image['src'] = ''
|
|
image['class'] = 'img-responsive'
|
|
image_changed = true
|
|
end
|
|
self[object_field] = parsed_description.to_html.strip if image_changed
|
|
end
|
|
|
|
def extract_base64_images
|
|
# extracts and uploads any base64 encoded images,
|
|
# so they get stored as files instead of directly in the text
|
|
@extracted_base64_images = []
|
|
|
|
object_field = Extends::RICH_TEXT_FIELD_MAPPINGS[self.class.name]
|
|
return unless object_field
|
|
|
|
sanitized_text = public_send(object_field)
|
|
return unless sanitized_text
|
|
|
|
ActiveRecord::Base.transaction do
|
|
sanitized_text.scan(/src="(data:image\/[^;]+;base64[^"]+)"/i).flatten.each do |base64_src|
|
|
base64_data_parts = base64_src.split('base64,')
|
|
base64_file_extension =
|
|
MIME::Types[
|
|
base64_data_parts.first.split(':').last[0..-2]
|
|
].first.preferred_extension
|
|
base64_data = base64_data_parts.last
|
|
|
|
tiny_image = TinyMceAsset.create!(
|
|
team: Team.search_by_object(self),
|
|
object_id: id,
|
|
object_type: self.class.name,
|
|
saved: true
|
|
)
|
|
|
|
tiny_image.image.attach(
|
|
io: StringIO.new(Base64.decode64(base64_data)),
|
|
filename: "#{Asset.generate_unique_secure_token}.#{base64_file_extension}"
|
|
)
|
|
|
|
@extracted_base64_images << tiny_image
|
|
|
|
encoded_id = Base62.encode(tiny_image.id)
|
|
|
|
sanitized_text.gsub!(
|
|
"#{base64_src}\"",
|
|
"\" data-mce-token=\"#{encoded_id}\" alt=\"description-#{encoded_id}\""
|
|
)
|
|
end
|
|
|
|
assign_attributes(object_field => sanitized_text)
|
|
end
|
|
end
|
|
|
|
def ensure_extracted_image_object_references
|
|
# for models that were not yet in database in time of image extraction
|
|
# we need to update image references after creation
|
|
|
|
@extracted_base64_images&.each do |image|
|
|
next if image.object
|
|
|
|
image.update(object: self)
|
|
end
|
|
end
|
|
end
|
|
|
|
def convert_to_base64(image)
|
|
encoded_data = Base64.strict_encode64(image.download)
|
|
"data:#{image.blob.content_type};base64,#{encoded_data}"
|
|
rescue StandardError => e
|
|
Rails.logger.error e.message
|
|
"data:#{image.blob.content_type};base64,"
|
|
end
|
|
# rubocop:enable Metrics/BlockLength:
|
|
end
|