计算机毕业设计选题推荐-小说阅读平台-Python项目实战

IT研究室

已于 2023-10-29 00:31:16 修改

阅读量179

点赞数

分类专栏： Python项目文章标签： python django 毕业设计选题推荐源码

于 2023-09-20 10:15:40 首次发布

本文链接： https://blog.csdn.net/2301_79456892/article/details/133054745

版权

Python项目专栏收录该内容

127 篇文章 12 订阅

订阅专栏

✨作者主页：IT研究室✨
个人简介：曾从事计算机专业培训教学，擅长Java、Python、微信小程序、Golang、安卓Android等。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。
☑文末获取源码☑
精彩专栏推荐⬇⬇⬇
Java项目
Python项目
安卓项目
微信小程序项目

文章目录

一、前言
二、开发环境
三、系统功能模块
四、系统界面展示
五、部分代码设计
六、论文参考
七、系统视频
结语

一、前言

在数字化时代，网络文学的发展迅猛，其中小说阅读平台作为网络文学的重要载体，已经成为了大众获取和分享文学作品的重要渠道。随着科技的发展和人们阅读习惯的改变，小说阅读平台的功能也在不断拓展和优化。然而，这种改变不仅带来了新的机遇，也带来了新的挑战。如何更好地满足会员的阅读需求，提高阅读体验，同时保证平台的管理效率和安全性，成为了当前亟待解决的问题。

当前的小说阅读平台虽然已经具备了基本的阅读和管理功能，但在一些方面仍然存在明显的问题。首先，会员的使用体验往往受到制约，例如下载小说的速度和评分管理的公正性等方面。其次，管理人员的管理效率低下，例如小说分类和章节管理等方面的操作繁琐且容易出错。此外，现有的平台往往缺乏对会员和管理人员的隐私保护，存在一定的安全隐患。

本课题旨在研究一种新型的小说阅读平台，该平台能够更好地满足会员的阅读需求和管理人员的管理需求。具体来说，我们的研究目标包括：
提高会员的阅读体验：通过优化下载小说和评分管理的功能，提高会员的使用便利性和满意度。
提高管理人员的管理效率：通过自动化和智能化的管理工具，减少管理人员的操作繁琐度，提高管理效率。
加强隐私保护：通过采用先进的加密技术和隐私保护算法，保护会员和管理人员的隐私安全。

本课题的研究成果将具有重要的理论和实践意义。首先，从理论角度来看，我们将为网络文学的发展提供新的理论支撑和实践经验。其次，从实践角度来看，我们的研究成果将直接应用于实际的软件开发中，为小说阅读平台的优化和升级提供指导。此外，我们的研究还将对其他网络平台的管理提供借鉴和参考。

二、开发环境

开发语言：Python
数据库：MySQL
系统架构：B/S
后端：Django
前端：Vue

三、系统功能模块

角色：会员、管理员
功能：
会员：
站内新闻、小说档案、论坛交流、公告、下载小说、说评分管理；
管理员：
会员管理、小说分类管理、章节管理、站内新闻管理、小说档案管理、小说评分管理、论坛交流、公告管理。

四、系统界面展示

小说阅读平台-界面展示：

五、部分代码设计

Python项目实战-代码参考：

class IssueBook(View):  # 发布书
    def post(self, request):
        request_data = request.body
        try:
            request_dict = json.loads(request_data.decode('utf-8'))
        except JSONDecodeError as e:
            return JsonResponse({'code': 4, 'msg': f'请求数据为空,解析失败[info:{str(e)}]'})
        novel_name = request_dict.get('novel_name', '').replace(' ', '').lower()
        n = NovelModel.objects.filter(novel_name=novel_name, is_delete=False)
        if n.count(): return JsonResponse({'code': 1, 'msg': '发布书本已存在！', 'version': version, 'uid': n.first().uuid})
        request_dict.update({'uuid': uuid.uuid4(), 'novel_name': novel_name})
        result = NovelModel.objects.create(**request_dict)  # 创建数据
        return JsonResponse({'code': 0, 'msg': 'success', 'version': version, 'uid': result.uuid})


class IssueChapter(View):  # 发布章节
    def post(self, request):
        request_data = request.body
        try:
            request_dict = json.loads(request_data.decode('utf-8'))
        except JSONDecodeError as e:
            return JsonResponse({'code': 4, 'msg': '请求数据为空,解析失败'})
        c = ChapterModel.objects.filter(title=request_dict['title'], novel=request_dict['novel_id'], is_delete=False)
        if c.count(): return JsonResponse({'code': 1, 'msg': '发布书本已存在！', 'version': version, 'uid': c.first().content_id})
        content = request_dict['content']
        content_id, content_path = lib_compress(content)
        data = {'uuid': uuid.uuid4(), 'title': request_dict['title'], 'novel_id': request_dict['novel_id'], 'is_pay': request_dict.get('is_pay', False), 'content_id': content_id,
                'content_path': content_path}
        result = ChapterModel.objects.create(**data)  # decompress(result.content_path,result.content_id) # 解码
        return JsonResponse({'code': 0, 'msg': 'success', 'version': version, 'cid': result.uuid})

class SystemPage(View):  # 站点设置

    @method_decorator(login_required)
    def get(self, request):
        system = SystemModel.objects.first()
        if system is None:
            system = SystemModel()  # todo 建议统一处理初始化系统
            system.save()
        return render(request, 'set_system.html', context={'data': dict(system)})

    @method_decorator(login_required)
    def post(self, request):
        return update_data(request, SystemForm, SystemModel, request.POST.get('uuid'))

    def http_method_not_allowed(self, request, *args, **kwargs):
        return HttpResponse(f'限制的{request.method}请求，请使用其他请求！')


class NavigationList(View):  # 分类列表

    @method_decorator(login_required)
    def get(self, request):
        return render(request, 'navigationList.html', context={'NavList': NavigationModel.objects.order_by('-create_time').filter(is_delete=False).all()})

    @method_decorator(login_required)
    def delete(self, request):
        uuid = QueryDict(request.body).get('uuid')
        return delete_data(uuid, NavigationModel)


class Navigation(View):  # 添加分类

    @method_decorator(login_required)
    def get(self, request):
        data = categoryList(NavigationModel.objects.filter(is_delete=False).values_list('uuid', 'column_name', 'column_parent'))
        return JsonResponse({'code': 0, 'category': data})

    @method_decorator(login_required)
    def post(self, request):
        return create_data(request, NavigationForm, NavigationModel)


class NavigationEdit(View):  # 修改分类

    @method_decorator(login_required)
    def get(self, request):
        uuid = request.GET.get('uuid', 'None')
        obj = NavigationModel.objects.filter(uuid=uuid).first()
        if not verify_obj(obj): return JsonResponse({'code': 4, 'msg': '参数错误', 'error': '未成功获取数据'})
        return JsonResponse({"code": 0, 'data': dict(obj)})

    @method_decorator(login_required)
    def post(self, request):
        uuid = request.POST.get('uuid', 'None')
        if uuid == request.POST.get('column_parent'): return JsonResponse({'code': 1, 'msg': '更新数据失败', 'error': '上级分类不可选择自己'})
        return update_data(request, NavigationEditForm, NavigationModel, uuid)


class NovelList(View):  # 小说列表

    @method_decorator(login_required)
    def get(self, request):
        search = request.GET.get('search')
        if search:
            data_list, page = PaginatorPage(request, NovelModel.objects.filter(novel_name=search).all())
        else:
            data_list, page = PaginatorPage(request, NovelModel.objects.order_by('-create_time').all())
        return render(request, 'novelList.html', context={'novelList': data_list, 'page': page})

    @method_decorator(login_required)
    def delete(self, request):
        uuid = QueryDict(request.body).get('uuid')
        try:
            obj = NovelModel.objects.filter(uuid=uuid).first()
            if not verify_obj(obj): return JsonResponse({'code': 1, 'msg': '删除数据失败', 'error': '参数有误，未检测到数据'})
            ChapterModel.objects.filter(novel=obj).delete()
            obj.delete()
        except Exception as e:
            return JsonResponse({'code': 4, 'msg': '删除数据异常', 'error': str(e)})
        return JsonResponse({'code': 0, 'msg': '删除数据成功'})

    @method_decorator(login_required)
    def post(self, request):
        uuidList = request.POST.get('uuidList').split('|*TL*|')
        if not uuidList: return JsonResponse({'code': 1, 'msg': '删除数据失败', 'error': '参数有误，未检测到参数'})
        for uuid in uuidList:
            try:
                obj = NovelModel.objects.filter(uuid=uuid)
                if not obj.first(): continue
                ChapterModel.objects.filter(novel=obj).delete()
                obj.delete()
            except Exception as e:
                return JsonResponse({'code': 4, 'msg': '删除数据异常', 'error': str(e)})
        return JsonResponse({'code': 0, 'msg': f'删除{len(uuidList)}条数据成功'})


class CommentView(View):  # 评论列表

    @method_decorator(login_required)
    def get(self, request):
        search = request.GET.get('search')
        if search:
            novel = NovelModel.objects.filter(novel_name=search).first()
            data_list, page = PaginatorPage(request, Comment_Model.objects.filter(content_uuid=novel).all())
        else:
            data_list, page = PaginatorPage(request, Comment_Model.objects.order_by('-create_time').all())
        return render(request, 'commentList.html', context={'dataList': data_list, 'page': page})

    @method_decorator(login_required)
    def delete(self, request):
        uuid = QueryDict(request.body).get('uuid')
        return delete_data(uuid, Comment_Model)


class LinkView(View):  # 链接列表

    @method_decorator(login_required)
    def get(self, request):
        data_list, page = PaginatorPage(request,
                                        Blogroll_Model.objects.order_by('-create_time').all().values('uuid', 'update_time', 'link_name', 'link_url', 'link_end_date',
                                                                                                     'link_remark'))
        return render(request, 'linkList.html', context={'dataList': data_list, 'page': page})

    @method_decorator(login_required)
    def delete(self, request):
        uuid = QueryDict(request.body).get('uuid')
        return delete_data(uuid, Blogroll_Model)

    @method_decorator(login_required)
    def post(self, request):
        return create_data(request, LinkForm, Blogroll_Model)


class AdView(View):

    @method_decorator(login_required)
    def get(self, request):
        data_list, page = PaginatorPage(request, Ad_Model.objects.order_by('-create_time').all().values('uuid', 'update_time', 'ad_name', 'ad_end_date', 'ad_remark'))
        return render(request, 'adList.html', context={'dataList': data_list, 'page': page})

    @method_decorator(login_required)
    def post(self, request):
        return create_data(request, AdForm, Ad_Model)

    @method_decorator(login_required)
    def delete(self, request):
        uuid = QueryDict(request.body).get('uuid')
        return delete_data(uuid, Ad_Model)


class SaveMode(View):
    @method_decorator(login_required)
    def get(self, request):
        obj = Save_Model.objects.first()
        if not obj: obj = Save_Model.objects.create()  # todo 建议统一初始化

        return render(request, 'save.html', {'data': dict(obj)})

    @method_decorator(login_required)
    def post(self, request):
        uuid = request.POST.get('uuid')
        return update_data(request, SaveForm, Save_Model, uuid)


class NormalAccess(View):
    @method_decorator(login_required)
    def get(self, request):
        result = [{}]
        result_list = conn.hgetall('NormalAccess')
        for k, v in result_list.items():
            value = json.loads(v.decode())
            value['ip'] = k.decode()
            b = (time.time() - value['first_time']) > NORMAL_AUTH_TIME
            if not b: result.append(value)
        dataList, page = access_auto_page(request, result)
        return render(request, 'normalList.html', context={'dataList': dataList, 'page': page})

    @method_decorator(login_required)
    def post(self, request):
        ip = request.POST.get('ip')
        try:
            try:
                d = json.loads(conn.hget('NormalAccess', ip).decode())
            except Exception as e:
                return JsonResponse({'code': 4, 'msg': f'IP读取出错:{e}'})
            d['freeze_time'] = time.time()
            result = conn.hset('FreezeAccess', ip, json.dumps(d))
            if result:
                conn.hdel('NormalAccess', ip)
                return JsonResponse({'code': 0})
            return JsonResponse({'code': 1, 'msg': '冻结失败，或已存在冻结'})
        except Exception as e:
            return JsonResponse({'code': 4, 'msg': f'冻结处理异常：{str(e)}'})

    @method_decorator(login_required)
    def delete(self, request):
        ip = QueryDict(request.body).get('uuid')
        return delete_access(conn, ip, 'NormalAccess')


class FreezeAccess(View):
    @method_decorator(login_required)
    def get(self, request):
        result = [{}]
        result_list = conn.hgetall('FreezeAccess')
        for k, v in result_list.items():
            value = json.loads(v.decode())
            value['ip'] = k.decode()
            b = ((time.time() - value['freeze_time']) / 60) >= FREEZE_TIME
            if not b: result.append(value)
        dataList, page = access_auto_page(request, result)
        return render(request, 'freezeList.html', context={'dataList': dataList, 'page': page})

    @method_decorator(login_required)
    def post(self, request):
        ip = request.POST.get('ip')
        try:
            try:
                d = json.loads(conn.hget('FreezeAccess', ip).decode())
            except Exception as e:
                return JsonResponse({'code': 4, 'msg': f'IP读取出错:{e}'})
            d['forbid_time'] = time.time()
            result = conn.hset('ForbidAccess', ip, json.dumps(d))
            if result:
                conn.hdel('FreezeAccess', ip)
                return JsonResponse({'code': 0})
            return JsonResponse({'code': 1, 'msg': '添加黑名单失败，或已存在黑名单'})
        except Exception as e:
            return JsonResponse({'code': 4, 'msg': f'处理异常：{str(e)}'})

    @method_decorator(login_required)
    def delete(self, request):
        ip = QueryDict(request.body).get('uuid')
        return delete_access(conn, ip, 'FreezeAccess')


class ForbidAccess(View):
    @method_decorator(login_required)
    def get(self, request):
        result = [{}]
        result_list = conn.hgetall('ForbidAccess')
        for k, v in result_list.items():
            value = json.loads(v.decode())
            value['ip'] = k.decode()
            result.append(value)
        dataList, page = access_auto_page(request, result)
        return render(request, 'forbidList.html', context={'dataList': dataList, 'page': page})

    @method_decorator(login_required)
    def delete(self, request):
        ip = QueryDict(request.body).get('uuid')
        return delete_access(conn, ip, 'ForbidAccess')

class Navigation(View):
    def get(self, request):
        Nav_List = NavigationModel.objects.order_by('-column_order').filter(is_delete=False).all()
        run_data = lambda x, y: x if y in x else x + [y]
        res = reduce(run_data, [[], ] + navigationList(Nav_List))
        column_display = [dict(o) for o in NavigationModel.objects.order_by('-column_order').filter(is_delete=False, column_display=True).all()]
        return JsonResponse({'code': 0, 'msg': 'success', 'nav_all': res, 'column_display': column_display}, json_dumps_params={'ensure_ascii': False})


class GetNovel(View):
    def get(self, request):
        limit = request.GET.get('limit', 10)
        type = request.GET.get('type', 'newest')  # 默认最新
        try:
            limit = int(limit)
        except:
            limit = 10
        if limit > 100 or limit < 0: limit = 10
        if type == 'hot':
            row_list = NovelModel.objects.order_by('-create_time').order_by('-novel_click').filter(is_delete=False).all()
        elif type == 'random':
            row_list = list(NovelModel.objects.filter(is_delete=False).all())
            shuffle(row_list)
        elif type == 'focus':
            row_list = NovelModel.objects.order_by('-create_time').filter(is_delete=False, novel_is_focus=True).all()
        else:
            row_list = NovelModel.objects.order_by('-create_time').filter(is_delete=False).all()
        dataList = row_list[:limit]
        return JsonResponse({'code': 0, 'dataList': [novelSerialize(d) for d in dataList]})


class NavigationNovel(View):
    def get(self, request):
        nav_list = NavigationModel.objects.order_by('-column_order').filter(is_delete=False, column_index_show=True).all()
        limit = request.GET.get('limit', 6)
        try:
            limit = int(limit)
        except:
            limit = 6  # 默认六条
        if limit > 100 or limit < 0: limit = 6
        dataList = []
        for obj in nav_list:
            nav = dict(obj)
            nav['novelList'] = [dict(n) for n in obj.novel_categories.all()][::-1][:limit]
            for d in nav['novelList']: d.pop('categories')
            dataList.append(nav)
        return JsonResponse({'code': 0, 'navNovel': dataList})


class Links(View):
    def get(self, request):
        links = [dict(b) for b in Blogroll_Model.objects.order_by('-create_time').order_by('-link_sort').filter(is_delete=False, link_end_date__gte=datetime.now()).all()]
        return JsonResponse({'code': 0, 'links': links})


class SortNovel(View):
    def get(self, request):
        uuid = request.GET.get('uid')
        nav = NavigationModel.objects.filter(is_delete=False, uuid=uuid).first()
        novelList = list(nav.novel_categories.all()[::-1])
        data, page = PaginatorPage(request, novelList)
        dataList = [novelSerialize(da, 5) for da in data]
        num = request.GET.get('page', '1')
        try:
            num = int(num)
        except:
            num = 1
        sortData = {'novelList': dataList, 'count': page.count, 'num_pages': page.num_pages, 'page_range': [p for p in page.page_range],
                    'has_next': data.has_next(), 'has_previous': data.has_previous(), 'currentPage': num}
        return JsonResponse({'code': 0, 'data': sortData})


class BookData(View):
    def get(self, request):
        uuid = request.GET.get('book_id')
        try:
            book = NovelModel.objects.filter(is_delete=False, uuid=uuid).first()
        except Exception as e:
            return JsonResponse({'code': 1, 'msg': '参数错误', 'error': str(e)})
        if book:
            try:
                data = novelSerialize(book)
                data['chapter'] = data['chapter'][::-1]
                return JsonResponse({'code': 0, 'bookData': data})
            except Exception as e:
                return JsonResponse({'code': 1, 'msg': '处理异常', 'error': f'[info]：{str(e)}'})
        return JsonResponse({'code': 1, 'msg': '参数错误', 'error': '参数非法'})


class GetOther(View):
    def get(self, request):
        if request.GET.get('cls') == reverse('web_system:rankingList'):  # 排行榜
            novelList = NovelModel.objects.order_by('-novel_click').order_by('-novel_love').order_by('-novel_praise').filter(is_delete=False)
        elif request.GET.get('cls') == reverse('web_system:overList'):  # 完本
            novelList = NovelModel.objects.order_by('-create_time').filter(is_delete=False, novel_state=True)
        elif request.GET.get('cls') == reverse('web_system:serializeList'):  # 连载
            novelList = NovelModel.objects.order_by('-create_time').filter(is_delete=False, novel_state=False)
        else:
            return JsonResponse({'code': 0, 'msg': '超出范围'})
        data, page = PaginatorPage(request, novelList)
        dataList = [novelSerialize(da, 5) for da in data]
        num = request.GET.get('page', '1')
        try:
            num = int(num)
        except:
            num = 1
        sortData = {'novelList': dataList, 'count': page.count, 'num_pages': page.num_pages, 'page_range': [p for p in page.page_range],
                    'has_next': data.has_next(), 'has_previous': data.has_previous(), 'currentPage': num}
        return JsonResponse({'code': 0, 'data': sortData})


class Search(View):
    def get(self, request):
        search_keywords = request.GET.get('keywords', '')
        novelList = NovelModel.objects.filter(
            Q(novel_name__icontains=search_keywords) | Q(novel_author__icontains=search_keywords) | Q(novel_description__icontains=search_keywords) | Q(
                novel_key__icontains=search_keywords))
        data, page = PaginatorPage(request, novelList)
        dataList = [novelSerialize(da, 5) for da in data]
        num = request.GET.get('page', '1')
        try:
            num = int(num)
        except:
            num = 1
        sortData = {'novelList': dataList, 'count': page.count, 'num_pages': page.num_pages, 'page_range': [p for p in page.page_range],
                    'has_next': data.has_next(), 'has_previous': data.has_previous(), 'currentPage': num}
        return JsonResponse({'code': 0, 'data': sortData})