def users(query=None,
tag=None,
flags=None,
page=1,
next_page_url=None,
prev_page_url=None,
scroll=False,
selected=None):
current_user = UserController().current_user
template = TEMPLATE_USERS
users, relationship_types = UserController().get_users(query=query,
tag=tag,
page=page)
chips = {
'tags':
_parse_chip([{
'chip_name': k,
'selected': k in tag if tag else False
} for k in relationship_types],
key='t',
mode=Tag.EXCLUSIVE,
display_name='Type')
}
vargs = {'users': users, 'selected': selected, 'chips': chips}
if request.is_xhr:
return render_template(template, vargs=vargs, **vargs)
return render_template(TEMPLATE_MAIN,
template=template,
vargs=vargs,
**vargs)
def get_event(self, event_id):
event = Event.query.filter(Event.event_id == event_id).first()
if not event: return None
user = UserController().current_user
if user:
user_event = UserEvent.query.filter(
and_(UserEvent.event_id == event.event_id,
UserEvent.user_id == user.user_id)).first()
if user_event:
event.current_user_event = user_event
following_event_users = db_session.query(User).filter(
and_(UserEvent.event_id == event.event_id,
UserEvent.user_id == User.user_id,
Follow.user_id == user.user_id,
Follow.follow_id == User.user_id,
User.user_id != user.user_id, Follow.active == True))
event.card_event_users = [{
"user_id": u.user_id,
"username": u.username,
"image_url": u.image_url
} for u in following_event_users]
user_event_count = UserEvent.query.filter(
and_(UserEvent.event_id == event_id,
UserEvent.interest > UserEvent.interest_level(UserEvent.SKIP),
UserEvent.interest <= (max(UserEvent.DONE_LEVELS)))).count()
event.card_user_count = user_event_count
return event
def decorated(*args, **kwargs):
token = request.headers.get("Authorization", None)
if not token:
raise ValidationError(
message="error",
status_code=401,
payload={"message": "No auth token"},
)
try:
data = jwt.decode(token,
current_app.config["SECRET_KEY"],
algorithms=["HS256"])
controller = UserController()
user = controller.find_one(email=data.get("email"))
if not user:
raise ValidationError(
message="error",
status_code=401,
payload={"message": "Invalid token"},
)
request.user = user
except Exception as error:
raise ValidationError(
message=str(error),
status_code=401,
payload={
"message": "AN error occurred when checking credential"
},
)
return f(*args, **kwargs)
def auth_callback():
if 'state' not in session:
return redirect('/')
state = session['state']
flow = get_oauth2_config(state=state)
flow.redirect_uri = get_oauth2_callback()
authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)
credentials = flow.credentials
session['credentials'] = {
'token': credentials.token,
'refresh_token': credentials.refresh_token,
'token_uri': credentials.token_uri,
'client_id': credentials.client_id,
'client_secret': credentials.client_secret,
'scopes': credentials.scopes
}
if 'state' in session:
del session['state']
UserController()._request_user_info()
ref_parsed = urlparse(request.referrer)
app_parsed = urlparse(url_for('events'))
redirect_url = '/'
if (ref_parsed.scheme == app_parsed.scheme
and ref_parsed.netloc == app_parsed.netloc):
redirect_url = request.referrer
return redirect(redirect_url)
def update_event(self, event_id, interest_key):
user_id = UserController().current_user_id
if user_id:
user_event = UserEvent.query.filter(
and_(UserEvent.user_id == user_id,
UserEvent.event_id == event_id)).first()
if user_event:
if interest_key == UserEvent.DONE:
if user_event.interest_key == interest_key:
user_event.interest = user_event.interest - 2
else:
user_event.interest = user_event.interest + 2
elif user_event.interest_key == interest_key:
user_event.interest = None
else:
user_event.interest = UserEvent.interest_level(
interest_key)
db_session.merge(user_event)
else:
user_event = UserEvent(
user_id=user_id,
event_id=event_id,
interest=UserEvent.interest_level(interest_key))
db_session.add(user_event)
db_session.commit()
return self.get_event(event_id)
return None
def decorated(*args, **kwargs):
token = request.headers.get('Authorization', None)
if not token:
raise ValidationError(message='error',
status_code=401,
payload={'message': 'No auth token'})
try:
data = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithms=['HS256'])
controller = UserController()
user = controller.find_one(email=data.get('email'))
if not user:
raise ValidationError(message='error',
status_code=401,
payload={'message': 'Invalid token'})
request.user = user
except Exception as error:
raise ValidationError(
message=str(error),
status_code=401,
payload={
'message': 'AN error occurred when checking credential'
})
return f(*args, **kwargs)
def user_update(identifier):
current_user = UserController().current_user
current_user_id = UserController().current_user_id
action = request.form.get('action')
active = request.form.get('active') == 'true'
if action == 'block':
u = UserController().block_user(identifier, active)
elif action == 'follow':
u = UserController().follow_user(identifier, active)
if u:
events = []
if not Block.blocks(u.user_id, current_user_id):
events = EventController().get_events_for_user_by_interested(
user=u, interested=UserEvent.INTERESTED)
return redirect(request.referrer or '/')
def post(self):
request_data = api.payload
api.schema_model('User', {**user_login_schema}).validate(request_data)
controller = UserController()
user = controller.find_one(email=request_data.get('email'))
if user and check_password_hash(user.password,
request_data['password']):
token = generate_token(user)
return {'token': token, **user._asdict()}, 200
raise ValidationError(message='error',
status_code=401,
payload={'message': 'Invalid credentials'})
def post(self):
user = api.payload
api.schema_model('User', {**user_schema}).validate(user)
user['password'] = generate_password_hash(user['password'],
method='sha256')
controller = UserController()
if not controller.find_one(email=user.get('email')):
user = controller.insert(user)
return user, 201
raise ValidationError(
message='error',
status_code=400,
payload={'message': 'User with email already exists'})
def post(self):
request_data = api.payload
api.schema_model("User", {**user_login_schema}).validate(request_data)
controller = UserController()
user = controller.find_one(email=request_data.get("email"))
if user and check_password_hash(user.password,
request_data["password"]):
token = generate_token(user)
return {"token": token, **user._asdict()}, 200
raise ValidationError(
message="error",
status_code=401,
payload={"message": "Invalid credentials"},
)
def post(self):
user = api.payload
api.schema_model("User", {**user_schema}).validate(user)
user["password"] = generate_password_hash(user["password"],
method="sha256")
controller = UserController()
if not controller.find_one(email=user.get("email")):
user = controller.insert(user)
return user, 201
raise ValidationError(
message="error",
status_code=400,
payload={"message": "User with email already exists"},
)
def events(query=None,
category=None,
tag=None,
cities=None,
flags=None,
page=1,
next_page_url=None,
prev_page_url=None,
lat=None,
lon=None,
scroll=False,
selected=None):
selected_categories = category
current_user = UserController().current_user
if tag == Tag.TVM:
cities = None
events, categories, tags, event_cities = EventController().get_events(
query=query,
categories=category,
tags=tag,
cities=cities,
flags=flags,
page=page)
chips = _parse_chips(selected_categories=selected_categories,
categories=categories,
tags=tags,
cities=event_cities,
flags=flags)
vargs = {
'current_user': current_user,
'events': events,
'selected': selected,
'chips': chips,
'page': page,
'next_page_url': next_page_url,
'prev_page_url': prev_page_url
}
return _render_events_list(request,
events,
vargs,
scroll=scroll,
template=TEMPLATE_EXPLORE)
def session(self, user):
""" Main Session method. Aims at finding session or creating if doesnt exist for user
:type user: str
:rtype session_id: str
"""
user_controller = UserController()
user_logged = user_controller.login(user)
if user_logged:
user_session = user_controller.get_user_session(user)
return user_session
else:
new_session = self._create_random_session(user)
user_controller.create_user(user, new_session)
return new_session
def event_update(event_id):
current_user = UserController().current_user
is_card = request.form.get('card') == 'true'
choice = request.form.get('choice')
if choice in UserEvent.interest_keys():
interest_key = choice
else:
interest_key = None
callback = request.form.get('cb')
if callback == "/": callback = 'events'
event = EventController().update_event(event_id=event_id,
interest_key=interest_key)
if event:
template = TEMPLATE_EVENT_CARD if is_card else TEMPLATE_EVENT_PAGE
categories_set = set()
tag_chips = []
for t in event.tags:
categories_set.add(t.tag_type)
tag_chips.append({'chip_name': t.tag_name})
category_chips = [{'chip_name': c} for c in categories_set]
chips = _parse_chips(categories=category_chips, tags=tag_chips)
vargs = {
'current_user': current_user,
'event': event,
'chips': chips,
'card': is_card
}
if request.is_xhr:
if template == TEMPLATE_EVENT_PAGE:
template = TEMPLATE_EVENT_PAGE_BODY
return render_template(template, vargs=vargs, **vargs)
if callback:
return redirect(callback)
return render_template(TEMPLATE_MAIN,
template=template,
vargs=vargs,
**vargs)
return redirect(request.referrer or '/')
def event(event_id):
event = EventController().get_event(event_id=event_id)
current_user = UserController().current_user
if event:
template = TEMPLATE_EVENT_PAGE
vargs = {
'title': event.display_name,
'current_user': current_user,
'event': event
}
if request.is_xhr:
return render_template(template, vargs=vargs, **vargs)
return render_template(TEMPLATE_MAIN,
template=template,
vargs=vargs,
**vargs)
return redirect(request.referrer or '/')
def get_events(self,
query=None,
categories=None,
tags=None,
cities=None,
flags=None,
page=1,
future_only=False):
current_user = UserController().current_user
selected_categories = set(categories.split(',') if categories else [])
selected_tags = set(tags.split(',') if tags else [])
events_with_counts = db_session.query(
Event,
func.count(func.distinct(
UserEvent.user_id)).label('ct')).outerjoin(
UserEvent, UserEvent.event_id == Event.event_id).group_by(
Event.event_id).order_by(desc('ct'))
if current_user:
current_user_events_table = alias(current_user.user_events(),
'current_user_events_table')
events_with_counts = events_with_counts.filter(~Event.event_id.in_(
db_session.query(
current_user_events_table.c.user_events_event_id)))
results, categories, tags, event_cities, results_table = self._process_events(
events=events_with_counts,
cities=cities,
page=page,
query=query,
user=current_user,
selected_categories=selected_categories,
selected_tags=selected_tags,
flags=flags,
future_only=future_only)
return results, categories, tags, event_cities
def logout():
UserController()._logout()
return redirect('/')
def update_user(current_user):
user_controller = UserController()
return user_controller.Update(request.get_json(), current_user)
def debug():
user_info = UserController()._request_user_info()
class UserInterface:
user_controller = UserController()
reservation_controller = ReservationController()
validator = CinemaValidator()
def reg_or_log(self):
while True:
print('You need to log in or register first!\n'
'Enter what u want to do!\n1. '
'Register\n2. log in?')
choice = input('>>> ')
try:
return self.__log_or_register(choice)
except ValueError as e:
print(e)
# self.__log_or_register(choice)
except UserAlreadyExists as e:
print(e)
# self.__log_or_register(choice)
def register(self):
username = self.__get_username()
password = self.__get_register_password()
self.user_controller.create_new_user(username, password)
print('Successful registration!')
return self.user_controller.get_user_id_by_username(username)
def log_in(self):
username = self.__get_username()
password = self.__get_login_password()
self.user_controller.log_user_in(username, password)
print('Successful login!')
return self.user_controller.get_user_id_by_username(username)
def make_reservation(self, user_id, proj_id, row, col):
self.reservation_controller.make_new_reservation(
user_id, proj_id, row, col)
def finalize_reservation(self):
self.reservation_controller.finalize_reservation()
def __log_or_register(self, choice):
if choice == '1':
return self.register()
elif choice == '2':
return self.log_in()
else:
print('Choice not valid!')
def __get_username(self):
while True:
try:
username = input('Enter username:\n>>> ')
self.validator.validate_username(username)
except ValueError as e:
print(e)
else:
return username
@staticmethod
def __get_login_password():
password = input('Enter password:\n>>> ')
return password
def __get_register_password(self):
while True:
try:
pass_1 = input('Enter password:\n >>> ')
self.validator.validate_password(pass_1)
pass_2 = input('Confirm password:\n >>> ')
if pass_1 != pass_2:
raise ValueError('Different passwords!')
except ValueError as e:
print(e)
else:
return pass_1
def read_user(current_user):
user_controller = UserController()
return user_controller.Read(current_user)
def register_user():
user_controller = UserController()
return user_controller.registration(request.get_json())
from flask import Blueprint, request, jsonify
from controllers.user_controller import UserController
user_module = Blueprint('User', __name__)
user_controller = UserController()
@user_module.route('/user', methods=['GET'])
def index():
data = request.json
id = 0
if (data != None):
id = data.get('id')
return jsonify(user_controller.list(id))
@user_module.route('/user', methods=['POST'])
def save():
data = request.json
name = data.get('username')
email = data.get('email')
password = data.get('password')
return jsonify(user_controller.save(name, email, password))
@user_module.route('/user', methods=['PUT'])
def update():
def init_nonserializable_objects(self, cursor_lib_callback):
self.io = WindowSystem(cursor_lib_callback())
self.user_controller = UserController(GameActions(self, self.player))
register_status_texts(self.io, self, self.player)
return self.io, self.user_controller
def user(identifier,
interested=None,
query=None,
category=None,
tag=None,
cities=None,
flags=None,
lat=None,
lon=None,
page=1,
next_page_url=None,
prev_page_url=None,
scroll=False,
selected=None):
selected_categories = category
current_user = UserController().current_user
current_user_id = UserController().current_user_id
user = UserController().get_user(identifier)
if user:
events = []
categories = []
tags = []
event_cities = []
if not Block.blocks(user.user_id, current_user_id):
events, categories, tags, event_cities = EventController(
).get_events_for_user_by_interested(user=user,
query=query,
categories=category,
tags=tag,
cities=cities,
flags=flags,
interested=interested,
page=page)
chips = _parse_chips(categories=categories,
selected_categories=selected_categories,
tags=tags,
cities=event_cities,
interested=interested,
flags=flags,
show_interested=True)
vargs = {
'current_user': current_user,
'is_me': user == current_user,
'events': events,
'selected': selected,
'chips': chips,
'page': page,
'next_page_url': next_page_url,
'prev_page_url': prev_page_url
}
if user.user_id == current_user_id:
return _render_events_list(request, events, vargs, scroll=scroll)
else:
vargs['user'] = user
user.card_follower_count = user.follower_users_count()
user.card_event_count = user.active_user_events_count()
user.card_is_followed = user.is_follows_user(
current_user) if current_user else False
user.card_is_following = current_user.is_follows_user(
user) if current_user else False
user.card_is_blocked = current_user.is_blocks_user(
user) if current_user else False
return _render_events_list(request,
events,
vargs,
template=TEMPLATE_USER_PAGE,
scroll=scroll)
return redirect(request.referrer or '/')
def delete_user(current_user):
user_controller = UserController()
return user_controller.Delete(current_user)
def saved(**kwargs):
current_user = UserController().current_user
kwargs.update({'identifier': current_user.username})
return user(**kwargs)
def get(self, params, **kwargs):
controller = UserController()
return controller.find(serialize=True, params=params, **kwargs), 200
from controllers.ride_controller import RideBookingController
from controllers.user_controller import UserController
from services.user_service import UserService
from services.ride_service import RideService
from services.location_service import LocationService
from services.vehicle_service import VehicleService
userController = UserController(UserService())
rideController = RideBookingController(RideService())
location1 = LocationService().addLocation(5, 6)
location2 = LocationService().addLocation(10, 9)
location3 = LocationService().addLocation(11, 4)
location4 = LocationService().addLocation(2, 6)
vehicle1 = VehicleService().addVehicle('prime', 123, 'sedan', location3)
vehicle2 = VehicleService().addVehicle('play', 124, 'sedan', location4)
driver1 = userController.addDriver('d1', 'XXX', '999', vehicle1)
driver2 = userController.addDriver('d2', 'YYY', '456', vehicle2)
customer1 = userController.addCustomer('c1', 'AAA', '342', location1)
rideController.bookRide('r1', 'c1', location1, location2,
userController.userService)
def get_events_for_user_by_interested(self,
interested,
user=None,
query=None,
categories=None,
tags=None,
cities=None,
flags=None,
page=1,
future_only=False):
current_user = UserController().current_user
if not user: user = current_user
selected_categories = set(categories.split(',') if categories else [])
selected_tags = set(tags.split(',') if tags else [])
results = []
categories = []
tags = []
event_cities = []
if user:
events_with_counts = db_session.query(
Event,
func.count(Event.user_events).label('ct')).join(
UserEvent,
UserEvent.user_id == user.user_id,
).filter(
and_(UserEvent.interest != None,
Event.event_id == UserEvent.event_id)).group_by(
Event.event_id)
if interested:
filter_conditions = []
if UserEvent.DONE in interested:
filter_conditions.extend(UserEvent.DONE_LEVELS)
if UserEvent.INTERESTED in interested:
filter_conditions.extend([
UserEvent.interest_level(UserEvent.GO),
UserEvent.interest_level(UserEvent.MAYBE)
])
for il in [UserEvent.GO, UserEvent.MAYBE, UserEvent.SKIP]:
if il in interested:
filter_conditions.append(UserEvent.interest_level(il))
if filter_conditions:
events_with_counts = events_with_counts.filter(
UserEvent.interest.in_(filter_conditions))
results, categories, tags, event_cities, results_table = self._process_events(
events=events_with_counts,
cities=cities,
page=page,
query=query,
user=user,
selected_categories=selected_categories,
selected_tags=selected_tags,
flags=flags,
future_only=future_only)
if current_user and results:
result_events_table = alias(results_table, 'events_table')
current_user_events = db_session.query(UserEvent).filter(
UserEvent.user_id == current_user.user_id).join(
result_events_table,
result_events_table.c.events_event_id ==
UserEvent.event_id).all()
if current_user_events is not None:
current_user_events_by_event_id = {
x.event_id: x
for x in current_user_events
}
for event in results:
event.current_user_event = get_from(
current_user_events_by_event_id, [event.event_id])
return results, categories, tags, event_cities
