def userView(user_id):
user = UserModel().user(user_id)
if request.method == 'PUT':
UserModel().updateUser(request.form)
elif request.method == 'POST':
UserModel().createUser(request.form)
elif request.method == 'DELETE':
UserModel().deleteUser(request.form['id'])
else:
return render_template('admin/user.html', user=user)
def test_pa3(self):
testdata = zip([(1024, 77), (1024, 268), (1024, 462), (1024, 393),
(1024, 36955), (2048, 77), (2048, 36955), (2048, 788)],
[
"1024,77,4.3848,Memento (2000)",
"1024,268,2.8646,Batman (1989)",
"1024,462,3.1082,Erin Brockovich (2000)",
"1024,393,3.8722,Kill Bill: Vol. 2 (2004)",
"1024,36955,2.3524,True Lies (1994)",
"2048,77,4.8493,Memento (2000)",
"2048,36955,3.9698,True Lies (1994)",
"2048,788,3.8509,Mrs. Doubtfire (1993)",
])
data = DataIO(verbose=False)
data.load('testdata/ratings.csv',
items_file='testdata/movie-titles.csv')
model = UserModel(verbose=False, normalize=True)
model.build(data)
for ((u, i), s) in testdata:
self.assertTrue(
'%s' % s == '%d,%d,%.4f,%s' %
(u, i,
user_based_knn(model,
30, [data.new_user_idx(u)],
[data.new_item_idx(i)],
cosine,
promote_users=True,
normalize='centered'), data.title(i)))
def post(data):
json = request.json['accessRequest']
user = UserModel.find(email=json['email'])
if user is not None:
resp = jsonify({'status': 409, 'message': 'Conflict.'})
resp.status_code = 409
return resp
user = UserModel(email=json['email'],
firstname=json['firstname'],
lastname=json['lastname'],
username=json['firstname'] + '.' + json['lastname'],
status='pending',
employee_id=json['employee_id'],
password=json['password'])
if user.save():
user = user.find(username=user.username)
users = UserModel.find(role='administrator')
for u in users:
message = Message()
message.type = 'access-request'
message.to_user = u
resp = jsonify({'accessRequest': {'id': user.id}})
resp.status_code = 201
return resp
resp = jsonify({'status': 400, 'message': 'Bad Request.'})
resp.status_code = 400
return resp
def post(self):
json_input = request.get_json()
try:
data = user_schema.load(json_input)
except ValidationError as err:
abort(422, errors=err.messages)
try:
UserModel.objects.get(username=data['username'])
abort(
400,
errors=f"user {data['username']} is already registered.",
)
except DoesNotExist:
pass
user = UserModel(
username=data['username'],
password=generate_password_hash(data['password']),
role=data['role'],
)
user.save()
message = f"Successfully created user: {user.username}"
data = user_schema.dump(user)
data['message'] = message
return data, 201
def post(self):
data = parser.parse_args(strict=True)
# check if user exists already
if UserModel.find_by_username(data['username']):
return {
'message': 'User {} already exists'.format(data['username'])
}
# create a new user
new_user = UserModel(username=data['username'],
password=UserModel.generate_hash(
data['password']))
# attempt saving user to the DB
try:
new_user.save_to_db()
# create temporary access token
access_token = create_access_token(identity=data['username'])
refresh_token = create_refresh_token(identity=data['username'])
return {
'message': 'User {} was created'.format(data['username']),
'access_token': access_token,
'refresh_token': refresh_token
}
except:
return {
'message': 'Something went wrong while creating the user'
}, 500
def register():
message = ''
form = forms.RegisterForm()
if form.is_submitted():
print(form.validate_on_submit())
if form.validate_on_submit():
d = json.dumps({
"fullname": form.name.data,
"email": form.email.data,
"password": form.password.data
})
d = user_schema_single.loads(d)
new_user = UserModel(fullname=d["fullname"],
email=d["email"],
password=d["password"])
db.session.add(new_user)
try:
db.session.commit()
except Exception as e:
print(e)
db.session.rollback()
return "User could not be saved."
return f"Welcome {form.name.data}."
else:
message = "Form is invalid."
return render_template('register.html', form=form, message=message)
def run(self):
print("working ...")
user = UserModel("nombre", "*****@*****.**")
r = requests.post(url='http://localhost:8000/users/',
data=user.getUserDictionary(),
auth=("zehemz", "isveckson"))
self.__callback.threadFinished(r)
print("Termine! ...")
def random_users():
db.drop_all()
db.create_all(app=app)
users = RandomUser.generate_users(100, {'gender': 'male'})
for user in users:
user = UserModel(first_name=user.get_first_name(),
last_name=user.get_last_name(),
dob=user.get_dob(),
gender=user.get_gender()
# may add more fields(city, number ...)
)
db.session.add(user)
db.session.commit()
return app
def create_user_instance(
userid,
username,
password,
record
):
user = UserModel()
user.userid = userid
user.username = username
user.password = password
user.record = record
user.save()
return user
async def post(self, user_id=None):
"""
summary: Создать пользователя
description: тест
"""
user = self.get_body(UserModel)
try:
user = UserModel(**user)
except ValidationError as e:
return self.finish_with_error()
try:
user_id = await self.application.db.users.create(user)
except Exception as e: # DatabaseException
return self.finish_with_error()
return self.finish_with_ok(
BaseResponse(status_code=200, reason='user_created', data=user_id))
def get(self):
'''
Returns a list of all users
:return:
Failure - Error codes: 500
Success - List: 200
'''
user_model = UserModel()
try:
users = user_model.get_all_users()
except (DatabaseError, IntegrityError):
return {"message": "Internal Server Error"}, 500
except Exception as e:
return {"message": "Exception : {}".format(str(e))}, 500
return users, 200
def get(self):
'''
Returns a list of skills that match the parameters entered by the user
:return:
Failure - Error codes: 500
Success - List: 200
'''
params = request.args.to_dict()
user_model = UserModel()
try:
skills = user_model.find_skill_by_params(params)
except (DatabaseError, IntegrityError) as e:
return {"message": "Internal Server Error {}".format(e)}, 500
except Exception as e:
return {"message": "Exception : {}".format(str(e))}, 500
return skills, 200
async def get(self, user_id: UUID):
"""
summary: Получение информации о пользователе по id
description: тест
"""
try:
user = dict(
name='samuel colvin',
username='******',
password1='zxcvbn',
password2='zxcvbn',
)
user = UserModel(**user)
return self.finish_with_ok(
BaseResponse(status_code=200, reason='user_found', data=user))
except ValidationError as e:
return self.finish_with_error(
BaseResponse(status_code=422, reason='validation error'))
def post(self):
json = request.json['user']
user = UserModel(firstname=json['firstname'],
lastname=json['lastname'],
email=json['email'],
username=json['firstname'] + '.' + json['lastname'],
employee_id=json['employee_id'],
status=json['status'],
password=''.join(
random.choice(string.ascii_uppercase +
string.digits) for _ in range(12)),
role=json['role'])
for department in json['departments']:
user.departments.append(Department.find(id=department['id']))
user.save()
departments = []
for department in user.departments:
departments.append({
'id': department.id,
'parent_id': department.parent_id,
'name': department.name,
'description': department.description
})
model = {
'user': {
'id': user.id,
'user_id': user.id,
'firstname': user.firstname,
'lastname': user.lastname,
'email': user.email,
'username': user.username,
'employee_id': user.employee_id,
'status': user.status,
'role': user.role,
'departments': departments
}
}
print model
return jsonify(model), 201
def __init__(self):
self.make_rates()
self.token = '1032122116:AAFMa6ewEqjbV9cYsu34kekzLJZo7ITq3Jw'
self.model = UserModel(self.currencies, self.rates,
util.Categorizer().get_categories())
self.add_callback = BankAdderCallback(self.model)
self.balance_callback = TotalBalanceCallback(self.model)
self.account_callback = DisplayAccountsCallback(self.model)
self.list_category_callback = ListCategoriesCallback(self.model)
self.category_spent_callback = ShowCategoryTotalCallback(self.model)
self.category_transactions = ShowCategoryTransactionsCallback(
self.model)
self.set_limit_callback = SetLimitCallback(self.model)
self.show_limit_callback = ShowLimitCallback(self.model)
self.show_freedom_callback = ShowLimitCallback(self.model)
self.paid_callback = ShowSpentCallback(self.model)
def get(self):
code = self.get_argument('code')
state = self.get_argument('state')
wechat_conf = utils.config.get_section('wechat')
app_id = wechat_conf['appid']
app_secret = wechat_conf['appsecret']
web_url = utils.config.get('global', 'url')
oauth_client = WeChatOAuth(app_id, app_secret, '')
oauth_client.fetch_access_token(code)
user_info = oauth_client.get_user_info()
user_model = self.model_config.first(
UserModel, open_id=user_info['openid']) # type:UserModel
if user_model:
user_model.profile = user_info['headimgurl']
user_model.nickname = user_info['nickname']
self.model_config.commit()
else:
user_model = UserModel(nickname=user_info['nickname'],
open_id=user_info['openid'],
sex=user_info['sex'],
province=user_info['province'],
country=user_info['country'],
city=user_info['city'],
profile=user_info['headimgurl'],
privilege=user_info['privilege'],
union_id=user_info['unionid'])
self.model_config.add(user_model)
self.session['user_id'] = user_model.id
self.session['open_id'] = user_model.open_id
self.session.save()
if self.session.get('current_url', ''):
current_url = urllib.unquote_plus(self.session.get('current_url'))
self.session['current_url'] = ''
self.session.save()
self.logger.info('current_url:%s' % current_url)
self.redirect(current_url)
else:
self.logger.info('current_url: null')
self.redirect(web_url)
def get(self, _id):
'''
Takes in an int as an id and returns the dictionary of the User
:param _id:
:return:
Failure - Error codes: 500, 404
Success - Dictionary: 200
'''
user_model = UserModel()
try:
user = user_model.get_by_id(_id)
except DataError:
return {
"message": "User with ID {} does not exist".format(_id)
}, 404
except (DatabaseError, IntegrityError):
return {"message": "Internal Server Error"}, 500
except Exception as e:
return {"message": "Exception : {}".format(str(e))}, 500
return user.get_fields(), 200
def put(self, _id, **kwargs):
'''
Takes in an int as an id and updates the user with the validated payload
:param _id:
:return:
Failure - Error codes: 500, 404
Success - Dictionary: 200
'''
payload = kwargs.get('payload', None)
user_model = UserModel()
try:
user = user_model.update_user(_id, payload)
except DataError:
return {
"message": "User with ID {} does not exist".format(_id)
}, 404
except (DatabaseError, IntegrityError):
return {"message": "Internal Server Error"}, 500
except Exception as e:
return {"message": "Exception : {}".format(str(e))}, 500
return user.get_fields(), 200
def create(request):
request_json = request.get_json()
id = request_json['phone']
userModel = UserModel(**request_json)
userResponse.userModel = userModel.__dict__
user = users_ref.document(id).get().to_dict()
if (user == None):
users_ref.document(id).set(userModel.__dict__)
userResponse.result = {
"code": "1",
"title": "註冊完成",
}
else:
userResponse.result = {
"code": "-1",
"title": "重複註冊",
"description": "本手機(" + str(id) + ")已由他人註冊"
}
return userResponse.__dict__
def post(self):
current_time = datetime.datetime.now()
nickname = self.get_json_argument('nickname')
open_id = '' # TODO: 前端传open_id？还是后端获取？
sex = self.get_json_argument('sex')
province = self.get_json_argument('province')
city = self.get_json_argument('city')
country = self.get_json_argument('country')
profile = self.get_json_argument('profile')
privilege = self.get_json_argument('privilege')
union_id = self.get_json_argument('union_id')
name = self.get_json_argument('name')
job = self.get_json_argument('job')
company = self.get_json_argument('company')
phone = self.get_json_argument('phone')
email = self.get_json_argument('email')
user = UserModel(nickname=nickname, open_id=open_id, sex=sex, province=province, city=city, country=country,
profile=profile, privilege=privilege, union_id=union_id, name=name, job=job, company=company,
phone=phone, email=email, is_del=False, create_time=current_time, update_time=current_time)
self.model_config.add(user)
return {'user_id': user.id}
def update(request):
request_json = request.get_json()
id = request_json['phone']
userModel = UserModel(**request_json)
userResponse.userModel = request_json
user = users_ref.document(id).get().to_dict()
if (user != None):
users_ref.document(id).set(userModel.__dict__, merge=True)
userResponse.result = {
"code": "1",
"title": "修改完成",
}
else:
userResponse.userModel = {}
userResponse.result = {
"code": "-1",
"title": "修改失敗",
"description": "本手機(" + str(id) + ")尚未由他人註冊"
}
return userResponse.__dict__
def user_to_dynamodb(self):
UserModel.create_table(read_capacity_units=1, write_capacity_units=1)
user = UserModel(self.user['id'])
user.screen_name = self.user['screen_name']
user.gender = self.user['gender']
user.statuses_count = self.user['statuses_count']
user.followers_count = self.user['followers_count']
user.follow_count = self.user['follow_count']
user.registration_time = self.user['registration_time']
user.sunshine = self.user['sunshine']
user.birthday = self.user['birthday']
user.location = self.user['location']
user.education = self.user['education']
user.company = self.user['company']
user.description = self.user['description']
user.profile_url = self.user['profile_url']
user.profile_image_url = self.user['profile_image_url']
user.avatar_hd = self.user['avatar_hd']
user.urank = self.user['urank']
user.mbrank = self.user['mbrank']
user.verified = self.user['verified']
user.verified_type = self.user['verified_type']
user.verified_reason = self.user['verified_reason']
user.save()
def delete(self, _id):
'''
Takes in an int as an id and deletes the user with the id
:param _id:
:return:
:param _id:
:return:
Failure - Error codes: 500, 404
Success - No Content: 204
'''
user_model = UserModel()
try:
user_model.delete_user(_id)
except DataError:
return {
"message": "User with ID {} does not exist".format(_id)
}, 404
except (DatabaseError, IntegrityError):
return {"message": "Internal Server Error"}, 500
except Exception as e:
return {"message": "Exception : {}".format(str(e))}, 500
return {}, 204
def create_new(self, *args, **kwargs):
"""Creates an empty user data object"""
self.ensure_mongo_conection()
return UserModel(*args, **kwargs)
def gconnect():
# Validate state token
if request.args.get('state') != login_session['state']:
response = make_response(json.dumps('Invalid state parameter.'), 401)
response.headers['Content-Type'] = 'application/json'
return response
# Obtain authorization code
code = request.data
try:
# Upgrade the authorization code into a credentials object
oauth_flow = flow_from_clientsecrets('client_secrets.json', scope='')
oauth_flow.redirect_uri = 'postmessage'
credentials = oauth_flow.step2_exchange(code)
except FlowExchangeError:
response = make_response(
json.dumps('Failed to upgrade the authorization code.'), 401)
response.headers['Content-Type'] = 'application/json'
return response
# Check that the access token is valid.
access_token = credentials.access_token
url = ('https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=%s' %
access_token)
h = httplib2.Http()
result = json.loads(h.request(url, 'GET')[1])
# If there was an error in the access token info, abort.
if result.get('error') is not None:
response = make_response(json.dumps(result.get('error')), 500)
response.headers['Content-Type'] = 'application/json'
return response
# Verify that the access token is used for the intended user.
gplus_id = credentials.id_token['sub']
if result['user_id'] != gplus_id:
response = make_response(
json.dumps("Token's user ID doesn't match given user ID."), 401)
response.headers['Content-Type'] = 'application/json'
return response
# Verify that the access token is valid for this app.
if result['issued_to'] != CLIENT_ID:
response = make_response(
json.dumps("Token's client ID does not match app's."), 401)
print "Token's client ID does not match app's."
response.headers['Content-Type'] = 'application/json'
return response
stored_access_token = login_session.get('access_token')
stored_gplus_id = login_session.get('gplus_id')
if stored_access_token is not None and gplus_id == stored_gplus_id:
response = make_response(
json.dumps('Current user is already connected.'), 200)
response.headers['Content-Type'] = 'application/json'
return response
# Store the access token in the session for later use.
login_session['access_token'] = credentials.access_token
login_session['gplus_id'] = gplus_id
# Get user info
userinfo_url = "https://www.googleapis.com/oauth2/v1/userinfo"
params = {'access_token': credentials.access_token, 'alt': 'json'}
answer = requests.get(userinfo_url, params=params)
data = answer.json()
login_session['username'] = data['name']
login_session['picture'] = data['picture']
login_session['email'] = data['email']
user_id = UserModel().getUserID(login_session['email'])
if not user_id:
user_id = UserModel().createUser(login_session)
login_session['user_id'] = user_id
output = ''
output += '<h1>Welcome, '
output += login_session['username']
output += '!</h1>'
output += '<img src="'
output += login_session['picture']
output += ''' " style =
"width: 300px;
height: 300px;
border-radius: 150px;
-webkit-border-radius: 150px;
-moz-border-radius: 150px;"> '''
flash("you are now logged in as %s" % login_session['username'])
print "done!"
return output
sys.path.append("../../../recsys")
from score import user_based_knn, cosine
from dataset import DataIO
from model import UserModel
ratings_file = '../data/ratings.csv'
items_file = '../data/movie-titles.csv'
NN = 30
answer_file = 'part_1.csv'
# part 1
data = DataIO()
data.load(ratings_file, items_file=items_file)
model = UserModel(normalize=True)
model.build(data)
inputs = [(4169, 161), (4169, 36955), (4169, 453), (4169, 857), (4169, 238),
(5399, 1891), (5399, 14), (5399, 187), (5399, 602), (5399, 629),
(3613, 329), (3613, 604), (3613, 134), (3613, 1637), (3613, 278),
(1873, 786), (1873, 2502), (1873, 550), (1873, 1894), (1873, 1422),
(4914, 268), (4914, 36658), (4914, 786), (4914, 161), (4914, 854)]
file = open(answer_file, 'w')
file.write('\n'.join([
'%d,%d,%.4f,%s' %
(u, i,
user_based_knn(model,
NN, [data.new_user_idx(u)], [data.new_item_idx(i)],
cosine,
def __init__(self):
self.model = UserModel()
import os
from firebase_admin import credentials, firestore, initialize_app
import requests
import json
from model import UserModel, UserResponse
userModel = UserModel()
userResponse = UserResponse()
cred = credentials.Certificate('firebaseKey.json')
initialize_app(cred)
db = firestore.client()
users_ref = db.collection('users')
def delete(request):
request_json = request.get_json()
id = request_json['phone']
userResponse.userModel = {}
user = users_ref.document(id).get().to_dict()
if (user != None):
users_ref.document(id).delete()
userResponse.result = {
"code": "1",
"title": "退出完成",
}
else:
import os
from firebase_admin import credentials, firestore, initialize_app
import requests
import json
from model import UserModel, ResponseModel
# data model
user = UserModel()
response = ResponseModel()
# firebase
cred = credentials.Certificate("firebase-key.json")
initialize_app(cred)
db = firestore.client()
# firebase data collection
users_ref = db.collection("users")
def check(request):
# 获取参数
request_json = request.get_json()
request_args = request.args
# lineId
if request_json and "lineId" in request_json:
lineId = request_json["lineId"]
elif request_args and "lineId" in request_args:
lineId = request_args["lineId"]
else:
lineId = None
def test_update(self):
self.assertLessEqual(
self.user_bl.sign_up(UserModel("law", "123456", Role.USER)), 10)
