def create_sys_admin_user():
# type: () -> object
"""
Create sys admin user if ir was not existing. The sys admin user use to use for maintian system
whenever you need. The username of Sys admin user in system is 'root' with default password is 'root'
:return:
"""
try:
# User.objects.set_db_schema("sys")
obj_users=User.objects
user = obj_users.get(username="******",schema=tenancy.get_schema())
user.is_staff = True
user.is_admin = True
user.save(schema=tenancy.get_schema())
# User.objects.set_db_schema(None)
except ObjectDoesNotExist as ex:
# User.objects.set_db_schema("sys")
user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******',
schema=tenancy.get_schema())
user.is_staff = True
user.is_admin = True
user.save(schema="sys")
User.objects.set_db_schema(None)
def login(request):
_login = {"username": "", "password": "", "language": "en", "next": ""}
from . import create_sys_admin_user
create_sys_admin_user.create_sys_admin_user()
_login["language"] = request._get_request().get("language", "en")
if request.GET.has_key("next"):
_login["next"] = request.GET.get("next", request.get_app_url(""))
request.session["language"] = _login["language"]
if request._get_post().keys().__len__() > 0:
_login["username"] = request._get_post().get("username", "")
_login["password"] = request._get_post().get("password", "")
_login["language"] = request._get_post().get("language", "en")
user = authenticate(username=request._get_post().get("username", ""),
password=request._get_post().get("password", ""),
schema=tenancy.get_schema())
if user == None:
_login.update(
dict(error=dict(message=request.get_global_res(
"Username or Password is incorrect"))))
return request.render(_login)
else:
try:
request_login(request, user, schema=tenancy.get_schema())
return redirect(_login["next"])
except Exception as ex:
raise (ex)
return request.render(_login)
def insert(args):
from quicky import tenancy
if args['data'] != None:
ret = {}
try:
lock.acquire()
user_name = args['data']['login_account']
if User.objects.filter(username=user_name).exists() == 0:
args['data']['username'] = generate_user_id()
data = dict(
username = args['data']['username'],
login_account = args['data']['login_account'],
display_name = args['data']['display_name'],
role_code = (lambda data: data["role_code"] if data.has_key("role_code") else None)(args['data']),
email = args['data']['email'],
is_system = (lambda data: data["is_system"] if data.has_key("is_system") else False)(args['data']),
never_expire = (lambda data: data["never_expire"] if data.has_key("never_expire") else False)(args['data']),
manlevel_from = (lambda data: data["manlevel_from"] if data.has_key("manlevel_from") else None)(args['data']),
manlevel_to = (lambda data: data["manlevel_to"] if data.has_key("manlevel_to") else None)(args['data']),
mobile = (lambda data: data["mobile"] if data.has_key("mobile") else None)(args['data']),
description = (lambda data: data["description"] if data.has_key("description") else None)(args['data'])
)
ret = models.auth_user_info().insert(data)
if ret.has_key('error') and ret['error'] != None:
raise(Exception(ret['error']['code']))
try:
user = User.objects.create_user(
username=args['data']['username'],
password=args['data']['password'],
schema=tenancy.get_schema()
)
user.save(schema=tenancy.get_schema())
lock.release()
return ret
except Exception as ex:
models.auth_user_info().delete("username == {0}", args['data']['username'])
lock.release()
return dict(
error = "Internal Server Error"
)
lock.release()
return dict(
error = "existing login account"
) #Already account
except Exception as ex:
logger.debug(ex)
lock.release()
return ret
return dict(
error = "request parameter is not exist"
)
def insert(args):
from quicky import tenancy
if args['data'] != None:
ret = {}
try:
lock.acquire()
user_name = args['data']['login_account']
if User.objects.filter(username=user_name, schema=tenancy.get_schema()).exists() == 0:
args['data']['username'] = generate_user_id()
data = dict(
username = args['data']['username'],
login_account = args['data']['login_account'],
display_name = args['data']['display_name'],
role_code = (lambda data: data["role_code"] if data.has_key("role_code") else None)(args['data']),
email = args['data']['email'],
is_system = (lambda data: data["is_system"] if data.has_key("is_system") else False)(args['data']),
never_expire = (lambda data: data["never_expire"] if data.has_key("never_expire") else False)(args['data']),
manlevel_from = (lambda data: data["manlevel_from"] if data.has_key("manlevel_from") else None)(args['data']),
manlevel_to = (lambda data: data["manlevel_to"] if data.has_key("manlevel_to") else None)(args['data']),
mobile = (lambda data: data["mobile"] if data.has_key("mobile") else None)(args['data']),
description = (lambda data: data["description"] if data.has_key("description") else None)(args['data'])
)
ret = models.auth_user_info().insert(data)
if ret.has_key('error') and ret['error'] != None:
raise(Exception(ret['error']['code']))
try:
user = User.objects.create_user(
username=args['data']['username'],
password=args['data']['password'],
schema=tenancy.get_schema()
)
user.save(schema=tenancy.get_schema())
lock.release()
return ret
except Exception as ex:
models.auth_user_info().delete("username == {0}", args['data']['username'])
lock.release()
return dict(
error = "Internal Server Error"
)
lock.release()
return dict(
error = "existing login account"
) #Already account
except Exception as ex:
logger.debug(ex)
lock.release()
return ret
return dict(
error = "request parameter is not exist"
)
def login(request):
#try:
# sys_user=User.objects.get(username="******")
#except ObjectDoesNotExist as ex:
# user = User.objects.create_user('sys', '', '123456')
# user.is_active=True
# user.is_supperuser=True
# user.save()
_login = LoginModel.Login()
#from django.conf import settings as st
import SystemConfig
st = SystemConfig.get()
_login.language = request._get_request().get("language",
st.default_language)
if request.GET.has_key("next"):
_login.url_next = request.GET["next"]
if request._get_post().get("site") != None and request._get_post().get(
"site") != "":
_login.url_next = request.GET["next"] + request._get_post().get(
"site")
if request._get_post().keys().__len__() > 0:
username_request = request._get_post().get("username")
password_request = request._get_post().get("password")
try:
from quicky import tenancy
user_login =qmongo.models.auth_user_info.aggregate.project(username=1, login_account=1)\
.match("login_account == @account", account = username_request).get_item()
if user_login == None:
raise (Exception("User was not found"))
ret = authenticate(username=user_login['username'],
password=password_request,
schema=tenancy.get_schema())
if ret.backend != quicky.applications.get_settings(
).AUTHENTICATION_BACKENDS[0]:
raise (Exception("user backend not correctly"))
form_login(request, ret, schema=tenancy.get_schema())
from quicky import language
language.set_language(_login.language)
request.session["language"] = _login.language
return redirect(
request.get_app_url(request._get_post().get("site")))
except Exception as ex:
_login.is_error = True
_login.error_message = request.get_global_res(
"Username or Password is incorrect")
return request.render(_login)
if hasattr(quicky.system_settings,
"SSO_LOGIN_URL") and quicky.system_settings.SSO_LOGIN_URL != "":
return redirect(quicky.system_settings.SSO_LOGIN_URL + "?ret=" +
request.get_app_url(""))
return request.render(_login)
def update():
global cache
if cache.has_key(tenancy.get_schema()):
cache[tenancy.get_schema()] = Config()
else:
lock.acquire()
try:
cache[tenancy.get_schema()] = Config()
lock.release()
except Exception as ex:
lock.release()
logger.debug(ex)
raise (ex)
def get():
global cache
if cache.has_key(tenancy.get_schema()):
return cache[tenancy.get_schema()]
else:
lock.acquire()
try:
cache[tenancy.get_schema()]=Config()
lock.release()
return cache[tenancy.get_schema()]
except Exception as ex:
lock.release()
logger.debug(ex)
raise(ex)
def update(args):
from quicky import tenancy
if args['data'] != None:
try:
lock.acquire()
user_name = args['data']['login_account']
if models.models_per.auth_user_info().aggregate().match(
"_id == {0}", ObjectId(
args['data']['_id'])).get_item() != None:
data = dict(
login_account=args['data']['login_account'],
display_name=args['data']['display_name'],
role_code=(lambda data: data["role_code"]
if data.has_key("role_code") else None)(
args['data']),
email=args['data']['email'],
is_system=(lambda data: data["is_system"]
if data.has_key("is_system") else False)(
args['data']),
never_expire=(lambda data: data["never_expire"]
if data.has_key("never_expire") else False)(
args['data']),
manlevel_from=(lambda data: data["manlevel_from"]
if data.has_key("manlevel_from") else None)(
args['data']),
manlevel_to=(lambda data: data["manlevel_to"]
if data.has_key("manlevel_to") else None)(
args['data']),
mobile=(lambda data: data["mobile"]
if data.has_key("mobile") else None)(args['data']),
description=(lambda data: data["description"]
if data.has_key("description") else None)(
args['data']))
if args['data']['change_password'] != None and args['data'][
'change_password'] == True:
rs_check = check_password(args['data']['password'],
user_name)
if not rs_check['result']:
u = User.objects.get(username=args['data']['username'])
u.set_password(args['data']['password'])
u.save(schema=tenancy.get_schema())
else:
lock.release()
return rs_check
ret = models.models_per.auth_user_info().update(
data, "username == {0}", args['data']['username'])
lock.release()
return ret
lock.release()
return None #Already account
except Exception as ex:
logger.debug(ex)
lock.release()
raise (ex)
return None
def login(request):
#try:
# sys_user=User.objects.get(username="******")
#except ObjectDoesNotExist as ex:
# user = User.objects.create_user('sys', '', '123456')
# user.is_active=True
# user.is_supperuser=True
# user.save()
_login=models.Login()
_login.language=request._get_request().get("language","en")
if request.GET.has_key("next"):
_login.url_next=request.GET["next"]
if request._get_post().get("site") != None and request._get_post().get("site") != "":
_login.url_next= request.GET["next"] + request._get_post().get("site")
request.session["language"] = _login.language
if request._get_post().keys().__len__()>0:
username_request=request._get_post().get("username")
password_request=request._get_post().get("password")
try:
from quicky import tenancy
user_login = auth_user_info().aggregate().project(username=1, login_account=1)\
.match("login_account == @account", account = username_request).get_item()
if user_login==None:
raise (Exception("User was not found"))
ret=authenticate(username=user_login['username'], password=password_request,schema=tenancy.get_schema())
form_login(request,ret,schema=tenancy.get_schema())
return redirect(request.get_app_url(request._get_post().get("site")))
except Exception as ex:
_login.is_error=True
_login.error_message=request.get_global_res("Username or Password is incorrect")
return request.render(_login)
return request.render(_login)
def clear_cache():
global cache
lock.acquire()
try:
del cache[tenancy.get_schema()]
lock.release()
except Exception as ex:
lock.release()
logger.debug(ex)
raise (ex)
def clear_cache():
global cache
lock.acquire()
try:
cache[tenancy.get_schema()]=None
lock.release()
except Exception as ex:
lock.release()
logger.debug(ex)
raise(ex)
def download_excel(request, path):
from .api import categories
from quicky import tenancy
from qexcel import export_excel
coll = categories.get_coll(path)
qr = coll().aggregate()
ret = export_excel.do_export(request.get_language(), application.name,
tenancy.get_schema(),
coll()._model.name, qr)
return ret
def login(request):
#try:
# sys_user=User.objects.get(username="******")
#except ObjectDoesNotExist as ex:
# user = User.objects.create_user('sys', '', '123456')
# user.is_active=True
# user.is_supperuser=True
# user.save()
_login = models.Login()
_login.language = request._get_request().get("language", "en")
if request.GET.has_key("next"):
_login.url_next = request.GET["next"]
if request._get_post().get("site") != None and request._get_post().get(
"site") != "":
_login.url_next = request.GET["next"] + request._get_post().get(
"site")
request.session["language"] = _login.language
if request._get_post().keys().__len__() > 0:
username_request = request._get_post().get("username")
password_request = request._get_post().get("password")
try:
from quicky import tenancy
user_login = auth_user_info().aggregate().project(username=1, login_account=1)\
.match("login_account == @account", account = username_request).get_item()
if user_login == None:
raise (Exception("User was not found"))
ret = authenticate(username=user_login['username'],
password=password_request,
schema=tenancy.get_schema())
form_login(request, ret, schema=tenancy.get_schema())
return redirect(
request.get_app_url(request._get_post().get("site")))
except Exception as ex:
_login.is_error = True
_login.error_message = request.get_global_res(
"Username or Password is incorrect")
return request.render(_login)
return request.render(_login)
def __init__(self, qr, name):
# type: (QR,str) -> NotImplemented
"""
Create instance of COLL
:param qr:
:param name:
"""
self.name = ""
self.qr = None
self._where = None
self._entity = None
self._none_schema_name = None
self._none_schema_name = name
import threading
if hasattr(threading.currentThread(),
"tenancy_code") and tenancy.get_schema() != "":
self.name = tenancy.get_schema() + "." + name
else:
self.name = name
self._model = get_model(name)
self.qr = qr
def update(args):
from quicky import tenancy
if args['data'] != None:
try:
lock.acquire()
user_name = args['data']['login_account']
if models.auth_user_info().aggregate().match("_id == {0}", ObjectId(args['data']['_id'])).get_item() != None:
data = dict(
login_account = args['data']['login_account'],
display_name = args['data']['display_name'],
role_code = (lambda data: data["role_code"] if data.has_key("role_code") else None)(args['data']),
email = args['data']['email'],
is_system = (lambda data: data["is_system"] if data.has_key("is_system") else False)(args['data']),
never_expire = (lambda data: data["never_expire"] if data.has_key("never_expire") else False)(args['data']),
manlevel_from = (lambda data: data["manlevel_from"] if data.has_key("manlevel_from") else None)(args['data']),
manlevel_to = (lambda data: data["manlevel_to"] if data.has_key("manlevel_to") else None)(args['data']),
mobile = (lambda data: data["mobile"] if data.has_key("mobile") else None)(args['data']),
description = (lambda data: data["description"] if data.has_key("description") else None)(args['data'])
)
ret = models.auth_user_info().update(
data,
"username == {0}",
args['data']['username'])
if args['data']['change_password'] != None and args['data']['change_password'] == True:
u = User.objects.get(username=args['data']['username'])
u.set_password(args['data']['password'])
u.save(schema=tenancy.get_schema())
lock.release()
return ret
lock.release()
return None #Already account
except Exception as ex:
logger.debug(ex)
lock.release()
raise(ex)
return None
def login(request):
from django.contrib.auth.models import User
try:
sys_user = User.objects.get(username='******',
schema=tenancy.get_schema())
sys_user.is_staff = True
sys_user.is_superuser = True
sys_user.save(schema=tenancy.get_schema())
except Exception as ex:
user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******',
schema=tenancy.get_schema())
user.is_staff = True
user.is_superuser = True
user.save(schema=tenancy.get_schema())
_login = {"username": "", "password": "", "language": "en", "next": ""}
_login["language"] = request._get_request().get("language", "en")
request.set_language(_login["language"])
if dict_utils.has_key(request.GET, "next"):
_login["next"] = request.GET.get("next", request.get_app_url(""))
request.session["language"] = _login["language"]
if request._get_post().keys().__len__() > 0:
_login["username"] = request._get_post().get("username", "")
_login["password"] = request._get_post().get("password", "")
_login["language"] = request._get_post().get("language", "en")
user = authenticate(username=request._get_post().get("username", ""),
password=request._get_post().get("password", ""),
schema=tenancy.get_schema())
if user == None:
_login.update(
dict(error=dict(message=request.get_global_res(
"Username or Password is incorrect"))))
return request.render(_login)
else:
request_login(request, user, schema=tenancy.get_schema())
return redirect(_login["next"])
return request.render(_login)