def api_get_users(*, page='0', pagesize='0'):
users = (yield from User().find(limit=int(pagesize),
offset=int(pagesize) * int(page)))['data']
for user in users:
logging.info('user: %s' % user)
return dict(users=users)
def api_blog_detail(*, id=0):
blogs = (yield from Blog(id=id).find())['data']
for blog in blogs:
# blog.createtime = datetime.strptime(blog.createtime, '%Y-%m-%d %H:%M:%S,%f').timestamp()
user = (yield from User(id=blog.userid).find())['data'][0]
blog.author = user
return {'blog': blogs[0]}
def api_user_authenticate(*, email, password):
if not email or not email.strip():
raise APIValueError('email', 'email is Null')
if not _RE_EMAIL.match(email):
raise APIValueError('email', 'email is not format')
if not password or not password.strip():
raise APIValueError('password', 'password is Null')
users = (yield from User(email=email).find())['data']
if len(users) == 0:
raise APIValueError('email', 'email is not in use')
user = users[0]
sha1_password = '******' % (user.id, password)
if hashlib.sha1(
sha1_password.encode('utf-8')).hexdigest() != user.password:
raise APIValueError('password', 'password is error')
rep = web.Response()
rep.content_type = 'application/json'
rep.set_cookie(_COOKIE_NAME,
user2cookie(user, 86400),
max_age=86400,
httponly=True)
user.password = '******'
rep.body = json.dumps(user, ensure_ascii=False).encode('utf-8')
return rep
def register(session: Session, email: str, password: str, given_name: str, last_name: str,
phone: str) -> RegisterResult:
"""
Register a new user in the application.
:param given_name: The users given name to register with.
:param last_name: The users last name to register with.
:param phone: The users mobile phone number.
:param session: A SQLAlchemy Session for the query.
:param email: The email to register with, this is also the username.
:param password: The password to register with.
:return: The result of the registration process.
"""
# Validate the data integrity of the parameters
if email is None:
return RegisterResult.BAD_USERNAME
if password is None or not passwordService.validate(password):
return RegisterResult.BAD_PASSWORD
# Check to see if the user already exists
existing_user = session.query(User) \
.filter(User.email == email) \
.first()
if existing_user is not None:
return RegisterResult.USERNAME_ALREADY_REGISTERED
# Everything seems fine, so we go ahead and create the user & the linked account.
password_hash = passwordService.hash(password)
new_user = User(role=UserType.VOLUNTEER, password=password_hash, first_name=given_name, last_name=last_name,
mobile_number=phone, email=email, preferred_hours={}, experience_years=0, possibleRoles=["Basic"],
qualifications=[],
availabilities={"Friday": [], "Monday": [], "Sunday": [], "Tuesday": [], "Saturday": [],
"Thursday": [], "Wednesday": []})
session.add(new_user)
session.flush()
return RegisterResult.SUCCESS
def api_get_blogs(request):
blogs = (yield from Blog().find())['data']
for blog in blogs:
blog.createtime = datetime.strptime(
blog.createtime, '%Y-%m-%d %H:%M:%S,%f').timestamp()
user = (yield from User(id=blog.userid).find())['data'][0]
blog.author = user
return {'__template__': 'blogs.html', 'blogs': blogs}
def execute(self, request):
response = Response()
try:
for post in [p['data'] for p in request.endpoint_data['data']['children']]:
user_id = self.user_repo.add_user(User(name = post['author'], ups = post['ups'], comments = post['num_comments']))
created_time = datetime.fromtimestamp(post['created_utc'], tz = pytz.timezone(request.timezone))
self.post_repo.add_post(Post(title = post['title'], ups = post['ups'], comments = post['num_comments'], created = created_time, author = user_id))
return response
except Exception as e:
response.add_exception_error(e)
return response
def test_get_ladders_when_in_a_ladder_should_put_your_ladder_at_the_top_and_have_true_flag(self):
with patch.object(self.manager.dao, "get_ladders", return_value=[
fixtures.ladder(1, "Ladder 1", date.today(), date.today(), False),
fixtures.ladder(2, "Ladder 2", date.today(), date.today(), False),
]):
with patch.object(self.manager.dao, "get_users_ladder_ids", return_value=[2]):
self.manager.user = User("TEST1", "User", "*****@*****.**", "555-555-5555", "user.jpg", "availability", False)
ladders = self.manager.get_ladders()
self.assertEqual(2, len(ladders))
self.assertEqual(2, ladders[0].ladder_id)
self.assertTrue(ladders[0].logged_in_user_has_joined)
self.assertEqual(1, ladders[1].ladder_id)
self.assertFalse(ladders[1].logged_in_user_has_joined)
def api_user_register(*, name, password, email):
if not name or not name.strip():
raise APIValueError('name', 'name is Null')
if not password or not password.strip():
raise APIValueError('password', 'password is Null')
if not email or not email.strip():
raise APIValueError('email', 'email is Null')
if not _RE_EMAIL.match(email):
raise APIValueError('email: %s' % email, 'email is no format')
users = (yield from User(email=email).find())['data']
if len(users) > 0:
raise APIValueError('email', 'email: %s is already in use' % email)
uid = next_id()
sha1_password = '******' % (uid, password)
user = User(id=uid,
name=name,
password=hashlib.sha1(
sha1_password.encode('utf-8')).hexdigest(),
email=email,
image='./res/tumble.png')
res = yield from user.save()
rep = web.Response()
rep.content_type = 'application/json'
if res == 1:
logging.info('save user sucessed')
rep.set_cookie(_COOKIE_NAME,
user2cookie(user, 86400),
max_age=86400,
httponly=True)
user.password = '******'
rep.body = json.dumps(user, ensure_ascii=False).encode('utf-8')
else:
logging.error('user save error')
raise APIError('register', 'save', 'register failed')
return rep
def api_blog_list(*, page='0'):
try:
if int(page) < 0:
page = 0
except Exception as e:
logging.exception(e)
page = 0
page = int(page)
pagesize = 5
data = (yield from Blog().find(index=page, limit=pagesize))
blogs = data['data']
info = data['info']
for blog in blogs:
# blog.createtime = datetime.strptime(blog.createtime, '%Y-%m-%d %H:%M:%S,%f').timestamp()
user = (yield from User(id=blog.userid).find())['data'][0]
blog.author = user
return {"blogs": blogs, "page": info}
def list_users(self, order):
"""
Lists users ordering the results according to the constraints defined by the parameters of the function
Args:
order (datetime): How the users must be ordered. Options are 'ups' (number of upvotes) or 'comments' number of comments
Returns:
[List(User)]: List of Users ordered accordingly
"""
try:
order_clause = DbUser.comments.desc(
) if order == 'comments' else DbUser.ups.desc()
db_users = DbUser.select().order_by(order_clause)
return [
User(name=u.name, ups=u.ups, comments=u.comments)
for u in db_users
]
except Exception as e:
raise Exception('error listing user')
def validate_token(self, token):
if token is None:
return
try:
firebase_user = self.firebase_client.get_firebase_user(token)
self.user = self.dao.get_user(firebase_user["user_id"])
if self.user is None:
print("Creating new user: "******"user_id"],
name=firebase_user.get("name", "Unknown"),
email=firebase_user["email"],
phone_number=None,
photo_url=firebase_user.get("picture") if firebase_user.get("picture") != "" else None,
availability_text=None,
admin=False
)
self.dao.create_user(self.user)
except Exception as error:
print("Token auth error: ", error)
self.user = None
def cookie2user(zip_cookie):
if not zip_cookie:
return None
try:
unzip_cookie = zip_cookie.split('-')
if len(unzip_cookie) != 3:
return None
uid, duration, sha1 = unzip_cookie
if int(duration) < time.time():
return None
users = (yield from User(id = uid).find())['data']
user = users[0]
if user is None:
return None
cookies = '%s-%s-%s-%s' % (user.id, user.password, duration, COOKIE_KEY)
if sha1 != hashlib.sha1(cookies.encode('utf-8')).hexdigest():
logging.info('invalid sha1')
return None
user.password = '******'
return user
except Exception as e:
logging.exception(e)
return None
def user(user_id="", name="", email="", phone_number=None, photo_url=None, availability_text=None, admin=False) -> User:
return User(user_id, name, email, phone_number, photo_url, availability_text, admin)
def get_app():
container = Container('app')
container.register_type(EngineWrapper).to_type(EngineWrapper)
container.register_type(SessionWrapper).to_type(SessionWrapper)
container.register_type(DBConn).to_type(DBConn)
# for user
container.register_value(RecordTransformer(
lambda record: User(record.id, record.name, record.password,
Role(record.role)),
lambda user: UserRecord(user.user_id, user.username, user.password,
'', int(user.role)))) \
.to_type(UserRecordTransformer)
# for announcements
container.register_value(
RecordTransformer(
lambda record: Announcement(record.title, record.text, record.date
),
lambda announcement: AnnouncementRecord(
announcement.title, announcement.text, announcement.date))
).to_type(AnnouncementRecordTransformer)
container.register_value(
JsonTransformer(lambda json: Announcement(json['title'], json[
'text'], str(datetime.now().date())))).to_type(
AnnouncementJsonTransformer)
container.register_value(Filter(lambda x: True)) \
.to_type(AnnouncementFilter)
container.register_type(DBAnnouncement) \
.to_type(DBAnnouncement)
container.register_type(AnnouncementDesk, Instantiation.Singleton). \
to_type(AnnouncementDesk) \
.with_params(name='announcements')
container.register_type(AnnouncementProvider, Instantiation.Singleton). \
to_type(AnnouncementProvider)
# for requests
container.register_value(RecordTransformer(
lambda record: Request(record.id, record.topic, record.comment,
record.username, record.date,
record.approved),
lambda request: RequestRecord(request.id, request.topic,
request.comment, request.username,
request.date, request.approved))) \
.to_type(RequestRecordTransformer)
container.register_value(JsonTransformer(
lambda json: Request(0, json['topic'],
json['comment'], json['username'],
str(datetime.now().date()),
False))) \
.to_type(RequestJsonTransformer)
container.register_value(Filter(lambda record: not record.approved)) \
.to_type(RequestFilter)
container.register_type(DBRequest).to_type(DBRequest)
container.register_type(RequestDesk, Instantiation.Singleton). \
to_type(RequestDesk) \
.with_params(name='requests')
container.register_type(RequestProvider, Instantiation.Singleton). \
to_type(RequestProvider)
# for table request
container.register_value(RecordTransformer(
lambda record: TableRequest(record.id, record.number,
record.date, record.username),
lambda request: TableRequestRecord(request.id, request.number,
request.date,
request.username))). \
to_type(TableRequestRecordTransformer)
container.register_value(JsonTransformer(
lambda json: TableRequest(0, json['number'],
json['date'], json['username']))) \
.to_type(TableRequestJsonTransformer)
container.register_value(Filter(lambda x: True)) \
.to_type(TableRequestFilter)
container.register_type(DBTableRequest) \
.to_type(DBTableRequest)
container.register_type(TableRequestDesk, Instantiation.Singleton) \
.to_type(TableRequestDesk).with_params(name='table_requests')
container.register_type(TableRequestProvider, Instantiation.Singleton) \
.to_type(TableRequestProvider)
container.register_value(7).to_name('entry_count')
container.register_type(DBUser) \
.to_type(DBUser)
container.register_type(UserManager, Instantiation.Singleton) \
.to_type(UserManager)
container.register_type(UserController, Instantiation.Singleton) \
.to_type(UserController)
container.register_type(Authentication, Instantiation.Singleton) \
.to_type(Authentication)
container.register_type(RouteManager, Instantiation.Singleton) \
.to_type(RouteManager)
routes = container.resolve_type(RouteManager)
app = Flask(__name__, static_folder='./static/build', static_url_path='/')
app.config.from_object(Config)
app.register_blueprint(routes.Routes)
@app.route('/')
@app.route('/admin')
@app.route('/login')
@app.route('/request')
@app.route('/table_request')
def req():
return app.send_static_file('index.html')
return app
from domain import Auction, User, Bid
paulo = User("Paulo")
amanda = User("Amanda")
paulo_bid = Bid(paulo, 100.0)
amanda_bid = Bid(amanda, 150.0)
auction = Auction("Notebook")
auction.bet(paulo_bid)
auction.bet(amanda_bid)
for bid in auction.bids:
print(f"{bid.user.name.title()} has bet {bid.value}")
print(f"Highest bid: {auction.highest_bid}")
print(f"Lowest bid: {auction.lowest_bid}")
