def put_user(user_id):
db_user = db.session.query(Users).get(user_id)
if db_user is None:
return render_template(
'user/list.html',
users=db.session.query(Users).order_by(Users.id).all(),
errors=u'Пользователя с id=%s не существует' % user_id)
db_roles = db.session.query(Roles).all()
radio_roles = [(role.id, role.name) for role in db_roles]
form = EditUserForm(login=db_user.login)
form.role.choices = radio_roles
if form.validate_on_submit():
password = form.password.data.strip()
if password:
user = User(form.login.data.strip(), form.password.data.strip())
db_user.password = user.pw_hash
else:
user = User(form.login.data.strip())
if db_user.login != user.login and db.session.query(Users).filter(
Users.login == user.login).count() > 0:
return render_template(
'user/edit.html',
errors=[
u'Пользователь с логином <b>%s</b> уже существует' %
user.login
],
form=form)
db_user.login = user.login
db_role = db.session.query(Roles).get(form.role.data)
db_user.roles[0] = db_role
db.session.commit()
flash(u'Пользователь изменен')
return redirect(url_for('users'))
return render_template('user/edit.html', form=form, user=db_user)
def post_user():
# create a new user
db_roles = db.session.query(Roles).all()
radio_roles = [(role.id, role.name) for role in db_roles]
form = EditUserForm()
form.role.choices = radio_roles
if form.validate_on_submit():
user = User(form.login.data.strip(), form.password.data.strip())
if db.session.query(Users).filter(
Users.login == user.login).count() > 0:
return render_template(
'user/edit.html',
errors=[
u'Пользователь с логином <b>%s</b> уже существует' %
user.login
],
form=form)
db_user = Users(user.login, user.pw_hash)
db_role = db.session.query(Roles).get(form.role.data)
db_user.roles.append(db_role)
db.session.add(db_user)
db.session.commit()
flash(u'Пользователь добавлен')
return redirect(url_for('users'))
return render_template('user/edit.html', form=form)
def get_updated_settings(args):
settings = Settings.load()
u = User(user=args.user, password=args.password)
s = XcodeServer(host=args.host, port=args.port)
settings.update(s, u)
settings.validate()
return settings
def index(self, param):
"""
ページの処理
"""
username = self.form_data.getvalue('username', '')
password = self.form_data.getvalue('password', None)
mode = self.form_data.getvalue('mode')
login = False
redirect = False
login_failed = False
if not username.isalnum():
username = ''
if self.session.getvalue('login', False):
login = True
elif mode == 'login':
login_failed = True
user = User()
if user.login(username, password,
self.setting['password']['salt']):
# ログイン成功
self.session.setvalue('login', True)
self.session.setvalue('user_id', user.getvalue('id'))
redirect = True
# テンプレ―ト用データ
template_data = {}
template_data['mode'] = mode
template_data['redirect'] = redirect
template_data['login'] = login
template_data['login_failed'] = login_failed
template_data['username'] = username
return self.template(template_data)
def login():
# login form that uses Flask-WTF
form = LoginForm()
errors = list()
# Validate form input
if form.validate_on_submit():
# Retrieve the user from the hypothetical datastore
user = db.session.query(Users).filter(
Users.login == form.login.data.strip()).first()
if user:
check_user = User(user.login)
# Compare passwords (use password hashing production)
if check_user.check_password(form.password.data.strip(),
user.password):
# Keep the user info in the session using Flask-Login
login_user(user)
# Tell Flask-Principal the identity changed
identity_changed.send(current_app._get_current_object(),
identity=Identity(user.id))
return redirect(request.args.get('next') or url_for('index'))
else:
errors.append(u'Неверная пара логин/пароль')
else:
errors.append(u'Нет пользователя с логином <b>%s</b>' %
form.login.data.strip())
return render_template('user/login.html', form=form, errors=errors)
def new_user():
data = request.get_json()
data = data['user']
email = data['email']
password_hash = bcrypt.generate_password_hash(data['password'])
# save user in database
save_user = User()
user_id = save_user.save(email, password_hash)
trxn = TransactionUtil(user_id)
trxn_success = trxn.create_basic_profile()
trxn_accounts = trxn.get_account_information()
# login user
if user_id is None:
auth_token = None
user = None
success = False
# return token
else:
auth_token = save_user.generate_auth_token(user_id)
user = save_user.get_user_from_id(user_id)
success = True
ret_val = {
"success": success,
"trxn_succes": trxn_success,
"token": auth_token,
"user": user,
"accounts": trxn_accounts
}
return jsonify(ret_val)
def verify_token(token):
user = User()
user_info = user.verify_token(token)
if user_info:
setattr(g, 'user', user_info)
return True
else:
return False
def getUsers(self):
users = []
with open(userDir, "r") as json_file:
data = json.load(json_file)
for u in data['user']:
object = User(u['username'], u['email'], u['password'], u['name'],
u['role'])
users.append(object)
return users
def inner(*a, **kw):
username = request.params.get('username') or kw.get('username')
password = request.params.get('password')
if username is None or password is None:
raise AuthenticationError
user = User(username)
if not user.password_auth(password):
raise AuthenticationError
return func(user=user, *a, **kw)
def inner(*a, **kw):
id_ = request.params.get('id') or kw.get('id_')
password = request.params.get('password')
if id_ is None or password is None:
raise AuthenticationError
user = User(id_)
if not user.password_auth(password):
raise AuthenticationError
return func(user=user, *a, **kw)
def post(self):
userid = self.get_argument('userid')
data = json.loads(self.request.body.decode())
publickey_pem = data.get('publickey', None)
privatekey_pem = data.get('privatekey', None)
meta = data.get('meta', None)
user = User(userid, publickey_pem, privatekey_pem=privatekey_pem,
services=data['services'], meta=meta)
ioloop.IOLoop.current().add_callback(partial(userprocess, user))
self.api_response("OK")
def auth_user():
user_id = g.user['id']
user = User()
user_info = user.get_user_from_id(user_id)
trxn = TransactionUtil(user_id)
trxn_accounts = trxn.get_account_information()
ret_val = {"user": user_info, "accounts": trxn_accounts}
return jsonify(ret_val)
def login_user():
data = request.get_json()
data = data['user']
user = User()
pw_hash = user.get_password_hash(data['email'])
validate = bcrypt.check_password_hash(pw_hash, data['password'])
user_info = user.get_user_from_email(data['email'])
token = user.generate_auth_token(user_info['id'])
ret_val = {"success": validate, "token": token, "user": user_info}
return jsonify(ret_val)
def register_users(self):
for _ in range(int(self.number_of_users)):
user = User(name=fake.user_name(),
password=fake.password(length=16,
special_chars=True,
digits=True,
upper_case=True,
lower_case=True),
email=fake.email())
code, data = user.sing_up(self.url + 'api/users/')
if code == 201:
self.users.append(user)
return self.users
def edit_profile():
data = request.get_json()
data = data['profile']
profile = ProfilePipeline()
save = profile.run([data])
user = User()
user_info = user.get_user_from_id(g.user['id'])
g.user = user_info
ret_val = {"success": save, "user": user_info}
return jsonify(ret_val)
def __init__(self, addr, port):
RPCServer.__init__(self, addr, port, user=User())
self._sandbox = Sandbox()
locks = []
for _ in range(LOCK_MAX):
locks.append(Lock())
self._locks = HashRing(locks)
self._cache = {}
if DEBUG:
self._register_cnt = 0
self._login_cnt = 0
self._upload_cnt = 0
self._install_cnt = 0
self._uninstall_cnt = 0
def show_number(self, ggnumber):
if FileManager.has_history(ggnumber):
sql = SQL()
query = 'select * from users where ggnumber=:ggnumber;'
ret = sql.execute(query, {'ggnumber': ggnumber})
row = ret.fetchone()
user = User(row, ggnumber)
view = UserView(user)
self.clear()
view()
else:
self.refresh()
ROText(1, 0, u'Nie znaleziono histori dla podanego numeru.',
u'Błąd').run()
def __call__(self, args):
self._args = args
try:
with open(self._args.config_file) as f:
self._settings = yaml.load(f, yaml.SafeLoader)
except Exception as e:
self._parser.error(
"Failed in loading the settings.yml file:{}".format(e))
self._logger = Logger(self._settings["logs_locations"])
self._database = Database(self._settings, self._parser, self._logger)
self._user = User(self._settings["okta_token"],
self._settings["okta_organization_url"])
self._group = Group(self._settings["okta_token"],
self._settings["okta_organization_url"])
self._change_policy = ChangePolicy(self._settings, self._user,
self._group)
self._run_risk_score_monitor()
def index(self, param):
"""
ページの処理
"""
probs = get_problems()
users = {}
for p in probs:
print(p.items())
user_id = p.getvalue('user_id', None)
if user_id and not user_id in users.keys():
users[user_id] = User(user_id)
# テンプレ―ト用データ
template_data = {}
template_data['problems'] = probs
template_data['users'] = users
return self.template(template_data)
def regist_user(self, username, password):
"""
登録
"""
user = User(username=username)
if user.exist():
return USER_EXIST
user.setvalue('username', username)
user.setvalue('nickname', u'名無し')
user.reset_hash()
if not user.reset_password(new_password=password,
salt=self.setting['password']['salt'],
force=True):
return PASSWORD_ERROR
if user.insert():
self.user = user
return REGIST_CORRECT
return OTHER_ERROR
def index(self, param):
"""
ページの処理
"""
login = self.session.getvalue('login', False)
user_id = self.session.getvalue('user_id', '-1')
mode = self.form_data.getvalue('mode')
reset_hash = self.form_data.getvalue('reset_hash', '') == 'reset'
nickname = unicode(self.form_data.getvalue('nickname', ''), 'utf-8')
edit_status = EDIT_NONE
userid = ''
userhash = ''
user = User(user_id)
if login:
if mode == 'pass_update':
old_password = self.form_data.getvalue('old_password', '')
new_password = self.form_data.getvalue('new_password', '')
retype_password = self.form_data.getvalue(
'retype_password', '')
if new_password == retype_password:
if user.reset_password(old_password, new_password,
self.setting['password']['salt']):
edit_status = EDIT_CORRECT
else:
edit_status = EDIT_FAILED
elif mode == 'update':
if reset_hash:
user.reset_hash()
if nickname != '':
user.setvalue('nickname', nickname)
edit_status = EDIT_CORRECT
user.update()
# テンプレ―ト用データ
template_data = {}
template_data['login'] = login
template_data['userid'] = str(user.getvalue('id', -1))
template_data['username'] = user.getvalue('username', '')
template_data['nickname'] = user.getvalue('nickname', '')
template_data['userhash'] = user.getvalue('hash', '')
template_data['mode'] = mode
template_data['edit_status'] = edit_status
return self.template(template_data)
def index(self, param):
"""
ページの処理
"""
mode = self.form_data.getvalue('mode')
username = self.form_data.getvalue('username')
password = self.form_data.getvalue('password')
login = self.session.getvalue('admin', False)
enable = self.setting['admin']['enable'] == 'On'
users = []
login_faled = False
if enable:
if mode == 'login':
if username == self.setting['admin'][
'user'] and password == self.setting['admin']['pass']:
self.session.setvalue('admin', True)
login = True
else:
login_faled = True
elif mode == 'logout':
self.session.delvalue('admin')
login = False
elif mode == 'reset_password':
user = User(username)
user.reset_password(new_password=password,
salt=self.setting['password']['salt'],
force=True)
user.update()
if login:
users = self.dba.select('user_tbl', '*')
# テンプレ―ト用データ
template_data = {}
template_data['enable'] = enable
template_data['login'] = login
template_data['login_failed'] = login_faled
template_data['users'] = users
return self.template(template_data)
def get(self):
showid = self.get_argument('showtime_id')
shares = self.get_arguments('share')
passphrase = self.get_argument('passphrase', None)
reprocess = bool(self.get_argument('reprocess', None) is not None)
ticket_api = CONFIG.get('ticket_api')
# we could also just pass the raw arguments, but this is more explicit
# and 'self documenting'
params = [('showtime_id', showid)]
if passphrase:
params += [('passphrase', passphrase)]
elif shares:
params += [('share', s) for s in shares]
url = url_concat(ticket_api + '/api/showtimes/access_tokens', params)
show_data_raw = yield httpclient.fetch(url, request_timeout=180)
if show_data_raw.code != 200:
return self.error(show_data_raw.code, show_data_raw.body)
exhibitperms = yield ExhibitPermissions.get_global()
show_data = json.loads(show_data_raw.body)
show_date = show_data['data']['date']
users_added = []
for user_data in show_data['data']['users']:
userid = user_data.pop('id')
perms = yield exhibitperms.get_permissions(userid)
if perms and not reprocess:
users_added.append({'userid': userid,
'permissions': perms,
'process': False})
publickey = user_data['publickey']
privatekey = user_data.get('privatekey')
meta = user_data.get('meta') or {}
meta.update({'showid': showid, 'permissions': perms,
'showdate': show_date})
user = User(userid, publickey, services=user_data['services'],
privatekey_pem=privatekey, meta=meta)
users_added.append({'userid': userid, 'process': True})
ioloop.IOLoop.current().add_callback(partial(userprocess, user))
return self.api_response(users_added)
def fetch_user():
data = request.get_json()
user = User()
user_info = user.get_user_from_id(data['user_id'])
ret_val = {"user": user_info}
return jsonify(ret_val)
def update_users():
for r in request.get_json()['users']:
usersMap[r['name']] = User(r['name'], r['port'], r['public'].encode())
return jsonify({'status': 'users have been updated successful'})
def get_settings(args):
u = User(user=args.user, password=args.password)
s = XcodeServer(host=args.host, port=args.port)
return Settings(s, u)
import socket
import json
from lib.action import Action
from lib.user import User
HOST = "localhost"
PORT = 7777
serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serverSocket.bind((HOST, PORT))
serverSocket.listen()
conn, addr = serverSocket.accept()
data = json.loads(conn.recv(1024))
action = Action(data["type"], User(data["target"]["nickname"]))
if action.type == "SIGNIN":
print("User has logged in")
conn.send(Action("Success").toJSON().encode())
print("Client sent:", data)
print("SERVER FINESHED")
# ~~~~~~~~~~~~~~~~~~~~~~ import modules ~~~~~~~~~~~~~~~~~~~~~~
from tkinter import Tk
from win.main_page import MainPage
from lib.user import User
# ~~~~~~~~~~~~~~~~~~~~~~ globsl variables ~~~~~~~~~~~~~~~~~~~~~~
monospaced_font = 'Consolas'
font = 'Helvetica'
# ~~~~~~~~~~~~~~~~~~~~~~ main programme ~~~~~~~~~~~~~~~~~~~~~~
# TEMP SETTING UP THE User
user = User('Portmoor')
#user = User('Test')
# creating tkinter window
root = Tk()
root.title(user.company_name)
root.iconbitmap(user.company_icon)
root.configure(bg=user.window_bg_colour)
root.minsize(user.root_window_width, user.root_window_height)
# add root to windows
user.root = root
# adding menu bar to the root window
MainPage.standard_menubar(user)
import lib.rsa as RSA
import lib.ecc as ECC
from lib.dh import DH_Wrapper
from lib.fernet import FRNET_Wrapper
from lib.user import User
from lib.serial import encode, decode
app = Flask(__name__,
template_folder='UI',
static_url_path='/static',
static_folder='UI/static')
CA_HOST, CA_PORT = 'localhost', 5000
currentUser = User('', 0)
mailbox = []
usersMap = {}
@app.route("/mailbox/<ciphertext>")
def receive_msg(ciphertext):
print(ciphertext)
mailbox.append(currentUser.decrypt(ciphertext))
return jsonify({'status': 'Message received'})
@app.route("/broadcast/<message>")
def broadcast_msg(message):
def fetch_all_users():
user = User()
all_users = user.get_all_users()
ret_val = {"all_users": all_users}
return jsonify(ret_val)
