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()