def put(self, id):
parser = reqparse.RequestParser()
parser.add_argument('username', type=str, location='json')
parser.add_argument('password', type=str, location='json')
parser.add_argument('email', type=str, location='json')
parser.add_argument('first_name', type=str, location='json')
parser.add_argument('last_name', type=str, location='json')
parser.add_argument('is_admin', type=bool, location='json')
parser.add_argument('is_active', type=bool, location='json')
args = parser.parse_args()
user_dao = UserDao(self.db_session())
user = user_dao.retrieve(id=id)
if user is None:
return self.error_response('User {} not found'.format(id), http.NOT_FOUND_404)
user.username = args['username']
if args['password'] != '':
user.password = args['password']
user.email = args['email']
user.first_name = args['first_name']
user.last_name = args['last_name']
user.is_admin = args['is_admin']
user.is_active = args['is_active']
user = user_dao.save(user)
return self.response(user.to_dict())
def getUserAccountFromSql(self, userInfo):
userAccountCheck = UserAccountCheck.UserAccountCheck()
userDao = UserDao.UserDao()
userAccountCheck = userDao.getUserAccountCheckFromSql(userInfo)
userAccountCheck.assetAddress = list(
userAccountCheck.assetAddress.split(","))
userAccountCheck.assetAddress.sort()
return userAccountCheck
def get(self, id):
user_dao = UserDao(self.db_session())
user = user_dao.retrieve(id=id)
if user is None:
return self.error_response('User {} not found'.format(id), http.NOT_FOUND_404)
return self.response(user.to_dict())
def updateAsset(self, to):
userDao = UserDao.UserDao()
assetAddressArray = to.assetAddress.split(",")
for assetAddress in assetAddressArray:
to.assetAddress = assetAddress
usertAssetObject = UserAsset.UserAsset()
usertAssetObject = to
userDao.updateAsset(usertAssetObject)
pass
def delete(self, id):
user_dao = UserDao(self.db_session())
user = user_dao.retrieve(id=id)
if user is None:
return self.error_response('User {} not found'.format(id), http.NOT_FOUND_404)
user_dao.delete(user)
return self.response({}, http.NO_CONTENT_204)
def check_login(username, password):
user_dao = UserDao(g.db_session)
user = user_dao.retrieve(username=username)
if user is None:
return None, 'User {} not found'.format(username)
if not user.is_active:
return None, 'User {} no longer active'.format(username)
if user.password != password:
return None, 'Invalid password'
return user, None
def newIssue(self, bossAccount, amount):
userDao = UserDao.UserDao()
issueObject = IssueObject.IssueObject()
issueObject.amount = amount
issueObject.createUserAccountAddress = bossAccount.address
issueObject.sourceId = "wsy_qian_yi_zhuan_yong_bao_wen"
issueObject.content = "{\"wsy\":\"wsy_qian_yi_zhuan_yong_bao_wen\"}"
issueObject.unit = "wsy_qian_yi_zhuan_yong_bao_wen"
jsonResult = userDao.issue(issueObject)
userAsset = UserAsset.UserAsset()
userAsset.assetAddress, userAsset.status, userAsset.userAddress, userAsset.money, userAsset.sourceId = \
jsonResult['assetId'], "0", bossAccount.address, amount, issueObject.sourceId
return userAsset
def init_tables():
user_dao = UserDao(db.session)
for item in app.config['USERS']:
user = user_dao.retrieve(username=item['username'])
if user is None:
user_dao.create(username=item['username'],
password=item['password'],
email=item['email'],
first_name=item['first_name'],
last_name=item['last_name'],
is_superuser=item['is_superuser'],
is_admin=item['is_admin'],
is_active=item['is_active'],
is_visible=item['is_visible'])
def bassCreateUser(self, username, userId):
user = UserInfo.UserInfo()
user.name = username
user.id = userId
user = user.__dict__
# 打印字典
print(user)
# 字典转化为json
userJson = json.dumps(user)
userDao = UserDao.UserDao()
userDict = userDao.baasCreateUser(userJson)
userInfo = UserInfo.UserInfo()
userInfo.userId, userInfo.publicKey, userInfo.privateKey, userInfo.address = userDict[
"id"], userDict['basePublicKey'], userDict[
'basePrivateKey'], userDict['baseAccountAddress']
return userInfo
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('username', type=str, required=True, location='json')
parser.add_argument('password', type=str, required=True, location='json')
parser.add_argument('email', type=str, required=True, location='json')
parser.add_argument('first_name', type=str, location='json')
parser.add_argument('last_name', type=str, location='json')
parser.add_argument('is_admin', type=bool, location='json')
parser.add_argument('is_active', type=bool, location='json')
args = parser.parse_args()
user_dao = UserDao(self.db_session())
user = user_dao.create(**args)
return self.response(user.to_dict(), http.CREATED_201)
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('username', type=str, location='args')
parser.add_argument('email', type=str, location='args')
parser.add_argument('first_name', type=str, location='args')
parser.add_argument('last_name', type=str, location='args')
parser.add_argument('is_admin', type=bool, location='args')
parser.add_argument('is_active', type=bool, location='args')
args = parser.parse_args()
user_dao = UserDao(self.db_session())
users = user_dao.retrieve_all(**args)
result = [user.to_dict() for user in users]
return self.response(result)
def check_token(token):
if 'SECRET_KEY' not in g.config.keys():
return None, 'Could not retrieve secret key'
secret = g.config['SECRET_KEY']
if secret is None:
return None, 'Secret key is empty'
try:
data = jwt.decode(token, secret, algorithms=['HS256'])
except JWTError as e:
return None, 'Could not decode token ({})'.format(e.message)
user_dao = UserDao(g.db_session)
user = user_dao.retrieve(id=data['id'])
if user is None:
return None, 'User {} not found'.format(data['id'])
if not user.is_active:
return None, 'User {} no longer active'.format(user.username)
return user, None
def delete(self, id, user_id):
user_group_dao = UserGroupDao(self.db_session())
user_group = user_group_dao.retrieve(id=id)
if user_group is None:
return self.error_response('User group {} not found'.format(id), http.NOT_FOUND_404)
user_dao = UserDao(self.db_session())
user = user_dao.retrieve(id=user_id)
if user is None:
return self.error_response('User {} not found'.format(id), http.NOT_FOUND_404)
if user in user_group.users:
user_group.users.remove(user)
user_group = user_group_dao.save(user_group)
return self.response(user_group.to_dict())
from bottle import run
from dao import UserDao
if __name__ == '__main__':
UserDao(database='figurinhas')
run(app='route', host='localhost', port=8080)
def findAssetId(self, userAddress):
userDao = UserDao.UserDao()
userAsset = UserAsset.UserAsset()
userAsset.userAddress = userAddress
userAssetArray = userDao.findAssetId(userAsset)
return userAssetArray
from flask import Blueprint, jsonify, request
from flask_jwt_extended import create_access_token
from dao import UserDao
from auth import verify_password
from utils.network.decorators import json_required_params
from utils.network.exc import UnauthorizedException
auth_blueprint = Blueprint(
'auth',
__name__,
)
user_dao = UserDao()
@auth_blueprint.route('/auth', methods=['POST'])
@json_required_params(['username', 'password'])
def auth():
username = request.json['username']
password = request.json['password']
user = user_dao.get_by_username(username)
if user is None:
raise UnauthorizedException('Bad username or password')
if not verify_password(user.password, password):
raise UnauthorizedException('Bad username or password')
access_token = create_access_token(identity=username)
return jsonify(access_token=access_token), 200
def settle(self, settleObject):
userDao = UserDao.UserDao()
src = userDao.settle(settleObject)
return src
def transfer(self, transferObject):
userDao = UserDao.UserDao()
src, to, fee = userDao.transfer(transferObject)
return src, to, fee
def insertUserAsset(slef, userAsset):
userDao = UserDao.UserDao()
userDao.insertUserAsset(userAsset)
return userAsset
def findUserInfoByAddress(self, address):
userDao = UserDao.UserDao()
userInfo = userDao.findUserInfoByAddress(address)
return userInfo
def getBossAccount(self, customerName):
userDao = UserDao.UserDao()
user = userDao.getBossAccount(customerName)
return user
def findUserInfo(self, customerName):
userDao = UserDao.UserDao()
array = []
array = userDao.findUserInfo(customerName)
return array
def __init__(self):
self.user_dao = UserDao()
from flask import Flask, render_template, request, redirect, url_for, flash, session
from flask_mysqldb import MySQL
from flask_socketio import SocketIO, emit, send
from models import User
from dao import UserDao
app = Flask(__name__)
io = SocketIO(app)
app.config.from_pyfile('config.py')
db = MySQL(app)
user_dao = UserDao(db)
messages = []
@io.on('sendMessage')
def send_message_handler(msg):
messages.append(msg)
emit('getMessage', msg, broadcast=True)
@io.on('message')
def message_handler(msg):
send(messages)
@app.route("/chat")
def home():
import os
from flask import Flask, session, flash, redirect, render_template, request, send_from_directory
from dao import UserDao, SearchDao
app = Flask(__name__)
secret = os.environ.get('SESSIONKEY')
app.secret_key = secret
user = UserDao()
search = SearchDao()
@app.route('/')
def home():
return render_template('index.html')
@app.route('/register')
def registrar():
return render_template('register.html')
@app.route('/login')
def login():
return render_template('login.html')
@app.route('/logout')
def logout():
session['usuario_logado'] = None
session.modified = True
def updateUserInfo(self, userInfo):
userDao = UserDao.UserDao()
userDao.update(userInfo)
