Ejemplo n.º 1
0
class UserRegister(Resource):
    parser = reqparse.RequestParser()
    parser.add_argument('username',
                        type=inputs.regex('^\S{4,20}$'),
                        required=True,
                        help='Must be 4-20 non-whitespace characters long',
                        trim=True)
    parser.add_argument('password',
                        type=inputs.regex('^.{8,20}$'),
                        required=True,
                        help='Must be 8-20 characters long',
                        trim=True)

    def post(self):
        request_data = self.parser.parse_args()
        username = request_data.get('username')
        password = request_data.get('password')

        # Users cannot have the same name
        if UserModel.find_by_username(username):
            return make_response_message(
                "User name '{}' already exists".format(username), 400)

        user = UserModel(username, generate_password_hash(password))
        user.save_to_db()
        return make_response_message("User name '{}' created".format(username),
                                     201)
Ejemplo n.º 2
0
    def post(self):
        parser = reqparse.RequestParser(bundle_errors=True)
        parser.add_argument('mobile', type=inputs.regex('1[3456789]\\d{9}'), required=True,
                            nullable=False, location=['json'], help='手机号格式不正确')
        parser.add_argument('nickname', type=inputs.regex('^[A-Za-z][A-Za-z0-9]{2,7}'), required=True,
                            nullable=False, location=['json'], help='昵称格式不正确')
        parser.add_argument('password', required=True, nullable=False, location=['json'],
                            help='密码不正确')
        args = parser.parse_args()
        user = UserLogin()
        user.nickname = args.nickname
        user.mobile = args.mobile

        try:
            db.session.add(user)
            db.session.commit()
            userinfo = UserLogin.query.filter(UserLogin.mobile == args.mobile).first()
            if not userinfo:
                return error(code=HttpCode.DB_ERROR, msg='注册数据失败')
        except Exception as e:
            current_app.logger.error(e)
            db.session.rollback()
            return error(code=HttpCode.DB_ERROR, msg='注册数据失败')

        return success(msg='注册成功', data=user.to_dict())
Ejemplo n.º 3
0
 def post(self):
     parser = reqparse.RequestParser()
     parser.add_argument('username',
                         required=True,
                         trim=True,
                         nullable=False)
     parser.add_argument('email',
                         type=inputs.regex(r'^[^\s@]+@[^\s@]+\.[^\s@]+$'),
                         help='Enter a correct email',
                         trim=True,
                         required=True,
                         nullable=False)
     parser.add_argument(
         'password',
         type=inputs.regex(r"^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$"),
         help=
         'Your password must include minimum eight characters, at least one letter and one number',
         required=True,
         nullable=False)
     args = parser.parse_args()
     user = User(**args)
     db.session.add(user)
     db.session.commit()
     buy_a_frog(user, free=True)
     return user, 201
Ejemplo n.º 4
0
 def __init__(self):
     "Validates input from the form as well as json input"
     self.reqparse = reqparse.RequestParser()
     self.reqparse.add_argument(
         'username',
         required=True,
         help='kindly provide a valid username',
         # match anything but newline + something not whitespace + anything but newline
         type=inputs.regex(r"(.*\S.*)"),
         location=['form', 'json'])
     self.reqparse.add_argument(
         'email',
         required=True,
         help='kindly provide a valid email address',
         location=['form', 'json'],
         type=inputs.regex(
             r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)"))
     self.reqparse.add_argument('password',
                                required=True,
                                trim=True,
                                help='kindly provide a valid password',
                                location=['form', 'json'])
     self.reqparse.add_argument(
         'confirm_password',
         required=True,
         trim=True,
         help='kindly provide a valid confirmation password',
         location=['form', 'json'])
     self.reqparse.add_argument('admin',
                                required=True,
                                default=False,
                                location=['form', 'json'])
     super().__init__()
Ejemplo n.º 5
0
 def post(self):
     """
     充值表信息
     :return: json
     """
     self.parser.add_argument("email", type=inputs.regex(r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
                              required=True, location="json",
                              help='email format is incorrect')
     self.parser.add_argument("username", type=str, location="json", required=True, help='username is required')
     self.parser.add_argument("phone", type=inputs.regex(
         r'((\+66|0)(\d{1,2}\-?\d{3}\-?\d{3,4}))|((\+๖๖|๐)([๐-๙]{1,2}\-?[๐-๙]{3}\-?[๐-๙]{3,4}))'), required=True,
                              location="json",help='phone is required or format is incorrect')
     self.parser.add_argument("defaultFlag", type=int, location="json", required=True, help='defaultFlag is required')
     self.parser.add_argument("provinceName", type=str, location="json", required=True, help='provinceName is required')
     self.parser.add_argument("cityName", type=str, location="json", required=True, help='cityName is required')
     self.parser.add_argument("townName", type=str, location="json", required=True, help='townName is required')
     self.parser.add_argument("postCode", type=str, location="json", required=True, help='postCode is required')
     self.parser.add_argument("detailAddress", type=str, location="json", required=True, help='detailAddress is required')
     args = self.parser.parse_args()
     if args.defaultFlag:
         AddressModel.updateStatus(AddressModel, args.email);
     Address = AddressModel( email=args.email, addressId=int(time.time()), username=args.username,
                            phone=args.phone.replace("-",""), defaultFlag=args.defaultFlag, provinceName=args.provinceName,
                               cityName=args.cityName, townName=args.townName, detailAddress=args.detailAddress, postCode=args.postCode)
     AddressModel.add(AddressModel, Address)
     if Address.id:
         return pretty_result(code.OK, msg='Add address successful!')
     else:
         return pretty_result(code.ERROR, msg='Add address failed')
Ejemplo n.º 6
0
 def __init__(self):
     """Validates both json and form-data input"""
     self.reqparse = reqparse.RequestParser()
     self.reqparse.add_argument(
         'username',
         required=True,
         help='kindly provide a valid username',
         # match anything but newline + something not whitespace + anything but newline
         type=inputs.regex(r"(.*\S.*)"),
         location=['form',
                   'json'])  # the one that comes last is looked at  first
     self.reqparse.add_argument(
         'email',
         required=True,
         help='kindly provide a valid email address',
         location=['form', 'json'],
         type=inputs.regex(
             r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)"))
     self.reqparse.add_argument('password',
                                required=True,
                                trim=True,
                                help='kindly provide a valid password',
                                location=['form', 'json'])
     self.reqparse.add_argument(
         'confirm_password',
         required=True,
         trim=True,
         help='kindly provide a valid confirmation password',
         location=['form', 'json'])
     super().__init__()
Ejemplo n.º 7
0
def author_rules():
    str_regex = r'^[\w ]+$'
    printable_regex = r'''
^[a-z0-9!"#$%&\'()*+,-./:;<=>?@\\^_`{|}~\[\] \t\n\r\x0b\x0c]+$
'''.strip()

    parser = reqparse.RequestParser(bundle_errors=True)
    parser.add_argument('last_name',
                        required=True,
                        type=inputs.regex(str_regex, re.IGNORECASE),
                        trim=True,
                        help='Last name is required',
                        location='json')
    parser.add_argument('first_name',
                        required=True,
                        type=inputs.regex(str_regex, re.IGNORECASE),
                        trim=True,
                        help='First name is required',
                        location='json')
    parser.add_argument('gender',
                        required=True,
                        trim=True,
                        help='Gender is required',
                        choices=(
                            'M',
                            'F',
                        ),
                        location='json')
    parser.add_argument('about',
                        required=True,
                        type=inputs.regex(printable_regex, re.IGNORECASE),
                        trim=True,
                        help='About is required',
                        location='json')
    return parser
Ejemplo n.º 8
0
class UserRegister(Resource):
    parser = reqparse.RequestParser()
    parser.add_argument(
        'username',
        type=inputs.regex(
            '^(?!_$)(?![-.])(?!.*[_.-]{2})[a-zA-Z0-9_.-]+(?<![.-])$'),
        required=True,
        help="Please enter a valid username")
    parser.add_argument(
        'email',
        type=inputs.regex('^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'),
        required=True,
        help='Invalid email address')
    parser.add_argument('password',
                        type=inputs.regex('[A-Za-z0-9@#$%^&+=]{8,}'),
                        required=True,
                        help="The password is not strong enough")
    """
    Handle the post request to register user
    """
    @classmethod
    def post(cls):
        data = cls.parser.parse_args()
        #Check if the username already exists
        #if True, return an error message
        #else, create a new user object, save it and return a success message
        if UserModel.get_by_username(data['username']):
            return {"message": "The username already exists"}, 409
        if UserModel.get_by_email(data['email']):
            return {"message": "The email already exists"}, 409

        user = UserModel(data['username'], data['email'], data['password'])
        user.save()
        return {"message": "User created successfully"}, 201
Ejemplo n.º 9
0
 def patch(self, username):
     current_app.logger.info(
         "modify profile of {username}".format(username=username))
     parser = reqparse.RequestParser(trim=True)
     parser.add_argument(
         "username",
         required=False,
         type=inputs.regex("^[a-zA-Z0-9\_]{6,16}$"),
         location="form",
     )
     parser.add_argument("city_id", location="form")
     parser.add_argument("signature",
                         type=inputs.regex("^.{1,64}$"),
                         location="form")
     parser.add_argument("avatar_file", type=FileStorage, location="files")
     args = parser.parse_args()
     user = g.current_user
     if args.username and args.username != g.current_user.username:
         if not user.change_username(args.username):
             return error(ErrorCode.USER_ALREADY_EXISTS, 403)
     if args.city_id:
         user.city_id = args.city_id
     if args.signature:
         user.signature = args.signature
     if args.avatar_file:
         avatar = Image.create_one(args.avatar_file)
         user.avatar = avatar
     sql_db.session.commit()
     return ok("ok", username=user.username, signature=user.signature)
Ejemplo n.º 10
0
 def __init__(self):
     NETWORK_REGEX = '^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(/(3[0-2]|[1-2][0-9]|[0-9]))$'
     IP_REGEX = '^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
     COMMUNITIES_REGEX = '^([0-9]{1,4}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])\:([0-9]{1,4}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])$'
     self.general_parser = reqparse.RequestParser()
     self.general_parser.add_argument(
         'ip',
         dest='ip',
         location=['form', 'json'],
         required=True,
         help='The IP with d.d.d.d/m form 0 < d < 255 and 0 < m < 32',
         type=inputs.regex(NETWORK_REGEX),
     )
     self.general_parser.add_argument(
         'next_hop',
         dest='next_hop',
         location=['form', 'json'],
         required=True,
         help='The next hop with d.d.d.d form 0 < d < 255',
         type=inputs.regex(IP_REGEX),
     )
     self.general_parser.add_argument(
         'communities',
         dest='communities',
         location=['form', 'json'],
         help="The communities with a:b form, a and b between 0 and 65535",
         action='append',
         type=inputs.regex(COMMUNITIES_REGEX),
     )
     self.mongo_db = MongoDB('Route')
     self.exabgp = ExaBGP(URL_EXABGP)
     super(Subnets, self).__init__()
Ejemplo n.º 11
0
 def get(self):
     parser = reqparse.RequestParser()
     parser.add_argument("name",
                         type=inputs.regex("^[\w\-,]+$"),
                         default="")
     parser.add_argument("ra",
                         type=inputs.regex("^[0-9\.,]*$"),
                         required=True)
     parser.add_argument("dec",
                         type=inputs.regex("^[0-9\.\-,]*$"),
                         required=True)
     parser.add_argument("lite", type=inputs.boolean, default=False)
     message = request.data
     args = parser.parse_args()
     name = args['name'].split(',')
     ra = args['ra'].split(',')
     dec = args['dec'].split(',')
     if len(ra) != len(dec):
         return "ra and dec lists must be equal length", 400
     if len(name) != len(ra):
         name = []
         for i in range(len(ra)):
             name.append("query" + str(i))
     classifications, crossmatches = classify(name,
                                              ra,
                                              dec,
                                              lite=args['lite'])
     result = {
         'classifications': classifications,
         'crossmatches': crossmatches
     }
     return result, 200
Ejemplo n.º 12
0
def book_rules():
    str_regex = r'^[\w ]+$'
    printable_regex = r'''
^[a-z0-9!"#$%&\'()*+,-./:;<=>?@\\^_`{|}~\[\] \t\n\r\x0b\x0c]+$
'''.strip()

    parser = reqparse.RequestParser(bundle_errors=True)
    parser.add_argument('isbn',
                        required=True,
                        trim=True,
                        help='ISBN is required',
                        location='json')
    parser.add_argument('title',
                        required=True,
                        type=inputs.regex(str_regex, re.IGNORECASE),
                        trim=True,
                        help='Title is required',
                        location='json')
    parser.add_argument(
        'num_of_pages',
        required=True,
        type=inputs.positive,
        help='Number of pages is required and must be a positive number',
        location='json')
    parser.add_argument('publisher',
                        required=True,
                        type=inputs.regex(str_regex, re.IGNORECASE),
                        trim=True,
                        help='Publisher is required',
                        location='json')
    parser.add_argument(
        'publication_date',
        required=True,
        type=inputs.date,
        help='Publication date is required and must be a valid date',
        location='json')
    parser.add_argument('about',
                        required=True,
                        type=inputs.regex(printable_regex, re.IGNORECASE),
                        trim=True,
                        help='About is required',
                        location='json')
    parser.add_argument('authors',
                        required=True,
                        type=int,
                        action='append',
                        help='Author is required',
                        location='json')
    parser.add_argument('categories',
                        required=True,
                        type=int,
                        action='append',
                        help='Category is required',
                        location='json')
    return parser
Ejemplo n.º 13
0
    def post(self):
        # 1.获取参数 -- post请求体以json格式传递参数
        # 1.1 mobile 手机号码
        # 1.2 code 用户填写的短信验证码
        # 2.参数校验--RequestParser参数提取和参数校验
        # 构建解析对象
        parser = RequestParser()

        parser.add_argument("mobile",
                            required=True,
                            location="json",
                            type=regex(r'^1[3-9]\d{9}$'))
        parser.add_argument("code",
                            required=True,
                            location="json",
                            type=regex(r'\d{6}'))

        param_ret = parser.parse_args()
        mobile = param_ret['mobile']
        sms_code = param_ret['sms_code']
        # 3业务逻辑处理
        key = "app:code:{}".format(mobile)
        real_smscode = redis_client.get(key)
        redis_client.delete(key)

        if real_smscode is None:
            return {"message": "短信验证码为空"}
        if sms_code != real_smscode:
            return {"message": "短信验证码错误"}

    # 3.3 短信验证码通过
    # 3.4 根据手机号码作为查询条件,查询用户对象是否存在
    # select * from xxxx where xx
    # 优化查询:options(load_only(User.id))
        user = User.query.options(load_only(
            User.id)).filter(User.mobile == mobile).first()
        if user is None:
            user = User(mobile=mobile, name=mobile, last_login=datetime.now())
            db.session.add(user)
        else:
            user.last_login = datetime.now()

        try:
            db.session.commit()
        except Exception as e:
            db.session.rollback()
            return {"message": f"数据库提交异常{e}"}, 507
        # 3.8 生成2小时有效的登录token和14天有效的刷新token
        login_token, refresh_token = self.get_token(user_id=user.id)

        # 4返回值处理
        return {"login_token": login_token, "refresh_token": refresh_token}
Ejemplo n.º 14
0
    def patch(self):
        """
        编辑用户的信息
        """
        db.session().set_to_write()
        json_parser = RequestParser()
        json_parser.add_argument('name',
                                 type=inputs.regex(r'^.{1,7}$'),
                                 required=False,
                                 location='json')
        json_parser.add_argument('intro',
                                 type=inputs.regex(r'^.{0,60}$'),
                                 required=False,
                                 location='json')
        json_parser.add_argument('email',
                                 type=parser.email,
                                 required=False,
                                 location='json')
        args = json_parser.parse_args()

        user_id = g.user_id
        new_cache_values = {}
        new_user_values = {}
        return_values = {'id': user_id}

        if args.name:
            new_cache_values['name'] = args.name
            new_user_values['name'] = args.name
            return_values['name'] = args.name

        if args.intro:
            new_cache_values['intro'] = args.intro
            new_user_values['introduction'] = args.intro
            return_values['intro'] = args.intro

        if args.email:
            # TODO email 缓存
            new_user_values['email'] = args.email
            return_values['email'] = args.email

        try:
            if new_user_values:
                User.query.filter_by(id=user_id).update(new_user_values)
        except IntegrityError:
            db.session.rollback()
            return {'message': 'User name has existed.'}, 409

        db.session.commit()
        if new_cache_values:
            cache_user.UserProfileCache(user_id).clear()

        return return_values, 201
Ejemplo n.º 15
0
 def post(self, movie_hash_id):
     parser = reqparse.RequestParser()
     parser.add_argument(
         "interest",
         type=int,
         choices=[RatingType.COLLECT, RatingType.WISH, RatingType.DO],
         required=True,
         location="form",
     )
     parser.add_argument(
         "score",
         type=inputs.positive,
         choices=[i for i in range(0, 11)],
         default=0,
         location="form",
     )
     parser.add_argument("tags",
                         type=inputs.regex("^.{0,512}$"),
                         location="form")
     parser.add_argument("comment",
                         type=inputs.regex("^.{0,128}$"),
                         location="form")
     args = parser.parse_args()
     this_movie = MovieModel.query.get(decode_str_to_id(movie_hash_id))
     this_user = g.current_user
     if not this_movie:
         return error(ErrorCode.MOVIE_NOT_FOUND, 404)
     f = False
     if args.interest == RatingType.WISH:
         f = this_user.wish_movie(this_movie,
                                  comment=args.comment,
                                  tags_name=args.tags.split(" "))
     if args.interest == RatingType.DO:
         f = this_user.do_movie(
             this_movie,
             score=args.score,
             comment=args.comment,
             tags_name=args.tags.split(" "),
         )
     if args.interest == RatingType.COLLECT:
         f = this_user.collect_movie(
             this_movie,
             score=args.score,
             comment=args.comment,
             tags_name=args.tags.split(" "),
         )
     if f:
         print(1)
         sql_db.session.commit()
         return ok("Rating This Movie Successfully")
     return error(ErrorCode.RATING_ALREADY_EXISTS, 403)
Ejemplo n.º 16
0
    def post(self):
        """
        发表文章
        """
        req_parser = RequestParser()
        req_parser.add_argument('draft', type=inputs.boolean, required=False, location='args')
        req_parser.add_argument('title', type=inputs.regex(r'.{5,30}'), required=True, location='json')
        req_parser.add_argument('content', type=inputs.regex(r'.+'), required=True, location='json')
        req_parser.add_argument('cover', type=self._cover, required=True, location='json')
        req_parser.add_argument('channel_id', type=self._channel_id, required=True, location='json')
        args = req_parser.parse_args()
        content = args['content']
        cover = args['cover']
        draft = args['draft']

        # 对于自动封面,生成封面
        cover_type = cover['type']
        if cover_type == -1:
            cover = self._generate_article_cover(content)

        article_id = current_app.id_worker.get_id()

        article = Article(
            id=article_id,
            user_id=g.user_id,
            channel_id=args['channel_id'],
            title=args['title'],
            cover=cover,
            status=Article.STATUS.DRAFT if draft else Article.STATUS.UNREVIEWED
        )
        db.session.add(article)

        article_content = ArticleContent(id=article_id, content=content)
        db.session.add(article_content)

        # TODO 已废弃
        article_statistic = ArticleStatistic(id=article_id)
        db.session.add(article_statistic)

        try:
            db.session.commit()
        except Exception as e:
            current_app.logger.error(e)
            db.session.rollback()
            return {'message': 'Server has something wrong.'}, 507

        # if not draft:
            # TODO 机器审核
            # TODO 新文章消息推送

        return {'id': article_id}, 201
Ejemplo n.º 17
0
    def put(self, target):
        """
        修改文章
        """
        req_parser = RequestParser()
        req_parser.add_argument('draft', type=inputs.boolean, required=False, location='args')
        req_parser.add_argument('title', type=inputs.regex(r'.{5,30}'), required=True, location='json')
        req_parser.add_argument('content', type=inputs.regex(r'.+'), required=True, location='json')
        req_parser.add_argument('cover', type=self._cover, required=True, location='json')
        req_parser.add_argument('channel_id', type=self._channel_id, required=True, location='json')
        args = req_parser.parse_args()
        content = args['content']
        cover = args['cover']
        draft = args['draft']

        ret = db.session.query(func.count(Article.id)).filter(Article.id == target, Article.user_id == g.user_id).first()
        if ret[0] == 0:
            return {'message': 'Invalid article.'}, 400

        # 对于自动封面,生成封面
        cover_type = cover['type']
        if cover_type == -1:
            cover = self._generate_article_cover(content)

        Article.query.filter_by(id=target).update(dict(
            channel_id=args['channel_id'],
            title=args['title'],
            cover=cover,
            status=Article.STATUS.DRAFT if draft else Article.STATUS.UNREVIEWED
        ))

        ArticleContent.query.filter_by(id=target).update(dict(content=content))

        try:
            db.session.commit()
        except Exception as e:
            current_app.logger.error(e)
            db.session.rollback()
            return {'message': 'Server has something wrong.'}, 507

        # 清除缓存
        cache_user.UserArticlesCache(g.user_id).clear()
        cache_article.ArticleInfoCache(target).clear()
        cache_article.ArticleDetailCache(target).clear()

        # if not draft:
            # TODO 机器审核
            # TODO 新文章消息推送

        return {'id': target}, 201
Ejemplo n.º 18
0
class QuestionList(Resource):
    parser = reqparse.RequestParser()
    parser.add_argument('title',
                        type=inputs.regex('^[a-zA-Z0-9 ]{3,30}$'),
                        required=True,
                        help='Invalid question title.')

    parser.add_argument('description',
                        type=inputs.regex('^[a-zA-Z0-9.,? ]{3,300}$'),
                        required=True,
                        help='Invalid question description.')
    """Process the POST request for adding a question
    """
    @jwt_required()
    def post(self):
        data = QuestionList.parser.parse_args()
        #Get the identity of the currently logged in user
        identity = 0
        if current_identity.id:
            identity = current_identity.id
        else:
            return {"message": "Login to continue"}
        #Check if a question with the same description exists
        #return an error message if it exists
        #else, save the new question and return a response
        if QuestionModel.find_by_description(data['description']):
            return {
                "message": "The question is already asked"
            }, 409  # Conflict(Duplicate)

        #Create a question object and pass the arguments
        question = QuestionModel(data["title"], data["description"])

        response = question.save(identity)
        return response, 201

    """Process the POST request for adding a question
    """

    def get(self):
        #call the all classmethod of questionModel class to get the response
        #if response exists , return it
        #else, return an error message
        response = QuestionModel.all()
        if response:
            return response, 200

        return {"message": "No questions found!"}, 422  #Unprocessable entity
Ejemplo n.º 19
0
 def post(self):
     from datetime import date
     #这是python自带的date
     #我们的flask_restfule验证日期类型 需要 inputs.date
     #区别: 原生的  date  date(2019,9,11)
     #inputs.date   2019-9-11  所以这里不用  自带的date
     parser = reqparse.RequestParser()
     parser.add_argument('username',
                         type=int,
                         help="用户名验证错误",
                         required=True)
     parser.add_argument('homepage',
                         type=inputs.url,
                         help="必须是url类型",
                         required=True)
     parser.add_argument('telephone',
                         type=inputs.regex(r'1[3-9]\d{9}'),
                         help="手机号类型有错误",
                         required=True)
     parser.add_argument('birth',
                         type=inputs.date,
                         help="生日字段验证错误",
                         required=True)
     parser.add_argument('gender',
                         type=str,
                         choices=['male', 'female', 'secret'])
     args = parser.parse_args()
     print(args)
     return {"username": "******"}
Ejemplo n.º 20
0
 def delete(self, vlan, ip):
     delParse = reqparse.RequestParser()
     delParse.add_argument(
         'mac',
         required=True,
         location='form',
         nullable=False,
         type=inputs.regex(r'^([0-9A-F]{2}:){5}[0-9A-F]{2}$'))
     delParse.add_argument('confirm',
                           required=True,
                           location='form',
                           nullable=False,
                           choices=['true'])
     args = delParse.parse_args()
     if 'vlan_' + vlan not in self.db.collection_names(
     ):  # test vlan exists
         return {'error': "vlan does not exist"}, 404
     auth = self.auth_test(request.headers, request.cookies,
                           vlan)  # test auth
     if auth != True:
         return auth
     record = self.db['vlan_' + vlan].find_one(
         {
             'mac': args['mac'],
             'ip': ip
         }, {'_id': 1})  # test record exists
     if record is None:
         return {'error': "MAC/IP address pair not found"}, 404
     result = self.db['vlan_' + vlan].delete_one({
         'mac': args['mac'],
         'ip': ip
     })
     if result.deleted_count != 1:
         return {'success': False}, 500
     return {'success': True}, 201
Ejemplo n.º 21
0
class Items(Resource):
    post_parser = reqparse.RequestParser()
    post_parser.add_argument('name',
                             type=inputs.regex('^.{,80}$'),
                             required=True,
                             help="Must be less than 80 characters",
                             trim=True)
    post_parser.add_argument('price',
                             type=inputs.positive,
                             required=True,
                             help="Must be positive")

    def get(self, store_id):
        # Validate store_id
        store = StoreModel.find_by_id(store_id)
        if not store:
            return Store.response_not_found(store_id)

        return [item.to_json() for item in store.items]

    @jwt_required()
    def post(self, store_id):
        # Validate store_id
        store = StoreModel.find_by_id(store_id)
        if not store:
            return Store.response_not_found(store_id)

        request_data = self.post_parser.parse_args()
        item = ItemModel(request_data['name'], request_data['price'], store_id)
        item.save_to_db()
        return item.to_json(), 201
Ejemplo n.º 22
0
 def post(self):
     self.parser.add_argument("id",
                              type=int,
                              required=True,
                              location="json",
                              help='id is required')
     self.parser.add_argument(
         "email",
         type=inputs.regex(
             r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
         required=True,
         location="json",
         help='email format is incorrect')
     self.parser.add_argument("password",
                              type=password_len,
                              location="json",
                              trim=True)
     args = self.parser.parse_args()
     userEmailInfo = UsersModel.query.filter_by(email=args.email).all()
     for item in userEmailInfo:
         if item.id != args.id:
             return pretty_result(code.ERROR, msg='该邮箱已经被注册!')
     userInfo = UsersModel.query.filter_by(id=args.id).first()
     userInfo.email = args.email
     if args.password:
         userInfo.password = UsersModel.set_password(
             UsersModel, args.password)
     UsersModel.update(userInfo)
     return pretty_result(code.OK, msg='用户信息更新成功!')
Ejemplo n.º 23
0
 def get(self):
     """
     积分表信息
     :return: json
     """
     self.parser.add_argument("email", type=inputs.regex(r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
                              required=True, location="args",
                              help='email format is incorrect')
     self.parser.add_argument("pageNo", type=int, required=True, location="args", help='pageNo format is incorrect')
     self.parser.add_argument("pageSize", type=int, required=True, location="args", help='pageSize format is incorrect')
     args = self.parser.parse_args()
     Points = PointsModel.query.filter_by(email=args.email).all()
     totalCount = len(Points)
     result=[]
     if Points:
         for item in Points:
             result.append({
                 'id': item.id,
                 'email': item.email,
                 'date': item.date,
                 'type': item.type,
                 'balance': item.balance,
                 'remark': item.remark,
                 'point': item.point,
             })
     data = {
         'pageNo': args.pageNo,
         'pageSize': args.pageSize,
         'totalCount': totalCount,
         'items': result
     }
     return pretty_result(code.OK, data=data, msg='Get balance successful')
Ejemplo n.º 24
0
 def post(self):
     """
     充值表信息
     :return: json
     """
     self.parser.add_argument("email", type=inputs.regex(r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
                              required=True, location="json",
                              help='email format is incorrect')
     self.parser.add_argument("balance", type=int, location="json", required=True, help='balance is required')
     self.parser.add_argument("point", type=int, location="json", required=True, help='point is required')
     self.parser.add_argument("type", type=str, location="json", required=True, help='type is required')
     self.parser.add_argument("date", type=str, location="json", required=True, help='date is required')
     self.parser.add_argument("remark", type=str, location="json", help='remark is required')
     args = self.parser.parse_args()
     Points = PointsModel( email=args.email, type=args.type, date=args.date,
                            balance=args.balance, point=args.point, remark=args.remark)
     PointsModel.add(PointsModel, Points)
     if Points.id:
         userInfo = MallUsersModel.query.filter_by(email=args.email).first()
         userInfo.balance = userInfo.balance - args.balance
         userInfo.point = userInfo.point + args.point
         MallUsersModel.update(userInfo)
         return pretty_result(code.OK, msg='Add point successful!')
     else:
         return pretty_result(code.ERROR, msg='Add point failed')
Ejemplo n.º 25
0
 def get(self):
     #处理请求参数
     req = RequestParser()
     req.add_argument('username',
                      type=str,
                      action='append',
                      required=True,
                      help='required a parameters')
     req.add_argument('mobile',
                      type=inputs.regex('1[3-9]\d{9}'),
                      action='stored',
                      required=True,
                      help='required a parameters')
     req.add_argument('user_id',
                      type=UserResources.mobile_parameter,
                      location='args',
                      action='stored',
                      required=True,
                      help='required a parameters')
     # location 参数位置,get能够传递非表单操作 form args headers cookies json files
     args = req.parse_args()
     username, mobile, user_id = args.get('username'), args.get(
         'mobile'), args.get('user_id')
     user = User(username, mobile, user_id)
     return user
Ejemplo n.º 26
0
 def post(self):
     """
     创建反馈意见
     :return: json
     """
     self.parser.add_argument("username",
                              type=str,
                              required=True,
                              location="json",
                              help='username is required')
     self.parser.add_argument(
         "email",
         type=inputs.regex(
             r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
         required=True,
         location="json",
         help='email format is incorrect')
     self.parser.add_argument("advice",
                              type=str,
                              required=True,
                              location="json",
                              help='advice is required')
     args = self.parser.parse_args()
     advice = AdvicesModel(username=args.username,
                           email=args.email,
                           advice=args.advice)
     AdvicesModel.add(AdvicesModel, advice)
     return pretty_result(code.OK, msg='意见反馈成功!')
Ejemplo n.º 27
0
 def get(self):
     """
     充值表信息
     :return: json
     """
     self.parser.add_argument("email", type=inputs.regex(r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
                              required=True, location="args",help='email format is incorrect')
     self.parser.add_argument("pageNo", type=int, required=True, location="args", help='pageNo format is incorrect')
     self.parser.add_argument("pageSize", type=int, required=True, location="args",help='pageSize format is incorrect')
     args = self.parser.parse_args()
     Balances = BalancesModel.query.filter_by(email=args.email).all()
     totalCount = len(Balances)
     result = []
     if Balances:
         for item in Balances:
             url = config.domain + "/api/v1/pictureManagement/get?type=balance&id=" + item.picture
             result.append({
                 'id': item.id,
                 'email': item.email,
                 'date': item.date,
                 'type': item.type,
                 'balance': item.balance,
                 'remark': item.remark,
                 'status': item.status,
                 'picture': url,
                 'reason': item.reason
             })
     data = {
         'pageNo': args.pageNo,
         'pageSize': args.pageSize,
         'totalCount': totalCount,
         'items': result
     }
     return pretty_result(code.OK, data=data, msg='Get balance successful')
Ejemplo n.º 28
0
 def post(self):
     """
     充值表信息
     :return: json
     """
     self.parser.add_argument("email", type=inputs.regex(r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
                              required=True, location="form",
                              help='email format is incorrect')
     self.parser.add_argument("balance", type=int, location="form", required=True, help='balance is required')
     self.parser.add_argument("type", type=str, location="form", required=True, help='type is required')
     self.parser.add_argument("date", type=str, location="form", required=True, help='date is required')
     self.parser.add_argument("remark", type=str, location="form", help='remark is required')
     self.parser.add_argument("picture", type=FileStorage, required=True, location='files', action='append',
                              help='picture is required')
     args = self.parser.parse_args()
     file_name = ""
     for item in args.picture:
         file_name = str(int(time.time()))
         new_fname = filePath + file_name + '.png'
         item.save(new_fname)
     Balances = BalancesModel( email=args.email, type=args.type, date=args.date,
                            balance=args.balance, picture=file_name, remark=args.remark)
     BalancesModel.add(BalancesModel, Balances)
     if Balances.id:
         userInfo = MallUsersModel.query.filter_by(email=args.email).first()
         userInfo.balance = userInfo.balance + args.balance
         MallUsersModel.update(userInfo)
         return pretty_result(code.OK, msg='Add balance successful!')
     else:
         return pretty_result(code.ERROR, msg='Add balance failed')
Ejemplo n.º 29
0
def test_regex_flags_bad_input():
    cases = ('abcd', 'ABCabc')

    case_sensitive = inputs.regex(r'^[A-Z]+$')

    for value in cases:
        yield assert_raises, ValueError, lambda: case_sensitive(value)
Ejemplo n.º 30
0
 def add_arguments(parse, put=False):
     parse.add_argument('name',
                        type=str,
                        required=True,
                        help=u'缺少用户名参数name',
                        location='json')
     parse.add_argument('cname',
                        type=str,
                        required=True,
                        help=u'缺少用户别名参数cname',
                        location='json')
     parse.add_argument('phone_number',
                        required=True,
                        type=inputs.regex(r'1[3578]\d{9}'),
                        help=u'缺少phone_number参数或手机号码格式不对',
                        location='json')
     parse.add_argument('email',
                        type=str,
                        required=True,
                        help=u'缺少email参数或email格式不对',
                        location='json')
     if not put:
         parse.add_argument('password',
                            type=str,
                            required=True,
                            help=u"缺少密码参数password",
                            location='json')
     return parse
Ejemplo n.º 31
0
def test_regex_flags_bad_input():
    cases = (
        'abcd',
        'ABCabc'
    )

    case_sensitive = inputs.regex(r'^[A-Z]+$')

    for value in cases:
        yield assert_raises, ValueError, lambda: case_sensitive(value)
Ejemplo n.º 32
0
def test_regex_good_input():
    cases = (
        '123',
        '1234567890',
        '00000',
    )

    num_only = inputs.regex(r'^[0-9]+$')

    for value in cases:
        yield assert_equal, num_only(value), value
Ejemplo n.º 33
0
def test_regex_flags_good_input():
    cases = (
        'abcd',
        'ABCabc',
        'ABC',
    )

    case_insensitive = inputs.regex(r'^[A-Z]+$', re.IGNORECASE)

    for value in cases:
        yield assert_equal, case_insensitive(value), value
Ejemplo n.º 34
0
def test_regex_bad_input():
    cases = (
        'abc',
        '123abc',
        'abc123',
        '',
    )

    num_only = inputs.regex(r'^[0-9]+$')

    for value in cases:
        yield assert_raises, ValueError, lambda: num_only(value)
Ejemplo n.º 35
0
    def __init__(self):
        self.reqparse = reqparse.RequestParser()
        self.reqparse.add_argument('limit', type=int, required=False,
                                   location='args', help=gettext('limit_help_msg'))

        self.reqparse.add_argument('offset', type=int, required=False,
                                   location='args', help=gettext('offset_help_msg'))

        self.reqparse.add_argument('uuid', type=str, required=False, location='args')

        self.reqparse.add_argument('valid', type=boolean, required=False, 
                                   location='args', help=gettext('valid_help_msg'))

        self.reqparse.add_argument('state', type=regex('^[a-zA-Z]{2}$'), 
                                   required=False, location='args', 
                                   help=gettext('state_help_msg'))

        super(OrderAPI, self).__init__()
Ejemplo n.º 36
0
    def post(self):

        self.parser.add_argument(
            'url',
            type=inputs.regex(CONSTANTS.YOUTUBE_URL_REGEX),
            help='Url is required',
            required=True
        )

        self.parser.add_argument(
            'type',
            help='Type is required',
            required=True
        )

        args = self.parser.parse_args()

        videoId = args['url'].split('watch?v=')[1]

        r = requests.get(buildYoutubeQueryURL(videoId))
        response = r.json()

        if len(response['items']) == 0:
            return buildResponse('Video not found', 404)

        youtubeDetails = response['items'][0]

        #At the time of this development the youtube API does not work properly to the embeddable property
        if not youtubeDetails['status']['embeddable']:
            return buildResponse('Video is not embeddable', 400)

        print youtubeDetails['snippet']['title']

        music = MusicModel()
        music.title = youtubeDetails['snippet']['title']
        music.description = youtubeDetails['snippet']['description']
        music.channel_title = youtubeDetails['snippet']['channelTitle']
        music.type = args['type']
        music.video_id = videoId
        music.save()

        return buildResponse('', 201)
Ejemplo n.º 37
0
accountParser = reqparse.RequestParser(bundle_errors=True)
accountParser.add_argument("username", required=True)
accountParser.add_argument("password", required=True)

# parser for get schools request
pageParser = reqparse.RequestParser(bundle_errors=True)
pageParser.add_argument("offset", type=inputs.natural)
pageParser.add_argument("limit", type=inputs.positive)

# parser for post and put schools requests
schoolParser = reqparse.RequestParser(bundle_errors=True)
schoolParser.add_argument("schoolName", required=True)
schoolParser.add_argument("typeOfSchool", required=True, action='append',
                          choices=["Daycare", "Preschool", "Elementary School (K-5)", "Middle School (6-8)", "High School (9-12)"])
schoolParser.add_argument("pubOrPri", required=True, choices=["Public", "Private"])
schoolParser.add_argument("location", required=True, type=inputs.regex("^[0-9]{5}$"), help="Please enter a valid 5-digit zip code.")
schoolParser.add_argument("foreignLanguagesTaught", action='append', choices=["Spanish", "French", "German", "Japanese", "Mandarin"], default=[])
schoolParser.add_argument("rating", required=True, type=inputs.int_range(1, 10))

# parser for post and put students requests
studentParser = reqparse.RequestParser(bundle_errors=True)
studentParser.add_argument("studentName", required=True)
studentParser.add_argument("grade", required=True,
                           choices=["Daycare", "Preschool", "K", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"])
studentParser.add_argument("currentSchoolST", required=True)
studentParser.add_argument("pastSchoolsST", required=True, action='append')

# parser for post and put parents requests
parentParser = reqparse.RequestParser(bundle_errors=True)
parentParser.add_argument("parentName", required=True)
Ejemplo n.º 38
0
	'type' : fields.String,
	'hours' :fields.String,
	'pay'	:fields.String,
	'rate'	:fields.String,
}

calculation_results = {
	'rows' : fields.List(fields.Nested(calculation_row)),
	'total_hours' :  fields.String,
	'total_pay' : fields.String,
}

parser = reqparse.RequestParser()

# HourlyRate
parser.add_argument('hours_worked', type=inputs.regex('^[0-9]+$'))
parser.add_argument('hourly_rate', type=inputs.regex('^[0-9]+$'))

# GuaranteedHours
parser.add_argument('guaranteed_rate', type=inputs.regex('^[0-9]+$'))
parser.add_argument('guaranteed_hours', type=inputs.regex('^[0-9]+$'))
parser.add_argument('actual_hours_worked', type=inputs.regex('^[0-9]+$'))

# for cache = false in ajax get request object (get's around IE's caching)
parser.add_argument('_', type=str)


# Calling parse_args with strict=True ensures that an error is thrown if
# the request includes arguments your parser does not define.
# args = parser.parse_args(strict=True)
Ejemplo n.º 39
0
# def Basic_Auth_Header():
#     return ex_reqparse.ExArgument(
#         'Authorization',
#         type=inputs.regex('^Basic [A-Za-z0-9+/=]|=[^=]|={3,}$'),
#         location="headers", required=True)
#
#
# def Access_Token_Header():
#     return ex_reqparse.ExArgument(
#         'Authorization',
#         type=inputs.regex("^Bearer [a-fA-F0-9]{8}-[a-fA-F0-9]{4}-" +
#                           "[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$"),
#         location="headers", required=True)
BASIC_AUTH_HEADER = ex_reqparse.ExArgument(
    'Authorization',
    type=inputs.regex('^Basic [A-Za-z0-9+/=]|=[^=]|={3,}$'),
    location="headers", required=True)

ACCESS_TOKEN_HEADER = ex_reqparse.ExArgument(
    'Authorization',
    type=inputs.regex("^Bearer [a-fA-F0-9]{8}-[a-fA-F0-9]{4}-" +
                      "[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$"),
    location="headers", required=True)

LOGIN_TYPE = ex_reqparse.ExArgument(
    'type',
    type=inputs.regex("^[A-Z]+$"),
    required=True
)

FACEBOOK_NAME = ex_reqparse.ExArgument(
Ejemplo n.º 40
0
    def post():
        parser = reqparse.RequestParser()
        parser.add_argument('name', required=True, location='json', type=str, help='Name must be set')
        parser.add_argument('address', required=True, location='json', type=inputs.regex('^[a-zA-Z0-9]{34}$'),
                            help='Address must be set')
        parser.add_argument('url', required=True, location='json', type=inputs.regex('^http(s)?:\/\/.*$'),
                            help='URL must be set')
        parser.add_argument('lang', required=True, location='json', type=inputs.regex('^[A-Z]{2}$'),
                            help='Lang must be set')
        parser.add_argument('country', required=True, location='json',
                            type=inputs.regex('^([A-Z]{2}(,[A-Z]{2})*|ALL)$'), help='Country must be set')
        parser.add_argument('cpc', required=True, location='json', type=float,
                            help='CPC must be set or incorrect value')
        parser.add_argument('keywords', required=True, location='json', type=str, help='Keywords must be set')
        parser.add_argument('days', required=True, location='json', type=int, help='Days must be set')
        parser.add_argument('txt', required=True, location='json', type=list, help='TXT must be set')
        args = parser.parse_args()

        resp = client.signmessage(args.address, args.name)
        if resp.get('error', False):
            return {'result_status': False, 'message': resp['error']['message']}, 400

        contract_content = """URL={url}
SIGNATURE={signature}
LANG={lang}
COUNTRY={country}
CPC={cpc}
KEYWORDS={keywords}
{txt}
""".format(url=args.url,
           signature=resp['result'],
           lang=args.lang,
           country=args.country,
           cpc=args.cpc,
           keywords=args.keywords,
           txt='\n'.join(['TXT={}'.format(txt) for txt in args.txt]))

        contract = Contracts(user_id=current_user.id,
                             name=args.name,
                             address=args.address,
                             url=args.url,
                             language=args.lang,
                             countries=args.country,
                             cpc=args.cpc,
                             keywords=args.keywords,
                             content=contract_content)

        connection.session.add(contract)
        connection.session.flush()
        for txt in args.txt:
            contract_txt = ContractTexts(contract_id=contract.id,
                                         txt=txt)
            connection.session.add(contract_txt)

        resp = client.name_new('lnx:{}'.format(args.name), contract_content, args.days)
        if resp.get('error', False):
            return {
                'result_status': False,
                'message': format(resp['error']['message'])
            }, 400

        connection.session.commit()

        return {'result_status': True, 'result': 'Created'}
Ejemplo n.º 41
0
TestRunParser.add_argument('product', required=None)
TestRunParser.add_argument('version', required=None)
TestRunParser.add_argument('arch', required=True)
TestRunParser.add_argument('type', required=True)
TestRunParser.add_argument('framework', required=True)
TestRunParser.add_argument('project', required=True)
TestRunParser.add_argument('date', type=inputs.datetime_from_iso8601, required=True)
TestRunParser.add_argument('ci_url', required=True)
TestRunParser.add_argument('description', default=None)
TestRunParser.add_argument('tags', type=str, action='append', default=[])
TestRunParser.add_argument('properties', type=dict, default={})


AutoResultParser = reqparse.RequestParser(bundle_errors=True)
AutoResultParser.add_argument('case', required=True)
AutoResultParser.add_argument('time', type=inputs.regex('^[0-9]+.[0-9]+$'), required=True)
AutoResultParser.add_argument('output', required=True)
AutoResultParser.add_argument('failure', default=None)
AutoResultParser.add_argument('source', default=None)
AutoResultParser.add_argument('skip', default=None)
AutoResultParser.add_argument('error', default=None)
AutoResultParser.add_argument('result', default=None)


AutoResultUpdateParser = AutoResultParser.copy()
AutoResultUpdateParser.replace_argument('output', required=False)
AutoResultUpdateParser.replace_argument('case', required=False)
AutoResultUpdateParser.replace_argument('time', type=inputs.regex('^[0-9]+.[0-9]+$'), required=False)


ManualResultUpdateParser = reqparse.RequestParser(bundle_errors=True)