public function pool_list(Post $post)
{
$html = "";
$pools = Pool::where("pools_posts.post_id = {$post->id}")->joins("JOIN pools_posts ON pools_posts.pool_id = pools.id")->order("pools.name")->select("pools.name, pools.id")->take();
if ($pools->blank()) {
$html .= "none";
} else {
$html .= join(", ", array_map(function ($p) {
return $this->linkTo($this->h($p->pretty_name()), ["pool#show", 'id' => $p->id]);
}, $pools->members()));
}
return $html;
}
public function select()
{
if (current_user()->is_anonymous()) {
$this->pools = Pool::where("is_active = TRUE AND is_public = TRUE")->order("name")->take();
} else {
$this->pools = Pool::where("is_active = TRUE AND (is_public = TRUE OR user_id = ?)", current_user()->id)->order("name")->take();
}
$options = array('(000) DO NOT ADD' => 0);
foreach ($this->pools as $p) {
$options[str_replace('_', ' ', $p->name)] = $p->id;
}
$this->options = $options;
$this->last_pool_id = $this->session()->last_pool_id;
$this->setLayout(false);
}
public function import()
{
$import_dir = Rails::publicPath() . '/data/import/';
if ($this->request()->isPost()) {
if ($this->request()->format() == 'json') {
foreach (explode('::', $this->params()->dupes) as $file) {
$file = stripslashes(utf8_decode($file));
$file = $import_dir . $file;
if (file_exists($file)) {
unlink($file);
} else {
$error = true;
}
}
$resp = !empty($error) ? array('reason' => 'Some files could not be deleted') : array('success' => true);
$this->render(array('json' => $resp));
return;
}
$this->setLayout(false);
$this->errors = $this->dupe = false;
$post = $this->params()->post;
$post['filename'] = stripslashes(utf8_decode($post['filename']));
$filepath = $import_dir . $post['filename'];
# Take folders as tags
if (is_int(strpos($post['filename'], '/'))) {
$folders = str_replace('#', ':', $post['filename']);
$tags = array_filter(array_unique(array_merge(explode(' ', $post['tags']), explode('/', $folders))));
array_pop($tags);
$post['tags'] = trim($post['tags'] . ' ' . implode(' ', $tags));
}
$post = array_merge($post, array('ip_addr' => $this->request()->remoteIp(), 'user_id' => current_user()->id, 'status' => 'active', 'tempfile_path' => $filepath, 'tempfile_name' => $post['filename'], 'is_import' => true));
unset($post['filename'], $post['i']);
$this->post = Post::create($post);
if ($this->post->errors()->blank()) {
$this->import_status = 'Posted';
} elseif ($this->post->errors()->invalid('md5')) {
$this->dupe = true;
$this->import_status = 'Already exists';
$this->post = Post::where(['md5' => $this->post->md5])->first();
$this->post->status = 'flagged';
} else {
$this->errors = $this->post->errors()->fullMessages('<br />');
$this->import_status = 'Error';
}
} else {
$this->set_title('Import');
$this->invalid_files = $this->files = [];
list($this->files, $this->invalid_files, $this->invalid_folders) = Post::get_import_files($import_dir);
$pools = Pool::where('is_active')->take();
if ($pools) {
$this->pool_list = '<datalist id="pool_list">';
foreach ($pools as $pool) {
$this->pool_list .= '<option value="' . str_replace('_', ' ', $pool->name) . '" />';
}
$this->pool_list .= '</datalist>';
} else {
$this->pool_list = null;
}
}
}
/**
* It's strange how actions like changing pool's sequence, that updates the post via
* update_batch and sends only one metatag: 'pool:$id:$seq' and doesn't send old_tags, don't
* mess up the rest of the tags (because that metatag is discarted, and the post is left without
* old_tags or any tag).
* So we're gonna do a workaround for that: if the new tags only contain metatags, we won't
* take any further action but commit such metatags.
* We'll use $had_metatags for that.
*/
protected function commit_tags()
{
if ($this->isNewRecord() || !$this->new_tags) {
return;
}
if ($this->old_tags) {
# If someone else committed changes to this post before we did,
# then try to merge the tag changes together.
$current_tags = explode(' ', $this->cached_tags);
$this->old_tags = Tag::scan_tags($this->old_tags);
$this->new_tags = array_filter(array_merge(array_diff(array_merge($current_tags, $this->new_tags), $this->old_tags), array_intersect($current_tags, $this->new_tags)));
}
$this->commit_metatags();
$meta_tags = ['-pool:', 'pool:', 'rating:', 'parent:', 'child:', 'source:'];
$ratings = ['q', 's', 'e'];
$had_metatags = false;
foreach ($this->new_tags as $k => $tag) {
# To avoid preg_match.
$is_mt = false;
foreach ($meta_tags as $mt) {
if (strpos($tag, $mt) === 0 || in_array($tag, $ratings)) {
$is_mt = true;
break;
}
}
if (!$is_mt) {
continue;
}
$had_metatags = true;
unset($this->new_tags[$k]);
if (in_array($tag, $ratings)) {
$tag = 'rating:' . $tag;
}
$subparam = explode(':', $tag, 3);
$metatag = array_shift($subparam);
$param = array_shift($subparam);
$subparam = empty($subparam) ? null : array_shift($subparam);
switch ($metatag) {
case 'rating':
# Change rating. This will override rating selected on radio buttons.
if (in_array($param, $ratings)) {
$this->rating = $param;
}
break;
case 'pool':
try {
$name = $param;
$seq = $subparam;
# Workaround: I don't understand how can the pool be found when finding_by_name
# using the id.
if (ctype_digit($name)) {
$pool = Pool::where(['id' => $name])->first();
} else {
$pool = Pool::where(['name' => $name])->first();
}
# Set :ignore_already_exists, so pool:1:2 can be used to change the sequence number
# of a post that already exists in the pool.
$options = array('user' => User::where('id = ?', $this->updater_user_id)->first(), 'ignore_already_exists' => true);
if ($seq) {
$options['sequence'] = $seq;
}
if (!$pool and !ctype_digit($name)) {
$pool = Pool::create(array('name' => $name, 'is_public' => false, 'user_id' => $this->updater_user_id));
}
if (!$pool || !$pool->can_change(current_user(), null)) {
continue;
}
$pool->add_post($this->id, $options);
} catch (Pool_PostAlreadyExistsError $e) {
} catch (Pool_AccessDeniedError $e) {
}
break;
case '-pool':
$name = $param;
$cmd = $subparam;
$pool = Pool::where(['name' => $name])->first();
if (!$pool->can_change(current_user(), null)) {
break;
}
if ($cmd == "parent") {
# If we have a parent, remove ourself from the pool and add our parent in
# our place. If we have no parent, do nothing and leave us in the pool.
if (!empty($this->parent_id)) {
$pool->transfer_post_to_parent($this->id, $this->parent_id);
break;
}
}
$pool && $pool->remove_post($id);
break;
case 'source':
$this->source = $param;
break;
case 'parent':
if (is_numeric($param)) {
$this->parent_id = (int) $param;
}
break;
case 'child':
unset($this->new_tags[$k]);
break;
}
}
if (!$this->new_tags) {
if ($had_metatags) {
return;
}
$this->new_tags[] = "tagme";
}
// $this->tags = implode(' ', array_unique(TagImplication::with_implied(TagAlias::to_aliased($this->new_tags))));
$this->new_tags = TagAlias::to_aliased($this->new_tags);
$this->new_tags = array_unique(TagImplication::with_implied($this->new_tags));
sort($this->new_tags);
// $this->tags = implode(' ', $this->tags());
# TODO: be more selective in deleting from the join table
self::connection()->executeSql("DELETE FROM posts_tags WHERE post_id = ?", $this->id);
$new_tags_ids = [];
$new_tags_names = [];
$this->new_tags = array_map(function ($x) use(&$new_tags_ids, &$new_tags_names) {
$tag = Tag::find_or_create_by_name($x);
if (!in_array($tag->id, $new_tags_ids)) {
$new_tags_ids[] = $tag->id;
$new_tags_names[] = $tag->name;
return $tag;
}
}, $this->new_tags);
unset($new_tags_ids);
$this->new_tags = array_filter($this->new_tags);
# If any tags are newly active, expire the tag cache.
if ($this->new_tags) {
$any_new_tags = false;
$previous_tags = explode(' ', $this->cached_tags);
foreach ($this->new_tags as $tag) {
# If this tag is in old_tags, then it's already active and we just removed it
# in the above DELETE, so it's not really a newly activated tag. (This isn't
# self.old_tags; that's the tags the user saw before he edited, not the data
# we're replacing.)
if ($tag->post_count == 0 and !in_array($tag->name, $previous_tags)) {
$any_new_tags = true;
break;
}
}
if ($any_new_tags) {
Moebooru\CacheHelper::expire_tag_version();
}
}
# Sort
sort($new_tags_names);
sort($this->new_tags);
$tag_set = implode(", ", array_map(function ($x) {
return "(" . $this->id . ", " . $x->id . ")";
}, $this->new_tags));
$this->cached_tags = implode(' ', $new_tags_names);
$sql = "INSERT INTO posts_tags (post_id, tag_id) VALUES " . $tag_set;
self::connection()->executeSql($sql);
# Store the old cached_tags, so we can expire them.
$this->old_cached_tags = $this->cached_tags;
// Commenting the following line; it will cause cached_tags to not to be updated.
// They're set above.
// $this->cached_tags = self::connection()->selectValue("SELECT cached_tags FROM posts WHERE id = " . $this->id);
$this->new_tags = null;
}
