Example #1
0
def index():
    # if g.current_user:
    current_user = get_current_user()
    if current_user:
        event_queue = []
    else:
        event_queue = []
    return render_template('index.html',
                           user=jsonify(current_user),
                           event_queue=jsonify(event_queue))
Example #2
0
def login():
    if LoginForm(request.form).validate():
        user = g.db.users.find_one({'email': request.form['email']})
        if user is not None:
            if authenticate(user, request.form['password']):
                login_user(user)

                # abstract into pre-serialize user
                user['logged_in'] = True
                return jsonify(user)
            else:
                return jsonify({'error': INCORRECT_EMAIL_PASSWORD})
        else:
            return jsonify({'error': UNKNOWN_EMAIL})
    else:
        return jsonify({'error': INCORRECT_EMAIL_PASSWORD})
Example #3
0
    def new(self):
        user = create_user(request.form['email'], request.form['password'])
        user.update(request.form.to_dict())

        # clean up user object
        user.pop('password')
        user.pop('confirm')
        if not user.get('name', None):
          user['name'] = ' '.join([request.form['first_name'],
                                   request.form['last_name']])

        user_id = g.db.users.insert(user)

        # TODO: find a cleaner way to hardcode the DP user_id
        # dp_user_id = ObjectId("5175d60a137a001de8c3fa6b")
        # dp_events = g.db.users.find_one({'_id': dp_user_id}).get('events', [])

        # all users follow themselves and the DP
        user['following'] = [user_id]
        # user['event_queue'] = dp_events
        user['event_queue'] = []

        g.db.users.update({'_id': user_id},
                          {'$set': {'following': user['following'],
                                    'event_queue': user['event_queue']}})

        login_user(user)

        user['logged_in'] = True
        return jsonify(user)
Example #4
0
    def index(self):
        """
        Either:
        -   Fetch a list of events (/events/)
        -   Search all events for a keyword. (/events/?q=keyword)
            -   Results will limited to 10 unless 'limit' is specified
            -   If 'creator_name' is given, results will be filtered to be only
                those events created by 'creator_name'
        """
        if 'q' in request.args:
            options = {
                'search': request.args['q'],
                'limit': (int(request.args['limit'])
                          if 'limit' in request.args else 10),
                'filter': {
                    'date_start': {
                        '$gte':
                        datetime.strptime(request.args['date_start'],
                                          '%m/%d/%Y %I:%M %p')
                    }
                }
            }

            if 'creator_name' in request.args:
                options['filter'] = {
                    'creator_name': request.args['creator_name'],
                }

            return jsonify(g.db.command("text", "events", **options))
        else:
            return super(EventAPI, self).index()
Example #5
0
    def new(self):
        # it might either be in form data or request data
        event = request.form.to_dict() or request.json
        # validate date and time fields
        # docs.python.org/2/library/datetime.html#strftime-strptime-behavior
        # date pattern: "%m/%d/%Y", e.g. "12/31/2000"
        #   %m: Month as a decimal number [01,12].
        #   %d: Day of the month as a decimal number [01,31].
        #   %Y: Year with century as a decimal number.
        # time pattern: "%I:%M %p", e.g. "12:30 pm"
        #   %I: Hour (12-hour clock) as a decimal number [01,12].
        #   %M: Minute as a decimal number [00,59].
        #   %p: Locale's equivalent of either AM or PM.
        date_string = event['date'].strip()
        time_start_string = event['time_start'].strip()
        time_end_string = event['time_end'].strip()
        try:
            date = parser.parse(date_string).date()
            time_start = parser.parse(time_start_string).time()
            time_end = parser.parse(time_end_string).time()
        except ValueError:
            return jsonify({'error': 'Invalid date or time.'})
        # if the end time is before the start time assume it is on the next day
        if time_end < time_start:
            time_end += timedelta(days=1)
        # construct date_start and date_end datetime objects
        date_start = datetime(year=date.year,
                              month=date.month,
                              day=date.day,
                              hour=time_start.hour,
                              minute=time_start.minute)
        date_end = datetime(year=date.year,
                            month=date.month,
                            day=date.day,
                            hour=time_end.hour,
                            minute=time_end.minute)

        event['date_start'] = date_start
        event['date_end'] = date_end

        # add event to events collection
        self.collection.insert(event)
        # signals that a new event was made
        new_event_signal.send(self, event=event, u_id=g.current_user['_id'])
        return jsonify(event)
Example #6
0
def logout():
    logout_user()
    return jsonify({'success': 'Successfully logged out'})
Example #7
0
def user(user_id):
    user_to_render = g.db.users.find_one({'_id': ObjectId(user_id)})
    return render_template('index.html',
                           user=jsonify(get_current_user()),
                           user_to_render=jsonify(user_to_render))
Example #8
0
def event(event_id):
    event_to_render = g.db.events.find_one({'_id': ObjectId(event_id)})
    return render_template('index.html',
                           user=jsonify(get_current_user()),
                           event_to_render=jsonify(event_to_render))
Example #9
0
def hardlink():
    return render_template('index.html', user=jsonify(g.current_user))