Esempio n. 1
0
class CommentDAO:
    def __init__(self):
        self.session = MysqlUtil().get_session()

    def new_comment(self, art_id, content):
        if ArticleDao().get_article_by_id(art_id) is None:
            return False, u'评论的文章不存在'
        else:
            comment = Comment()
            comment.article_id = art_id
            comment.comment = content
            comment.user = current_user.username
            self.session.add(comment)
            self.session.commit()
            return True, u'评论成功!'

    def get_article_comments_num(self, art_id):
        return self.session.query(Comment) \
            .filter_by(article_id=art_id).count()

    def get_comments_by_article(self, article_id, page=0, size=20):
        article_num = self.get_article_comments_num(article_id)
        if page * size > article_num:
            return None, u'分页数超出最大值'
        info = u'more' if (page + 1) * size < article_num else u'nomore'
        return self.session.query(Comment)\
                   .filter_by(article_id=article_id)\
                   .order_by(desc(Comment.modified_time)).offset(size * page).limit(size).all(), info
Esempio n. 2
0
def init_db():
    conf = ConfigUtil()
    host = conf.get_config(conf='host', section='db_info')
    port = conf.get_config(conf='port', section='db_info')
    username = conf.get_config(conf='username', section='db_info')
    password = conf.get_config(conf='password', section='db_info')
    database = conf.get_config(conf='database', section='db_info')

    conn = MySQLdb.connect(host=host,
                           user=username,
                           passwd=password,
                           port=int(port))
    cur = conn.cursor()
    sql = 'CREATE DATABASE IF NOT EXISTS `{db}` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;'.format(
        db=database)

    cur.execute(sql)
    conn.commit()
    cur.close()
    conn.close()

    session = MysqlUtil().get_session()
    BaseModel.metadata.create_all(MysqlUtil().get_engine())

    email = conf.get_config('email', 'admin_account')
    if session.query(User).filter_by(email=email).first() is None:
        password = conf.get_config('password', 'admin_account')
        username = conf.get_config('username', 'admin_account')

        user = User(username=username,
                    password=generate_password_hash(password),
                    email=email,
                    status=1,
                    is_admin=1,
                    register_time=datetime.datetime.now(),
                    last_login_time=datetime.datetime.now())
        session.add(user)
        session.commit()
Esempio n. 3
0
class CategoryDAO:
    def __init__(self):
        self.session = MysqlUtil().get_session()

    def add_category(self, cate_name):
        if self.get_cate_by_name(cate_name) is None:
            cate = Category(cate_name=cate_name)
            self.session.add(cate)
            self.session.commit()
            return True, u'成功添加新分类'
        else:
            return False, u'类目已经存在'

    def get_cate_by_name(self, cate_name):
        cate = self.session.query(Category).filter_by(
            cate_name=cate_name).first()
        if cate is not None:
            return cate
        else:
            return None

    def get_cate_by_id(self, cate_id):
        cate = self.session.query(Category).filter_by(id=cate_id).first()
        if cate is not None:
            return cate
        else:
            return None

    def get_categories(self):
        return self.session.query(Category).all()

    def delete_category(self, cate_id):
        cate = self.get_cate_by_id(cate_id)
        if cate is not None:
            self.session.delete(cate)
            self.session.commit()
            return True, u'删除成功'
        else:
            return False, u'删除失败,删除的类目不存在!'

    def update_category(self, cate_id, cate_name):
        cate = self.get_cate_by_id(cate_id)
        if cate is not None:
            if self.get_cate_by_id(cate_name) is None:
                cate.cate_name = cate_name
                cate.modify_time = datetime.datetime.utcnow()
                self.session.commit()
                return True, u'修改成功!'
            else:
                return False, u'修改的类目名称已经存在!'
        else:
            return False, u'指定ID的类目不存在!'
Esempio n. 4
0
class AuthorDAO():
    def __init__(self):
        self.session = MysqlUtil().get_session()

    def get_authors(self):
        return self.session.query(Author).all()

    def get_author_by_name(self, auth_name):
        return self.session.query(Author).filter_by(name=auth_name).first()

    def get_author_by_id(self, auth_id):
        return self.session.query(Author).filter_by(id=auth_id).first()

    def add_author(self, auth_name):
        if self.get_author_by_name(auth_name) is None:
            auth = Author(name=auth_name)
            self.session.add(auth)
            self.session.commit()
            return True, u'添加成功'
        else:
            return False, u'作者已经存在!'

    def delete_author(self, auth_name):
        auth = self.get_author_by_name(auth_name)
        if auth is None:
            return False, u'作者不存在!'
        self.session.delete(auth)
        self.session.commit()
        return True, u'删除作者成功!'

    def update_author(self, auth_id, auth_name):
        auth = self.get_author_by_name(auth_name)
        if auth is not None:
            return False, u'作者名已经存在!'
        else:
            auth = self.get_author_by_id(auth_id)
            auth.name = auth_name
            self.session.commit()
            return True, u'修改成功!'
Esempio n. 5
0
class ArticleDao:
    def __init__(self):
        self.session = MysqlUtil().get_session()

    def get_articles(self, page=0, size=20):
        article_num = self.get_article_num()
        if page * size > article_num:
            return None, u'分页数超出最大值'
        info = u'more' if (page + 1) * size < article_num else u'nomore'
        return self.session.query(Article).order_by(desc(
            Article.modified_time)).offset(size * page).limit(size).all(), info

    def get_article_num(self):
        return self.session.query(Article).count()

    def get_article_by_title(self, title):
        return self.session.query(Article).filter_by(title=title).first()

    def get_article_by_id(self, id):
        return self.session.query(Article).filter_by(id=id).first()

    def new_article(self, title, author_id, author_name, cate_id, cate_name,
                    intro, filepath, tags):
        article = Article(title=title,
                          intro=intro,
                          is_public=1,
                          auth_id=author_id,
                          auth_name=author_name,
                          cate_id=cate_id,
                          cate_name=cate_name,
                          file_path=filepath,
                          tags=tags,
                          create_time=datetime.datetime.now(),
                          modified_time=datetime.datetime.now())

        if self.get_article_by_title(title) is None:
            self.session.add(article)
            self.session.commit()
            return True, u'成功添加新文章!'
        else:
            return False, u'文章标题已经存在!'

    def delete_article(self, article):
        self.session.delete(article)
        self.session.commit()
        return True, u'删除成功!'

    def get_articles_by_cate(self, cate, page=0, size=20):
        article_num = self.get_article_num()
        if page * size > article_num:
            return None, u'分页数超出最大值'
        info = u'more' if (page + 1) * size < article_num else u'nomore'
        return self.session.query(Article).filter_by(cate_id=cate).order_by(
            desc(Article.modified_time)).offset(size *
                                                page).limit(size).all(), info

    def get_article_by_tag(self, tag, page=0, size=20):
        article_num = self.get_article_num()
        if page * size > article_num:
            return None, u'分页数超出最大值'
        info = u'more' if (page + 1) * size < article_num else u'nomore'
        return self.session.query(Article)\
                   .filter(Article.tags.like(u'%{tag}%'.format(tag=tag)))\
                   .order_by(desc(Article.modified_time)).offset(size * page).limit(size).all(), info