def dissect_comment(comment):
"""
:param comment: comment string
:raises exceptions.MovieNotFound
:raises exceptions.EpisodeNotFound
:raises exceptions.OffensiveWord
"""
split_command = comment.split(" ")
requests_command = split_command[0]
if not any(commands in requests_command.lower() for commands in COMMANDS):
return
split_command.pop(0)
final_comment = " ".join(split_command)
try:
title = final_comment.split("[")[0].rstrip()
if is_episode(title):
search_episode(EPISODE_LIST, title, raise_resting=False)
else:
search_movie(MOVIE_LIST, title, raise_resting=False)
except IndexError:
return
content = REQUEST_RE.findall(final_comment)
if content:
[check_offensive_content(text) for text in content]
return {
"command": requests_command,
"title": title,
"comment": final_comment,
"content": content,
}
def get_requests(filter_type="movies", priority_only=False):
"""
:param filter: movies or episodes
:param priority_only: filter requests without priority
"""
with sqlite3.connect(REQUESTS_DB) as conn:
result = conn.execute("select * from requests where used=0").fetchall()
requests = []
for i in result:
is_episode_ = is_episode(i[1])
if filter_type == "movies" and is_episode_:
continue
if filter_type == "episodes" and not is_episode_:
continue
requests.append({
"user": i[0],
"comment": i[1],
"type": i[2],
"movie": i[3],
"content": i[4].split("|"),
"id": i[5],
"verified": i[7],
"priority": i[8],
})
random.shuffle(requests)
if priority_only:
return [request for request in requests if request.get("priority")]
return requests
def handle_request_item(request_dict, published):
"""
:param request_list: request dictionaries
:param published: directly publish to Facebook
"""
block_user(request_dict["user"], check=True)
request_command = request_dict["type"]
request_dict["is_episode"] = is_episode(request_dict["comment"])
request_dict["parallel"] = is_parallel(request_dict["comment"])
if len(request_dict["content"]) > 8:
raise exceptions.TooLongRequest
logger.info(
f"Request command: {request_command} {request_dict['comment']} "
f"(Episode: {request_dict['is_episode']})")
is_multiple = len(request_dict["content"]) > 1
final_imgs, frames, alt_title = get_images(request_dict, is_multiple,
published)
request_dict["parallel"] = alt_title
try:
post_id = post_request(
final_imgs,
frames[0].movie,
request_dict,
published,
request_dict["is_episode"],
)
except facepy.exceptions.OAuthError as error:
message = f"Something is wrong with the Facebook token: {error}"
webhook = DiscordWebhook(url=DISCORD_WEBHOOK_TEST, content=message)
webhook.execute()
sys.exit(message)
try:
comment_post(post_id, published, request_dict["is_episode"])
notify(request_dict["id"], None, published, request_dict["is_episode"])
except (facepy.exceptions.FacepyError, RequestException) as error:
logger.error(error, exc_info=True)
finally:
if request_dict["is_episode"]:
insert_episode_request_info_to_db(frames[0].movie,
request_dict["user"])
else:
insert_request_info_to_db(frames[0].movie, request_dict["user"])
update_request_to_used(request_dict["id"])
logger.info("Request finished successfully")
return True
async def search(ctx, *args):
query = " ".join(args)
try:
if is_episode(query):
result = search_episode(EPISODE_LIST, query, raise_resting=False)
message = f"{BASE}/episode/{result['id']}"
else:
result = search_movie(MOVIE_LIST, query, raise_resting=False)
message = f"{BASE}/movie/{result['tmdb']}"
except (MovieNotFound, EpisodeNotFound):
message = "apoco si pa"
await ctx.send(message)
def search_item(query, return_dict=False):
if is_episode(query):
EPISODE_LIST = db.get_list_of_episode_dicts()
result = search_episode(EPISODE_LIST, query, raise_resting=False)
if not return_dict:
return f"{BASE}/episode/{result['id']}"
else:
MOVIE_LIST = db.get_list_of_movie_dicts()
result = search_movie(MOVIE_LIST, query, raise_resting=False)
if not return_dict:
return f"{BASE}/movie/{result['tmdb']}"
return result
def dissect_comment(comment):
"""
:param comment: comment string
:raises exceptions.MovieNotFound
:raises exceptions.EpisodeNotFound
:raises exceptions.OffensiveWord
:raises exceptions.IvalidRequest
"""
split_command = comment.split(" ")
requests_command = split_command[0]
if requests_command.lower() not in COMMANDS:
return
split_command.pop(0)
final_comment = " ".join(split_command)
if requests_command == "!parallel":
parallels = is_parallel(final_comment)
try:
contents = [REQUEST_RE.findall(parallel) for parallel in parallels]
if any(len(content) > 1
for content in contents) or len(parallels) > 3:
raise InvalidRequest(final_comment)
except TypeError:
return
title, content = "Parallel", ["Parallel"]
else:
try:
title = final_comment.split("[")[0].rstrip()
if is_episode(title):
search_episode(EPISODE_LIST, title, raise_resting=False)
else:
search_movie(MOVIE_LIST, title, raise_resting=False)
except IndexError:
return
content = REQUEST_RE.findall(final_comment)
if content:
[check_offensive_content(text) for text in content]
return {
"command": requests_command,
"title": title,
"comment": final_comment,
"content": content,
}
def handle_request(request_dict, facebook=True):
"""
:param request_list: request dictionaries
:param facebook: add extra info to description key
"""
request_dict["is_episode"] = is_episode(request_dict["comment"])
request_dict["parallel"] = is_parallel(request_dict["comment"])
if len(request_dict["content"]) > 10:
raise exceptions.TooLongRequest(
f"Expected less than 11 brackets, found {len(request_dict['content'])}."
)
logger.info(f"Request comment: {request_dict['comment']}; "
f"command: {request_dict['type']}")
if request_dict["type"] == "!gif":
if facebook:
raise exceptions.InvalidRequest(
"Facebook doesn't support GIF requests.")
if request_dict["is_episode"]:
raise exceptions.NotAvailableForCommand(
"Episodes don't support GIFs yet.")
movie, final_imgs = handle_gif_request(request_dict,
get_list_of_movie_dicts())
alt_title = None
else:
is_multiple = len(request_dict["content"]) > 1
final_imgs, frames, alt_title = get_images(request_dict, is_multiple)
movie = frames[0].movie
request_dict["parallel"] = alt_title
request_description = get_description(movie, request_dict, facebook)
logger.info("Request finished successfully")
return {
"description": request_description,
"images": final_imgs,
"final_request_dict": request_dict,
"movie_dict": movie,
}
