diff options
Diffstat (limited to 'Models.py')
-rwxr-xr-x | Models.py | 723 |
1 files changed, 723 insertions, 0 deletions
diff --git a/Models.py b/Models.py new file mode 100755 index 0000000..44f1021 --- /dev/null +++ b/Models.py @@ -0,0 +1,723 @@ +import sqlite3 +import hashlib +import os +import logging + +class ScorePadDB(): + + def __init__(self, nickname = ""): + + self.scorepaddb = "../ScorePad.activity/"+str(nickname)+"db.sqlite" + self.connection = sqlite3.connect(self.scorepaddb) + self.cursor = self.connection.cursor() + + def insert_rubric(self, rubric): + temp = (rubric.title, rubric.author, rubric.description, rubric.is_predefined, + rubric.xo_name, rubric.rubric_sha, rubric.enable_points) + insert_str = "INSERT INTO rubric_table(title, author, description,is_predefined,\ + xo_name, rubric_sha,enable_points)\ + VALUES(?,?,?,?,?,?,?)" + self.cursor.execute(insert_str,temp) + self.connection.commit() + + def insert_category(self, category): + temp = (category.name, category.rubric_id, category.category_sha, category.percentage) + insert_str = "INSERT INTO category_table(name,rubric_id,category_sha,percentage) VALUES (?,?,?,?)" + self.cursor.execute(insert_str, temp) + self.connection.commit() + + def insert_level(self, level): + temp = (level.name,level.description,level.category_id,level.rubric_id,level.level_sha,level.points) + insert_str = "INSERT INTO level_table(name, description, category_id, rubric_id,level_sha,points) \ + VALUES(?,?,?,?,?,?)" + self.cursor.execute(insert_str, temp) + self.connection.commit() + + def insert_criteria2(self, category, levels, rubric_id): + temp = (category.name, rubric_id, category.category_sha,category.percentage) + insert_str = "INSERT INTO category_table(name,rubric_id,category_sha,percentage) VALUES (?,?,?,?)" + self.cursor.execute(insert_str, temp) + self.connection.commit() + + query_str = "SELECT MAX(category_id) from category_table" + self.cursor.execute(query_str) + category_id = self.cursor.fetchone()[0] + + insert_str = "INSERT INTO level_table(name,description,category_id,rubric_id,level_sha,points)\ + VALUES(?,?,?,?,?,?)" + for level in levels: + temp = (level.name, level.description,category_id,\ + rubric_id, level.level_sha,level.points) + self.cursor.execute(insert_str, temp) + self.connection.commit() + + def query_maxrubric(self): + query_str = "SELECT MAX(rubric_id) from rubric_table" + self.cursor.execute(query_str) + rubric_id = self.cursor.fetchone()[0] + return rubric_id + + def query_level(self,category_id): + + query_str = "SELECT * from level_table where category_id ="+str(category_id) + self.cursor.execute(query_str) + + level_list = [] + for row in self.cursor: + level = Level(row[0], row[1], row[2], row[3], row[4], row[5],row[6]) + level_list.append(level) + return level_list + + def rubric_exists(self, title, author): + temp = (title, author) + query_str = "SELECT * FROM rubric_table WHERE title = ? and author = ?" + + self.cursor.execute(query_str, temp) + for row in self.cursor: + rubric = Rubric(row[0],row[1],row[2],row[3],row[4],row[5],row[6],row[7]) + + try: + if rubric.rubric_id == None: + return None + else: + return rubric.rubric_id + except: + return None + + def close_db(self): + self.cursor.close() + +class YardStickDB(): + + def connect_db(self, nickname = ""): + is_newlycreated = False + self.yardstickdb = str(nickname)+"db.sqlite" + if not os.path.isfile(self.yardstickdb): + logging.debug("the database already exist") + + self.connection = sqlite3.connect(self.yardstickdb) + logging.debug("ScorepadDB-->connect") + self.cursor = self.connection.cursor() + try: + self.create_tables() + is_newlycreated = True + logging.debug("ScorepadDB -->create_tables") + except: + logging.debug("Exception here") + + return is_newlycreated + + def create_tables(self): + rubric_table = "CREATE TABLE rubric_table (rubric_id INTEGER PRIMARY KEY,\ + title VARCHAR(40) NOT NULL,\ + author VARCHAR(40) NOT NULL,\ + description TEXT,\ + is_predefined INTEGER,\ + xo_name VARCHAR(50),\ + rubric_sha TEXT,\ + enable_points INTERGER)" + category_table = "CREATE TABLE category_table (category_id INTEGER PRIMARY KEY,\ + name VARCHAR(40) NOT NULL,\ + rubric_id INTEGER NOT NULL REFERENCES rubric_table(rubric_id),\ + category_sha TEXT,\ + percentage FLOAT)" + + level_table = "CREATE TABLE level_table (level_id INTEGER PRIMARY KEY,\ + name VARCHAR(40) NOT NULL,\ + description TEXT NOT NULL,\ + category_id INTEGER NOT NULL REFERENCES category_table(category_id),\ + rubric_id INTEGER NOT NULL REFERENCES rubric_table(rubric_id),\ + level_sha TEXT,\ + points INTEGER)" + + project_table = "CREATE TABLE project_table (project_id INTEGER PRIMARY KEY,\ + title VARCHAR(40) NOT NULL,\ + author VARCHAR(40) NOT NULL,\ + description TEXT,\ + subject VARCHAR(40),\ + publish_date TEXT,\ + is_owned INTEGER,\ + is_shared INTEGER,\ + rubric_id INTEGER NOT NULL REFERENCES rubric_table(rubric_id),\ + xo_name VARCHAR(50),\ + project_sha TEXT,\ + total_score FLOAT)" + + score_table = "CREATE TABLE score_table (score_id INTEGER PRIMARY KEY,\ + project_id INTEGER NOT NULL REFERENCES project_table(project_id),\ + rubric_id INTEGER NOT NULL REFERENCES rubric_table(rubric_id),\ + category_id INTEGER NOT NULL REFERENCES category_table(category_id),\ + level_id INTEGER NOT NULL REFERENCES level_table(level_id),\ + project_sha TEXT REFERENCES project_table(project_sha),\ + rubric_sha TEXT REFERENCES rubric_table(rubric_sha),\ + category_sha TEXT REFERENCES category_table(category_sha),\ + level_sha TEXT REFERENCES level_table(level_sha),\ + count INTEGER NOT NULL)" + + self.cursor.execute(rubric_table) + print "rubric table created" + self.cursor.execute(category_table) + print "category table created" + self.cursor.execute(level_table) + print "level table created" + self.cursor.execute(project_table) + print "project table created" + self.cursor.execute(score_table) + print "score table created" + + def insert_rubric(self, rubric): + temp = (rubric.title, rubric.author, rubric.description, rubric.is_predefined, + rubric.xo_name, rubric.rubric_sha, rubric.enable_points) + insert_str = "INSERT INTO rubric_table(title, author, description,is_predefined,\ + xo_name,rubric_sha,enable_points)\ + VALUES(?,?,?,?,?,?,?)" + self.cursor.execute(insert_str,temp) + self.connection.commit() + + def query_maxrubric(self): + query_str = "SELECT MAX(rubric_id) from rubric_table" + self.cursor.execute(query_str) + rubric_id = self.cursor.fetchone()[0] + return rubric_id + + def insert_criteria(self, category, levels): + temp = (category.name, category.rubric_id,category.category_sha,category.percentage) + insert_str = "INSERT INTO category_table(name,rubric_id,category_sha,percentage) VALUES (?,?,?,?)" + self.cursor.execute(insert_str, temp) + self.connection.commit() + + query_str = "SELECT MAX(category_id) from category_table" + self.cursor.execute(query_str) + category_id = self.cursor.fetchone()[0] + + insert_str = "INSERT INTO level_table(name,description,category_id,rubric_id,level_sha,points)\ + VALUES(?,?,?,?,?,?)" + for i in range(len(levels)): + temp = (levels[i].name, levels[i].description,category_id ,\ + levels[i].rubric_id, levels[i].level_sha, levels[i].points) + self.cursor.execute(insert_str, temp) + self.connection.commit() + + def insert_project(self, project): + temp = (project.title, project.author, project.description, project.subject,\ + project.publish_date, project.is_owned,\ + project.is_shared, project.rubric_id,project.xo_name,\ + project.project_sha,project.total_score) + + insert_str = "INSERT INTO project_table(title, author, description, subject,\ + publish_date, is_owned, is_shared, rubric_id,xo_name,\ + project_sha,total_score) VALUES (?,?,?,?,?,?,?,?,?,?,?)" + + self.cursor.execute(insert_str,temp) + self.connection.commit() + + def query_maxproject(self): + query_str = "SELECT MAX(project_id) from project_table" + self.cursor.execute(query_str) + project_id = self.cursor.fetchone()[0] + return project_id + + def insert_score(self, score): + temp = (score.project_id, score.rubric_id, score.category_id, score.level_id, + score.project_sha, score.rubric_sha, score.category_sha, score.level_sha, score.count) + insert_str = "INSERT INTO score_table(project_id,rubric_id,category_id,level_id,\ + project_sha, rubric_sha, category_sha, level_sha, count)\ + VALUES (?,?,?,?,?,?,?,?,?)" + self.cursor.execute(insert_str,temp) + self.connection.commit() + + def insert_category(self, category): + temp = (category.name,category.rubric_id,category.category_sha,category.percentage) + insert_str = "INSERT INTO category_table(name,rubric_id,category_sha,percentage) VALUES (?,?,?,?)" + self.cursor.execute(insert_str, temp) + self.connection.commit() + + def insert_level(self, level): + temp = (level.name, level.description, level.category_id, level.rubric_id, level.level_sha, level.points) + insert_str = "INSERT INTO level_table(name, description, category_id, rubric_id, level_sha, points) \ + VALUES(?,?,?,?,?,?)" + self.cursor.execute(insert_str, temp) + self.connection.commit() + + + def query_maxscore(self): + query_str = "SELECT MAX(score_id) from score_table" + self.cursor.execute(query_str) + score_id = self.cursor.fetchone()[0] + return score_id + + def query_maxcategory(self): + query_str = "SELECT MAX(category_id) from category_table" + self.cursor.execute(query_str) + category_id = self.cursor.fetchone()[0] + return category_id + + def queryall_rubric(self, is_predefined): + query_str = "SELECT * from rubric_table where is_predefined = "+str(is_predefined) + self.cursor.execute(query_str) + + rubric_list = [] + for row in self.cursor: + rubric = Rubric(row[0], row[1], row[2], row[3], row[4], row[5], row[6],row[7]) + rubric_list.append(rubric) + return rubric_list + + def queryall_project(self, is_owned): + query_str = "SELECT * from project_table where is_owned = "+str(is_owned) + self.cursor.execute(query_str) + + project_list = [] + for row in self.cursor: + project = Project(row[0],row[1],row[2],row[3],row[4], + row[5],row[6],row[7],row[8], row[9],row[10],row[11]) + project_list.append(project) + return project_list + + def query_rubric(self, rubric_id): + query_str = "SELECT * from rubric_table where rubric_id = "+str(rubric_id) + self.cursor.execute(query_str) + + for row in self.cursor: + rubric = Rubric(row[0],row[1],row[2],row[3],row[4],row[5],row[6],row[7]) + + return rubric + + def queryall_category(self, rubric_id): + query_str = "SELECT * from category_table where rubric_id = "+str(rubric_id) + self.cursor.execute(query_str) + + category_list = [] + for row in self.cursor: + category = Category(row[0], row[1], row[2], row[3],row[4]) + category_list.append(category) + return category_list + + def query_level(self,category_id): + + query_str = "SELECT * from level_table where category_id ="+str(category_id) + self.cursor.execute(query_str) + + level_list = [] + for row in self.cursor: + level = Level(row[0], row[1], row[2], row[3], row[4], row[5],row[6]) + level_list.append(level) + return level_list + + def querylevel_id(self, category_id, level_name): + temp = (category_id, level_name) + query_str = "SELECT level_id from level_table WHERE category_id = ? and name = ?" + self.cursor.execute(query_str,temp) + level_id = self.cursor.fetchone()[0] + return level_id + + def query_score(self, project_id, rubric_id, category_id, level_id): + temp = (project_id, rubric_id, category_id, level_id) + query_str = "SELECT count from score_table WHERE project_id = ? \ + and rubric_id = ? and category_id = ? and \ + level_id = ?" + self.cursor.execute(query_str, temp) + count = self.cursor.fetchone()[0] + return count + + def query_score2(self, project_id, rubric_id, category_id, level_id): + temp = (project_id, rubric_id, category_id, level_id) + query_str = "SELECT * from score_table WHERE project_id = ? \ + and rubric_id = ? and category_id = ? and \ + level_id = ?" + + self.cursor.execute(query_str, temp) + for row in self.cursor: + score = Score(row[0],row[1],row[2],row[3],row[4],row[5],row[6],row[7],row[8],row[9]) + return score + + def query_project_sha(self, project_id): + query_str = "SELECT project_sha from project_table WHERE project_id = "+ str(project_id) + self.cursor.execute(query_str) + + project_sha = self.cursor.fetchone()[0] + return str(project_sha) + + def query_project(self, project_id): + query_str = "SELECT * from project_table WHERE project_id ="+ str(project_id) + self.cursor.execute(query_str) + + for row in self.cursor: + project = Project(row[0],row[1],row[2],row[3],row[4],row[5],row[6],row[7],row[8],row[9],row[10],row[11]) + + return project + + def query_rubric_sha(self, rubric_id): + query_str = "SELECT rubric_sha from rubric_table WHERE rubric_id = "+ str(rubric_id) + self.cursor.execute(query_str) + + rubric_sha = self.cursor.fetchone()[0] + return str(rubric_sha) + + def query_category_sha(self, category_id): + query_str = "SELECT category_sha from category_table WHERE category_id = "+ str(category_id) + self.cursor.execute(query_str) + + category_sha = self.cursor.fetchone()[0] + return str(category_sha) + + def query_level_sha(self, level_id): + query_str = "SELECT level_sha from level_table WHERE level_id = "+ str(level_id) + self.cursor.execute(query_str) + + level_sha = self.cursor.fetchone()[0] + return str(level_sha) + + def query_score_id(self, project_sha, rubric_sha, category_sha, level_sha): + temp = (project_sha, rubric_sha, category_sha, level_sha) + query_str = "SELECT score_id from score_table WHERE project_sha = ? \ + and rubric_sha = ? and category_sha = ? and level_sha = ?" + self.cursor.execute(query_str, temp) + score_id = self.cursor.fetchone()[0] + return score_id + + def is_points_enabled(self, rubric_id): + query_str = "SELECT enable_points from rubric_table WHERE rubric_id = " + str(rubric_id) + self.cursor.execute(query_str) + enable_points = self.cursor.fetchone()[0] + if enable_points == 0: + return False + else : + return True + + def queryall_level(self, rubric_id): + query_str = "SELECT * from level_table where rubric_id = "+str(rubric_id) + self.cursor.execute(query_str) + + level_list = [] + for row in self.cursor: + level = Level(row[0],row[1],row[2],row[3],row[4],row[5],row[6]) + level_list.append(level) + return level_list + + def query_category_id(self, rubric_id, name): + temp = (rubric_id, name) + query_str = "SELECT * from category_table where rubric_id = ? and name = ?" + self.cursor.execute(query_str, temp) + category_id = self.cursor.fetchone()[0] + + return category_id + + def query_level_id(self, rubric_id, category_id, name): + temp = (rubric_id, category_id, name) + query_str = "SELECT * from level_table where rubric_id = ? and category_id = ? and name = ?" + self.cursor.execute(query_str, temp) + level_id = self.cursor.fetchone()[0] + + return level_id + + def update_project(self, modified_project): + temp = (modified_project.title,modified_project.author,modified_project.description,\ + modified_project.subject,\ + modified_project.publish_date,\ + modified_project.rubric_id,modified_project.project_sha,\ + modified_project.total_score,\ + modified_project.project_id) + update_str = "UPDATE project_table SET title = ?,"+\ + "author = ?, "+\ + "description = ?,"+\ + "subject = ?,"+\ + "publish_date = ?,"+\ + "rubric_id = ?,"+\ + "project_sha = ?"+\ + "total_score = ?"+\ + "WHERE project_id = ?" + self.cursor.execute(update_str,temp) + self.connection.commit() + + def update_levels(self, modified_levels): + + for i in modified_levels: + temp = (i.name,i.description,i.level_id,) + update_str = "UPDATE level_table SET name = ?,"+\ + "description = ?"+\ + "WHERE level_id = ?" + self.cursor.execute(update_str,temp) + self.connection.commit() + + def update_level(self, modified_level): + temp = (modified_level.name,modified_level.description,modified_level.level_id,) + update_str = "UPDATE level_table SET name = ?,"+\ + "description = ?"+\ + "WHERE level_id = ?" + self.cursor.execute(update_str,temp) + self.connection.commit() + + def update_categories(self, modified_categories): + for i in modified_categories: + temp = (i.name,i.rubric_id,i.category_id) + update_str = "UPDATE category_table SET name = ?"+\ + "WHERE rubric_id = ? and category_id = ?" + self.cursor.execute(update_str,temp) + self.connection.commit() + + def update_category(self, modified_category): + temp = (modified_category.name,modified_category.rubric_id,modified_category.category_id) + update_str = "UPDATE category_table SET name = ?"+\ + "WHERE rubric_id = ? and category_id = ?" + self.cursor.execute(update_str,temp) + self.connection.commit() + + def update_rubric(self, modified_rubric): + temp = (modified_rubric.title,modified_rubric.author,modified_rubric.description,modified_rubric.enable_points, + modified_rubric.rubric_id) + update_str = "UPDATE rubric_table SET title = ?,"+\ + "author = ?, "+\ + "description = ?,"+\ + "enable_points = ?"+\ + "WHERE rubric_id = ?" + self.cursor.execute(update_str,temp) + self.connection.commit() + + def update_percentage(self, category_id, percentage): + temp = (percentage, category_id) + update_str = "UPDATE category_table SET percentage = ?"+\ + "WHERE category_id = ?" + self.cursor.execute(update_str, temp) + self.connection.commit() + + def update_points(self, category_id, level_name, points): + temp = (points, category_id, level_name) + update_str = "UPDATE level_table SET points = ?"+\ + "WHERE category_id = ? and name = ?" + self.cursor.execute(update_str, temp) + self.connection.commit() + + def update_enablepoints(self, rubric_id, is_enable): + temp = (is_enable, rubric_id) + update_str = "UPDATE rubric_table SET enable_points = ?"+\ + "WHERE rubric_id = ?" + self.cursor.execute(update_str, temp) + self.connection.commit() + + + + def delete_project(self, project_id): + delete_str = "DELETE FROM project_table WHERE project_id ="+ str(project_id) + self.cursor.execute(delete_str) + + self.connection.commit() + + def delete_rubric(self, rubric_id): + delete_str = "DELETE FROM rubric_table WHERE rubric_id ="+ str(rubric_id) + self.cursor.execute(delete_str) + + delete_str = "DELETE FROM category_table WHERE rubric_id ="+ str(rubric_id) + self.cursor.execute(delete_str) + + delete_str = "DELETE FROM level_table WHERE rubric_id ="+ str(rubric_id) + self.cursor.execute(delete_str) + + self.connection.commit() + + def score_exists(self, project_id, rubric_id, category_id, level_id): + temp = (project_id, rubric_id, category_id, level_id) + query_str = "SELECT * FROM score_table WHERE project_id = ? and rubric_id = ? and \ + category_id = ? and level_id = ?" + + self.cursor.execute(query_str, temp) + for row in self.cursor: + score = Score(row[0],row[1],row[2],row[3],row[4],row[5],row[6],\ + row[7],row[8],row[9]) + + try: + if score.score_id == None: + return False + else: + return True + except: + return False + + def project_exists(self, project_sha, author): + temp = (project_sha, author) + query_str = "SELECT * FROM project_table WHERE project_sha = ? and author = ?" + + self.cursor.execute(query_str, temp) + for row in self.cursor: + project = Project(row[0],row[1],row[2],row[3],row[4],row[5],row[6],\ + row[7],row[8],row[9],row[10],row[11]) + + try: + if project.project_id == None: + return False + else: + return True + except: + return False + + def rubric_exists(self, rubric_sha, description): + temp = (rubric_sha, description) + query_str = "SELECT * FROM rubric_table WHERE rubric_sha = ? and description = ?" + + self.cursor.execute(query_str, temp) + for row in self.cursor: + rubric = Rubric(row[0],row[1],row[2],row[3],row[4],row[5],row[6],row[7]) + + try: + if rubric.rubric_id == None: + return None + else: + return rubric.rubric_id + except: + return None + + def rubric_title_exists(self, rubric_title): + query_str = "SELECT * FROM rubric_table WHERE title = \'" + str(rubric_title) +"\'" + self.cursor.execute(query_str) + count = 0 + for row in self.cursor: + rubric = Rubric(row[0],row[1],row[2],row[3],row[4],row[5],row[6],row[7]) + count = count+1 + + try: + if rubric.rubric_id == None: + return None + else: + return count + except: + return None + + def query_score_attr(self, score_id): + query_str = "SELECT * from score_table WHERE score_id = " + str(score_id) + self.cursor.execute(query_str) + + for row in self.cursor: + score = Score(row[0],row[1],row[2],row[3],row[4],row[5],row[6],\ + row[7],row[8],row[9]) + + attr = [score.project_id, score.rubric_id, score.category_id, score.level_id] + return attr + + + def increment_scorecount(self, project_id, rubric_id, category_id, level_id): + temp = (project_id, rubric_id, category_id, level_id) + query_str = "SELECT * FROM score_table WHERE project_id = ? and rubric_id = ? and \ + category_id = ? and level_id = ?" + self.cursor.execute(query_str, temp) + + for row in self.cursor: + score = Score(row[0],row[1],row[2],row[3],row[4],row[5],row[6],row[7],row[8],row[9]) + + score_id = score.score_id + count = score.count + count = count +1 + temp = (count, score_id) + update_str = "UPDATE score_table SET count = ?"+\ + "WHERE score_id = ?" + self.cursor.execute(update_str, temp) + self.connection.commit() + return score_id + + def close_db(self): + self.cursor.close() + +class Project(): + + def __init__(self, project_id = 0, title = "", author = "", + description = "", subject = "", publish_date = "", + is_owned = 1, is_shared = 1, rubric_id = None, xo_name = "", + project_sha = "", total_score = 0): + self.project_id = project_id + self.title = title + self.author = author + self.description = description + self.subject = subject + self.publish_date = publish_date + self.is_owned = is_owned + self.is_shared = is_shared + self.rubric_id = rubric_id + self.xo_name = xo_name + self.project_sha = self.get_sha(xo_name, title, publish_date) + self.total_score = total_score + + + def get_sha(self, xo_name, title, publish_date): + text = xo_name + title + str(publish_date) + h = hashlib.sha1() + h.update(text) + project_sha = str(h.hexdigest()) + + return project_sha + + + +class Rubric(): + + def __init__(self, rubric_id = 0, title = "", author = "", description = "",\ + is_predefined =None, xo_name = "", rubric_sha = "", enable_points = 0): + self.rubric_id = rubric_id + self.title = title + self.author = author + self.description = description + self.is_predefined = is_predefined + self.xo_name = xo_name + self.rubric_sha = self.get_sha(xo_name, title, author) + self.enable_points = enable_points + + def get_sha(self, xo_name, title, author): + text = xo_name + title + author + h = hashlib.sha1() + h.update(text) + rubric_sha = str(h.hexdigest()) + + return rubric_sha + + +class Category(): + + def __init__(self, category_id = None, name = "", rubric_id = None, + category_sha = "", percentage = 0.0): + self.category_id = category_id + self.name = name + self.rubric_id = rubric_id + self.category_sha = self.get_sha(name) + self.percentage = percentage + + def get_sha(self, name): + text = name + h = hashlib.sha1() + h.update(text) + category_sha = str(h.hexdigest()) + + return category_sha + + +class Level(): + + def __init__(self, level_id = None, name = "", description = "", + category_id = None, rubric_id = None, + level_sha = "", points = 0): + self.level_id = level_id + self.name = name + self.description = description + self.category_id = category_id + self.rubric_id = rubric_id + self.level_sha = self.get_sha(name,description) + self.points = points + + def get_sha(self, name, description): + text = name + description + h = hashlib.sha1() + h.update(text) + level_sha = str(h.hexdigest()) + + return level_sha + +class Score(): + + def __init__(self, score_id = 0, project_id = None, rubric_id = None, category_id = None,level_id = None, + project_sha = "", rubric_sha = "", category_sha = "", level_sha = "",count = 0): + self.score_id = score_id + self.project_id = project_id + self.rubric_id = rubric_id + self.category_id = category_id + self.level_id = level_id + self.project_sha = project_sha + self.rubric_sha = rubric_sha + self.category_sha = category_sha + self.level_sha = level_sha + self.count = count |