def post(self):
username = request.form['username']
password = request.form['password']
user = db_session.query(User).filter(User.username == username,
User.password == password)
user_exists = db_session.query(user.exists()).scalar()
if user_exists:
session['loggedIn'] = True
session['username'] = username
return redirect('/')
else:
return redirect('/login')
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 _filter_events(klass,
events,
query=None,
categories=None,
tags=None,
flags=None):
query_tags = None
if query:
tags_matching_query = Tag.query.filter(
Tag.tag_name.ilike("{}%".format(query)))
query_tags = {t.tag_name for t in tags_matching_query}
if query_tags:
if tags is None:
tags = query_tags
else:
tags |= query_tags
else:
events = klass._filter_events_by_query(events=events,
query=query)
if tags or categories:
# Filter out valid_tags
valid_tags = db_session.query(func.distinct(Tag.tag_name)).filter(
Tag.tag_name.in_(tags))
tags = set(t[0] for t in valid_tags)
events = klass._filter_events_by_tags(events,
tags=tags,
categories=categories)
if flags:
events = klass._filter_events_by_flags(events, flags=flags)
return events, tags
def get_suggested(self, user=None, query=None):
if user is None: user = self.current_user
if user is None: return []
already_following_user_ids = alias(
db_session.query(Follow.follow_id).select_from(Follow).filter(
and_(Follow.user_id == user.user_id, Follow.active)),
'already_following_user_ids')
blocking_user_ids = alias(user.all_blocks_table(), 'blocking_user_ids')
suggested_users = db_session.query(User).filter(
and_(User.user_id != user.user_id,
~User.user_id.in_(already_following_user_ids),
~User.user_id.in_(blocking_user_ids)))
return suggested_users
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 _cities_for_events(klass, events, limit=None):
cities_query = db_session.query(
Event.city,
func.count(distinct(
Event.event_id)).label('ct')).filter(Event.city != None)
events_table = alias(events, 'events_table')
cities_query = cities_query.join(
events_table, Event.event_id == events_table.c.events_event_id)
cities_query = cities_query.group_by(Event.city).order_by(desc('ct'))
if limit:
cities_query = cities_query.limit(limit)
return [{
'chip_name': dat[0] or 'Unknown',
'ct': dat[1],
} for dat in cities_query if dat[1] > 0]
def _filter_events_by_tags(klass, events, tags, categories=None):
event_matches = db_session.query(
EventTag.event_id.label('event_id'),
func.count(distinct(Tag.tag_id)).label('ct')).join(
Tag, Tag.tag_id == EventTag.tag_id)
if tags and categories:
event_matches = event_matches.filter(
and_(Tag.tag_name.in_(tags), Tag.tag_type.in_(categories)))
elif tags:
event_matches = event_matches.filter(Tag.tag_name.in_(tags))
elif categories:
event_matches = event_matches.filter(Tag.tag_type.in_(categories))
event_matches = event_matches.group_by(EventTag.event_id)
event_matches = alias(event_matches, 'event_matches')
return events.join(event_matches,
Event.event_id == event_matches.c.event_id).filter(
event_matches.c.ct >= len(tags))
def get_users(self, query=None, tag=None, page=1):
current_user = self.current_user
relationship_types = User.relationship_types()
users_table = None
if tag and tag in relationship_types:
users_table = self.get(relationship_type=tag,
query=query,
table_only=True)
if tag == User.FOLLOWING:
suggested_users_table = self.get(
relationship_type=User.SUGGESTED,
query=query,
table_only=True,
limit=5)
users_table = users_table.union(suggested_users_table)
if users_table:
if page:
users_table = users_table.limit(self.PAGE_SIZE).offset(
(page - 1) * self.PAGE_SIZE)
users = users_table.all()
else:
users = []
if users:
all_user_ids = set(u.user_id for u in users)
event_counts_by_user_id = db_session.query(
UserEvent.user_id,
func.count(UserEvent.event_id).label('ct')).filter(
and_(UserEvent.user_id.in_(all_user_ids),
UserEvent.interest.in_(
UserEvent.INTERESTED_LEVELS))).group_by(
UserEvent.user_id)
event_counts_by_user_id = {
str(x[0]): x[1]
for x in event_counts_by_user_id
}
follower_counts_by_user_id = db_session.query(
Follow.follow_id,
func.count(Follow.user_id).label('ct')).filter(
and_(Follow.follow_id.in_(all_user_ids),
Follow.active == True)).group_by(Follow.follow_id)
follower_counts_by_user_id = {
str(x[0]): x[1]
for x in follower_counts_by_user_id
}
is_follower_by_user_id = db_session.query(Follow.follow_id).filter(
and_(Follow.follow_id == current_user.user_id,
Follow.user_id.in_(all_user_ids), Follow.active == True))
is_follower_by_user_id = set(
str(x[0]) for x in is_follower_by_user_id)
is_following_by_user_id = db_session.query(
Follow.follow_id).filter(
and_(Follow.user_id == current_user.user_id,
Follow.follow_id.in_(all_user_ids),
Follow.active == True))
is_following_by_user_id = set(
str(x[0]) for x in is_following_by_user_id)
is_blocked_by_user_id = db_session.query(Block.block_id).filter(
and_(Block.user_id == current_user.user_id,
Block.block_id.in_(all_user_ids), Block.active == True))
is_blocked_by_user_id = set(
str(x[0]) for x in is_blocked_by_user_id)
for user in users:
uid = str(user.user_id)
user.card_event_count = get_from(event_counts_by_user_id,
[uid], 0)
user.card_follower_count = get_from(follower_counts_by_user_id,
[uid], 0)
user.card_is_follower = uid in is_follower_by_user_id
user.card_is_following = uid in is_following_by_user_id
user.card_is_blocked = uid in is_blocked_by_user_id
if not (user.card_is_follower or user.card_is_following
or user.card_is_blocked):
user.card_is_suggested = True
return users, relationship_types
def run():
row_user = db_session.query(User).first()
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
def _process_events(klass,
events,
page,
query=None,
cities=None,
user=None,
flags=None,
selected_tags=None,
selected_categories=None,
future_only=None):
if future_only:
events_with_counts = events_with_counts.filter(
or_(Event.start_time >= datetime.datetime.now(),
Event.end_time >= datetime.datetime.now()))
events = events.filter(Event.status != Event.STATUS_CLOSED_PERM)
events, selected_tags = klass._filter_events(
events,
query=query,
categories=selected_categories,
tags=selected_tags,
flags=flags)
event_cities = klass._cities_for_events(events)
if cities:
events = events.filter(Event.city.in_(cities))
for city in event_cities:
city['selected'] = city['chip_name'] in cities
tags, categories = klass._tags_for_events(
events=events,
selected_categories=selected_categories,
selected_tags=selected_tags)
event_user_ids = None
if user:
event_ids = {e[0].event_id for e in events if e[1]}
following_user_ids = alias(
db_session.query(func.distinct(Follow.follow_id)).filter(
and_(UserEvent.event_id.in_(event_ids),
UserEvent.user_id == Follow.follow_id,
Follow.user_id == user.user_id,
Follow.follow_id != user.user_id,
Follow.active == True)), "following_user_ids")
event_users = {
str(u.user_id): {
'user_id': u.user_id,
'username': u.username,
'image_url': u.image_url
}
for u in User.query.filter(User.user_id.in_(
following_user_ids))
}
events_with_following_counts = db_session.query(
UserEvent.event_id,
func.array_agg(func.distinct(
User.user_id)).label('user_ids')).filter(
and_(Follow.user_id == user.user_id,
UserEvent.user_id == Follow.follow_id,
UserEvent.event_id.in_(event_ids),
Follow.follow_id != user.user_id)).group_by(
UserEvent.event_id)
event_user_ids = {
row[0]: set(str(follower_id) for follower_id in row[1])
for row in events_with_following_counts
}
events = klass._order_events(events)
events = events.limit(klass.PAGE_SIZE).offset(
(page - 1) * klass.PAGE_SIZE)
results = []
for event, user_count in events:
event.card_user_count = user_count
if event_user_ids and event.event_id in event_user_ids:
event.card_event_users = [
event_users[x] for x in event_user_ids[event.event_id]
if x in event_users
]
results.append(event)
return results, categories, tags, event_cities, events
def _tags_for_events(klass,
events=None,
selected_categories=None,
selected_tags=None,
limit=None,
future_only=False):
tag_query = db_session.query(
Tag.tag_name,
func.count(distinct(EventTag.event_id)).label('ct')).join(
EventTag, Tag.tag_id == EventTag.tag_id).join(
Event, EventTag.event_id == Event.event_id)
category_query = db_session.query(
Tag.tag_type,
func.count(distinct(EventTag.event_id)).label('ct')).join(
EventTag, Tag.tag_id == EventTag.tag_id)
if events:
events_table = alias(events, 'events_table')
tag_query = tag_query.join(events_table)
category_query = category_query.join(events_table)
if future_only:
tag_query = tag_query.filter(
Event.end_time >= datetime.datetime.now())
category_query = category_query.filter(
Event.end_time >= datetime.datetime.now())
tag_query = tag_query.group_by(Tag.tag_name).order_by(desc('ct'))
category_query = category_query.group_by(Tag.tag_type).order_by(
desc('ct'))
if limit:
tag_query = tag_query.limit(limit)
category_query = category_query.limit(limit)
distinct_tags = {t: {'chip_name': t, 'ct': 0} for t in selected_tags}
for t in tag_query:
chip_name = t[0]
chip_ct = t[1]
if chip_ct > 0:
if chip_name not in distinct_tags:
distinct_tags[chip_name] = {'chip_name': chip_name}
distinct_tags[chip_name]['ct'] = chip_ct
tags = distinct_tags.values()
# category_cts = {c[0]: c[1] for c in category_query}
# categories = [
# {
# 'chip_name': c,
# 'ct': get_from(category_cts, [c], ""),
# } for c in Tag.TYPES
# ]
categories = []
#
if selected_categories:
is_any_category_selected = False
if categories:
for event_category in categories:
is_category_selected = event_category[
'chip_name'] in selected_categories
event_category['selected'] = is_category_selected
if not is_any_category_selected and is_category_selected:
is_any_category_selected = is_category_selected
categories = sorted(
[c for c in categories if c['selected']],
key=lambda c: c['chip_name']) + sorted(
[c for c in categories if not c['selected']],
key=lambda c: c['ct'] * -1)
if selected_tags:
is_any_tag_selected = False
if tags:
for event_tag in tags:
is_tag_selected = event_tag['chip_name'] in selected_tags
event_tag['selected'] = is_tag_selected
if not is_any_tag_selected and is_tag_selected:
is_any_tag_selected = is_tag_selected
tags = sorted([t for t in tags if t['selected']],
key=lambda t: t['chip_name']) + sorted(
[t for t in tags if not t['selected']],
key=lambda t: t['ct'] * -1)
return tags, categories
