def function_login(**kwargs):
user=User()
user=user.login(kwargs["email"],kwargs["password"])
if(user[0]):
return True,user[1]
else:
return False,None
def setup_class(cls):
cls.admin_session = ProxyAPI(
APITestBase.ProxyUrl,
User(username='******', password='******', id=1))
cls.user_session = ProxyAPI(
APITestBase.ProxyUrl,
User(username='******', password='******', id=2))
def post(self):
schema = SignupSchema()
data, errors = schema.load(api.payload)
if errors:
return errors, 400
username = data['username']
email = data['email']
if not User.username_is_unique(username):
errors['username'] = ["User already exits."]
if not User.email_is_unique(email):
errors['email'] = ["Email already exits."]
if errors:
return errors, 403
password = data['password']
user = User(username, email, password)
db.session.add(user)
db.session.commit()
# try:
# db.session.add(user)
# db.session.commit()
# except:
# abort(400) # could not create user for some reason
return {'auth_token': user.get_token()}
def renderDisplay(self):
st.markdown('# SIGN UP')
userName = st.text_input("Username")
loginEmail = st.text_input("Login Email")
updateEmail = st.text_input("Update Email")
password = st.text_input("Input Password",type = "password")
passwordHash = sha256(password.encode('utf-8')).hexdigest()
rePassword = st.text_input("Retype Password",type = "password")
rePasswordHash = sha256(rePassword.encode('utf-8')).hexdigest()
if passwordHash != rePasswordHash:
st.write("### Passwords don't match!")
updateFrequency = st.slider('Update Frequency', min_value=0, max_value=10)
updateConfidence = st.slider('Update Confidence Level', min_value=85, max_value=95)
if st.button('Submit'):
payload = {}
headers= {}
url = "https://us-central1-cz2006-9cd2d.cloudfunctions.net/app/checkUserName/"+userName
response = requests.request("GET", url, headers=headers, data = payload)
if not response.json()["present"] and passwordHash == rePasswordHash:
user = User(userName,loginEmail,passwordHash,updateEmail,updateFrequency,updateConfidence)
user.postUser()
elif passwordHash == rePasswordHash:
st.write("That username is taken.")
return False,None
else:
st.write("Retype your password")
return False,None
return True,user
else:
return False,None
def getCosechas(self, productor):
db = Database()
cursor = db.main()
cosechas = []
try:
data = cursor.cosecha.find({"productor": productor})
for i in data:
ventas = []
id = i["_id"]
ventasJSON = cursor.ventas.find({"cosecha": ObjectId(id)})
for ven in ventasJSON:
v = Venta()
v.fecha = ven["fecha"]
v.cantidad = ven["cantidad"]
v.monto = ven["monto"]
ventas.append(v)
nc = Cosecha(id, i["cereal"], i["cantidadProduccion"],
i["cantidadParcial"], i["inicio"], i["fin"],
i["productor"], ventas)
nc.id = id
productorJSON = cursor.usuario.find_one({"user": productor})
productorObject = User()
productorObject.parse(productorJSON)
nc.productor = productorObject
cosechas.append(nc)
return cosechas
except NameError:
print(NameError)
return None
def store(req):
data = req.get_json()
error = []
new_user = None
try:
new_user = User(username=data['username'], email=data['email'],
password=generate_password_hash(data['password']))
new_user.created_at = datetime.datetime.utcnow()
new_user.tokens = []
new_user.save()
new_user.tokens.append(encode_auth_token(str(new_user.id)).decode('ascii'))
new_user.save()
del new_user.password
except ValidationError as e:
error.append(str(e))
except KeyError as e:
error.append("Missing key in request body : {}".format(e))
except (DuplicateKeyError, NotUniqueError) as e:
email_exists = User.objects(email=data['email']).count()
if email_exists > 0:
error.append("Email already exists")
username_exists = User.objects(username=data['username']).count()
if username_exists > 0:
error.append("Username already exists")
if error.__len__() > 0:
return Response(json.dumps({"error": "Sent data is invalid", "message": error}), status=400,
headers={"content-type": "application/json"})
user_response = UserDTO(new_user).__dict__
user_response['tokens'] = new_user.tokens
return Response(json.dumps(user_response), status=201, headers={"content-type": "application/json"})
def addSession(form):
if not checkKeys(form, ['email', 'password']):
return msg.errMsg("Please check the inputs.")
sessions = SessionModel()
users = UserModel()
(email, password) = (form['email'], form['password'])
usersFounded = users.getUser(email=email, password=password, enable=True)
if usersFounded == None:
return msg.errMsg("Failed to validate user information.")
if len(usersFounded) == 0:
return msg.errMsg("Invalid email address or password.")
uid = usersFounded[0][0]
newSessionID = sessions.createSessionID()
startTime = datetime.utcnow()
startSessionResult = sessions.startSession(newSessionID, uid, startTime)
if startSessionResult == None:
return msg.errMsg("Failed to start a new session.")
return msg.successMsg({
"sessionID": newSessionID,
"uid": uid,
"startTime": str(startTime)
})
def remove_user(uid):
uuid = request.args.get("token", None)
result_uid = onpage_dict.pop(uuid)
if session.get("uid") == result_uid:
User.del_user_by_id(uid)
return redirect(url_for("admin.get_all_users"))
else:
return redirect(url_for("index.index"))
def getUser(self, user, password):
#Hacer try catch, que pasa si no encuentra un usuario?
db = Database()
cursor = db.main()
logUserJSON = cursor.usuario.find_one({"user": user, "password": password})
if logUserJSON != None:
logUserModel = User()
logUserModel.parse(logUserJSON)
return logUserModel
else:
return None
def register():
if request.method == "GET":
return render_template("regist.html")
elif request.method == "POST":
form = request.form
form = todict(**form)
if check_regi_para(**form):
u = User(**form)
try:
u.register()
except pymysql.err.IntegrityError as e:
return redirect(url_for("User.register"))
return redirect(url_for("index.index"))
else:
return redirect(url_for("User.register"))
def get_user_by_email(self, email, partnercode):
try:
return User.select().where((User.email == email)
& (User.partnercode == partnercode)
& (User.deleted == 0)).get()
except User.DoesNotExist:
return None
def test_get_addChatroom(self):
user = User("Test", "ACTIVE")
cliente = Client(('127.0.0.1', 54000), user)
chatroom = Chatroom("sala", user)
cliente.addChatroom(chatroom)
ch = cliente.getChatroom()
self.assertEqual(ch[0], chatroom)
def remove_project(user_id, project_id, email):
query = f"""
SELECT
[creator]
FROM
[prj].[project]
WHERE
[ProjectId] = '{project_id}'
"""
conn = Database.connect()
cursor = conn.cursor()
results = Database.execute_query(query, cursor)
conn.close()
if user_id == results[0][0]:
remove_member = User.get_user_from_email(email)
if remove_member is not None:
query = """
[prj].[RemoveProject] @UserId = ?, @ProjectId = ?
"""
params = (user_id, project_id)
conn = Database.connect()
cursor = conn.cursor()
results = Database.execute_sproc(query, params, cursor)
if results['Status'] == 201:
cursor.commit()
conn.close()
return results
else:
return {'Status': 400, 'Message': 'There is no account associated with this email'}
else:
return {'Status': 400, 'Message':'This user is not the owner of the project'}
def register():
session['is_in_home'] = False
msg = ''
if request.method == 'POST':
email = request.form['email']
age = request.form['age']
name = request.form['name']
surname = request.form['surname']
password = request.form['password']
#password = hash_password(password)
user = User(email, age, name, surname, password, user_type=1)
db = current_app.config['db']
answer = db.insert_user(user)
if answer[0]:
msg = 'You have successfully registered '
flash(msg)
return redirect(url_for('login'))
else:
print(answer[1])
idx = str(answer[1]).find("DETAIL")
if idx != -1:
msg = str(answer[1])[:idx].capitalize()
else:
msg = "Something went wrong"
flash(msg)
return redirect(url_for('register'))
# return render_template('register.html')
return render_template('register.html')
def createUser(self, username, password):
cipherKey = random.randint(1, 26)
encryptedPassword = encrypt(password, cipherKey)
newUser = User(username, encryptedPassword, cipherKey)
self.getUsers().append(newUser)
with open('data.pkl', 'wb') as output:
pickle.dump(self.getUsers(), output, pickle.HIGHEST_PROTOCOL)
def project_leave():
if request.method == 'POST':
response = User.get_user_from_session(request.headers.get('SessionId'))
if response['Status'] == 200:
return Project.leave_project(response['Message'],
request.get_json()['ProjectId'])
return json.dumps(response)
def project_add():
if request.method == 'POST':
response = User.get_user_from_session(request.headers.get('SessionId'))
if response['Status'] == 200:
info = request.get_json()
return Project.add_dataset_to_project(response['Message'], info)
return json.dumps(response)
def download_file():
if request.method == 'POST':
response = UserModel.get_user_from_session(request.headers.get('SessionId'))
if response['Status'] == 200:
json_query = request.get_json()
return FileModel.download_file_s3(json_query['File'])
return json.dumps(response)
def registraty(fname, name, login, password):
for u in users:
if u.login == login:
return False
u = User(idGen.get_new_user_id(), name, fname, login, password)
users.append(u)
return True
def handle_create_profile(self, data):
profile_data = data["profile"]
user_data = None
if "user" in data:
user_data = data["user"]
if "namespaceid" in profile_data:
namespaceid = profile_data["namespaceid"]
else:
namespaceid = 0
if "uniquenick" in profile_data:
if not self.is_name_valid(profile_data["uniquenick"]):
raise OS_Profile_UniquenickInvalid()
nick_available = self.check_uniquenick_available(
profile_data["uniquenick"], namespaceid)
if nick_available["exists"]:
raise OS_Profile_UniquenickInUse(nick_available["profile"])
user = User.get((User.id == user_data["id"]))
if "nick" in profile_data:
if not self.is_name_valid(profile_data["nick"]):
raise OS_Profile_NickInvalid()
profile_data["user"] = user
profile_pk = Profile.insert(**profile_data).execute()
profile = Profile.get((Profile.id == profile_pk))
profile = model_to_dict(profile)
del profile["user"]
user = model_to_dict(user)
return {"user": user, "profile": profile, "success": True}
def handle_perform_verify_email(self, request_data):
response = {}
redis_key = "emailveri_{}".format(request_data['userid'])
success = False
user = None
required_params = ["userid", "verifykey"]
for param in required_params:
if param not in request_data:
raise OS_MissingParam(param)
try:
user = User.get((User.id == request_data['userid']))
if self.redis_ctx.exists(redis_key):
real_verification_key = self.redis_ctx.get(redis_key)
if request_data['verifykey'] == real_verification_key:
success = True
user.email_verified = True
user.save()
self.redis_ctx.delete(redis_key)
except User.DoesNotExist:
raise OS_Auth_NoSuchUser()
response['success'] = success
return response
def signUp():
fullname = request.json.get('fullname', None)
CC = request.json.get('CC', None)
phone = request.json.get('phone', None)
password = request.json.get('password', None)
confirm_password = request.json.get('confirm_password', None)
user = User.query.filter_by(CC=CC).first()
if user:
return jsonify({"error": "Esta cédula ya está registrada"}), 400
if not fullname:
return jsonify({"error":
"El nombre completo no puede estar vacio"}), 400
if not CC:
return jsonify({"error": "La cédula no puede estar vacia"}), 400
if not phone:
return jsonify({"error": "El Telefono no puede estar vacio"}), 400
if not password:
return jsonify({"error": "La contraseña no puede estar vacía"}), 400
if not confirm_password:
return jsonify({"error":
"Confirmar contraseña no puede estar vacio"}), 400
if password != confirm_password:
return jsonify({"error": "Las contraseñas no coinciden"}), 400
hashed = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
new_user = User(fullname, CC, phone, hashed)
db.session.add(new_user)
db.session.commit()
return user_schema.jsonify(new_user)
def switchFrame(self, frame, controller, user = User()):
new_frame = frame(self)
new_frame.setController(controller(new_frame,user))
if self.frame is not None:
self.frame.destroy()
self.frame = new_frame
self.frame.grid()
def project_file_history():
if request.method == 'POST':
response = User.get_user_from_session(request.headers.get('SessionId'))
if response['Status'] == 200:
info = request.get_json()
return Project.get_file_history(info['FileId'], info['ProjectId'])
return response
def upload_change_obj():
if request.method == 'POST':
response = UserModel.get_user_from_session(
request.headers.get('SessionId'))
if response['Status'] == 200:
submitted_file = request.files['file']
file_obj = FileModel(submitted_file)
file_valid_response = file_obj.check_file_extension()
if file_valid_response['Status'] == 200:
file_obj.upload_file_landing()
file_path = file_obj.upload_file_s3()
file_obj.delete_file_landing()
if file_path is not None:
response = {
'Status': 201,
'Filepath': file_path,
'Message': 'Successfully uploaded'
}
else:
response = {
'Status': 201,
'FileName': file_obj.file_name,
'Message': 'Could not upload file'
}
return json.dumps(response)
def institution_create():
if request.method == 'POST':
response = User.get_user_from_session(request.headers.get('SessionId'))
if response['Status'] == 200:
user = User.get_user_info(response['Message'])
if user.get_institution() is None:
institution_info = request.get_json()
institution_model = Institution()
institution_model.set_name(institution_info['Name'])
institution_model.set_desc(institution_info['Desc'])
institution_model.set_owner(response['Message'])
return Institution.create_institution(institution_model)
return {
'Status': 400,
'Message': 'Member already part of an institution'
}
return json.dumps(response)
def institution_remove():
if request.method == 'POST':
response = User.get_user_from_session(request.headers.get('SessionId'))
if response['Status'] == 200:
remove_info = request.get_json()
return Institution.remove_member(response['Message'],
remove_info['Email'])
return json.dumps(response)
def institution_invite():
if request.method == 'POST':
response = User.get_user_from_session(request.headers.get('SessionId'))
if response['Status'] == 200:
invitation_info = request.get_json()
return Institution.invite_member(response['Message'],
invitation_info)
return json.dumps(response)
def institution_join():
if request.method == 'POST':
response = User.get_user_from_session(request.headers.get('SessionId'))
if response['Status'] == 200:
institution_invitation = request.get_json()
return Institution.accept_pending_invite(
response['Message'], institution_invitation['InstitutionId'])
return json.dumps(response)
def project_public():
if request.method == 'POST':
response = User.get_user_from_session(request.headers.get('SessionId'))
if response['Status'] == 200:
project_info = request.get_json()
return Project.make_public_or_private(project_info['ProjectId'],
project_info['Mode'])
return json.dumps(response)
