Example #1
0
    def get(self):
        orderitems = []
        user = self.current_user

        try:
            order = Order.get(uid=user.id, status=0)

            for orderitem in OrderItem.select().where(
                    OrderItem.oid == order.id).dicts():
                try:
                    orderitem['shop'] = Shop.get(id=orderitem['sid'])
                    if orderitem['said'] > 0:
                        orderitem['shopattr'] = ShopAttr.get(
                            id=orderitem['said'])
                    orderitems.append(orderitem)
                except:
                    pass
        except:
            order = Order()

        ashops = Shop.select().where((Shop.cid == 2) & (Shop.status != 9))
        self.render("shop/order.html",
                    orderitems=orderitems,
                    order=order,
                    ashops=ashops)
Example #2
0
def insert_user(user_json):
  #print "INSERT USER"
  #print user_json
 
  user_string = json.loads(user_json)
  userAddress = Address(number = user_string["number"],
                    street = user_string["street"],
                    postalCode = user_string["postalCode"],
                    city = user_string["city"],
                    province = user_string["province"])

  #print "pizzaId: " + user_string["pizzaId"]
  
  userOrder = Order(qty = int(user_string["quantity"]),
								size = int(user_string["pizzaSize"]),
                pizza_type = int(user_string["pizzaId"]))   
  userAddress.put()
  userOrder.put()
  user = User(name = user_string["name"],
              phoneNumber = user_string["phoneNumber"],
              email = user_string["email"],
              addressId = userAddress.key(), 
              orderId = userOrder.key())  

  user.put()
  return user.key();
Example #3
0
 def post(self):
     notify = Notify_pub()
     xml = self.request.body
     notify.saveData(xml)
     if not notify.checkSign:
         notify.setParameter("return_code", "FAIL")
         notify.setReturnParameter("return_msg", "签名失败")
         print "签名失败"
     else:
         result = notify.getData()
         print "result:"
         print result
         
         if result["return_code"] == "FAIL":
             notify.setReturnParameter("return_code", "FAIL")
             notify.setReturnParameter("return_msg", "通信错误")
             print "通信错误"
         elif result["result_code"] == "FAIL":
             notify.setReturnParameter("return_code", "FAIL")
             notify.setReturnParameter("return_msg", result["err_code_des"])
         else:
             notify.setReturnParameter("return_code", "SUCCESS")
             out_trade_no = result["out_trade_no"]
             time_end = result["time_end"]
             print "支付成功:" + out_trade_no
             print "交易时间:" + time_end
             print "更改订单状态"
             Order.update(status = 1).where(Order.status == 0 and Order.wxid == out_trade_no).execute() #支付成功订单状态改为1
     return self.write(notify.returnXml()) 
Example #4
0
    def post(self):
        notify = Notify_pub()
        xml = self.request.body
        notify.saveData(xml)
        if not notify.checkSign:
            notify.setParameter("return_code", "FAIL")
            notify.setReturnParameter("return_msg", "签名失败")
            print "签名失败"
        else:
            result = notify.getData()
            print "result:"
            print result

            if result["return_code"] == "FAIL":
                notify.setReturnParameter("return_code", "FAIL")
                notify.setReturnParameter("return_msg", "通信错误")
                print "通信错误"
            elif result["result_code"] == "FAIL":
                notify.setReturnParameter("return_code", "FAIL")
                notify.setReturnParameter("return_msg", result["err_code_des"])
            else:
                notify.setReturnParameter("return_code", "SUCCESS")
                out_trade_no = result["out_trade_no"]
                time_end = result["time_end"]
                print "支付成功:" + out_trade_no
                print "交易时间:" + time_end
                print "更改订单状态"
                Order.update(status=1).where(
                    Order.status == 0
                    and Order.wxid == out_trade_no).execute()  #支付成功订单状态改为1
        return self.write(notify.returnXml())
Example #5
0
    def accept_order(self, order: Order):
        if order.get_id() in self.orders:
            self.remove_order(order.get_id())

        th = WorkingThread(self, order)
        self.working_threads.append(th)
        th.start()
        self.orders[order.get_id()] = order
Example #6
0
    def accept_order(self, order: Order):
        if order.get_id() in self.orders:
            self.remove_order(order.get_id())

        th = WorkingThread(self, order)
        self.working_threads.append(th)
        th.start()
        self.orders[order.get_id()] = order
Example #7
0
 def add_order(self):
     s = Session()
     ord = Order()
     ord.manager_id = self.parent.user.id
     ord.device =  unicode(self.ui.device.text())
     ord.description =  unicode(self.ui.description)
     ord.client_id = s.query(Client).filter_by(id=unicode(self.ui.client.itemText(self.ui.client.currentIndex())).split()[0]).one().id
     s.add(ord)
     s.commit()
     s.close()
     self.close()
Example #8
0
    def get(self):
        user = self.get_current_user()
        status = self.get_argument("status", None)

        ft = (Order.uid == user.id)

        if status:
            ft = ft & (Order.status == status)

        page = int(self.get_argument("page", 1))
        pagesize = self.settings['admin_pagesize']

        oq = Order.select().where(ft)
        total = oq.count()

        orders = []
        for order in oq.paginate(page, pagesize).dicts():
            order['orderitems'] = []

            for orderitem in OrderItem.select().where(
                    OrderItem.oid == order['id']).dicts():

                try:
                    orderitem['shop'] = Shop.get(id=orderitem['sid'])
                    if orderitem['said'] > 0:
                        orderitem['shopattr'] = ShopAttr.get(
                            id=orderitem['said'])
                except:
                    break

                order['orderitems'].append(orderitem)

            if order['orderitems']:
                orders.append(order)

            else:
                Order.delete().where(Order.id == order['id']).execute()

                try:
                    user = User.get(id=user.id)

                    if user.order > 0:
                        user.order = user.order - 1
                        user.save()
                        self.session['user'] = user
                        self.session.save()
                except:
                    pass

        self.render('user/order.html',
                    orders=orders,
                    total=total,
                    page=page,
                    pagesize=pagesize)
def reject_order(order_event):
    status = 'REJECTED'
    try:
        order = Order(order_event['order_id'])
        order.update(actions=[
            Order.order_status.set(status)
            # Order.cause.set(order_event['error']['Error'])
        ])
        return
    except UpdateError as e:
        error_message = 'update_order Error: {}'.format(vars(e))
        logging.exception(error_message)
        raise ErrorOrderUpdate(error_message)
Example #10
0
def submit_order():
    headers = request.headers
    if headers['Authorization'] != os.getenv("WEBHOOK_PSWD"):
        return ""

    data = request.json
    data['order_id'] = data['id']
    del data['id']
    del data['status']
    order = Order(**data)
    order.save()

    return jsonify({"success": True})
Example #11
0
 def get(self):
     user = self.get_current_user()
     status = self.get_argument("status", None)
     
     ft = (Order.uid == user.id)
     
     if status:
         ft = ft & (Order.status == status)
     
     page = int(self.get_argument("page", 1))
     pagesize = self.settings['admin_pagesize']
     
     oq = Order.select().where(ft)
     total = oq.count()
     
     orders = []
     for order in oq.paginate(page, pagesize).dicts():
         order['orderitems'] = []
         
         for orderitem in OrderItem.select().where(OrderItem.oid == order['id']).dicts():
             
             try:
                 orderitem['shop'] = Shop.get(id = orderitem['sid'])
                 if orderitem['said'] > 0:
                     orderitem['shopattr'] = ShopAttr.get(id = orderitem['said'])
             except:
                 break
             
             order['orderitems'].append(orderitem)
         
         if order['orderitems']:
             orders.append(order)
             
         else:
             Order.delete().where(Order.id == order['id']).execute()
             
             try:
                 user = User.get(id = user.id)
                 
                 if user.order > 0:
                     user.order = user.order - 1
                     user.save()
                     self.session['user'] = user
                     self.session.save()
             except:
                 pass
             
     
     self.render('user/order.html', orders = orders, total = total, page = page, pagesize = pagesize)
Example #12
0
def approve_order(order_event):
    status = 'APPROVED'
    try:
        order = Order(order_event['order_id'])
        order.update(
            actions=[
                Order.order_status.set(status)
            ]
        )
        return

    except UpdateError as e:
        error_message = 'update_order Error: {}'.format(vars(e))
        logging.exception(error_message)
        raise ErrorOrderUpdate(error_message)
def booking(id):
    apartment = Apartment.query.filter_by(id=id).first()
    if request.method == 'POST':
        daterange = request.values.get('daterange')
        if daterange:
            l = daterange.split('-')
            checkin = datetime.strptime(l[0].strip(), '%m/%d/%Y').date()
            checkout = datetime.strptime(l[1].strip(), '%m/%d/%Y').date()

            if not apartment.checkbooking(checkin, checkout):
                booking = Order(user_id=current_user.id,
                                apartment_id=id,
                                checkin_date=checkin,
                                checkout_date=checkout)

                db.session.add(booking)
                db.session.commit()

                flash('This booking ordered.', 'success')
                return redirect(url_for('apartment', id=id))
            else:
                flash('This apartment is booked in this daterange', 'info')
        else:
            flash('Booking date not selected.', 'warning')
    return render_template('booking.html', data=apartment)
Example #14
0
def create_order():
    global order_counter
    parser = reqparse.RequestParser()
    parser.add_argument('coffee_id', type=int, required=True)
    parser.add_argument('additions', type=str, action='append')
    args = parser.parse_args()

    coffee_id = args.get("coffee_id")
    additions = args.get("additions")
    for row in coffee_db:
        if int(row.coffee_id) == int(coffee_id):
            coffee = row
            break
    else:
        return jsonify(coffee_id=False), 404

    order_counter += 1
    new = Order(order_counter, coffee_id, coffee.coffee_name, coffee.cost,
                'open', additions)
    order_db.append(new)
    return jsonify({
        'data': new.__dict__,
        'payment': {
            'link': url_for('create_payment', order_id=order_counter),
            'method': 'POST'
        }
    }), 201
Example #15
0
 def get(self, oid):
     orderitems = []
     price = 0.0
     credit = 0.0
     order = None
     try:
         order = Order.get(id = oid)
         print order.id
         for orderitem in OrderItem.select().where(OrderItem.oid == order.id).dicts():
             try:
                 orderitem['shop'] = Shop.get(id = orderitem['sid'])
                 _oiprice = orderitem['shop'].price
                 
                 if orderitem['said'] > 0:
                     orderitem['shopattr'] = ShopAttr.get(id = orderitem['said'])
                     if orderitem['shop'].cid == 1:
                         _oicredit = orderitem['shopattr'].price
                         credit = credit + _oicredit * orderitem['num']
                         _oiprice = orderitem['shopattr'].price
                     else:
                         _oiprice = orderitem['shopattr'].price
                 else:
                     _oiprice = float(_oiprice)
                     
                 orderitems.append(orderitem)
                 price = price + float(_oiprice) * orderitem['num']
             except:
                 pass
         print price
     except:
         pass
     
     self.render("/responsive/user_confirmorder.html", order = order, credit = credit, orderitems = orderitems)
Example #16
0
 def get(self, oid):
     try:
         order = Order.get(id = oid)
     except:
         pass
     
     self.render("admin/changeorder.html", order = order)
Example #17
0
    def test_job_transmission(self):
        self.awake_single()
        # campaignをセット
        campaign = Campaign(author="cxxx0",
                            requirement=Requirement(values=["zero", "random"],
                                                    trigger={"timer": 1}),
                            trigger={"timer": 5},
                            place="All",
                            purpose="test_purpose",
                            destination="mongodb://localhost:27017/")
        clients["cxxx0"].post('/commander/campaigns',
                              data=json.dumps(campaign.to_dict()),
                              content_type='application/json')
        time.sleep(1.5)  # heartbeatを待つ; 0.7 + 0.4 + alpha

        # missionを確認
        mission = Mission(author="lxxx0",
                          requirement=Requirement(values=["zero", "random"],
                                                  trigger={"timer": 1}),
                          trigger={"timer": 5},
                          place="All",
                          purpose=campaign.get_id())
        self.assertIn(mission, self.models["lxxx0"].missions.values())

        # orderを確認
        order = Order(author="sxxx0",
                      values=["zero", "random"],
                      trigger={"timer": 1},
                      purpose=mission.get_id())
        self.assertIn(order, self.models["sxxx0"].orders.values())
Example #18
0
    def get(self, oiid):
        result = {'status': False, 'msg': 0}
        user = self.get_current_user()

        if user:
            try:
                orderitem = OrderItem.get(id=oiid)
                order = Order.get(id=orderitem.oid)

                if order.uid == user.id:
                    if OrderItem.select().where(
                            OrderItem.oid == orderitem.oid).count() == 1:
                        order.delete_instance()

                        if user.order > 0:
                            user.order = user.order - 1
                            user.save()
                            self.session['user'] = user
                            self.session.save()

                    orderitem.delete_instance()
                    result['status'] = True
                    result['msg'] = 200

                else:
                    result['msg'] = 403

            except Exception, ex:
                logging.error(ex)
                result['msg'] = 500
Example #19
0
    def post(self, oid, sid):

        result = {'status': False, 'msg': 0}
        user = self.get_current_user()

        if user:
            try:
                order = Order.get(id=oid)

                if order.uid == user.id:
                    try:
                        orderitem = OrderItem.get(OrderItem.oid == oid,
                                                  OrderItem.sid == sid)
                    except:
                        orderitem = OrderItem()

                    orderitem.oid = oid
                    orderitem.sid = sid
                    orderitem.num = orderitem.num + 1

                    try:
                        orderitem.save()
                        result['status'] = True
                        result['msg'] = 200
                    except Exception, ex:
                        logging.error(ex)
                        result['msg'] = 500
                else:
                    result['msg'] = 403
Example #20
0
    def accept_mission(self, mission: Mission) -> Mission:
        # Missionの更新であれば(=IDが同じであれば)既存のものを消す
        if mission.get_id() in self.missions:
            self.remove_mission(mission.get_id())

        # 部下のOrderを生成・割り当てる
        target_subs = []
        if mission.place == "All":
            target_subs = list(self.subordinates.values())
        for sol in target_subs:
            m_req = mission.requirement
            values = list(set(m_req.values).intersection(sol.weapons))
            order = Order(author=sol.id,
                          values=values,
                          trigger=m_req.trigger,
                          purpose=mission.get_id())
            sol.orders.append(order)

        # 自身のデータ送信スレッドを生成する
        th = WorkingThread(self, mission)
        self.working_threads.append(th)
        th.start()

        self.missions[mission.get_id()] = mission
        return mission
Example #21
0
    def get(self):
        iscatched = False
        if self.current_user:
            beginvalue = time.mktime(time.strptime('2015-01-12', "%Y-%m-%d"))
            endvalue = time.mktime(time.strptime('2015-01-31', "%Y-%m-%d"))

            q = Order.select(Order.currentprice).where(
                (Order.user == self.current_user)
                & (Order.ordered >= beginvalue) & (Order.status < 5)
                & (Order.ordered < endvalue) & (Order.payment < 9)
                & (((Order.status > -1) & (Order.payment == 0)) | (
                    (Order.status > 0) & (Order.payment > 0)))).dicts()

            price = sum([n['currentprice'] for n in q])
            cpcount = int(price / 50.0)
            activities = UserActivity.select().where(
                UserActivity.user == self.current_user.id)
            if activities.count() > 0:
                iscatched = True
        else:
            price = 0.0
            cpcount = 0
        list = ProductStandard.select(ProductStandard).join(Product). \
            where((ProductStandard.id << [268,215,128,279,38,37,84,86]) & (Product.status == 1))
        self.render('activity/new_year.html',
                    user=self.current_user,
                    price=price,
                    cpcount=cpcount,
                    iscatched=iscatched,
                    list=list)
Example #22
0
 def get(self, oiid):
     result = {'status' : False, 'msg' : 0}
     user = self.get_current_user()
     
     if user:
         try:
             orderitem  = OrderItem.get(id = oiid)
             order = Order.get(id = orderitem.oid)
             
             if order.uid == user.id:
                 if OrderItem.select().where(OrderItem.oid == orderitem.oid).count() == 1:
                     order.delete_instance()
                     
                     if user.order > 0:
                         user.order = user.order - 1
                         user.save()
                         self.session['user'] = user
                         self.session.save()
                 
                 orderitem.delete_instance()
                 result['status'] = True
                 result['msg'] = 200
                 
             else:
                 result['msg'] = 403
             
         except Exception, ex:
             logging.error(ex)
             result['msg'] = 500
Example #23
0
 def post(self, oid, sid):
     
     result = {'status' : False, 'msg' : 0}
     user = self.get_current_user()
     
     if user:
         try:
             order = Order.get(id = oid)
             
             if order.uid == user.id:
                 try:
                     orderitem = OrderItem.get(OrderItem.oid == oid, OrderItem.sid == sid)
                 except:
                     orderitem = OrderItem()
                 
                 orderitem.oid = oid
                 orderitem.sid = sid
                 orderitem.num = orderitem.num + 1
                 
                 try:
                     orderitem.save()
                     result['status'] = True
                     result['msg'] = 200
                 except Exception, ex:
                     logging.error(ex)
                     result['msg'] = 500
             else:
                 result['msg'] = 403
Example #24
0
    def get(self, oid):
        try:
            order = Order.get(id=oid)
        except:
            pass

        self.render("admin/changeorder.html", order=order)
Example #25
0
 def make(cls, source: dict):
     try:
         return cls(source['id'], source['name'], source['place'],
                    source['weapons'],
                    [Order.make(o) for o in source['orders']])
     except KeyError:
         raise TypeError
Example #26
0
def check_order_store_quantity(store_id, oid):
    result = 0
    items = OrderItem.select().where(OrderItem.order == oid)
    r = 0
    if store_id:
        for i in items:
            if i.product.is_store == 1:  # and i.product.store.id == int(store_id)
                r += 1
            else:
                r += check_store_product_quantity(store_id,
                                                  i.product_standard.id)
        if r == items.count():
            result = 1
    else:
        list = []
        order = Order.get(Order.id == oid)
        store = Store.select().where(Store.status == 1)
        sid = 0
        for s in store:
            ss = getDistanceAS(order.take_address.replace(' ', ''), s.id)
            if ss['flag'] == 1:
                list.append(float(ss['data']))
                if float(ss['data']) < setting.PeiSongDistance:
                    sid = s.id
        for i in items:
            if i.product.is_store == 1 and i.product.store.id == sid:
                r += 1
            else:
                r += check_store_product_quantity(sid, i.product_standard.id)
        if r == items.count():
            result = 1
    return result
Example #27
0
def createOrder():
    current_user = get_jwt_identity()

    vir = Order(current_user)
    db.session.add(vir)
    db.session.commit()

    carts = Cart.query.filter_by(creator_id=current_user, removed=False).all()
    orders = []
    for cart in carts:
        product = Product.query.filter_by(id=cart.product_id,
                                          shelved=True,
                                          archived=False).first()
        description = Description.query.filter_by(product_id=cart.product_id,
                                                  active=True,
                                                  removed=False).first()
        # 限购暂未实现
        print(description.remain, cart.count)
        if (not product) or (not description) or (description.remain <
                                                  cart.count):
            orders.append([False, cart.id])
            continue
        description.remain = description.remain - cart.count
        order = Order(current_user)
        order.fill(cart.product_id, cart.count, description.price, vir.id)
        db.session.add(order)
        cart.removed = True
        db.session.commit()
        orders.append(
            [True, cart.id, cart.product_id, cart.count, description.price])
    return jsonify(orders=orders, price=vir.cost()), 200
Example #28
0
    def get(self):
        orderitems = []
        user = self.current_user

        order = None

        distributions = self.get_distributions()
        price = 0.0
        credit = 0.0

        try:
            order = Order.get(uid=user.id, status=0)

            try:
                mobile = '18014349809'
                sendmsg(self.settings, mobile, '新订单')
            except:
                pass

            for orderitem in OrderItem.select().where(
                    OrderItem.oid == order.id).dicts():
                try:
                    orderitem['shop'] = Shop.get(id=orderitem['sid'])
                    _oiprice = orderitem['shop'].price

                    if orderitem['said'] > 0:
                        orderitem['shopattr'] = ShopAttr.get(
                            id=orderitem['said'])
                        if orderitem['shop'].cid == 1:
                            _oicredit = orderitem['shopattr'].price
                            credit = credit + _oicredit * orderitem['num']
                        else:
                            _oiprice = orderitem['shopattr'].price
                    else:
                        _oiprice = float(_oiprice)

                    orderitems.append(orderitem)

                    price = price + _oiprice * orderitem['num']

                except:
                    pass
            order.price = price
            order.save()

        except:
            pass

        if orderitems:
            self.render("shop/settle.html",
                        tmday=datetime.date.today() +
                        datetime.timedelta(days=1),
                        order=order,
                        orderitems=orderitems,
                        distributions=distributions.values(),
                        credit=credit)
Example #29
0
 def make(cls, source: dict):
     try:
         return cls(
             source['id'],
             source['name'],
             source['place'],
             source['weapons'],
             [Order.make(o) for o in source['orders']]
         )
     except KeyError:
         raise TypeError
Example #30
0
def save_order(order_data):
    order = Order(order_id=order_data.get("id"),
                  side=order_data.get("side"),
                  state=order_data.get("state"),
                  price=float(order_data.get("price")),
                  symbol=order_data.get("symbol"),
                  amount=float(order_data.get("amount")),
                  filled_amount=float(order_data.get("filled_amount")),
                  fill_fees=float(order_data.get("fill_fees")))
    with DBSession() as session:
        session.add(order)
def add_order_details(order_id, address, user_id):
    try:
        order = Order(order_id=order_id, address=address, user=user_id)
        db.session.add(order)
        db.session.commit()
        return True
    except IntegrityError:
        return make_response(
            jsonify({'response': "user name or email already exists"}), 400)
    except (InvalidRequestError, OperationalError):
        raise InvalidUsageError('sql connection or syntax is improper', 500)
Example #32
0
    def post(self):

        result = {'status': False, 'msg': 0}
        user = self.get_current_user()

        if user:
            sid = int(self.get_argument("sid", 0))
            said = int(self.get_argument("said", 0))
            num = int(self.get_argument("num", 1))

            #判断商品是否下架
            if sid > 0 and said > 0 and num > 0:
                try:
                    Shop.get(id=sid)
                    ShopAttr.get(id=said)

                    #判断是否有未使用的订单或生成新订单
                    try:
                        try:
                            order = Order.get(uid=user.id, status=0)
                        except:
                            order = Order()
                            order.uid = user.id
                            order.mobile = user.mobile
                            order.ordered = int(time.time())
                            try:
                                order.save()
                            except Exception, ex:
                                logging.error(ex)

                        try:
                            orderitem = OrderItem.get(oid=order.id,
                                                      sid=sid,
                                                      said=said)
                        except:
                            orderitem = OrderItem()

                        orderitem.oid = order.id
                        orderitem.sid = sid
                        orderitem.said = said
                        orderitem.num = orderitem.num + num
                        orderitem.save()

                        result['status'] = True
                        result['msg'] = 200

                    except Exception, ex:
                        logging.error(ex)
                        result['msg'] = 500

                except:
Example #33
0
    def create_order(self, rq_user_id, products):
        session = self.Session()

        try:
            user = session.query(User).get(rq_user_id)

            if user is None:
                raise Exception('Unable to find user with id = %s' %
                                rq_user_id)

            order_line_list = []
            user_order = Order(user_id=rq_user_id, order_total=0)

            for prod_def in products:
                db_product = session.query(Product).get(prod_def['productId'])
                if db_product is None:
                    raise Exception('Product not found with ProductID: %s' %
                                    prod_def['productId'])
                order_line = OrderLine(product=db_product,
                                       order=user_order,
                                       quantity=prod_def['quantity'])
                order_line_list.append(order_line)
                user_order.order_total = user_order.order_total + db_product.price * prod_def[
                    'quantity']

            session.add(user_order)
            session.add_all(order_line_list)
            session.commit()

            the_order = session.query(Order).get(user_order.order_id)

            return the_order.to_json()

        except Exception as e:
            logging.error('*** Exception in create_order: %s' % e)
            traceback.print_exc()

            session.rollback()
            raise
        finally:
            session.close()
Example #34
0
 def insert_order(self, order_dict):
     order = Order(id=order_dict.get('id'),
                   reqId=order_dict.get('reqId'),
                   createTime=datetime.now(),
                   updateTime=None,
                   status=order_dict.get('status'),
                   total=order_dict.get('total'),
                   payWay=order_dict.get('pay_way'))
     session = self.get_session()
     session.add(order)
     session.commit()
     session.close()
Example #35
0
def order_item(order_event):
    logger.info('order_item: {}'.format(order_event))
    try:
        order = Order(order_event['order_id'],
                      order_date=order_event['order_date'],
                      customer_id=order_event['customer_id'],
                      items=order_event['items'],
                      order_status='APPROVED_PENDING')
        return order
    except Exception as e:
        logging.error('Error: order_item: {}'.format(vars(e)))
        raise e
Example #36
0
File: views.py Project: giskar/shop
def buy():
    if request.method == 'POST' and request.form['name']:

        order = Order(
            # goods = request.form['goods'],
            name=request.form['name'],
            phone=request.form['phone'],
            pay_method=request.form['payment'],
            del_method=request.form['delivery'],
        )
        order.save()

        # huey = Goods.get(Goods.id == 2)
        # cs1 = Order.get(Order.id == 2)
        # huey.orders.add(cs1)
        #
        id_goods = request.form['goods'].split()
        for id in id_goods:
            huey = Goods.get(Goods.id == id)
            huey.orders.add(Order.get(Order.id == order.id))

    return redirect(url_for('goods_list'))
Example #37
0
def create_order():

    if request.method == "POST":

        params = request.json
        latitude = request.json["latitude"]
        longitude = request.json["longitude"]
        user_id = request.json["user_id"]
        text = request.json["text"]
        location_text = ""

        new_order = Order(
            latitude=latitude, longitude=longitude, text=text, location_text=location_text, user_id=user_id
        )

        g.db.add(new_order)
        g.db.flush()
        g.socketio.emit("order", new_order.serialize(), namespace="/update")
        return resource_created(new_order)

    else:

        return invalid_method()
def get_order():
    if db.is_closed():
        db.connect()

    order = Order.get_or_none(Order.is_processing == False)
    if not order:
        return

    order.is_processing = True
    order.save()
    if not db.is_closed():
        db.close()

    return order
Example #39
0
    def neworder(self, session_id, json_order):
        distributor = self._get_distributor(session_id)

        if not distributor:
            return json_error("NotLoggedIn")

        order_dict = json.loads(json_order)

        product_id = order_dict["product_id"]
        amount = order_dict["amount"]

        try:
            product = self.session.query(Product).filter(Product.product_id == product_id).one()
        except:
            return json_error("ProductNonExistant")

        order = Order(datetime.now(), amount)
        order.distributor_id = distributor.dist_id
        order.product_id = product.product_id
        self.session.add(order)
        try:
            self.session.commit()
        except:
            self.session.rollback()
            return json_error("ProductNotAdded")

        #product_order = Product_Order(product_id=product.product_id, order_id=order.order_id)

        #self.session.add(product_order)

        #try:
            #self.session.commit()
        #except:
            #self.session.rollback()
            #return json_error("ProductNotAdded")

        return json_neworder(order.order_id)
Example #40
0
def new_order(customer_id, product_list):

    order = Order(customer_id)

    db.session.add(order)
    db.session.commit(
    )  # order id has to be generated first to add products in order

    for product in product_list:

        link = product.get('link')
        description = product.get('description')
        quantity = product.get('quantity')

        new_product(order.id, link, description, quantity)
Example #41
0
 def get(self):
     orderitems = []
     user = self.current_user
     
     order = None
     
     distributions = self.get_distributions()
     price = 0.0
     credit = 0.0
     
     try:
         order = Order.get(uid = user.id, status = 0)
         
         try:
             mobile = '18014349809'
             sendmsg(self.settings, mobile, '新订单')
         except:
             pass
             
         for orderitem in OrderItem.select().where(OrderItem.oid == order.id).dicts():
             try:
                 orderitem['shop'] = Shop.get(id = orderitem['sid'])
                 _oiprice = orderitem['shop'].price
                 
                 if orderitem['said'] > 0:
                     orderitem['shopattr'] = ShopAttr.get(id = orderitem['said'])
                     if orderitem['shop'].cid == 1:
                         _oicredit = orderitem['shopattr'].price
                         credit = credit + _oicredit * orderitem['num']
                     else:
                         _oiprice = orderitem['shopattr'].price
                 else:
                     _oiprice = float(_oiprice)
                 
                 orderitems.append(orderitem)
                 
                 price = price + _oiprice * orderitem['num']
                 
             except:
                 pass
         order.price = price
         order.save()
         
     except:
         pass
     
     if orderitems:
         self.render("shop/settle.html", tmday = datetime.date.today() + datetime.timedelta(days=1), order  = order, orderitems = orderitems, distributions = distributions.values(), credit = credit)
Example #42
0
def add_order(amazon_fresh_order_id, delivery_date, delivery_day_of_week,
              delivery_time, user_gmail, line_items_one_order):
    """Adds information for one order to database"""

    order = Order.query.filter_by(
        amazon_fresh_order_id=amazon_fresh_order_id).first()

    if order:
        print "Order # %s already in database" % amazon_fresh_order_id
    else:
        order = Order(amazon_fresh_order_id=amazon_fresh_order_id,
                      delivery_date=delivery_date,
                      delivery_day_of_week=delivery_day_of_week,
                      delivery_time=delivery_time,
                      user_gmail=user_gmail)
        db.session.add(order)

        print "Order # %s added to database" % amazon_fresh_order_id

        for line_item_info in line_items_one_order:  # line_item_info is a list of info for one line item ex [1, 5.50, "description"]
            quantity, unit_price_cents, description = line_item_info

            description_key = ""
            for char in description:
                if char.isalpha():
                    description_key += char
            description_key = description_key.lower()

            item = Item.query.filter_by(
                description_key=description_key).first()

            if item:
                print "General item description '%s' already in database." % (
                    description)
            else:
                add_item(description, description_key)
                print "General item description '%s' added to database." % (
                    description)

            item = Item.query.filter_by(
                description_key=description_key).first()

            add_line_item(amazon_fresh_order_id, item.item_id,
                          unit_price_cents, quantity)
            print "Line item '%s', added to database for order # %s" % (
                description, amazon_fresh_order_id)

    db.session.commit()
Example #43
0
    def post(self):
        
        result = {'status' : False, 'msg' : 0}
        user = self.get_current_user()
        
        if user:
            sid = int(self.get_argument("sid", 0))
            said = int(self.get_argument("said", 0))
            num = int(self.get_argument("num", 1))
            
            #判断商品是否下架
            if sid > 0 and said > 0 and num > 0:
                try:
                    Shop.get(id = sid)
                    ShopAttr.get(id = said)
                    
                    #判断是否有未使用的订单或生成新订单
                    try:
                        try:
                            order = Order.get(uid = user.id, status = 0)
                        except:
                            order = Order()
                            order.uid = user.id
                            order.mobile = user.mobile
                            order.ordered = int(time.time())
                            try:
                                order.save()
                            except Exception, ex:
                                logging.error(ex)
                        
                        try:
                            orderitem = OrderItem.get(oid = order.id, sid = sid, said = said)
                        except:
                            orderitem = OrderItem()

                        orderitem.oid = order.id
                        orderitem.sid = sid
                        orderitem.said = said
                        orderitem.num = orderitem.num + num
                        orderitem.save()
                        
                        result['status'] = True
                        result['msg'] = 200
                        
                    except Exception, ex:
                        logging.error(ex)
                        result['msg'] = 500
                    
                except:
Example #44
0
 def post(self):
     alipay = Alipay(**self.settings)
     
     params = {}
     ks = list(self.request.arguments.keys())
     
     for k in ks:
         params[k] = self.get_argument(k)
         
     if alipay.notify_verify(params):
         tn = self.get_argument("out_trade_no", None)
         trade_no = self.get_argument("trade_no", None)
         trade_status = self.get_argument("trade_status", None)
         logging.info("notify:%s - %s - %s" % (tn, trade_no, trade_status))
         
         oid = int(tn.split('-')[1].replace('S', ''))
         
         try:
             order = Order.get(id = oid)
             
             if order.status == 0:
                 order.status = 1
                 order.save()
                 
                 user = User.get(id = order.uid)
                 user.credit = user.credit + int(order.price)
                 user.save()
                 
                 log = CreditLog()
                 log.uid = order.uid
                 log.mobile = user.mobile
                 log.ctype = 0
                 log.affect = int(order.price)
                 log.log = '成功下单 - %s' %  tn
                 log.save()
             
         except Exception as ex:
             logging.error(ex)
         
         if trade_status == 'WAIT_SELLER_SEND_GOODS':
             alipay.send_goods_confirm_by_platform(trade_no)
         
         self.write("success")
     else:
         self.write("fail")
Example #45
0
 def get(self):
     alipay = Alipay(**self.settings)
     
     params = {}
     ks = list(self.request.arguments.keys())
     
     for k in ks:
         params[k] = self.get_argument(k)
     
     if alipay.notify_verify(params):
         tn = self.get_argument("out_trade_no", None)
         trade_no = self.get_argument("trade_no", None)
         trade_status = self.get_argument("trade_status", None)
         logging.info("return:%s - %s - %s" % (tn, trade_no, trade_status))
         oid = int(tn.split('-')[1].replace('S', ''))
         
         try:
             order = Order.get(id = oid)
             order.status = 1
             order.save()
             
             user = User.get(id = order.uid)
             user.credit = user.credit + int(order.price)
             user.save()
             
             log = CreditLog()
             log.uid = order.uid
             log.mobile = user.mobile
             log.ctype = 0
             log.affect = int(order.price)
             log.log = '成功下单 - %s' %  tn
             log.save()
             
             self.session['user'] = user
             self.session.save()
         
             alipay.send_goods_confirm_by_platform(trade_no)
             self.flash("支付成功")
         except Exception as ex:
             logging.error(ex)
         else:
             self.flash("支付失败")
     self.redirect("/pay")
Example #46
0
 def get(self):
     orderitems = []
     user = self.current_user
     
     try:
         order = Order.get(uid = user.id, status = 0)
         
         for orderitem in OrderItem.select().where(OrderItem.oid == order.id).dicts():
             try:
                 orderitem['shop'] = Shop.get(id = orderitem['sid'])
                 if orderitem['said'] > 0:
                     orderitem['shopattr'] = ShopAttr.get(id = orderitem['said'])
                 orderitems.append(orderitem)
             except:
                 pass
     except:
         order = Order()
     
     ashops = Shop.select().where((Shop.cid == 2) & (Shop.status != 9))
     self.render("shop/order.html", orderitems = orderitems, order = order, ashops = ashops)
Example #47
0
 def get(self):
     status = self.get_argument("status", None)
     ft = (Order.status >= 0)
     if status:
         ft = ft & (Order.status == status)
     
     page = int(self.get_argument("page", 1))
     pagesize = self.settings['admin_pagesize']
     
     oq = Order.select().where(ft)
     total = oq.count()
             
     orders = []
     for order in oq.paginate(page, pagesize).order_by(Order.ordered.desc()).dicts():
         order['orderitems'] = []
         try:
             order['ua'] = UserAddr.get(id = order['uaid'])
         except:
             order['ua'] = UserAddr()
         
         try:
             order['distr'] = Distribution.get(id = order['distrid'])
         except:
             order['distr'] = Distribution()
             
         for orderitem in OrderItem.select().where(OrderItem.oid == order['id']).dicts():
             
             try:
                 orderitem['shop'] = Shop.get(id = orderitem['sid'])
                 if orderitem['said'] > 0:
                     orderitem['shopattr'] = ShopAttr.get(id = orderitem['said'])
                 
                 order['orderitems'].append(orderitem)
             except:
                 orderitem['shop'] = Shop()
         
         if order['orderitems']:
             orders.append(order)
     
     self.render('admin/order.html', orders = orders, total = total, page = page, pagesize = pagesize)
Example #48
0
 def get(self):
     orderitems = []
     user = self.current_user
     
     order = None
     
     distributions = self.get_distributions()
     price = 0.0
     credit = 0.0
     
     try:
         order = Order.get(uid = user.id, status = 0)
         print order.id
         '''
         try:
             mobile = '18014349809'
             sendmsg(self.settings, mobile, '新订单')
         except:
             pass
         '''    
         for orderitem in OrderItem.select().where(OrderItem.oid == order.id).dicts():
             try:
                 orderitem['shop'] = Shop.get(id = orderitem['sid'])
                 _oiprice = orderitem['shop'].price
                 
                 if orderitem['said'] > 0:
                     orderitem['shopattr'] = ShopAttr.get(id = orderitem['said'])
                     if orderitem['shop'].cid == 1:
                         _oicredit = orderitem['shopattr'].price
                         credit = credit + _oicredit * orderitem['num']
                         _oiprice = orderitem['shopattr'].price
                     else:
                         _oiprice = orderitem['shopattr'].price
                 else:
                     _oiprice = float(_oiprice)
                     
                 orderitems.append(orderitem)
                 price = price + float(_oiprice) * orderitem['num']
             except:
                 pass
         print price
         price_pay = str(int(price*100))
         print 'price_pay:' + price_pay
         openid = user.openid
         print 'wx_pay:'+ openid
         jsApi = JsApi_pub()
         unifiedOrder = UnifiedOrder_pub()
         unifiedOrder.setParameter("openid",openid) #商品描述
         unifiedOrder.setParameter("body","菜市优品购物") #商品描述
         timeStamp = time.time()
         print timeStamp
         out_trade_no = "{0}{1}".format(WxPayConf_pub.APPID, int(timeStamp*100))
         unifiedOrder.setParameter("out_trade_no", out_trade_no) #商户订单号
         print 'out_trade_no:' + out_trade_no
         Order.update(wxid = out_trade_no).where(Order.id == order.id).execute()
         unifiedOrder.setParameter("total_fee", price_pay) #总金额
         print WxPayConf_pub.NOTIFY_URL
         unifiedOrder.setParameter("notify_url", WxPayConf_pub.NOTIFY_URL) #通知地址 
         unifiedOrder.setParameter("trade_type", "JSAPI") #交易类型
         
         prepay_id = unifiedOrder.getPrepayId()
         jsApi.setPrepayId(prepay_id)
         jsApiParameters = jsApi.getParameters()
         print jsApiParameters
         appid = json.loads(jsApiParameters).get("appId")
         timestamp = json.loads(jsApiParameters).get("timeStamp")
         noncestr = json.loads(jsApiParameters).get("nonceStr")
         package = json.loads(jsApiParameters).get("package")
         signtype = json.loads(jsApiParameters).get("signType")
         paysign = json.loads(jsApiParameters).get("paySign")
         print appid + timestamp + noncestr + package + signtype +paysign
         if orderitems:
             self.render("/responsive/wxpay.html", tmday = datetime.date.today() + datetime.timedelta(days=1), order  = order, orderitems = orderitems, distributions = distributions.values(), credit = credit, appid = appid, timestamp = timestamp, noncestr = noncestr, package = package, signtype = signtype, paysign = paysign)
     except:
         pass
Example #49
0
 def post(self):
     order = None
     user = self.get_current_user()
     
     try:
         order = Order.get(uid = user.id, status = 0)
         
         mobile = self.get_argument("mobile", user.mobile)
         uaid = self.get_argument("uaid", None)
         distrid = self.get_argument("distrid", None)
         day = self.get_argument("day", datetime.date.today() + datetime.timedelta(days=1))
         hour = int(self.get_argument("hour", 10))
         payment = self.get_argument("payment", 0)
         message = self.get_argument("message", "")
         isinvoice = self.get_argument("isinvoice", 0)
         invoicesub = self.get_argument("invoicesub", 0)
         invoicename = self.get_argument("invoicename", "")
         invoicecontent = self.get_argument("payment", 1)
         shippingprice = self.get_argument("shippingprice", 0.0)
         
         if uaid and distrid:
             try:
                 distrib = Distribution.get(id = distrid)
                 shippingprice = distrib.price
             except:
                 pass
             
             order.mobile = mobile
             order.uaid = uaid
             order.distrid = distrid
             order.distribbed = "%s %d:00:00" % (str(day), hour)
             order.payment = payment
             order.message = message
             
             order.isinvoice = isinvoice
             
             if isinvoice:
                 order.invoicesub = invoicesub
                 order.invoicename = invoicename
                 order.invoicecontent = invoicecontent
             
             order.shippingprice = shippingprice
             
             order.save()
             
             
                 
             body = ""
             for orderitem in OrderItem.select().where(OrderItem.oid == order.id).dicts():
                     
                 try:
                     shop = Shop.get(id = orderitem['sid'])
                         
                     sname = ""
                     if orderitem['said'] > 0:
                         shopattr = ShopAttr.get(id = orderitem['said'])
                         
                         if shop.cid == 1:
                             credits = shopattr.price * orderitem['num']
                             
                             if credits > user.credit:
                                 OrderItem.delete().where(OrderItem.id == orderitem['id']).execute()
                             else:
                                 user = User.get(id = user.id)
                                 user.credit = user.credit - credits
                                 user.save()
                                 
                                 clog = CreditLog()
                                 clog.uid = user.id
                                 clog.mobile = user.mobile
                                 clog.ctype = 1
                                 clog.affect = int(credits)
                                 clog.log = u"购买" + shop.name
                                 clog.save()
                                 
                                 self.session['user'] = user
                                 self.session.save()
                                 
                         sname = shopattr.name
                         
                     #body = body + shop.name + " " + sname + " " + str(orderitem['num']) + "个\n"
                     body = body + shop.name + " " + sname + " " + str(orderitem['num'])
                 except Exception, ex:
                     logging.error(ex)
             
             tn = "U%d-S%d" % (user.id, order.id)
             
             if int(payment) == 1:
                 self.redirect("/alipay/topay?tn=%s&body=%s&price=%f" % (tn, body, order.price))
             else:
                 self.flash(u"请选择地址和收货方式")
                 self.redirect("/user/orders")
         else:
Example #50
0
 def post(self, oid):
     #status = int(self.get_argument("status", 0))
     
     Order.update(status = 3).where(Order.id == oid).execute()
     self.flash("修改成功")
     self.redirect("/user/orders")