\n)
28 |
29 | if tab == selected_tab
30 | str << "\t"
31 | str << translate(locale, "channel_tab_#{tab_name}_label")
32 | str << "\n"
33 | else
34 | # Video tab doesn't have the last path component
35 | url = tab.videos? ? base_url : "#{base_url}/#{tab_name}"
36 |
37 | str << %(\t)
38 | str << translate(locale, "channel_tab_#{tab_name}_label")
39 | str << "\n"
40 | end
41 |
42 | str << "
"
43 | end
44 | end
45 | end
46 | end
47 | end
48 |
--------------------------------------------------------------------------------
/src/invidious/frontend/comments_reddit.cr:
--------------------------------------------------------------------------------
1 | module Invidious::Frontend::Comments
2 | extend self
3 |
4 | def template_reddit(root, locale)
5 | String.build do |html|
6 | root.each do |child|
7 | if child.data.is_a?(RedditComment)
8 | child = child.data.as(RedditComment)
9 | body_html = HTML.unescape(child.body_html)
10 |
11 | replies_html = ""
12 | if child.replies.is_a?(RedditThing)
13 | replies = child.replies.as(RedditThing)
14 | replies_html = self.template_reddit(replies.data.as(RedditListing).children, locale)
15 | end
16 |
17 | if child.depth > 0
18 | html << <<-END_HTML
19 |
20 |
21 |
22 |
23 | END_HTML
24 | else
25 | html << <<-END_HTML
26 | ([a-zA-Z0-9_-]{11})|(\w+))$/)
9 | item = md["id"]
10 |
11 | # Check if item is branding URL e.g. https://youtube.com/gaming
12 | response = YT_POOL.client &.get("/#{item}")
13 |
14 | if response.status_code == 301
15 | response = YT_POOL.client &.get(URI.parse(response.headers["Location"]).request_target)
16 | end
17 |
18 | if response.body.empty?
19 | env.response.headers["Location"] = "/"
20 | haltf env, status_code: 302
21 | end
22 |
23 | html = XML.parse_html(response.body)
24 | ucid = html.xpath_node(%q(//link[@rel="canonical"])).try &.["href"].split("/")[-1]
25 |
26 | if ucid
27 | env.response.headers["Location"] = "/channel/#{ucid}"
28 | haltf env, status_code: 302
29 | end
30 |
31 | params = [] of String
32 | env.params.query.each do |k, v|
33 | params << "#{k}=#{v}"
34 | end
35 | params = params.join("&")
36 |
37 | url = "/watch?v=#{item}"
38 | if !params.empty?
39 | url += "&#{params}"
40 | end
41 |
42 | # Check if item is video ID
43 | if item.match(/^[a-zA-Z0-9_-]{11}$/) && YT_POOL.client &.head("/watch?v=#{item}").status_code != 404
44 | env.response.headers["Location"] = url
45 | haltf env, status_code: 302
46 | end
47 | end
48 |
49 | env.response.headers["Location"] = "/"
50 | haltf env, status_code: 302
51 | end
52 | end
53 |
--------------------------------------------------------------------------------
/src/invidious/routes/misc.cr:
--------------------------------------------------------------------------------
1 | {% skip_file if flag?(:api_only) %}
2 |
3 | module Invidious::Routes::Misc
4 | def self.home(env)
5 | preferences = env.get("preferences").as(Preferences)
6 | locale = preferences.locale
7 | user = env.get? "user"
8 |
9 | case preferences.default_home
10 | when "Popular"
11 | env.redirect "/feed/popular"
12 | when "Trending"
13 | env.redirect "/feed/trending"
14 | when "Subscriptions"
15 | if user
16 | env.redirect "/feed/subscriptions"
17 | else
18 | env.redirect "/feed/popular"
19 | end
20 | when "Playlists"
21 | if user
22 | env.redirect "/feed/playlists"
23 | else
24 | env.redirect "/feed/popular"
25 | end
26 | else
27 | templated "search_homepage", navbar_search: false
28 | end
29 | end
30 |
31 | def self.privacy(env)
32 | locale = env.get("preferences").as(Preferences).locale
33 | templated "privacy"
34 | end
35 |
36 | def self.licenses(env)
37 | locale = env.get("preferences").as(Preferences).locale
38 | rendered "licenses"
39 | end
40 |
41 | def self.cross_instance_redirect(env)
42 | referer = get_referer(env)
43 |
44 | instance_list = Invidious::Jobs::InstanceListRefreshJob::INSTANCES["INSTANCES"]
45 | # Filter out the current instance
46 | other_available_instances = instance_list.reject { |_, domain| domain == CONFIG.domain }
47 |
48 | if other_available_instances.empty?
49 | # If the current instance is the only one, use the redirect URL as fallback
50 | instance_url = "redirect.invidious.io"
51 | else
52 | # Select other random instance
53 | # Sample returns an array
54 | # Instances are packaged as {region, domain} in the instance list
55 | instance_url = other_available_instances.sample(1)[0][1]
56 | end
57 |
58 | env.redirect "https://#{instance_url}#{referer}"
59 | end
60 | end
61 |
--------------------------------------------------------------------------------
/src/invidious/routes/notifications.cr:
--------------------------------------------------------------------------------
1 | module Invidious::Routes::Notifications
2 | # /modify_notifications
3 | # will "ding" all subscriptions.
4 | # /modify_notifications?receive_all_updates=false&receive_no_updates=false
5 | # will "unding" all subscriptions.
6 | def self.modify(env)
7 | locale = env.get("preferences").as(Preferences).locale
8 |
9 | user = env.get? "user"
10 | sid = env.get? "sid"
11 | referer = get_referer(env, "/")
12 |
13 | redirect = env.params.query["redirect"]?
14 | redirect ||= "false"
15 | redirect = redirect == "true"
16 |
17 | if !user
18 | if redirect
19 | return env.redirect referer
20 | else
21 | return error_json(403, "No such user")
22 | end
23 | end
24 |
25 | user = user.as(User)
26 |
27 | if redirect
28 | env.redirect referer
29 | else
30 | env.response.content_type = "application/json"
31 | "{}"
32 | end
33 | end
34 | end
35 |
--------------------------------------------------------------------------------
/src/invidious/search/ctoken.cr:
--------------------------------------------------------------------------------
1 | def produce_channel_search_continuation(ucid, query, page)
2 | if page <= 1
3 | idx = 0_i64
4 | else
5 | idx = 30_i64 * (page - 1)
6 | end
7 |
8 | object = {
9 | "80226972:embedded" => {
10 | "2:string" => ucid,
11 | "3:base64" => {
12 | "2:string" => "search",
13 | "6:varint" => 1_i64,
14 | "7:varint" => 1_i64,
15 | "12:varint" => 1_i64,
16 | "15:base64" => {
17 | "3:varint" => idx,
18 | },
19 | "23:varint" => 0_i64,
20 | },
21 | "11:string" => query,
22 | "35:string" => "browse-feed#{ucid}search",
23 | },
24 | }
25 |
26 | continuation = object.try { |i| Protodec::Any.cast_json(i) }
27 | .try { |i| Protodec::Any.from_json(i) }
28 | .try { |i| Base64.urlsafe_encode(i) }
29 | .try { |i| URI.encode_www_form(i) }
30 |
31 | return continuation
32 | end
33 |
--------------------------------------------------------------------------------
/src/invidious/search/processors.cr:
--------------------------------------------------------------------------------
1 | module Invidious::Search
2 | module Processors
3 | extend self
4 |
5 | # Regular search (`/search` endpoint)
6 | def regular(query : Query) : Array(SearchItem)
7 | search_params = query.filters.to_yt_params(page: query.page)
8 |
9 | client_config = YoutubeAPI::ClientConfig.new(region: query.region)
10 | initial_data = YoutubeAPI.search(query.text, search_params, client_config: client_config)
11 |
12 | items, _ = extract_items(initial_data)
13 | return items.reject!(Category)
14 | end
15 |
16 | # Search a youtube channel
17 | # TODO: clean code, and rely more on YoutubeAPI
18 | def channel(query : Query) : Array(SearchItem)
19 | response = YT_POOL.client &.get("/channel/#{query.channel}")
20 |
21 | if response.status_code == 404
22 | response = YT_POOL.client &.get("/user/#{query.channel}")
23 | response = YT_POOL.client &.get("/c/#{query.channel}") if response.status_code == 404
24 | initial_data = extract_initial_data(response.body)
25 | ucid = initial_data.dig?("header", "c4TabbedHeaderRenderer", "channelId").try(&.as_s?)
26 | raise ChannelSearchException.new(query.channel) if !ucid
27 | else
28 | ucid = query.channel
29 | end
30 |
31 | continuation = produce_channel_search_continuation(ucid, query.text, query.page)
32 | response_json = YoutubeAPI.browse(continuation)
33 |
34 | items, _ = extract_items(response_json, "", ucid)
35 | return items.reject!(Category)
36 | end
37 |
38 | # Search inside of user subscriptions
39 | def subscriptions(query : Query, user : Invidious::User) : Array(ChannelVideo)
40 | view_name = "subscriptions_#{sha256(user.email)}"
41 |
42 | return PG_DB.query_all("
43 | SELECT id,title,published,updated,ucid,author,length_seconds
44 | FROM (
45 | SELECT *,
46 | to_tsvector(#{view_name}.title) ||
47 | to_tsvector(#{view_name}.author)
48 | as document
49 | FROM #{view_name}
50 | ) v_search WHERE v_search.document @@ plainto_tsquery($1) LIMIT 20 OFFSET $2;",
51 | query.text, (query.page - 1) * 20,
52 | as: ChannelVideo
53 | )
54 | end
55 | end
56 | end
57 |
--------------------------------------------------------------------------------
/src/invidious/trending.cr:
--------------------------------------------------------------------------------
1 | def fetch_trending(trending_type, region, locale)
2 | region ||= "US"
3 | region = region.upcase
4 |
5 | plid = nil
6 |
7 | case trending_type.try &.downcase
8 | when "music"
9 | params = "4gINGgt5dG1hX2NoYXJ0cw%3D%3D"
10 | when "gaming"
11 | params = "4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D"
12 | when "movies"
13 | params = "4gIKGgh0cmFpbGVycw%3D%3D"
14 | else # Default
15 | params = ""
16 | end
17 |
18 | client_config = YoutubeAPI::ClientConfig.new(region: region)
19 | initial_data = YoutubeAPI.browse("FEtrending", params: params, client_config: client_config)
20 |
21 | items, _ = extract_items(initial_data)
22 |
23 | extracted = [] of SearchItem
24 |
25 | deduplicate = items.size > 1
26 |
27 | items.each do |itm|
28 | if itm.is_a?(Category)
29 | # Ignore the smaller categories, as they generally contain a sponsored
30 | # channel, which brings a lot of noise on the trending page.
31 | # See: https://github.com/iv-org/invidious/issues/2989
32 | next if (itm.contents.size < 24 && deduplicate)
33 |
34 | extracted.concat itm.contents.select(SearchItem)
35 | else
36 | extracted << itm
37 | end
38 | end
39 |
40 | # Deduplicate items before returning results
41 | return extracted.select(SearchVideo | ProblematicTimelineItem).uniq!(&.id), plid
42 | end
43 |
--------------------------------------------------------------------------------
/src/invidious/user/converters.cr:
--------------------------------------------------------------------------------
1 | def convert_theme(theme)
2 | case theme
3 | when "true"
4 | "dark"
5 | when "false"
6 | "light"
7 | when "", nil
8 | nil
9 | else
10 | theme
11 | end
12 | end
13 |
--------------------------------------------------------------------------------
/src/invidious/user/cookies.cr:
--------------------------------------------------------------------------------
1 | require "http/cookie"
2 |
3 | struct Invidious::User
4 | module Cookies
5 | extend self
6 |
7 | # Note: we use ternary operator because the two variables
8 | # used in here are not booleans.
9 | SECURE = (Kemal.config.ssl || CONFIG.https_only) ? true : false
10 |
11 | # Session ID (SID) cookie
12 | # Parameter "domain" comes from the global config
13 | def sid(domain : String?, sid) : HTTP::Cookie
14 | return HTTP::Cookie.new(
15 | name: "SID",
16 | domain: domain,
17 | value: sid,
18 | expires: Time.utc + 2.years,
19 | secure: SECURE,
20 | http_only: true,
21 | samesite: HTTP::Cookie::SameSite::Lax
22 | )
23 | end
24 |
25 | # Preferences (PREFS) cookie
26 | # Parameter "domain" comes from the global config
27 | def prefs(domain : String?, preferences : Preferences) : HTTP::Cookie
28 | return HTTP::Cookie.new(
29 | name: "PREFS",
30 | domain: domain,
31 | value: URI.encode_www_form(preferences.to_json),
32 | expires: Time.utc + 2.years,
33 | secure: SECURE,
34 | http_only: false,
35 | samesite: HTTP::Cookie::SameSite::Lax
36 | )
37 | end
38 | end
39 | end
40 |
--------------------------------------------------------------------------------
/src/invidious/user/exports.cr:
--------------------------------------------------------------------------------
1 | struct Invidious::User
2 | module Export
3 | extend self
4 |
5 | def to_invidious(user : User)
6 | playlists = Invidious::Database::Playlists.select_like_iv(user.email)
7 |
8 | return JSON.build do |json|
9 | json.object do
10 | json.field "subscriptions", user.subscriptions
11 | json.field "watch_history", user.watched
12 | json.field "preferences", user.preferences
13 | json.field "playlists" do
14 | json.array do
15 | playlists.each do |playlist|
16 | json.object do
17 | json.field "title", playlist.title
18 | json.field "description", html_to_content(playlist.description_html)
19 | json.field "privacy", playlist.privacy.to_s
20 | json.field "videos" do
21 | json.array do
22 | Invidious::Database::PlaylistVideos.select_ids(playlist.id, playlist.index, limit: CONFIG.playlist_length_limit).each do |video_id|
23 | json.string video_id
24 | end
25 | end
26 | end
27 | end
28 | end
29 | end
30 | end
31 | end
32 | end
33 | end
34 | end # module
35 | end
36 |
--------------------------------------------------------------------------------
/src/invidious/user/user.cr:
--------------------------------------------------------------------------------
1 | require "db"
2 |
3 | struct Invidious::User
4 | include DB::Serializable
5 |
6 | property updated : Time
7 | property notifications : Array(String)
8 | property subscriptions : Array(String)
9 | property email : String
10 |
11 | @[DB::Field(converter: Invidious::User::PreferencesConverter)]
12 | property preferences : Preferences
13 | property password : String?
14 | property token : String
15 | property watched : Array(String)
16 | property feed_needs_update : Bool?
17 |
18 | module PreferencesConverter
19 | def self.from_rs(rs)
20 | begin
21 | Preferences.from_json(rs.read(String))
22 | rescue ex
23 | Preferences.from_json("{}")
24 | end
25 | end
26 | end
27 | end
28 |
--------------------------------------------------------------------------------
/src/invidious/videos/clip.cr:
--------------------------------------------------------------------------------
1 | require "json"
2 |
3 | # returns start_time, end_time and clip_title
4 | def parse_clip_parameters(params) : {Float64?, Float64?, String?}
5 | decoded_protobuf = params.try { |i| URI.decode_www_form(i) }
6 | .try { |i| Base64.decode(i) }
7 | .try { |i| IO::Memory.new(i) }
8 | .try { |i| Protodec::Any.parse(i) }
9 |
10 | start_time = decoded_protobuf
11 | .try(&.["50:0:embedded"]["2:1:varint"].as_i64)
12 | .try { |i| i/1000 }
13 |
14 | end_time = decoded_protobuf
15 | .try(&.["50:0:embedded"]["3:2:varint"].as_i64)
16 | .try { |i| i/1000 }
17 |
18 | clip_title = decoded_protobuf
19 | .try(&.["50:0:embedded"]["4:3:string"].as_s)
20 |
21 | return start_time, end_time, clip_title
22 | end
23 |
--------------------------------------------------------------------------------
/src/invidious/videos/description.cr:
--------------------------------------------------------------------------------
1 | require "json"
2 | require "uri"
3 |
4 | private def copy_string(str : String::Builder, iter : Iterator, count : Int) : Int
5 | copied = 0
6 | while copied < count
7 | cp = iter.next
8 | break if cp.is_a?(Iterator::Stop)
9 |
10 | if cp == 0x26 # Ampersand (&)
11 | str << "&"
12 | elsif cp == 0x27 # Single quote (')
13 | str << "'"
14 | elsif cp == 0x22 # Double quote (")
15 | str << """
16 | elsif cp == 0x3C # Less-than (<)
17 | str << "<"
18 | elsif cp == 0x3E # Greater than (>)
19 | str << ">"
20 | else
21 | str << cp.chr
22 | end
23 |
24 | # A codepoint from the SMP counts twice
25 | copied += 1 if cp > 0xFFFF
26 | copied += 1
27 | end
28 |
29 | return copied
30 | end
31 |
32 | def parse_description(desc, video_id : String) : String?
33 | return "" if desc.nil?
34 |
35 | content = desc["content"].as_s
36 | return "" if content.empty?
37 |
38 | commands = desc["commandRuns"]?.try &.as_a
39 | if commands.nil?
40 | # Slightly faster than HTML.escape, as we're only doing one pass on
41 | # the string instead of five for the standard library
42 | return String.build do |str|
43 | copy_string(str, content.each_codepoint, content.size)
44 | end
45 | end
46 |
47 | # Not everything is stored in UTF-8 on youtube's side. The SMP codepoints
48 | # (0x10000 and above) are encoded as UTF-16 surrogate pairs, which are
49 | # automatically decoded by the JSON parser. It means that we need to count
50 | # copied byte in a special manner, preventing the use of regular string copy.
51 | iter = content.each_codepoint
52 |
53 | index = 0
54 |
55 | return String.build do |str|
56 | commands.each do |command|
57 | cmd_start = command["startIndex"].as_i
58 | cmd_length = command["length"].as_i
59 |
60 | # Copy the text chunk between this command and the previous if needed.
61 | length = cmd_start - index
62 | index += copy_string(str, iter, length)
63 |
64 | # We need to copy the command's text using the iterator
65 | # and the special function defined above.
66 | cmd_content = String.build(cmd_length) do |str2|
67 | copy_string(str2, iter, cmd_length)
68 | end
69 |
70 | link = cmd_content
71 | if on_tap = command.dig?("onTap", "innertubeCommand")
72 | link = parse_link_endpoint(on_tap, cmd_content, video_id)
73 | end
74 | str << link
75 | index += cmd_length
76 | end
77 |
78 | # Copy the end of the string (past the last command).
79 | remaining_length = content.size - index
80 | copy_string(str, iter, remaining_length) if remaining_length > 0
81 | end
82 | end
83 |
--------------------------------------------------------------------------------
/src/invidious/videos/music.cr:
--------------------------------------------------------------------------------
1 | require "json"
2 |
3 | struct VideoMusic
4 | include JSON::Serializable
5 |
6 | property song : String
7 | property album : String
8 | property artist : String
9 | property license : String
10 |
11 | def initialize(@song : String, @album : String, @artist : String, @license : String)
12 | end
13 | end
14 |
--------------------------------------------------------------------------------
/src/invidious/videos/regions.cr:
--------------------------------------------------------------------------------
1 | # List of geographical regions that Youtube recognizes.
2 | # This is used to determine if a video is either restricted to a list
3 | # of allowed regions (= whitelisted) or if it can't be watched in
4 | # a set of regions (= blacklisted).
5 | REGIONS = {
6 | "AD", "AE", "AF", "AG", "AI", "AL", "AM", "AO", "AQ", "AR", "AS", "AT",
7 | "AU", "AW", "AX", "AZ", "BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI",
8 | "BJ", "BL", "BM", "BN", "BO", "BQ", "BR", "BS", "BT", "BV", "BW", "BY",
9 | "BZ", "CA", "CC", "CD", "CF", "CG", "CH", "CI", "CK", "CL", "CM", "CN",
10 | "CO", "CR", "CU", "CV", "CW", "CX", "CY", "CZ", "DE", "DJ", "DK", "DM",
11 | "DO", "DZ", "EC", "EE", "EG", "EH", "ER", "ES", "ET", "FI", "FJ", "FK",
12 | "FM", "FO", "FR", "GA", "GB", "GD", "GE", "GF", "GG", "GH", "GI", "GL",
13 | "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", "GW", "GY", "HK", "HM",
14 | "HN", "HR", "HT", "HU", "ID", "IE", "IL", "IM", "IN", "IO", "IQ", "IR",
15 | "IS", "IT", "JE", "JM", "JO", "JP", "KE", "KG", "KH", "KI", "KM", "KN",
16 | "KP", "KR", "KW", "KY", "KZ", "LA", "LB", "LC", "LI", "LK", "LR", "LS",
17 | "LT", "LU", "LV", "LY", "MA", "MC", "MD", "ME", "MF", "MG", "MH", "MK",
18 | "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW",
19 | "MX", "MY", "MZ", "NA", "NC", "NE", "NF", "NG", "NI", "NL", "NO", "NP",
20 | "NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG", "PH", "PK", "PL", "PM",
21 | "PN", "PR", "PS", "PT", "PW", "PY", "QA", "RE", "RO", "RS", "RU", "RW",
22 | "SA", "SB", "SC", "SD", "SE", "SG", "SH", "SI", "SJ", "SK", "SL", "SM",
23 | "SN", "SO", "SR", "SS", "ST", "SV", "SX", "SY", "SZ", "TC", "TD", "TF",
24 | "TG", "TH", "TJ", "TK", "TL", "TM", "TN", "TO", "TR", "TT", "TV", "TW",
25 | "TZ", "UA", "UG", "UM", "US", "UY", "UZ", "VA", "VC", "VE", "VG", "VI",
26 | "VN", "VU", "WF", "WS", "YE", "YT", "ZA", "ZM", "ZW",
27 | }
28 |
--------------------------------------------------------------------------------
/src/invidious/views/add_playlist_items.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 | <%= playlist.title %> - Invidious
3 |
4 | <% end %>
5 |
6 | <%= author %> - Invidious
50 | <% end %>
51 |
52 | <%= rendered "components/channel_info" %>
53 |
54 | <%= author %> - Invidious
16 | <% end %>
17 |
18 | <%= rendered "components/channel_info" %>
19 |
20 | <%= translate(locale, "Create playlist") %> - Invidious
3 | <% end %>
4 |
5 | <%= translate(locale, "Delete playlist") %> - Invidious
3 | <% end %>
4 |
5 | <%= title %> - Invidious
5 |
6 | <% end %>
7 |
8 |
54 |
55 | <%= HTML.escape(video.title) %> - Invidious
14 |
15 |
16 |
17 |
18 |
33 |
34 | <%= rendered "components/player" %>
35 |
36 |
37 |
38 |
--------------------------------------------------------------------------------
/src/invidious/views/error.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 | <%= "Error" %> - Invidious
3 | <% end %>
4 |
5 | <%= translate(locale, "History") %> - Invidious
3 | <% end %>
4 |
5 | <%= translate(locale, "Playlists") %> - Invidious
3 | <% end %>
4 |
5 | <%= rendered "components/feed_menu" %>
6 |
7 |
4 | <% if env.get("preferences").as(Preferences).default_home != "Popular" %>
5 | <%= translate(locale, "Popular") %> - Invidious
6 | <% else %>
7 | Invidious
8 | <% end %>
9 |
10 | <% end %>
11 |
12 | <%= rendered "components/feed_menu" %>
13 |
14 | <%= translate(locale, "Subscriptions") %> - Invidious
3 |
4 | <% end %>
5 |
6 | <%= rendered "components/feed_menu" %>
7 |
8 |
29 | <%= translate_count(locale, "subscriptions_unseen_notifs_count", notifications.size) %>
30 |
31 |
32 | <% if !notifications.empty? %>
33 |
4 | <% if env.get("preferences").as(Preferences).default_home != "Trending" %>
5 | <%= translate(locale, "Trending") %> - Invidious
6 | <% else %>
7 | Invidious
8 | <% end %>
9 |
10 | <% end %>
11 |
12 | <%= rendered "components/feed_menu" %>
13 |
14 | <%= HTML.escape(hashtag) %> - Invidious
3 | <% end %>
4 |
5 |
6 | 7 | 8 | <%= rendered "components/items_paginated" %> 9 | -------------------------------------------------------------------------------- /src/invidious/views/message.ecr: -------------------------------------------------------------------------------- 1 | <% content_for "header" do %> 2 | "> 3 |
4 | Invidious
5 |
6 | <% end %>
7 |
8 | <%= rendered "components/feed_menu" %>
9 |
10 | <%= HTML.escape(mix.title) %> - Invidious
3 | <% end %>
4 |
5 |
15 |
16 | Invidious
3 | <% end %>
4 |
5 | <%= query.text.size > 30 ? HTML.escape(query.text[0,30].rstrip(".")) + "…" : HTML.escape(query.text) %> - Invidious
3 |
4 | <% end %>
5 |
6 |
7 | <%= Invidious::Frontend::SearchFilters.generate(query.filters, query.text, query.page, locale) %>
8 |
9 | 10 | 11 | <%- if items.empty? -%> 12 |
4 | Invidious - <%= translate(locale, "search") %>
5 |
6 |
7 | <% end %>
8 |
9 | <%= rendered "components/feed_menu" %>
10 |
11 | <%= translate(locale, "Change password") %> - Invidious
3 | <% end %>
4 |
5 | <%= translate(locale, "Clear watch history") %> - Invidious
3 | <% end %>
4 |
5 | <%= translate(locale, "Delete account") %> - Invidious
3 | <% end %>
4 |
5 | <%= translate(locale, "Log in") %> - Invidious
3 | <% end %>
4 |
5 | <%= translate(locale, "Subscription manager") %> - Invidious
3 | <% end %>
4 |
5 | <%= translate(locale, "Token manager") %> - Invidious
3 | <% end %>
4 |
5 |
27 |
45 | END_HTML
46 | end
47 | end
48 | end
49 | end
50 | end
51 |
--------------------------------------------------------------------------------
/src/invidious/frontend/misc.cr:
--------------------------------------------------------------------------------
1 | module Invidious::Frontend::Misc
2 | extend self
3 |
4 | def redirect_url(env : HTTP::Server::Context)
5 | prefs = env.get("preferences").as(Preferences)
6 |
7 | if prefs.automatic_instance_redirect
8 | current_page = env.get?("current_page").as(String)
9 | return "/redirect?referer=#{current_page}"
10 | else
11 | return "https://redirect.invidious.io#{env.request.resource}"
12 | end
13 | end
14 | end
15 |
--------------------------------------------------------------------------------
/src/invidious/hashtag.cr:
--------------------------------------------------------------------------------
1 | module Invidious::Hashtag
2 | extend self
3 |
4 | def fetch(hashtag : String, page : Int, region : String? = nil) : Array(SearchItem)
5 | cursor = (page - 1) * 60
6 | ctoken = generate_continuation(hashtag, cursor)
7 |
8 | client_config = YoutubeAPI::ClientConfig.new(region: region)
9 | response = YoutubeAPI.browse(continuation: ctoken, client_config: client_config)
10 |
11 | items, _ = extract_items(response)
12 | return items
13 | end
14 |
15 | def generate_continuation(hashtag : String, cursor : Int)
16 | object = {
17 | "80226972:embedded" => {
18 | "2:string" => "FEhashtag",
19 | "3:base64" => {
20 | "1:varint" => 60_i64, # result count
21 | "15:base64" => {
22 | "1:varint" => cursor.to_i64,
23 | "2:varint" => 0_i64,
24 | },
25 | "93:2:embedded" => {
26 | "1:string" => hashtag,
27 | "2:varint" => 0_i64,
28 | "3:varint" => 1_i64,
29 | },
30 | },
31 | "35:string" => "browse-feedFEhashtag",
32 | },
33 | }
34 |
35 | continuation = object.try { |i| Protodec::Any.cast_json(i) }
36 | .try { |i| Protodec::Any.from_json(i) }
37 | .try { |i| Base64.urlsafe_encode(i) }
38 | .try { |i| URI.encode_www_form(i) }
39 |
40 | return continuation
41 | end
42 | end
43 |
--------------------------------------------------------------------------------
/src/invidious/helpers/crystal_class_overrides.cr:
--------------------------------------------------------------------------------
1 | # Override of the TCPSocket and HTTP::Client classes in order to allow an
2 | # IP family to be selected for domains that resolve to both IPv4 and
3 | # IPv6 addresses.
4 | #
5 | class TCPSocket
6 | def initialize(host, port, dns_timeout = nil, connect_timeout = nil, blocking = false, family = Socket::Family::UNSPEC)
7 | Addrinfo.tcp(host, port, timeout: dns_timeout, family: family) do |addrinfo|
8 | super(addrinfo.family, addrinfo.type, addrinfo.protocol, blocking)
9 | connect(addrinfo, timeout: connect_timeout) do |error|
10 | close
11 | error
12 | end
13 | end
14 | end
15 | end
16 |
17 | # :ditto:
18 | class HTTP::Client
19 | property family : Socket::Family = Socket::Family::UNSPEC
20 |
21 | private def io
22 | io = @io
23 | return io if io
24 | unless @reconnect
25 | raise "This HTTP::Client cannot be reconnected"
26 | end
27 |
28 | hostname = @host.starts_with?('[') && @host.ends_with?(']') ? @host[1..-2] : @host
29 | io = TCPSocket.new hostname, @port, @dns_timeout, @connect_timeout, family: @family
30 | io.read_timeout = @read_timeout if @read_timeout
31 | io.write_timeout = @write_timeout if @write_timeout
32 | io.sync = false
33 |
34 | {% if !flag?(:without_openssl) %}
35 | if tls = @tls
36 | tcp_socket = io
37 | begin
38 | io = OpenSSL::SSL::Socket::Client.new(tcp_socket, context: tls, sync_close: true, hostname: @host.rchop('.'))
39 | rescue exc
40 | # don't leak the TCP socket when the SSL connection failed
41 | tcp_socket.close
42 | raise exc
43 | end
44 | end
45 | {% end %}
46 |
47 | @io = io
48 | end
49 | end
50 |
51 | # Mute the ClientError exception raised when a connection is flushed.
52 | # This happends when the connection is unexpectedly closed by the client.
53 | #
54 | class HTTP::Server::Response
55 | class Output
56 | private def unbuffered_flush
57 | @io.flush
58 | rescue ex : IO::Error
59 | unbuffered_close
60 | end
61 | end
62 | end
63 |
64 | # TODO: Document this override
65 | #
66 | class PG::ResultSet
67 | def field(index = @column_index)
68 | @fields.not_nil![index]
69 | end
70 | end
71 |
--------------------------------------------------------------------------------
/src/invidious/helpers/logger.cr:
--------------------------------------------------------------------------------
1 | require "colorize"
2 |
3 | enum LogLevel
4 | All = 0
5 | Trace = 1
6 | Debug = 2
7 | Info = 3
8 | Warn = 4
9 | Error = 5
10 | Fatal = 6
11 | Off = 7
12 | end
13 |
14 | class Invidious::LogHandler < Kemal::BaseLogHandler
15 | def initialize(@io : IO = STDOUT, @level = LogLevel::Debug, use_color : Bool = true)
16 | Colorize.enabled = use_color
17 | Colorize.on_tty_only!
18 | end
19 |
20 | def call(context : HTTP::Server::Context)
21 | elapsed_time = Time.measure { call_next(context) }
22 | elapsed_text = elapsed_text(elapsed_time)
23 |
24 | # Default: full path with parameters
25 | requested_url = context.request.resource
26 |
27 | # Try not to log search queries passed as GET parameters during normal use
28 | # (They will still be logged if log level is 'Debug' or 'Trace')
29 | if @level > LogLevel::Debug && (
30 | requested_url.downcase.includes?("search") || requested_url.downcase.includes?("q=")
31 | )
32 | # Log only the path
33 | requested_url = context.request.path
34 | end
35 |
36 | info("#{context.response.status_code} #{context.request.method} #{requested_url} #{elapsed_text}")
37 |
38 | context
39 | end
40 |
41 | def write(message : String)
42 | @io << message
43 | @io.flush
44 | end
45 |
46 | def color(level)
47 | case level
48 | when LogLevel::Trace then :cyan
49 | when LogLevel::Debug then :green
50 | when LogLevel::Info then :white
51 | when LogLevel::Warn then :yellow
52 | when LogLevel::Error then :red
53 | when LogLevel::Fatal then :magenta
54 | else :default
55 | end
56 | end
57 |
58 | {% for level in %w(trace debug info warn error fatal) %}
59 | def {{level.id}}(message : String)
60 | if LogLevel::{{level.id.capitalize}} >= @level
61 | puts("#{Time.utc} [{{level.id}}] #{message}".colorize(color(LogLevel::{{level.id.capitalize}})))
62 | end
63 | end
64 | {% end %}
65 |
66 | private def elapsed_text(elapsed)
67 | millis = elapsed.total_milliseconds
68 | return "#{millis.round(2)}ms" if millis >= 1
69 |
70 | "#{(millis * 1000).round(2)}µs"
71 | end
72 | end
73 |
--------------------------------------------------------------------------------
/src/invidious/helpers/macros.cr:
--------------------------------------------------------------------------------
1 | module DB::Serializable
2 | macro included
3 | {% verbatim do %}
4 | macro finished
5 | def self.type_array
6 | \{{ @type.instance_vars
7 | .reject { |var| var.annotation(::DB::Field) && var.annotation(::DB::Field)[:ignore] }
8 | .map { |name| name.stringify }
9 | }}
10 | end
11 |
12 | def initialize(tuple)
13 | \{% for var in @type.instance_vars %}
14 | \{% ann = var.annotation(::DB::Field) %}
15 | \{% if ann && ann[:ignore] %}
16 | \{% else %}
17 | @\{{var.name}} = tuple[:\{{var.name.id}}]
18 | \{% end %}
19 | \{% end %}
20 | end
21 |
22 | def to_a
23 | \{{ @type.instance_vars
24 | .reject { |var| var.annotation(::DB::Field) && var.annotation(::DB::Field)[:ignore] }
25 | .map { |name| name }
26 | }}
27 | end
28 | end
29 | {% end %}
30 | end
31 | end
32 |
33 | module JSON::Serializable
34 | macro included
35 | {% verbatim do %}
36 | macro finished
37 | def initialize(tuple)
38 | \{% for var in @type.instance_vars %}
39 | \{% ann = var.annotation(::JSON::Field) %}
40 | \{% if ann && ann[:ignore] %}
41 | \{% else %}
42 | @\{{var.name}} = tuple[:\{{var.name.id}}]
43 | \{% end %}
44 | \{% end %}
45 | end
46 | end
47 | {% end %}
48 | end
49 | end
50 |
51 | macro templated(_filename, template = "template", navbar_search = true)
52 | navbar_search = {{navbar_search}}
53 |
54 | {{ filename = "src/invidious/views/" + _filename + ".ecr" }}
55 | {{ layout = "src/invidious/views/" + template + ".ecr" }}
56 |
57 | __content_filename__ = {{filename}}
58 | render {{filename}}, {{layout}}
59 | end
60 |
61 | macro rendered(filename)
62 | render("src/invidious/views/#{{{filename}}}.ecr")
63 | end
64 |
65 | # Similar to Kemals halt method but works in a
66 | # method.
67 | macro haltf(env, status_code = 200, response = "")
68 | {{env}}.response.status_code = {{status_code}}
69 | {{env}}.response.print {{response}}
70 | {{env}}.response.close
71 | return
72 | end
73 |
--------------------------------------------------------------------------------
/src/invidious/helpers/signatures.cr:
--------------------------------------------------------------------------------
1 | require "http/params"
2 | require "./sig_helper"
3 |
4 | class Invidious::DecryptFunction
5 | @last_update : Time = Time.utc - 42.days
6 |
7 | def initialize(uri_or_path)
8 | @client = SigHelper::Client.new(uri_or_path)
9 | self.check_update
10 | end
11 |
12 | def check_update
13 | # If we have updated in the last 5 minutes, do nothing
14 | return if (Time.utc - @last_update) < 5.minutes
15 |
16 | # Get the amount of time elapsed since when the player was updated, in the
17 | # event where multiple invidious processes are run in parallel.
18 | update_time_elapsed = (@client.get_player_timestamp || 301).seconds
19 |
20 | if update_time_elapsed > 5.minutes
21 | LOGGER.debug("Signature: Player might be outdated, updating")
22 | @client.force_update
23 | @last_update = Time.utc
24 | end
25 | end
26 |
27 | def decrypt_nsig(n : String) : String?
28 | self.check_update
29 | return @client.decrypt_n_param(n)
30 | rescue ex
31 | LOGGER.debug(ex.message || "Signature: Unknown error")
32 | LOGGER.trace(ex.inspect_with_backtrace)
33 | return nil
34 | end
35 |
36 | def decrypt_signature(str : String) : String?
37 | self.check_update
38 | return @client.decrypt_sig(str)
39 | rescue ex
40 | LOGGER.debug(ex.message || "Signature: Unknown error")
41 | LOGGER.trace(ex.inspect_with_backtrace)
42 | return nil
43 | end
44 |
45 | def get_sts : UInt64?
46 | self.check_update
47 | return @client.get_signature_timestamp
48 | rescue ex
49 | LOGGER.debug(ex.message || "Signature: Unknown error")
50 | LOGGER.trace(ex.inspect_with_backtrace)
51 | return nil
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/src/invidious/helpers/webvtt.cr:
--------------------------------------------------------------------------------
1 | # Namespace for logic relating to generating WebVTT files
2 | #
3 | # Probably not compliant to WebVTT's specs but it is enough for Invidious.
4 | module WebVTT
5 | # A WebVTT builder generates WebVTT files
6 | private class Builder
7 | # See https://developer.mozilla.org/en-US/docs/Web/API/WebVTT_API#cue_payload
8 | private ESCAPE_SUBSTITUTIONS = {
9 | '&' => "&",
10 | '<' => "<",
11 | '>' => ">",
12 | '\u200E' => "",
13 | '\u200F' => "",
14 | '\u00A0' => " ",
15 | }
16 |
17 | def initialize(@io : IO)
18 | end
19 |
20 | # Writes an vtt cue with the specified time stamp and contents
21 | def cue(start_time : Time::Span, end_time : Time::Span, text : String)
22 | timestamp(start_time, end_time)
23 | @io << self.escape(text)
24 | @io << "\n\n"
25 | end
26 |
27 | private def timestamp(start_time : Time::Span, end_time : Time::Span)
28 | timestamp_component(start_time)
29 | @io << " --> "
30 | timestamp_component(end_time)
31 |
32 | @io << '\n'
33 | end
34 |
35 | private def timestamp_component(timestamp : Time::Span)
36 | @io << timestamp.hours.to_s.rjust(2, '0')
37 | @io << ':' << timestamp.minutes.to_s.rjust(2, '0')
38 | @io << ':' << timestamp.seconds.to_s.rjust(2, '0')
39 | @io << '.' << timestamp.milliseconds.to_s.rjust(3, '0')
40 | end
41 |
42 | private def escape(text : String) : String
43 | return text.gsub(ESCAPE_SUBSTITUTIONS)
44 | end
45 |
46 | def document(setting_fields : Hash(String, String)? = nil, &)
47 | @io << "WEBVTT\n"
48 |
49 | if setting_fields
50 | setting_fields.each do |name, value|
51 | @io << name << ": " << value << '\n'
52 | end
53 | end
54 |
55 | @io << '\n'
56 |
57 | yield
58 | end
59 | end
60 |
61 | # Returns the resulting `String` of writing WebVTT to the yielded `WebVTT::Builder`
62 | #
63 | # ```
64 | # string = WebVTT.build do |vtt|
65 | # vtt.cue(Time::Span.new(seconds: 1), Time::Span.new(seconds: 2), "Line 1")
66 | # vtt.cue(Time::Span.new(seconds: 2), Time::Span.new(seconds: 3), "Line 2")
67 | # end
68 | #
69 | # string # => "WEBVTT\n\n00:00:01.000 --> 00:00:02.000\nLine 1\n\n00:00:02.000 --> 00:00:03.000\nLine 2\n\n"
70 | # ```
71 | #
72 | # Accepts an optional settings fields hash to add settings attribute to the resulting vtt file.
73 | def self.build(setting_fields : Hash(String, String)? = nil, &)
74 | String.build do |str|
75 | builder = Builder.new(str)
76 | builder.document(setting_fields) do
77 | yield builder
78 | end
79 | end
80 | end
81 | end
82 |
--------------------------------------------------------------------------------
/src/invidious/http_server/utils.cr:
--------------------------------------------------------------------------------
1 | require "uri"
2 |
3 | module Invidious::HttpServer
4 | module Utils
5 | extend self
6 |
7 | def proxy_video_url(raw_url : String, *, region : String? = nil, absolute : Bool = false)
8 | url = URI.parse(raw_url)
9 |
10 | # Add some URL parameters
11 | params = url.query_params
12 | params["host"] = url.host.not_nil! # Should never be nil, in theory
13 | params["region"] = region if !region.nil?
14 | url.query_params = params
15 |
16 | if absolute
17 | return "#{HOST_URL}#{url.request_target}"
18 | else
19 | return url.request_target
20 | end
21 | end
22 |
23 | def add_params_to_url(url : String | URI, params : URI::Params) : URI
24 | url = URI.parse(url) if url.is_a?(String)
25 |
26 | url_query = url.query || ""
27 |
28 | # Append the parameters
29 | url.query = String.build do |str|
30 | if !url_query.empty?
31 | str << url_query
32 | str << '&'
33 | end
34 |
35 | str << params
36 | end
37 |
38 | return url
39 | end
40 | end
41 | end
42 |
--------------------------------------------------------------------------------
/src/invidious/jobs.cr:
--------------------------------------------------------------------------------
1 | module Invidious::Jobs
2 | JOBS = [] of BaseJob
3 |
4 | # Automatically generate a structure that wraps the various
5 | # jobs' configs, so that the following YAML config can be used:
6 | #
7 | # jobs:
8 | # job_name:
9 | # enabled: true
10 | # some_property: "value"
11 | #
12 | macro finished
13 | struct JobsConfig
14 | include YAML::Serializable
15 |
16 | {% for sc in BaseJob.subclasses %}
17 | # Voodoo macro to transform `Some::Module::CustomJob` to `custom`
18 | {% class_name = sc.id.split("::").last.id.gsub(/Job$/, "").underscore %}
19 |
20 | getter {{ class_name }} = {{ sc.name }}::Config.new
21 | {% end %}
22 |
23 | def initialize
24 | end
25 | end
26 | end
27 |
28 | def self.register(job : BaseJob)
29 | JOBS << job
30 | end
31 |
32 | def self.start_all
33 | JOBS.each do |job|
34 | # Don't run the main rountine if the job is disabled by config
35 | next if job.disabled?
36 |
37 | spawn { job.begin }
38 | end
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/src/invidious/jobs/base_job.cr:
--------------------------------------------------------------------------------
1 | abstract class Invidious::Jobs::BaseJob
2 | abstract def begin
3 |
4 | # When this base job class is inherited, make sure to define
5 | # a basic "Config" structure, that contains the "enable" property,
6 | # and to create the associated instance property.
7 | #
8 | macro inherited
9 | macro finished
10 | # This config structure can be expanded as required.
11 | struct Config
12 | include YAML::Serializable
13 |
14 | property enable = true
15 |
16 | def initialize
17 | end
18 | end
19 |
20 | property cfg = Config.new
21 |
22 | # Return true if job is enabled by config
23 | protected def enabled? : Bool
24 | return (@cfg.enable == true)
25 | end
26 |
27 | # Return true if job is disabled by config
28 | protected def disabled? : Bool
29 | return (@cfg.enable == false)
30 | end
31 | end
32 | end
33 | end
34 |
--------------------------------------------------------------------------------
/src/invidious/jobs/clear_expired_items_job.cr:
--------------------------------------------------------------------------------
1 | class Invidious::Jobs::ClearExpiredItemsJob < Invidious::Jobs::BaseJob
2 | # Remove items (videos, nonces, etc..) whose cache is outdated every hour.
3 | # Removes the need for a cron job.
4 | def begin
5 | loop do
6 | failed = false
7 |
8 | LOGGER.info("jobs: running ClearExpiredItems job")
9 |
10 | begin
11 | Invidious::Database::Videos.delete_expired
12 | Invidious::Database::Nonces.delete_expired
13 | rescue DB::Error
14 | failed = true
15 | end
16 |
17 | # Retry earlier than scheduled on DB error
18 | if failed
19 | LOGGER.info("jobs: ClearExpiredItems failed. Retrying in 10 minutes.")
20 | sleep 10.minutes
21 | else
22 | LOGGER.info("jobs: ClearExpiredItems done.")
23 | sleep 1.hour
24 | end
25 | end
26 | end
27 | end
28 |
--------------------------------------------------------------------------------
/src/invidious/jobs/pull_popular_videos_job.cr:
--------------------------------------------------------------------------------
1 | class Invidious::Jobs::PullPopularVideosJob < Invidious::Jobs::BaseJob
2 | POPULAR_VIDEOS = Atomic.new([] of ChannelVideo)
3 | private getter db : DB::Database
4 |
5 | def initialize(@db)
6 | end
7 |
8 | def begin
9 | loop do
10 | videos = Invidious::Database::ChannelVideos.select_popular_videos
11 | .sort_by!(&.published)
12 | .reverse!
13 |
14 | POPULAR_VIDEOS.set(videos)
15 |
16 | sleep 1.minute
17 | Fiber.yield
18 | end
19 | end
20 | end
21 |
--------------------------------------------------------------------------------
/src/invidious/jobs/refresh_channels_job.cr:
--------------------------------------------------------------------------------
1 | class Invidious::Jobs::RefreshChannelsJob < Invidious::Jobs::BaseJob
2 | private getter db : DB::Database
3 |
4 | def initialize(@db)
5 | end
6 |
7 | def begin
8 | max_fibers = CONFIG.channel_threads
9 | lim_fibers = max_fibers
10 | active_fibers = 0
11 | active_channel = ::Channel(Bool).new
12 | backoff = 2.minutes
13 |
14 | loop do
15 | LOGGER.debug("RefreshChannelsJob: Refreshing all channels")
16 | PG_DB.query("SELECT id FROM channels ORDER BY updated") do |rs|
17 | rs.each do
18 | id = rs.read(String)
19 |
20 | if active_fibers >= lim_fibers
21 | LOGGER.trace("RefreshChannelsJob: Fiber limit reached, waiting...")
22 | if active_channel.receive
23 | LOGGER.trace("RefreshChannelsJob: Fiber limit ok, continuing")
24 | active_fibers -= 1
25 | end
26 | end
27 |
28 | LOGGER.debug("RefreshChannelsJob: #{id} : Spawning fiber")
29 | active_fibers += 1
30 | spawn do
31 | begin
32 | LOGGER.trace("RefreshChannelsJob: #{id} fiber : Fetching channel")
33 | channel = fetch_channel(id, pull_all_videos: CONFIG.full_refresh)
34 |
35 | lim_fibers = max_fibers
36 |
37 | LOGGER.trace("RefreshChannelsJob: #{id} fiber : Updating DB")
38 | Invidious::Database::Channels.update_author(id, channel.author)
39 | rescue ex
40 | LOGGER.error("RefreshChannelsJob: #{id} : #{ex.message}")
41 | if ex.message == "Deleted or invalid channel"
42 | Invidious::Database::Channels.update_mark_deleted(id)
43 | else
44 | lim_fibers = 1
45 | LOGGER.error("RefreshChannelsJob: #{id} fiber : backing off for #{backoff}s")
46 | sleep backoff
47 | if backoff < 1.days
48 | backoff += backoff
49 | else
50 | backoff = 1.days
51 | end
52 | end
53 | ensure
54 | LOGGER.debug("RefreshChannelsJob: #{id} fiber : Done")
55 | active_channel.send(true)
56 | end
57 | end
58 | end
59 | end
60 |
61 | LOGGER.debug("RefreshChannelsJob: Done, sleeping for #{CONFIG.channel_refresh_interval}")
62 | sleep CONFIG.channel_refresh_interval
63 | Fiber.yield
64 | end
65 | end
66 | end
67 |
--------------------------------------------------------------------------------
/src/invidious/jobs/statistics_refresh_job.cr:
--------------------------------------------------------------------------------
1 | class Invidious::Jobs::StatisticsRefreshJob < Invidious::Jobs::BaseJob
2 | STATISTICS = {
3 | "version" => "2.0",
4 | "software" => {
5 | "name" => "invidious",
6 | "version" => "",
7 | "branch" => "",
8 | },
9 | "openRegistrations" => true,
10 | "usage" => {
11 | "users" => {
12 | "total" => 0_i64,
13 | "activeHalfyear" => 0_i64,
14 | "activeMonth" => 0_i64,
15 | },
16 | },
17 | "metadata" => {
18 | "updatedAt" => Time.utc.to_unix,
19 | "lastChannelRefreshedAt" => 0_i64,
20 | },
21 |
22 | #
23 | # "totalRequests" => 0_i64,
24 | # "successfulRequests" => 0_i64
25 | # "ratio" => 0_i64
26 | #
27 | "playback" => {} of String => Int64 | Float64,
28 | }
29 |
30 | private getter db : DB::Database
31 |
32 | def initialize(@db, @software_config : Hash(String, String))
33 | end
34 |
35 | def begin
36 | load_initial_stats
37 |
38 | loop do
39 | refresh_stats
40 | sleep 10.minute
41 | Fiber.yield
42 | end
43 | end
44 |
45 | # should only be called once at the very beginning
46 | private def load_initial_stats
47 | STATISTICS["software"] = {
48 | "name" => @software_config["name"],
49 | "version" => @software_config["version"],
50 | "branch" => @software_config["branch"],
51 | }
52 | STATISTICS["openRegistrations"] = CONFIG.registration_enabled
53 | end
54 |
55 | private def refresh_stats
56 | users = STATISTICS.dig("usage", "users").as(Hash(String, Int64))
57 |
58 | users["total"] = Invidious::Database::Statistics.count_users_total
59 | users["activeHalfyear"] = Invidious::Database::Statistics.count_users_active_6m
60 | users["activeMonth"] = Invidious::Database::Statistics.count_users_active_1m
61 |
62 | STATISTICS["metadata"] = {
63 | "updatedAt" => Time.utc.to_unix,
64 | "lastChannelRefreshedAt" => Invidious::Database::Statistics.channel_last_update.try &.to_unix || 0_i64,
65 | }
66 |
67 | # Reset playback requests tracker
68 | STATISTICS["playback"] = {} of String => Int64 | Float64
69 | end
70 | end
71 |
--------------------------------------------------------------------------------
/src/invidious/jobs/subscribe_to_feeds_job.cr:
--------------------------------------------------------------------------------
1 | class Invidious::Jobs::SubscribeToFeedsJob < Invidious::Jobs::BaseJob
2 | private getter db : DB::Database
3 | private getter hmac_key : String
4 |
5 | def initialize(@db, @hmac_key)
6 | end
7 |
8 | def begin
9 | max_fibers = 1
10 | if CONFIG.use_pubsub_feeds.is_a?(Int32)
11 | max_fibers = CONFIG.use_pubsub_feeds.as(Int32)
12 | end
13 |
14 | active_fibers = 0
15 | active_channel = ::Channel(Bool).new
16 |
17 | loop do
18 | db.query_all("SELECT id FROM channels WHERE CURRENT_TIMESTAMP - subscribed > interval '4 days' OR subscribed IS NULL") do |rs|
19 | rs.each do
20 | ucid = rs.read(String)
21 |
22 | if active_fibers >= max_fibers.as(Int32)
23 | if active_channel.receive
24 | active_fibers -= 1
25 | end
26 | end
27 |
28 | active_fibers += 1
29 |
30 | spawn do
31 | begin
32 | response = subscribe_pubsub(ucid, hmac_key)
33 |
34 | if response.status_code >= 400
35 | LOGGER.error("SubscribeToFeedsJob: #{ucid} : #{response.body}")
36 | end
37 | rescue ex
38 | LOGGER.error("SubscribeToFeedsJob: #{ucid} : #{ex.message}")
39 | end
40 |
41 | active_channel.send(true)
42 | end
43 | end
44 | end
45 |
46 | sleep 1.minute
47 | Fiber.yield
48 | end
49 | end
50 | end
51 |
--------------------------------------------------------------------------------
/src/invidious/jsonify/api_v1/common.cr:
--------------------------------------------------------------------------------
1 | require "json"
2 |
3 | module Invidious::JSONify::APIv1
4 | extend self
5 |
6 | def thumbnails(json : JSON::Builder, id : String)
7 | json.array do
8 | build_thumbnails(id).each do |thumbnail|
9 | json.object do
10 | json.field "quality", thumbnail[:name]
11 | json.field "url", "#{thumbnail[:host]}/vi/#{id}/#{thumbnail["url"]}.jpg"
12 | json.field "width", thumbnail[:width]
13 | json.field "height", thumbnail[:height]
14 | end
15 | end
16 | end
17 | end
18 | end
19 |
--------------------------------------------------------------------------------
/src/invidious/routes/api/v1/feeds.cr:
--------------------------------------------------------------------------------
1 | module Invidious::Routes::API::V1::Feeds
2 | def self.trending(env)
3 | locale = env.get("preferences").as(Preferences).locale
4 |
5 | env.response.content_type = "application/json"
6 |
7 | region = env.params.query["region"]?
8 | trending_type = env.params.query["type"]?
9 |
10 | begin
11 | trending, plid = fetch_trending(trending_type, region, locale)
12 | rescue ex
13 | return error_json(500, ex)
14 | end
15 |
16 | videos = JSON.build do |json|
17 | json.array do
18 | trending.each do |video|
19 | video.to_json(locale, json)
20 | end
21 | end
22 | end
23 |
24 | videos
25 | end
26 |
27 | def self.popular(env)
28 | locale = env.get("preferences").as(Preferences).locale
29 |
30 | env.response.content_type = "application/json"
31 |
32 | if !CONFIG.popular_enabled
33 | error_message = {"error" => "Administrator has disabled this endpoint."}.to_json
34 | haltf env, 403, error_message
35 | end
36 |
37 | JSON.build do |json|
38 | json.array do
39 | popular_videos.each do |video|
40 | video.to_json(locale, json)
41 | end
42 | end
43 | end
44 | end
45 | end
46 |
--------------------------------------------------------------------------------
/src/invidious/routes/api/v1/search.cr:
--------------------------------------------------------------------------------
1 | module Invidious::Routes::API::V1::Search
2 | def self.search(env)
3 | locale = env.get("preferences").as(Preferences).locale
4 | region = env.params.query["region"]?
5 |
6 | env.response.content_type = "application/json"
7 |
8 | query = Invidious::Search::Query.new(env.params.query, :regular, region)
9 |
10 | begin
11 | search_results = query.process
12 | rescue ex
13 | return error_json(400, ex)
14 | end
15 |
16 | JSON.build do |json|
17 | json.array do
18 | search_results.each do |item|
19 | item.to_json(locale, json)
20 | end
21 | end
22 | end
23 | end
24 |
25 | def self.search_suggestions(env)
26 | preferences = env.get("preferences").as(Preferences)
27 | region = env.params.query["region"]? || preferences.region
28 |
29 | env.response.content_type = "application/json"
30 |
31 | query = env.params.query["q"]? || ""
32 |
33 | begin
34 | client = make_client(URI.parse("https://suggestqueries-clients6.youtube.com"), force_youtube_headers: true)
35 | url = "/complete/search?client=youtube&hl=en&gl=#{region}&q=#{URI.encode_www_form(query)}&gs_ri=youtube&ds=yt"
36 |
37 | response = client.get(url).body
38 | client.close
39 |
40 | body = JSON.parse(response[19..-2]).as_a
41 | suggestions = body[1].as_a[0..-2]
42 |
43 | JSON.build do |json|
44 | json.object do
45 | json.field "query", body[0].as_s
46 | json.field "suggestions" do
47 | json.array do
48 | suggestions.each do |suggestion|
49 | json.string suggestion[0].as_s
50 | end
51 | end
52 | end
53 | end
54 | end
55 | rescue ex
56 | return error_json(500, ex)
57 | end
58 | end
59 |
60 | def self.hashtag(env)
61 | hashtag = env.params.url["hashtag"]
62 |
63 | page = env.params.query["page"]?.try &.to_i? || 1
64 |
65 | locale = env.get("preferences").as(Preferences).locale
66 | region = env.params.query["region"]?
67 | env.response.content_type = "application/json"
68 |
69 | begin
70 | results = Invidious::Hashtag.fetch(hashtag, page, region)
71 | rescue ex
72 | return error_json(400, ex)
73 | end
74 |
75 | JSON.build do |json|
76 | json.object do
77 | json.field "results" do
78 | json.array do
79 | results.each do |item|
80 | item.to_json(locale, json)
81 | end
82 | end
83 | end
84 | end
85 | end
86 | end
87 | end
88 |
--------------------------------------------------------------------------------
/src/invidious/routes/errors.cr:
--------------------------------------------------------------------------------
1 | module Invidious::Routes::ErrorRoutes
2 | def self.error_404(env)
3 | # Workaround for #3117
4 | if HOST_URL.empty? && env.request.path.starts_with?("/v1/storyboards/sb")
5 | return env.redirect "#{env.request.path[15..]}?#{env.params.query}"
6 | end
7 |
8 | if md = env.request.path.match(/^\/(?
28 | END_HTML
29 | end
30 |
31 | html << <<-END_HTML
32 |
44 | 33 | [ − ] 34 | #{child.author} 35 | #{translate_count(locale, "comments_points_count", child.score, NumberFormatting::Separator)} 36 | #{translate(locale, "`x` ago", recode_date(child.created_utc, locale))} 37 | #{translate(locale, "permalink")} 38 |
39 |
40 | #{body_html}
41 | #{replies_html}
42 |
43 |
7 |
8 |
24 |
25 |
32 |
33 |
34 |
35 | <%= rendered "components/items_paginated" %>
36 |
--------------------------------------------------------------------------------
/src/invidious/views/channel.ecr:
--------------------------------------------------------------------------------
1 | <%-
2 | ucid = channel.ucid
3 | author = HTML.escape(channel.author)
4 | channel_profile_pic = URI.parse(channel.author_thumbnail).request_target
5 |
6 | relative_url =
7 | case selected_tab
8 | when .shorts? then "/channel/#{ucid}/shorts"
9 | when .streams? then "/channel/#{ucid}/streams"
10 | when .playlists? then "/channel/#{ucid}/playlists"
11 | when .channels? then "/channel/#{ucid}/channels"
12 | when .podcasts? then "/channel/#{ucid}/podcasts"
13 | when .releases? then "/channel/#{ucid}/releases"
14 | when .courses? then "/channel/#{ucid}/courses"
15 | else
16 | "/channel/#{ucid}"
17 | end
18 |
19 | youtube_url = "https://www.youtube.com#{relative_url}"
20 | redirect_url = Invidious::Frontend::Misc.redirect_url(env)
21 |
22 | page_nav_html = IV::Frontend::Pagination.nav_ctoken(locale,
23 | base_url: relative_url,
24 | ctoken: next_continuation,
25 | first_page: continuation.nil?,
26 | params: env.params.query,
27 | )
28 | %>
29 |
30 | <% content_for "header" do %>
31 | <%- if selected_tab.videos? -%>
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 | <%- end -%>
45 |
46 |
47 |
48 |
49 |
9 |
22 |
23 |
10 |
20 |
21 |
55 |
56 |
57 |
58 |
59 | <%= rendered "components/items_paginated" %>
60 |
--------------------------------------------------------------------------------
/src/invidious/views/community.ecr:
--------------------------------------------------------------------------------
1 | <%-
2 | ucid = channel.ucid
3 | author = HTML.escape(channel.author)
4 | channel_profile_pic = URI.parse(channel.author_thumbnail).request_target
5 |
6 | relative_url = "/channel/#{ucid}/community"
7 | youtube_url = "https://www.youtube.com#{relative_url}"
8 | redirect_url = Invidious::Frontend::Misc.redirect_url(env)
9 |
10 | selected_tab = Invidious::Frontend::ChannelPage::TabsAvailable::Posts
11 | -%>
12 |
13 | <% content_for "header" do %>
14 |
15 | 56 |
21 |
22 |
23 |
24 | <% if error_message %>
25 | 22 |
26 |
28 | <% else %>
29 | <%= error_message %>
27 |
30 | <%= IV::Frontend::Comments.template_youtube(items.not_nil!, locale, thin_mode) %>
31 |
32 | <% end %>
33 |
34 |
46 |
47 |
--------------------------------------------------------------------------------
/src/invidious/views/components/channel_info.ecr:
--------------------------------------------------------------------------------
1 | <% if channel.banner %>
2 |
3 | 
" alt="" />
4 |
5 |
6 | " alt="" />
4 |
7 |
8 |
9 | <% end %>
10 |
11 | 8 |
12 |
32 |
33 |
13 |
18 |
19 |
31 |
14 | 
15 | <%= author %><% if !channel.verified.nil? && channel.verified %> <% end %>
16 |
17 |
15 | <%= author %><% if !channel.verified.nil? && channel.verified %> <% end %>
16 |
34 |
35 |
36 |
37 | <%= channel.description_html %>
38 |
62 |
--------------------------------------------------------------------------------
/src/invidious/views/components/feed_menu.ecr:
--------------------------------------------------------------------------------
1 |
12 |
--------------------------------------------------------------------------------
/src/invidious/views/components/items_paginated.ecr:
--------------------------------------------------------------------------------
1 | <%= page_nav_html %>
2 |
3 |
39 |
42 |
45 |
46 | <%= Invidious::Frontend::ChannelPage.generate_tabs_links(locale, channel, selected_tab) %>
47 |
48 |
49 |
61 |
50 | <% sort_options.each do |sort| %>
51 |
60 |
52 | <% if sort_by == sort %>
53 | <%= translate(locale, sort) %>
54 | <% else %>
55 | <%= translate(locale, sort) %>
56 | <% end %>
57 |
58 | <% end %>
59 |
4 | <%- items.each do |item| -%>
5 | <%= rendered "components/item" %>
6 | <%- end -%>
7 |
8 |
9 | <%= page_nav_html %>
10 |
11 |
20 |
21 |
22 |
--------------------------------------------------------------------------------
/src/invidious/views/components/player_sources.ecr:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 | <% if params.annotations %>
19 |
20 |
21 | <% end %>
22 |
23 | <% if params.listen || params.quality != "dash" %>
24 |
25 |
26 | <% end %>
27 |
28 | <% if !params.listen && params.vr_mode %>
29 |
30 |
31 | <% end %>
32 |
--------------------------------------------------------------------------------
/src/invidious/views/components/search_box.ecr:
--------------------------------------------------------------------------------
1 |
13 |
--------------------------------------------------------------------------------
/src/invidious/views/components/subscribe_widget.ecr:
--------------------------------------------------------------------------------
1 | <% if user %>
2 | <% if subscriptions.includes? ucid %>
3 |
9 | <% else %>
10 |
16 | <% end %>
17 |
18 |
30 |
31 | <% else %>
32 | ">
34 | <%= translate(locale, "Subscribe") %> | <%= sub_count_text %>
35 |
36 | <% end %>
37 |
--------------------------------------------------------------------------------
/src/invidious/views/components/video-context-buttons.ecr:
--------------------------------------------------------------------------------
1 |
2 |
21 |
--------------------------------------------------------------------------------
/src/invidious/views/create_playlist.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
6 |
7 |
40 |
--------------------------------------------------------------------------------
/src/invidious/views/delete_playlist.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
8 |
38 |
39 |
9 |
36 |
37 |
6 |
24 |
25 |
--------------------------------------------------------------------------------
/src/invidious/views/edit_playlist.ecr:
--------------------------------------------------------------------------------
1 | <% title = HTML.escape(playlist.title) %>
2 |
3 | <% content_for "header" do %>
4 |
56 |
57 |
58 |
59 |
60 | <%= rendered "components/items_paginated" %>
61 |
--------------------------------------------------------------------------------
/src/invidious/views/embed.ecr:
--------------------------------------------------------------------------------
1 |
2 | ">
3 |
4 |
5 |
6 |
7 |
8 | <%= rendered "components/player_sources" %>
9 |
10 |
11 |
12 |
13 | 57 |
6 | <%= error_message %>
7 | <%= next_steps %>
8 |
9 |
--------------------------------------------------------------------------------
/src/invidious/views/feeds/history.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
6 |
20 |
21 |
28 |
29 |
30 |
7 |
9 | <%= translate_count(locale, "generic_videos_count", user.watched.size, NumberFormatting::HtmlSpan) %>
8 |
10 |
14 | 11 | <%= translate_count(locale, "generic_subscriptions_count", user.subscriptions.size, NumberFormatting::HtmlSpan) %> 12 |
13 |
15 |
19 | 16 | <%= translate(locale, "Clear watch history") %> 17 |
18 |
31 | <% watched.each do |item| %>
32 |
52 |
53 | <%=
54 | IV::Frontend::Pagination.nav_numeric(locale,
55 | base_url: base_url,
56 | current_page: page,
57 | show_next: (watched.size >= max_results)
58 | )
59 | %>
60 |
--------------------------------------------------------------------------------
/src/invidious/views/feeds/playlists.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
33 |
50 | <% end %>
51 |
34 |
49 |
35 |
36 | 
37 |
38 |
39 |
46 |
47 |
48 |
37 |
38 |
39 |
46 |
8 |
24 |
25 |
9 |
11 | <%= translate(locale, "user_created_playlists", %(#{items_created.size})) %>
10 |
12 |
16 | 13 | "><%= translate(locale, "Create playlist") %> 14 |
15 |
17 |
23 | 18 | "> 19 | <%= translate(locale, "Import/export") %> 20 | 21 |
22 |
26 | <% items_created.each do |item| %>
27 | <%= rendered "components/item" %>
28 | <% end %>
29 |
30 |
31 |
32 |
36 |
37 |
33 |
35 | <%= translate(locale, "user_saved_playlists", %(#{items_saved.size})) %>
34 |
38 | <% items_saved.each do |item| %>
39 | <%= rendered "components/item" %>
40 | <% end %>
41 |
42 |
43 |
44 |
--------------------------------------------------------------------------------
/src/invidious/views/feeds/popular.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 | ">
3 |
15 | <% popular_videos.each do |item| %>
16 | <%= rendered "components/item" %>
17 | <% end %>
18 |
19 |
20 |
21 |
--------------------------------------------------------------------------------
/src/invidious/views/feeds/subscriptions.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
9 |
25 |
26 | <% if CONFIG.enable_user_notifications %>
27 |
28 |
10 |
14 | 11 | <%= translate(locale, "Manage subscriptions") %> 12 |
13 |
15 |
19 |
24 | 16 | <%= translate(locale, "Watch history") %> 17 |
18 |
34 |
35 |
36 | <% end %>
37 |
38 | 35 |
39 | <% notifications.each do |item| %>
40 | <%= rendered "components/item" %>
41 | <% end %>
42 |
43 |
44 | <% end %>
45 |
46 |
47 |
48 |
49 |
50 |
57 |
58 |
59 |
60 | 48 |
61 | <% videos.each do |item| %>
62 | <%= rendered "components/item" %>
63 | <% end %>
64 |
65 |
66 |
67 |
68 | <%=
69 | IV::Frontend::Pagination.nav_numeric(locale,
70 | base_url: base_url,
71 | current_page: page,
72 | show_next: ((videos.size + notifications.size) == max_results)
73 | )
74 | %>
75 |
--------------------------------------------------------------------------------
/src/invidious/views/feeds/trending.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 | ">
3 |
15 |
38 |
39 |
16 | <% if plid %>
17 |
18 | <%= translate(locale, "View as playlist") %>
19 |
20 | <% end %>
21 |
22 |
23 |
37 |
24 | <% {"Default", "Music", "Gaming", "Movies"}.each do |option| %>
25 |
36 |
26 | <% if trending_type == option %>
27 | <%= translate(locale, option) %>
28 | <% else %>
29 |
30 | <%= translate(locale, option) %>
31 |
32 | <% end %>
33 |
34 | <% end %>
35 |
40 |
41 |
42 |
43 | 41 |
44 | <% trending.each do |item| %>
45 | <%= rendered "components/item" %>
46 | <% end %>
47 |
48 |
49 |
50 |
--------------------------------------------------------------------------------
/src/invidious/views/hashtag.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 | 6 | 7 | 8 | <%= rendered "components/items_paginated" %> 9 | -------------------------------------------------------------------------------- /src/invidious/views/message.ecr: -------------------------------------------------------------------------------- 1 | <% content_for "header" do %> 2 | "> 3 |
11 | <%= message %> 12 |
13 | -------------------------------------------------------------------------------- /src/invidious/views/mix.ecr: -------------------------------------------------------------------------------- 1 | <% content_for "header" do %> 2 |
17 | <% mix.videos.each do |item| %>
18 | <%= rendered "components/item" %>
19 | <% end %>
20 |
21 |
--------------------------------------------------------------------------------
/src/invidious/views/post.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
6 |
12 | <% end %> 13 |
14 | 15 |
27 |
28 |
47 |
48 |
--------------------------------------------------------------------------------
/src/invidious/views/search.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
7 | <%= IV::Frontend::Comments.template_youtube(post_response.not_nil!, locale, thin_mode) %>
8 |
9 |
10 | <% if nojs %>
11 | 12 | <% end %> 13 |
14 | 15 |
16 | <% if nojs %>
17 | <%= comment_html %>
18 | <% else %>
19 |
24 | <% end %>
25 |
26 | 9 | 10 | 11 | <%- if items.empty? -%> 12 |
13 |
19 | <%- else -%>
20 | <%= rendered "components/items_paginated" %>
21 | <%- end -%>
22 |
--------------------------------------------------------------------------------
/src/invidious/views/search_homepage.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 | ">
3 |
14 | <%= translate(locale, "search_message_no_results") %>
15 | <%= translate(locale, "search_message_change_filters_or_query") %>
16 | <%= translate(locale, "search_message_use_another_instance", redirect_url) %> 17 |
18 | 15 | <%= translate(locale, "search_message_change_filters_or_query") %>
16 | <%= translate(locale, "search_message_use_another_instance", redirect_url) %> 17 |
12 |
21 |
--------------------------------------------------------------------------------
/src/invidious/views/user/change_password.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
13 |
15 |
16 |
19 |
20 | Invidious
14 |
6 |
7 |
33 |
--------------------------------------------------------------------------------
/src/invidious/views/user/clear_watch_history.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
8 |
31 |
32 |
9 |
29 |
30 |
6 |
24 |
25 |
--------------------------------------------------------------------------------
/src/invidious/views/user/delete_account.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
6 |
24 |
25 |
--------------------------------------------------------------------------------
/src/invidious/views/user/login.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
6 |
7 |
51 |
--------------------------------------------------------------------------------
/src/invidious/views/user/subscription_manager.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
8 |
49 |
50 |
9 | <% case account_type when %>
10 | <% else # "invidious" %>
11 |
46 | <% end %>
47 |
48 |
6 |
28 |
29 | <% subscriptions.each do |channel| %>
30 |
7 |
13 | 8 | 9 | <%= translate_count(locale, "generic_subscriptions_count", subscriptions.size, NumberFormatting::HtmlSpan) %> 10 | 11 |
12 |
14 |
20 | 15 | 16 | <%= translate(locale, "Watch history") %> 17 | 18 |
19 |
21 |
27 | 22 | 23 | <%= translate(locale, "Import/export") %> 24 | 25 |
26 |
31 |
50 | <% end %> 51 |
52 | <% end %>
53 |
--------------------------------------------------------------------------------
/src/invidious/views/user/token_manager.ecr:
--------------------------------------------------------------------------------
1 | <% content_for "header" do %>
2 |
32 |
47 |
48 | <% if subscriptions[-1].author != channel.author %>
49 |
33 |
37 |
38 | 34 | <%= HTML.escape(channel.author) %> 35 |
36 |
39 |
46 | 40 |
44 | 45 |50 | <% end %> 51 |
6 |
18 |
19 | <% tokens.each do |token| %>
20 |
7 |
11 |
12 | 8 | <%= translate_count(locale, "tokens_count", tokens.size, NumberFormatting::HtmlSpan) %> 9 |
10 |
13 |
17 | 14 | <%= translate(locale, "Preferences") %> 15 |
16 |
21 |
42 | <% end %> 43 |
44 | <% end %>
45 |
--------------------------------------------------------------------------------
/src/invidious/yt_backend/extractors_utils.cr:
--------------------------------------------------------------------------------
1 | # Extracts text from InnerTube response
2 | #
3 | # InnerTube can package text in three different formats
4 | # "runs": [
5 | # {"text": "something"},
6 | # {"text": "cont"},
7 | # ...
8 | # ]
9 | #
10 | # "SimpleText": "something"
11 | #
12 | # Or sometimes just none at all as with the data returned from
13 | # category continuations.
14 | #
15 | # In order to facilitate calling this function with `#[]?`:
16 | # A nil will be accepted. Of course, since nil cannot be parsed,
17 | # another nil will be returned.
18 | def extract_text(item : JSON::Any?) : String?
19 | if item.nil?
20 | return nil
21 | end
22 |
23 | if text_container = item["simpleText"]?
24 | return text_container.as_s
25 | elsif text_container = item["runs"]?
26 | return text_container.as_a.map(&.["text"].as_s).join("")
27 | else
28 | nil
29 | end
30 | end
31 |
32 | # Check if an "ownerBadges" or a "badges" element contains a verified badge.
33 | # There is currently two known types of verified badges:
34 | #
35 | # "ownerBadges": [{
36 | # "metadataBadgeRenderer": {
37 | # "icon": { "iconType": "CHECK_CIRCLE_THICK" },
38 | # "style": "BADGE_STYLE_TYPE_VERIFIED",
39 | # "tooltip": "Verified",
40 | # "accessibilityData": { "label": "Verified" }
41 | # }
42 | # }],
43 | #
44 | # "ownerBadges": [{
45 | # "metadataBadgeRenderer": {
46 | # "icon": { "iconType": "OFFICIAL_ARTIST_BADGE" },
47 | # "style": "BADGE_STYLE_TYPE_VERIFIED_ARTIST",
48 | # "tooltip": "Official Artist Channel",
49 | # "accessibilityData": { "label": "Official Artist Channel" }
50 | # }
51 | # }],
52 | #
53 | def has_verified_badge?(badges : JSON::Any?)
54 | return false if badges.nil?
55 |
56 | badges.as_a.each do |badge|
57 | style = badge.dig("metadataBadgeRenderer", "style").as_s
58 |
59 | return true if style == "BADGE_STYLE_TYPE_VERIFIED"
60 | return true if style == "BADGE_STYLE_TYPE_VERIFIED_ARTIST"
61 | end
62 |
63 | return false
64 | rescue ex
65 | LOGGER.debug("Unable to parse owner badges. Got exception: #{ex.message}")
66 | LOGGER.trace("Owner badges data: #{badges.to_json}")
67 |
68 | return false
69 | end
70 |
71 | # This function extracts SearchVideo items from a Category.
72 | # Categories are commonly returned in search results and trending pages.
73 | def extract_category(category : Category) : Array(SearchVideo)
74 | return category.contents.select(SearchVideo)
75 | end
76 |
77 | # :ditto:
78 | def extract_category(category : Category, &)
79 | category.contents.select(SearchVideo).each do |item|
80 | yield item
81 | end
82 | end
83 |
84 | def extract_selected_tab(tabs)
85 | # Extract the selected tab from the array of tabs Youtube returns
86 | return tabs.as_a.select(&.["tabRenderer"]?.try &.["selected"]?.try &.as_bool)[0]["tabRenderer"]
87 | end
88 |
--------------------------------------------------------------------------------
/videojs-dependencies.yml:
--------------------------------------------------------------------------------
1 | # Due to a 'video append of' error (see #3011), we're stuck on 7.12.1.
2 | video.js:
3 | version: 7.12.1
4 | shasum: 1d12eeb1f52e3679e8e4c987d9b9eb37e2247fa2
5 |
6 | videojs-contrib-quality-levels:
7 | version: 2.1.0
8 | shasum: 046e9e21ed01043f512b83a1916001d552457083
9 |
10 | videojs-http-source-selector:
11 | version: 1.1.6
12 | shasum: 073aadbea0106ba6c98d6b611094dbf8554ffa1f
13 |
14 | videojs-markers:
15 | version: 1.0.1
16 | shasum: d7f8d804253fd587813271f8db308a22b9f7df34
17 |
18 | videojs-mobile-ui:
19 | version: 0.6.1
20 | shasum: 0e146c4c481cbee0729cb5e162e558b455562cd0
21 |
22 | videojs-overlay:
23 | version: 2.1.4
24 | shasum: 5a103b25374dbb753eb87960d8360c2e8f39cc05
25 |
26 | videojs-share:
27 | version: 3.2.1
28 | shasum: 0a3024b981387b9d21c058c829760a72c14b8ceb
29 |
30 | videojs-vr:
31 | version: 1.8.0
32 | shasum: 7f2f07f760d8a329c615acd316e49da6ee8edd34
33 |
34 | videojs-vtt-thumbnails:
35 | version: 0.0.13
36 | shasum: d1e7d47f4ed80bb52f5fc4f4bad4bfc871f5970f
37 |
38 | # We're using iv-org's fork of videojs-quality-selector,
39 | # which isn't published on NPM, and doesn't have any
40 | # easy way of fetching the compiled variant.
41 | #
42 | # silvermine-videojs-quality-selector:
43 | # version: 1.1.2
44 | # shasum: 94033ff9ee52ba6da1263b97c9a74d5b3dfdf711
45 |
46 |
47 | # Ditto. Although this extension contains the complied variant in its git repo,
48 | # it lacks any sort of versioning. As such, the script will ignore it.
49 | #
50 | # videojs-youtube-annotations:
51 | # github: https://github.com/afrmtbl/videojs-youtube-annotations
52 |
53 |
54 |
55 |
--------------------------------------------------------------------------------
22 |
39 |
40 | <% if tokens[-1].try &.[:session]? != token[:session] %>
41 |
23 |
24 |
26 |
27 |
24 | <%= token[:session] %>
25 |
26 |
28 |
30 | <%= translate(locale, "`x` ago", recode_date(token[:issued], locale)) %>
29 |
31 |
38 | 32 |
36 | 37 |42 | <% end %> 43 |