def test_delete_a_person_without_authentication(self, init_db, client,
new_role): # pylint: disable=C0103, W0613
"""
Test delete a person endpoint without authentication.
:param client: request client fixture
:return: None
"""
center = Center(name='Lagos', image={'url': 'image url'})
center.save()
new_role.save()
person = User(name='Tony',
email='*****@*****.**',
image_url='url',
role_id=new_role.id,
center_id=center.id)
person.save()
response = client.delete(
f'{API_V1_BASE_URL}/centers/{center.id}/people/{person.id}')
response_json = json.loads(response.data.decode(CHARSET))
assert response.status_code == 401
assert response_json['status'] == 'error'
assert response_json['message'] == jwt_errors['NO_TOKEN_MSG']
def single_user(testdb):
user = User(name="Ziutek")
testdb.add(user)
testdb.commit()
yield user
testdb.delete(user)
testdb.commit()
def populate_users(_, __):
cols = ['sentiment', 'id', 'date', 'query_string', 'user', 'content']
dataframe = pandas.read_csv(
'./data_processing/data/training_data.16000.csv',
header=None,
names=cols,
encoding="ISO-8859-1",
low_memory=False)
# removes unnecessary columns
dataframe.drop(['sentiment', 'date', 'query_string', 'content'],
axis=1,
inplace=True)
for i in range(0, dataframe['id'].count()):
tweet = Tweet.objects.get(pk=dataframe.loc[i, 'id'])
if tweet:
try:
user = User.objects.get(pk=dataframe.loc[i, 'user'])
except User.DoesNotExist:
user = User(id=dataframe.loc[i, 'user'])
user.save()
finally:
tweet.user = user
tweet.save()
def register():
if request.method == 'POST':
name = request.json.get("name", None)
email = request.json.get("email", None)
password = request.json.get("password", None)
#Valida que se ingrese un nuevo email y contraseña
if not name:
return jsonify({"msg": "name is required"}), 400
if not email:
return jsonify({"msg": "email is required"}), 400
if not password:
return jsonify({"msg": "Password is required"}), 400
user = User.query.filter_by(email=email).first()
if user:
return jsonify({"msg": "Username already exists"}), 400
user = User() # Crea un nuevo usuario
user.name = name # name que ingresa el usuario
user.email = email # email que ingresa el usuario
hashed_password = generate_password_hash(
password) #Incripcion de la contraseña
print(password, hashed_password)
user.password = hashed_password # se le asigna al usuario el password que se acaba de generar
db.session.add(user) # agrga al usuario a la DB
db.session.commit()
return jsonify({
"success": "Thanks. your register was successfully",
"status": "true"
})
def post(self):
post_data = request.get_json()
if (not post_data or "username" not in post_data
or "email" not in post_data or "password" not in post_data):
return {"message": "Invalid payload", "status": "fail"}, 400
username = post_data.get("username")
email = post_data.get("email")
password = post_data.get("password")
try:
user_with_mail = User.query.filter_by(email=email).first()
if not user_with_mail:
db.session.add(
User(username=username, email=email, password=password))
db.session.commit()
return (
{
"status": "success",
"message": f"{email} was added!"
},
201,
)
else:
return (
{
"status": "fail",
"message": "Email already exists."
},
400,
)
except exc.IntegrityError:
db.session.rollback()
return {"message": "Database error", "status": "fail"}, 400
def setUp(self):
"""Set up the internal viewset tests."""
super().setUp()
self.client = APIClient()
self.customer = self._create_customer_data()
self.internal_request_context = self._create_request_context(
self.customer, self.user_data, create_customer=False, is_internal=True, create_tenant=True
)
self.request = self.internal_request_context["request"]
user = User()
user.username = self.user_data["username"]
user.account = self.customer_data["account_id"]
self.request.user = user
with tenant_context(self.tenant):
self.group = Group(name="System Group", system=True)
self.group.save()
self.role = Role.objects.create(name="System Role", description="A role for a group.", system=True)
self.policy = Policy.objects.create(name="System Policy", group=self.group)
self.policy.roles.add(self.role)
self.policy.save()
self.group.policies.add(self.policy)
self.group.save()
def store():
data_request = request.get_json()
user = User.query.filter_by(email=data_request["email"]).first()
# Se valida que el email no haya sido registrado.
if user:
return jsonify({"msg": "El email ya fue registrado."}), 401
user = User(name = data_request["name"],
first_surname = data_request["first_surname"],
second_surname = data_request["second_surname"],
birth_date = data_request["birth_date"],
telephone_number = data_request["telephone_number"],
user_image = data_request["user_image"],
email = data_request["email"],
password = data_request["password"],
active = data_request["active"],
creation_date = datetime.datetime.now(),
update_date = datetime.datetime.now())
try:
db.session.add(user)
db.session.commit()
return jsonify(User.serialize(user)), 201
except AssertionError as exception_message:
return jsonify(message='Error: {}. '.format(exception_message)), 400
def setUp(self):
"""Set up the role viewset tests."""
super().setUp()
request = self.request_context['request']
user = User(username=self.user_data['username'],
tenant=self.tenant)
user.save()
request.user = user
sys_role_config = {
'name': 'system_role',
'system': True
}
def_role_config = {
'name': 'default_role',
'platform_default': True
}
with tenant_context(self.tenant):
self.principal = Principal(username=self.user_data['username'])
self.principal.save()
self.group = Group(name='groupA')
self.group.save()
self.group.principals.add(self.principal)
self.group.save()
self.sysRole = Role(**sys_role_config)
self.sysRole.save()
self.defRole = Role(**def_role_config)
self.defRole.save()
def register():
name = request.json.get("name", None)
email = request.json.get("email", None)
password = request.json.get("password", None)
if not name:
return "Debes ingresar tu nombre", 401
if not email:
return "Email es requerido", 401
email_query = User.query.filter_by(email=email).first()
if email_query:
return "Esta cuenta ya esta registrada", 401
if not password:
return "Debes ingresar una contraseña", 401
user = User()
user.name = name
user.email = email
hashed_password = generate_password_hash(password)
user.password = hashed_password
db.session.add(user)
db.session.commit()
response_token = {
"msg": "Usuario fue ingresado con exito"
}
return jsonify(response_token), 200
def add_user():
# Take the data passed from the front request an turn it into JSON
request_body = request.get_json()
# ----- USER ON DATABASE VALIDATION -----
# Get the parameter to validate
email = request_body["email"]
# Validating that email doesn't already exist on database
user = User.query.filter_by(email=email).first()
# If user doesn't exist on database then create a new instance
if user is None:
# Build a new instance of User, passing the parameters from the request.body
user = User(first_name=request_body["first_name"], last_name=request_body["last_name"], email=request_body["email"], password=request_body["password"], bio=request_body["bio"])
# Append the the instance into the database session of the API
db.session.add(user)
db.session.commit()
# Return a response with sucessful status
response_body = {
"msg": "POST /register response. Registration succesfully done."
}
return jsonify(response_body), 200
# Return a client error response and a comment indicating duplication of email is imposible.
return jsonify({"msg": "POST /register response. Email already exist on database."}), 401
def post(self, request):
check = CheckRequest(request)
if check.user:
return JsonResponse({"status": "error", "msg": "User logined"})
uf = UserForm(check.jsonForm)
if uf.is_valid():
#检测用户是否存在
checkUser = User.objects.filter(
qq__exact=uf.cleaned_data['qq']).first()
if checkUser:
if checkUser.status == 0:
return JsonResponse({
"status": 'error',
'msg': "此qq账户已注册,但未激活"
})
else:
return JsonResponse({"status": 'error', 'msg': "此qq账户已存在"})
user = User(username=uf.cleaned_data['username'],
password=db_password(uf.cleaned_data['password']),
qq=uf.cleaned_data['qq'],
login_random=new_random(),
activate_random=new_random(),
recover_random=new_random())
user.save()
return JsonResponse({"status": 'success', 'msg': ""})
else:
return JsonResponse({"status": 'error', 'msg': "Illegal post"})
def start_meeting(cls, bot, update):
user = User.objects.filter(
username=update.message.from_user.name).first()
if not user:
user = User(username=update.message.from_user.name)
user.user_id = update.message.from_user.id
user.save()
update.message.reply_text('Hi!')
update.message.reply_text(
"I can help self-diagnose and fight mild cases of depression "
"by informing your friends that you need care.\n"
"You can learn more about me here: http://depressionweakerthan.tech. \n"
"If you want, you can just lurk and recieve notifications about your friends' statuses. "
"However, I strongly recommend you to add trusted friends and install my browser extension. "
"It is a good idea to take care of yourself even if you don't think you could ever get depressed.\n"
)
subscriptions = get_all_subscriptions(update.message.from_user.id)
for subscription in subscriptions:
update.message.reply_text(
'User {} has added you as trusted friend'.format(
cls.get_username(subscription)))
update.message.reply_text(
"Type /help to get a list of all avaliable commands.")
def add_friend(friend_username, bot, update):
user = update.message.from_user
friend_username = correct_username(friend_username)
logger.info('User {} want to add friend {}'.format(
user.id, friend_username))
friend = User.objects.filter(username=friend_username).first()
if friend is None:
friend = User(username=friend_username)
friend.save()
if friend.user_id is None:
update.message.reply_text((
"I don't know {} yet. Please share link "
"t.me/depression_weaker_than_tech_bot with them. "
"When they register, I will be able to notify them of your status"
).format(friend_username))
logger.info(
'Not found friend with username: {}'.format(friend_username))
else:
add_friend_message = (
'User {} has added you to their list of trusted friends. '
'Now I will drop you a message should they need your attention and care'
)
bot.send_message(friend.user_id,
add_friend_message.format(user.name))
update.message.reply_text(
'User {} was added to list of your trusted friends.'.format(
friend_username))
logger.info('Found friend id: ' + str(friend.user_id))
User.objects.get(user_id=user.id).trusted.add(friend)
return True
def signup():
form = request.form
if request.method == "POST":
try:
username = form["username"]
password = form["password"]
firstName = form["first_name"]
lastName = form["last_name"]
email = form["email"]
location = form["location"]
biography = form["biography"]
photo = form["photo"]
except KeyError:
return make_response(
"Error on Server",
403,
{"WWW-Authenticate": 'Basic realm ="Wrong Password !!"'},
)
user = User(
first_name=firstName,
last_name=lastName,
username=username.lower(),
password=password,
biography=biography,
email=email,
photo=photo,
location=location,
)
db.session.add(user)
db.session.commit()
return make_response(
"User created sucessfully",
201,
)
def register():
if request.method == 'POST':
email = request.json.get("email", None)
password = request.json.get("password", None)
username = request.json.get("username", None)
if not email:
return "Email required", 401
username = request.json.get("username", None)
if not username:
return "Username required", 401
password = request.json.get("password", None)
if not password:
return "Password required", 401
email_query = User.query.filter_by(email=email).first()
if email_query:
return "This email has been already taken", 401
user = User()
user.email = email
user.is_active = True
user.username = username
hashed_password = generate_password_hash(password)
user.password = hashed_password
db.session.add(user)
db.session.commit()
response = {"msg": "Added successfully", "username": username}
return jsonify(response), 200
def setUp(self):
"""Set up the permission viewset tests."""
super().setUp()
request = self.request_context["request"]
user = User()
user.username = self.user_data["username"]
user.account = self.customer_data["account_id"]
request.user = user
self.display_fields = {
"application", "resource_type", "verb", "permission"
}
with tenant_context(self.tenant):
self.permissionA = Permission.objects.create(
permission="rbac:roles:read")
self.permissionB = Permission.objects.create(permission="rbac:*:*")
self.permissionC = Permission.objects.create(permission="acme:*:*")
self.permissionD = Permission.objects.create(
permission="acme:*:write")
self.permissionE = Permission.objects.create(permission="*:*:*")
self.permissionF = Permission.objects.create(permission="*:bar:*")
self.permissionG = Permission.objects.create(permission="*:*:baz")
self.permissionH = Permission.objects.create(
permission="*:bar:baz")
self.permissionI = Permission.objects.create(
permission="foo:bar:*", description="Description test.")
def post_user(request):
netid = get_netid(request)
data_json = json.loads(request.body)
data = data_json[0]
# check if user exists
user_set = User.objects.filter(netid=netid)
if len(user_set) == 1: # if found, edit the user info
u = User.objects.get(netid=netid)
u.first_name = data["first_name"]
u.last_name = data["last_name"]
u.res_college = data["res_college"]
u.year = data["year"]
u.eating_club = data["eating_club"]
u.save()
return HttpResponse("User edited " + netid)
else: # create a new user
u = User(netid=netid,
first_name=data["first_name"],
last_name=data["last_name"],
res_college=data["res_college"],
year=data["year"],
eating_club=data["eating_club"])
u.save()
tolist = [netid]
subject = 'Welcome to Bixr'
message = "Hi " + data[
"first_name"] + ",\n\nThanks for joining Bixr and setting up your profile! To opt out of email notifications, visit your Account Settings at https://bixr.herokuapp.com/myprofile/account/ \n\n Sincerely,\n The Bixr Team"
notify(subject, message, tolist)
return HttpResponse("User created " + netid)
def create_dummy_users(quantity=2):
users = []
for x in range(2):
b = User(username=f'user_{x}', email=f'user{x}@email.com')
b.save()
users.append(b)
return users
def add_lawyer_judge(json_obj):
try:
y = json_obj
user_type = y['usr_type']
username = y["username"]
name = y["name"]
passw = y["password"]
address = y['usr_addr']
hashed_password = bcrypt.generate_password_hash(passw).decode('utf-8')
usr = User.query.filter_by(username=username).first()
if(usr):
return json.dumps({"add_status": "0", "err_msg": "Username Already Exists"})
user = User(username=username, address=address, name=name,
password=hashed_password, user_type=user_type)
db.session.add(user)
db.session.commit()
ret_val = {}
ret_val['add_status'] = "1"
ret_val['err_msg'] = "The account of has been created successfully!!"
ret_json = json.dumps(ret_val)
return ret_json
except:
db.session.rollback()
ret_val = {}
ret_val['add_status'] = "0"
ret_val['err_msg'] = "Sorry!!We were unable to create the account!! The username probably exists !!"
ret_json = json.dumps(ret_val)
return ret_json
def add_user():
post_data = request.get_json()
if not post_data:
response_object = {'status': 'fail', 'message': 'Invalid payload.'}
return jsonify(response_object), 400
username = post_data.get('username')
email = post_data.get('email')
try:
user = User.query.filter_by(email=email).first()
if not user:
db.session.add(User(username=username, email=email))
db.session.commit()
response_object = {
'status': 'success',
'message': f'{email} was added!'
}
return jsonify(response_object), 201
else:
response_object = {
'status': 'fail',
'message': 'Sorry. That email already exists.'
}
return jsonify(response_object), 400
except exc.IntegrityError as e:
db.session.rollback()
response_object = {'status': 'fail', 'message': 'Invalid payload.'}
return jsonify(response_object), 400
def adduserpass(username, password):
"""Register a new user with password"""
db.create_all()
user = User(username=username, password=password)
db.session.add(user)
db.session.commit()
print('User {0} was registered successfully.'.format(username))
async def create_user(user_create: UserCreate) -> 'UserDictNative':
user = User(**user_create.dict())
result = await collection.insert_one(user.dict())
user_dict = await collection.find_one({'_id': result.inserted_id})
return user_dict
def test_creation(self):
user = User('*****@*****.**')
user.save()
retrieved = User.query.filter_by(email='*****@*****.**').first()
assert retrieved == user
json = retrieved.to_dict()
assert json['email'] == '*****@*****.**'
def register():
username = request.json["username"]
password = request.json["password"]
email = request.json["email"]
user = User.query.filter(User.username == username).first()
# checking if entered username exists
if not user:
try:
new_user = User(username, email)
new_user.set_password(password)
db.session.add(new_user)
db.session.commit()
except:
return jsonify({"message": "An error occured, try again"})
# token generation
token = jwt.encode(
{
"user_id":
new_user.id,
"exp":
datetime.datetime.utcnow() + datetime.timedelta(minutes=200),
},
app.config["SECRET_KEY"],
)
return jsonify({"token": token.decode("UTF-8")})
else:
return {"message": "User already exists"}
def create(self, validated_data):
password = validated_data.pop('password')
user = User(**validated_data)
user.username = validated_data.get('email')
user.set_password(password)
user.save()
return user
def setUp(self):
"""Set up the access view tests."""
super().setUp()
request = self.request_context['request']
user = User()
user.username = self.user_data['username']
user.account = self.customer_data['account_id']
request.user = user
self.access_data = {
'permission':
'app:*:*',
'resourceDefinitions': [{
'attributeFilter': {
'key': 'key1',
'operation': 'equal',
'value': 'value1'
}
}]
}
with tenant_context(self.tenant):
self.principal = Principal(username=self.user_data['username'])
self.principal.save()
self.admin_principal = Principal(username="******")
self.admin_principal.save()
self.group = Group(name='groupA')
self.group.save()
self.group.principals.add(self.principal)
self.group.save()
def signup(username, password, phonenum, deviceid):
"""
Handles put requests for signups from our Android app
"""
# hash the password
pwhash = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
# check to see if a username is already in the database
userexist = User.objects.filter(username=username).exists()
if userexist:
return "User already exists"
user = User(username=username,
pwhash=pwhash,
phonenum=phonenum,
deviceid=deviceid)
user.save()
device = Device(deviceid=deviceid,
username=username,
pendingrequest=False,
requestgranted=False,
imagebytes='')
device.save()
return "User and Device added"
def setUp(self):
"""Set up the access view tests."""
super().setUp()
request = self.request_context["request"]
user = User()
user.username = self.user_data["username"]
user.account = self.customer_data["account_id"]
request.user = user
self.access_data = {
"permission":
"app:*:*",
"resourceDefinitions": [{
"attributeFilter": {
"key": "key1",
"operation": "equal",
"value": "value1"
}
}],
}
with tenant_context(self.tenant):
self.principal = Principal(username=self.user_data["username"])
self.principal.save()
self.admin_principal = Principal(username="******")
self.admin_principal.save()
self.group = Group(name="groupA")
self.group.save()
self.group.principals.add(self.principal)
self.group.save()
def app(user, plan_record):
app = create_app(test_config)
with app.app_context():
db.create_all()
admin_role = Role(name="admin")
user_role = Role(name="user")
db.session.add(admin_role)
db.session.add(user_role)
# Admin user
user.roles = [admin_role, user_role]
db.session.add(user)
# Non-admin user
non_admin = User(first="Example",
last="Person",
email="*****@*****.**")
non_admin.roles = [user_role]
db.session.add(non_admin)
place = Place(name="Lowell, MA", description="A town")
db.session.add(place)
plan = PlanSchema().load(plan_record)
plan.user = user
db.session.add(plan)
db.session.commit()
return app
def test_delete_a_person_for_a_successful_request( # pylint: disable=C0103
self, init_db, client, auth_header, new_role): # pylint: disable=W0613
"""
Test delete a person endpoint for when the request is successful
:param init_db: initialize database fixture
:param client: request client fixture
:param auth_header: authentication header fixture
:return: None
"""
center = Center(name='Kampala', image={'url': 'image url'})
center.save()
new_role.save()
person = User(name='Paul',
email='*****@*****.**',
image_url='url',
role_id=new_role.id,
center_id=center.id)
person.save()
response = client.delete(
f'{API_V1_BASE_URL}/centers/{center.id}/people/{person.id}',
headers=auth_header)
response_json = json.loads(response.data.decode(CHARSET))
assert response.status_code == 200
assert response_json['status'] == 'success'
assert response_json['message'] == SUCCESS_MESSAGES[
'person_deleted'].format(person.name)
