Esempio n. 1
0
def login_in():
    content = request.data
    try:
        data = json.loads(str(content, encoding="utf-8"))
    except JSONDecodeError:
        return jsonify(Result().fail(code="error.json"))
    mobile = data.get('mobile')
    password = data.get('password')
    code = data.get('code')
    if not mobile or not password:
        return jsonify(Result().fail(code="param.null",
                                     msg="Invalid username/password"))
    if not code:
        captcha = RequestUtil.get_captcha(session)
        if code != captcha:
            return jsonify(Result().fail(code="error.captcha"))
    user = user_service.find_by_user(mobile, password)
    if user:
        session["user_id"] = str(user.id)
        session["mobile"] = str(user.mobile)
        user.update(login_time=datetime.datetime.now())
        return jsonify(Result().success({"id": str(user.id)}))
    else:
        return jsonify(Result().fail(code="user.not.exists",
                                     msg="user not exists"))
Esempio n. 2
0
def create():
    user_id = session.get("user_id")
    content = request.data
    try:
        data = json.loads(str(content, encoding="utf-8"))
    except JSONDecodeError:
        return jsonify(Result().fail(code="error.json"))
    pros = data.get('pros')
    areas = data.get('areas')
    name = data.get('name')
    mobile = data.get('mobile')
    address = data.get('address')
    save = OrdSave()
    for pro in pros:
        pid = pro.split("_")[0]
        num = pro.split("_")[1]
        product = product_service.find_by_id(pid)
        if not product:
            return jsonify(Result().fail(code="product.not.exist",
                                         msg="product not exist"))
        save.add_product({
            "id": str(product.id),
            "num": num,
            "title": product.title
        })
    save.areas = areas
    save.name = name
    save.mobile = mobile
    save.address = address
    save.user_id = user_id
    save.status = 1
    id = ord_service.save(save)
    return jsonify(Result().success({"id": id}))
Esempio n. 3
0
def save():
    try:
        data = json.loads(str(request.data, encoding="utf-8"))
    except JSONDecodeError:
        return jsonify(Result().fail(code="error.json"))
    area = data.get('area')
    year = data.get('year')
    unit = data.get('unit')
    print1 = data.get('print')
    num_start = int(data.get('num_start'))
    num_end = int(data.get('num_end'))
    if not area or not year or not unit or not num_start or not print1:
        return jsonify(Result().fail(code="param.null", msg="Invalid param"))
    if len(area) != 2 or len(year) != 4 or len(unit) != 2 or len(print1) != 2:
        return jsonify(Result().fail(code="param.length",
                                     msg="param length error"))
    if num_end - num_start > 1000:
        return jsonify(Result().fail(code="param.range",
                                     msg="end - start over 1000"))
    for num in range(int(num_start), int(num_end)):
        code = GiftCardCode()
        code.area = area
        code.year = year
        code.unit = unit
        code.print = print1
        code.num = num
        if gift_card_service.find_by_code(code.code()) is None:
            gift_card_service.save(code)
    return jsonify(Result().success())
Esempio n. 4
0
def plot_total_cases(country):
    data.process_data(country)
    model = Model(data.dtf)
    model.forecast()
    model.add_deaths(data.mortality)
    result = Result(model.dtf)
    # Python function to plot active cases
    return result.plot_total(model.today)
Esempio n. 5
0
def delete(aid):
    user_id = session.get(const.SESSION_USER_ID)
    ua = user_address_service.find_by_id(aid)
    if ua.user_id != user_id:
        return jsonify(Result().fail(code="error.not.yours"))
    if ua:
        user_address_service.delete(aid)
    return jsonify(Result().success())
Esempio n. 6
0
def plot_active_cases(country):
    data.process_data(country)
    model = Model(data.dtf)
    model.forecast()
    model.add_deaths(data.mortality)
    result = Result(model.dtf)
    # Python function to render output panel
    return result.plot_active(model.today)
Esempio n. 7
0
    def _construct_player(self, command):
        result = P.decode_player(command)

        if not result.success:
            return Result.get_negative()

        name, number_of_players = result.result
        return Result.get_positive(Player(self.player.get_connection, name, number_of_players))
Esempio n. 8
0
def delete(uid):
    user_id = session.get(const.SESSION_USER_ID)
    if user_id == uid:
        return jsonify(Result().fail(code="error.delete.yourself"))
    u = user_service.find_by_id(uid)
    if not u:
        return jsonify(Result().fail(code="error.not.exists"))
    user_service.delete(uid)
    return jsonify(Result().success())
Esempio n. 9
0
def update():
    try:
        data = json.loads(str(request.data, encoding="utf-8"))
    except JSONDecodeError:
        return jsonify(Result().fail(code="error.json"))
    code = str(data['code'])
    password = str(data['password'])
    id = gift_card_service.update_used(code, password)
    return jsonify(Result().success())
Esempio n. 10
0
    def _add_to_group(self):
        result = self._check_available_groups()

        if not result.success:
            return Result.get_negative()

        self._add_player_to_queue()
        result.result.add([self.player])

        return Result.get_positive()
Esempio n. 11
0
def save():
    content = request.data
    try:
        data = json.loads(str(content, encoding="utf-8"))
    except JSONDecodeError:
        return jsonify(Result().fail(code="error.json"))
    address = UserAddress()
    address.user_id = session.get("user_id")
    get_address_from_json(address, data)
    aid = user_address_service.save(address)
    return jsonify(Result().success({"id": aid}))
Esempio n. 12
0
def delete(oid):
    user_id = RequestUtil.get_user_id(session)
    ord_db = ord_service.find_by_id(oid)
    if not ord_db:
        return jsonify(Result().fail(code="ord.not.exists"))
    if not ord_db['ord'].user_id:
        ord_service.delete(oid)
        return jsonify(Result().success())
    if ord_db['ord'].user_id != user_id:
        return jsonify(Result().fail(code="ord.not.yours"))
    ord_service.delete(oid)
    return jsonify(Result().success())
Esempio n. 13
0
def find_by_code(code):
    gift = gift_card_service.find_by_code(code)
    if not gift:
        current_app.logger.warn("can not find the gift code: %s" % code)
        return jsonify(Result().fail(code="gift_card.not.found"))
    pro = product_service.find_by_id(gift.product_id)
    if not pro:
        return jsonify(Result().fail(code="product.not.bind"))
    return jsonify(Result().success({
        "gift_card": gift.to_dict(),
        "product": pro.to_dict()
    }))
Esempio n. 14
0
def bind_product():
    try:
        data = json.loads(str(request.data, encoding="utf-8"))
    except JSONDecodeError:
        return jsonify(Result().fail(code="error.json"))
    product_id = str(data['product_id'])
    codes = data['codes']
    p = product_service.find_by_id(product_id)
    if not p:
        return jsonify(Result().fail(code="product.not.found"))
    gift_card_service.update_bind_product(codes, product_id)
    return jsonify(Result().success())
Esempio n. 15
0
 def test_result_dict(self):
     self.assertDictEqual(Result().success(), {'code': 'success'})
     self.assertDictEqual(Result().success("data"), {
         'code': 'success',
         'data': 'data'
     })
     self.assertDictEqual(Result().fail(), {'code': 'fail'})
     self.assertDictEqual(Result().fail(code="cod11e", msg="msg11"), {
         'code': 'cod11e',
         'msg': 'msg11'
     })
     self.assertDictEqual(Result().fail(code="cod11e"), {'code': 'cod11e'})
Esempio n. 16
0
def update():
    content = request.data
    try:
        data = json.loads(str(content, encoding="utf-8"))
    except JSONDecodeError:
        return jsonify(Result().fail(code="error.json"))
    id = str(data.get("id"))
    address = user_address_service.find_by_id(id)
    if not address:
        return jsonify(Result().fail("address.not.exists"))
    get_address_from_json(address, data)
    user_address_service.update(address)
    return jsonify(Result().success())
Esempio n. 17
0
def api_upload():
    upload = current_app.config.get("UPLOAD_IMAGE")
    now = datetime.date.today().isoformat()
    file_dir = os.path.join(upload, now.replace("-", "/"))
    if not os.path.exists(file_dir):
        os.makedirs(file_dir)
    f = request.files['file']
    if f and allowed_file(f.filename):
        ext = f.filename.rsplit('.', 1)[1]
        if ext in ALLOWED_EXTENSIONS:
            new_filename = str(int(time.time())) + '_' + shortuuid.uuid()[:8] + "." + ext
            f.save(os.path.join(file_dir, new_filename))
            return jsonify(Result().success("/file/img/" + new_filename))
    return jsonify(Result().fail())
Esempio n. 18
0
def decode_player(command: str):
    parts = command.split(ASSIGNMENT)
    if parts[0] == PLAYER:
        construction_arguments = parts[1].split(LIST_DELIMITER)

        if len(construction_arguments) == 2:
            try:
                return Result.get_positive((construction_arguments[0],
                                            int(construction_arguments[1])))
            except ValueError as error:
                # WARNING Invalid argument
                return Result.get_negative(error)

    return Result.get_negative()
Esempio n. 19
0
def update_head():
    user_id = RequestUtil.get_user_id(session)
    try:
        data = json.loads(str(request.data, encoding="utf-8"))
    except JSONDecodeError:
        return jsonify(Result().fail(code="error.json"))
    head = data.get('head_url')
    if not head:
        return jsonify(Result().fail(code="error.head.null"))
    u = user_service.find_by_id(user_id)
    if not u:
        current_app.logger.warn("can not find the user %s" % user_id)
        return jsonify(Result().fail(code="error.not.exists"))
    u.update(head_url=head, update_time=datetime.datetime.now())
    return jsonify(Result().success())
Esempio n. 20
0
def get_img(path):
    arr = path.split("_")
    time = arr[0]
    upload = current_app.config.get("UPLOAD_IMAGE")
    datepath = datetime.datetime.fromtimestamp(int(time)).date().isoformat()
    file_dir = os.path.join(upload, datepath.replace("-", "/"), path)
    if not os.path.exists(file_dir):
        ext = path.rsplit('.', 1)[1]
        orign_dir = os.path.join(upload, datepath.replace("-", "/"), "%s_%s.%s" % (arr[0], arr[1], ext))
        print(orign_dir)
        if len(arr) > 2:
            wh_str = arr[2].split(".")[0]
            if not wh_str in ALLOWED_WIDTH_HEIGHT:
                return jsonify(Result().fail(code="wh.not.allow", msg="wh not allow"))
            wh = wh_str.split("x")
            if len(wh) > 1:
                # widthxheight.png
                print(orign_dir)
                print(file_dir)
                print(wh)
                clip_resize(orign_dir, file_dir, wh)
            else:
                # width.png
                thumbnail(orign_dir, file_dir, wh)
    with open(file_dir, 'rb') as f:
        return Response(f.read(), mimetype="image/jpeg")
Esempio n. 21
0
def update():
    try:
        data = json.loads(str(request.data, encoding="utf-8"))
    except JSONDecodeError:
        return jsonify(Result().fail(code="error.json"))
    mobile = data.get('mobile')
    password = data.get('password')
    if not mobile:
        return jsonify(Result().fail(code="param.null", msg="Invalid username/password"))
    if not user_service.find_by_mobile(mobile):
        return jsonify(Result().fail(code="user.exists"))
    save = UserSave()
    save.mobile = mobile
    save.password = password
    uid = user_service.update(save)
    return jsonify(Result().success())
    def get_super_csv(self) -> [Result]:
        results = []
        for directory in os.listdir(self.path):
            csv_results = os.listdir(os.path.join(self.path, directory))
            print(csv_results)

            for csv_result in csv_results:
                with open(os.path.join(self.path, directory, csv_result),
                          encoding="utf8") as file:
                    #with open(os.path.join(self.path, directory, csv_result)) as file:
                    reader = csv.reader(file)

                    for row in reader:
                        if not row:
                            continue
                        if row[0] == 'title':
                            continue
                        results.append(
                            Result(title=row[0],
                                   author=row[1],
                                   date=row[2],
                                   link=row[3],
                                   pdf_link=row[4],
                                   query=csv_result,
                                   search_engine=directory,
                                   cite_count=row[8],
                                   doi=row[9]))
                #results = count_similar_results(results)
        return results
Esempio n. 23
0
 def results(self):
     arguments = {'count': 10, 'full': True, 'revision': self.sha1}
     raw_results = self.client.execute_request(rest_resource='resultset',
                                               get_arguments=arguments)
     return [
         Result.from_json(self.client, raw_result)
         for raw_result in raw_results
     ]
Esempio n. 24
0
def update_password():
    user_id = session.get(const.SESSION_USER_ID)
    content = request.data
    try:
        data = json.loads(str(content, encoding="utf-8"))
    except JSONDecodeError:
        return jsonify(Result().fail(code="error.json"))
    password_old = data.get('password_old')
    password_new1 = data.get('password_new1')
    password_new2 = data.get('password_new2')
    if password_new1 != password_new2:
        return jsonify(Result().fail(code="new_password.not.equal"))
    u = user_service.find_by_id(user_id)
    if password_old != u.password:
        return jsonify(Result().fail(code="old_password.not.equal"))
    u.update(password=str(password_new1), update_time=datetime.datetime.now())
    return jsonify(Result().success())
Esempio n. 25
0
def _update_found_result(result: Result, found_result: Result):
    found_result.nr_found += 1

    not_empty = (result.cite_count != ResultConstants.NO_CITE_COUNT
                 and found_result.cite_count != ResultConstants.NO_CITE_COUNT)
    if not_empty:
        max_cite_count = max(_to_number(result.cite_count),
                             _to_number(found_result.cite_count))
        found_result.cite_count = str(max_cite_count)
    def write(self, results: [], file_name: str):
        with open(self._path + file_name, 'w',encoding = "utf8", newline = '') as file:
            writer = csv.writer(file)
            keys = [key for key, value in vars(Result('', '', '', '', '')).items()]
            writer.writerow(keys)

            for result in results:
                values = [str(value).replace(';', '') for key, value in vars(result).items()]
                writer.writerow(values)
Esempio n. 27
0
def save():
    content = request.data
    try:
        data = json.loads(str(content, encoding="utf-8"))
    except JSONDecodeError:
        return jsonify(Result().fail(code="error.json"))
    mobile = data.get('mobile')
    password = data.get('password')
    head_url = data.get('head_url')
    if not mobile or not password:
        return jsonify(Result().fail(code="param.null"))
    if user_service.find_by_user(mobile, password):
        return jsonify(Result().fail(code="user.exists", msg="user exists"))
    save = UserSave()
    save.mobile = mobile
    save.password = password
    save.head_url = head_url
    uid = user_service.save(save)
    return jsonify(Result().success({"id": uid}))
Esempio n. 28
0
def save():
    try:
        data = json.loads(str(request.data, encoding="utf-8"))
    except JSONDecodeError:
        return jsonify(Result().fail(code="error.json"))
    title = data.get('title')
    content = data.get('content')
    main_pic = data.get('main_pic')
    price = data.get('price')
    pics = data.get('pics')
    if not title or not content:
        return jsonify(Result().fail("param.none", "param.none"))
    save = ProductSave()
    save.title = title
    save.content = content
    save.price = price
    save.main_pic = main_pic
    save.pics = pics
    p = product_service.save(save)
    return jsonify(Result().success(p.code))
Esempio n. 29
0
def detail(id):
    user_id = RequestUtil.get_user_id(session)
    detail = ord_service.find_by_id(id)
    if not detail or not detail.get("ord"):
        return jsonify(Result().fail(code="ord.not.exist"))
    if not detail.get("ord").user_id or user_id != detail.get("ord").user_id:
        return jsonify(Result().fail(code="ord.not.yours",
                                     msg="ord is not yours"))
    ps = list(map(lambda item: item.to_dict(), list(detail.get("products"))))
    return jsonify(Result().success({
        "ord":
        detail.get("ord").to_dict(),
        "products":
        ps,
        "area":
        None if not detail.get("area") else detail.get("area").to_dict(),
        "gift_card":
        None
        if not detail.get("gift_card") else detail.get("gift_card").to_dict()
    }))
Esempio n. 30
0
def reg():
    content = request.data
    data = json.loads(str(content, encoding="utf-8"))
    mobile = data.get('mobile')
    password = data.get('password')
    password2 = data.get('password2')
    if not mobile or not password:
        return jsonify(Result().fail(code="param.null",
                                     msg="Invalid username/password"))
    if password != password2:
        return jsonify(Result().fail(code="password.not.equal",
                                     msg="password not equal"))
    if user_service.find_by_mobile(mobile):
        return jsonify(Result().fail(code="user.exists", msg="user exists"))
    else:
        save = UserSave()
        save.mobile = mobile
        save.password = password
        user_id = user_service.save(save)
        session["user_id"] = str(user_id)
        session["mobile"] = str(mobile)
        return jsonify(Result().success({"id": user_id}))
Esempio n. 31
0
    def search(self, q):
        """
        Prepare elements for request and play it
        """
        self.param = urlencode(self.param.myParam.get())
        self.recherche = urlparse(self.recherche.my_recherche.get())
        url = "%s%s%s" % (
            self.recherche[1],
            self.recherche[2],
            self.recherche[3]
        )
        ok, response, timer = self._requester()
        if not ok:
            self.error = Error()
            self.error.add_param(
                GT_('Erreur'),
                GT_('Url injoignable : %s\n%s') % (url, response)
            )
        else:
            self.result = Result()
            self.result.unset()
            # Request information (url, execution time)
            self.result.add_param(
                GT_('http://%s en %d.%06d secondes') % (
                    url,
                    timer.seconds,
                    timer.microseconds
                ),
                '%s : %s' % (response.status, response.reason)
            )
            # Request information (url, execution time)
            self.result.add_param(
                GT_('Entetes'),
                response.getheaders()
            )
            version = 1.0
            if response.version == 11:
                version = 1.1

            self.result.add_param(
                GT_('Version du protocole'),
                GT_('HTTP/%s' % version)
            )
        q.task_done()
Esempio n. 32
0
class Action:
    """
    Class Recherche
    Classe de controle de la vue "Recherche"
    """

    def __init__(self):
        """
        Constructeur du controleur de la vue "Recherche"
        A à sa charge la gestion des événements sur la vue "vue.Recherche"
        """
        self.param = Parametre()
        self.recherche = Recherche()
        self.header = Header()

    def search(self, q):
        """
        Prepare elements for request and play it
        """
        self.param = urlencode(self.param.myParam.get())
        self.recherche = urlparse(self.recherche.my_recherche.get())
        url = "%s%s%s" % (
            self.recherche[1],
            self.recherche[2],
            self.recherche[3]
        )
        ok, response, timer = self._requester()
        if not ok:
            self.error = Error()
            self.error.add_param(
                GT_('Erreur'),
                GT_('Url injoignable : %s\n%s') % (url, response)
            )
        else:
            self.result = Result()
            self.result.unset()
            # Request information (url, execution time)
            self.result.add_param(
                GT_('http://%s en %d.%06d secondes') % (
                    url,
                    timer.seconds,
                    timer.microseconds
                ),
                '%s : %s' % (response.status, response.reason)
            )
            # Request information (url, execution time)
            self.result.add_param(
                GT_('Entetes'),
                response.getheaders()
            )
            version = 1.0
            if response.version == 11:
                version = 1.1

            self.result.add_param(
                GT_('Version du protocole'),
                GT_('HTTP/%s' % version)
            )
        q.task_done()

    def _requester(self):
        """
        Execute request and return result
        """
        try:
            methode = 'POST'
            if not self.param:
                methode = 'GET'
            debut = datetime.now()
            connection = httplib.HTTPConnection(self.recherche[1])
            connection.request(
                methode,
                '%s/%s' % (self.recherche[2], self.recherche[3]),
                self.param,
                self.header.my_header.get()
            )
            response = connection.getresponse()
            connection.close()
            timer = datetime.now() - debut
            return True, response, timer
        except socket.gaierror:
            return False, GT_("Socket erreur"), None
        except http.client.InvalidURL:
            return False, GT_("Url non valide"), None
Esempio n. 33
0
 def results(self):
     arguments = {'count': 10, 'full': True, 'revision': self.sha1}
     raw_results = self.client.execute_request(rest_resource='resultset', get_arguments=arguments)
     return [Result.from_json(self.client, raw_result) for raw_result in raw_results]