def logs(request):
prof_id = 1
try:
prof_id = request.session["prof_id"]
except KeyError:
pass
filterCriteria = "all"
try:
if (request.GET.get("filter")):
if (request.GET.get("filter") == "Media"):
filterCriteria = "Radarr"
else:
filterCriteria = request.GET.get("filter")
except KeyError:
pass
system_settings = SiteSettings.objects.all()[:1].get()
system_settings.newVersion = SiteSettings.checkVersion()
prof_list = Profile.objects.all()
if (filterCriteria == 'all'):
log_list = Logs.objects.all().order_by('-id')
else:
log_list = Logs.objects.all().order_by('-id').filter(
log_category=filterCriteria)
context = {
'system_settings': system_settings,
'log_list': log_list,
'prof_list': prof_list,
'prof_id': prof_id
}
template = loader.get_template("jibarr/logs.html")
return HttpResponse(template.render(context, request))
def upgrade(request):
prof_id = 1
try:
prof_id = request.session["prof_id"]
except KeyError:
pass
system_settings = SiteSettings.objects.all()[:1].get()
system_settings.newVersion = SiteSettings.checkVersion()
jv = ""
try:
resp = urllib.request.urlopen(
'https://github.com/ExtensiveJS/Jibarr/wiki/Current-Versions')
html = resp.read()
htmlstr = html.decode('utf8')
htmlSplit = htmlstr.split("\n")
for line in htmlSplit:
if line.find('Jibarr_Version') > -1:
jv = line.replace("</p>", "").replace("Jibarr_Version: ",
"").replace("<br>", "")
resp.close()
except:
pass
system_settings.jibarr_advertised_version = jv
prof_list = Profile.objects.all()
context = {
'system_settings': system_settings,
'prof_list': prof_list,
'prof_id': prof_id,
}
template = loader.get_template("jibarr/upgrade.html")
return HttpResponse(template.render(context, request))
def runsyncshows(request):
prof_id = 1
try:
prof_id = request.session["prof_id"]
except KeyError:
#prof_id = 1
pass
system_settings = SiteSettings.objects.all()[:1].get()
system_settings.newVersion = SiteSettings.checkVersion()
prof_list = Profile.objects.all()
sonarr_episode_list = sonarrEpisodeList()
profile_sonarr_show_list = ProfileSonarr.objects.filter(profile_id=prof_id)
totalFileSize = 0
for pss in profile_sonarr_show_list:
sel = SonarrEpisodeMedia.objects.filter(seriesId=pss.sonarr_id)
for se in sel:
# check if the season is excluded
if SonarrSeasonExclusions.objects.filter(series_id=pss.sonarr_id,seasonNumber=se.seasonNumber,profile_id=prof_id).count() < 1:
# check if the episode is monitored
if ProfileSonarrEpisode.objects.filter(profile_id=prof_id,sonarr_id=se.sonarr_id).count() == 1:
pse = ProfileSonarrEpisode.objects.get(profile_id=prof_id,sonarr_id=se.sonarr_id)
if pse:
pseLr = datetime.fromtimestamp(mktime(time.strptime(pse.lastRun, "%b %d %Y %H:%M:%S")))
selu = datetime.fromtimestamp(mktime(time.strptime(se.dateAdded, "%Y-%m-%d %H:%M")))
if selu > pseLr:
sem = SonarrEpisodeMedia.objects.get(sonarr_id=se.sonarr_id)
ss = SonarrShowMedia.objects.get(sonarr_id=sem.seriesId)
sem.showName = ss.title
sem.fileSize = convert_size(sem.size)
sonarr_episode_list.episodelist.append(sem)
totalFileSize = totalFileSize + sem.size
else:
# not in PSE, add it to sync list
sem = SonarrEpisodeMedia.objects.get(sonarr_id=se.sonarr_id)
ss = SonarrShowMedia.objects.get(sonarr_id=sem.seriesId)
sem.showName = ss.title
sem.fileSize = convert_size(sem.size)
sonarr_episode_list.episodelist.append(sem)
totalFileSize = totalFileSize + sem.size
sonarr_episode_list.episodelist.sort(key=lambda x: x.showName.lower(), reverse=False)
sonarr_episode_list.totalSize = convert_size(totalFileSize)
context = {
'system_settings': system_settings,
'prof_list': prof_list,
'prof_id': prof_id,
'sonarr_episode_list': sonarr_episode_list,
'prof_lastPath': Profile.objects.get(id=prof_id).profile_lastPath
}
template = loader.get_template("jibarr/runsyncshows.html")
return HttpResponse(template.render(context, request))
def sitesettings(request):
prof_id = 1
try:
prof_id = request.session["prof_id"]
except KeyError:
#prof_id = 1
pass
system_settings = SiteSettings.objects.all()[:1].get()
system_settings.newVersion = SiteSettings.checkVersion()
prof_list = Profile.objects.all()
context = {
'system_settings': system_settings,
'prof_list': prof_list,
'prof_id': prof_id
}
template = loader.get_template("jibarr/sitesettings.html")
return HttpResponse(template.render(context, request))
def shows(request):
prof_id = 1
try:
prof_id = request.session["prof_id"]
except KeyError:
pass
system_settings = SiteSettings.objects.all()[:1].get()
system_settings.newVersion = SiteSettings.checkVersion()
isSonarrConnected = settings.isSonarrConnected
system_settings.isSonarrConnected = isSonarrConnected
prof_list = Profile.objects.all()
prof = Profile.objects.get(id=prof_id)
pageNum = 1
try:
if (request.GET.get("page")):
pageNum = request.GET.get("page")
except KeyError:
pass
ssml = get_show_info(system_settings, prof)
ssml.showlist.sort(key=lambda x: x.title.lower(), reverse=False)
searchCriteria = ""
try:
if (request.GET.get("search")):
searchCriteria = request.GET.get("search")
except:
pass
if (searchCriteria):
ssml.showlist = [
x for x in ssml.showlist if bool(
re.search(re.compile(searchCriteria, re.IGNORECASE), x.title))
]
filterCriteria = "all"
try:
if (request.GET.get("filter")):
filterCriteria = request.GET.get("filter")
except:
pass
if (filterCriteria == 'monitored'):
ssml.showlist = [x for x in ssml.showlist if x.isMonitored]
if (filterCriteria == 'unmonitored'):
ssml.showlist = [x for x in ssml.showlist if x.isMonitored == False]
ssml.filterCriteria = filterCriteria
paginator = Paginator(ssml.showlist, 25)
if (int(pageNum) > paginator.num_pages):
pageNum = 1
pageStuff = PageStuff
pageStuff.pageNumber = pageNum
pageStuff.totalPages = paginator.num_pages
pageStuff.perPage = 5
pageStuff.totalRecords = paginator.count
ssml.showlist = paginator.page(int(pageNum))
context = {
'system_settings': system_settings,
'system_profile': prof,
'show_list': ssml,
'prof_list': prof_list,
'prof_id': prof_id
}
template = loader.get_template("jibarr/shows.html")
return HttpResponse(template.render(context, request))
def index(request):
prof_id = 1
try:
prof_id = request.session["prof_id"]
except KeyError:
pass
system_settings = SiteSettings.objects.all()[:1].get()
system_settings.newVersion = SiteSettings.checkVersion()
prof_list = Profile.objects.all()
rdl = get_movie_info(system_settings, prof_id)
rdml = rdl.movielist
rdml.sort(key=lambda x: x.lastUpdt.lower(), reverse=True)
radarr_list = radarrMovieList()
radarr_list.movielist = rdml[:5]
sonarr_list = sonarrShowList()
sonarr_list_ids = []
# 1) Get list of Episodes by dateAdded desc
sel = get_episode_info(system_settings, prof_id)
sell = sel.episodelist
sell.sort(key=lambda x: x.dateAdded, reverse=True)
# 2) Loop episodes for unique shows, exit with 5 shows
for var in sell:
if not var.seriesId in sonarr_list_ids:
sonarr_list_ids.append(var.seriesId)
if len(sonarr_list_ids) >= 5:
break
# 3) Fill show details (maybe do as part of 2)
for var in sonarr_list_ids:
ss = SonarrShowMedia.objects.get(sonarr_id=var)
ss.episodePercentage = round(
(ss.episodeFileCount / ss.episodeCount) * 100)
ss.isMonitored = False
try:
ProfileSonarr.objects.get(sonarr_id=var)
ss.isMonitored = True
except:
pass
ss.isNewer = True
sonarr_list.showlist.append(ss)
#for var in sell:
# ss = SonarrShowMedia.objects.get(sonarr_id=var.seriesId)
# ss.episodePercentage = round((ss.episodeFileCount / ss.episodeCount) * 100)
# ss.isMonitored = False
# try:
# ProfileSonarr.objects.get(sonarr_id=var.seriesId)
# ss.isMonitored = True
# except:
# pass
# ss.isNewer = True
# sonarr_list.showlist.append(ss)
#sonarr_list2 = sonarrShowList()
#for var in sonarr_list.showlist:
# found = False
# for var2 in sonarr_list2.showlist:
# if var.sonarr_id == var2.sonarr_id:
# found = True
# if found == False:
# sonarr_list2.showlist.append(var)
# if len(sonarr_list2.showlist) >= 5:
# break
isConnected = settings.isConnected
isSonarrConnected = settings.isSonarrConnected
system_settings.isConnected = isConnected
system_settings.isSonarrConnected = isSonarrConnected
isRadarrConnected = settings.isRadarrConnected
system_settings.isRadarrConnected = isRadarrConnected
context = {
'system_settings': system_settings,
'prof_list': prof_list,
'prof_id': prof_id,
'radarr_list': radarr_list,
'sonarr_list': sonarr_list
}
template = loader.get_template("jibarr/index.html")
return HttpResponse(template.render(context, request))
def showdetails(request):
prof_id = 1
try:
prof_id = request.session["prof_id"]
except KeyError:
pass
show_id = 0
try:
show_id = request.GET.get("id")
except:
pass
show = SonarrShowMedia()
try:
show = SonarrShowMedia.objects.get(sonarr_id=show_id)
except:
pass
seasCount = 0
#pseList = ProfileSonarrEpisode.objects.filter(profile_id=prof_id)
psList = ProfileSonarr.objects.filter(profile_id=prof_id)
pseList = ProfileSonarrEpisode.objects.filter(profile_id=prof_id)
show.isMonitored = False
for ps in psList:
if ps.sonarr_id == show.sonarr_id:
show.isMonitored = True
show.seasons = [sonarrSeason()] * 0
epC = 0
while seasCount < show.seasonCount:
seas = sonarrSeason()
seas.title = 'Season ' + str(seasCount + 1)
#seas.episodes.clear()
seas.episodes = [SonarrEpisodeMedia()] * 0
seas.number = str(seasCount + 1)
# check if the season is EXCLUDED.
seas.excluded = False
seExList = SonarrSeasonExclusions.objects.filter(
series_id=show.sonarr_id,
seasonNumber=seas.number,
profile_id=prof_id)
if seExList.count() > 0:
seas.excluded = True
for seasEp in SonarrEpisodeMedia.objects.filter(
seriesId=show.sonarr_id, seasonNumber=seasCount + 1):
se = sonarrEpisode()
se.id = seasEp.id
se.sonarr_id = seasEp.sonarr_id
se.seriesId = seasEp.seriesId
se.episodeNumber = seasEp.episodeNumber
se.title = seasEp.title
se.seasonNumber = seasEp.seasonNumber
se.path = seasEp.path
se.dateAdded = seasEp.dateAdded
se.quality = seasEp.quality
se.description = seasEp.description
se.airDate = seasEp.airDate
se.size = seasEp.size
se.isMonitored = show.isMonitored
se.excluded = seas.excluded
se.isNewer = False
if show.isMonitored:
se.isNewer = True
for pse in pseList:
if pse.sonarr_id == se.sonarr_id:
pseLr = datetime.fromtimestamp(
mktime(
time.strptime(pse.lastRun,
"%b %d %Y %H:%M:%S")))
seDa = datetime.fromtimestamp(
mktime(
time.strptime(se.dateAdded, "%Y-%m-%d %H:%M")))
if seDa < pseLr:
se.isNewer = False
seas.episodes.append(se)
epC += 1
show.seasons.append(seas)
seasCount = seasCount + 1
system_settings = SiteSettings.objects.all()[:1].get()
system_settings.newVersion = SiteSettings.checkVersion()
isSonarrConnected = settings.isSonarrConnected
system_settings.isSonarrConnected = isSonarrConnected
prof_list = Profile.objects.all()
prof = Profile.objects.get(id=prof_id)
context = {
'system_settings': system_settings,
'system_profile': prof,
'show': show,
'prof_list': prof_list,
'prof_id': prof_id
}
template = loader.get_template("jibarr/showdetails.html")
return HttpResponse(template.render(context, request))
def runsync(request):
prof_id = 1
try:
prof_id = request.session["prof_id"]
except KeyError:
#prof_id = 1
pass
system_settings = SiteSettings.objects.all()[:1].get()
system_settings.newVersion = SiteSettings.checkVersion()
prof_list = Profile.objects.all()
radarr_list = radarrMovieList()
profile_radarr_list = ProfileRadarr.objects.filter(profile_id=prof_id)
totalFileSize = 0
for pr in profile_radarr_list:
rid = pr.radarr_id
prLr = datetime.fromtimestamp(
mktime(time.strptime(pr.lastRun, "%b %d %Y %H:%M:%S")))
#data = urlopen(system_settings.radarr_path + "/api/movie/" + str(rid) + "?apikey=" + system_settings.radarr_apikey).read()
#output = json.loads(data)
rmed = RadarrMedia.objects.get(radarr_id=rid)
rm = radarrMovie()
rm.prid = pr.id
rm.id = rmed.radarr_id # output['id']
rm.title = rmed.title # output['title']
rm.lastUpdt = rmed.last_updt
try:
rm.releaseDate = rmed.release_date # output['inCinemas'][:4]
except KeyError:
pass
try:
rm.tmdbid = rmed.tmdbid # output["tmdbId"]
except KeyError:
pass
#if output['hasFile']:
# plu = output['movieFile']['dateAdded'][:10] + " " + output['movieFile']['dateAdded'][11:16]
# rmlu = datetime.fromtimestamp(mktime(time.strptime(plu, "%Y-%m-%d %H:%M")))
# rm.fileSize = convert_size(output['sizeOnDisk'])
rm.fileSize = convert_size(rmed.size)
rmlu = datetime.fromtimestamp(
mktime(time.strptime(rmed.last_updt, "%Y-%m-%d %H:%M")))
if rmlu > prLr:
radarr_list.movielist.append(rm)
#radarr_list.movielist.append(rm)
totalFileSize = totalFileSize + rmed.size
radarr_list.movielist.sort(key=lambda x: x.title.lower(), reverse=False)
radarr_list.totalSize = convert_size(totalFileSize)
context = {
'system_settings': system_settings,
'prof_list': prof_list,
'prof_id': prof_id,
'radarr_list': radarr_list,
''
'prof_lastPath': Profile.objects.get(id=prof_id).profile_lastPath
}
template = loader.get_template("jibarr/runsync.html")
return HttpResponse(template.render(context, request))
def SystemUpgrade(toVer):
try:
Logs.objects.create(
log_type='Upgrade',
log_category='System',
log_message='System Upgrade (' + toVer + ') initiated',
log_datetime=datetime.utcnow().strftime("%b %d %Y %H:%M:%S"))
except:
pass
isSuccessful = True
time.sleep(1)
# 1) Backup the DB
isSuccessful = backupDatabase()
time.sleep(1)
# 2) Download new files
if isSuccessful:
try:
isSuccessful = downloadZipFile()
except:
isSuccessful = False
pass
# 3) Unzip files
if isSuccessful:
try:
isSuccessful = unzipZipFile()
except:
isSuccessful = False
pass
# 4) Run Schema updates
if isSuccessful:
try:
curDbVer = SiteSettings.jibarr_version
isSuccessful = upgradeDatabase(curDbVer, toVer)
except:
isSuccessful = False
pass
# 5) Run file copies
if isSuccessful:
try:
isSuccessful = upgradeCode()
except:
isSuccessful = False
pass
# 6) Update DB Version
# This is happening in step 4 today, change it!!
# 7) Cleanup files
if isSuccessful:
try:
isSuccessful = cleanupFiles
except:
isSuccessful = False
pass
# 8) Clear the cached Upgrade Needed indicator
if isSuccessful:
try:
CACHE_KEY_NEWVERSION = 'NEWVERSION'
cache.delete(CACHE_KEY_NEWVERSION)
SiteSettings.checkVersion()
except:
isSuccessful = False
pass
if isSuccessful:
try:
Logs.objects.create(
log_type='Upgrade',
log_category='System',
log_message='System Upgrade completed successfully.',
log_datetime=datetime.utcnow().strftime("%b %d %Y %H:%M:%S"))
except KeyError:
pass
else:
try:
Logs.objects.create(
log_type='Upgrade',
log_category='System',
log_message='System Upgrade failed!!!!',
log_datetime=datetime.utcnow().strftime("%b %d %Y %H:%M:%S"))
except KeyError:
pass
return isSuccessful