def create(self, vals, **kw):
uid = access.get_active_user()
try:
access.set_active_user(1)
return super().create(vals, **kw)
finally:
access.set_active_user(uid)
def default_get(self, field_names=None, context=None, **kw):
user_id = get_active_user()
set_active_user(1)
user = get_model("base.user").browse(user_id)
vals = {"name": user.name, "password": user.password, "email": user.email, "mobile": user.mobile}
set_active_user(user_id)
return vals
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()
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()
def create(self, vals, **kw):
uid = access.get_active_user()
try:
access.set_active_user(1)
return super().create(vals, **kw)
finally:
access.set_active_user(uid)
def send_email(self, ids, context={}):
uid = access.get_active_user()
try:
access.set_active_user(1)
obj = self.browse(ids[0])
# XXX "=" should be changed to "=ilike" later
res = get_model("base.user").search((["email", "=ilike", obj.email.strip()]))
if not res:
raise Exception("User with given email doesn't exist in database")
request = context["request"]
msg = "Somebody requested change of your Netforce password.\n\n"
msg += "If you didn't do it, please ignore this message.\n\n"
msg += "Otherwise if you want to reset your password click on the link below:\n\n"
msg += "http://%s/ui#name=change_passwd&key=%s\n\n\n" % (request.host, obj.key)
msg += "Regards,\n"
msg += "Netforce Team"
vals = {
"type": "out",
"from_addr": "*****@*****.**",
"to_addrs": obj.email,
"subject": "Netforce reset password request",
"body": msg,
"state": "to_send",
}
get_model("email.message").create(vals)
return {
"next": {
"name": "forgot_passwd_done"
}
}
finally:
access.set_active_user(uid)
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()
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)
def remove_expired_lots(self, context={}):
print("StockLot.remove_expired_lots")
access.set_active_user(1)
access.set_active_company(1)
settings = get_model("settings").browse(1)
if not settings.lot_expiry_journal_id:
raise Exception("Missing lot expiry journal")
journal = settings.lot_expiry_journal_id
if not journal.location_to_id:
raise Exception("Missing to location in lot expiry journal")
t = time.strftime("%Y-%m-%d")
pick_vals = {"type": "out", "journal_id": journal.id, "lines": []}
n = 0
for obj in self.search_browse([["expiry_date", "<", t]]):
prod = obj.product_id
if not prod:
continue
for bal in obj.stock_balances:
if bal.qty_phys <= 0:
continue
line_vals = {
"product_id": prod.id,
"location_from_id": bal.location_id.id,
"location_to_id": journal.location_to_id.id,
"lot_id": obj.id,
"qty": bal.qty_phys,
"uom_id": prod.uom_id.id,
}
pick_vals["lines"].append(("create", line_vals))
n += 1
if pick_vals["lines"]:
pick_id = get_model("stock.picking").create(pick_vals, context={"pick_type": "out"})
get_model("stock.picking").set_done([pick_id])
get_model("stock.picking").trigger([pick_id], "lot_expired")
return {"flash": "%d lots removed from stock" % n}
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()
def send_email(self, ids, context={}):
uid = access.get_active_user()
try:
access.set_active_user(1)
obj = self.browse(ids[0])
# XXX "=" should be changed to "=ilike" later
res = get_model("base.user").search(
(["email", "=ilike", obj.email.strip()]))
if not res:
raise Exception(
"User with given email doesn't exist in database")
request = context["request"]
msg = "Somebody requested change of your Netforce password.\n\n"
msg += "If you didn't do it, please ignore this message.\n\n"
msg += "Otherwise if you want to reset your password click on the link below:\n\n"
msg += "http://%s/ui#name=change_passwd&key=%s\n\n\n" % (
request.host, obj.key)
msg += "Regards,\n"
msg += "Netforce Team"
vals = {
"type": "out",
"from_addr": "*****@*****.**",
"to_addrs": obj.email,
"subject": "Netforce reset password request",
"body": msg,
"state": "to_send",
}
get_model("email.message").create(vals)
return {"next": {"name": "forgot_passwd_done"}}
finally:
access.set_active_user(uid)
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)
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
def post(self):
#try:
with database.Transaction():
#db = get_connection()
print("########################################")
print("#######Result Payment Online SCB########")
print("############# POST ##############")
print("########################################")
f = open("scblog", "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()
if self.request.arguments:
website = get_model("website").browse(1)
if not website.scb_mid:
raise Exception("no merchant id in website settings")
if not website.scb_terminal:
raise Exception("no terminal id in website settings")
if not website.scb_url:
raise Exception("no URL server in website settings")
mid = self.get_argument("mid", None)
print(mid)
if mid != website.scb_mid:
raise Exception("Merchant id does not match")
terminal = self.get_argument("terminal", None)
print(terminal)
if terminal != website.scb_terminal:
raise Exception("Terminal id does not match")
command = self.get_argument("command", None)
print(command)
if command != 'CRAUTH':
raise Exception("Command does not match")
payment_status = self.get_argument("payment_status", None)
print(payment_status)
if payment_status == '003':
raise Exception("Payment host reject")
if payment_status == '006':
raise Exception("Payment error")
ref_no = self.get_argument("ref_no", None)
print(ref_no)
if payment_status == '002':
set_active_user(1)
set_active_company(1)
res = get_model("sale.order").search_browse(
[["number", "=", ref_no]])
if res: # XXX Inquiry double check
sale = res[0]
if not sale.is_paid:
sale.import_scb_payment()
def post(self):
#try:
with database.Transaction():
#db = get_connection()
print("########################################")
print("#######Result Payment Online SCB########")
print("############# POST ##############")
print("########################################")
f = open("scblog", "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()
if self.request.arguments:
website = get_model("website").browse(1)
if not website.scb_mid:
raise Exception("no merchant id in website settings")
if not website.scb_terminal:
raise Exception("no terminal id in website settings")
if not website.scb_url:
raise Exception("no URL server in website settings")
mid = self.get_argument("mid", None)
print(mid)
if mid != website.scb_mid:
raise Exception("Merchant id does not match")
terminal = self.get_argument("terminal", None)
print(terminal)
if terminal != website.scb_terminal:
raise Exception("Terminal id does not match")
command = self.get_argument("command", None)
print(command)
if command != 'CRAUTH':
raise Exception("Command does not match")
payment_status = self.get_argument("payment_status", None)
print(payment_status)
if payment_status == '003':
raise Exception("Payment host reject")
if payment_status == '006':
raise Exception("Payment error")
ref_no = self.get_argument("ref_no", None)
print(ref_no)
if payment_status == '002':
set_active_user(1)
set_active_company(1)
res = get_model("sale.order").search_browse([["number", "=", ref_no]])
if res: # XXX Inquiry double check
sale = res[0]
if not sale.is_paid:
sale.import_scb_payment()
def delete(self, ids, **kw):
prod_ids = []
for obj in self.browse(ids):
prod_ids.append(obj.product_id.id)
super().delete(ids, **kw)
user_id = get_active_user()
set_active_user(1)
get_model("product").write(prod_ids, {"update_balance": True})
set_active_user(user_id)
def delete(self, ids, **kw):
prod_ids = []
for obj in self.browse(ids):
prod_ids.append(obj.product_id.id)
super().delete(ids, **kw)
user_id = get_active_user()
set_active_user(1)
get_model("product").write(prod_ids, {"update_balance": True})
set_active_user(user_id)
def migrate(self):
user_id = get_active_user()
set_active_user(1)
for payslip in get_model("hr.payslip").search_browse([]):
if not payslip.state:
payslip.write({"state": "draft"})
for payrun in get_model("hr.payrun").search_browse([]):
if not payrun.state:
payrun.write({"state": "draft"})
set_active_user(user_id)
def auto_create_purchase_orders(self,context={}):
access.set_active_user(1)
access.set_active_company(1) # XXX
vals={
"confirm_orders": True,
}
obj_id=self.create(vals)
self.delete_planned_orders([obj_id])
self.fill_products([obj_id])
self.create_po([obj_id])
def auto_create_production_orders(self, context={}):
access.set_active_user(1)
access.set_active_company(1) # XXX
vals = {
"confirm_orders": True,
}
obj_id = self.create(vals)
self.delete_planned_orders([obj_id])
self.fill_products([obj_id])
self.create_mo([obj_id])
def save_changes(self, ids, context={}):
obj = self.browse(ids)[0]
check_password(obj.password)
vals = {"name": obj.name, "password": obj.password, "email": obj.email, "mobile": obj.mobile}
user_id = get_active_user()
set_active_user(1)
get_model("base.user").write([user_id], vals)
obj.write({"password": ""})
set_active_user(user_id)
return {"next": "_close"}
def migrate(self):
set_active_user(1)
for user in get_model("base.user").search_browse([]):
res=get_model("limit.inspect").search([['user_id','=',user.id]])
if not res:
insp_ids=get_model("inspection").search([['user_id','=',user.id]])
get_model("limit.inspect").create({
'user_id': user.id,
'record_count': len(insp_ids),
})
def migrate(self):
user_id=get_active_user()
set_active_user(1)
for leave in get_model("hr.leave").search_browse([]):
if leave.time_from and leave.time_to:
leave.write({
'start_date': '%s %s:00'%(leave.start_date[0:10],leave.time_from.replace(".",":")),
'end_date': '%s %s:00'%(leave.end_date[0:10],leave.time_to.replace(".",":")),
})
set_active_user(user_id)
def run_job(dbname, job):
print("run_job dbname=%s pid=%s job='%s'" %
(dbname, os.getpid(), job["name"]))
database.connections.clear()
set_active_user(1)
database.set_active_db(dbname)
db = database.get_connection()
db.begin()
clear_cache()
m = get_model(job["model"])
f = getattr(m, job["method"])
if job["args"]:
args = json.loads(job["args"])
else:
args = []
db.execute("UPDATE cron_job SET state='running' WHERE id=%s", job["id"])
db.commit()
print("starting job '%s'" % job["name"])
try:
with utils.timeout(seconds=job["timeout"]):
f(*args)
db.commit()
print("job '%s' success" % job["name"])
except Exception as e:
print("WARNING: job '%s' failed: %s" % (job["name"], e))
db.rollback()
t = time.strftime("%Y-%m-%d %H:%M:%S")
msg = traceback.format_exc()
db.execute(
"UPDATE cron_job SET last_error_time=%s,error_message=%s WHERE id=%s",
t, msg, job["id"])
db.commit()
t1 = time.strftime("%Y-%m-%s %H:%M:%S")
if job["interval_num"]:
if job["interval_type"] == "second":
dt = timedelta(seconds=job["interval_num"])
elif job["interval_type"] == "minute":
dt = timedelta(minutes=job["interval_num"])
elif job["interval_type"] == "hour":
dt = timedelta(hours=job["interval_num"])
elif job["interval_type"] == "day":
dt = timedelta(days=job["interval_num"])
else:
raise Exception("Missing interval unit")
next_date = datetime.strptime(job["date"], "%Y-%m-%d %H:%M:%S")
now = datetime.now()
while next_date <= now: # TODO: make this faster
next_date += dt
if next_date < _check_times[dbname]:
_check_times[dbname] = next_date
db.execute("UPDATE cron_job SET date=%s,state='waiting' WHERE id=%s",
next_date.strftime("%Y-%m-%d %H:%M:%S"), job["id"])
else:
db.execute("UPDATE cron_job SET state='done' WHERE id=%s", job["id"])
db.commit()
def run_tests():
print("running tests...")
access.set_active_user(1)
suites = []
for test in test_cases:
loader = unittest.TestLoader()
suite = loader.loadTestsFromTestCase(test)
suites.append(suite)
suite_all = unittest.TestSuite(suites)
runner = unittest.TextTestRunner(verbosity=2)
res = runner.run(suite_all)
def run_tests():
print("running tests...")
access.set_active_user(1)
suites = []
for test in test_cases:
loader = unittest.TestLoader()
suite = loader.loadTestsFromTestCase(test)
suites.append(suite)
suite_all = unittest.TestSuite(suites)
runner = unittest.TextTestRunner(verbosity=2)
res = runner.run(suite_all)
def default_get(self, field_names=None, context=None, **kw):
user_id = get_active_user()
set_active_user(1)
user = get_model("base.user").browse(user_id)
vals = {
"name": user.name,
"password": user.password,
"email": user.email,
"mobile": user.mobile,
}
set_active_user(user_id)
return vals
def _get_number(self, context={}):
while 1:
num = get_model("sequence").get_number(type="job")
if not num:
return None
user_id = get_active_user()
set_active_user(1)
res = self.search([["number", "=", num]])
set_active_user(user_id)
if not res:
return num
get_model("sequence").increment(type="job")
def run_job(dbname, job):
print("run_job dbname=%s pid=%s job='%s'"%(dbname, os.getpid(), job["name"]))
database.connections.clear()
set_active_user(1)
database.set_active_db(dbname)
db = database.get_connection()
db.begin()
clear_cache()
m = get_model(job["model"])
f = getattr(m, job["method"])
if job["args"]:
args = json.loads(job["args"])
else:
args = []
db.execute("UPDATE cron_job SET state='running' WHERE id=%s", job["id"])
db.commit()
print("starting job '%s'"%job["name"])
try:
with utils.timeout(seconds=job["timeout"]):
f(*args)
db.commit()
print("job '%s' success" % job["name"])
except Exception as e:
print("WARNING: job '%s' failed: %s"%(job["name"],e))
db.rollback()
t=time.strftime("%Y-%m-%d %H:%M:%S")
msg=traceback.format_exc()
db.execute("UPDATE cron_job SET last_error_time=%s,error_message=%s WHERE id=%s", t, msg, job["id"])
db.commit()
t1 = time.strftime("%Y-%m-%s %H:%M:%S")
if job["interval_num"]:
if job["interval_type"] == "second":
dt = timedelta(seconds=job["interval_num"])
elif job["interval_type"] == "minute":
dt = timedelta(minutes=job["interval_num"])
elif job["interval_type"] == "hour":
dt = timedelta(hours=job["interval_num"])
elif job["interval_type"] == "day":
dt = timedelta(days=job["interval_num"])
else:
raise Exception("Missing interval unit")
next_date = datetime.strptime(job["date"], "%Y-%m-%d %H:%M:%S")
now = datetime.now()
while next_date <= now: # TODO: make this faster
next_date += dt
if next_date < _check_times[dbname]:
_check_times[dbname] = next_date
db.execute("UPDATE cron_job SET date=%s,state='waiting' WHERE id=%s",
next_date.strftime("%Y-%m-%d %H:%M:%S"), job["id"])
else:
db.execute("UPDATE cron_job SET state='done' WHERE id=%s", job["id"])
db.commit()
def write(self, ids, vals, context={}):
prod_ids = []
for obj in self.browse(ids):
prod_ids.append(obj.product_id.id)
super().write(ids, vals, context=context)
prod_id = vals.get("product_id")
if prod_id:
prod_ids.append(prod_id)
self.function_store(ids)
user_id = get_active_user()
set_active_user(1)
get_model("product").write(prod_ids, {"update_balance": True})
set_active_user(user_id)
def _get_number(self, context={}):
seq_id = get_model("sequence").find_sequence(type="purchase_order")
if not seq_id:
return None
while 1:
num = get_model("sequence").get_next_number(seq_id)
user_id = get_active_user()
set_active_user(1)
res = self.search([["number", "=", num]])
set_active_user(user_id)
if not res:
return num
get_model("sequence").increment_number(seq_id)
def _get_number(self, context={}):
seq_id = get_model("sequence").find_sequence(type="purchase_return")
if not seq_id:
return None
while 1:
num = get_model("sequence").get_next_number(seq_id)
user_id = get_active_user()
set_active_user(1)
res = self.search([["number", "=", num]])
set_active_user(user_id)
if not res:
return num
get_model("sequence").increment_number(seq_id)
def write(self, ids, vals, context={}):
prod_ids = []
for obj in self.browse(ids):
prod_ids.append(obj.product_id.id)
super().write(ids, vals, context=context)
prod_id = vals.get("product_id")
if prod_id:
prod_ids.append(prod_id)
self.function_store(ids)
user_id = get_active_user()
set_active_user(1)
get_model("product").write(prod_ids, {"update_balance": True})
set_active_user(user_id)
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()
def migrate(self):
user_id = get_active_user()
set_active_user(1)
for payslip in get_model("hr.payslip").search_browse([]):
if not payslip.state:
payslip.write({
'state': 'draft',
})
for payrun in get_model("hr.payrun").search_browse([]):
if not payrun.state:
payrun.write({
'state': 'draft',
})
set_active_user(user_id)
def apply_migrations(from_version):
to_version = get_db_version()
print("Applying migrations from version %s to %s..." % (from_version, to_version))
for mig_cls in sorted(_migrations, key=lambda m: (m._version, m._name)):
if compare_version(mig_cls._version, from_version) <= 0:
continue
if mig_cls._max_version and compare_version(to_version, mig_cls._max_version) > 0:
raise Exception(
"Can not apply migration '%s', maximum version that can apply this migration is %s" % (mig._name, mig._max_version))
mig = mig_cls()
print("Applying migration %s..." % mig._name)
set_active_user(1)
set_active_company(None)
mig.migrate()
def migrate(self):
user_id = get_active_user()
set_active_user(1)
for leave in get_model("hr.leave").search_browse([]):
if leave.time_from and leave.time_to:
leave.write({
'start_date':
'%s %s:00' % (leave.start_date[0:10],
leave.time_from.replace(".", ":")),
'end_date':
'%s %s:00' %
(leave.end_date[0:10], leave.time_to.replace(".", ":")),
})
set_active_user(user_id)
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()
def create(self, vals, context={}):
pick_id = vals.get("picking_id")
if pick_id:
pick = get_model("stock.picking").browse(pick_id)
vals["date"] = pick.date
vals["picking_id"] = pick.id
vals["journal_id"] = pick.journal_id.id
new_id = super().create(vals, context=context)
self.function_store([new_id])
prod_id = vals["product_id"]
user_id = get_active_user()
set_active_user(1)
get_model("product").write([prod_id], {"update_balance": True})
set_active_user(user_id)
return new_id
def create(self, vals, context={}):
pick_id = vals.get("picking_id")
if pick_id:
pick = get_model("stock.picking").browse(pick_id)
vals["date"] = pick.date
vals["picking_id"] = pick.id
vals["journal_id"] = pick.journal_id.id
new_id = super().create(vals, context=context)
self.function_store([new_id])
prod_id = vals["product_id"]
user_id = get_active_user()
set_active_user(1)
get_model("product").write([prod_id], {"update_balance": True})
set_active_user(user_id)
return new_id
def _get_number(self, context={}):
seq_id = get_model("sequence").find_sequence(type="ecom_cart")
if not seq_id:
return None
while 1:
num = get_model("sequence").get_next_number(seq_id, context=context)
if not num:
return None
user_id = access.get_active_user()
access.set_active_user(1)
res = self.search([["number", "=", num]])
access.set_active_user(user_id)
if not res:
return num
get_model("sequence").increment_number(seq_id, context=context)
def _get_number(self, context={}):
seq_id = get_model("sequence").find_sequence(type="ecom_cart")
if not seq_id:
return None
while 1:
num = get_model("sequence").get_next_number(seq_id,
context=context)
if not num:
return None
user_id = access.get_active_user()
access.set_active_user(1)
res = self.search([["number", "=", num]])
access.set_active_user(user_id)
if not res:
return num
get_model("sequence").increment_number(seq_id, context=context)
def get(self):
db=get_connection()
try:
set_active_user(1)
action=self.get_argument("action")
res=get_model("inline.help").search([["action","=",action]])
if not res:
raise Exception("Inline help not found for action '%s'"%action)
page_id=res[0]
page=get_model("inline.help").browse(page_id)
self.write(page.content)
db.commit()
except:
import traceback
traceback.print_exc()
db.rollback()
def post(self):
try:
print("POST ARGUMENT >>>>>>>>>>>>>>>>>>>")
print(self.request.body)
f = open("paysbuy_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"))
result = self.get_argument("result", None)
method = self.get_argument("method", None)
cart = get_model("ecom.cart").browse(cart_id)
if method:
access.set_active_user(1)
access.set_active_company(1)
cart.update_paysbuy_method(method)
db = database.get_connection()
db.commit()
if result.startswith("00"): # received payment already
if not cart.is_paid:
access.set_active_user(1)
access.set_active_company(1)
cart.import_paysbuy_payment()
db = database.get_connection()
db.commit()
self.redirect("/ecom_order_confirmed?cart_id=%s" % cart_id)
elif result.startswith("02"): # will receive payment later
self.redirect("/ecom_order_confirmed?cart_id=%s" % cart_id)
else:
cart.cancel_order()
db = database.get_connection()
db.commit()
#self.set_cookie("cart_id", str(cart_id))
self.redirect("/ecom_order_cancelled?cart_id=%s" % cart_id)
except Exception as e:
db = database.get_connection()
db.rollback
import traceback
traceback.print_exc()
def apply_migrations(from_version):
to_version = get_db_version()
print("Applying migrations from version %s to %s..." %
(from_version, to_version))
for mig_cls in sorted(_migrations, key=lambda m: (m._version, m._name)):
if compare_version(mig_cls._version, from_version) <= 0:
continue
if mig_cls._max_version and compare_version(to_version,
mig_cls._max_version) > 0:
raise Exception(
"Can not apply migration '%s', maximum version that can apply this migration is %s"
% (mig._name, mig._max_version))
mig = mig_cls()
print("Applying migration %s..." % mig._name)
set_active_user(1)
set_active_company(None)
mig.migrate()
def gen_tax_no(self, context={}):
seq_id = get_model("sequence").find_sequence(type="wht_no",
context=context)
if not seq_id:
return None
while 1:
num = get_model("sequence").get_next_number(seq_id,
context=context)
if not num:
return None
user_id = get_active_user()
set_active_user(1)
res = self.search([["tax_invoice", "=", num]])
set_active_user(user_id)
if not res:
return num
get_model("sequence").increment_number(seq_id, context=context)
def onchange_sequence(self, context={}):
data = context["data"]
context['date'] = data['date']
seq_id = data["sequence_id"]
if not seq_id:
seq_id = get_model("sequence").find_sequence(type="purchase_order")
while 1:
num = get_model("sequence").get_next_number(seq_id, context=context)
user_id = get_active_user()
set_active_user(1)
res = self.search([["number", "=", num]])
set_active_user(user_id)
if not res:
break
get_model("sequence").increment_number(seq_id, context=context)
data["number"] = num
return data
def get(self):
db = get_connection()
try:
set_active_user(1)
action = self.get_argument("action")
res = get_model("inline.help").search([["action", "=", action]])
if not res:
raise Exception("Inline help not found for action '%s'" %
action)
page_id = res[0]
page = get_model("inline.help").browse(page_id)
self.write(page.content)
db.commit()
except:
import traceback
traceback.print_exc()
db.rollback()
def save_changes(self, ids, context={}):
obj = self.browse(ids)[0]
check_password(obj.password)
vals = {
"name": obj.name,
"password": obj.password,
"email": obj.email,
"mobile": obj.mobile,
}
user_id = get_active_user()
set_active_user(1)
get_model("base.user").write([user_id], vals)
obj.write({"password": ""})
set_active_user(user_id)
return {
"next": "_close",
}
def get_company_logo(self, context={}):
dbname = database.get_active_db()
if not dbname:
return None
user_id = get_active_user()
try:
set_active_user(1)
res = get_model("company").search([["parent_id", "=", None]], order="id")
if not res:
return None
company_id = res[0]
set_active_company(company_id)
settings = get_model("settings").browse(1)
if not settings.logo:
return None
return "/static/db/%s/files/%s" % (dbname, settings.logo)
finally:
set_active_user(user_id)
def get_ui_params(self, context={}):
user_id = access.get_active_user()
if not user_id:
return
try:
access.set_active_user(1)
db = database.get_connection()
if not db:
return
user = self.browse(user_id)
params = {
"name": user.name,
}
prof = user.profile_id
params["default_model_perms"] = prof.default_model_perms
params["model_perms"] = []
for p in prof.perms:
params["model_perms"].append({
"model": p.model_id.name,
"perm_read": p.perm_read,
"perm_create": p.perm_create,
"perm_write": p.perm_write,
"perm_delete": p.perm_delete,
})
params["field_perms"] = []
for p in prof.field_perms:
params["field_perms"].append({
"model": p.field_id.model_id.name,
"field": p.field_id.name,
"perm_read": p.perm_read,
"perm_write": p.perm_write,
})
params["default_menu_access"] = prof.default_menu_access
params["menu_perms"] = []
for p in prof.menu_perms:
params["menu_perms"].append({
"action": p.action,
"menu": p.menu,
"access": p.access,
})
params["other_perms"] = [p.code for p in prof.other_perms]
return params
finally:
access.set_active_user(user_id)
def get_ui_params(self, context={}):
user_id = access.get_active_user()
if not user_id:
return
try:
access.set_active_user(1)
db = database.get_connection()
if not db:
return
user = self.browse(user_id)
params = {
"name": user.name,
}
prof = user.profile_id
params["default_model_perms"] = prof.default_model_perms
params["model_perms"] = []
for p in prof.perms:
params["model_perms"].append({
"model": p.model_id.name,
"perm_read": p.perm_read,
"perm_create": p.perm_create,
"perm_write": p.perm_write,
"perm_delete": p.perm_delete,
})
params["field_perms"] = []
for p in prof.field_perms:
params["field_perms"].append({
"model": p.field_id.model_id.name,
"field": p.field_id.name,
"perm_read": p.perm_read,
"perm_write": p.perm_write,
})
params["default_menu_access"] = prof.default_menu_access
params["menu_perms"] = []
for p in prof.menu_perms:
params["menu_perms"].append({
"action": p.action,
"menu": p.menu,
"access": p.access,
})
params["other_perms"] = [p.code for p in prof.other_perms]
return params
finally:
access.set_active_user(user_id)
def get_company_logo(self, context={}):
dbname = database.get_active_db()
if not dbname:
return None
user_id = get_active_user()
try:
set_active_user(1)
res = get_model("company").search([["parent_id", "=", None]],
order="id")
if not res:
return None
company_id = res[0]
set_active_company(company_id)
settings = get_model("settings").browse(1)
if not settings.logo:
return None
return "/static/db/%s/files/%s" % (dbname, settings.logo)
finally:
set_active_user(user_id)
def get(self):
#url="https://v5.inspection.in.th/inspectionreport/checkqr?id=1541844&password=f45681f1"
current_local=get_active_locale()
set_active_user(1) #admin
set_active_locale('th_TH')
db=get_connection() # prevent to error get transaction
try:
db.begin()
id=self.get_argument("id")
if not id:
self.write("Missing ID")
return
password=self.get_argument("password")
if not password:
self.write("Missing Password")
return
ctx={
'obj': None,
}
#res=db.query("select * from inspection where number=%s and password=%s",id,password)
dom=[
['number','=', id],
['password','=', password]
]
res=get_model("inspection").search_read(dom)
if res:
#t0=res[-1]['date']
#t1=t0.split(" ")
#res[-1]['date']='%s %s'%(sale_utils.date2thai(t1[0], format='%(d)s %(Tm)s %(BY)s'), t1[1])
#res[-1]['date_register']=sale_utils.date2thai(res[-1]['date_register'], format='%(d)s %(Tm)s %(BY)s')
ctx['obj']=res[-1]
else:
ctx['nothing']=True
data=ctx['obj']
html=render("checkqr",context=ctx, data=data)
self.write(html)
except Exception as e:
self.write("ERROR : %s"%str(e))
finally:
if db:
db.commit()
set_active_locale(current_local)
def remove_expired_lots(self, context={}):
print("StockLot.remove_expired_lots")
access.set_active_user(1)
access.set_active_company(1)
settings = get_model("settings").browse(1)
if not settings.lot_expiry_journal_id:
raise Exception("Missing lot expiry journal")
journal = settings.lot_expiry_journal_id
if not journal.location_to_id:
raise Exception("Missing to location in lot expiry journal")
t = time.strftime("%Y-%m-%d")
pick_vals = {
"type": "out",
"journal_id": journal.id,
"lines": [],
}
n = 0
for obj in self.search_browse([["expiry_date", "<", t]]):
prod = obj.product_id
if not prod:
continue
for bal in obj.stock_balances:
if bal.qty_phys <= 0:
continue
line_vals = {
"product_id": prod.id,
"location_from_id": bal.location_id.id,
"location_to_id": journal.location_to_id.id,
"lot_id": obj.id,
"qty": bal.qty_phys,
"uom_id": prod.uom_id.id,
}
pick_vals["lines"].append(("create", line_vals))
n += 1
if pick_vals["lines"]:
pick_id = get_model("stock.picking").create(
pick_vals, context={"pick_type": "out"})
get_model("stock.picking").set_done([pick_id])
get_model("stock.picking").trigger([pick_id], "lot_expired")
return {
"flash": "%d lots removed from stock" % n,
}
def post(self):
print("POST >>>>>>>>>>>>>>>>>>>")
with database.Transaction():
cart_id = int(self.get_argument("cart_id"))
cart = get_model("ecom.cart").browse(cart_id)
website=cart.website_id
base_url=(website.url or "").strip()
if base_url.endswith("/"):
base_url=base_url[:-1]
response = self.get_argument("response")
if response == "declined":
cart.cancel_order()
#self.set_cookie("cart_id", str(cart_id))
self.redirect(base_url+"/ecom_order_cancelled?cart_id=%s" % cart_id)
return
if not cart.is_paid:
access.set_active_user(1)
access.set_active_company(1)
cart.import_scb_payment()
self.redirect(base_url+"/ecom_order_confirmed?cart_id=%s" % cart_id)
def _get_number(self, context={}):
pick_type = context.get("pick_type")
journal_id = context.get("journal_id")
seq_id = None
if journal_id:
journal = get_model("stock.journal").browse(journal_id)
seq_id = journal.sequence_id.id
if not seq_id and pick_type:
seq_type = "pick_" + pick_type
seq_id = get_model("sequence").find_sequence(seq_type)
if not seq_id:
return None
while 1:
num = get_model("sequence").get_next_number(seq_id)
user_id = get_active_user()
set_active_user(1)
res = self.search([["number", "=", num]])
set_active_user(user_id)
if not res:
return num
get_model("sequence").increment_number(seq_id)
def post(self):
with database.Transaction():
print("POST ARGUMENT >>>>>>>>>>>>>>>>>>>")
print(self.request.body)
f = open("paysbuy_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"))
result = self.get_argument("result", None)
method = self.get_argument("method", None)
cart = get_model("ecom.cart").browse(cart_id)
f = open("record_return", "a")
x = "cart_id:" + str(cart_id)
x += "\nrestut:" + result
f.write(x)
f.close()
if method:
access.set_active_user(1)
access.set_active_company(1)
cart.update_paysbuy_method(method)
if result.startswith("00"): # received payment already
if not cart.is_paid:
access.set_active_user(1)
access.set_active_company(1)
cart.import_paysbuy_payment()
self.redirect("/ecom_order_confirmed?cart_id=%s" % cart_id)
elif result.startswith("02"): # will receive payment later
self.redirect("/ecom_order_confirmed?cart_id=%s" % cart_id)
else:
cart.cancel_order()
self.redirect("/ecom_order_cancelled?cart_id=%s" % cart_id)
self.redirect("/ecom_order_cancelled?cart_id=%s" % cart_id)
def log(self, msg, details=None, ip_addr=None, related_id=None):
uid = get_active_user()
if not ip_addr:
ip_addr = get_ip_addr()
try:
country_code = get_ip_country(ip_addr)
res = get_model("country").search([["code", "=", country_code]])
country_id = res[0]
except Exception as e:
#print("Failed to get IP country: %s"%e)
country_id = None
vals = {
"user_id": uid,
"ip_addr": ip_addr,
"message": msg,
"details": details,
"country_id": country_id,
"related_id": related_id,
}
set_active_user(1)
self.create(vals)
set_active_user(uid)
