def my_requests(request):
user_requests = (UserRequest.objects.filter(
requested_by=request.user).order_by("id").reverse())
all_cards = generate_requests_cards(user_requests)
context = generate_context({"all_cards": all_cards})
template = loader.get_template("viewport/requests.html")
return HttpResponse(template.render(context, request))
def my_issues(request):
reported_issues = (ReportedIssue.objects.filter(
reported_by=request.user).order_by("id").reverse())
all_cards = generate_issue_cards(reported_issues)
context = generate_context({"all_cards": all_cards})
template = loader.get_template("viewport/reported_issues.html")
return HttpResponse(template.render(context, request))
def content_preview_modal(request):
content_discovery = ContentDiscovery()
# Get the ID from the URL
tmdb_id = request.GET.get("tmdb_id", None)
content_type = request.GET.get("content_type", None)
if tmdb_id and content_type:
# Fetch and process
content = content_discovery.get_by_tmdb_id(
tmdb_id, content_type, obtain_extras=False
)
set_single_availability(content)
preprocess_tmdb_result(content)
# Check if the user has already requested this
requested = False
if UserRequest.objects.filter(
content_id=content["id"],
source="tmdb",
content_type=content["content_type"],
):
requested = True
context = generate_context({"content": content, "requested": requested})
template = loader.get_template("modal/content_preview.html")
return HttpResponse(template.render(context, request))
def initialization(request):
conreq_config = ConreqConfig.get_solo()
user_objects = get_user_model().objects
# Authenticate using Organizr headers
organizr_username = request.headers.get("X-WEBAUTH-USER")
if conreq_config.conreq_http_header_auth and organizr_username:
organizr_email = request.headers.get("X-WEBAUTH-EMAIL")
organizr_group = int(request.headers.get("X-WEBAUTH-GROUP"))
user = user_objects.get_or_create(username=organizr_username, )[0]
user.email = organizr_email
user.is_staff = False
if organizr_group == 0:
user.is_superuser = True
if organizr_group == 0 or organizr_group == 1:
user.is_staff = True
user.save()
login(request, user)
# Run the first time initialization if needed
if conreq_config.conreq_initialized is False:
# User submitted the first time setup form
if request.method == "POST":
form = InitializationForm(request.POST)
# Create the superuser and set up the database if the form is valid
if form.is_valid():
form.save()
username = form.cleaned_data.get("username")
password = form.cleaned_data.get("password1")
user = authenticate(username=username, password=password)
user.is_staff = True
user.is_admin = True
user.is_superuser = True
user.save()
login(request, user)
initialize_conreq(conreq_config, form)
return redirect("base:index")
# Form data wasn't valid, so return the error codes
template = loader.get_template("registration/initialization.html")
return HttpResponse(template.render({"form": form}, request))
# User needs to fill out the first time setup
template = loader.get_template("registration/initialization.html")
return HttpResponse(template.render({}, request))
# If a base URL is set, redirect the user to it
if request.path[1:] != BASE_URL:
return redirect("/" + BASE_URL)
# Render the base
return login_required(render)(request, "primary/base.html",
generate_context({}))
def report_issue_modal(request):
# Get the parameters from the URL
context = generate_context({
"issues":
ISSUE_LIST,
"tmdb_id":
request.GET.get("tmdb_id", None),
"tvdb_id":
request.GET.get("tvdb_id", None),
"content_type":
request.GET.get("content_type", None),
})
template = loader.get_template("modal/report_issue.html")
return HttpResponse(template.render(context, request))
def collection(request):
collection_id = request.GET.get("collection_id", None)
if collection_id:
content_discovery = ContentDiscovery()
tmdb_collection = content_discovery.collections(collection_id)
if not isinstance(tmdb_collection, dict) or not tmdb_collection:
tmdb_collection = None
else:
set_many_availability(tmdb_collection["parts"])
context = generate_context({"collection": tmdb_collection})
template = loader.get_template("viewport/more_info_collection.html")
return HttpResponse(template.render(context, request))
def discover_movies(request):
content_discovery = ContentDiscovery()
template = loader.get_template("viewport/discover.html")
# Get the page number from the URL
page = int(request.GET.get("page", 1))
# Search for TV content
tmdb_results = content_discovery.movies(page, page_multiplier=2)["results"]
# Set the availability for all cards
set_many_availability(tmdb_results)
context = generate_context({
"all_cards": tmdb_results,
})
return HttpResponse(template.render(context, request))
def recommended(request):
tmdb_id = request.GET.get("tmdb_id", None)
content_type = request.GET.get("content_type", None)
if tmdb_id and content_type:
content_discovery = ContentDiscovery()
tmdb_recommended = content_discovery.similar_and_recommended(
tmdb_id, content_type
)
if not isinstance(tmdb_recommended, dict) or not tmdb_recommended:
tmdb_recommended = None
else:
set_many_availability(tmdb_recommended["results"])
context = generate_context({"recommended": tmdb_recommended})
template = loader.get_template("viewport/more_info_recommended.html")
return HttpResponse(template.render(context, request))
def search(request):
content_discovery = ContentDiscovery()
searcher = Search()
# Get the ID from the URL
query = request.GET.get("query", "")
content_type = request.GET.get("content_type", None)
template = loader.get_template("viewport/search.html")
# Determine which search method to use (tv/movie/all)
if content_type == "tv":
arr_results = searcher.television(query)
elif content_type == "movie":
arr_results = searcher.movie(query)
else:
arr_results = searcher.all(query)
# Attempt to convert cards to TMDB equivalents
thread_list = []
for index in range(0, len(arr_results)):
thread = Thread(target=convert_card_to_tmdb, args=[index, arr_results])
thread.start()
thread_list.append(thread)
# Wait for computation to complete
for thread in thread_list:
thread.join()
# Determine the availability
content_discovery.determine_id_validity({"results": arr_results})
set_many_availability(arr_results)
context = generate_context(
{
"all_cards": arr_results,
}
)
return HttpResponse(template.render(context, request))
def manage_users(request):
template = loader.get_template("viewport/manage_users.html")
users = get_user_model().objects.values()
context = generate_context({"users": users})
return HttpResponse(template.render(context, request))
def more_info(request):
content_discovery = ContentDiscovery()
template = loader.get_template("viewport/more_info.html")
# Get the ID from the URL
tmdb_id = request.GET.get("tmdb_id", None)
tvdb_id = request.GET.get("tvdb_id", None)
if tmdb_id:
content_type = request.GET.get("content_type", None)
# Get all the basic metadata for a given ID
content = content_discovery.get_by_tmdb_id(tmdb_id, content_type)
# Determine the availability of the current TMDB ID
set_single_availability(content)
# Pre-process data attributes within tmdb_result
preprocess_tmdb_result(content)
# Get collection information
if (
content.__contains__("belongs_to_collection")
and content["belongs_to_collection"] is not None
):
tmdb_collection_id = content["belongs_to_collection"]["id"]
else:
tmdb_collection_id = None
# Check if the user has already requested this
requested = False
if UserRequest.objects.filter(
content_id=content["id"],
source="tmdb",
content_type=content["content_type"],
):
requested = True
# Generate context for page rendering
context = generate_context(
{
"content": content,
"collection_id": tmdb_collection_id,
"content_type": content["content_type"],
"requested": requested,
}
)
elif tvdb_id:
searcher = Search()
# Fallback for TVDB
content = searcher.television(tvdb_id)[0]
# Preprocess results
preprocess_arr_result(content)
# Determine the availability
set_single_availability(content)
# Generate context for page rendering
context = generate_context(
{
"content": content,
"content_type": content["content_type"],
}
)
# Render the page
return HttpResponse(template.render(context, request))
def series_modal(request):
content_discovery = ContentDiscovery()
content_manager = ContentManager()
report_modal = request.GET.get("report_modal", False)
# Get the ID from the URL
tmdb_id = request.GET.get("tmdb_id", None)
tvdb_id = request.GET.get("tvdb_id", None)
# Determine the TVDB ID
if tvdb_id:
pass
elif tmdb_id:
tvdb_id = content_discovery.get_external_ids(tmdb_id, "tv")["tvdb_id"]
# Check if the show is already within Sonarr's collection
requested_show = content_manager.get(tvdb_id=tvdb_id)
# If it doesn't already exists, add then add it
if requested_show is None:
sonarr_params = obtain_sonarr_parameters(
content_discovery, content_manager, tmdb_id, tvdb_id
)
requested_show = content_manager.add(
tvdb_id=tvdb_id,
quality_profile_id=sonarr_params["sonarr_profile_id"],
root_dir=sonarr_params["sonarr_root"],
series_type=sonarr_params["series_type"],
season_folders=sonarr_params["season_folders"],
)
# Keep refreshing until we get the series from Sonarr
series = content_manager.get(
tvdb_id=tvdb_id, obtain_season_info=True, force_update_cache=True
)
if series is None:
series_fetch_retries = 0
while series is None:
if series_fetch_retries > MAX_SERIES_FETCH_RETRIES:
break
series_fetch_retries = series_fetch_retries + 1
series = content_manager.get(
tvdb_id=tvdb_id, obtain_season_info=True, force_update_cache=True
)
log.handler(
"Sonarr did not have the series information! Conreq is waiting...",
log.INFO,
_logger,
)
# Series successfully obtained from Sonarr
if series:
context = generate_context(
{
"seasons": series["seasons"],
"tvdb_id": tvdb_id,
"report_modal": report_modal,
}
)
template = loader.get_template("modal/series_selection.html")
return HttpResponse(template.render(context, request))
# Sonarr couldn't process this request
return HttpResponseNotFound()