Example #1
0
    def post(self, *args, **kwargs):
        rep = BaseResponse()
        form = account.SendMsgForm()
        if form.valid(self):
            email = form._value_dict['email']
            conn = ORM.session()

            has_exists_email = conn.query(ORM.UserInfo).filter(
                ORM.UserInfo.email == form._value_dict['email']).count()
            print(has_exists_email, "@@@@", form._value_dict['email'])
            if has_exists_email:
                rep.summary = "此邮箱已经被注册"
                self.write(json.dumps(rep.__dict__))
                return
            current_date = datetime.datetime.now()
            code = commons.random_code()

            count = conn.query(
                ORM.SendMsg).filter_by(**form._value_dict).count()
            if not count:
                insert = ORM.SendMsg(code=code,
                                     email=email,
                                     ctime=current_date)
                conn.add(insert)
                conn.commit()
                rep.status = True
            else:
                limit_day = current_date - datetime.timedelta(hours=1)
                times = conn.query(ORM.SendMsg).filter(
                    ORM.SendMsg.email == email,
                    ORM.SendMsg.ctime > limit_day,
                    ORM.SendMsg.times >= 10,
                ).count()
                if times:
                    rep.summary = "'已经超过今日最大次数(1小时后重试)'"
                else:
                    unfreeze = conn.query(ORM.SendMsg).filter(
                        ORM.SendMsg.email == email,
                        ORM.SendMsg.ctime < limit_day).count()
                    if unfreeze:
                        conn.query(ORM.SendMsg).filter_by(email=email).update(
                            {"times": 0})

                    conn.query(ORM.SendMsg).filter_by(email=email).update(
                        {
                            "times": ORM.SendMsg.times + 1,
                            "code": code,
                            "ctime": current_date
                        },
                        synchronize_session="evaluate")
                    conn.commit()
                    rep.status = True
            conn.close()
        else:
            rep.summary = form._error_dict['email']
        self.write(json.dumps(rep.__dict__))
def send_msg(req):
    '''
    该功能主要用于注册时候发送,邮箱验证码
    :param req:
    :return:
    '''
    rep = BaseResponse()  # 拿取接口需要返回的字段以及初始默认值
    form = SendMsgForm(req.POST)  # 拿取前端返回的数据进行邮箱校验
    if form.is_valid():
        _value_dict = form.clean()  # 如果信息正确输入,则拿取到正确的信息
        email = _value_dict['email']
        email_list = [email]

        has_exists_email = models.UserInfo.objects.filter(
            email=email).count()  # 如果有值则提示用户已经注册了
        if has_exists_email:
            rep.summary = "此邮箱号,已被注册!"
            return HttpResponse(json.dumps(rep.__dict__))
        current_date = datetime.datetime.now()  # 获取一个当前时间
        code = commons.random_code()  # 产生一个4位的随机验证码

        count = models.SendMsg.objects.filter(
            email=email).count()  # 统计发送了短信验证码的次数
        if not count:  # 如果没有发送则发送,在表中记录
            models.SendMsg.objects.create(code=code,
                                          email=email,
                                          ctime=current_date)
            send_email(email_list, code)
            rep.status = True
        else:
            limit_day = current_date - datetime.timedelta(
                hours=1)  # 将创建时间减去一小时前的时间=一小时
            times = models.SendMsg.objects.filter(
                email=email,
                ctime__gt=limit_day,  # 如果数据库中的时间大于 一小时前的时间(此时表明在1小时以内)
                times__gt=9).count()  # 获取数据库中满足要求的数据(次数大于9)
            if times:
                rep.summary = "'已经超过发送的最大次数(请1小时后重试)'"
            else:
                unfreeze = models.SendMsg.objects.filter(
                    email=email, ctime__lt=limit_day).count(
                    )  # 获取一小时前的时间小于当前时间的数据(此时重置次数times)
                if unfreeze:
                    models.SendMsg.objects.filter(email=email).update(times=0)
                from django.db.models import F  # 导入F查询
                # 更新数据库中的数据
                models.SendMsg.objects.filter(email=email).update(
                    code=code, ctime=current_date, times=F('times') + 1)
                send_email(email_list, code)
                rep.status = True
    else:
        rep.summary = form.errors['email'][0]  # 如果不正确 则修改返回字段中的summary信息
    return HttpResponse(json.dumps(rep.__dict__))  # 返回时 把状态信息转换成json格式返回给前端
Example #3
0
def send_msg(request):
    """
    注册时,发送邮箱验证码
    :param request:
    :return:
    """
    rep = BaseResponse()
    form = SendMsgForm(request.POST)
    if form.is_valid():
        _value_dict = form.clean()
        email = _value_dict['email']

        has_exists_email = models.UserInfo.objects.filter(email=email).count()

        if has_exists_email:
            rep.summary = "此邮箱已经被注册"
            return HttpResponse(json.dumps(rep.__dict__))

        current_date = datetime.datetime.now()
        code = commons.random_code()

        count = models.SendMsg.objects.filter(email=email).count()
        if not count:
            models.SendMsg.objects.create(code=code,
                                          email=email,
                                          ctime=current_date)
            rep.status = True
        else:
            limit_day = current_date - datetime.timedelta(hours=1)

            times = models.SendMsg.objects.filter(email=email,
                                                  ctime__gt=limit_day,
                                                  times__gt=9).count()
            if times:
                rep.summary = "'已超最大次数(1小时后重试)'"
            else:
                unfreeze = models.SendMsg.objects.filter(
                    email=email, ctime__lt=limit_day).count()
                if unfreeze:
                    models.SendMsg.objects.filter(email=email).update(times=0)

                from django.db.models import F

                models.SendMsg.objects.filter(email=email).update(
                    code=code, ctime=current_date, times=F('times') + 1)
                rep.status = True
    else:
        #error_dict = json.loads(form.errors.as_json())
        #rep.summary = error_dict['email'][0]['message']
        rep.summary = form.errors['email'][0]
    return HttpResponse(json.dumps(rep.__dict__))
Example #4
0
    def post(self, *args, **kwargs):
        rep = BaseResponse()
        form = account.SendMsgForm()
        # 判断输入是否合法
        if form.valid(self):
            email = form._value_dict['email']
            conn = ORM.session()

            # 判断该邮箱是否已注册
            has_exists_email = conn.query(ORM.UserInfo).filter(ORM.UserInfo.email == email).count()
            if has_exists_email:
                rep.summary = '该邮箱已被注册'
                self.write(json.dumps(rep.__dict__))
                return
            current_datetime = datetime.datetime.now()
            code = commons.random_code()

            # 判断该邮箱之前是否发送过验证码
            has_send_count = conn.query(ORM.SendMsg).filter(ORM.SendMsg.email == email).count
            if not has_send_count:
                message.email([email, ], code)
                insert_obj = ORM.SendMsg(email = email, code = code, ctime = current_datetime)
                conn.add(insert_obj)
                conn.commit()
                rep.status = True
            else:
                # 发送过则判断是否过于频繁
                limit_hour = current_datetime - datetime.timedelta(hours=1)
                times = conn.query(ORM.SendMsg).filter(ORM.SendMsg.email == email,
                                                       ORM.SendMsg.ctime > limit_hour,
                                                       ORM.SendMsg.times >= 10,).count()
                if times:
                    rep.summary = "已经超过今日最大次数(1小时后重试)"
                else:
                    # 判断是否超过间隔时间,是则清零
                    unforzen = conn.query(ORM.SendMsg).filter(ORM.SendMsg.email == email,
                                                              ORM.SendMsg.ctime < limit_hour).count()
                    if unforzen:
                        # filter_by 里面是键值对; filter 里面是条件
                        conn.query(ORM.SendMsg).filter_by(email = email).update({"times": 0})
                    message.email([email,], code)
                    conn.query(ORM.SendMsg).filter_by(email = email).update({"times": ORM.SendMsg.times + 1,
                                                                             "code": code,
                                                                             "ctime": current_datetime})
                    conn.commit()
                    rep.status = True
            conn.close()
        else:
            rep.summary = form._error_dict['email']
        self.write(json.dumps(rep.__dict__))
def creat_report(req):
    '''
    初始化变量
    :param req:
    :return:
    '''
    # global filePath
    rep = BaseResponse()
    user_info = req.session['user_info']
    u_nid = user_info['nid']
    u_name = user_info['username']
    ePassword = models.UserInfo.objects.get(nid=u_nid).password
    headLine = req.POST.get('itemName')
    create_word = CreateWord(u_nid, headLine)

    obj_ufp = models.UserFilesPaths.objects.get(user_info_id=u_nid)

    if req.method == "POST":
        try:
            create_word.create_word()  # 生成报告
            obj_ufp.word_resultFile_path = create_word.return_filePath(
            )  # 将获取的文件名存入数据库
            obj_ufp.save()

            rep.message = "word生成成功!"
            rep.summary = "操作成功!"
            rep.status = True
        except Exception as e:
            rep.status = False
            rep.message = "word生成失败!"
            rep.summary = "操作失败!"
            print("报错原因:", e)

    if req.method == "GET":
        obj_ri = models.ReportInfo.objects.get(user_info_id=u_nid)
        emailCount = obj_ri.emailContent
        email_list = create_word.buffer_func(obj_ri.emailList)

        authorEmail = '*****@*****.**' % u_name
        rep.message = "报告发送成功!"
        rep.status = True
        filePath = obj_ufp.word_resultFile_path  # 获取报告地址

        email_report(filePath,
                     emailCount,
                     email_list,
                     authorEmail=authorEmail,
                     ePassword=ePassword)
    return HttpResponse(json.dumps(rep.__dict__))
Example #6
0
    def post(self, *args, **kwargs):
        rep = BaseResponse()

        news_id = self.get_argument('news_id', None)
        if not news_id:
            rep.summary = "新闻ID不能为空."
        else:
            user_info_id = self.session['user_info']['nid']
            conn = ORM.session()
            has_favor = conn.query(ORM.Favor).filter(ORM.Favor.user_info_id == user_info_id,
                                                     ORM.Favor.news_id == news_id).count()
            if has_favor:
                conn.query(ORM.Favor).filter(ORM.Favor.user_info_id == user_info_id,
                                             ORM.Favor.news_id == news_id).delete()
                conn.query(ORM.News).filter(ORM.News.nid == news_id).update(
                    {"favor_count": ORM.News.favor_count - 1}, synchronize_session="evaluate")
                rep.code = StatusCodeEnum.FavorMinus
            else:
                conn.add(ORM.Favor(user_info_id=user_info_id, news_id=news_id, ctime=datetime.datetime.now()))
                conn.query(ORM.News).filter(ORM.News.nid == news_id).update(
                    {"favor_count": ORM.News.favor_count + 1}, synchronize_session="evaluate")
                rep.code = StatusCodeEnum.FavorPlus
            conn.commit()
            conn.close()

            rep.status = True

        self.write(json.dumps(rep.__dict__))
Example #7
0
 def inner(self, *args, **kwargs):
     if not self.session['is_login']:
         rep = BaseResponse()
         rep.summary = "auth failed"
         self.write(json.dumps(rep.__dict__))
         return
     func(self, *args, **kwargs)
Example #8
0
def favor(request):
    """
    点赞
    :param request:
    :return:
    """
    rep = BaseResponse()

    news_id = request.POST.get('news_id', None)
    if not news_id:
        rep.summary = "新闻ID不能为空."
    else:
        user_info_id = request.session['user_info']['nid']

        has_favor = models.Favor.objects.filter(user_info_id=user_info_id, news_id=news_id).count()
        if has_favor:
            models.Favor.objects.filter(user_info_id=user_info_id, news_id=news_id).delete()
            models.News.objects.filter(nid=news_id).update(favor_count=F('favor_count') - 1)

            rep.code = StatusCodeEnum.FavorMinus
        else:
            models.Favor.objects.create(user_info_id=user_info_id, news_id=news_id, ctime=datetime.datetime.now())
            models.News.objects.filter(nid=news_id).update(favor_count=F('favor_count') + 1)

            rep.code = StatusCodeEnum.FavorPlus

        rep.status = True

    return HttpResponse(json.dumps(rep.__dict__))
Example #9
0
def favor(request):
    """新闻点赞"""
    rep = BaseResponse()

    news_id = request.POST.get("news_id", None)
    if not news_id:
        rep.summary = "新闻ID不能为空"
    else:
        user_info_id = request.session["user_info"]["nid"]

        has_favor = models.Favor.objects.filter(user_info_id=user_info_id, news_id=news_id).count()
        if has_favor:
            models.Favor.objects.filter(user_info_id=user_info_id, news_id=news_id).delete()
            models.News.objects.filter(nid=news_id).update(favor_count=F("favor_count")-1)

            rep.code = StatusCodeEnum.FavorMinus
        else:
            models.Favor.objects.create(user_info_id=user_info_id, news_id=news_id, ctime=datetime.datetime.now())
            models.News.objects.filter(nid=news_id).update(favor_count=F("favor_count")+1)

            rep.code = StatusCodeEnum.FavorPlus

        # 获取当前点赞数返回给前端
        obj = models.News.objects.get(nid=news_id)
        rep.counts = obj.favor_count

        rep.status = True
    return HttpResponse(json.dumps(rep.__dict__))
Example #10
0
def send_msg(request):
    """发送邮件验证码"""
    rep = BaseResponse()
    form = SendMsgForm(request.POST)
    # 一、先检查邮箱格式
    if form.is_valid():
        _value_dict = form.clean()
        email = _value_dict["email"]

        # 二、再检查邮箱是否已被注册
        has_exists_email = models.UserInfo.objects.filter(email=email).count()
        if has_exists_email:
            rep.summary = "此邮箱已被注册"
            return HttpResponse(json.dumps(rep.__dict__))

        # 三、再检查此邮箱发送验证码的次数,并生成当前时间以及验证码
        current_date = datetime.datetime.now()
        code = commons.random_code()
        count = models.SendMsg.objects.filter(email=email).count()

        if not count:
            # 如果此邮箱从没有发送过验证码,则在数据库SendMsg表创建一条新记录,并发送邮件
            models.SendMsg.objects.create(code=code, email=email, ctime=current_date, times=1)
            rep.status = True
            # 发送邮件
            send_email(email, "验证码:" + str(code))
        else:
            # 如果之前发送过验证码,先检查有没有超过限制,一小时只能发10次
            limit_time = current_date - datetime.timedelta(hours=1)
            current_times = models.SendMsg.objects.filter(email=email, ctime__gt=limit_time, times__gt=9).count()
            if current_times:
                # 如果已经发送超过9次,并且最后一次发邮件到现在还没有超过一小时,提示错误,等待一小时后重试
                rep.summary = "已超过最大次数,请一小时后重试"
            else:
                # 如果最后一次发送邮件时间到现在已经超过一小时了,则将计数归零,重新计算
                # 然后更新数据库记录
                unfreeze = models.SendMsg.objects.filter(email=email, ctime__lt=limit_time).count()
                if unfreeze:
                    models.SendMsg.objects.filter(email=email).update(times=0)
                models.SendMsg.objects.filter(email=email).update(code=code, ctime=current_date, times=F("times")+1)
                rep.status = True
                # 发送邮件
                send_email(email, "验证码:" + str(code))
    else:
        rep.summary = form.errors["email"][0]
    return HttpResponse(json.dumps(rep.__dict__))
Example #11
0
 def post(self, *args, **kwargs):
     rep = BaseResponse()
     try:
         file_metas = self.request.files["img"]
         for meta in file_metas:
             file_name = meta['filename']
             file_path = os.path.join('statics', 'upload', commons.generate_md5(file_name))
             with open(file_path, 'wb') as up:
                 up.write(meta['body'])
         rep.status = True
         rep.data = file_path
     except Exception as ex:
         rep.summary = str(ex)
     self.write(json.dumps(rep.__dict__))
Example #12
0
def servers_info_extract(req):
    rep = BaseResponse()  # 创建 回调类对象
    user_info = req.session['user_info']  # 从session中拿取 用户ID
    u_nid = user_info['nid']

    # 拿取该表对象
    ser_obj = models.PertestingServersTable.objects.get(user_info_id=u_nid)

    # 实例化服务器对象
    ser = servers(ser_obj.server_add, ser_obj.server_port,
                  ser_obj.server_username, ser_obj.server_password)

    try:
        res_mem, res_sys = ser.info_dispose()
        # 计算内存占用比
        ser_obj.memory_used_per = (int(res_mem['used']) /
                                   int(res_mem['total'])) * 100
        # 计算系统负债的情况
        ser_obj.sysLoad_time = res_sys[0]
        ser_obj.sysLoad_runTime = res_sys[2] + res_sys[3].replace(",", "")
        ser_obj.sysLoad_userNum = res_sys[5].replace(",", "")
        ser_obj.sysLoad_loadLevel_1min = res_sys[9].replace(",", "")
        ser_obj.sysLoad_loadLevel_5min = res_sys[10].replace(",", "")
        ser_obj.sysLoad_loadLevel_15min = res_sys[11].replace("\n", "")
        ser_obj.save()

        rep.status = True
        rep.data = [
            ser_obj.sysLoad_time, ser_obj.sysLoad_runTime,
            ser_obj.sysLoad_userNum
        ]
        rep.message = [
            ser_obj.memory_used_per, ser_obj.sysLoad_loadLevel_1min,
            ser_obj.sysLoad_loadLevel_5min, ser_obj.sysLoad_loadLevel_15min
        ]
    except Exception as e:
        print('错误内容:', e)
        rep.status = False
        rep.data = []
        rep.message = []
        rep.summary = '运行错误!servers_info_extract 接口请求失败。'
    finally:
        ser.server_linke_close()

    return HttpResponse(json.dumps(rep.__dict__))
Example #13
0
 def post(self, *args, **kwargs):
     print("我到了!!!")
     rep = BaseResponse()
     try:
         file_metas = self.request.files["fafafa"]
         for meta in file_metas:
             file_name = meta['filename']
             xxx = file_name.split(".")[-1]
             username = self.session['user_info']["username"]
             file_path = os.path.join('statics', 'upload', username, 'temp',
                                      commons.generate_md5(file_name) + '.' + xxx)
             with open(file_path, 'wb') as up:
                 up.write(meta['body'])
         rep.status = True
         rep.data = file_path
     except Exception as ex:
         rep.summary = str(ex)
     self.write(json.dumps(rep.__dict__))
Example #14
0
    def post(self, *args, **kwargs):
        rep = BaseResponse()

        # 前端对应index.html中的DoFavor方法中的ajax请求
        news_id = self.get_argument('news_id', None)
        if not news_id:
            rep.summary = "新闻ID不能为空."
        else:
            # 从session中获取用户信息
            user_info_id = self.session['user_info']['nid']
            conn = ORM.session()
            # 在Favor表中查询是否有该用户的点赞记录
            has_favor = conn.query(ORM.Favor).filter(
                ORM.Favor.user_info_id == user_info_id,
                ORM.Favor.news_id == news_id).count()
            if has_favor:
                # 用户已点过赞,则此时用户的点击操作代表消除自己的点赞
                # 因此先从数据库中删除点赞该用户的点赞记录
                # 分别从Favor和News表中同时删除,保持数据一致
                conn.query(ORM.Favor).filter(
                    ORM.Favor.user_info_id == user_info_id,
                    ORM.Favor.news_id == news_id).delete()
                conn.query(ORM.News).filter(ORM.News.nid == news_id).update(
                    {"favor_count": ORM.News.favor_count - 1},
                    synchronize_session="evaluate")
                # 要给前端发送的code信息,以便前端做出相应的效果改变
                rep.code = StatusCodeEnum.FavorMinus
            else:
                # 否则用户执行点赞操作,数据库内记录+1
                conn.add(
                    ORM.Favor(user_info_id=user_info_id,
                              news_id=news_id,
                              ctime=datetime.datetime.now()))
                conn.query(ORM.News).filter(ORM.News.nid == news_id).update(
                    {"favor_count": ORM.News.favor_count + 1},
                    synchronize_session="evaluate")
                rep.code = StatusCodeEnum.FavorPlus
            conn.commit()
            conn.close()

            rep.status = True
        # 将返回信息写入前端
        self.write(json.dumps(rep.__dict__))
Example #15
0
def upload_image(request):
    """
    上传图片
    :param request:
    :return:
    """
    rep = BaseResponse()
    try:
        obj = request.FILES.get('img')
        file_path = os.path.join('statics', 'upload', commons.generate_md5(obj.name))

        f = open(file_path, 'wb')
        for chunk in obj.chunks():
            f.write(chunk)
        f.close()

        rep.status = True
        rep.data = file_path
    except Exception as ex:
        rep.summary = str(ex)
    return HttpResponse(json.dumps(rep.__dict__))
Example #16
0
def per_data_extract(req):
    """
    前端页面点击发送请求 后 执行的操作
    :param req:
    :return:
    """
    rep = BaseResponse()  # 创建 回调类对象
    user_info = req.session['user_info']  # 从session中拿取 用户ID
    u_nid = user_info['nid']

    # 拿取该表对象
    per_obj = models.PertestingTable.objects.get(user_info_id=u_nid)

    # 将部分数据进行处理 协议类型\并发数\请求头\请求体类型转换
    url = per_obj.hosts + per_obj.paths
    if not url.find('https'):
        flag = False
    else:
        flag = True

    # 查询到最大并发数 与 每次启动的并发数  并且进行计算
    maxNum = int(per_obj.maxnum)
    onceNum = int(per_obj.oncenum)
    if onceNum < maxNum:
        per_obj.oncenum += onceNum
    else:
        per_obj.oncenum = maxNum
    # print('此时的并发数为:',onceNum)

    # 请求头进行预处理
    try:
        headers = json.loads(per_obj.headers)

    except Exception:
        headers = {"Content-Type": "application/json"}

    # 请求体进行预处理
    try:
        datas = json.loads(per_obj.datas)
    except Exception:
        datas = ''

    # 请求断言进行预处理
    try:
        assert_dic = json.loads(per_obj.assert_dic)  # 对断言数据进行预处理
    except Exception:
        assert_dic = {}

    maxTime = per_obj.maxTime  # 接口响应的最大时间

    # 将表中的数据 初始化到 数据统计类中
    ds = DataStatistics(method=per_obj.method,
                        url=url,
                        headers=headers,
                        data=datas,
                        count=onceNum,
                        flag=flag,
                        assert_dic=assert_dic,
                        maxTime=maxTime)

    if req.method == 'POST':
        loop_num = req.POST.get('loop_num')  # 收集前端请求中的循环次数
        per_obj.loop_num += int(loop_num)  # 进行累加求值
        try:
            ds.together_send()  # 计算出来的指标
            rep.status = True
            data = ds.data_response()  # 提取指标

            # 数据存储与计算
            per_obj.success_req += data[0]  # 成功请求数
            per_obj.lose_req += data[1]  # 失败请求数
            per_obj.total_req += data[0] + data[1]  # 总请求数
            per_obj.total_time += data[2]  # 总共花销的时间
            per_obj.avg_time = per_obj.total_time / per_obj.loop_num  # 平均花销的时间

            # 以下数据 属于图表使用
            per_obj.count_time = data[3]  # 每次请求用时
            per_obj.rps = onceNum / data[3]  # 每次的并发数 / 每次请求用时
            # 保存数据入库
            per_obj.save()

            # 获取当前的系统时间
            lt = '{0}{1}:{2}:{3}'
            localtime = time.localtime()
            if localtime.tm_hour < 12:
                lti = lt.format('上午', localtime.tm_hour, localtime.tm_min,
                                localtime.tm_sec)
            elif 12 <= localtime.tm_hour < 14:
                lti = lt.format('中午', localtime.tm_hour, localtime.tm_min,
                                localtime.tm_sec)
            else:
                lti = lt.format('下午', localtime.tm_hour, localtime.tm_min,
                                localtime.tm_sec)

            # 将数据存入 前端回调类对象中(这里存在读写消耗)
            rep.data = [
                per_obj.success_req, per_obj.lose_req, per_obj.total_req,
                per_obj.avg_time, per_obj.total_time, per_obj.oncenum
            ]
            rep.message = [per_obj.count_time, per_obj.rps, lti]
            # print(rep.data)
            rep.summary = '运行ing...'
        except (IndexError):
            rep.status = False
            rep.data = []
            rep.summary = '运行错误!per_data_extract 接口请求失败。'

    return HttpResponse(json.dumps(rep.__dict__))