def removeApprovals(article,user1=None):
page=0;limit=100
if user1:
users=[user1]
else:# if no user specified, then apply all users
users=User.all().fetch(limit,page*limit)
while users:
for user in users:
approvals=ArticleLib.getApprovals(article, user)
if approvals:
logging.info("TODO: lock the ArticleCategory records for update")
article_cats=ArticleLib.getCategories(article)
if article_cats:
for article_cat in article_cats:
if approvals.has_key(article_cat.category):
article_cat.r2=article_cat.r2-(approvals[article_cat.category].score/100)
else:
article_cat.r2=article_cat.r2-(0.01/100)
article_cat.save()
page=page+1
if not user1:
users=User.all().fetch(limit,page*limit)
return None
def post(self):
self.response.headers['Content-Type'] = 'application/json'
firstname = self.request.get('firstname')
lastname = self.request.get('lastname')
email = self.request.get('email')
password = self.request.get('password')
work, info = User.create_user(
email,
firstname=firstname,
lastname=lastname,
password_raw=password
)
if not work:
self.response.write(resp.fail(
'email',
'Email address already exists'
))
else:
user = info
token = User.create_auth_token(user.key.id())
self.response.write(resp.success({
'Token' : token,
'User' : {
'firstname' : user.firstname,
'lastname' : user.lastname,
'email' : user.auth_ids[0],
'id' : user.key.id()
}
}))
def post(self):
self.response.headers['Content-Type'] = 'application/json'
firstname = self.request.get('firstname')
lastname = self.request.get('lastname')
email = self.request.get('email')
password = self.request.get('password')
work, info = User.create_user(email,
firstname=firstname,
lastname=lastname,
password_raw=password)
if not work:
self.response.write(
resp.fail('email', 'Email address already exists'))
else:
user = info
token = User.create_auth_token(user.key.id())
self.response.write(
resp.success({
'Token': token,
'User': {
'firstname': user.firstname,
'lastname': user.lastname,
'email': user.auth_ids[0],
'id': user.key.id()
}
}))
def post(self):
self.response.headers["Content-Type"] = "application/json"
email = self.request.get("email")
password = self.request.get("password")
try:
user = User.get_by_auth_password(email, password)
except:
self.response.write(resp.fail_pass())
return
if not user:
self.response.write(resp.fail_pass())
else:
token = User.create_auth_token(user.key.id())
self.response.write(
resp.success(
{
"Token": token,
"User": {
"firstname": user.firstname,
"lastname": user.lastname,
"email": user.auth_ids[0],
"id": user.key.id(),
},
}
)
)
def set_emailAction(self,email):
if self.user:
current_email=self.user.getEmail()
if current_email!=email:
user=User().get_by_auth_id(self.user.username)
user.email_address=email
user.put()
model={"email":email}
return model
def post(self):
# set headers
self.response.headers.add_header('Content-Type', 'application/json')
form = LoginForm(formdata=webob.multidict.MultiDict(json.loads(self.request.body or '{}')))
form.validate()
if form.errors:
self.response.set_status(400)
self.response.write(json.dumps(form.errors))
else:
try:
User.get_by_auth_password(form.email.data, form.password.data)
self.session['user'] = form.email.data
self.response.write(json.dumps({'success': "Logged in"}))
except Exception:
self.response.set_status(400)
self.response.write(json.dumps({'error': "Login failed"}))
def get(self):
users = User.query().fetch()
tasklist_name = self.request.get('tasklist_name', DEFAULT_TASKLIST_NAME)
tasks_query = Task.query(ancestor=tasklist_key(tasklist_name)).order(-Task.date)
tasks = tasks_query.fetch()
self.render_template('authenticated.html', locals())
def add_quote(title1, user_id, user_anon, provider, quote1=None, url1=None, image=None, _created=None):
try:
now = datetime.datetime.now()
if isinstance(user_id, unicode):
auth_id = '%s:%s' % (provider, user_id)
user = User.get_by_auth_id(auth_id)
else:
user = user_id
unique_user = _unique_user(user)
if _created:
created = _created
else:
created = (now - datetime.datetime(2008, 10, 1)).days
q = Post(
title=title1,
quote=quote1,
created=created,
image=image,
creator_anonymous=user_anon,
creator=user.key,
creation_order=now.isoformat()[:19] + "|" + unique_user,
uri=url1
)
q.put()
add_search_index(q.key.id(), title1, quote1, url1, image, user, user_anon)
return q.key.id()
except db.Error:
return None
def send_rfps_to_subscribers(self):
"""
As the function name implies, all subscribed users will receive an RFP update to their
email accounts. By comparing an RFP's parse date to a subscription's last update date,
we ensure dups aren't being sent out.
Returns a list of results based on what happened for each subscription.
"""
results = []
subs = Subscription.all()
for sub in subs:
try:
# Grab what user info, add first, last name later
user = User.query(query.FilterNode('username', '=', sub.username)).get()
# Ensure the the sub's username is associated with an actual account
# by checking if the email exists.
if user.email:
self._send_rfps_to_subscribers(sub, user.first_name, user.email, results)
else:
msg = 'No email found for username: %s and keyword: %s' % (sub.username, sub.keyword)
logging.info(msg)
results.append('Error: ' + msg)
except:
msg = 'Problem with sending RFPs for some subscription, maybe bad user object'
logging.info(msg)
results.append('Error: ' + msg)
return results
def printUser():
print "User List:"
print 100 * '#'
for user in User.query().fetch():
for name in user._properties:
print str(name) + ":" + str(getattr(user, name))
print 100 * '#'
def delete_orphaned_article_approvalsAction(self):
page=0
limit=100
records=[0]
num_deleted=0
total_records=0
while records:
records=ArticleApproveModel.all().fetch(limit,page*limit)
for record in records:
total_records=total_records+1
if not record.parent():
record.delete()
num_deleted=num_deleted+1
else:
category=CategoryModel.get(record.category.key())
if not category:
record.delete()
num_deleted=num_deleted+1
else:
user=User.get(record.user.key())
if not user:
record.delete()
num_deleted=num_deleted+1
page=page+1
return DevView(DevModel())
def get_user_address(self):
user = User.get_by_id(long(self.user_id)) if self.user_id != -1 else None
if user:
if user.address:
return user.address.address_from
else:
return ''
def add_comment(user, user_anon, quote_id, text, provider):
try:
if user is None:
return
if isinstance(user, unicode):
auth_id = '%s:%s' % (provider, user)
user = User.get_by_auth_id(auth_id)
else:
user = user
quote = Post.get_by_id(long(quote_id))
comment = Comment(parent=quote.key,
author_anonymous=user_anon,
author=user.key,
text=text)
quote.comments += 1
quote.put()
comment.put()
memcache.set("comment|" + user.email + "|" + str(quote_id),
comment.text)
except db.Error:
return None
def set_vote(quote_id, user_id, newvote, provider):
if user_id is None:
return
if isinstance(user_id, unicode):
auth_id = '%s:%s' % (provider, user_id)
user = User.get_by_auth_id(auth_id)
else:
user = user_id
email = user.email
def txn():
quote = Post.get_by_id(quote_id)
vote = Vote.get_by_id(id=email, parent=quote.key)
if vote is None:
vote = Vote(id=email, parent=quote.key)
if vote.vote == newvote:
return
quote.votesum = quote.votesum - vote.vote + newvote
vote.vote = newvote
quote.rank = "%020d|%s" % (
long(quote.created * DAY_SCALE + quote.votesum),
quote.creation_order
)
quote.put()
vote.put()
memcache.set("vote|" + email + "|" + str(quote_id), vote.vote)
ndb.transaction(txn)
def add_comment(user, user_anon, quote_id, text, provider):
try:
if user is None:
return
if isinstance(user, unicode):
auth_id = '%s:%s' % (provider, user)
user = User.get_by_auth_id(auth_id)
else:
user = user
quote = Post.get_by_id(long(quote_id))
comment = Comment(
parent=quote.key,
author_anonymous=user_anon,
author=user.key,
text=text
)
quote.comments += 1
quote.put()
comment.put()
memcache.set("comment|" + user.email + "|" + str(quote_id), comment.text)
except db.Error:
return None
def get(self):
printUser()
names = [
str(getattr(user, 'auth_ids')[0]) for user in User.query().fetch()
]
names.sort()
self.render_template('template.html', {'names': names})
def get(self, username, term, syllabus):
# Deal with possible trailing slash
if syllabus[-1] == '/':
syllabus = syllabus[:-1]
user = User.get_by_auth_id(username)
terms = user.terms
if terms:
for t in terms:
if t.url == term.upper():
syllabi = t.syllabi
for syl in syllabi:
if syl.info.url.lower() == syllabus.lower():
if not syl.isActive:
currentUser = None
if self.user:
currentUser = ndb.Key(User, self.user['user_id']).get()
if not currentUser or username not in currentUser.auth_ids:
self.abort(403)
self.render(t, syl)
return
# Raise HTTP 404 error for syllabi that don't exist
self.abort(404)
def printUser():
print "User List:"
print 100 * '#'
for user in User.query().fetch():
for name in user._properties:
print str(name) + ":" + str(getattr(user, name))
print 100 * '#'
def set_vote(quote_id, user_id, newvote, provider):
if user_id is None:
return
if isinstance(user_id, unicode):
auth_id = '%s:%s' % (provider, user_id)
user = User.get_by_auth_id(auth_id)
else:
user = user_id
email = user.email
def txn():
quote = Post.get_by_id(quote_id)
vote = Vote.get_by_id(id=email, parent=quote.key)
if vote is None:
vote = Vote(id=email, parent=quote.key)
if vote.vote == newvote:
return
quote.votesum = quote.votesum - vote.vote + newvote
vote.vote = newvote
quote.rank = "%020d|%s" % (long(quote.created * DAY_SCALE +
quote.votesum), quote.creation_order)
quote.put()
vote.put()
memcache.set("vote|" + email + "|" + str(quote_id), vote.vote)
ndb.transaction(txn)
def create_random_article_approvalsAction(self):
self.checkEnv()
all_articles=ArticleModel.all().fetch(100)
page=0
limit=100
users=[1]
while users:
logging.info("processing page "+str(page))
users=User.all().fetch(limit,page*limit)
for user in users:
logging.info("processing user: "******"article =",article).fetch(100)
approval_count=0
for article_cat in article_cats:
userknowledges=UserKnowledgeModel.all().filter("user ="******"category =",article_cat.category).fetch(1)
article_approval=ArticleApproveModel.all().filter("user ="******"category =",article_cat.category).get()
if not article_approval:
article_approval=ArticleApproveModel(user=user,article=article,category=article_cat.category,score=0.01)
if userknowledges:
article_approval.score=userknowledges[0].score
article_approval.save()
approval_count=1
if article_approval > 0:
article.numapprovals=article.numapprovals+1
article.save();
page=page+1
return DevView(DevModel())
def get_user_address(self):
user = User.get_by_id(long(self.user_id)) if self.user_id != -1 else None
if user:
if user.address:
return user.address.address_from
else:
return ''
def login( self ):
login = self.request.get( 'login', None );
password = self.request.get( 'password', None );
logging.info( "login=%s password=%s" % (login,password) );
# パラメータチェック
if (login is None) or (password is None):
out = { "meta": functions.createMetaData( status="fail", code=400, cc_code=1000, message="login and password required") };
logging.error( "login and password required" );
self.response.out.write( json.encode(out) )
return
# ログインしようとしているユーザーがメアドを verify 済みかチェック
auth_id = "own:"+ login
m = self.user_model
q = m.query( m.auth_ids==auth_id, m.verified==True )
result = q.get();
if result is None:
out = { "meta": functions.createMetaData( status="fail", code=400, cc_code=1000, message="ユーザーが存在しないか、メールアドレス認証が完了していません") };
logging.error( "ユーザーが存在しないか、メールアドレス認証が完了していません" );
self.response.out.write( json.encode(out) )
return
user = None
userInfo = self.auth.get_user_by_password( "own:"+ login, password, True, True, True )
# 2013/01/06 以前のバージョンは頭に「own:」がついてなかったので、それにも対応。
if userInfo is None:
logging.info( "2013/01/06 以前のバージョン方式でログインします" );
userInfo = self.auth.get_user_by_password( login, password, True, True, True )
if userInfo is None:
# ログイン失敗
logging.error( "Invalid email/username or password." );
out = {
"meta": functions.createMetaData(
status="fail", code=401, cc_code=1000, message="Invalid email/username or password."
),
};
self.response.out.write( json.encode(out) )
return
# ログイン成功
user = User.get_by_id( userInfo["user_id"] )
sessionId = self.serialize_user_token( auth_info=userInfo )
out = {
"meta": {
"status": "ok",
"code": 200,
"method_name": "loginUser",
"session_id": sessionId,
},
"response":{
"users": [
user.toDict( full=True ),
],
},
};
self.response.out.write( json.encode(out) )
def get_group_users(cls, group): users = [] entries = cls.query().filter(cls.group == group, cls.active == True).fetch() for entry in entries: stuff = entry.member user = User.get_by_id(entry.member.id()) users.append(user) return users
def post(self,userid):
print userid
url = images.get_serving_url(self.get_uploads()[0].key())
user = User.get_by_id(int(userid))
print user
user.img = url;
user.put();
self.response.write(resp.success())
def get(self, _id=None):
if self.user:
q = User.gql('')
response = [{'email': user.auth_ids[0], 'fullname': user.full_name} for user in q]
self.response.headers.add_header('Content-Type', 'application/json')
self.response.write(json.dumps(response))
else:
self.response.set_status(403)
def calculate_user_knowledgeAction(self,nickname=None):
self.checkEnv()
if nickname:
user=User.all().filter("nickname =",nickname).get()
else:
user=None
KnowledgeLib.calculate_user_knowledge(user)
return DevView(DevModel())
def create_random_article_commentsAction(self):
import string
page=0
limit=100
articles=[1]
while articles:
#articles=ArticleModel.all().fetch(limit,page*limit)
articles=ArticleModel.all().filter("ihref =",'google-earnings-clipped-mobile-headwinds').fetch(limit,page*limit)
for article in articles:
logging.info("generating comments for article "+article.title)
existing_comments=[] # this is a lifo stack of the most recent 100 comments on the article
# every user will comment between 1 or 10 times on either the article or another users comment
upage=0
users=[1]
while users:
users=User.all().fetch(limit,upage*limit)
for user in users:
if not article.comment:
comment_text=''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(32))
#comment=Comments(parent_comment=None,text=comment_text,user=user,rank=0.0)
#comment.save()
comment=CommentsLib.saveComment(article.key().id(),comment_text,user=user)
article.comment=comment
article.save()
existing_comments.append(article.comment)
logging.info("creating parent comment "+str(comment))
numcomments=random.randint(1,10)
for c in range(1,numcomments):
# pick between commenting on the article and commenting on another users comment
target=random.randint(0,1)
if target==1:
parent=article.comment
else:
parent=random.choice(existing_comments)
#logging.info("parent=");
#logging.info(parent);
comment_text=''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(32))
comment=CommentsLib.saveComment(article.key().id(),comment_text,parent_id=parent.key().id(),user=user)
#comment=Comments(parent_comment=parent,text=comment_text,user=user,rank=0.0)
#comment.save()
existing_comments.append(comment);
if len(existing_comments) > 100:
# pop the oldest comment off the stack
existing_comments.pop(0)
logging.info("processing user page "+str(upage))
upage=upage+1
return None
logging.info("processing page "+str(page))
page=page+1
return DevView(DevModel())
def get(self):
users = User.query().fetch()
tasklist_name = self.request.get('tasklist_name',
DEFAULT_TASKLIST_NAME)
tasks_query = Task.query(
ancestor=tasklist_key(tasklist_name)).order(-Task.date)
tasks = tasks_query.fetch()
self.render_template('authenticated.html', locals())
def authenticate(request,id):
auth = Auth(request)
token = request.headers['Authorization']
user, ts = User.get_by_auth_token(id, token)
if not user:
return None
elif not user.validate_token(id, 'auth', token):
return None
return user
def get_group_users(cls, group):
users = []
entries = cls.query().filter(cls.group == group,
cls.active == True).fetch()
for entry in entries:
stuff = entry.member
user = User.get_by_id(entry.member.id())
users.append(user)
return users
def authenticate(request, id):
auth = Auth(request)
token = request.headers['Authorization']
user, ts = User.get_by_auth_token(id, token)
if not user:
return None
elif not user.validate_token(id, 'auth', token):
return None
return user
def getCurrentUser( cls ): logging.error( "現在 getCurrentUser にはバグがあります" ) if cls.userCache=="notInitialized": myAuth = auth.get_auth() userInfo = myAuth.get_user_by_session() if userInfo: cls.userCache = User.get_by_id( userInfo["user_id"] ) else: cls.userCache = None return cls.userCache
def send_reports(self):
queue = taskqueue.Queue('mail')
keys = User.query().fetch(keys_only=True)
for key in keys:
task = taskqueue.Task(
url='/worker/send_report',
params={
'key': key.urlsafe(),
}
)
queue.add(task)
def delete_all_usersAction(self):
self.checkEnv()
page=0
limit=100
records=[1]
while records:
records=User.all().fetch(limit,page*limit)
for record in records:
record.delete()
logging.info("deleted "+str(page*limit)+" records")
page=page+1
return DevView(DevModel())
def get_user(self):
"""
Return the current :class:`google.appengine.api.users.User` or
``None``.
"""
user = None
auth_id = get_param(self.request.headers, _AUTH_ID_HEADER_KEY)
if auth_id:
try:
user = User.get_by_auth_id(auth_id)
except BadRequestError:
_log.exception('Error getting user by auth_id: {}'.format(
auth_id))
return user
def generate_reportAction(self):
model={'num_comments':0,'num_articles':0,'num_users':0}
# number of new comments in the last 24 hours
model['num_comments']=Comments.all().filter("created >",(datetime.datetime.now()-datetime.timedelta(days=1))).count()
# number of new articles in the last 24 hours
model['num_articles']=ArticleModel.all().filter("updated >",(datetime.datetime.now()-datetime.timedelta(days=1))).count()
# number of new users in the last 24 hours
qry = User.query(User.created > datetime.datetime.now()-datetime.timedelta(days=1))
model['num_users']=qry.count()
mail.send_mail('*****@*****.**', '*****@*****.**', 'Daily Activity Report',str(model))
return model
def post(self):
self.response.headers['Content-Type'] = 'application/json'
email = self.request.get('email')
password = self.request.get('password')
try:
user = User.get_by_auth_password(email, password)
except:
self.response.write(resp.fail_pass())
return
if not user:
self.response.write(resp.fail_pass())
else:
token = User.create_auth_token(user.key.id())
self.response.write(
resp.success({
'Token': token,
'User': {
'firstname': user.firstname,
'lastname': user.lastname,
'email': user.auth_ids[0],
'id': user.key.id()
}
}))
def create_random_user_answersAction(self,nickname=None):
# get list of all categories for all articles
page=0
limit=100
articlecategories=[1]
categories = {}
while articlecategories:
articlecategories=ArticleCategoryModel.all().fetch(limit, page*limit);
for articlecategory in articlecategories:
if not categories.has_key(articlecategory.category.name):
categories[articlecategory.category.name]=articlecategory.category
logging.info("page: "+str(page))
page=page+1
model=DevModel()
model.messages=["found "+str(len(categories))+" distinct categories "]
now=time.time()
total_records=0
users=[1]
upage=0
while users:
users=User.all().fetch(100,upage*limit)
upage=upage+1
for user in users:
logging.info("processing user "+user.nickname)
# for each category get 10 questions
for tag,category in categories.items():
questions=QuestionModel.all().filter("cats in",[category.key()]).fetch(10,0)
for question in questions:
if random.randint(0,1)==1:
iscorrect=True
else:
iscorrect=False
t1=now-random.randint(0,(86400*365))
updated=datetime.datetime.utcfromtimestamp(t1)
topa=datetime.datetime.utcfromtimestamp(t1-random.randint(0,86400*30))
delay=random.randint(1,360000)
useranswer=UserAnswerModel(question=question,iscorrect=iscorrect,user=user,updated=updated,topa=topa,delay=delay)
useranswer.save()
total_records=total_records+1
message="created "+str(total_records)+" answers"
model.messages.append(message)
logging.info(message)
return DevView(model)
def get(self, username, term):
# TODO: Render weekly calendar template
term = term.upper()
user = User.get_by_auth_id(username)
if user:
terms = Term.query(ancestor = user.key).fetch()
for t in terms:
if t.url == term:
return self.render(user, t)
# Raise HTTP 404 error for terms not yet available
self.abort(404)
def post(self):
email = self.request.POST.get('email')
auth_id = "own:%s" % email
user = User.get_by_auth_id(auth_id)
if user is not None:
# Send Message Received Email
taskqueue.add(url='/emails/password/reset', params={
'recipient_id': user.key.id(),
})
_message = 'Password reset instruction have been sent to %s. Please check your inbox.' % email
self.add_message(_message, 'success')
return self.redirect_to('login')
_message = 'Your email address was not found. Please try another or <a href="/register">create an account</a>.'
self.add_message(_message, 'error')
return self.redirect_to('password-reset')
def get(self):
self.response.headers['Content-Type'] = 'application/json'
print self.request.headers['Authorization']
user = authenticate(self.request, int(self.request.get('userid')))
if not user:
self.response.write(resp.fail_auth())
else:
q = User.query()
def convert(user):
return {
'firstname': user.firstname,
'lastname': user.lastname,
'email': user.auth_ids[0],
'id': user.key.id(),
'img': user.img
}
self.response.write(resp.success(q.map(convert)))
def setUp(self):
# First, create an instance of the Testbed class.
self.testbed = testbed.Testbed()
# Then activate the testbed, which prepares the service stubs for use.
self.testbed.activate()
# Next, declare which service stubs you want to use.
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub()
self.user1 = User(name="User1_name",
last_name="User1_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user1.put()
self.user2 = User(name="User2_name",
last_name="User2_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user2.put()
self.user3 = User(name="User3_name",
last_name="User3_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user3.put()
self.user4 = User(name="User4_name",
last_name="User4_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user4.put()
def add_quote(title1,
user_id,
user_anon,
provider,
quote1=None,
url1=None,
image=None,
_created=None):
try:
now = datetime.datetime.now()
if isinstance(user_id, unicode):
auth_id = '%s:%s' % (provider, user_id)
user = User.get_by_auth_id(auth_id)
else:
user = user_id
unique_user = _unique_user(user)
if _created:
created = _created
else:
created = (now - datetime.datetime(2008, 10, 1)).days
q = Post(title=title1,
quote=quote1,
created=created,
image=image,
creator_anonymous=user_anon,
creator=user.key,
creation_order=now.isoformat()[:19] + "|" + unique_user,
uri=url1)
q.put()
add_search_index(q.key.id(), title1, quote1, url1, image, user,
user_anon)
return q.key.id()
except db.Error:
return None
def send_rfps_to_subscribers(self):
"""
As the function name implies, all subscribed users will receive an RFP update to their
email accounts. By comparing an RFP's parse date to a subscription's last update date,
we ensure dups aren't being sent out.
Returns a list of results based on what happened for each subscription.
"""
results = []
subs = Subscription.all()
for sub in subs:
try:
# Grab what user info, add first, last name later
user = User.query(
query.FilterNode('username', '=', sub.username)).get()
# Ensure the the sub's username is associated with an actual account
# by checking if the email exists.
if user.email:
self._send_rfps_to_subscribers(sub, user.first_name,
user.email, results)
else:
msg = 'No email found for username: %s and keyword: %s' % (
sub.username, sub.keyword)
logging.info(msg)
results.append('Error: ' + msg)
except:
msg = 'Problem with sending RFPs for some subscription, maybe bad user object'
logging.info(msg)
results.append('Error: ' + msg)
return results
def get_user_email(self):
user = User.get_by_id(long(self.user_id)) if self.user_id != -1 else None
if user:
return user.email
else:
return ''
def get_user_lastname(self):
user = User.get_by_id(long(self.user_id)) if self.user_id != -1 else None
if user:
return user.last_name
else:
return ''
def get_user_phone(self):
user = User.get_by_id(long(self.user_id)) if self.user_id != -1 else None
if user:
return user.phone
else:
return ''
def get_user(self):
user = User.get_by_email(self.user_email)
if user:
return user
else:
return None
class MatchMakerTest(unittest.TestCase):
def setUp(self):
# First, create an instance of the Testbed class.
self.testbed = testbed.Testbed()
# Then activate the testbed, which prepares the service stubs for use.
self.testbed.activate()
# Next, declare which service stubs you want to use.
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub()
self.user1 = User(name="User1_name",
last_name="User1_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user1.put()
self.user2 = User(name="User2_name",
last_name="User2_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user2.put()
self.user3 = User(name="User3_name",
last_name="User3_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user3.put()
self.user4 = User(name="User4_name",
last_name="User4_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user4.put()
def tearDown(self):
self.testbed.deactivate()
def test_match_making(self):
interest_list = []
activity_list = []
#Create some interests
interest_list.append(
EventManager.create(category='Play date',
duration='40',
expiration='180',
username='******',
building_name='building1',
note='test_node')[2])
interest_list.append(
EventManager.create(category='Play date',
duration='40',
expiration='180',
username='******',
building_name='building1',
note='test_node')[2])
interest_list.append(
EventManager.create(category='Play date',
duration='20',
expiration='180',
username='******',
building_name='building1',
note='test_node')[2])
#Create some activities
activity_list.append(
EventManager.create(category='Play date',
duration='40',
expiration='180',
username='******',
building_name='building1',
ip='127.0.0.1',
min_number_of_people_to_join='1',
max_number_of_people_to_join='1',
note='meet me at shadyside')[2])
activity_list.append(
EventManager.create(category='Stroller walk',
duration='40',
expiration='180',
username='******',
building_name='building1',
ip='127.0.0.1',
min_number_of_people_to_join='1',
max_number_of_people_to_join='1',
note='meet me at shadyside')[2])
#Assert if interests and activities are created fine
self.assertEqual(
3, len(Event.get_active_interests_by_category('Play date')))
self.assertEqual(
1, len(Event.get_active_activities_by_category('Stroller walk')))
self.assertEqual(
1, len(Event.get_active_activities_by_category('Stroller walk')))
match_list = MatchMaker.match_all()
self.assertEqual(2, len(match_list))
self.assertEqual(2, len(match_list['user1']))
self.assertEqual(1, len(match_list['user2']))
interest = EventManager.create(category='Stroller walk',
duration='40',
expiration='180',
username='******',
building_name='building1',
note='test_node')[2]
interest_list.append(interest)
match_list = MatchMaker.match_interest_with_activities(
interest.key.urlsafe())
self.assertEqual(1, len(match_list))
self.assertEqual(1, len(match_list['user1']))
activity = EventManager.create(category='Stroller walk',
duration='40',
expiration='180',
username='******',
building_name='building1',
ip='127.0.0.1',
min_number_of_people_to_join='1',
max_number_of_people_to_join='1',
note='meet me at shadyside')[2]
match_list = MatchMaker.match_activity_with_interests(
activity.key.urlsafe())
self.assertEqual(1, len(match_list))
activity = EventManager.create(category='Play date',
duration='20',
expiration='180',
username='******',
building_name='building1',
ip='127.0.0.1',
min_number_of_people_to_join='1',
max_number_of_people_to_join='1',
note='meet me at shadyside')[2]
match_list = MatchMaker.match_activity_with_interests(
activity.key.urlsafe())
self.assertEqual(2, len(match_list))
self.assertEqual(2, len(match_list['user1']))
class EventManagerTest(unittest.TestCase):
def setUp(self):
# First, create an instance of the Testbed class.
self.testbed = testbed.Testbed()
# Then activate the testbed, which prepares the service stubs for use.
self.testbed.activate()
# Next, declare which service stubs you want to use.
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub()
self.user1 = User(name="User1_name",
last_name="User1_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user1.put()
self.user2 = User(name="User2_name",
last_name="User2_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user2.put()
self.user3 = User(name="User3_name",
last_name="User3_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user3.put()
self.user4 = User(name="User4_name",
last_name="User4_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user4.put()
def tearDown(self):
self.testbed.deactivate()
def test_create_specific_interest(self):
EventManager.create(category='Category1',
duration='40',
expiration='180',
username='******',
building_name='building_1',
min_number_of_people_to_join='1',
max_number_of_people_to_join='2',
note='note1')
EventManager.create(category='Category2',
duration='40',
expiration='180',
username='******',
building_name='building_1',
min_number_of_people_to_join='1',
max_number_of_people_to_join='2',
note='note2')
EventManager.create(category='Category3',
duration='40',
expiration='180',
username='******',
building_name='building_1',
min_number_of_people_to_join='1',
max_number_of_people_to_join='2',
note='note2')
EventManager.create(category='Category4',
duration='40',
expiration='180',
username='******',
building_name='building_2',
min_number_of_people_to_join='1',
max_number_of_people_to_join='2',
note='note3')
EventManager.create(category='Category5',
duration='40',
expiration='180',
username='******',
building_name='building_2',
min_number_of_people_to_join='1',
max_number_of_people_to_join='2',
note='note4')
self.assertEqual(3,
len(Event.get_activities_by_building('building_1')))
self.assertEqual(2,
len(Event.get_activities_by_building('building_2')))
def test_load_activity_mgr(self):
success, message, activity_created = EventManager.create(
category='Category1',
duration='40',
expiration='180',
username='******',
building_name='building_1',
min_number_of_people_to_join='1',
max_number_of_people_to_join='2',
note='note1')
activity_from_activity_mgr = EventManager.get(
activity_created.key.urlsafe()).get_event()
self.assertEqual(activity_created.key.urlsafe(),
activity_from_activity_mgr.key.urlsafe())
self.assertEqual(Event.FORMING, activity_from_activity_mgr.status)
def test_join(self):
success, message, activity_created = EventManager.create(
category='Category1',
duration='40',
expiration='180',
username=self.user1.username,
building_name='building_1',
min_number_of_people_to_join='1',
max_number_of_people_to_join='2',
note='note1')
activity_manager = EventManager.get(activity_created.key.urlsafe())
self.assertEqual(activity_created.key.urlsafe(),
activity_manager.get_event().key.urlsafe())
self.assertEqual(True,
activity_manager.can_join(self.user2.key.id())[0])
activity_manager.connect(self.user2.key.id())
self.assertEqual(Event.FORMED_OPEN, activity_created.status)
self.assertEqual(False,
activity_manager.can_join(self.user2.key.id())[0])
self.assertEqual(True,
activity_manager.can_join(self.user3.key.id())[0])
activity_manager.connect(self.user3.key.id())
self.assertEqual(Event.FORMED_OPEN, activity_created.status)
self.assertEqual(False,
activity_manager.can_join(self.user4.key.id())[0])
self.assertEqual(2, activity_manager.companion_count())
get_interest_details(activity_created.key.urlsafe())
#Now have 3 Unjoin activity
activity_manager.unjoin(self.user3.key.id())
self.assertEqual(Event.FORMED_OPEN, activity_created.status)
self.assertEqual(1, activity_manager.companion_count())
#Now check if User4 can join
self.assertEqual(True,
activity_manager.can_join(self.user4.key.id())[0])
activity_manager.connect(self.user4.key.id())
self.assertEqual(2, activity_manager.companion_count())
self.assertEqual(Event.FORMED_OPEN, activity_created.status)
activity_manager.unjoin(self.user4.key.id())
activity_manager.unjoin(self.user2.key.id())
self.assertEqual(Event.FORMING, activity_created.status)
self.assertEqual(0, activity_manager.companion_count())
def test_set_time_interest(self):
interest_start_time = datetime.utcnow() + timedelta(hours=2)
success, message, activity_created = EventManager.create(
category='Category1',
start_time=interest_start_time,
username=self.user1.username,
building_name='building_1',
min_number_of_people_to_join='1',
max_number_of_people_to_join='2',
meeting_place='meeting_place',
activity_location='activity_location')
activity_manager = EventManager.get(activity_created.key.urlsafe())
self.assertEqual(activity_created.key.urlsafe(),
activity_manager.get_event().key.urlsafe())
self.assertEqual(True,
activity_manager.can_join(self.user2.key.id())[0])
activity_manager.connect(self.user2.key.id())
self.assertEqual(Event.FORMED_OPEN, activity_created.status)
self.assertEqual(False,
activity_manager.can_join(self.user2.key.id())[0])
self.assertEqual(True,
activity_manager.can_join(self.user3.key.id())[0])
activity_manager.connect(self.user3.key.id())
self.assertEqual(Event.FORMED_OPEN, activity_created.status)
self.assertEqual(False,
activity_manager.can_join(self.user4.key.id())[0])
self.assertEqual(2, activity_manager.companion_count())
get_interest_details(activity_created.key.urlsafe())
#Now have 3 Unjoin activity
activity_manager.unjoin(self.user3.key.id())
self.assertEqual(Event.FORMED_OPEN, activity_created.status)
self.assertEqual(1, activity_manager.companion_count())
#Now check if User4 can join
self.assertEqual(True,
activity_manager.can_join(self.user4.key.id())[0])
activity_manager.connect(self.user4.key.id())
self.assertEqual(2, activity_manager.companion_count())
self.assertEqual(Event.FORMED_OPEN, activity_created.status)
activity_manager.unjoin(self.user4.key.id())
activity_manager.unjoin(self.user2.key.id())
self.assertEqual(Event.FORMING, activity_created.status)
self.assertEqual(0, activity_manager.companion_count())
def test_create_flex_interest(self):
EventManager.create(category='Category1',
duration='40',
expiration='180',
username='******',
building_name='building_1',
note='test_note')
EventManager.create(category='Category2',
duration='40',
expiration='180',
username='******',
building_name='building_1',
note='test_note')
EventManager.create(category='Category3',
duration='40',
expiration='180',
username='******',
building_name='building_1',
note='test_note')
EventManager.create(category='Category4',
duration='40',
expiration='180',
username='******',
building_name='building_2',
note='test_note')
EventManager.create(category='Category5',
duration='40',
expiration='180',
username='******',
building_name='building_2',
note='test_note')
self.assertEqual(3, len(Event.get_interests_by_building('building_1')))
self.assertEqual(2, len(Event.get_interests_by_building('building_2')))
def test_load_interest_mgr(self):
success, message, interest_created = EventManager.create(
category='Category1',
duration='40',
expiration='180',
username='******',
building_name='building_1',
note='test_note')
interest_from_interest_mgr = EventManager.get(
interest_created.key.urlsafe()).get_event()
self.assertEqual(interest_created.key.urlsafe(),
interest_from_interest_mgr.key.urlsafe())
self.assertEqual(Event.FORMING, interest_from_interest_mgr.status)
def test_join_flex_interest(self):
success, message, interest_created = EventManager.create(
category='Category1',
duration='40',
expiration='180',
username=self.user1.username,
building_name='building_1',
note='test_note')
interest_manager = EventManager.get(interest_created.key.urlsafe())
interest_from_interest_mgr = interest_manager.get_event()
self.assertEqual(interest_created.key.urlsafe(),
interest_from_interest_mgr.key.urlsafe())
self.assertEqual(Event.FORMING, interest_from_interest_mgr.status)
interest_manager.join_flex_interest(self.user2.key.id(),
min_number_of_people_to_join='2',
max_number_of_people_to_join='3')
self.assertEqual(Event.EVENT_TYPE_SPECIFIC_INTEREST,
interest_created.type)
self.assertEqual(Event.FORMING, interest_created.status)
self.assertEqual(1, interest_manager.companion_count())
interest_manager.connect(self.user3.key.id())
self.assertEqual(Event.FORMED_OPEN, interest_created.status)
self.assertEqual(2, interest_manager.companion_count())
class RequestManagerTest(unittest.TestCase):
def setUp(self):
# First, create an instance of the Testbed class.
self.testbed = testbed.Testbed()
# Then activate the testbed, which prepares the service stubs for use.
self.testbed.activate()
# Next, declare which service stubs you want to use.
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub()
self.user1 = User(name="User1_name",
last_name="User1_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user1.put()
self.user2 = User(name="User2_name",
last_name="User2_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user2.put()
self.user3 = User(name="User3_name",
last_name="User3_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user3.put()
self.user4 = User(name="User4_name",
last_name="User4_lastname",
email="*****@*****.**",
password="******",
username="******",
building="building_1")
self.user4.put()
def tearDown(self):
self.testbed.deactivate()
def test_initiate(self):
#Activity Created by user1
success, message, activity_created = EventManager.create(
category='Category1',
duration='40',
expiration='180',
username=self.user1.username,
building_name='building_1',
min_number_of_people_to_join='1',
max_number_of_people_to_join='2',
note='note1')
activity_manager = EventManager.get(activity_created.key.urlsafe())
self.assertEqual(activity_created.key.urlsafe(),
activity_manager.get_event().key.urlsafe())
(success,
request) = RequestManager.initiate(activity_key=activity_created.key,
requester_key=self.user2.key)
self.assertIsNotNone(request, "Failed to initiate request")
request_manager = RequestManager.get(request.key.urlsafe())
self.assertIsNotNone(request_manager, "Failed to load request manager")
self.assertEqual(True, request_manager.can_accept(self.user1.username))
def test_approve(self):
#Activity Created by user1
success, message, activity_created = EventManager.create(
category='Category1',
duration='40',
expiration='180',
username=self.user1.username,
building_name='building_1',
min_number_of_people_to_join='1',
max_number_of_people_to_join='2',
note='note1')
activity_manager = EventManager.get(activity_created.key.urlsafe())
self.assertEqual(activity_created.key.urlsafe(),
activity_manager.get_event().key.urlsafe())
(success,
request) = RequestManager.initiate(activity_key=activity_created.key,
requester_key=self.user2.key)
self.assertIsNotNone(request, "Failed to initiate request")
request_manager = RequestManager.get(request.key.urlsafe())
self.assertIsNotNone(request_manager, "Failed to load request manager")
self.assertEqual(True, request_manager.can_accept(self.user1.username))
request_manager.accept()
self.assertEqual(request.ACCEPTED, request.status)
self.assertEqual(1, activity_manager.spots_remaining())
# webapp2 user store, how do you query it from webapp2_extras.appengine.auth.models import User myusers = User.query().fetch()
