mirror of
https://github.com/euzu/tuliprox.git
synced 2026-10-20 06:42:20 +02:00
590 lines
24 KiB
Rust
590 lines
24 KiB
Rust
use crate::model::Epg;
|
|
use crate::model::{EpgConfig, EpgSmartMatchConfig};
|
|
use crate::model::FetchedPlaylist;
|
|
use crate::processing::parser::xmltv::normalize_channel_name;
|
|
use crate::utils::with_folded_epg_id;
|
|
use log::{debug, trace, warn};
|
|
use rphonetic::{DoubleMetaphone, Encoder};
|
|
use std::collections::{HashMap, HashSet};
|
|
use shared::model::{EpgSmartMatchConfigDto, PlaylistItem, XtreamCluster};
|
|
use std::sync::Arc;
|
|
use shared::utils::Internable;
|
|
|
|
pub struct EpgIdCache {
|
|
/// Membership set of the epg ids collected from playlist channels.
|
|
/// Keys are stored ASCII-lowercased so guide-id matching is case-insensitive.
|
|
/// This set is used only for membership tests, never to source an emitted/display
|
|
/// id, so folding the stored key does not affect output (channels keep their
|
|
/// original-case id). Insert via [`Self::insert_channel_epg_id`] and query via
|
|
/// [`Self::contains_channel_epg_id`] to keep the fold consistent.
|
|
pub channel_epg_id: HashSet<Arc<str>>,
|
|
pub normalized: HashMap<Arc<str>, Option<Arc<str>>>,
|
|
pub phonetics: HashMap<Arc<str>, HashSet<Arc<str>>>,
|
|
pub processed: HashSet<Arc<str>>,
|
|
pub smart_match_config: EpgSmartMatchConfig,
|
|
pub metaphone: DoubleMetaphone,
|
|
pub smart_match_enabled: bool, // smart match is enabled, normalizing names
|
|
pub fuzzy_match_enabled: bool, // fuzzy matching enabled
|
|
}
|
|
|
|
impl EpgIdCache {
|
|
/// Creates a new `EpgIdCache` with configuration for smart and fuzzy matching.
|
|
///
|
|
/// Initializes all internal caches and sets matching options based on the provided EPG configuration. If no configuration is given, defaults are used.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let cache = EpgIdCache::new(None);
|
|
/// assert!(cache.is_empty());
|
|
/// ```
|
|
pub fn new(epg_config: Option<&EpgConfig>) -> Self {
|
|
let normalize_config: EpgSmartMatchConfig = epg_config
|
|
.and_then(|cfg| cfg.smart_match.clone())
|
|
.unwrap_or_else(|| EpgSmartMatchConfigDto::default().into());
|
|
|
|
EpgIdCache {
|
|
channel_epg_id: HashSet::new(), // contains the epg_ids collected from playlist channels
|
|
normalized: HashMap::new(),
|
|
phonetics: HashMap::new(),
|
|
processed: HashSet::new(),
|
|
metaphone: DoubleMetaphone::default(),
|
|
smart_match_enabled: normalize_config.enabled,
|
|
fuzzy_match_enabled: normalize_config.enabled && normalize_config.fuzzy_matching,
|
|
smart_match_config: normalize_config,
|
|
|
|
}
|
|
}
|
|
|
|
fn is_empty(&self) -> bool {
|
|
self.channel_epg_id.is_empty() && self.normalized.is_empty()
|
|
}
|
|
|
|
/// Adds an epg id to the case-folded membership set.
|
|
///
|
|
/// The key is ASCII-lowercased so a `MixedCase` source id matches a guide
|
|
/// `<channel id>` of a different case. ASCII folding (not Unicode) avoids
|
|
/// Turkish-i/locale issues and is faster; channel ids are ASCII.
|
|
pub fn insert_channel_epg_id(&mut self, id: &str) {
|
|
with_folded_epg_id(id, |folded| self.channel_epg_id.insert(folded.intern()));
|
|
}
|
|
|
|
/// Case-insensitive (ASCII) membership test against the folded keys stored by
|
|
/// [`Self::insert_channel_epg_id`].
|
|
pub fn contains_channel_epg_id(&self, id: &str) -> bool {
|
|
with_folded_epg_id(id, |folded| self.channel_epg_id.contains(folded))
|
|
}
|
|
|
|
pub fn insert_processed_epg_id(&mut self, id: &str) {
|
|
with_folded_epg_id(id, |folded| self.processed.insert(folded.intern()));
|
|
}
|
|
|
|
pub fn contains_processed_epg_id(&self, id: &str) -> bool {
|
|
with_folded_epg_id(id, |folded| self.processed.contains(folded))
|
|
}
|
|
|
|
/// Normalizes a channel name, computes its phonetic encoding, and stores both in the cache for later EPG matching.
|
|
///
|
|
/// The normalized name is mapped to the provided EPG ID (if any), and the phonetic encoding is added to the phonetics map.
|
|
/// This facilitates efficient lookup and fuzzy matching of channel names during EPG assignment.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let mut cache = EpgIdCache::new(None);
|
|
/// cache.normalize_and_store("Discovery Channel", Some(&"discovery.epg".to_string()));
|
|
/// assert!(cache.normalized.contains_key(&cache.normalize("Discovery Channel")));
|
|
/// ```
|
|
fn normalize_and_store(&mut self, name: &str, epg_id: Option<&Arc<str>>) {
|
|
self.insert_normalized(name);
|
|
|
|
if let Some(chan_epg_id) = epg_id {
|
|
self.insert_normalized(chan_epg_id);
|
|
}
|
|
}
|
|
fn insert_normalized(&mut self, key: &str) {
|
|
let normalized = self.normalize(key).intern();
|
|
let phonetic = self.phonetic(&normalized);
|
|
|
|
self.normalized.insert(normalized.clone(), None);
|
|
self.phonetics
|
|
.entry(phonetic.clone())
|
|
.or_default()
|
|
.insert(normalized);
|
|
}
|
|
|
|
/// Returns the normalized form of a channel name using the configured smart match settings.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let cache = EpgIdCache::new(None);
|
|
/// let normalized = cache.normalize("HBO HD");
|
|
/// assert!(!normalized.is_empty());
|
|
/// ```
|
|
fn normalize(&self, name: &str) -> String {
|
|
normalize_channel_name(name, &self.smart_match_config)
|
|
}
|
|
|
|
pub(crate) fn phonetic(&self, name: &Arc<str>) -> Arc<str> {
|
|
let result = self.metaphone.encode(name);
|
|
if result.is_empty() {
|
|
name.clone()
|
|
} else {
|
|
result.intern()
|
|
}
|
|
}
|
|
|
|
pub fn collect_epg_id(&mut self, fp: &mut FetchedPlaylist) {
|
|
let smart_match_enabled = self.smart_match_enabled;
|
|
let fuzzy_matching = self.fuzzy_match_enabled;
|
|
|
|
// Helper closure to process a single item
|
|
// We use a closure here to capture `self` and avoid code duplication
|
|
let mut process_item = |name: &str, epg_channel_id: Option<&Arc<str>>| {
|
|
let mut missing_epg_id = true;
|
|
// insert epg_id to known channel epg_ids
|
|
if let Some(id) = epg_channel_id {
|
|
if !id.is_empty() {
|
|
missing_epg_id = false;
|
|
self.insert_channel_epg_id(id);
|
|
}
|
|
}
|
|
|
|
// for fuzzy_matching we need to put the normalized name even if there is an epg_id, because the epg_id
|
|
// could not match to the epg file. And then we try to guess it based on normalized name
|
|
let needs_normalization = smart_match_enabled && (fuzzy_matching || missing_epg_id);
|
|
|
|
if needs_normalization {
|
|
self.normalize_and_store(name, epg_channel_id);
|
|
}
|
|
};
|
|
|
|
for channel in fp.items() {
|
|
if channel.header.xtream_cluster == XtreamCluster::Live && channel.header.item_type.is_live() {
|
|
process_item(&channel.header.name, channel.header.epg_channel_id.as_ref());
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn match_with_normalized(&mut self, epg_id: &Arc<str>, normalized_epg_ids: &[Arc<str>]) -> bool {
|
|
for key in normalized_epg_ids {
|
|
if let Some(entry) = self.normalized.get_mut(key) {
|
|
entry.replace(Arc::clone(epg_id));
|
|
// Inline fold (mirrors `insert_channel_epg_id`); a `&mut self` call
|
|
// here would conflict with the `entry` borrow of `self.normalized`.
|
|
with_folded_epg_id(epg_id, |folded| self.channel_epg_id.insert(folded.intern()));
|
|
return true;
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
pub fn normalize_candidates<I, S>(&self, candidates: I) -> Vec<Arc<str>>
|
|
where
|
|
I: IntoIterator<Item = S>,
|
|
S: AsRef<str>,
|
|
{
|
|
candidates
|
|
.into_iter()
|
|
.map(|candidate| candidate.as_ref().trim().to_string())
|
|
.filter(|candidate| !candidate.is_empty())
|
|
.map(|candidate| self.normalize(&candidate).intern())
|
|
.collect()
|
|
}
|
|
|
|
pub fn match_epg_channel_candidates(&mut self, epg_id: &Arc<str>, normalized_candidates: &[Arc<str>]) -> bool {
|
|
let mut matched = self.match_with_normalized(epg_id, normalized_candidates);
|
|
if !matched && self.fuzzy_match_enabled {
|
|
if let Some(key) = self.find_best_fuzzy_match_for_candidates(normalized_candidates) {
|
|
self.normalized.entry(key).and_modify(|entry| {
|
|
entry.replace(epg_id.clone());
|
|
with_folded_epg_id(epg_id, |folded| self.channel_epg_id.insert(folded.intern()));
|
|
matched = true;
|
|
});
|
|
}
|
|
}
|
|
matched
|
|
}
|
|
|
|
fn find_best_fuzzy_match_for_candidates(&self, normalized_candidates: &[Arc<str>]) -> Option<Arc<str>> {
|
|
let match_threshold = self.smart_match_config.match_threshold;
|
|
let best_match_threshold = self.smart_match_config.best_match_threshold;
|
|
let pre = normalized_candidates
|
|
.iter()
|
|
.map(|candidate| (candidate.clone(), self.phonetic(candidate)))
|
|
.collect::<Vec<_>>();
|
|
|
|
for (candidate, code) in &pre {
|
|
if let Some(keys) = self.phonetics.get(code) {
|
|
if let Some(good_enough) = keys.iter().find(|norm_key| {
|
|
let jw = strsim::jaro_winkler(norm_key, candidate);
|
|
#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
|
|
let score = ((jw * 100.0).round() as u16).min(100);
|
|
score >= best_match_threshold
|
|
}) {
|
|
return Some(good_enough.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
pre.iter()
|
|
.filter_map(|(candidate, code)| {
|
|
self.phonetics.get(code).and_then(|keys| {
|
|
keys.iter()
|
|
.map(|norm_key| {
|
|
let jw = strsim::jaro_winkler(norm_key, candidate);
|
|
#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
|
|
let score = ((jw * 100.0).round() as u16).min(100);
|
|
(score, norm_key)
|
|
})
|
|
.max_by_key(|(score, _)| *score)
|
|
})
|
|
})
|
|
.max_by_key(|(score, _)| *score)
|
|
.and_then(|(score, key)| (score >= match_threshold).then(|| key.clone()))
|
|
}
|
|
}
|
|
|
|
/// Assigns EPG IDs and logos to live playlist channels by matching them with EPG data.
|
|
///
|
|
/// For each live channel in the playlist missing an EPG ID, attempts to assign one using normalized name matching if smart matching is enabled. If a channel has an EPG ID but lacks logos, assigns logos from the corresponding EPG icon tags. Adds the matched EPG data to the provided vector.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let mut new_epg = Vec::new();
|
|
/// let mut playlist = FetchedPlaylist::default();
|
|
/// let mut id_cache = EpgIdCache::new(None);
|
|
/// assign_channel_epg(&mut new_epg, &mut playlist, &mut id_cache);
|
|
/// ```
|
|
async fn assign_channel_epg(new_epg: &mut Vec<Epg>, fp: &mut FetchedPlaylist<'_>, id_cache: &mut EpgIdCache) {
|
|
//id_cache.normalized.retain(|_, v| v.is_some());
|
|
if let Some(tv_guide) = &fp.epg {
|
|
if let Some((epg_source, icon_override_channels)) = tv_guide.filter_merged_with_icon_overrides(id_cache).await {
|
|
let mut icon_assigned = HashSet::new();
|
|
let icon_tags: HashMap<Arc<str>, &Arc<str>> = epg_source.children
|
|
.iter()
|
|
.filter_map(|tag| {
|
|
tag.icon.as_ref().filter(|icon| !icon.is_empty()).map(|icon| {
|
|
(with_folded_epg_id(&tag.id, |folded| folded.intern()), icon)
|
|
})
|
|
})
|
|
.collect();
|
|
let icon_override_channels = icon_override_channels
|
|
.into_iter()
|
|
.map(|id| with_folded_epg_id(&id, |folded| folded.intern()))
|
|
.collect::<HashSet<_>>();
|
|
|
|
let assign_values = |chan: &mut PlaylistItem| {
|
|
if id_cache.smart_match_enabled {
|
|
// id_cache.processed contains all epg_ids found in any xmltv source.
|
|
let not_found_in_epg = match &chan.header.epg_channel_id {
|
|
None => true,
|
|
Some(epg_id) => !id_cache.contains_processed_epg_id(epg_id),
|
|
};
|
|
if not_found_in_epg {
|
|
let try_match = |key: &str| {
|
|
let normalized = id_cache.normalize(key).intern();
|
|
id_cache.normalized.get(&normalized).and_then(|epg_id| {
|
|
epg_id.as_ref().map(|id| {
|
|
trace!("Matched channel {} to epg {id:?}", chan.header.name);
|
|
id.clone()
|
|
})
|
|
})
|
|
};
|
|
if let Some(new_id) =
|
|
try_match(&chan.header.name).or_else(|| chan.header.epg_channel_id.as_deref().and_then(try_match))
|
|
{
|
|
chan.header.epg_channel_id = Some(new_id);
|
|
}
|
|
}
|
|
}
|
|
if let Some(epg_channel_id) = chan.header.epg_channel_id.as_ref() {
|
|
with_folded_epg_id(epg_channel_id, |folded_epg_channel_id| {
|
|
if !icon_assigned.contains(folded_epg_channel_id) &&
|
|
(icon_override_channels.contains(folded_epg_channel_id) || chan.header.logo.is_empty() || chan.header.logo_small.is_empty()) {
|
|
if let Some(icon) = icon_tags.get(folded_epg_channel_id) {
|
|
icon_assigned.insert(folded_epg_channel_id.intern());
|
|
if icon_override_channels.contains(folded_epg_channel_id) || chan.header.logo.is_empty() {
|
|
trace!("Matched channel {} to epg icon {icon}", chan.header.name);
|
|
chan.header.logo = Arc::clone(icon);
|
|
}
|
|
if icon_override_channels.contains(folded_epg_channel_id) || chan.header.logo_small.is_empty() {
|
|
chan.header.logo_small = Arc::clone(icon);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
let filter_live = |c: &&mut PlaylistItem| c.header.xtream_cluster == XtreamCluster::Live && c.header.item_type.is_live();
|
|
|
|
if fp.is_memory() {
|
|
fp.items_mut().filter(filter_live).for_each(assign_values);
|
|
} else {
|
|
warn!("Disk based playlist modification is not supported!");
|
|
}
|
|
|
|
new_epg.push(epg_source);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Processes a fetched playlist and assigns EPG data to its channels.
|
|
///
|
|
/// Collects EPG channel IDs from the playlist, initializes an EPG ID cache, and assigns EPG data to channels using normalization and smart matching if enabled. Logs a debug message if no EPG IDs are found and smart matching is disabled.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let mut playlist = FetchedPlaylist::default();
|
|
/// let mut epg_data = Vec::new();
|
|
/// process_playlist_epg(&mut playlist, &mut epg_data);
|
|
/// ```
|
|
pub async fn process_playlist_epg(fp: &mut FetchedPlaylist<'_>, epg: &mut Vec<Epg>) {
|
|
if fp.input.epg.is_none() {
|
|
return;
|
|
}
|
|
// collect all epg_channel ids
|
|
let mut id_cache = EpgIdCache::new(fp.input.epg.as_ref());
|
|
id_cache.collect_epg_id(fp);
|
|
|
|
if id_cache.is_empty() && !id_cache.smart_match_enabled {
|
|
debug!("No epg ids found for input {}", fp.input.name);
|
|
} else {
|
|
assign_channel_epg(epg, fp, &mut id_cache).await;
|
|
}
|
|
}
|
|
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::model::{
|
|
ConfigInput, EpgConfig, EpgSmartMatchConfig, FetchedPlaylist, IcsEpgSourceConfig, PersistedEpgSource,
|
|
PersistedEpgSourceKind, TVGuide,
|
|
};
|
|
use crate::repository::MemoryPlaylistSource;
|
|
use rand::distr::Alphanumeric;
|
|
use rand::Rng;
|
|
use rphonetic::{DoubleMetaphone, Encoder};
|
|
use shared::model::{ConfigInputDto, PlaylistGroup, PlaylistItemHeader, PlaylistItemType};
|
|
use shared::utils::Internable;
|
|
use std::{fs, sync::Arc};
|
|
use tempfile::tempdir;
|
|
use tokio::time::Instant;
|
|
|
|
fn random_string() -> String {
|
|
rand::rng()
|
|
.sample_iter(&Alphanumeric)
|
|
.take(30)
|
|
.map(char::from)
|
|
.collect()
|
|
}
|
|
|
|
fn write_ics_file(path: &std::path::Path) {
|
|
fs::write(
|
|
path,
|
|
"BEGIN:VCALENDAR\nBEGIN:VEVENT\nSUMMARY:Practice 1\nDTSTART:20260306T123000Z\nDTEND:20260306T133000Z\nEND:VEVENT\nEND:VCALENDAR",
|
|
)
|
|
.expect("write ics");
|
|
}
|
|
|
|
fn ics_tv_guide(path: std::path::PathBuf, match_names: Vec<Arc<str>>) -> TVGuide {
|
|
TVGuide::new(vec![PersistedEpgSource {
|
|
file_path: path,
|
|
priority: 0,
|
|
logo_override: false,
|
|
kind: PersistedEpgSourceKind::Ics {
|
|
channel_id: "f1.calendar".intern(),
|
|
channel_title: Some("Formula 1".intern()),
|
|
match_names,
|
|
config: Box::new(IcsEpgSourceConfig::default()),
|
|
},
|
|
}])
|
|
}
|
|
|
|
fn live_playlist_item(name: &str, epg_channel_id: Option<&str>) -> shared::model::PlaylistItem {
|
|
shared::model::PlaylistItem {
|
|
header: PlaylistItemHeader {
|
|
name: name.intern(),
|
|
epg_channel_id: epg_channel_id.map(Internable::intern),
|
|
xtream_cluster: super::XtreamCluster::Live,
|
|
item_type: PlaylistItemType::Live,
|
|
..PlaylistItemHeader::default()
|
|
},
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn channel_epg_id_membership_is_case_insensitive_ascii() {
|
|
let mut cache = super::EpgIdCache::new(None);
|
|
// Playlist epg ids stored MixedCase from different origins (Xtream source /
|
|
// mapper literal). Both go through the folding insert.
|
|
cache.insert_channel_epg_id("CNN.us");
|
|
cache.insert_channel_epg_id("BBC.One.UK");
|
|
|
|
// A guide <channel id> in any case matches the folded membership key.
|
|
assert!(cache.contains_channel_epg_id("cnn.US"));
|
|
assert!(cache.contains_channel_epg_id("CNN.US"));
|
|
assert!(cache.contains_channel_epg_id("cnn.us"));
|
|
assert!(cache.contains_channel_epg_id("bbc.one.uk"));
|
|
assert!(!cache.contains_channel_epg_id("unknown.tv"));
|
|
}
|
|
|
|
#[test]
|
|
fn assign_channel_epg_uses_case_insensitive_processed_and_icon_lookup() {
|
|
let runtime = tokio::runtime::Runtime::new().unwrap();
|
|
runtime.block_on(async move {
|
|
let dir = tempdir().unwrap();
|
|
let epg_path = dir.path().join("mixed-case-icon.xml");
|
|
|
|
fs::write(
|
|
&epg_path,
|
|
r#"<?xml version="1.0" encoding="UTF-8"?>
|
|
<tv>
|
|
<channel id="Demo.Channel">
|
|
<display-name>Demo</display-name>
|
|
<icon src="http://guide/icon.png" />
|
|
</channel>
|
|
<programme start="20260425000000 +0000" stop="20260425010000 +0000" channel="Demo.Channel">
|
|
<title>Demo Show</title>
|
|
</programme>
|
|
</tv>"#,
|
|
)
|
|
.unwrap();
|
|
|
|
let mut input = ConfigInput::from(ConfigInputDto::default());
|
|
input.epg = Some(EpgConfig { sources: vec![], smart_match: None });
|
|
let channel = shared::model::PlaylistItem {
|
|
header: PlaylistItemHeader {
|
|
name: "Demo".intern(),
|
|
epg_channel_id: Some("demo.channel".intern()),
|
|
logo: "http://old/icon.png".intern(),
|
|
logo_small: "".intern(),
|
|
xtream_cluster: super::XtreamCluster::Live,
|
|
item_type: PlaylistItemType::Live,
|
|
..PlaylistItemHeader::default()
|
|
},
|
|
};
|
|
let groups = vec![PlaylistGroup {
|
|
id: 1,
|
|
title: "Live".intern(),
|
|
channels: vec![channel],
|
|
xtream_cluster: super::XtreamCluster::Live,
|
|
}];
|
|
let tv_guide = TVGuide::new(vec![PersistedEpgSource {
|
|
file_path: epg_path,
|
|
priority: 0,
|
|
logo_override: true,
|
|
kind: PersistedEpgSourceKind::Xmltv,
|
|
}]);
|
|
let mut playlist = FetchedPlaylist {
|
|
input: &input,
|
|
source: MemoryPlaylistSource::new(groups).into_source(),
|
|
epg: Some(tv_guide),
|
|
};
|
|
let mut epg = Vec::new();
|
|
|
|
super::process_playlist_epg(&mut playlist, &mut epg).await;
|
|
|
|
let updated = playlist.items_mut().next().unwrap();
|
|
assert_eq!(updated.header.epg_channel_id.as_deref(), Some("demo.channel"));
|
|
assert_eq!(updated.header.logo.as_ref(), "http://guide/icon.png");
|
|
assert_eq!(updated.header.logo_small.as_ref(), "http://guide/icon.png");
|
|
assert_eq!(epg[0].children[0].id.as_ref(), "Demo.Channel");
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn playlist_item_with_ics_epg_channel_id_gets_ics_programmes() {
|
|
let runtime = tokio::runtime::Runtime::new().unwrap();
|
|
runtime.block_on(async move {
|
|
let dir = tempdir().unwrap();
|
|
let ics_path = dir.path().join("f1.ics");
|
|
write_ics_file(&ics_path);
|
|
|
|
let mut input = ConfigInput::from(ConfigInputDto::default());
|
|
input.epg = Some(EpgConfig { sources: vec![], smart_match: None });
|
|
let groups = vec![PlaylistGroup {
|
|
id: 1,
|
|
title: "Live".intern(),
|
|
channels: vec![live_playlist_item("Formula 1", Some("f1.calendar"))],
|
|
xtream_cluster: super::XtreamCluster::Live,
|
|
}];
|
|
let mut playlist = FetchedPlaylist {
|
|
input: &input,
|
|
source: MemoryPlaylistSource::new(groups).into_source(),
|
|
epg: Some(ics_tv_guide(ics_path, Vec::new())),
|
|
};
|
|
let mut epg = Vec::new();
|
|
|
|
super::process_playlist_epg(&mut playlist, &mut epg).await;
|
|
|
|
assert_eq!(epg.len(), 1);
|
|
assert_eq!(epg[0].children[0].id.as_ref(), "f1.calendar");
|
|
assert_eq!(epg[0].children[0].programmes.len(), 1);
|
|
assert_eq!(epg[0].children[0].programmes[0].title.as_deref(), Some("Practice 1"));
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn smart_match_uses_ics_channel_title_and_match_names() {
|
|
let runtime = tokio::runtime::Runtime::new().unwrap();
|
|
runtime.block_on(async move {
|
|
let dir = tempdir().unwrap();
|
|
let ics_path = dir.path().join("f1.ics");
|
|
write_ics_file(&ics_path);
|
|
|
|
let mut smart_dto = shared::model::EpgSmartMatchConfigDto {
|
|
enabled: true,
|
|
fuzzy_matching: false,
|
|
..shared::model::EpgSmartMatchConfigDto::default()
|
|
};
|
|
smart_dto.prepare().expect("smart config");
|
|
let mut input = ConfigInput::from(ConfigInputDto::default());
|
|
input.epg = Some(EpgConfig {
|
|
sources: vec![],
|
|
smart_match: Some(EpgSmartMatchConfig::from(smart_dto)),
|
|
});
|
|
let groups = vec![PlaylistGroup {
|
|
id: 1,
|
|
title: "Live".intern(),
|
|
channels: vec![live_playlist_item("F1", None)],
|
|
xtream_cluster: super::XtreamCluster::Live,
|
|
}];
|
|
let mut playlist = FetchedPlaylist {
|
|
input: &input,
|
|
source: MemoryPlaylistSource::new(groups).into_source(),
|
|
epg: Some(ics_tv_guide(ics_path, vec!["F1".intern()])),
|
|
};
|
|
let mut epg = Vec::new();
|
|
|
|
super::process_playlist_epg(&mut playlist, &mut epg).await;
|
|
|
|
let updated = playlist.items_mut().next().unwrap();
|
|
assert_eq!(updated.header.epg_channel_id.as_deref(), Some("f1.calendar"));
|
|
assert_eq!(epg[0].children[0].id.as_ref(), "f1.calendar");
|
|
assert_eq!(epg[0].children[0].programmes.len(), 1);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn test_phonetic() {
|
|
let strings: Vec<String> = (0..5_000)
|
|
.map(|_| random_string())
|
|
.collect();
|
|
|
|
let phonetic = DoubleMetaphone::new(Some(6));
|
|
|
|
let now = Instant::now();
|
|
for value in &strings {
|
|
let _ = phonetic.encode(value);
|
|
}
|
|
|
|
let elapsed = now.elapsed();
|
|
println!("Elapsed time: {}.{:03} secs", elapsed.as_secs(), elapsed.subsec_millis());
|
|
}
|
|
}
|