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)