Example #1
0
 def post(self):
     try:
         db = get_connection()
         result = self.get_argument("result")
         method = self.get_argument("method", None)
         cart_no = result[2:]
         res = get_model("ecom.cart").search([["number", "=", cart_no]])
         if not res:
             raise Exception("Invalid cart  number")
         cart_id = res[0]
         cart = get_model("ecom.cart").browse(cart_id)
         if method:
             cart.update_paysbuy_method(method)
         if result.startswith("00") and not cart.is_paid:
             set_active_user(1)
             set_active_company(1)
             cart.import_paysbuy_payment()  # Inquiry Doublecheck
         db.commit()
     except Exception as e:
         db = get_connection()
         db.rollback
         import traceback
         audit_log("Failed to get result payment from paysbuy",
                   details=traceback.format_exc())
         traceback.print_exc()
Example #2
0
 def post(self):
     try:
         db = get_connection()
         result = self.get_argument("result")
         method = self.get_argument("method", None)
         cart_no = result[2:]
         res = get_model("ecom.cart").search([["number", "=", cart_no]])
         if not res:
             raise Exception("Invalid cart  number")
         cart_id=res[0]
         cart=get_model("ecom.cart").browse(cart_id)
         if method:
             cart.update_paysbuy_method(method)
             db = database.get_connection()
             db.commit()
         if result.startswith("00") and not cart.is_paid:
             set_active_user(1)
             set_active_company(1)
             cart.import_paysbuy_payment()  # Inquiry Doublecheck
             db.commit()
     except Exception as e:
         db = get_connection()
         db.rollback
         import traceback
         audit_log("Failed to get result payment from paysbuy", details=traceback.format_exc())
         traceback.print_exc()
Example #3
0
 def login(self, context={}):
     set_active_user(None)
     data = context["data"]
     db_name = data.get("db_name")
     if not db_name:
         raise Exception("Missing db name")
     database.set_active_db(db_name)
     login = data["login"]
     password = data["password"]
     user_id = get_model("base.user").check_password(login, password)
     if not user_id:
         audit_log("Invalid login (%s)" % login)
         db = database.get_connection()
         db.commit()
         raise Exception("Invalid login")
     try:
         print("login ok", login)
         set_active_user(1)
         user = get_model("base.user").browse(user_id)
         if user.profile_id.prevent_login or not user.active:
             raise Exception("User not allowed to login")
         t = time.strftime("%Y-%m-%d %H:%M:%S")
         user.write({"lastlog": t})
         profile = user.profile_id
         action = profile.home_action or "account_board"
         token = new_token(db_name, user_id)
         db = database.get_connection()
         res = db.get("SELECT * FROM pg_class WHERE relname='settings'")
         settings = get_model("settings").browse(1)
         version = settings.version
         mod_version = get_module_version()
         if version != mod_version:
             raise Exception("Database version (%s) is different than modules version (%s), please upgrade database before login." % (
                 version, mod_version))
         company_id = user.company_id.id or profile.login_company_id.id
         if not company_id:
             res = get_model("company").search([["parent_id", "=", None]])
             if not res:
                 raise Exception("No company found")
             company_id = res[0]
         comp = get_model("company").browse(company_id)
         return {
             "cookies": {
                 "dbname": database.get_active_db(),
                 "user_id": user_id,
                 "token": token,
                 "user_name": user.name,
                 "package": settings.package,
                 "company_id": company_id,
                 "company_name": comp.name,
             },
             "next": {
                 "type": "url",
                 "url": "/ui#name=%s" % action,
             },
             "login_action": action,
         }
     finally:
         set_active_user(user_id)
         audit_log("Login")
Example #4
0
    def post(self):
        try:
            db = get_connection()
            print("########################################")
            print("###########Result Paypal Ipn############")
            print("########################################")

            payment_status = self.get_argument("payment_status", None)
            if payment_status != "Completed":
                raise Exception("Paypal transaction is not completed")
            invoice = self.get_argument("invoice")

            set_active_user(1)
            set_active_company(1)
            res = get_model("ecom.cart").search([["number", "=", invoice]])
            if not res:
                raise Exception("Invalid cart number: %s"%invoice)
            cart_id = res[0]
            cart=get_model("ecom.cart").browse(cart_id)
            website=cart.website_id
            receiver_email = self.get_argument("receiver_email", None)
            if receiver_email != website.paypal_user:
                raise Exception("Wrong paypal receiver email")

            if not website.paypal_user:
                raise Exception("Missing paypal user in cms setting")
            if not website.paypal_password:
                raise Exception("Missing paypal password in cms setting")
            if not website.paypal_signature:
                raise Exception("Missing paypal signature in cms setting")
            if not website.paypal_url:
                raise Exception("Missing paypal URL Server in cms setting")
            params = {}
            for argument in self.request.arguments:
                params[argument] = argument[0].decode('utf-8')
            params['cmd'] = '_notify-validate'
            if website.paypal_url == "test":
                url = "https://www.sandbox.paypal.com/cgi-bin/webscr"
            else:
                url = "https://www.paypal.com/cgi-bin/webscr"
            data = urllib.parse.urlencode(params)
            data = data.encode('utf-8')
            req = urllib.request.Request(url, data)
            response = urllib.request.urlopen(req)
            word = response.read()
            verify = word.decode('utf-8')
            if verify != "VERIFIED":
                raise Exception("Failed to verify payment")
            mc_gross = float(self.get_argument("mc_gross", None))
            if cart.amount_total != mc_gross:
                raise Exception("Amount total doesn't match")
            cart.import_paypal_payment()  # TODO Add Token
            print("Payment Created")
            db.commit()
        except Exception as e:
            db = get_connection()
            db.rollback
            import traceback
            audit_log("Failed to get IPN from paypal", details=traceback.format_exc())
            traceback.print_exc()
Example #5
0
 def post(self):
     db = get_connection()
     try:
         try:
             fields = ["old_password", "new_password", "re_password"]
             field_errors = {}
             form_vals = {}
             for n in fields:
                 v = self.get_argument(n, None)
                 form_vals[n] = v
                 if not v:
                     field_errors[n] = True
             if field_errors:
                 raise Exception("Some required fields are missing")
             user_id = get_active_user()
             if not user_id:
                 raise Exception("No user")
             user = get_model("base.user").browse(user_id)
             user_id = get_model("base.user").check_password(
                 user.email, form_vals["old_password"])
             if not user_id:
                 raise Exception("Wrong password")
             if len(form_vals["new_password"]) < 6:
                 raise Exception(
                     "New password must be more than 6 character")
             if form_vals["new_password"] != form_vals["re_password"]:
                 raise Exception(
                     "New password does not match confirmed password")
             get_model("base.user").write(
                 [user_id], {"password": form_vals["new_password"]})
             get_model("base.user").trigger(
                 [user_id],
                 "change_password",
                 context={"new_password": form_vals["new_password"]})
             self.redirect(
                 "/cms_account?message=Your%20password%20has%20been%20changed"
             )
             db.commit()
         except Exception as e:
             db = get_connection()
             error_message = str(e)
             ctx = self.context
             ctx["form_vals"] = form_vals
             ctx["error_message"] = error_message
             ctx["field_errors"] = field_errors
             content = render("cms_change_pass", ctx)
             ctx["content"] = content
             html = render("cms_layout", ctx)
             self.write(html)
             db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #6
0
    def check_payment_online(self, ids, context={}):
        obj = self.browse(ids)[0]
        date = time.strftime('%Y%m%d%H%M%S')
        qs = urllib.parse.urlencode([
            ('mid', 1000006741),
            ('terminal', 524114384),
            ('command', 'CRINQ'),
            ('ref_no', obj.number),
            ('ref_date', date),
            ('service_id', 10),
            ('cur_abbr', 'THB'),
            ('amount', obj.amount_total),
        ])

        url = 'https://nsips-test.scb.co.th:443/NSIPSWeb/NsipsMessageAction.do?'
        data = qs.encode('utf-8')
        req = urllib.request.Request(url, data)
        response = urllib.request.urlopen(req)
        ur = response.read()
        te = ur.decode('utf-8')
        p = urllib.parse.parse_qsl(te)
        params = dict(list(map(lambda x: (x[0], x[1]), p)))
        payment_status = params['payment_status'] or ''
        amount = params['amount'] or ''
        trans_no = params['trans_no'] or ''
        if payment_status == "002":
            try:
                db = get_connection()
                vals = {
                    "type": "in",
                    "pay_type": "invoice",
                    "contact_id": obj.contact_id.id,
                    "date": time.strftime("%Y-%m-%d"),
                    "ref": trans_no,
                    "account_id": obj.account_id.id,
                    "currency_id": obj.currency_id.id,
                    "lines": [("create", {
                        "type": "invoice",
                        "invoice_id": obj.id,
                        "account_id": obj.account_id.id,
                        "amount": amount,
                    })]
                }
                pmt_id = get_model("account.payment").create(vals, context={"type": vals["type"]})
                get_model("account.payment").post([pmt_id])
                db.commit()
            except Exception as e:
                db = get_connection()
                db.rollback
                import traceback
                audit_log("Failed to get result payment from scb", details=traceback.format_exc())
                traceback.print_exc()
Example #7
0
 def post(self):
     db = get_connection()
     try:
         try:
             print("CHECK protocol XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
             print(self.request.protocol)
             print("CHECK protocol XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
             fields = ["email", "password"]
             field_errors = {}
             form_vals = {}
             for n in fields:
                 v = self.get_argument(n, None)
                 form_vals[n] = v
                 if not v:
                     field_errors[n] = True
             if field_errors:
                 raise Exception("Some required fields are missing")
             user_id = get_model("base.user").check_password(
                 form_vals["email"], form_vals["password"])
             if not user_id:
                 raise Exception("Invalid login")
             set_active_user(user_id)
             dbname = get_active_db()
             token = new_token(dbname, user_id)
             self.set_cookie("user_id", str(user_id))
             self.set_cookie("token", token)
             cart_id = self.get_cookie("cart_id")
             if cart_id:
                 cart_id = int(cart_id)
                 get_model("ecom.cart").set_default_address([cart_id])
             db.commit()
             url = self.get_argument("return_url", None)
             if not url:
                 url = "/cms_account"
             self.redirect(url)
         except Exception as e:
             db = get_connection()
             error_message = str(e)
             ctx = self.context
             ctx["form_vals"] = form_vals
             ctx["error_message"] = error_message
             ctx["field_errors"] = field_errors
             content = render("cms_login", ctx)
             ctx["content"] = content
             html = render("cms_layout", ctx)
             self.write(html)
             db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #8
0
 def post(self):
     db=get_connection()
     try:
         try:
             print("CHECK protocol XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
             print(self.request.protocol)
             print("CHECK protocol XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
             fields=["email","password"]
             field_errors={}
             form_vals={}
             for n in fields:
                 v=self.get_argument(n,None)
                 form_vals[n]=v
                 if not v:
                     field_errors[n]=True
             if field_errors:
                 raise Exception("Some required fields are missing")
             user_id=get_model("base.user").check_password(form_vals["email"],form_vals["password"])
             if not user_id:
                 raise Exception("Invalid login")
             set_active_user(user_id)
             dbname=get_active_db()
             token=new_token(dbname,user_id)
             self.set_cookie("user_id",str(user_id))
             self.set_cookie("token",token)
             cart_id=self.get_cookie("cart_id")
             if cart_id:
                 cart_id=int(cart_id)
                 get_model("ecom.cart").set_default_address([cart_id])
             db.commit()
             url=self.get_argument("return_url",None)
             if not url:
                 url="/cms_account"
             self.redirect(url)
         except Exception as e:
             db=get_connection()
             error_message=str(e)
             ctx=self.context
             ctx["form_vals"]=form_vals
             ctx["error_message"]=error_message
             ctx["field_errors"]=field_errors
             content=render("cms_login",ctx)
             ctx["content"]=content
             html=render("cms_layout",ctx)
             self.write(html)
             db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #9
0
 def money_out(self, context={}):
     company_id = get_active_company()
     company_ids = get_model("company").search([["id", "child_of", company_id]])
     db = get_connection()
     res = db.query(
         "SELECT COALESCE(l.due_date,l.move_date) AS due_date,SUM(l.credit-l.debit) as amount FROM account_move_line l JOIN account_account a ON a.id=l.account_id LEFT JOIN account_reconcile r ON r.id=l.reconcile_id WHERE l.move_state='posted' AND a.type='payable' AND l.reconcile_id IS NULL AND a.company_id IN %s GROUP BY COALESCE(l.due_date,l.move_date)",
         tuple(company_ids),
     )
     amounts = {}
     for r in res:
         amounts[r.due_date] = r.amount
     values = []
     d0 = date.today()
     d1 = d0 + timedelta(days=60)
     d = d0
     while d < d1:
         ds = d.strftime("%Y-%m-%d")
         values.append((js_time(d), amounts.get(ds, 0)))
         d += timedelta(days=1)
     data = {"value": [{"key": "Payable", "values": values}]}
     res = db.get(
         "SELECT count(*) AS count,SUM(amount_total_cur) AS amount FROM account_invoice WHERE type='in' AND inv_type='invoice' AND state='draft' AND company_id IN %s",
         tuple(company_ids),
     )
     if res:
         data["draft_count"] = res.count
         data["draft_amount"] = res.amount
     res = db.get(
         "SELECT count(*) AS count,SUM(amount_total_cur) AS amount FROM account_invoice WHERE type='in' AND inv_type='invoice' AND state='waiting_payment' AND due_date<now() AND company_id IN %s",
         tuple(company_ids),
     )
     if res:
         data["overdue_count"] = res.count
         data["overdue_amount"] = res.amount
     return data
Example #10
0
 def get_report_data(self, ids, context={}):
     company_id = get_active_company()
     comp = get_model("company").browse(company_id)
     if ids:
         params = self.read(ids, load_m2o=False)[0]
     else:
         params = self.default_get(load_m2o=False, context=context)
     settings = get_model("settings").browse(1)
     if not params.get("account_id"):
         return
     account_id = int(params.get("account_id"))
     date_from = params.get("date_from")
     date_to = params.get("date_to")
     if not date_from and not date_to:
         date_from = date.today().strftime("%Y-%m-01")
         date_to = (date.today() + relativedelta(day=31)).strftime("%Y-%m-%d")
     acc = get_model("account.account").browse(account_id, context={"date_to": date_to})
     acc_balance = acc.balance
     acc_unrec = get_model("account.account").browse(
         account_id, context={"date_to": date_to, "bank_rec_state": "not_reconciled"})
     unrec_paid_amt = acc_unrec.credit
     unrec_received_amt = acc_unrec.debit
     rec_paid = []
     condition = [["account_id", "=", account_id], ["move_id.state", "=", "posted"], ["move_id.date", ">=", date_from], [
         "move_id.date", "<=", date_to], ["state", "=", "reconciled"], ["credit", ">", 0]]
     for line in get_model("account.move.line").search_browse(condition, order="move_id.date,id"):
         vals = {
             "date": line.move_id.date,
             "description": line.description,
             "ref": line.move_id.number,
             "amount": line.credit - line.debit,
         }
         rec_paid.append(vals)
     rec_received = []
     condition = [["account_id", "=", account_id], ["move_id.state", "=", "posted"], ["move_id.date", ">=", date_from], [
         "move_id.date", "<=", date_to], ["state", "=", "reconciled"], ["debit", ">", 0]]
     for line in get_model("account.move.line").search_browse(condition, order="move_id.date,id"):
         vals = {
             "date": line.move_id.date,
             "description": line.description,
             "ref": line.move_id.number,
             "amount": line.debit - line.credit,
         }
         rec_received.append(vals)
     db = database.get_connection()
     data = {
         "company_name": comp.name,
         "date_from": date_from,
         "date_to": date_to,
         "account_name": acc.name,
         "rec_paid": rec_paid,
         "total_rec_paid": sum([l["amount"] for l in rec_paid]),
         "rec_received": rec_received,
         "total_rec_received": sum([l["amount"] for l in rec_received]),
         "acc_balance": acc_balance,
         "unrec_paid_amt": unrec_paid_amt,
         "unrec_received_amt": unrec_received_amt,
         "st_balance": acc_balance + unrec_paid_amt - unrec_received_amt,
     }
     return data
 def get(self):
     db = get_connection()
     try:
         cart_id = int(self.get_argument("cart_id"))
         print("cart_id", cart_id)
         cart = get_model("ecom.cart").browse(cart_id)
         set_active_company(1)
         user_id = get_active_user()
         website = self.context["website"]
         ctx = self.context
         ctx["cart"] = cart
         if not cart.is_paid and website.payment_slip_template_id and (cart.pay_method_id.id == website.bank_method_id.id):
             tmpl_name = website.payment_slip_template_id.name
             url = "/report?type=report_jasper&model=ecom.cart&convert=pdf&ids=[%d]&template=%s" % (
                 cart.id, tmpl_name)
             ctx["payment_slip_report_url"] = url
         content = render("ecom_order_confirmed", ctx)
         ctx["content"] = content
         html = render("cms_layout", ctx)
         self.write(html)
         db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
 def get_report_data(self, ids, context={}):
     if ids:
         params = self.read(ids, load_m2o=False)[0]
     else:
         params = self.default_get(load_m2o=False, context=context)
     company_id = get_active_company()
     comp = get_model("company").browse(company_id)
     settings = get_model("settings").browse(1)
     date_from = params.get("date_from")
     date_to = params.get("date_to")
     if not date_from:
         date_from = date.today().strftime("%Y-%m-01")
     if not date_to:
         date_to = (date.today() + relativedelta(day=31)).strftime("%Y-%m-%d")
     data = {
         "company_name": comp.name,
         "date_from": date_from,
         "date_to": date_to,
         "total_qty": 0,
         "total_amount": 0,
     }
     db = get_connection()
     res = db.query(
         "SELECT l.product_id,p.name AS product_name,p.sale_price AS product_price,SUM(l.amount) AS amount,SUM(l.qty) AS qty FROM account_invoice_line l,account_invoice i,product p WHERE i.id=l.invoice_id AND p.id=l.product_id AND i.date>=%s AND i.date<=%s GROUP BY l.product_id,p.name,p.sale_price ORDER BY p.name", date_from, date_to)
     lines = []
     for r in res:
         line = r
         line["avg_price"] = line["amount"] / line["qty"] if line["qty"] else None
         lines.append(line)
         data["total_qty"] += line["qty"]
         data["total_amount"] += line["amount"]
     data["lines"] = lines
     data["total_avg_price"] = data["total_amount"] / data["total_qty"] if data["total_qty"] else None
     pprint(data)
     return data
Example #13
0
 def post(self):
     db = get_connection()
     try:
         data_json = self.get_argument("json_str", None)
         if not data_json:
             raise Exception("Can't get json_str")
         data = json.loads(data_json)
         cart_id = self.get_cookie("cart_id", None)
         if not cart_id:
             raise Exception("Can't get cart id")
         cart_id = int(cart_id)
         cart = get_model("ecom.cart").browse(cart_id)
         order = 0
         for line in cart.lines:
             for item in data:
                 if item.get('order') == order:
                     line.write({"ship_method_id": item.get('method_id')})
             order += 1
         cart.calc_shipping()
         amount_ship = "{:0,.2f}".format(float(cart.amount_ship))
         amount_total = "{:0,.2f}".format(float(cart.amount_total))
         total = {
             "amount_ship": amount_ship,
             "amount_total": amount_total,
         }
         data = json.dumps(total)
         self.write(data)
         db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #14
0
 def get(self):
     raise Exception("Polling is disabled") # XXX
     #print("ListenPoll.get",os.getpid())
     global sending_notifs
     t=time.strftime("%Y-%m-%d %H:%M:%S")
     dbname=get_active_db()
     if not dbname:
         raise Exception("Missing dbname in long poll request")
     db=None
     try:
         db=get_connection()
         user_id=self.get_cookie("user_id",None)
         if user_id:
             user_id=int(user_id)
         res=db.get("INSERT INTO ws_listener (user_id,last_check_time) VALUES (%s,%s) RETURNING id",user_id,t)
         self.listener_id=res.id
         self.dbname=dbname
         listen_handlers[self.listener_id]=self
         if not sending_notifs:
             io_loop=tornado.ioloop.IOLoop.instance()
             io_loop.add_timeout(time.time()+POLL_WAIT,send_notifs) # XXX: should start this directly when process is started?
             sending_notifs=True
         db.commit()
     except:
         print("#########################################################")
         print("ERROR: ListenPoll.get failed")
         if db:
             db.rollback()
         import traceback
         traceback.print_exc()
Example #15
0
 def get(self):
     db = get_connection()
     try:
         user_id = self.get_cookie("user_id", None)
         if user_id:
             user_id = int(user_id)
             user = get_model("base.user").browse(user_id)
             ctx = self.context
             ctx["coupons_available"] = get_model(
                 "sale.coupon").search_browse(
                     [["contact_id", "=", user.contact_id.id],
                      ["state", "=", "available"]])
             ctx["coupons_in_use"] = get_model("sale.coupon").search_browse(
                 [["contact_id", "=", user.contact_id.id],
                  ["state", "=", "in_use"]])
             ctx["coupons_used"] = get_model("sale.coupon").search_browse(
                 [["contact_id", "=", user.contact_id.id],
                  ["state", "=", "used"]])
             ctx["coupons_expired"] = get_model(
                 "sale.coupon").search_browse(
                     [["contact_id", "=", user.contact_id.id],
                      ["state", "=", "expired"]])
             content = render("ecom_coupons", ctx)
             ctx["content"] = content
             html = render("cms_layout", ctx)
             self.write(html)
         else:
             self.redirect("cms_login")
         db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #16
0
    def post(self):
        db = get_connection()
        try:
            user_id = self.get_cookie("user_id", None)
            product_id = self.get_argument("product_id")
            if user_id:
                user_id = int(user_id)
                user = get_model("base.user").browse(user_id)
                if not user.contact_id:
                    raise Exception("Cannot find contact with user_id: ", user_id)
                vals = {
                    "contact_id": user.contact_id.id,
                    "product_id": product_id,
                    "date": time.strftime("%Y-%m-%d %H:%M:%S"),
                }
                res = db.query(
                    "SELECT COUNT(*) FROM ecom_wishlist WHERE contact_id = %s AND product_id = %s"
                    % (user.contact_id.id, product_id)
                )
                res = res[0]["count"] or 0
                if res == 0:
                    get_model("ecom.wishlist").create(vals)
                    db.commit()
        except:
            import traceback

            traceback.print_exc()
            db.rollback()
Example #17
0
 def get(self):
     db = get_connection()
     try:
         ctx = self.context
         brand_id=self.get_argument("brand_id",None)
         if brand_id:
             brand_id = int(brand_id)
         else:
             brand_code=self.get_argument("brand_code",None)
             res=get_model("product.brand").search([["code","=",brand_code]])
             if not res:
                 raise Exception("Product brand not found: '%s'"%brand_code)
             brand_id=res[0]
         res = get_model("product.brand").browse([brand_id])
         if not res:
             raise Exception("Can't find product brand id: ",brand_id)
         brand = res[0]
         ctx["product_brand"] = brand
         ctx["parent_brand_list"] = list_brand_parent(brand, brand_list=[])
         content = render("ecom_product_brand", ctx)
         ctx["content"] = content
         html = render("cms_layout", ctx)
         self.write(html)
         db.commit()
     except:
         self.redirect("/cms_page_not_found")
         import traceback
         traceback.print_exc()
         db.rollback()
Example #18
0
 def round(self, cur_id, amt, scale=2):
     db = database.get_connection()
     if not amt:
         return 0
     amt = Decimal(
         db.query('select round(%s,%s) as out' % (amt, scale))[0]['out'])
     return amt
Example #19
0
 def get(self):
     self.get_argument("token") # TODO: check token
     dbname=database.get_active_db()
     db=database.get_connection()
     try:
         db.begin()
         set_active_user(None)
         user_id=1
         user=get_model("base.user").browse(user_id)
         t=time.strftime("%Y-%m-%d %H:%M:%S")
         user.write({"lastlog":t})
         comp=get_model("company").browse(1)
         set_active_user(user_id)
         audit_log("Login token")
         url="http://nf1.netforce.com/update_lastlogin?dbname=%s"%dbname
         req=urllib.request.Request(url)
         try:
             urllib.request.urlopen(req).read()
         except:
             print("ERROR: failed to update last login time")
         token=new_token(dbname,user_id)
         self.set_cookie("dbname",dbname)
         self.set_cookie("user_id",str(user_id))
         self.set_cookie("token",token)
         self.set_cookie("user_name",quote(user.name)) # XXX: space
         self.set_cookie("company_name",quote(comp.name))
         self.set_cookie("package",comp.package)
         self.redirect("http://%s.my.netforce.com/action#name=account_board"%dbname.replace("_","-"))
         db.commit()
     except:
         db.rollback()
Example #20
0
 def post(self):
     db = database.get_connection()
     data = {}
     try:
         data["barcode"] = self.get_argument("barcode", None)
         data["qty"] = self.get_argument("qty", None)
         barcode = data["barcode"]
         if not barcode:
             raise Exception("Missing barcode!")
         barcode = int(barcode)
         qty = data["qty"]
         if not qty:
             raise Exception("Missing qty!")
         qty = int(qty)
         res = get_model("production.component").search(
             [["id", "=", barcode]])
         if not res:
             raise Exception("Invalid barcode")
         comp_id = res[0]
         # TODO: create goods issue for that component
         db.commit()
         self.redirect("/issue_rm")
     except Exception as e:
         data["error"] = "ERROR: %s" % e
         html = template.render("issue_rm", data)
         self.write(html)
         db.rollback()
         import traceback
         traceback.print_exc()
Example #21
0
 def get(self):
     db = get_connection()
     try:
         country_id = self.get_argument("country_id")
         print(country_id)
         country = get_model("country").browse(int(country_id))
         if not country:
             raise Exception("Country not found")
         provinces = []
         for province in country.provinces:
             vals = {
                 'name': province.name,
                 'id': province.id,
                 'code': province.code,
             }
             provinces.append(vals)
         provinces = sorted(provinces, key=lambda k: k['name'])
         print(provinces)
         data = json.dumps(provinces)
         self.write(data)
         db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #22
0
def send_notifs():
    #print("send_notifs",os.getpid(),list(listen_handlers.keys()))
    t=time.strftime("%Y-%m-%d %H:%M:%S")
    db_handlers={}
    for listener_id,h in listen_handlers.items(): # XXX
        db_handlers.setdefault(h.dbname,[]).append(listener_id)
    for dbname,listener_ids in db_handlers.items():
        set_active_db(dbname)
        db=get_connection()
        try:
            ids_sql="("+",".join(str(x) for x in listener_ids)+")"
            res=db.query("SELECT listener_id,name FROM ws_event WHERE listener_id IN "+ids_sql)
            if res:
                handler_events={}
                for r in res:
                    handler_events.setdefault(r.listener_id,[]).append(r.name)
                for listener_id,events in handler_events.items():
                    print("NOTIFY %s %s %s"%(dbname,listener_id,events))
                    handler=listen_handlers[listener_id]
                    handler.write(json.dumps(events))
                    handler.finish()
                    del listen_handlers[listener_id]
                db.execute("DELETE FROM ws_event WHERE listener_id IN "+ids_sql)
            db.execute("UPDATE ws_listener SET last_check_time=%s WHERE id IN "+ids_sql,t) # XXX: do this less often
            db.execute("DELETE FROM ws_listener WHERE last_check_time<TIMESTAMP %s-INTERVAL '10 seconds'",t) # XXX: do this less often, FIXME
            db.commit()
        except:
            print("#########################################################")
            print("ERROR: send_notifs failed")
            db.rollback()
            import traceback
            traceback.print_exc()
    io_loop=tornado.ioloop.IOLoop.instance()
    io_loop.add_timeout(time.time()+POLL_WAIT,send_notifs)
Example #23
0
 def get(self):
     db = get_connection()
     try:
         ctx = self.context
         edit_form_vals = {}
         for addr in ctx["customer"].addresses:
             edit_form_vals[addr.id] = {
                 "first_name": addr.first_name,
                 "last_name": addr.last_name,
                 "company": addr.company,
                 "address": addr.address,
                 "address2": addr.address2,
                 "province": addr.province,
                 "province_id": addr.province_id.id,
                 "district_id": addr.district_id.id,
                 "subdistrict_id": addr.subdistrict_id.id,
                 "postal_code": addr.postal_code,
                 "country": addr.country_id.name,
                 "phone": addr.phone,
             }
         ctx["edit_form_vals"] = edit_form_vals
         content = render("ecom_addresses", ctx)
         ctx["content"] = content
         html = render("cms_layout", ctx)
         self.write(html)
         db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #24
0
 def migrate(self):
     res = get_model("stock.journal").search([])
     if res:
         print("Stock journals already created")
         return
     vals = {
         "name": "Goods Receipts",
         "type": "in",
     }
     in_id = get_model("stock.journal").create(vals)
     vals = {
         "name": "Goods Transfers",
         "type": "internal",
     }
     internal_id = get_model("stock.journal").create(vals)
     vals = {
         "name": "Goods Issues",
         "type": "out",
     }
     out_id = get_model("stock.journal").create(vals)
     db = get_connection()
     db.execute("UPDATE stock_picking SET journal_id=%s WHERE type='in'",
                in_id)
     db.execute(
         "UPDATE stock_picking SET journal_id=%s WHERE type='internal'",
         internal_id)
     db.execute("UPDATE stock_picking SET journal_id=%s WHERE type='out'",
                out_id)
Example #25
0
 def get(self):
     db = get_connection()
     try:
         ctx = self.context
         seller_id = int(self.get_argument("seller_id"))
         comp = get_model("company").browse(seller_id)
         #products=get_model("product").search_browse([["company_id","=",seller_id]])
         res = get_model("product.group").search_browse([["code","=","seller_new"],["company_id","=",seller_id]])
         if not res:
             raise Exception("No product group code 'seller_new' in company: ",comp.name)
         new_product_group = res[0]
         res = get_model("product.group").search_browse([["code","=","seller_rec"],["company_id","=",seller_id]])
         if not res:
             raise Exception("No product group code 'seller_new' in company: ",comp.name)
         rec_product_group = res[0]
         ctx["seller"]={
             "name": comp.name,
             "new_product_group": new_product_group,
             "rec_product_group": rec_product_group,
         }
         content = render("ecom_seller", ctx)
         ctx["content"] = content
         html = render("cms_layout", ctx)
         self.write(html)
         db.commit()
     except:
         self.redirect("/cms_page_not_found")
         import traceback
         traceback.print_exc()
         db.rollback()
Example #26
0
    def get(self):
        db = get_connection()
        try:
            ctx = self.context
            page_code = self.get_argument("page")
            res = get_model("cms.page").search([["code", "=", page_code]])
            if not res:
                self.redirect("/cms_page_not_found")
                return
            page_id = res[0]
            page = get_model("cms.page").browse(page_id)
            if page.state == "inactive":
                self.redirect("/cms_page_not_found")
                return
            ctx["page"] = page
            tmpl_name = page.template or "cms_page"
            content = render(tmpl_name, ctx)
            ctx["content"] = content
            html = render("cms_layout", ctx)
            self.write(html)
            db.commit()
        except:
            import traceback

            traceback.print_exc()
            db.rollback()
Example #27
0
 def get(self):
     db = get_connection()
     try:
         ctx = self.context
         edit_form_vals = {}
         for addr in ctx["customer"].addresses:
             edit_form_vals[addr.id] = {
                 "first_name": addr.first_name,
                 "last_name": addr.last_name,
                 "company": addr.company,
                 "address": addr.address,
                 "address2": addr.address2,
                 "province": addr.province,
                 "province_id": addr.province_id.id,
                 "district_id": addr.district_id.id,
                 "subdistrict_id": addr.subdistrict_id.id,
                 "postal_code": addr.postal_code,
                 "country": addr.country_id.name,
                 "phone": addr.phone,
             }
         ctx["edit_form_vals"] = edit_form_vals
         content = render("ecom_addresses", ctx)
         ctx["content"] = content
         html = render("cms_layout", ctx)
         self.write(html)
         db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
 def get_balance_90d(self, ids, context={}, nocache=False):
     if not nocache:
         min_ctime = time.strftime("%Y-%m-%d 00:00:00")
         vals = get_model("field.cache").get_value("account.account", "balance_90d", ids, min_ctime=min_ctime)
         remain_ids = [id for id in ids if id not in vals]
         if remain_ids:
             res = self.get_balance_90d(remain_ids, context=context, nocache=True)
             for id, data in res.items():
                 vals[id] = data
                 get_model("field.cache").set_value("account.account", "balance_90d", id, data)
         return vals
     print("#########################################################################")
     print("get_balance_90d CACHE MISS", ids)
     date_from = datetime.date.today() - datetime.timedelta(days=90)
     date_to = datetime.date.today()
     db = database.get_connection()
     vals = {}
     for id in ids:
         balance = self.get_balance([id], context={"date_to": date_from.strftime("%Y-%m-%d")})[id]["balance"]
         q = "SELECT move_date,debit,credit FROM account_move_line WHERE account_id=%s AND move_date>%s AND move_date<=%s AND move_state='posted' ORDER BY move_date"
         res = db.query(q, id, date_from, date_to)
         d = date_from
         data = []
         for r in res:
             while d.strftime("%Y-%m-%d") < r["move_date"]:
                 data.append([time.mktime(d.timetuple()) * 1000, balance])
                 d += datetime.timedelta(days=1)
             balance += (r["debit"] or 0) - (r["credit"] or 0)
         while d <= date_to:
             data.append([time.mktime(d.timetuple()) * 1000, balance])
             d += datetime.timedelta(days=1)
         vals[id] = data
     return vals
Example #29
0
 def post(self):
     db = get_connection()
     try:
         user_id = self.get_cookie("user_id", None)
         product_id = self.get_argument("product_id")
         if user_id:
             user_id = int(user_id)
             user = get_model("base.user").browse(user_id)
             if not user.contact_id:
                 raise Exception("Cannot find contact with user_id: ",
                                 user_id)
             vals = {
                 "contact_id": user.contact_id.id,
                 "product_id": product_id,
                 "date": time.strftime("%Y-%m-%d %H:%M:%S"),
             }
             res = db.query(
                 "SELECT COUNT(*) FROM ecom_wishlist WHERE contact_id = %s AND product_id = %s"
                 % (user.contact_id.id, product_id))
             res = res[0]['count'] or 0
             if res == 0:
                 get_model("ecom.wishlist").create(vals)
                 db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #30
0
def init_db():
    db = database.get_connection()
    db.execute("INSERT INTO settings (id) VALUES (1)")
    enc_pass=encrypt_password('1234')
    db.execute("INSERT INTO profile (id,name) VALUES (1,'System Admin')")
    db.execute("INSERT INTO base_user (id,login,password,name,profile_id,active) VALUES (1,'admin',%s,'Admin',1,true)",enc_pass)
    db.execute("INSERT INTO company (id,name) VALUES (1,'Test Company')")
Example #31
0
 def get(self):
     db = get_connection()
     try:
         country_id = self.get_argument("country_id")
         print(country_id)
         country = get_model("country").browse(int(country_id))
         if not country:
             raise Exception("Country not found")
         provinces = []
         for province in country.provinces:
             vals = {
                 'name': province.name,
                 'id': province.id,
                 'code': province.code,
             }
             provinces.append(vals)
         provinces = sorted(provinces, key=lambda k: k['name'])
         print(provinces)
         data = json.dumps(provinces)
         self.write(data)
         db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #32
0
 def get_report_data(self, ids, context={}):
     company_id = get_active_company()
     company_ids = get_model("company").search([["id", "child_of", company_id]])
     comp = get_model("company").browse(company_id)
     if ids:
         params = self.read(ids, load_m2o=False)[0]
     else:
         params = self.default_get(load_m2o=False, context=context)
     settings = get_model("settings").browse(1)
     date_from = params.get("date_from")
     if not date_from:
         date_from = date.today().strftime("%Y-%m-01")
     date_to = params.get("date_to")
     if not date_to:
         date_to = (date.today() + relativedelta(day=31)).strftime("%Y-%m-%d")
     data = {
         "company_name": comp.name,
         "date_from": date_from,
         "date_to": date_to,
         "by_rate": params.get("by_rate"),
         "by_comp": params.get("by_comp"),
     }
     db = database.get_connection()
     if params.get("by_comp"):
         res = db.query("SELECT c.id AS comp_id,c.name AS comp_name,c.rate AS comp_rate,r.name AS rate_name,SUM(l.credit-l.debit) AS tax_total,SUM(l.tax_base*sign(l.credit-l.debit)) AS base_total FROM account_move_line l,account_move m,account_tax_component c,account_tax_rate r WHERE m.id=l.move_id AND m.state='posted' AND m.date>=%s AND m.date<=%s AND c.id=l.tax_comp_id AND r.id=c.tax_rate_id AND m.company_id IN %s GROUP BY comp_id,comp_name,comp_rate,rate_name ORDER BY comp_name,rate_name",
                        date_from, date_to, tuple(company_ids))
         data["comp_taxes"] = [dict(r) for r in res]
     if params.get("by_rate"):
         res = db.query("SELECT c.id AS comp_id,c.name AS comp_name,c.rate AS comp_rate,r.name AS rate_name,SUM(l.credit-l.debit) AS tax_total,SUM(l.tax_base*sign(l.credit-l.debit)) AS base_total FROM account_move_line l,account_move m,account_tax_component c,account_tax_rate r WHERE m.id=l.move_id AND m.state='posted' AND m.date>=%s AND m.date<=%s AND c.id=l.tax_comp_id AND r.id=c.tax_rate_id AND m.company_id IN %s GROUP BY comp_id,comp_name,comp_rate,rate_name ORDER BY rate_name,comp_name",
                        date_from, date_to, tuple(company_ids))
         data["rate_taxes"] = [dict(r) for r in res]
     return data
Example #33
0
 def post(self):
     print("POST ARGUMENT >>>>>>>>>>>>>>>>>>>")
     print(self.request.body)
     f = open("paypal_return", "a")
     s = "################################################################################################################" + \
         "\n"
     s += "Date : " + time.strftime("%Y-%m-%d %H:%M:%S") + "\n"
     s += "Request : " + str(self.request) + "\n"
     if self.request.body:
         s += "Body : " + str(self.request.body) + "\n"
     s += "################################################################################################################" + \
         "\n"
     f.write(s)
     f.close()
     cart_id = int(self.get_argument("cart_id"))
     token = self.get_argument("token", None)
     payer_id = self.get_argument("PayerID", None)
     cart = get_model("ecom.cart").browse(cart_id)
     if not cart.is_paid:
         access.set_active_user(1)
         access.set_active_company(1)
         cart.import_paypal_payment(token, context={})
         db = database.get_connection()
         db.commit()
     self.redirect("/ecom_order_confirmed?cart_id=%s" % cart_id)
Example #34
0
    def get(self):
        db = get_connection()
        try:
            ctx = self.context
            brand_id = self.get_argument("brand_id", None)
            if brand_id:
                brand_id = int(brand_id)
            else:
                brand_code = self.get_argument("brand_code", None)
                res = get_model("product.brand").search([["code", "=", brand_code]])
                if not res:
                    raise Exception("Product brand not found: '%s'" % brand_code)
                brand_id = res[0]
            res = get_model("product.brand").browse([brand_id])
            if not res:
                raise Exception("Can't find product brand id: ", brand_id)
            brand = res[0]
            ctx["product_brand"] = brand
            ctx["parent_brand_list"] = list_brand_parent(brand, brand_list=[])
            content = render("ecom_product_brand", ctx)
            ctx["content"] = content
            html = render("cms_layout", ctx)
            self.write(html)
            db.commit()
        except:
            self.redirect("/cms_page_not_found")
            import traceback

            traceback.print_exc()
            db.rollback()
Example #35
0
 def post(self):
     db=get_connection()
     try:
         ctx=self.context
         coupon_id=int(self.get_argument("coupon_id"))
         action=self.get_argument("action")
         try:
             if action=="use_coupon":
                 coupon=get_model("sale.coupon").browse(coupon_id)
                 coupon.use_coupon()
                 db.commit()
                 self.redirect("/ecom_coupon?coupon_id=%s"%coupon.id)
         except Exception as e:
             ctx["error_message"]=str(e)
             coupon=get_model("sale.coupon").browse(coupon_id)
             ctx["coupon"]=coupon
             content=render("ecom_coupon",ctx)
             ctx["content"]=content
             html=render("cms_layout",ctx)
             self.write(html)
             db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #36
0
 def get(self):
     db = get_connection()
     if db:
         db.begin()
     ctx = {
         "dbname": get_active_db(),
         "locale": netforce.locale.get_active_locale(),
         "css_file": static.get_css_file(),
         "js_file": static.get_js_file(),
     }
     static.check_ui_params_db()
     html = netforce.template.render("action_local", {"context": ctx})
     self.write(html)
     db = get_connection()
     if db:
         db.commit()  # XXX
Example #37
0
    def get_amount(self, ids, context={}):
        all_vals = {}
        db = database.get_connection()
        for obj in self.browse(ids):
            q = "SELECT SUM(opp.amount) AS amount,SUM(opp.qty) AS qty FROM sale_opportunity opp LEFT JOIN product prod ON prod.id=opp.product_id WHERE opp.state='won' AND opp.date_close>=%s AND opp.date_close<=%s"
            a = [obj.date_from, obj.date_to]
            if obj.user_id:
                q += " AND opp.user_id=%s"
                a.append(obj.user_id.id)
            if obj.prod_categ_id:
                q += " AND prod.categ_id=%s"
                a.append(obj.prod_categ_id.id)
            res_won = db.get(q, *a)

            q = "SELECT SUM(opp.amount*opp.probability/100) AS amount,SUM(opp.qty*opp.probability/100) AS qty FROM sale_opportunity opp LEFT JOIN product prod ON prod.id=opp.product_id WHERE opp.state='open' AND opp.date_close>=%s AND opp.date_close<=%s"
            a = [obj.date_from, obj.date_to]
            if obj.user_id:
                q += " AND opp.user_id=%s"
                a.append(obj.user_id.id)
            if obj.prod_categ_id:
                q += " AND prod.categ_id=%s"
                a.append(obj.prod_categ_id.id)
            res_open = db.get(q, *a)

            vals = {
                "amount_actual": res_won.amount or 0,
                "amount_expected": res_open.amount or 0,
                "qty_actual": res_won.qty or 0,
                "qty_expected": res_open.qty or 0,
            }
            all_vals[obj.id] = vals
        return all_vals
Example #38
0
 def get(self):
     db = get_connection()
     try:
         keyword = self.get_argument("keyword")
         domain = [["or",["name","ilike",keyword],["description","ilike",keyword],["code","ilike",keyword]],["parent_id","=",None],["is_published","=",True]]
         result = get_model("product").search_browse(domain)
         #if not result:
             #raise Exception("Product not found")
         products = []
         for product in result:
             vals = {
                 "name": product.name,
                 "id": product.id,
                 "desc": product.description[:20]+"..." if product.description else ""
             }
             products.append(vals)
         products = sorted(products, key=lambda k: k['name'])
         print(products)
         data = json.dumps(products)
         self.write(data)
         db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #39
0
    def get_amount(self, ids, context={}):
        all_vals = {}
        db = database.get_connection()
        for obj in self.browse(ids):
            q = "SELECT SUM(opp.amount) AS amount,SUM(opp.qty) AS qty FROM sale_opportunity opp LEFT JOIN product prod ON prod.id=opp.product_id WHERE opp.state='won' AND opp.date_close>=%s AND opp.date_close<=%s"
            a = [obj.date_from, obj.date_to]
            if obj.user_id:
                q += " AND opp.user_id=%s"
                a.append(obj.user_id.id)
            if obj.prod_categ_id:
                q += " AND prod.categ_id=%s"
                a.append(obj.prod_categ_id.id)
            res_won = db.get(q, *a)

            q = "SELECT SUM(opp.amount*opp.probability/100) AS amount,SUM(opp.qty*opp.probability/100) AS qty FROM sale_opportunity opp LEFT JOIN product prod ON prod.id=opp.product_id WHERE opp.state='open' AND opp.date_close>=%s AND opp.date_close<=%s"
            a = [obj.date_from, obj.date_to]
            if obj.user_id:
                q += " AND opp.user_id=%s"
                a.append(obj.user_id.id)
            if obj.prod_categ_id:
                q += " AND prod.categ_id=%s"
                a.append(obj.prod_categ_id.id)
            res_open = db.get(q, *a)

            vals = {
                "amount_actual": res_won.amount or 0,
                "amount_expected": res_open.amount or 0,
                "qty_actual": res_won.qty or 0,
                "qty_expected": res_open.qty or 0,
            }
            all_vals[obj.id] = vals
        return all_vals
Example #40
0
 def get_attend_hist(self, context={}):
     db = database.get_connection()
     date_from = datetime.date.today() - datetime.timedelta(days=30)
     res = db.query(
         "SELECT user_id,action,time FROM hr_attendance WHERE time>=%s ORDER BY time",
         date_from)
     days = {}
     sign_ins = {}
     for r in res:
         if r.action == "sign_in":
             sign_ins[r.user_id] = r.time
         elif r.action == "sign_out":
             last_in = sign_ins.get(r.user_id)
             if not last_in:
                 continue
             day = r.time[:10]
             if last_in[:10] != day:
                 continue
             t = days.get(day, 0)
             t += (datetime.datetime.strptime(r.time, "%Y-%m-%d %H:%M:%S") -
                   datetime.datetime.strptime(
                       last_in, "%Y-%m-%d %H:%M:%S")).seconds / 3600.0
             days[day] = t
     vals = sorted(days.items())
     return {
         "value": vals,
     }
Example #41
0
 def get(self):
     db = get_connection()
     try:
         cart_id = int(self.get_argument("cart_id"))
         print("cart_id", cart_id)
         cart = get_model("ecom.cart").browse(cart_id)
         set_active_company(1)
         user_id = get_active_user()
         website = self.context["website"]
         ctx = self.context
         ctx["cart"] = cart
         if not cart.is_paid and website.payment_slip_template_id and (
                 cart.pay_method_id.id == website.bank_method_id.id):
             tmpl_name = website.payment_slip_template_id.name
             url = "/report?type=report_jasper&model=ecom.cart&convert=pdf&ids=[%d]&template=%s" % (
                 cart.id, tmpl_name)
             ctx["payment_slip_report_url"] = url
         content = render("ecom_order_confirmed", ctx)
         ctx["content"] = content
         html = render("cms_layout", ctx)
         self.write(html)
         db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #42
0
def send_notifs():
    print("send_notifs", os.getpid(), list(listen_handlers.keys()))
    t = time.strftime("%Y-%m-%d %H:%M:%S")
    db_handlers = {}
    for listener_id, h in listen_handlers.items():  # XXX
        db_handlers.setdefault(h.dbname, []).append(listener_id)
    for dbname, listener_ids in db_handlers.items():
        set_active_db(dbname)
        db = get_connection()
        ids_sql = "(" + ",".join(str(x) for x in listener_ids) + ")"
        res = db.query(
            "SELECT listener_id,name FROM ws_event WHERE listener_id IN " +
            ids_sql)
        if res:
            for r in res:
                print("NOTIFY %s %s %s" % (dbname, r.listener_id, r.name))
                handler = listen_handlers[r.listener_id]
                handler.write_message("NOTIFY %s" % r.name)
            db.execute("DELETE FROM ws_event WHERE listener_id IN " + ids_sql)
        db.execute("UPDATE ws_listener SET last_check_time=%s WHERE id IN " +
                   ids_sql, t)  # XXX: do this less often
        db.execute(
            "DELETE FROM ws_listener WHERE last_check_time<TIMESTAMP %s-INTERVAL '10 seconds'",
            t)  # XXX: do this less often, FIXME
        db.commit()
    io_loop = tornado.ioloop.IOLoop.instance()
    io_loop.add_timeout(time.time() + POLL_WAIT, send_notifs)
Example #43
0
 def open(self):
     print("Listen.open", os.getpid())
     global sending_notifs
     t = time.strftime("%Y-%m-%d %H:%M:%S")
     dbname = config.get("database")
     if not dbname:
         dbname = self.get_cookie("dbname", None)
     if not dbname:
         raise Exception("Can't open websocket, missing dbname")
     set_active_db(dbname)
     db = get_connection()
     user_id = self.get_cookie("user_id", None)
     if user_id:
         user_id = int(user_id)
     res = db.get(
         "INSERT INTO ws_listener (user_id,last_check_time) VALUES (%s,%s) RETURNING id",
         user_id, t)
     self.listener_id = res.id
     self.dbname = dbname
     listen_handlers[self.listener_id] = self
     if not sending_notifs:
         io_loop = tornado.ioloop.IOLoop.instance()
         io_loop.add_timeout(
             time.time() + POLL_WAIT, send_notifs
         )  # XXX: should start this directly when process is started?
         sending_notifs = True
     db.commit()
Example #44
0
 def get(self):
     db = get_connection()
     try:
         ctx = self.context
         categ_id=self.get_argument("categ_id",None)
         if categ_id:
             categ_id = int(categ_id)
         else:
             categ_code=self.get_argument("categ_code",None)
             res=get_model("product.categ").search([["code","=",categ_code]])
             if not res:
                 raise Exception("Product categ not found: '%s'"%categ_code)
             categ_id=res[0]
         res = get_model("product.categ").browse([categ_id])
         if not res:
             raise Exception("Can't find product category id: ",categ_id)
         categ = res[0]
         ctx["product_categ"] = categ
         ctx["parent_categ_list"] = list_categ_parent(categ, categ_list=[])
         content = render("ecom_product_categ", ctx)
         ctx["content"] = content
         html = render("cms_layout", ctx)
         self.write(html)
         db.commit()
     except:
         self.redirect("/cms_page_not_found")
         import traceback
         traceback.print_exc()
         db.rollback()
Example #45
0
 def get_balance_90d(self, ids, context={}, nocache=False):
     if not nocache:
         min_ctime = time.strftime("%Y-%m-%d 00:00:00")
         vals = get_model("field.cache").get_value("account.account", "balance_90d", ids, min_ctime=min_ctime)
         remain_ids = [id for id in ids if id not in vals]
         if remain_ids:
             res = self.get_balance_90d(remain_ids, context=context, nocache=True)
             for id, data in res.items():
                 vals[id] = data
                 get_model("field.cache").set_value("account.account", "balance_90d", id, data)
         return vals
     print("#########################################################################")
     print("get_balance_90d CACHE MISS", ids)
     date_from = datetime.date.today() - datetime.timedelta(days=90)
     date_to = datetime.date.today()
     db = database.get_connection()
     vals = {}
     for id in ids:
         balance = self.get_balance([id], context={"date_to": date_from.strftime("%Y-%m-%d")})[id]["balance"]
         q = "SELECT move_date,debit,credit FROM account_move_line WHERE account_id=%s AND move_date>%s AND move_date<=%s AND move_state='posted' ORDER BY move_date"
         res = db.query(q, id, date_from, date_to)
         d = date_from
         data = []
         for r in res:
             while d.strftime("%Y-%m-%d") < r["move_date"]:
                 data.append([time.mktime(d.timetuple()) * 1000, balance])
                 d += datetime.timedelta(days=1)
             balance += (r["debit"] or 0) - (r["credit"] or 0)
         while d <= date_to:
             data.append([time.mktime(d.timetuple()) * 1000, balance])
             d += datetime.timedelta(days=1)
         vals[id] = data
     return vals
Example #46
0
    def post(self):
        db = database.get_connection()
        data = {}
        try:
            data["barcode"] = self.get_argument("barcode", None)
            data["qty"] = self.get_argument("qty", None)
            barcode = data["barcode"]
            if not barcode:
                raise Exception("Missing barcode!")
            barcode = int(barcode)
            qty = data["qty"]
            if not qty:
                raise Exception("Missing qty!")
            qty = int(qty)
            res = get_model("production.component").search([["id", "=", barcode]])
            if not res:
                raise Exception("Invalid barcode")
            comp_id = res[0]
            # TODO: create goods issue for that component
            db.commit()
            self.redirect("/issue_rm")
        except Exception as e:
            data["error"] = "ERROR: %s" % e
            html = template.render("issue_rm", data)
            self.write(html)
            db.rollback()
            import traceback

            traceback.print_exc()
    def get_balance(self, ids, context={}):
        print("account.track.categ get_balance")
        db = database.get_connection()
        child_ids = self.search([["id", "child_of", ids]])
        print("child_ids", child_ids)
        res = db.query(
            "SELECT track_id,SUM(amount) AS total FROM account_track_entry WHERE track_id IN %s GROUP BY track_id",
            tuple(child_ids))
        totals = {}
        for r in res:
            totals[r.track_id] = r.total
        res = db.query(
            "SELECT id,parent_id FROM account_track_categ WHERE id IN %s",
            tuple(child_ids))
        sub_ids = {}
        for r in res:
            sub_ids.setdefault(r.parent_id, [])
            sub_ids[r.parent_id].append(r.id)

        def _get_total(track_id):
            amt = totals.get(track_id, 0)
            for child_id in sub_ids.get(track_id, []):
                amt += _get_total(child_id)
            return amt

        vals = {}
        for obj in self.browse(ids):
            vals[obj.id] = _get_total(obj.id)
        return vals
Example #48
0
 def post(self):
     db = get_connection()
     try:
         data_json = self.get_argument("json_str",None)
         if not data_json:
             raise Exception("Can't get json_str")
         data = json.loads(data_json)
         cart_id = self.get_cookie("cart_id",None)
         if not cart_id:
             raise Exception("Can't get cart id")
         cart_id = int(cart_id)
         cart = get_model("ecom.cart").browse(cart_id)
         order = 0
         for line in cart.lines:
             for item in data: 
                 if item.get('order') == order:
                     line.write({"ship_method_id": item.get('method_id')})
             order += 1
         cart.calc_shipping()
         amount_ship = "{:0,.2f}".format(float(cart.amount_ship))
         amount_total = "{:0,.2f}".format(float(cart.amount_total))
         total = {
             "amount_ship": amount_ship,
             "amount_total": amount_total,
         }
         data = json.dumps(total)
         self.write(data)
         db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #49
0
 def get(self):
     db=get_connection()
     try:
         ctx=self.context
         page_code=self.get_argument("page")
         res=get_model("cms.page").search([["code","=",page_code]])
         if not res:
             self.redirect("/cms_page_not_found")
             return
         page_id=res[0]
         page=get_model("cms.page").browse(page_id)
         if page.state=="inactive":
             self.redirect("/cms_page_not_found")
             return
         ctx["page"]=page
         tmpl_name=page.template or "cms_page"
         content=render(tmpl_name,ctx)
         ctx["content"]=content
         html=render("cms_layout",ctx)
         self.write(html)
         db.commit()
     except:
         import traceback
         traceback.print_exc()
         db.rollback()
Example #50
0
 def approve(self, ids, context={}):
     print("ApproveWizard.approve", ids)
     obj = self.browse(ids)[0]
     pin_code = obj.pin_code
     obj.write({"pin_code": ""})  # XXX
     m = get_model(obj.approve_model)
     f = getattr(m, obj.approve_method, None)
     if not f:
         raise Exception("Invalid method %s of %s" %
                         (obj.approve_method, obj.approve_model))
     if not obj.approver_id:
         res = f([obj.approve_id], context=context)
     else:
         db = database.get_connection()
         res = db.get("SELECT pin_code FROM base_user WHERE id=%s",
                      obj.approver_id.id)
         enc_pin_code = res.pin_code
         if not utils.check_password(pin_code, enc_pin_code):
             raise Exception("Wrong PIN")
         user_id = get_active_user()
         set_active_user(obj.approver_id.id)
         try:
             res = f([obj.approve_id], context=context)
         finally:
             set_active_user(user_id)
     return res
Example #51
0
 def post(self):
     print("POST ARGUMENT >>>>>>>>>>>>>>>>>>>")
     print(self.request.body)
     f = open("paypal_return", "a")
     s = "################################################################################################################" + \
         "\n"
     s += "Date : " + time.strftime("%Y-%m-%d %H:%M:%S") + "\n"
     s += "Request : " + str(self.request) + "\n"
     if self.request.body:
         s += "Body : " + str(self.request.body) + "\n"
     s += "################################################################################################################" + \
         "\n"
     f.write(s)
     f.close()
     cart_id = int(self.get_argument("cart_id"))
     token = self.get_argument("token", None)
     payer_id = self.get_argument("PayerID", None)
     cart = get_model("ecom.cart").browse(cart_id)
     if not cart.is_paid:
         access.set_active_user(1)
         access.set_active_company(1)
         cart.import_paypal_payment(token, context={})
         db = database.get_connection()
         db.commit()
     self.redirect("/ecom_order_confirmed?cart_id=%s" % cart_id)
Example #52
0
 def compute_balance(self,
                     ids,
                     product_id,
                     date=None,
                     lot_id=None,
                     container_id=None,
                     uom_id=None):
     print("compute_balance", ids, product_id, date)
     prod = get_model("product").browse(product_id)
     if not uom_id:
         uom_id = prod.uom_id.id
     db = database.get_connection()
     q = "SELECT uom_id,SUM(qty) AS total_qty,SUM(cost_amount) AS total_amount,SUM(qty2) AS total_qty2 FROM stock_move WHERE location_to_id IN %s AND product_id=%s AND state='done'"
     args = [tuple(ids), product_id]
     if date:
         q += " AND date<=%s"
         args.append(date)
     if lot_id:
         q += " AND lot_id=%s"
         args.append(lot_id)
     if container_id:
         q += " AND container_to_id=%s"
         args.append(container_id)
     q += " GROUP BY uom_id"
     res = db.query(q, *args)
     in_qty = 0
     in_amount = 0
     in_qty2 = 0
     for r in res:
         qty = get_model("uom").convert(r.total_qty, r.uom_id, uom_id)
         in_qty += qty
         in_amount += r.total_amount or 0
         in_qty2 += r.total_qty2 or 0
     q = "SELECT uom_id,SUM(qty) AS total_qty,SUM(cost_amount) AS total_amount,SUM(qty2) AS total_qty2 FROM stock_move WHERE location_from_id IN %s AND product_id=%s AND state='done'"
     args = [tuple(ids), product_id]
     if date:
         q += " AND date<=%s"
         args.append(date)
     if lot_id:
         q += " AND lot_id=%s"
         args.append(lot_id)
     if container_id:
         q += " AND container_from_id=%s"
         args.append(container_id)
     q += " GROUP BY uom_id"
     res = db.query(q, *args)
     out_qty = 0
     out_amount = 0
     out_qty2 = 0
     for r in res:
         qty = get_model("uom").convert(r.total_qty, r.uom_id, uom_id)
         out_qty += qty
         out_amount += r.total_amount or 0
         out_qty2 += r.total_qty2 or 0
     return {
         "bal_qty": in_qty - out_qty,
         "bal_amount": in_amount - out_amount,
         "bal_qty2": in_qty2 - out_qty2,
     }
Example #53
0
def get_permissions(model):
    uid = get_active_user()
    if uid == 1:
        return {
            "read": True,
            "create": True,
            "write": True,
            "delete": True,
            "view_all": True,
            "modif_all": True,
        }
    db = database.get_connection()
    if uid:
        res = db.get("SELECT profile_id FROM base_user WHERE id=%s", uid)
        profile_id = res.profile_id if res else None
    else:
        res = db.get("SELECT anon_profile_id FROM settings WHERE id=1")
        profile_id = res.anon_profile_id if res else None
    if not profile_id:
        return {
            "read": False,
            "create": False,
            "write": False,
            "delete": False,
            "view_all": False,
            "modif_all": False,
        }
    res = db.get(
        "SELECT a.* FROM profile_access a JOIN model m ON m.id=a.model_id WHERE a.profile_id=%s AND m.name=%s", profile_id, model)
    if res:
        perms = {
            "read": res.perm_read,
            "create": res.perm_create,
            "write": res.perm_write,
            "delete": res.perm_delete,
            "view_all": res.view_all,
            "modif_all": res.modif_all,
        }
    else:
        res = db.get("SELECT default_model_perms FROM profile WHERE id=%s", profile_id)
        if res.default_model_perms == "full":
            perms = {
                "read": True,
                "create": True,
                "write": True,
                "delete": True,
                "view_all": False,
                "modif_all": False,
            }
        else:
            perms = {
                "read": False,
                "create": False,
                "write": False,
                "delete": False,
                "view_all": False,
                "modif_all": False,
            }
    return perms
Example #54
0
 def get_online_status(self, ids, context={}):
     vals = {}
     db = database.get_connection()
     res = db.query("SELECT user_id FROM ws_listener")
     online_ids = set([r.user_id for r in res])
     for obj in self.browse(ids):
         vals[obj.id] = obj.id in online_ids and "online" or "offline"
     return vals
 def get_unrec_num(self, ids, context={}):
     db = database.get_connection()
     res = db.query(
         "SELECT st.account_id,count(*) FROM account_statement_line stl JOIN account_statement st ON st.id=stl.statement_id WHERE stl.state='not_reconciled' AND st.account_id IN %s GROUP BY st.account_id", tuple(ids))
     vals = {}
     for r in res:
         vals[r.account_id] = r.count
     return vals