from models.user import User
list_users = [
User(username='******', password='******', email='*****@*****.**', profile_picture='https://www.insidehook.com/wp-content/uploads/2019/03/futurama.jpg?fit=1280%2C720'),
User(username='******', password='******', email='*****@*****.**', profile_picture='https://www.middlebury.edu/office/sites/www.middlebury.edu.office/files/2019-08/big-bird-portrait_0.jpg?fv=ktnJn2IK'),
User(username='******', password='******', email='*****@*****.**', profile_picture='https://i.pinimg.com/originals/b0/88/e5/b088e5db6b560a33fc20e666a46263b3.jpg'),
User(username='******', password='******', email='*****@*****.**', profile_picture='https://mfl.global/wp-content/uploads/2017/06/David-M-630x700.jpg')
]
def test_args(self):
"""Arguments to the instance"""
b = User(8)
self.assertEqual(type(b).__name__, "User")
self.assertFalse(hasattr(b, "8"))
def create_user(email, password, f_name,
l_name): #Called from auth_controller.py in the register route
new_user = User(email, password, f_name, l_name)
return new_user.save()
#!/usr/bin/python3
from models import storage
from models.base_model import BaseModel
from models.user import User
from models.city import City
all_objs = storage.all()
print("-- Reloaded objects --")
for obj_id in all_objs.keys():
obj = all_objs[obj_id]
print(obj)
print("-- Create a new User --")
my_user = User()
my_user.first_name = "Betty"
my_user.last_name = "Holberton"
my_user.email = "*****@*****.**"
my_user.password = "******"
my_user.save()
print(my_user)
print("-- Create a new User 2 --")
my_user2 = User()
my_user2.first_name = "John"
my_user2.email = "*****@*****.**"
my_user2.password = "******"
my_user2.save()
print(my_user2)
print("-- Create a new City --")
my_city = City()
def setUpClass(cls):
""" create instance for test """
cls.user = User()
def test_ids_maker(self):
""" test to generate unique id """
user1_id = User()
user2_id = User()
self.assertNotEqual(user1_id, user2_id)
def load_user(userid):
user_doc = User.get(userid, collection)
return User(user_doc['username'])
def create_users(uid_list):
"""Creates a list of users."""
user_list = [User(uuid=uid, nickname=uid) for uid in uid_list]
ndb.put_multi(user_list)
import pdb
from models.task import Task
from models.user import User
import repositories.task_repository as task_repository
import repositories.user_repository as user_repository
task_repository.delete_all()
user_repository.delete_all()
user_1 = User("Kenny", "McKeown")
user_repository.save(user_1)
user_2 = User("Jeffy", "McTavenish")
user_repository.save(user_2)
task = Task("walk the dog", user_1, 60, True)
pdb.set_trace()
def delete_user_controller():
if (not request.json or not 'login' in request.json):
abort(400)
user = User(request.json['login'])
return jsonify({'status': 'OК'}) if delete_user(user) else abort(404)
def create_user(uid):
"""Creates a user."""
user = User(uuid=uid, nickname=uid)
user.put()
def test_user_save_method(self):
"""User save method alters update_at date"""
user = User()
time.sleep(0.0001)
user.save()
self.assertNotEqual(user.updated_at, user.created_at)
def test_user_updated_at_matches_created_at_initialization(self):
"""User updated_at is same as create_at"""
user = User()
self.assertEqual(user.updated_at, user.created_at)
def setUp(self):
""" setup tests """
self.model = User()
from models.amenity import Amenity
from models.place import Place
from models.review import Review
print("creation of a State")
state = State(name="California")
state.save()
print("----------------------")
print("\ncreation of a City")
city = City(state_id=state.id, name="San Francisco")
city.save()
print("----------------------")
print("\ncreation of a User")
user = User(email="*****@*****.**", password="******")
user.save()
print("----------------------")
print("\ncreation of 2 Places")
place_1 = Place(user_id=user.id, city_id=city.id, name="House 1")
place_1.save()
print("----------------------")
place_2 = Place(user_id=user.id, city_id=city.id, name="House 2")
place_2.save()
print("----------------------")
print("\ncreation of 3 various Amenity")
amenity_1 = Amenity(name="Wifi")
amenity_1.save()
print("----------------------")
def tickets_choose_free(user_id=None):
has_price = TicketPrice.query.filter(TicketPrice.price_int > 0)
free_tts = TicketType.query.filter(
~has_price.filter(TicketPrice.type.expression).exists(), ).order_by(
TicketType.order).all()
if user_id is None:
form = FreeTicketsNewUserForm()
user = None
new_user = True
else:
form = FreeTicketsForm()
user = User.query.get_or_404(user_id)
new_user = False
if request.method != 'POST':
for tt in free_tts:
form.types.append_entry()
form.types[-1].type_id.data = tt.id
tts = {tt.id: tt for tt in free_tts}
for f in form.types:
f._type = tts[f.type_id.data]
# TODO: apply per-user limits
values = range(f._type.personal_limit + 1)
f.amount.values = values
f._any = any(values)
if form.validate_on_submit():
if new_user:
app.logger.info('Creating new user with email %s and name %s',
form.email.data, form.name.data)
user = User(form.email.data, form.name.data)
flash('Created account for %s' % form.email.data)
tickets = []
for f in form.types:
if f.amount.data:
tt = f._type
for i in range(f.amount.data):
t = Ticket(type=tt, user_id=user_id)
t.paid = True
user.tickets.append(t)
tickets.append(t)
app.logger.info('Allocated %s %s tickets to user',
f.amount.data, tt.name)
db.session.add(user)
db.session.commit()
code = user.login_code(app.config['SECRET_KEY'])
send_template_email('Your complimentary tickets to EMF',
user.email,
app.config['CONTACT_EMAIL'],
'emails/tickets-free.txt',
user=user,
code=code,
tickets=tickets,
new_user=new_user)
flash('Allocated %s ticket(s)' % len(tickets))
return redirect(url_for('.tickets_choose_free'))
if new_user:
users = User.query.order_by(User.id).all()
else:
users = None
return render_template('admin/tickets-choose-free.html',
form=form,
tts=free_tts,
user=user,
users=users)
def test_instace(self):
""" test instance """
test1 = User()
self.assertIsInstance(test1, User)
def query_user_self():
currentUserId = get_jwt_identity()
users = mongo.db.user.find_one_or_404({'_id': currentUserId})
user = User(entries=users)
return user.serialize()
from models.user import User
from models.tweet import Tweet
from models.rule import Rule
from database import get_db_session
from crypt import crypt
from sqlalchemy import exc
from sqlalchemy.dialects import mysql
session = get_db_session()
if session.query(User).filter(User.email == "*****@*****.**").count() == 0:
myuser = User(fullname='leon',
email='*****@*****.**',
password='******',
admin=1)
session.add(myuser)
session.commit()
print myuser.id
else:
print "Email address taken"
query = session.query(User).filter(User.email == "*****@*****.**")
user = query.one()
print user.validate_password('password')
query = session.query(Tweet).filter(Tweet.timestam == "1381824130")
tweet = query.one()
print tweet.id
query = session.query(Rule).join(User).filter(Rule.userid == User.id)
print str(query.statement.compile(dialect=mysql.dialect()))
def test_str_method(self):
"""Tests to see if each method is printing accurately"""
obj = User()
objprinted = obj.__str__()
self.assertEqual(objprinted,
"[User] ({}) {}".format(obj.id, obj.__dict__))
def home():
users = User().select()
return render_template('home.html',users = users)
return dict(
(cursor.description[idx][0], value) for idx, value in enumerate(row))
db = sqlite3.connect('.data/db.sqlite')
db.row_factory = make_dicts
cur = db.cursor()
User.create_table(cur)
Table.create_table(cur)
Column.create_table(cur)
Task.create_table(cur)
users = [
User("Ford", "zda", "*****@*****.**", "12345"),
User("Arthur", "firero", "*****@*****.**", "12345"),
User("ismail", "Aissami", "[email protected]", "12345"),
User("sana", "kriaa", "*****@*****.**", "aaa")
]
tables = [Table("Table1", "[email protected]"), Table("Table2", "[email protected]")]
columns = [Column("colonne1", "Table1"), Column("colonne2", "Table1")]
tasks = [Task("descrep1", "colonne1"), Task("descrep2", "colonne1")]
for user in users:
user.insert(cur)
for table in tables:
#!/usr/bin/python3
""" Main 0
"""
import base64
from api.v1.auth.basic_auth import BasicAuth
from models import db_session
from models.user import User
""" Create a user test """
user_email = "*****@*****.**"
user_clear_pwd = "H0lbertonSchool98!"
user = User()
user.email = user_email
user.password = user_clear_pwd
print("New user: {}".format(user))
db_session.add(user)
db_session.commit()
basic_clear = "{}:{}".format(user_email, user_clear_pwd)
print("Basic Base64: {}".format(
base64.b64encode(basic_clear.encode('utf-8')).decode("utf-8")))
def setUpClass(cls):
cls.user1 = User()
cls.user1.email = '*****@*****.**'
cls.user1.password = '******'
cls.user1.first_name = 'Lisa'
cls.user1.last_name = 'Olson'
def test_isinstance(self):
""""Test if is an instance of the class"""
obj = User()
self.assertIsInstance(obj, User)
class HBNBCommand(cmd.Cmd):
""" contains the entry point of the command interpreter """
classes_str = [
'BaseModel', 'User', 'State', 'City', 'Amenity', 'Place', 'Review'
]
classes = [
BaseModel(),
User(),
State(),
City(),
Amenity(),
Place(),
Review()
]
prompt = "(hbnb) "
def default(self, inp):
""" Method called to complete an input line when no command-specific
complete_*() method is available """
args = inp.split('.')
for cont in range(len(self.classes_str)):
for key in self.classes_str:
if key == args[0]:
if args[1] == 'all()':
self.do_all(args[0])
return False
elif args[1] == 'count()':
cont = 0
for key, val in storage.all().items():
classe = key.split('.')
if args[0] == classe[0]:
cont += 1
print(cont)
return False
elif args[1][0:5] == 'show(':
id = args[1][5:-1]
line = args[0] + ' ' + id
self.do_show(line)
return False
elif args[1][0:8] == 'destroy(':
id = args[1][8:-1]
line = args[0] + ' ' + id
self.do_destroy(line)
return False
elif args[1][0:7] == 'update(':
argus = args[1][7:-1].split(', ')
new_value = '"{}"'.format(argus[2])
id = argus[0]
att = argus[1]
line = args[0] + ' ' + id + ' ' + att + ' ' + new_value
self.do_destroy(line)
return False
def do_quit(self, inp):
"""Quit command to exit the program
"""
return True
def emptyline(self):
return False
def do_EOF(self, inp):
"""Exit the program
"""
return True
def do_create(self, inp):
"""Creates a new instance of BaseModel,
saves it (to the JSON file) and prints the id"""
args = shlex.split(inp)
if len(args) == 0:
print("** class name missing **")
return False
aux = 0
for cont in range(len(self.classes_str)):
if args[0] == self.classes_str[cont]:
obj = self.classes[cont]
obj.save()
print(obj.id)
aux = 1
return False
if aux == 0:
print("** class doesn't exist **")
return False
def do_show(self, inp):
"""Prints the string representation of an instance
based on the class name and id"""
args = shlex.split(inp)
if len(args) == 0:
print("** class name missing **")
return False
if not args[0] in self.classes_str:
print("** class doesn't exist **")
return False
for cont in range(len(self.classes_str)):
if args[0] == self.classes_str[cont]:
if len(args) > 1:
txt = storage.all()
obj = args[0] + "." + args[1]
if obj in txt:
print(txt[obj])
return False
else:
print("** no instance found **")
return False
else:
print("** instance id missing **")
return False
def do_destroy(self, inp):
"""Deletes an instance based on the class name and id"""
args = shlex.split(inp)
if len(args) == 0:
print("** class name missing **")
return False
if not args[0] in self.classes_str:
print("** class doesn't exist **")
return False
for cont in range(len(self.classes_str)):
if args[0] == self.classes_str[cont]:
if len(args) > 1:
txt = storage.all()
obj = args[0] + "." + args[1]
if obj in txt:
storage.all().pop(obj)
storage.save()
return False
else:
print("** no instance found **")
return False
else:
print("** instance id missing **")
return False
def do_all(self, inp):
"""Prints all string representation of all instances
based or not on the class name"""
args = shlex.split(inp)
n_list = []
if len(args) == 0:
for key, val in storage.all().items():
n_list.append(val.__str__())
print(n_list)
return False
if not args[0] in self.classes_str:
print("** class doesn't exist **")
return False
for cont in range(len(self.classes_str)):
for key, val in storage.all().items():
if val.__class__.__name__ == args[0]:
n_list.append(val.__str__())
print(n_list)
return False
def do_update(self, inp):
"""Updates an instance based on the class name and id
by adding or updating attribute (save the change into
the JSON file)"""
args = shlex.split(inp)
if len(args) == 0:
print("** class name missing **")
return False
for cont in range(len(self.classes_str)):
if not args[0] in self.classes_str:
print("** class doesn't exist **")
return False
elif len(args) < 2:
print("** instance id missing **")
return False
elif args[0] + '.' + args[1] not in \
storage.all().keys():
print("** no instance found **")
return False
elif len(args) < 3:
print("** attribute name missing **")
return False
elif len(args) < 4:
print("** value missing **")
return False
else:
obj = storage.all().get(args[0] + '.' + args[1])
setattr(obj, args[2], "{}".format(args[3]))
obj.save()
return
def generate_user(account_id, username,roleid):
usr = User(username=username,password='******',RoleID=roleid,title='Users Title',AccountID=account_id,Email="*****@*****.**",LastName="LastName", FirstName="FirstName")
usr.save()
uid = usr.UserID
#uid = User.create(username, account_id, "test", "test", title="Users Title", email="*****@*****.**", first_name="FirstName", last_name="LastName")
return uid
def setUpClass(cls):
cls.my_user = User()
cls.my_user.first_name = "Betty"
cls.my_user.last_name = "Holberton"
cls.my_user.email = "*****@*****.**"
cls.my_user.password = "******"
def add_test_user(self):
user = User({"username": self.testname})
user.hash_password(self.testpass)
return self.user_store.add_user_to_index(user)
def initialize_user_if_new(self):
if not self.actor.is_user():
self.actor.user = self.user = User(self.params.nick)
