mirror of
https://github.com/indentlabs/notebook.git
synced 2025-10-26 11:19:22 +00:00
107 lines
3.7 KiB
Ruby
107 lines
3.7 KiB
Ruby
class GreenService < Service
|
|
AVERAGE_WORDS_PER_PAGE = 500
|
|
AVERAGE_TIMELINE_EVENTS_PER_PAGE = 3
|
|
SHEETS_OF_PAPER_PER_TREE = 11_000 # source: https://ribble-pack.co.uk/blog/much-paper-comes-one-tree
|
|
|
|
def self.physical_pages_equivalent_for(worldbuilding_page_type)
|
|
# TODO: This would be better estimated with [average] word counts from pages (or a real total),
|
|
# but we don't have that data computed (and definitely don't want to do so on each page load).
|
|
# Until we have a better solution, these page counts come from printing out notebook pages
|
|
# from http://www.notebook-paper.com/
|
|
|
|
case worldbuilding_page_type
|
|
when "Universe" then 2
|
|
when "Character" then 6
|
|
when "Location" then 4
|
|
when "Item" then 2
|
|
when "Building" then 8
|
|
when "Condition" then 4
|
|
when "Continent" then 6
|
|
when "Country" then 5
|
|
when "Creature" then 8
|
|
when "Deity" then 5
|
|
when "Flora" then 4
|
|
when "Food" then 5
|
|
when "Government" then 6
|
|
when "Group" then 4
|
|
when "Job" then 4
|
|
when "Landmark" then 3
|
|
when "Language" then 5
|
|
when "Lore" then 8
|
|
when "Magic" then 4
|
|
when "Planet" then 6
|
|
when "Race" then 4
|
|
when "Religion" then 3
|
|
when "Scene" then 2
|
|
when "School" then 6
|
|
when "Sport" then 4
|
|
when "Technology" then 4
|
|
when "Town" then 4
|
|
when "Tradition" then 3
|
|
when "Vehicle" then 4
|
|
else
|
|
raise "Unknown green estimate: #{worldbuilding_page_type}"
|
|
end
|
|
end
|
|
|
|
def self.trees_saved_by(worldbuilding_page_type)
|
|
(physical_pages_equivalent_for(worldbuilding_page_type) * (worldbuilding_page_type.constantize.last.try(:id) || 0)) / SHEETS_OF_PAPER_PER_TREE.to_f
|
|
end
|
|
|
|
def self.total_document_pages_equivalent
|
|
total_pages = 0
|
|
|
|
# Treat all <1-page documents as 1 page per document, since they'd print on separate pages
|
|
total_pages += Document.with_deleted.where('cached_word_count <= ?', AVERAGE_WORDS_PER_PAGE).count
|
|
|
|
# For all >1-page documents, do a quick estimate of word count sum + num docs to also cover EOD page breaks
|
|
docs = Document.with_deleted.where.not(cached_word_count: nil).where('cached_word_count > ?', AVERAGE_WORDS_PER_PAGE)
|
|
total_pages += (docs.sum(:cached_word_count) / AVERAGE_WORDS_PER_PAGE.to_f).round
|
|
total_pages += docs.count
|
|
|
|
total_pages
|
|
end
|
|
|
|
def self.total_timeline_pages_equivalent
|
|
((TimelineEvent.last.try(:id) || 0) / AVERAGE_TIMELINE_EVENTS_PER_PAGE.to_f).to_i
|
|
end
|
|
|
|
def self.total_physical_pages_equivalent(content_type)
|
|
case content_type.name
|
|
when 'Timeline'
|
|
GreenService.total_timeline_pages_equivalent
|
|
when 'Document'
|
|
GreenService.total_document_pages_equivalent
|
|
else
|
|
GreenService.physical_pages_equivalent_for(content_type.name) * (content_type.last.try(:id) || 0)
|
|
end
|
|
end
|
|
|
|
def self.total_pages_saved_by(user)
|
|
total_pages = 0
|
|
|
|
user.content.each do |content_type, content_list|
|
|
physical_page_equivalent_for_content_type = case content_type
|
|
when 'Timeline'
|
|
AVERAGE_TIMELINE_EVENTS_PER_PAGE * TimelineEvent.where(timeline_id: content_list.map(&:id)).count
|
|
|
|
when 'Document'
|
|
[
|
|
content_list.inject(0) { |sum, doc| sum + (doc.cached_word_count || 0) } / GreenService::AVERAGE_WORDS_PER_PAGE.to_f,
|
|
content_list_count
|
|
].max
|
|
|
|
else
|
|
physical_pages_equivalent_for(content_type) * content_list.count
|
|
end
|
|
|
|
total_pages += physical_page_equivalent_for_content_type
|
|
end
|
|
|
|
total_pages
|
|
end
|
|
|
|
def self.total_trees_saved_by(user)
|
|
total_pages_saved_by(user).to_f / GreenService::SHEETS_OF_PAPER_PER_TREE
|
|
end
|
|
end |