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