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)