242 lines
8.0 KiB
Perl
242 lines
8.0 KiB
Perl
package BurguillosInfo::Posts;
|
|
|
|
use v5.34.1;
|
|
|
|
use strict;
|
|
use warnings;
|
|
|
|
use feature 'signatures';
|
|
|
|
use Data::Dumper;
|
|
use MIME::Base64;
|
|
|
|
use BurguillosInfo::Categories;
|
|
|
|
use Const::Fast;
|
|
use Mojo::DOM;
|
|
use Path::Tiny;
|
|
use DateTime::Format::ISO8601;
|
|
use DateTime;
|
|
|
|
use BurguillosInfo::Preview;
|
|
|
|
const my $CURRENT_FILE => __FILE__;
|
|
const my $ROOT_PROJECT => path($CURRENT_FILE)->parent->parent->parent;
|
|
const my $PUBLIC_DIR => $ROOT_PROJECT->child('public');
|
|
const my $POSTS_DIR => $ROOT_PROJECT->child('content/posts');
|
|
|
|
my $cached_posts_by_category;
|
|
my $cached_posts_by_slug;
|
|
|
|
sub new {
|
|
return bless {}, shift;
|
|
}
|
|
|
|
sub _ReturnCacheFilter ( $self, $filters = 1 ) {
|
|
my %posts_by_category_filtered;
|
|
my %posts_by_slug_filtered;
|
|
my $iso8601 = DateTime::Format::ISO8601->new;
|
|
my $current_date = DateTime->now;
|
|
for my $category ( keys %$cached_posts_by_category ) {
|
|
for my $post ( @{ $cached_posts_by_category->{$category} } ) {
|
|
if ($filters) {
|
|
my $date_post;
|
|
eval { $date_post = $iso8601->parse_datetime( $post->{date} ); };
|
|
if ($@) {
|
|
print $@ . ': ' . Data::Dumper::Dumper $post;
|
|
}
|
|
if ( $date_post > $current_date ) {
|
|
next;
|
|
}
|
|
}
|
|
$posts_by_slug_filtered{ $post->{slug} } = $post;
|
|
$posts_by_category_filtered{ $category } //= [];
|
|
push @{ $posts_by_category_filtered{ $category } }, $post;
|
|
}
|
|
}
|
|
return ( \%posts_by_category_filtered, \%posts_by_slug_filtered );
|
|
}
|
|
|
|
sub _GeneratePostFromFile ( $self, $post_file ) {
|
|
warn "Bad file $post_file, omiting...", return
|
|
if !-f $post_file || $post_file !~ /\.xml$/;
|
|
my $dom = Mojo::DOM->new( $post_file->slurp_utf8 );
|
|
my $title = $dom->at(':root > title')->text
|
|
or die "Missing title at $post_file.";
|
|
my $author = $dom->at(':root > author')->text
|
|
or die "Missing author at $post_file.";
|
|
my $date = $dom->at(':root > date')->text
|
|
or die "Missing date at $post_file.";
|
|
my $ogdesc = $dom->at(':root > ogdesc')->text
|
|
or die "Missing ogdesc at $post_file";
|
|
my @categories = $dom->find(':root > category')->map('text')->each;
|
|
my $slug = $dom->at(':root > slug')->text
|
|
or die "Missing slug at $post_file.";
|
|
my $content_tag = $dom->at(':root > content')
|
|
or die "Missing content at $post_file.";
|
|
|
|
for my $tag ( $content_tag->children->each ) {
|
|
$tag->content( $tag->content =~ s/\n//gr );
|
|
}
|
|
if ( !scalar @categories ) {
|
|
die 'Missing category';
|
|
}
|
|
my $content = $content_tag->content;
|
|
my $pinned_node = $dom->at(':root > pinned');
|
|
my $image_element = $dom->at(':root > img');
|
|
my $image;
|
|
my $image_bottom_preview;
|
|
my $attributes = $self->_GetAttributes( $post_file, $dom );
|
|
|
|
my $pinned;
|
|
if ( defined $pinned_node ) {
|
|
$pinned = int( $pinned_node->text );
|
|
}
|
|
if ( defined $image_element ) {
|
|
$image = $image_element->attr->{src};
|
|
$image_bottom_preview = $image_element->attr->{'bottom-preview'};
|
|
}
|
|
|
|
my $last_modification_date_element =
|
|
$dom->at(':root > last_modification_date');
|
|
my $last_modification_date;
|
|
if ( defined $last_modification_date_element ) {
|
|
$last_modification_date = $last_modification_date_element->content;
|
|
}
|
|
|
|
return {
|
|
title => $title,
|
|
author => $author,
|
|
date => $date,
|
|
ogdesc => $ogdesc,
|
|
categories => [@categories],
|
|
category => $categories[0],
|
|
slug => $slug,
|
|
content => $content,
|
|
attributes => $attributes,
|
|
image_bottom_preview => $image_bottom_preview,
|
|
(
|
|
( defined $last_modification_date )
|
|
? ( last_modification_date => $last_modification_date )
|
|
: ()
|
|
),
|
|
( ( defined $image ) ? ( image => $image ) : () ),
|
|
(
|
|
( defined $pinned ) ? ( pinned => $pinned )
|
|
: ()
|
|
)
|
|
};
|
|
}
|
|
|
|
sub _GetAttributes ( $self, $post_file, $dom ) {
|
|
my $attributes_tag = $dom->at(':root > attributes');
|
|
my %attributes;
|
|
if ( defined $attributes_tag ) {
|
|
my @attribute_list =
|
|
$attributes_tag->find('attributes > attribute')->map('text')->each;
|
|
%attributes = map {
|
|
my $identifier = $_;
|
|
( $identifier => 1 );
|
|
} @attribute_list;
|
|
}
|
|
return \%attributes;
|
|
|
|
}
|
|
|
|
sub _GeneratePostCache ($self) {
|
|
$cached_posts_by_category = {};
|
|
$cached_posts_by_slug = {};
|
|
for my $post_file ( sort { $b cmp $a } $POSTS_DIR->children ) {
|
|
my $post = $self->_GeneratePostFromFile($post_file);
|
|
if ( !defined $post ) {
|
|
next;
|
|
}
|
|
my $categories = $post->{categories};
|
|
for my $category ($post->{categories}->@*) {
|
|
$cached_posts_by_category->{$category} //= [];
|
|
my $slug = $post->{slug};
|
|
my $category_posts = $cached_posts_by_category->{$category};
|
|
$cached_posts_by_slug->{$slug} = $post;
|
|
push @$category_posts, $post;
|
|
}
|
|
}
|
|
}
|
|
|
|
sub Retrieve ( $self, $filters = 1 ) {
|
|
if ( defined $cached_posts_by_category && defined $cached_posts_by_slug ) {
|
|
return $self->_ReturnCacheFilter($filters);
|
|
}
|
|
$self->_GeneratePostCache();
|
|
return $self->_ReturnCacheFilter($filters);
|
|
}
|
|
|
|
my $cache_all_post_categories = {};
|
|
|
|
sub RetrieveAllPostsForCategory ( $self, $category_name ) {
|
|
my $categories = BurguillosInfo::Categories->new->Retrieve;
|
|
my $category = $categories->{$category_name};
|
|
if ( defined $cache_all_post_categories->{$category_name} ) {
|
|
my $posts = $cache_all_post_categories->{$category_name};
|
|
return $self->shufflePostsIfRequired( $category, $posts );
|
|
}
|
|
my $posts = $self->RetrieveDirectPostsForCategory($category_name);
|
|
for my $child_category ( $category->{children}->@* ) {
|
|
my $child_category_name = $child_category->{slug};
|
|
push @$posts,
|
|
@{ $self->RetrieveDirectPostsForCategory($child_category_name) };
|
|
}
|
|
@$posts = sort {
|
|
DateTime::Format::ISO8601->parse_datetime( $b->{date} )
|
|
<=> DateTime::Format::ISO8601->parse_datetime( $a->{date} )
|
|
} @$posts;
|
|
$cache_all_post_categories->{$category_name} = $posts;
|
|
return $self->shufflePostsIfRequired( $category, $posts );
|
|
}
|
|
|
|
sub comparePinned ( $self, $a, $b ) {
|
|
my $cmp = $b->{pinned} <=> $a->{pinned};
|
|
if ( $cmp != 0 ) {
|
|
return $cmp;
|
|
}
|
|
return int( rand(3) ) - 1;
|
|
}
|
|
|
|
sub shufflePostsIfRequired ( $self, $category, $posts ) {
|
|
my $pinned_posts = [
|
|
sort { $self->comparePinned( $a, $b ) }
|
|
grep { defined $_->{pinned} } @$posts
|
|
];
|
|
$posts = [ grep { !exists $_->{pinned} } @$posts ];
|
|
if ( exists $category->{random} && $category->{random} ) {
|
|
require List::AllUtils;
|
|
$posts = [ List::AllUtils::shuffle @$posts ];
|
|
}
|
|
return [ @$pinned_posts, @$posts ];
|
|
}
|
|
|
|
sub RetrieveDirectPostsForCategory ( $self, $category_name ) {
|
|
my ($post_by_category) = $self->Retrieve;
|
|
my $categories = BurguillosInfo::Categories->new->Retrieve;
|
|
my $category = $categories->{$category_name};
|
|
if ( !defined $category ) {
|
|
die "$category_name category does not exists";
|
|
}
|
|
my $posts = $post_by_category->{$category_name};
|
|
$posts //= [];
|
|
return $self->shufflePostsIfRequired( $category, [@$posts] );
|
|
}
|
|
|
|
sub PreviewOg ( $self, $post, $isWhatsApp ) {
|
|
my $title = $post->{title};
|
|
my $content = $post->{content};
|
|
my $image_file = $post->{image};
|
|
my $image_bottom_preview = $post->{image_bottom_preview};
|
|
if ($isWhatsApp) {
|
|
return BurguillosInfo::Preview->WhatsappAlternativeGenerate( $title,
|
|
$content, $image_file, $image_bottom_preview );
|
|
}
|
|
return BurguillosInfo::Preview->Generate( $title, $content, $image_file,
|
|
$image_bottom_preview );
|
|
}
|
|
1;
|