def connect(self,user_id):
'''
Connects/Joins an user with provided user_id with the activity for the current activity manager
:param user_id:
:return:
'''
(canJoin, message) = self.can_join(user_id)
if not canJoin:
return False, message
#Need to validate whether the same user has signed up for the same activity
#Count the number of companions first to handle the eventual consistency pattern for ndb
companion_count = self.companion_count() + 1
user_info = models.User.get_by_id(long(user_id))
user_activity = UserActivity(user=user_info.key,
activity=self._event.key)
user_activity.put()
#An activity will be marked as FORMED_OPEN if it satisfies the minm number of people required requirement
if self._event.status == Event.FORMING:
if self._can_complete(companion_count):
self._event.status = Event.FORMED_OPEN
self._event.put()
self._on_event_formation()
eventThrottler = EventThrottler(self.get_event().username)
eventThrottler.decrement_activity_count()
return True, message
def cancel(self):
(canCancel, message) = self.can_cancel()
if not canCancel:
return False, message
user_activities = UserActivity.query(UserActivity.activity == self._event.key, UserActivity.status == UserActivity.ACTIVE)
for user_activity in user_activities:
user_activity.status = UserActivity.CANCELLED
user_activity.put()
self.get_event().status = Event.CANCELLED
self.get_event().put()
eventThrottler = EventThrottler(self.get_event().username)
eventThrottler.decrement_activity_count()
return True, "Your activity has been successfully canceled."
def can_join_flex(self, userId):
#First check the status
if self.expires_in() == Event.EXPIRED or self._event.status in Event.NON_EDITABLE_STATUS_CHOICES:
return False, "Event has already expired/cancelled or closed"
#Are there any activities with this user and this activity?
user_info = models.User.get_by_id(long(userId))
if self._event.username == user_info.username:
return False, "You cannot join an activity you created."
user_activity = UserActivity.get_by_user_activity(user_info.key, self._event.key)
if user_activity:
return False, "You have already joined this activity."
#Now check if there are spots remaining
if self._event.type != Event.EVENT_TYPE_FLEX_INTEREST:
return False, "This is not a flex event"
return True, "Success"
def unjoin(self, user_id):
(canLeave, message) = self.can_leave()
if not canLeave:
return False, message
user_info = models.User.get_by_id(long(user_id))
companion_count = self.companion_count() - 1
user_activity = UserActivity.get_by_user_activity(user_info.key, self._event.key)
user_activity.status = UserActivity.CANCELLED
user_activity.put()
if not self._can_complete(companion_count):
self._event.status = Event.FORMING
self._event.put()
eventThrottler = EventThrottler(self.get_event().username)
eventThrottler.increment_activity_count()
return True, "You have successfully left the activity " + self._event.category
def _handleFeedBack(self, activity):
activity_user = models.User.get_by_username(activity.username)
#all users signed up for this activity
participants_list = UserActivity.query(
UserActivity.activity == activity.key,
UserActivity.status == UserActivity.ACTIVE).fetch(
projection=[UserActivity.user])
#Ask feedback from participants
for participant in participants_list:
user_feedback = UserFeedback()
user_feedback.activity = activity.key
user_feedback.user = participant.user
user_feedback.put()
#Ask feedback from owner
user_feedback = UserFeedback()
user_feedback.activity = activity.key
user_feedback.user = activity_user.key
user_feedback.put()
def _handle_companionship_rating(self, activity):
#populate default rating information for the owner
activity_user = models.User.get_by_username(activity.username).key
participants_list = UserActivity.query(
UserActivity.activity == activity.key,
UserActivity.status == UserActivity.ACTIVE).fetch(
projection=[UserActivity.user])
for participant in participants_list:
self._create_default_rating(activity, activity_user,
participant.user)
#populate for other participants
for participant in participants_list:
self._create_default_rating(activity, participant.user,
activity_user)
for other_participant in filter(
lambda user_participant: user_participant.user !=
participant.user, participants_list):
self._create_default_rating(activity, participant.user,
other_participant.user)
def can_leave(self,user_id=None):
if self.expires_in() == Event.EXPIRED or self._event.status in Event.NON_EDITABLE_STATUS_CHOICES:
return False, "You cannot leave an expired/closed/initiated/cancelled interest."
if user_id is not None:
user = models.User.get_by_id(long(user_id))
count = UserActivity.query(UserActivity.activity == self._event.key, UserActivity.user == user.key,
UserActivity.status == UserActivity.ACTIVE).count()
if count == 0:
return False,"This is not your activity"
if self._event.status == Event.FORMED_OPEN:
#TODO Needs some work here to figure out till what time an event can be cancelled
if self._event.expiration is not None:
expiration_time = int(str(self._event.expiration))
now = datetime.now()
timezone_offset = now - datetime.utcnow()
last_cancellation_time = self._event.date_entered + timedelta(minutes=expiration_time) - timedelta(minutes=5) + timezone_offset
if now > last_cancellation_time:
return False, "You cannot leave 5 minutes before activity starts."
return True, "You can leave."
def can_join(self, userId):
if self._event.type == Event.EVENT_TYPE_FLEX_INTEREST:
return self.can_join_flex(userId)
#First check the status
if self.expires_in() == Event.EXPIRED or self._event.status in Event.NON_EDITABLE_STATUS_CHOICES:
return False, "Event has already expired/cancelled or closed"
#Are there any activities with this user and this activity?
user_info = models.User.get_by_id(long(userId))
if self._event.username == user_info.username:
return False, "You created this activity."
user_activity = UserActivity.get_by_user_activity(user_info.key, self._event.key)
if user_activity:
return False, "You have already joined this activity."
#Now check if there are spots remaining
elif self._event.max_number_of_people_to_join == 'No Limit':
return True, "Success"
else:
max_count = int(self._event.max_number_of_people_to_join.split()[0])
if self.companion_count() < max_count:
return True, "Success"
return False, "This activity is full."
def get_all_companions(self):
return UserActivity.query(UserActivity.activity == self._event.key, UserActivity.status == UserActivity.ACTIVE).fetch(projection = [UserActivity.user])
def companion_count(self):
companions = UserActivity.query(UserActivity.activity == self._event.key, UserActivity.status == UserActivity.ACTIVE).count()
logging.info(companions)
return companions