def generate(self):
query = session.query(self.Model).all()
self.objects = []
for item in query:
jason_row = {"name": item.name}
self.objects.append(jason_row)
self.generate_file()
def counter_movies(self, Model):
def count_movies(dir):
movie_dir = dir + '' + '\movies'
listSeries = os.listdir(movie_dir)
count = 0
for dir_element in listSeries:
nev_dir = movie_dir + '' + '\\' + str(dir_element) + '\\DATA'
nev_dir_loop = []
if os.path.isdir(nev_dir):
nev_dir_loop = os.listdir(nev_dir)
for movie in nev_dir_loop:
if movie.endswith(movie_ext):
count = count + 1
return count
def movies_series_by_series():
item = self.set_dir('series')
count = 0
dir = os.listdir(item['dir'])
for el in dir:
new_dir = item['dir'] + '' + str('\\' + el)
list = os.listdir(new_dir)
for dir_element in list:
count = count + count_movies(new_dir + '' +
str('\\' + dir_element))
return count
movies_in_db = session.query(Model).count()
movies_series = movies_series_by_series()
return_count = movies_series - movies_in_db
self.counter_object = self.counter_object + return_count
return return_count
def __init__(self, dir):
self.dir = dir
self.session = session
self.name = set_name(dir)
print("Config " + str(self.name))
self.data = session.query(self.Model).filter(self.Model.name == self.name).first()
self.config = self.dir + '\\config.JSON'
self.name = set_name(dir)
def add_fields(self, data_JSON, Movie):
print("creating JSON OUTPUT for Star " + data_JSON['name'])
self.add_index(self.fields, data_JSON, Movie)
data = session.query(
self.Model).filter(self.Model.name == data_JSON['name']).first()
data_JSON['movies'] = self.CreateJSONDBLISTObj.base_get(
data.movies, movies_fields_defults)
data_JSON['photos'] = self.return_galery(data_JSON, Movie)
return data_JSON
def load(self):
self.row = 0
self.col = 0
for Movie in session.query(Movies).all():
self.movies.append(Movie)
for Movie in self.movies:
self.add_row(Movie)
self.col = 0
self.row += 1
self.workbook.close()
def add_fields(self, data_JSON, Movie):
print("creating JSON OUTPUT for movie " + data_JSON['name'])
self.add_index(self.fields, data_JSON, Movie)
data = session.query(
self.Model).filter(self.Model.name == data_JSON['name']).first()
data_JSON['photos'] = self.return_galery(data_JSON)
data_JSON[
'producent'] = self.CreateJSONDBLISTObj.return_short_producent(
data)
return data_JSON
def count_series(self, dir, Model):
count = 0
Model = session.query(Model).filter(Model.name == dir).first()
if Model is not None:
with open(Model.dir + '\\\\\\\\config.JSON') as json_file:
data = json.load(json_file)
if 'fields' in data:
for item in data['fields']:
if hasattr(Model, item['db']):
if getattr(Model, item['db']) != item['value']:
count = count + 1
return count
def add_tags(self, tags, Obj=None):
if Obj is not None:
self.data = Obj
for tag in tags:
query = session.query(Tags).filter(Tags.name == tag).first()
if query is None:
TagObj = Tags(name=tag.replace(",", "").replace(" ", "").capitalize())
session.add_all([TagObj])
session.commit()
query = TagObj
self.data.tags.append(query)
session.commit()
def count_item_in_dir(self, Model, index):
item = self.set_dir(index)
dir = os.listdir(item['dir'])
count = 0
for el in dir:
new_dir = item['dir'] + '' + str('\\' + el)
list = os.listdir(new_dir)
count = count + len(list)
movies_in_db = session.query(Model).count()
return_count = count - movies_in_db
self.counter_object = self.counter_object + return_count
return return_count
def add_fields(self, data_JSON, Movie):
print("creating JSON OUTPUT for Producent " + data_JSON['name'])
data = session.query(
self.Model).filter(self.Model.name == data_JSON['name']).first()
self.add_index(self.fields, data_JSON, Movie)
data_JSON['series'] = self.CreateJSONDBLISTObj.base_get(
data.series, series_fields_defults)
data_JSON['movies'] = self.add_movies(data.series)
data_JSON['stars'] = self.CreateJSONDBLISTObj.return_top_stars(data)
data_JSON['photos'] = self.return_galery(data_JSON, data)
data_JSON['banner'] = self.return_banners(data)
return data_JSON
def __init__(self, dir):
super().__init__(dir)
self.config = self.dir + '\\config.JSON'
self.skip_galery = self.dir + '\\skip_galery.JSON'
self.name = set_name(dir)
print("Scaning Series " + str(self.name))
item = session.query(
self.model).filter(self.model.name == self.name).first()
if item is None:
self.series = self.if_series_exist(self.name)
else:
self.series = item
def generate(self):
query = session.query(self.Model).all()
self.objects = []
for item in query:
jason_row = {
"name": item.name,
"banner": self.set_dir(item.baner),
"year": item.year,
"show_name": item.show_name,
"avatar": self.set_img(item.avatar),
"dir": self.set_dir(item.dir),
"web_dir": item.dir,
"country": item.country,
"description": item.description,
"tags": self.add_many_to_many_as_array(item, 'tags')
}
self.objects.append(jason_row)
self.generate_file()
def config_movie(dir):
sezons = os.listdir(dir)
count = 0
for movies_dir in sezons:
movies_sezons = os.listdir(dir + '\\\\\\\\' + movies_dir)
for movie_sezons in movies_sezons:
Model = session.query(Movies).filter(
Movies.name == movie_sezons).first()
if Model is not None:
with open(dir + '\\\\\\\\' + movies_dir + '\\\\\\\\' +
movie_sezons +
'\\\\\\\\config.JSON') as json_file:
data = json.load(json_file)
if 'fields' in data:
for item in data['fields']:
if hasattr(Model, item['db']):
if item['db'] != 'date_relesed':
if getattr(Model, item['db']
) != item['value']:
count = count + 1
return count
def generate(self):
query = session.query(self.Model).all()
self.objects = []
for item in query:
jason_row = {
"name": item.name,
"show_name": item.show_name,
"description": item.description,
"src": self.set_img(item.src),
"avatar": self.set_img(item.avatar),
"date_relesed": self.add_date(item.date_relesed),
"dir": self.set_dir(item.dir),
"web_dir": item.dir,
"web_src": item.src,
"country": item.country,
"poster": self.set_img(item.poster),
"tags": self.add_many_to_many_as_array(item, 'tags'),
"series": self.add_many_to_many_as_array(item, 'series'),
"stars": self.add_many_to_many_as_array(item, 'stars')
}
self.objects.append(jason_row)
self.generate_file()
def generate(self):
query = session.query(self.Model).all()
self.objects = []
for item in query:
jason_row = {
"name": item.name,
"show_name": item.show_name,
"description": item.description,
"weight": self.convert_int(item.weight),
"avatar": self.set_img(item.avatar),
"height": self.convert_int(item.height),
"ethnicity": item.height,
"hair_color": item.height,
"birth_place": item.height,
"nationality": item.nationality,
"dir": self.set_dir(item.dir),
"web_dir": item.dir,
"date_of_birth": self.add_date(item.date_of_birth),
"movies": self.add_many_to_many_as_array(item, 'movies'),
"tags": self.add_many_to_many_as_array(item, 'tags'),
"series": self.add_many_to_many_as_array(item, 'series'),
}
self.objects.append(jason_row)
self.generate_file()
def start(self):
self.LoopRun.objets = [
{
"obj": LoadFilesFromJson(data_JSON['dirs']), "method": 'add_files',
"stan": setings_array["scan_dir"], "start_mes": 'Scaning Dir in progres', "end_mees": 'End of scaning'
},
{
"obj": ConfigLoop(data_JSON['dirs']), "method": 'load',
"stan": setings_array["config"], "start_mes": 'Config in progres', "end_mees": 'End of Config'
},
{
"obj": ConfigMovies(data_JSON['movies_photos']), "method": 'load',
"stan": setings_array["config"], "start_mes": 'Config Movies in progres',
"end_mees": 'End of Movies in progres'
},
{
"obj": SetTags(data_JSON['dirs']), "method": 'set',
"stan": setings_array["config"], "start_mes": 'Set Tags in progres',
"end_mees": 'End of Set Tags in progres'
},
{
"obj": CreateXML(data_JSON['dirs']), "method": 'load',
"stan": setings_array["create_xml"], "start_mes": 'Createing XML in progres',
"end_mees": 'End of Createing XML in progres'
},
{
"obj": CreateMovieList(data_JSON['dirs']), "method": 'load',
"stan": setings_array["create_movie_list"], "start_mes": 'Createing Movies List in progres',
"end_mees": 'End of Createing Movies List in progres'
},
{
"obj": CreateJSONDBLIST(), "method": 'create',
"stan": setings_array["generate_json"], "start_mes": 'Config JSON Outputs in progres',
"end_mees": 'End of Config JSON Outputs in progres'
},
{
"obj": GenerateJSONOtputsSeries(), "method": 'create',
"stan": setings_array["generate_json"], "start_mes": 'Config Series in progres',
"end_mees": 'End of Series in progres'
},
{
"obj": GenerateJSONOtputsMovies(), "method": 'create',
"stan": setings_array["generate_json"], "start_mes": 'Config JSON Outputs for movies in progres',
"end_mees": 'End of Config JSON Outputs for movies in progres'
},
{
"obj": GenerateJSONOtputsStars(), "method": 'create',
"stan": setings_array["generate_json"], "start_mes": 'Config JSON Outputs for stars in progres',
"end_mees": 'End of Config JSON Outputs for stars in progres'
},
{
"obj": GenerateJSONOtputsProducent(), "method": 'create',
"stan": setings_array["generate_json"], "start_mes": 'Config JSON Outputs for producent in progres',
"end_mees": 'End of Config JSON Outputs for producent in progres'
},
{
"obj": HTMLGenaratorMain(), "method": 'generate',
"stan": setings_array["generate_html"], "start_mes": 'Genereting HTML Base',
"end_mees": 'End of Genereting HTML Base'
},
{
"obj": GenerateHTMLMovies(), "method": 'generate',
"stan": setings_array["generate_html"], "start_mes": 'Genereting HTML Movies',
"end_mees": 'End of Genereting HTML Movies'
},
{
"obj": GenerateHTMLProducents(), "method": 'generate',
"stan": setings_array["generate_html"], "start_mes": 'Genereting HTML Producents',
"end_mees": 'End of Genereting HTML Producents'
},
{
"obj": GenerateHTMLSeries(), "method": 'generate',
"stan": setings_array["generate_html"], "start_mes": 'Genereting HTML Series',
"end_mees": 'End of Genereting HTML Series'
},
{
"obj": GenerateHTMLStars(), "method": 'generate',
"stan": setings_array["generate_html"], "start_mes": 'Genereting HTML Stars',
"end_mees": 'End of Genereting HTML Stars'
},
]
if Path('data.json').is_file():
self.LoopRun.loop()
if self.scan_photos:
print("Createing screen shots in progres")
for Movie in session.query(Movies).all():
PM = PhotoMeaker(Movie, data_JSON['movies_photos'])
PM.make()
else:
self.config=False
self.JSONConfigView.run_window()
def set_data(self, id):
if self.model:
self.data = session.query(self.model).get(id)
def counter(self, Model):
return session.query(Model).count()
def create_missing_photos(self,values):
Movie = session.query(Movies).filter(Movies.id == self.data.id).first()
PM = PhotoMeaker(Movie, data_JSON['movies_photos'],self)
PM.make()
self.BaseActions.reset()
def load(self):
for Movie in session.query(Movies).all():
self.name=Movie
print('Config for ' + str(self.name))
self.make_dir(Movie)
def search_faze_normal(self):
return session.query(self.model).filter(
self.model.name.like(str(self.Menu.search_faze) + '%'))
def set_query(self):
if self.Menu.search_faze:
return session.query(self.model).filter(
self.model.name.like(str(self.Menu.search_faze) + '%'))
return session.query(self.model)
def load(self):
for Star in session.query(Stars).all():
self.create_list(Star)
def return_Movies_in_series():
return session.query(Movies)\
.filter(Movies.series.any(Series.id.in_(("",self.data.id))))\
.order_by(desc('year'))\
.all()
def set(self):
for Movie in session.query(Movies).all():
self.name = Movie
print('Adding tag for ' + str(self.name))
self.set_tags(Movie)
def set_up(self):
self.set_list_view_data(session.query(Movies).all())
