def test_insert(self):
dao = UserDAO(self._conn, users)
user = {
'name': 'Flavio',
'fullname': 'Flavio Fernandes',
}
dao.insert(user)
def createUser():
userDAO = UserDAO()
user = User()
user.username = "******"
user.password = "******"
group = Group()
group.grouName = "admin"
group.addUser(user)
userDAO.save(user)
def test_save_and_get(connection_pool, test_table_name):
_log.info(f'Started test with table name {test_table_name}')
dao = UserDAO(connection_pool, test_table_name)
dao.save(User('Pavel Andreievich Chekov', 15, 21))
# coordinates are specified as degrees of lat and long, distance is measured in meters
expected_result = [SearchResult('Pavel Andreievich Chekov', 15, 21, 442977.30004328)]
actual_result = dao.get_nearest(15, 25)
assert actual_result == expected_result
def test_sorting(connection_pool, test_table_name):
_log.info(f'Started test with table name {test_table_name}')
dao = UserDAO(connection_pool, test_table_name)
dao.save(User('Leonard McCoy', 3, 2))
dao.save(User('James Tiberius Kirk', 2, 3))
dao.save(User('Spock', 13, 25))
actual_result = dao.get_nearest(5, 8)
assert \
[i.username for i in actual_result] == \
['James Tiberius Kirk', 'Leonard McCoy', 'Spock']
def self_sign_up(user_id=None):
"""
:param user_id: 'sub' field from Google id_token supplied in header Authenticate: Bearer <id_token>
:return: OK
"""
user = get_user_from_id_token(request.headers['Authorization'].split(" ")[1])
returned_code = UserDAO.set(user)
if returned_code == 0:
data = {
"code": 200,
"fields": "",
"message": "OK"
}
js = json.dumps(data)
resp = Response(js, status=200, mimetype='application/json')
resp.headers['Content-Type'] = 'application/json; charset=utf-8'
else:
data = {
"code": 400,
"fields": "string",
"message": "Malformed Data"
}
js = json.dumps(data)
resp = Response(js, status=400, mimetype='application/json')
resp.headers['Content-Type'] = 'application/json; charset=utf-8'
return resp
def test_select(self):
dao = UserDAO(self._conn, users)
user = {
'name': 'Flavio',
'fullname': 'Flavio Fernandes',
}
dao.insert(user)
users_list = dao.list()
_, name, fullname = users_list[0]
self.assertEqual(1, len(users_list))
self.assertEqual('Flavio', name)
self.assertEqual('Flavio Fernandes', fullname)
def handle_hmac(username, auth, data):
with open('config.json') as f:
config = json.load(f)
obj = json.loads(data)
if not obj["username"] == username:
return forbidden, 403
if (round(time.time()/1000) - obj["timestamp"]) > 10:
return forbidden, 403
conn = mysql.connector.connect(**config["db_config"])
dao = UserDAO(conn)
user = dao.do_retrieve(obj["username"], config["salt"])
if not user:
return forbidden, 403
if not user.verify(auth, data):
return forbidden, 403
token = b2a_hex(os.urandom(64))
dao.do_update_token(user, token)
conn.close()
cred = { "username": user.username, "level": user.level, "timestamp": round(time.time()/1000), "token": token }
cookie = "credential=username:{0}|level:{1}|timestamp:{2}|token:{3}".format(cred["username"], cred["level"], cred["timestamp"], cred["token"])
headers = { "Set-Cookie": "{}; Max-Age=3600; Path=/;".format(cookie) }
return flask.Response(json.dumps(cred), mimetype="application/json", headers=headers)
def test_replace(connection_pool, test_table_name):
_log.info(f'Started test with table name {test_table_name}')
dao = UserDAO(connection_pool, test_table_name)
dao.save(User('Pavel Andreievich Chekov', 15, 21))
dao.save(User('Pavel Andreievich Chekov', 1, 1))
# coordinates are specified as degrees of lat and long, distance is measured in meters
expected_result = [SearchResult('Pavel Andreievich Chekov', 1, 1, 553912.06108329)]
actual_result = dao.get_nearest(4, 5)
assert actual_result == expected_result
def create_user(user_id=None):
"""
Create new user from json object
:param user_id:
:return:
"""
if request.headers['Content-Type'] == 'application/json':
dict_data = {
'userID': 0,
'firstName': "",
'lastName': "",
'email': "",
'phone': "",
'userStatus': 0
}
dict_data1 = request.json
dict_data.update(dict_data1)
user = User(dict_data)
else:
data = {
"code": 400,
"fields": "Content-Type",
"message": "Malformed Data"
}
js = json.dumps(data)
resp = Response(js, status=400, mimetype='application/json')
resp.headers['Content-Type'] = 'application/json; charset=utf-8'
return resp
returned_code = UserDAO.set(user)
if returned_code == 0:
data = {
"code": 200,
"fields": "",
"message": "OK"
}
js = json.dumps(data)
resp = Response(js, status=200, mimetype='application/json')
resp.headers['Content-Type'] = 'application/json; charset=utf-8'
else:
data = {
"code": 400,
"fields": "returned_code",
"message": "Malformed Data"
}
js = json.dumps(data)
resp = Response(js, status=400, mimetype='application/json')
resp.headers['Content-Type'] = 'application/json; charset=utf-8'
return resp
class UserService:
def __init__(self):
self.global_model_dao = GlobalModelDAO()
self.local_model_dao = LocalModelDAO()
self.session_dao = SessionDAO()
self.user_dao = UserDAO()
def create_user(self, email, password, name="default"):
user_po = po_creator.create_user_po()
user_po.pop("_id")
user_po.update({'email': email, 'password': password, 'name': name})
return self.user_dao.insert_one(user_po)
@check_session
def remove_user(self, session_id, user_id):
return self.user_dao.delete_one_by_id(user_id)
def update_user(self,
session_id,
user_id,
email=None,
password=None,
name=None):
user_po = self.user_dao.find_one_by_id(user_id)
user_po.update({
'email': email if email else user_po['email'],
'password': email if password else user_po['password'],
'name': email if name else user_po['name'],
})
return self.user_dao.replace_one_by_id(user_id, user_po)
def find_one_user_by_id(self, session_id):
user_id = self.session_dao.find_one_by_id(session_id)['user_id']
return self.user_dao.find_one_by_id(user_id)
def create_session(self, user_id, password):
user_po = self.user_dao.find_one_by_id(user_id)
if not user_po['password'] == password:
return None
session_po = po_creator.create_session_po()
session_po.pop('_id')
session_po.update({'user_id': user_id, 'created_time': time.time()})
inserted_id = self.session_dao.inert_one(session_po)
return inserted_id
def find_one_session_by_id(self, session_id):
return self.session_dao.find_one_by_id(session_id)
def get_user_by_id(uid, user_id=None):
"""
Get complete user data
:param uid: ID of a user to get
:param user_id: ID of the logged on user
:return: user_data
"""
result = UserDAO.get(uid)
if result != 1:
user = result.get_dict()
js = json.dumps(user)
user_data = Response(js, status=200, mimetype='application/json')
resp = user_data
resp.headers['Content-Type'] = 'application/json; charset=utf-8'
else:
data = {
"code": 404,
"fields": "string",
"message": "Not Found"
}
js = json.dumps(data)
resp = Response(js, status=404, mimetype='application/json')
resp.headers['Content-Type'] = 'application/json; charset=utf-8'
return resp
def __init__(self):
self.global_model_dao = GlobalModelDAO()
self.local_model_dao = LocalModelDAO()
self.session_dao = SessionDAO()
self.user_dao = UserDAO()
class GlobalModelService:
def __init__(self):
self.global_model_dao = GlobalModelDAO()
self.local_model_dao = LocalModelDAO()
self.session_dao = SessionDAO()
self.user_dao = UserDAO()
def create_global_model(self,
session_id,
name="default",
version="0",
type="default",
status="default",
description="default"):
user_id = self.session_dao.find_one_by_id(session_id).get('user_id')
if not user_id:
return None
global_model_po = po_creator.create_global_model_po()
global_model_po.pop("_id", None)
global_model_po.update({
"name": name,
"version": version,
"type": type,
"status": status,
"description": description
})
global_model_id = self.global_model_dao.insert_one(global_model_po)
user_po = self.user_dao.find_one_by_id(user_id)
user_po['global_model_ids'].append(global_model_id)
self.user_dao.replace_one_by_id(user_id, user_po)
return global_model_id
def update_global_model(self,
session_id,
global_model_id,
name=None,
version=None,
type=None,
status=None,
description=None):
user_id = self.session_dao.find_one_by_id(session_id).get('user_id')
if not user_id:
return None
if global_model_id not in self.user_dao.find_one_by_id(
user_id)['global_model_ids']:
return None
global_model_po = self.global_model_dao.find_one_by_id(global_model_id)
global_model_po.update({
"name":
name if name else global_model_po.name,
"version":
version if version else global_model_po.version,
"type":
type if type else global_model_po.type,
"status":
status if status else global_model_po.status,
"description":
description if description else global_model_po.description,
})
return self.global_model_dao.replace_one_by_id(global_model_id,
global_model_po)
def find_one_global_models_by_id(self, session_id, global_model_id):
user_id = self.session_dao.find_one_by_id(session_id).get('user_id')
if not user_id:
return None
global_model = self.global_model_dao.find_one_by_id(global_model_id)
global_model = json_util.dumps(global_model)
return global_model
@check_session
def find_all_global_models(self, session_id):
global_model_pos = self.global_model_dao.find_many_by_criteria({})
global_model_pos = json_util.dumps(global_model_pos)
return global_model_pos
def remove_global_model(self, session_id, global_model_id):
user_id = self.session_dao.find_one_by_id(session_id)['user_id']
if global_model_id in self.user_dao.find_one_by_id(
user_id)["global_model_ids"]:
user_po = self.user_dao.find_one_by_id("user_id")
user_po['global_model_ids'].pop(global_model_id)
self.user_dao.replace_one_by_id(user_id, user_po)
global_model_po = self.global_model_dao.find_one_by_id(
global_model_id)
local_model_ids = global_model_po['local_model_ids']
for local_model_id in local_model_ids:
self.local_model_dao.delete_one_by_id(local_model_id)
self.global_model_dao.delete_one_by_id(global_model_id)
else:
return None
def insert_subscribe_global_model(self, session_id, global_model_id,
address, condition):
user_id = self.session_dao.find_one_by_id(session_id)['user_id']
if not user_id:
return None
global_model = self.global_model_dao.find_one_by_id(global_model_id)
return self.global_model_dao.replace_one_by_id(global_model_id,
global_model)
def remove_subscribe_global_model(self, session_id, global_model_id,
address, condition):
user_id = self.session_dao.find_one_by_id(session_id)['user_id']
if not user_id:
return None
global_model = self.global_model_dao.find_one_by_id(global_model_id)
global_model['subscriptions'].remove({
"user_id": user_id,
"address": address,
"condition": condition
})
return self.global_model_dao.replace_one_by_id(global_model_id,
global_model)
def insert_label_global_model(self, session_id, global_model_id, key,
value):
user_id = self.session_dao.find_one_by_id(session_id)['user_id']
if global_model_id not in self.user_dao.find_one_by_id(user_id):
return None
global_model = self.global_model_dao.find_one_by_id(global_model_id)
global_model['labels'][key] = value
return self.global_model_dao.replace_one_by_id(global_model_id,
global_model)
def remove_label_global_model(self, session_id, global_model_id, key):
user_id = self.session_dao.find_one_by_id(session_id)['user_id']
if global_model_id not in self.user_dao.find_one_by_id(user_id):
return None
global_model = self.global_model_dao.find_one_by_id(global_model_id)
global_model['labels'].pop(key)
return self.global_model_dao.replace_one_by_id(global_model_id,
global_model)
def upload_global_model_file(self, session_id, global_model_id,
file_upload):
file = file_upload.file
user_id = self.session_dao.find_one_by_id(session_id)['user_id']
if not user_id:
return None
file_id = self.global_model_dao.insert_file_one(file)
global_model = self.global_model_dao.find_one_by_id(global_model_id)
global_model['file_id'] = file_id
self.global_model_dao.replace_one_by_id(global_model_id, global_model)
return file_id
def download_global_model_file(self, session_id, global_model_id):
user_id = self.session_dao.find_one_by_id(session_id)['user_id']
if not user_id:
return None
file_id = self.global_model_dao.find_one_by_id(
global_model_id)['file_id']
return self.global_model_dao.find_file_one_by_id(file_id)
#!/usr/bin/env python3
from argparse import ArgumentParser, FileType
from configparser import ConfigParser
from psycopg_pool import ConnectionPool
from api import Api
from dao import UserDAO
parser = ArgumentParser()
parser.add_argument('--config',
nargs='?',
type=FileType('r'),
default=open('config.ini'),
help='Path to config file, default is config.ini')
if __name__ == '__main__':
args = parser.parse_args()
config = ConfigParser()
config.read_file(args.config)
# TODO get pool parameters from configuration file
connection_pool = ConnectionPool(config['database']['conninfo'])
user_dao = UserDAO(connection_pool)
api = Api(user_dao)
api.app.run(config.get('http', 'host'), config.getint('http', 'port'))
def get_users(config): conn = mysql.connector.connect(**config["db_config"]) dao = UserDAO(conn) conn.close() return dao.do_retrieve_all()
import config
from model import Movie, Series, User
from dao import MovieDAO, SeriesDAO, UserDAO
import db_connection
from flask import Flask, render_template, request, session, redirect, url_for
app = Flask(__name__)
app.secret_key = 'jooj'
# ---------- Objetos de conexão com o banco ----------
movie_dao = MovieDAO(db_connection.session)
series_dao = SeriesDAO(db_connection.session)
user_dao = UserDAO(db_connection.session)
@app.route('/')
def home():
if 'user_logged' in session:
return render_template('index.html')
return redirect(url_for('login'))
@app.route('/login')
def login():
next = request.args.get('next')
return render_template('login.html')
@app.route('/signin')
def signin():
next = request.args.get('next')
from mysql.connector import connection, Error
import bcrypt
from models import User
from dao import UserDAO, AuthDAO
import configparser
usrs = [
(("Will", "Cravitz", "*****@*****.**"), ("pass")),
(("Vedant", "Pathak", "*****@*****.**"), ("pass")),
]
for usr, pass_ in usrs:
UserDAO.insert_user(usr[0], usr[1], usr[2])
id = UserDAO.get_user_by_email(usr[2])
AuthDAO.insert_hash(bcrypt.hashpw(id, pass_.encode("utf-8")))
class LocalModelService:
def __init__(self):
self.global_model_dao = GlobalModelDAO()
self.local_model_dao = LocalModelDAO()
self.session_dao = SessionDAO()
self.user_dao = UserDAO()
def create_local_model(self, session_id, global_model_id, message="default"):
user_id = self.session_dao.find_one_by_id(session_id).get('user_id')
if not user_id:
return None
local_model_po = po_creator.create_local_model_po()
local_model_po.pop("_id")
local_model_po.update({
"message": message
})
local_model_id = self.local_model_dao.insert_one(local_model_po)
global_model = self.global_model_dao.find_one_by_id(global_model_id)
global_model['local_model_ids'].append(local_model_id)
self.global_model_dao.replace_one_by_id(global_model_id, global_model)
user_po = self.user_dao.find_one_by_id(user_id)
user_po['local_model_ids'].append(local_model_id)
self.user_dao.replace_one_by_id(user_id, user_po)
return local_model_id
def remove_local_model(self, session_id, local_model_id):
user_id = self.session_dao.find_one_by_id(session_id).get('user_id')
if not user_id:
return None
result = self.local_model_dao.delete_one_by_id(local_model_id)
global_model_po = self.global_model_dao.find_one_by_local_model_id(local_model_id)['local_model_ids']
global_model_po.pop(
local_model_id)
self.global_model_dao.replace_one_by_id(global_model_po['_id'], global_model_po)
user_po = self.user_dao.find_one_by_id(user_id)
user_po['local_model_ids'].pop(local_model_id)
self.user_dao.replace_one_by_id(user_id, user_po)
return result
@check_session
def find_one_local_model_by_id(self, session_id, local_model_id):
return self.local_model_dao.find_one_by_id(local_model_id)
@check_session
def find_all_local_models_by_global_model_id(self, session_id, global_model_id):
local_model_ids = self.global_model_dao.find_one_by_id(global_model_id)['local_model_ids']
return self.local_model_dao.find_many_by_criteria({"_id": {"$in": local_model_ids}})
@check_session
def insert_label_local_model(self, session_id, local_model_id, key, value):
local_model_po = self.local_model_dao.find_one_by_id(local_model_id)
local_model_po['labels'][key] = value
return self.local_model_dao.replace_one_by_id(local_model_id, local_model_po)
@check_session
def remove_label_local_model(self, session_id, local_model_id, key):
local_model_po = self.local_model_dao.find_one_by_id(local_model_id)
local_model_po['labels'].pop(key)
return self.local_model_dao.replace_one_by_id(local_model_id, local_model_po)
@check_session
def upload_local_model_file(self, session_id, local_model_id, file_upload):
file = file_upload.file
file_id = self.local_model_dao.insert_file_one(file)
local_model_po = self.local_model_dao.find_one_by_id(local_model_id)
local_model_po['file_id'] = file_id
self.local_model_dao.replace_one_by_id(local_model_id, local_model_po)
return file_id
@check_session
def download_local_model_file(self, session_id, local_model_id):
file_id = self.local_model_dao.find_one_by_id(local_model_id)['file_id']
return self.local_model_dao.find_file_one_by_id(file_id)
from datamodels import User from datamodels import Group from dao import UserDAO user = User() user.username = "******" user.password = "******" admin = Group() admin.addUser(user) print(user) userDao = UserDAO() userDao.save()
import os
import time
from flask import render_template, request, session, flash, redirect, url_for, send_from_directory
from app import app, db
from dao import GameDAO, UserDAO
from helpers import get_image_filename, delete_image
from models import Game
game_dao = GameDAO(db)
user_dao = UserDAO(db)
@app.route('/')
def index():
return render_template('list.html',
title='Playroom',
games=game_dao.list())
@app.route('/login')
def login():
next_page = request.args.get('next_page')
return render_template('login.html', title='Login', next_page=next_page)
@app.route('/authenticate', methods=['POST'])
def authenticate():
next_page = request.form['next_page']
user = user_dao.search_by_id(request.form['username'])
from typing import Any
from azure.cognitiveservices.vision.face import FaceClient
from azure.cognitiveservices.vision.face.models import Person, TrainingStatusType
from msrest.authentication import CognitiveServicesCredentials
from config import DefaultConfig
from dao import PeopleDAO, UserDAO
CONFIG = DefaultConfig()
face_client = FaceClient(CONFIG.COGNITIVE_SERVICES_ENDPOINT, CognitiveServicesCredentials(CONFIG.COGNITIVE_SERVICES_KEY))
people_dao = PeopleDAO(face_client=face_client, config=CONFIG)
user_dao = UserDAO(config=CONFIG)
def main(req: func.HttpRequest) -> func.HttpResponse:
logging.info('Python HTTP trigger function processed a request.')
try:
data = req.get_json()
except ValueError as e:
logging.exception(e)
return func.HttpResponse(f'No input', status_code=400)
if parse_data(data):
return func.HttpResponse(f'Operation completed', status_code=200)
else:
return func.HttpResponse(f'Bad data', status_code=400)
from enums import RoleType, CompanyType
from exceptions import (UserAlreadyExistsException, TooMuchEconomistsException,
TooMuchDirectorsException, UserIsNotFoundException,
TooMuchLawyersException)
app = Flask(__name__)
cors = CORS(app)
app.config["JWT_SECRET_KEY"] = "secret-key"
jwt = JWTManager(app)
async_mode = None
socketio = SocketIO(app, async_mode=async_mode, cors_allowed_origins="*")
client = MongoClient(host=os.environ.get('MONGO_HOST', 'localhost'),
port=int(os.environ.get('MONGO_PORT', 27017)))
users = UserDAO(client)
companies = CompanyDAO(client)
documents = DocumentDAO(client)
messages = MessageDAO(client)
versions = VersionDAO(client)
roles = RoleDAO(client)
@app.route('/api/v1/signup/', methods=["POST"])
def signup():
json_data = request.json
username = json_data.get('username', None)
company_id = json_data.get('company_id', None)
role_id = json_data.get('role_id', None)
if not username or not company_id:
return Response(status=400)
