def get_attendees_within(bounds, max_attendees):
geoname_ids = _get_geoname_ids_within(bounds)
logging.info('Loading PRCityCategory for top 10 cities: %s', geoname_ids)
if not geoname_ids:
return {}
memcache_key = 'AttendeeCache: %s' % hashlib.md5('\n'.join(str(x) for x in geoname_ids).encode('utf-8')).hexdigest()
memcache_result = memcache.get(memcache_key)
if memcache_result:
logging.info('Reading memcache key %s with value length: %s', memcache_key, len(memcache_result))
result = json.loads(memcache_result)
else:
people_rankings = get_people_rankings_for_city_names(geoname_ids, attendees_only=True)
logging.info('Loaded %s People Rankings', len(people_rankings))
if runtime.is_local_appengine() and False:
for x in people_rankings:
logging.info(x.key)
for person in x.worthy_top_people():
logging.info(' - %s' % person)
groupings = combine_rankings(people_rankings, max_people=max_attendees)
result = groupings.get('ATTENDEE', {})
# Trim out the unnecessary names
for category_city, people in result.iteritems():
for person in people:
del person['name']
json_dump = json.dumps(result)
try:
logging.info('Writing memcache key %s with value length: %s', memcache_key, len(json_dump))
memcache.set(memcache_key, json_dump, time=24 * 60 * 60)
except ValueError:
logging.warning('Error writing memcache key %s with value length: %s', memcache_key, len(json_dump))
logging.warning('Tried to write: %s', json.dumps(result, indent=2))
return result
def post(self):
code = self.request.get('code',None)
img = self.request.get('img',"")
# simple antispam
if sum(x in code.lower() for x in ('href=', 'url=', 'link=')) > 2:
self.redirect("/error")
return
if code.strip():
hash = base64.b64encode(hashlib.sha1(code.strip()).digest()[:6], "-_")
if not LogoProgram.all().filter('hash =', hash).get():
program = LogoProgram()
program.code = code
program.hash = hash
if img:
img = base64.b64decode(img)
img = images.Image(img)
img.resize(125, 125)
program.img = img.execute_transforms()
else:
self.redirect("/error")
return
program.put()
memcache.set("program: %s" % hash, program)
memcache.delete("recent_progs")
else:
hash = ""
self.redirect("/%s" % hash)
def put(self):
"""
Adds a keyname/value for session to the datastore and memcache
Returns the key from the datastore put or u"dirty"
"""
# update or insert in datastore
try:
return_val = db.put(self)
self.dirty = False
except:
return_val = u"dirty"
self.dirty = True
# update or insert in memcache
mc_items = memcache.get(u"_AppEngineUtilities_SessionData_%s" % \
(str(self.session.key())))
if mc_items:
value_updated = False
for item in mc_items:
if value_updated == True:
break
if item.keyname == self.keyname:
item.content = self.content
item.model = self.model
memcache.set(u"_AppEngineUtilities_SessionData_%s" % \
(str(self.session.key())), mc_items)
value_updated = True
break
if value_updated == False:
mc_items.append(self)
memcache.set(u"_AppEngineUtilities_SessionData_%s" % \
(str(self.session.key())), mc_items)
return return_val
def participate_in_doppleganger_on_new_instance(self):
"""Simulate participating in a new experiment on a "new" instance.
This test works by loading memcache with a copy of all gae/bingo
experiments before the doppleganger test exists.
After the doppleganger test has been created once, all future calls to
this function simulate being run on machines that haven't yet cleared
their instance cache and loaded the newly created doppleganger yet. We
do this by replacing the instance cache'd state of BingoCache with the
deep copy that we made before doppleganger was created.
A correctly functioning test will still only create one copy of the
experiment even though multiple clients attempted to create a new
experiment.
"""
# First, make a deep copy of the current state of bingo's experiments
bingo_clone = memcache.get("bingo_clone")
if not bingo_clone:
# Set the clone by copying the current bingo cache state
memcache.set("bingo_clone", copy.deepcopy(BingoCache.get()))
else:
# Set the current bingo cache state to the cloned state
gae_bingo.instance_cache.set(BingoCache.CACHE_KEY, bingo_clone)
return ab_test("doppleganger")
def GetBotsUser(user):
"""Finds and return BotsUser.
Args:
user: Currently signed in GAIA user (UserProperty).
Raises:
TypeError: If required parameter is missing.
Returns:
Matching existing bots user (first user in case of more than one matching),
else None.
"""
if not user:
raise TypeError('Missing parameter - User is required.')
# Checking the memcache first.
bots_user = memcache.get(user.user_id())
if bots_user:
return bots_user
existing_bots_users = BotsUser.all().filter('user = '******'More than one matching existing users found. %s',
str(existing_bots_users))
memcache.set(user.user_id(), existing_bots_users[0], MEMCACHE_EXP_TIME_IN_SEC)
return existing_bots_users[0]
def get_item(self, keyname = None):
"""
Returns a single session data item from the memcache or datastore
Args:
keyname: keyname of the session data object
Returns the session data object if it exists, otherwise returns None
"""
mc = memcache.get(u"_AppEngineUtilities_SessionData_%s" % \
(str(self.key())))
if mc:
for item in mc:
if item.keyname == keyname:
if item.deleted == True:
item.delete()
return None
return item
query = _AppEngineUtilities_SessionData.all()
query.filter(u"session = ", self)
query.filter(u"keyname = ", keyname)
results = query.fetch(1)
if len(results) > 0:
memcache.set(u"_AppEngineUtilities_SessionData_%s" % \
(str(self.key())), self.get_items_ds())
return results[0]
return None
def delete(self):
"""
Deletes a session and all it's associated data from the datastore and
memcache.
Returns True
"""
try:
query = _AppEngineUtilities_SessionData.all()
query.filter(u"session = ", self)
results = query.fetch(1000)
db.delete(results)
db.delete(self)
memcache.delete_multi([u"_AppEngineUtilities_Session_%s" % \
(str(self.key())), \
u"_AppEngineUtilities_SessionData_%s" % \
(str(self.key()))])
except:
mc = memcache.get(u"_AppEngineUtilities_Session_%s" % \
(str(self.key())))
if mc:
mc.deleted = True
else:
# not in the memcache, check to see if it should be
query = _AppEngineUtilities_Session.all()
query.filter(u"sid = ", self.sid)
results = query.fetch(1)
if len(results) > 0:
results[0].deleted = True
memcache.set(u"_AppEngineUtilities_Session_%s" % \
(unicode(self.key())), results[0])
return True
def post(self):
"""Checks the speakers in given conference and if it finds more than 1
entry of the speaker, it sets a memcache entry to the speaker and the
session names the speaker is in.
"""
speaker_ = self.request.get('speaker')
if speaker_ != "none":
memcache_output = []
wsck = self.request.get('wsck')
conf = ndb.Key(urlsafe=wsck).get()
# search sessions for multiple instances of the same speaker:
sessions_in_conf = Session.query(ancestor=conf.key)
for x in sessions_in_conf:
# if we find a match, add session to output:
if x.speaker == speaker_:
memcache_output.append(str(x.name))
# if memcache_output is greater than 1, we have a featured speaker:
if len(memcache_output) > 1:
# create unique memcache key for conference (using conf key):
memcache_key = MEMCACHE_FEATURED_SPEAKER_KEY + str(wsck)
# cast memcache_output as string:
memcache_output = ', '.join(memcache_output)
# set memcache on datastore using key, speaker, and output:
memcache.set(memcache_key, "Featured Speaker: {}. Sessions: {}"
"".format(speaker_,
memcache_output))
def get_title(self, url):
memcache_key = 'LinkInfo_' + url
title = memcache.get(memcache_key)
if not title:
title = fetch_title(url)
memcache.set(memcache_key, title)
return title
def gaeSet(key, bytesValue): # stores bytes, not string valye
global gaeMemcache
if gaeMemcache is None:
from google.appengine.api import memcache as gaeMemcache
compressedValue = zlib.compress(bytesValue)
# delete previous entity with the given key
# in order to conserve available memcache space.
gaeDelete(key)
valueSize = len(compressedValue)
if valueSize < GAE_MEMCACHE_MAX_ITEM_SIZE: # only one segment
return gaeMemcache.set(key, compressedValue, time=GAE_EXPIRE_WEEK)
# else store in separate chunk shards
chunkKeys = []
for pos in range(0, valueSize, GAE_MEMCACHE_MAX_ITEM_SIZE):
# TODO: use memcache.set_multi() for speedup, but don't forget
# about batch operation size limit (32Mb currently).
chunk = compressedValue[pos:pos + GAE_MEMCACHE_MAX_ITEM_SIZE]
# the pos is used for reliable distinction between chunk keys.
# the random suffix is used as a counter-measure for distinction
# between different values, which can be simultaneously written
# under the same key.
chunkKey = '%s%d%d' % (key, pos, random.getrandbits(31))
isSuccess = gaeMemcache.set(chunkKey, chunk, time=GAE_EXPIRE_WEEK)
if not isSuccess:
return False
chunkKeys.append(chunkKey)
return gaeMemcache.set(key, chunkKeys, time=GAE_EXPIRE_WEEK)
def stops(self, request):
stops = memcache.get('all_stops')
if not stops:
stops = [StopDef(key=s.key.urlsafe(), value=s.name.strip()) for s in models.Stop.query(projection=[models.Stop.name]).order(models.Stop.name).iter()]
stops = StopApiResponse(stops=stops)
memcache.set('all_stops', stops)
return stops
def get(self):
user=users.get_current_user()
smile=models.Smiley.get_by_id(int(self.request.get("id")))
if smile:
eVote=0
if user:
existVote=memcache.get("user"+user.nickname()+"smile"+str(smile.key().id()))
if existVote is None:
existVoteQ = models.db.GqlQuery("SELECT * FROM Votes WHERE voter = :1 AND smiley_id = :2 ",user,smile.key().id())
existVote=existVoteQ.get()
if existVote:
if not memcache.set("user"+user.nickname()+"smile"+str(smile.key().id()),existVote,3600):
logging.error("Memcache set failed. Checking Vote")
eVote=existVote.vote
existFlag=memcache.get("user"+user.nickname()+"smile"+str(smile.key().id())+"flag")
if existFlag is None:
existFlagQ = models.db.GqlQuery("SELECT * FROM Flags WHERE voter = :1 AND smiley_id = :2 ",user,smile.key().id())
existFlag=existFlagQ.get()
if existFlag:
if not memcache.set("user"+user.nickname()+"smile"+str(smile.key().id())+"flag",existFlag,3600):
logging.error("Memcache set failed. Adding Flag")
exist='neutral'
eFlag=0
if existFlag:
eFlag=existFlag.flag
if eVote>0:
exist='up'
elif eVote<0:
exist='down'
self.response.out.write("{'ups':'"+str(smile.ups)+"','downs':'"+str(smile.downs)+"','myVote':'"+str(exist)+"','flag':'"+str(eFlag)+"'}")
def _get_auth_token(self):
"""Get Authorization Token.
Actually gets the authorization token and secret from the service. The
token and secret are stored in our database, and the auth token is
returned.
"""
response = self.make_request(self.request_url)
result = self._extract_credentials(response)
auth_token = result["token"]
auth_secret = result["secret"]
# Save the auth token and secret in our database.
auth = AuthToken(service=self.service_name,
token=auth_token,
secret=auth_secret)
auth.put()
# Add the secret to memcache as well.
memcache.set(self._get_memcache_auth_key(auth_token), auth_secret,
time=20*60)
return auth_token
def validateDevKey(devKey):
if devKey is None:
return None
else:
devKey = devKey.lower()
storeKey = memcache.get(devKey)
if storeKey is None:
logging.error('Dev key - %s - cache miss')
q = db.GqlQuery("SELECT __key__ FROM DeveloperKeys WHERE developerKey = :1", devKey)
storeKey = q.get()
if storeKey is None:
# @todo we can create a black list for abusive keys to avoid the
# datastore query all together if this becomes a problem
logging.debug('API : illegal access using devkey %s' % devKey)
return None
else:
logging.debug('API : devkey cache miss!')
memcache.set(devKey, storeKey)
# we've validated the dev key at this point... start counting requests
total = memcache.incr(devKey + ':counter', initial_value=0)
logging.debug(storeKey)
return storeKey
def update_mainpage(key, page_no=1):
memcache.set('querytime' + str(page_no), round(time.time()))
#This is kinda expensive, I need a better way to do this.
posts=db.GqlQuery('SELECT * FROM Posts ORDER BY posted DESC') # DESC LIMIT :1', page_no*10) Intended at least this, but isn't working
posts=(list(posts))[(page_no-1)*10:(page_no-1)*10+10]
memcache.set(key,posts)
logging.error(memcache.get(key))
def get_feed(self, path):
articles = memcache.get('%s|feed|%s' % (settings.MEMCACHE_KEY_PREFIX, path))
if articles is None or not self.request.cache:
# DB query is memcached in get_all(). Limit to last several results
tutorials = models.Resource.get_all(order='-publication_date',
limit=self.FEED_RESULTS_LIMIT)
articles = []
for tut in tutorials:
article = {}
article['title'] = tut.title
if hasattr(tut, 'subtitle'):
article['subtitle'] = tut.subtitle
article['id'] = '-'.join(tut.title.lower().split())
article['href'] = tut.url
article['description'] = tut.description
article['author_id'] = tut.author.key().name()
if tut.second_author:
article['second_author'] = tut.second_author.key().name()
article['pubdate'] = datetime.datetime.strptime(
str(tut.publication_date), '%Y-%m-%d')
article['categories'] = []
for tag in tut.tags:
article['categories'].append(tag)
articles.append(article)
# Cache feed for 24hrs.
memcache.set(
'%s|feed|%s' % (settings.MEMCACHE_KEY_PREFIX, path), articles, 86400)
return articles
def get_toc(self, path):
# Only have TOC on tutorial pages. Don't do work for others.
if not (re.search('/tutorials', path) or re.search('/mobile', path)):
return ''
toc = memcache.get('%s|toc|%s' % (settings.MEMCACHE_KEY_PREFIX, path))
if toc is None or not self.request.cache:
template_text = render_to_string(path, {})
parser = html5lib.HTMLParser(tree=treebuilders.getTreeBuilder("dom"))
dom_tree = parser.parse(template_text)
walker = treewalkers.getTreeWalker("dom")
stream = walker(dom_tree)
toc = []
current = None
for element in stream:
if element['type'] == 'StartTag':
if element['name'] in ['h2', 'h3', 'h4']:
for attr in element['data']:
if attr[0] == 'id':
current = {
'level' : int(element['name'][-1:]) - 1,
'id' : attr[1]
}
elif element['type'] == 'Characters' and current is not None:
current['text'] = element['data']
elif element['type'] == 'EndTag' and current is not None:
toc.append(current)
current = None
memcache.set('%s|toc|%s' % (settings.MEMCACHE_KEY_PREFIX, path), toc, 3600)
return toc
def saveReview(self, username, date, review, movie):
f = Review(username = username, date = date, review = review, movie = movie)
f.put() #add the username/date/review/movie to the database
randomNumber = random.randint(1,100000)
cached_reviews_key = username + "_" + str(randomNumber) #create a key for the review
cached_reviews_value = [username, date, review, movie]
cached_allReviews_dict = memcache.get("allReviews")
if cached_allReviews_dict is not None: #if this dictionary exists
cached_reviews_dict = cached_allReviews_dict.get(username) #get the cached dictionary of this user's reviews
if cached_reviews_dict is not None: #if this dictionary exists
cached_reviews_dict[cached_reviews_key] = cached_reviews_value #add the key/value pair to the dictionary
cached_allReviews_dict[username] = cached_reviews_dict
memcache.set("allReviews", cached_allReviews_dict)
self.redirect("/")
else: #if this is the user's first review
cached_reviews_dict = {}
cached_reviews_dict[cached_reviews_key] = cached_reviews_value
cached_allReviews_dict[username] = cached_reviews_dict
memcache.set("allReviews", cached_allReviews_dict)
self.redirect("/")
else: #creating cached_allReviews_dict for first time
cached_reviews_dict = {}
cached_reviews_dict[cached_reviews_key] = cached_reviews_value
cached_allReviews_dict = {}
cached_allReviews_dict[username] = cached_reviews_dict
memcache.add("allReviews", cached_allReviews_dict)
self.redirect("/")
def render_to_response(self, template, context=None, use_cache=False):
"""Renders the template and writes the result to the response."""
if use_cache:
# Use the request's path to store the contents.
# WARNING: This could cause scary problems if you render
# user-specific pages.
# DO NOT use current_profile in a template rendered with use_cache=True.
cache_key = self.request.path
contents = memcache.get(cache_key)
if not contents or 'flushcache' in self.request.arguments():
contents = self.render_template(template, context)
# If add() returns False, it means another request is already trying
# to cache the page. No need to do anything here.
if memcache.add('lock.%s' % cache_key, True):
memcache.set(cache_key, contents)
memcache.delete('lock.%s' % cache_key)
else:
contents = self.render_template(template, context)
self.response.write(contents)
def saveFavorite(self, username, favoriteMovie, favoriteGenre):
f = Favorite(username = username, movie = favoriteMovie, genre = favoriteGenre)
f.put() #add the username/movie/genre to the database
randomNumber = random.randint(1,100000)
cached_favorite_key = username + "_" + str(randomNumber) #create a key for the favorite
cached_favorite_value = [username, favoriteMovie, favoriteGenre]
cached_allFavorites_dict = memcache.get("allFavorites")
if cached_allFavorites_dict is not None: #if this dictionary exists
cached_favorites_dict = cached_allFavorites_dict.get(username) #get the cached dictionary of this user's favorites
if cached_favorites_dict is not None: #if this dictionary exists
cached_favorites_dict[cached_favorite_key] = cached_favorite_value #add the key/value pair to the dictionary
cached_allFavorites_dict[username] = cached_favorites_dict
memcache.set("allFavorites", cached_allFavorites_dict)
self.redirect("/")
else: #if this is the user's first favorite
cached_favorites_dict = {}
cached_favorites_dict[cached_favorite_key] = cached_favorite_value
cached_allFavorites_dict[username] = cached_favorites_dict
memcache.set("allFavorites", cached_allFavorites_dict)
self.redirect("/")
else: #creating cached_allFavorites_dict for first time
cached_favorites_dict = {}
cached_favorites_dict[cached_favorite_key] = cached_favorite_value
cached_allFavorites_dict = {}
cached_allFavorites_dict[username] = cached_favorites_dict
memcache.add("allFavorites", cached_allFavorites_dict)
self.redirect("/")
def refillSignedUp(self):
s = db.GqlQuery("SELECT * FROM SignedUp")
cached_signup_set = set()
for c in s:
cached_signup_set.add(c.username) #add to the set of signed-up people
memcache.set("signedUp",cached_signup_set)
def get_present_users(shard, include_stale=False, limit=1000):
"""Returns a list of present users for a shard in descending log-in order.
Notably, this query is going to be eventually consistent and miss the folks
who have just recently joined. That's okay. It's like they joined the chat
a little bit late. They will still be able to see previous Posts through
historical queries.
"""
shard_key = 'users-shard-%s' % shard
if include_stale:
shard_key = '%s-stale' % shard_key
user_list = memcache.get(shard_key)
if user_list:
return user_list
query = models.LoginRecord.query()
query = query.filter(models.LoginRecord.shard_id == shard)
# When we don't care about stale users, select everyone in the query,
# including users we know are already logged out.
if not include_stale:
query = query.filter(models.LoginRecord.online == True)
query.order(-models.LoginRecord.last_update_time)
user_list = query.fetch(limit)
if not include_stale:
user_list = only_active_users(*user_list)
memcache.set(shard_key, user_list, config.user_max_inactive_seconds)
return user_list
def get(self):
resp = urlfetch.fetch('http://domain.hackerdojo.com/users', deadline=20)
if resp.status_code == 200:
memcache.set('usernames', resp.content, 3600*2)
self.response.out.write("<h1>200 OK - Usernames set</h1>")
else:
self.response.out.write("500 - Something broke")
def auth_login_with_third_party(self, auth_id=None, login_id=None, remember=False, **kwargs):
"""Called to authenticate the user after a third party confirmed
authentication.
:param login_id:
Authentication id, generally a combination of service name and
user identifier for the service, e.g.: 'twitter:john'.
:param remember:
True if authentication should be persisted even if user leaves the
current session (the "remember me" feature).
:return:
``None``. This always authenticates the user.
"""
# Load user entity.
user = self.auth_get_user_entity(auth_id=auth_id, login_id=login_id)
if user:
# Set current user from datastore.
self.auth_set_session(user.auth_id, user.session_id, remember)#, **kwargs)
else:
# Simply set a session; user will be created later if required.
# put args in memcache
data = memcache.get(login_id)
if data is None:
memcache.add(login_id, kwargs, 3600)
else:
memcache.set(login_id, kwargs, 3600)
self.auth_set_session(auth_id, remember=remember, login_id=login_id)#, **kwargs)
return user
def create_key(self):
"""
Creates a unique key for the session.
Returns the key value as a unicode string.
"""
self.session_key = time.time()
valid = False
while valid == False:
# verify session_key is unique
if memcache.get(u"_AppEngineUtilities_Session_%s" % \
(unicode(self.session_key))):
self.session_key = self.session_key + 0.001
else:
query = _AppEngineUtilities_Session.all()
query.filter(u"session_key = ", self.session_key)
results = query.fetch(1)
if len(results) > 0:
self.session_key = self.session_key + 0.001
else:
try:
self.put()
memcache.set(u"_AppEngineUtilities_Session_%s" %+ \
(unicode(self.session_key)), self)
except:
self.dirty = True
memcache.set(u"_AppEngineUtilities_Session_%s" % \
(unicode(self.session_key)), self)
valid = True
return unicode(self.session_key)
def post(self):
"""Execute the request and render the template."""
operation = self.request.get('operation')
# Dict of operations to easily map keys to methods.
operations = {
'insertSubscription': self._insert_subscription,
'deleteSubscription': self._delete_subscription,
'insertContact': self._insert_contact,
'deleteContact': self._delete_contact,
'deleteTimelineItem': self._delete_timeline_item,
'propertiesForLocation': self._insert_properties_for_location,
'clearTimeline': self._clear_timeline,
}
if operation in operations:
message = operations[operation]()
else:
message = "I don't know how to " + operation
# Store the flash message for 5 seconds.
memcache.set(key=self.userid, value=message, time=5)
self.redirect('/')
def cached_by_id(photo_id):
key = 'photo_' + str(photo_id)
photo = memcache.get(key)
if not photo:
photo = Photo.get_by_id(photo_id)
memcache.set(key, photo)
return photo
def __init__(self, credentials=None):
"""Initialize Client API object for Compute Engine manipulation.
If authorized HTTP is not given by parameter, it uses user ID stored
in Memcache and fetches credentials for that user.
Args:
credentials: OAuth2 credentials of current user.
"""
if credentials:
user_id = users.get_current_user().user_id()
credentials_in_json = credentials.to_json()
authorized_user = AuthorizedUserId.get_or_insert(
self.USER_ID_KEY, user_id=user_id,
credentials=db.Text(credentials_in_json))
memcache.set(self.USER_CREDENTIALS_KEY, credentials_in_json)
if (authorized_user.user_id != user_id or
str(authorized_user.credentials) != credentials_in_json):
authorized_user.user_id = user_id
authorized_user.credentials = db.Text(credentials_in_json)
authorized_user.put()
else:
credentials_in_json = memcache.get(self.USER_CREDENTIALS_KEY)
if not credentials_in_json:
authorized_user = AuthorizedUserId.get_by_key_name(self.USER_ID_KEY)
credentials_in_json = str(authorized_user.credentials)
credentials = OAuth2Credentials.from_json(credentials_in_json)
self.compute_api = build('compute', self.COMPUTE_API_VERSION,
http=credentials.authorize(httplib2.Http()))
def post(self):
status = "ok"
user = self.user
if not user:
self.redirect('/login')
store_name = self.request.get('choose_market')
logging.error(store_name)
address = self.request.get('address')
telephone = self.request.get('telephone')
stores_list = list(caching.get_stores())
t = db.GqlQuery('SELECT * FROM UserData WHERE login = :login', login = user.auth_ids)
new_user = models.UserData()
new_user = list(t)[0]
db.delete(t)
new_user.store_id = int(store_name)
new_user.address = address
if re.match('^\+(?:[0-9] ?){6,14}[0-9]$', telephone):
new_user.telephone = telephone
else:
status = "telephone"
new_user.put()
memcache.set('current_store', None)
memcache.set('current_store' + user.auth_ids[0], None)
self.render('user_profile_change.html',{'m_user': new_user,
'is_home':1,
'first_name' : user.name,
'last_name' : user.last_name,
'stores_list': stores_list,
'address': new_user.address if new_user.address else "",
'telephone': new_user.telephone if new_user.telephone else "",
'status': status})
def fix_DB(request):
edition = db_fixer_edition.all().get()
if edition == None:
edition = db_fixer_edition(edition = "")
edition.put()
return HttpResponse("NO ME GUSTA")
query = cartas_mtg.all().filter('edicao =',edition.edition).filter('raridade =','Uncommon')
last_cursor = memcache.get('DB_Fixer')
if last_cursor:
query.with_cursor(last_cursor)
entries = query.fetch(50)
cursor = query.cursor()
memcache.set('DB_Fixer', cursor)
quantidade = len(entries)
for carta in entries:
carta.stock = carta.stock + 4
carta.put()
return HttpResponse("Success " + str(quantidade))
def cache_set(self):
logging.info('cache set')
memcache.set(self.key().name(), self, namespace=self.key().kind())
def save(self): """Save session data.""" if not self._invalid: memcache.set(self._sid,self.copy(),self._timeout)
def query_or_cache(entity, start, stop, force=False):
if force:
entities = TwitterEntityFreq.query(
TwitterEntityFreq.entity == entity,
TwitterEntityFreq.timestamp > start,
TwitterEntityFreq.timestamp <= stop).order(
TwitterEntityFreq.timestamp)
data = [MockTWE(i) for i in entities]
memcache.set(MC_GUARD % entity, 1, 30)
memcache.set(MC_KEY % entity, data)
return [i for i in data]
nq = memcache.get(MC_GUARD % entity)
data = memcache.get(MC_KEY % entity)
td = timedelta(seconds=30)
if data:
last = data[-1].timestamp
if stop - last > td and not nq:
entities = TwitterEntityFreq.query(
TwitterEntityFreq.entity == entity,
TwitterEntityFreq.timestamp > last,
TwitterEntityFreq.timestamp <= stop).order(
TwitterEntityFreq.timestamp)
data += [MockTWE(i) for i in entities]
memcache.set(MC_GUARD % entity, 1, 30)
memcache.set(MC_KEY % entity, data)
elif not nq:
entities = TwitterEntityFreq.query(
TwitterEntityFreq.entity == entity,
TwitterEntityFreq.timestamp > start,
TwitterEntityFreq.timestamp <= stop).order(
TwitterEntityFreq.timestamp)
data = [MockTWE(i) for i in entities]
memcache.set(MC_GUARD % entity, 1, 30)
memcache.set(MC_KEY % entity, data)
return [i for i in data if i.timestamp > start and i.timestamp <= stop]
def get(self):
if not db.WRITE_CAPABILITY.is_enabled():
self.response.set_status(503)
self.response.headders['Retry-After'] = 120
logging.info("Told that the db was down for maintenance")
self.response.out.write('Currently down for maintenance')
else:
t = int(time.time()) - 7200
logging.info(
'CRON AccountNewRecords: totaling funds for after %d' % t)
dispersal = Dispersals()
commissions_total = 0
designer_total = 0
maintainers_total = 0
total = 0
maintainers = AppSettings.get_or_insert(
"maintainers",
value="00000000-0000-0000-0000-000000000000|0").value.split(
"|")
people_to_pay = []
query = Purchases.gql("WHERE accounted = :1", "0")
for record in query:
logging.info('CRON: %s|%s' %
(record.key().id(), record.seller))
total += record.amount_paid
token = 'Distributor_%s' % record.seller
cacheditem = memcache.get(token)
if cacheditem is None:
dist = Distributor.gql("WHERE avkey = :1",
record.seller).get()
dist_info = {
"max_discount": dist.max_discount,
"commission": dist.commission
}
memcache.set(token, yaml.safe_dump(dist_info))
else:
#pull the item's details out of the yaml'd dict
dist_info = yaml.safe_load(cacheditem)
if dist_info['commission'] > 0:
commission = record.paid_amount * dist_info[
'commission'] / 100
commissions_total += commission
stoken = '%s_seller' % (record.seller)
commission_total = commission + getattr(
dispersal, stoken, 0)
setattr(dispersal, stoken, commission_total)
people_to_pay.append(stoken)
name = record.item
item = tools.get_item(name, True)
if item is None:
logging.error(
'Error, Paid item %s not found. Requested by %s using %s.'
%
(name, self.request.headers['X-SecondLife-Owner-Name'],
self.request.headers['X-SecondLife-Object-Name']))
if item['designer_cut'] > 0:
cut = record.paid_amount * item['designer_cut'] / 100
designer_total += cut
dtoken = '%s_designer' % (item['designer'])
cut_total = cut + getattr(dispersal, dtoken, 0)
setattr(dispersal, dtoken, cut_total)
people_to_pay.append(dtoken)
for maintainer, amount in zip(maintainers[::2], maintainers[1::2]):
cut = total * int(amount) / 100
maintainers_total += cut
mtoken = '%s_maintainer' % (maintainer)
setattr(dispersal, mtoken, cut)
people_to_pay.append(mtoken)
if query.count(1) > 0:
if total >= (maintainers_total + designer_total +
commissions_total):
setattr(dispersal, 'commissions_total', commissions_total)
setattr(dispersal, 'designers_total', designer_total)
setattr(dispersal, 'maintainers_total', maintainers_total)
setattr(dispersal, 'dispersal_total',
(maintainers_total + designer_total +
commissions_total))
setattr(dispersal, 'total', total)
setattr(dispersal, 'people_to_pay',
"\n".join(people_to_pay))
dispersal.put()
logging.info('CRON AccountNewRecords: saved')
#add right url
taskqueue.add(url='/paiddist/disperse?id=%s' %
(dispersal.key().id()),
headers={},
queue_name='Disperse',
method='PUT')
for record in query:
record.accounted = "1"
record.put()
else:
logging.error(
"CRON AccountNewRecords: total dispersal %s is greater than total paid %s"
% (maintainers_total + designer_total +
commissions_total, total))
redirecturl = "not needed?"
alarm.SendAlarm(
'Dispersal', t, True,
"total dispersal %s is greater than total paid %s" %
(maintainers_total + designer_total +
commissions_total, total), redirecturl)
self.error(500)
else:
logging.info('CRON AccountNewRecords: No records')
logging.info('CRON AccountNewRecords: Finished')
def put(self):
if not self._invalidated:
memcache.set(self._id, pickle.dumps(self.copy()), self._timeout)
def post(self):
title = self.request.get("title")
pic = self.request.get("pic")
team = self.request.get('team')
user = users.get_current_user()
error = ""
teamKey = None
if not team:
error = "please provide a team"
else:
teamKey = getOrCreateTeamKeyFromName(team)
if teamKey == None:
#malicious key
error += "bad team name"
else:
teamKey = str(teamKey)
#if not user:
# self.redirect('/')
# return
artistKey = None
if user:
artistKey = getOrCreateArtistKeyFromUser(user)
artistKey = str(artistKey)
#if not artist: letting anyone submit
# logging.log('had some problem, could not ger artist')
# self.redirect('/')
keys = memcache.get(MEMCACHE_TOP_ART_KEY)
if keys and len(keys) >= MAX_POSTS:
self.redirect(
'/') #only allow MAX_POSTS posts, this is going on appengine
return
#canVote = not check_secure_val(self.request.cookies.get('voted%s' % VOTING_EVENT))
if len(title) > 500:
error += "title should be less than 500 characters"
if len(title) == 0:
error += "Your artwork needs a title"
canProceed = (not not title) and (not not pic) and (not error)
if canProceed:
try:
resizedPic = images.resize(pic, 500, 300)
picBlob = db.Blob(resizedPic)
if artistKey:
a = Art(title=title,
pic=picBlob,
artist=artistKey,
teamKey=teamKey)
else:
a = Art(title=title, pic=picBlob, teamKey=teamKey)
a.put()
team = db.get(teamKey)
teamMemcacheID = getMemcacheTeamIDfromKey(teamKey)
memcache.set(teamMemcacheID, team)
addArtToTeam(teamKey, str(a.key()))
topArts(True)
topTeams(True)
title = ""
#clear title for redirect
except images.BadImageError:
error += "Bad Image file"
"""
except images.NOT_IMAGE:
error += "no image file"
except images.IMAGE_TOO_LARGE:
error += "image too large, please keep it under 4MB"
"""
except images.Error:
error += "Sorry, the image you tried to upload could not be processed"
#finally:
#self.render_front(title=title,error = error, canVote=canVote)
else:
error += 'Sorry, you need a title and a picture to submit'
if title or error:
self.redirect('/?get_title=%s&get_error=%s' % (title, error))
else:
self.redirect('/')
import hashlib
import hmac
import random
import re
#by default reset all cookies if the hmac is not consistent, this will allow for easily expiring cookies
#if login is used, its better to have a different secret for non-volatile data like that.
SECRET = "you've been trusted with this secret :)" #+ str(random.randint(0,2000000000000))
MEMCACHE_ART_PREFIX = "Art_"
MEMCACHE_TEAM_PREFIX = "Team"
MEMCACHE_TOP_ART_KEY = "top"
MEMCACHE_USER_PREFIX = "Artist_"
MEMCACHE_USERS_KEY = "Artists"
MEMCACHE_TOP_TEAM_KEY = "Teams"
VOTING_EVENT = "1"
memcache.set('app_voting_started', True)
VOTES_ACTIVE = memcache.get('app_voting_started')
MAX_POSTS = 20
PAGE_HEADING = "Voting Page- currently max " + str(MAX_POSTS) + "posts"
simpleStringRegex = (r'[a-zA-Z0-9]+(?:[a-zA-Z0-9 ]+[a-zA-Z0-9])*')
def getMemcacheArtIDfromKey(key):
return MEMCACHE_ART_PREFIX + str(key)
def getMemcacheTeamIDfromKey(key):
return MEMCACHE_TEAM_PREFIX + str(key)
def getcache(key, compute, time=600):
value = memcache.get(key)
if value is None:
value = compute()
memcache.set(key, value, time=time)
return value
def put(self, key, value):
"""Put (key, value) into cache."""
memcache.set(key, value, self.ttl_in_seconds)
def get(self):
mode = self.request.get('mode')
if mode != "count":
self.response.out.write("""<html>
<head>
<link rel="shortcut icon" href="http://www.pixelbeat.org/favicon.ico" type="image/x-icon"/>
<!-- The following stops prefetching of domains (of urls provided by commenters) -->
<meta http-equiv="x-dns-prefetch-control" content="off">
<style type="text/css">
a { /*add :link for external links*/
text-decoration: none; /* don't underline links by default */
outline-style: none; /* don't put dotted box around clicked links */
}
a:hover {
text-decoration: underline;
}
.comment {
background-color: #FAFAF0;
border: 1px solid #E8E7D0;
margin-bottom: 0.5em;
}
.odd {
background-color: #F5F5F0;
}
</style>
<script type="text/javascript">
/* If user isn't running javascript and
they don't click the checkbox then comment lost */
function validateOnSubmit() {
var spammer = document.commentform.remmaps.checked;
if (spammer==1) {
alert("You must uncheck the checkbox");
return false;
}
return true;
}
</script>
</head>
<body border=0>""")
if mode == "count":
value = memcache.get(self.request.path)
if value is not None:
self.response.out.write('%d' % value)
return
#TODO: can have simpler query for just counting. May not need Gql at all?
comments = db.GqlQuery(
"SELECT * FROM Comment WHERE page = '%s' ORDER BY date" %
self.request.path)
if mode == "count":
value = comments.count()
memcache.set(self.request.path, value,
600) #timeout as can delete comments in dashboard
self.response.out.write('%d' % value)
return
num = 0
for comment in comments:
self.response.out.write(
'\n<div id="comment-%s" class="comment %s">\n' %
(comment.key().id(), (num % 2 and "odd" or "")))
self.response.out.write('<a href="#comment-%s">#</a> ' %
comment.key().id())
if comment.author:
if comment.url.startswith("http://"):
self.response.out.write(
'<a rel="nofollow" href="%s">%s</a>:' %
(cgi.escape(comment.url,
quote=True), cgi.escape(comment.author)))
else:
self.response.out.write('%s:' % cgi.escape(comment.author))
else:
self.response.out.write('anonymous:')
self.response.out.write(' ' + age(comment.date))
self.response.out.write('\n<blockquote>%s</blockquote>' %
comment.content)
self.response.out.write('\n</div>\n')
num += 1
#Use this to auto fill form
#user = users.get_current_user()
#if user:
# self.response.out.write('Hello, ' + user.nickname())
self.response.out.write("""
<div style="margin-top: 1.5em;">
<form id="commentform" name="commentform" action="" method="post" onsubmit="return validateOnSubmit();">
<table>
<tr><td> Name: </td> <td><input type="text" name="author" size="30"> </td></tr>
<tr><td> Website: </td> <td><input type="text" name="url" size="60"> </td></tr>
<tr><td> Spammer? </td> <td> <input type="checkbox" id="remmaps" name="remmaps" value="1" checked> </td></tr>
<tr><td style="vertical-align:top;"> comments: <br/>(no HTML) </td> <td><textarea name="content" rows="10" cols="60"></textarea></td></tr>
<table>
<input type="submit" value="Post">
</form>
</div>
""")
self.response.out.write('\n</html>\n</body>')
def post(self):
site = GetSite()
self.session = Session()
browser = detect(self.request)
template_values = {}
template_values['site'] = site
template_values['system_version'] = SYSTEM_VERSION
member = CheckAuth(self)
l10n = GetMessages(self, member, site)
template_values['l10n'] = l10n
if (member):
dest = '/settings/avatar'
timestamp = str(int(time.time()))
try:
avatar = self.request.get('avatar')
except:
return self.redirect(dest)
if avatar is None:
return self.redirect(dest)
avatar_len = len(avatar)
if avatar_len == 0:
return self.redirect(dest)
avatar_73 = images.resize(avatar, 73, 73)
avatar_48 = images.resize(avatar, 48, 48)
avatar_24 = images.resize(avatar, 24, 24)
# Large 73x73
q1 = db.GqlQuery("SELECT * FROM Avatar WHERE name = :1",
'avatar_' + str(member.num) + '_large')
if (q1.count() == 1):
avatar_large = q1[0]
avatar_large.content = db.Blob(avatar_73)
avatar_large.put()
else:
qc1 = db.GqlQuery("SELECT * FROM Counter WHERE name = :1",
'avatar.max')
if (qc1.count() == 1):
counter1 = qc1[0]
counter1.value = counter1.value + 1
else:
counter1 = Counter()
counter1.name = 'avatar.max'
counter1.value = 1
counter1.put()
avatar_large = Avatar()
avatar_large.name = 'avatar_' + str(member.num) + '_large'
avatar_large.content = db.Blob(avatar_73)
avatar_large.num = counter1.value
avatar_large.put()
member.avatar_large_url = '/avatar/' + str(
member.num) + '/large?r=' + timestamp
member.put()
# Normal 48x48
q2 = db.GqlQuery("SELECT * FROM Avatar WHERE name = :1",
'avatar_' + str(member.num) + '_normal')
if (q2.count() == 1):
avatar_normal = q2[0]
avatar_normal.content = db.Blob(avatar_48)
avatar_normal.put()
else:
qc2 = db.GqlQuery("SELECT * FROM Counter WHERE name = :1",
'avatar.max')
if (qc2.count() == 1):
counter2 = qc2[0]
counter2.value = counter2.value + 1
else:
counter2 = Counter()
counter2.name = 'avatar.max'
counter2.value = 1
counter2.put()
avatar_normal = Avatar()
avatar_normal.name = 'avatar_' + str(member.num) + '_normal'
avatar_normal.content = db.Blob(avatar_48)
avatar_normal.num = counter2.value
avatar_normal.put()
member.avatar_normal_url = '/avatar/' + str(
member.num) + '/normal?r=' + timestamp
member.put()
# Mini 24x24
q3 = db.GqlQuery("SELECT * FROM Avatar WHERE name = :1",
'avatar_' + str(member.num) + '_mini')
if (q3.count() == 1):
avatar_mini = q3[0]
avatar_mini.content = db.Blob(avatar_24)
avatar_mini.put()
else:
qc3 = db.GqlQuery("SELECT * FROM Counter WHERE name = :1",
'avatar.max')
if (qc3.count() == 1):
counter3 = qc3[0]
counter3.value = counter3.value + 1
else:
counter3 = Counter()
counter3.name = 'avatar.max'
counter3.value = 1
counter3.put()
avatar_mini = Avatar()
avatar_mini.name = 'avatar_' + str(member.num) + '_mini'
avatar_mini.content = db.Blob(avatar_24)
avatar_mini.num = counter3.value
avatar_mini.put()
member.avatar_mini_url = '/avatar/' + str(
member.num) + '/mini?r=' + timestamp
member.put()
# Upload to MobileMe
if config.mobileme_enabled:
headers = {
'Authorization':
'Basic ' + base64.b64encode(config.mobileme_username +
':' + config.mobileme_password)
}
host = 'idisk.me.com'
# Sharding
timestamp = str(int(time.time()))
shard = member.num % 31
root = '/' + config.mobileme_username + '/Web/Sites/v2ex/avatars/' + str(
shard)
root_mini = root + '/mini'
root_normal = root + '/normal'
root_large = root + '/large'
h = httplib.HTTPConnection(host)
# Mini
h.request('PUT', root_mini + '/' + str(member.num) + '.png',
str(avatar_24), headers)
response = h.getresponse()
if response.status == 201 or response.status == 204:
member.avatar_mini_url = 'http://web.me.com/' + config.mobileme_username + '/v2ex/avatars/' + str(
shard) + '/mini/' + str(
member.num) + '.png?r=' + timestamp
# Normal
h.request('PUT', root_normal + '/' + str(member.num) + '.png',
str(avatar_48), headers)
response = h.getresponse()
if response.status == 201 or response.status == 204:
member.avatar_normal_url = 'http://web.me.com/' + config.mobileme_username + '/v2ex/avatars/' + str(
shard) + '/normal/' + str(
member.num) + '.png?r=' + timestamp
# Large
h.request('PUT', root_large + '/' + str(member.num) + '.png',
str(avatar_73), headers)
response = h.getresponse()
if response.status == 201 or response.status == 204:
member.avatar_large_url = 'http://web.me.com/' + config.mobileme_username + '/v2ex/avatars/' + str(
shard) + '/large/' + str(
member.num) + '.png?r=' + timestamp
member.put()
# Upload to UpYun
if config.upyun_enabled:
u = UpYun(config.upyun_bucket, config.upyun_username,
config.upyun_password)
# Mini
mini = avatar_24
u.setContentMD5(md5(mini))
mini_suffix = '/avatars/mini/' + str(member.num) + '.png'
r = u.writeFile(mini_suffix, mini, True)
if r == True:
member.avatar_mini_url = 'http://' + config.upyun_bucket + '.b0.upaiyun.com' + mini_suffix + '?r=' + timestamp
# Normal
normal = avatar_48
u.setContentMD5(md5(normal))
normal_suffix = '/avatars/normal/' + str(member.num) + '.png'
r = u.writeFile(normal_suffix, normal, True)
if r == True:
member.avatar_normal_url = 'http://' + config.upyun_bucket + '.b0.upaiyun.com' + normal_suffix + '?r=' + timestamp
# Large
large = avatar_73
u.setContentMD5(md5(large))
large_suffix = '/avatars/large/' + str(member.num) + '.png'
r = u.writeFile(large_suffix, large, True)
if r == True:
member.avatar_large_url = 'http://' + config.upyun_bucket + '.b0.upaiyun.com' + large_suffix + '?r=' + timestamp
member.put()
memcache.set('Member_' + str(member.num), member, 86400 * 14)
memcache.set('Member::' + member.username_lower, member,
86400 * 14)
memcache.delete('Avatar::avatar_' + str(member.num) + '_large')
memcache.delete('Avatar::avatar_' + str(member.num) + '_normal')
memcache.delete('Avatar::avatar_' + str(member.num) + '_mini')
self.session['message'] = '新头像设置成功'
self.redirect('/settings/avatar')
else:
self.redirect('/signin')
def time_set(key, val):
save_time = datetime.utcnow()
memcache.set(key, (val, save_time))
def get(self, member_username):
site = GetSite()
browser = detect(self.request)
self.session = Session()
template_values = {}
template_values['site'] = site
template_values['system_version'] = SYSTEM_VERSION
member = CheckAuth(self)
template_values['member'] = member
template_values['show_extra_options'] = False
if member:
if member.num == 1:
template_values['show_extra_options'] = True
l10n = GetMessages(self, member, site)
template_values['l10n'] = l10n
one = False
one = GetMemberByUsername(member_username)
if one is not False:
if one.followers_count is None:
one.followers_count = 0
template_values['one'] = one
template_values['page_title'] = site.title + u' › ' + one.username
template_values[
'canonical'] = 'http://' + site.domain + '/member/' + one.username
if one.github:
github = memcache.get('Member::' + one.username_lower +
'::github')
if github is None:
response = urlfetch.fetch("https://api.github.com/users/" +
one.github + "/repos")
if response.status_code == 200:
github = response.content
memcache.set(
'Member::' + one.username_lower + '::github',
github, 86400)
if github is not None:
template_values['github_repos'] = sorted(
json.loads(github),
key=lambda x: x['stargazers_count'],
reverse=True)
if one is not False:
member_blog = memcache.get('member::' + str(one.num) + '::blog')
if member_blog == None:
blog = db.GqlQuery(
"SELECT * FROM Topic WHERE node_name = :1 AND member_num = :2 ORDER BY created DESC LIMIT 1",
'blog', one.num)
if blog.count() > 0:
template_values['blog'] = blog[0]
memcache.set('member::' + str(one.num) + '::blog', blog[0],
7200)
else:
template_values['blog'] = member_blog
member_topics = memcache.get('member::' + str(one.num) +
'::topics')
if member_topics != None:
template_values['topics'] = member_topics
else:
q2 = db.GqlQuery(
"SELECT * FROM Topic WHERE member_num = :1 ORDER BY created DESC LIMIT 10",
one.num)
template_values['topics'] = q2
memcache.set('member::' + str(one.num) + '::topics', q2, 7200)
replies = memcache.get('member::' + str(one.num) +
'::participated')
if replies is None:
q3 = db.GqlQuery(
"SELECT * FROM Reply WHERE member_num = :1 ORDER BY created DESC LIMIT 10",
one.num)
ids = []
replies = []
i = 0
for reply in q3:
if reply.topic.num not in ids:
i = i + 1
if i > 10:
break
replies.append(reply)
ids.append(reply.topic.num)
if len(replies) > 0:
memcache.set('member::' + str(one.num) + '::participated',
replies, 7200)
if len(replies) > 0:
template_values['replies'] = replies
template_values['show_block'] = False
template_values['show_follow'] = False
template_values['favorited'] = False
if one and member:
if one.num != member.num:
template_values['show_follow'] = True
template_values['show_block'] = True
try:
blocked = pickle.loads(member.blocked.encode('utf-8'))
except:
blocked = []
if one.num in blocked:
template_values['one_is_blocked'] = True
else:
template_values['one_is_blocked'] = False
if member.hasFavorited(one):
template_values['favorited'] = True
else:
template_values['favorited'] = False
if 'message' in self.session:
template_values['message'] = self.session['message']
del self.session['message']
if one is not False:
if browser['ios']:
path = os.path.join(os.path.dirname(__file__), 'tpl', 'mobile',
'member_home.html')
else:
path = os.path.join(os.path.dirname(__file__), 'tpl',
'desktop', 'member_home.html')
else:
if browser['ios']:
path = os.path.join(os.path.dirname(__file__), 'tpl', 'mobile',
'member_not_found.html')
else:
path = os.path.join(os.path.dirname(__file__), 'tpl',
'desktop', 'member_not_found.html')
output = template.render(path, template_values)
self.response.out.write(output)
def save(self): # Update the timestamp, because it was modified. self.timestamp = time.time() memcache.set(self.key, self)
def _put(self):
"""Saves the session and updates the memcache entry."""
memcache.set(self._key.id(), self.data)
super(Session, self).put()
def post(self):
site = GetSite()
browser = detect(self.request)
self.session = Session()
template_values = {}
template_values['site'] = site
template_values['page_title'] = site.title + u' › 密码设置'
template_values['system_version'] = SYSTEM_VERSION
errors = 0
member = CheckAuth(self)
l10n = GetMessages(self, member, site)
template_values['l10n'] = l10n
if (member):
template_values['member'] = member
template_values['member_username'] = member.username
template_values['member_email'] = member.email
# Verification: password
password_error = 0
password_update = False
password_error_messages = [
'', '新密码长度不能超过 32 个字符', '请输入当前密码', '当前密码不正确'
]
password_new = self.request.get('password_new').strip()
if (len(password_new) > 0):
password_update = True
if (len(password_new) > 32):
password_error = 1
else:
password_current = self.request.get(
'password_current').strip()
if (len(password_current) == 0):
password_error = 2
else:
password_current_sha1 = hashlib.sha1(
password_current).hexdigest()
if (password_current_sha1 != member.password):
password_error = 3
template_values['password_error'] = password_error
template_values[
'password_error_message'] = password_error_messages[
password_error]
if ((password_error == 0) and (password_update == True)):
old_auth = member.auth
memcache.delete(old_auth)
member.password = hashlib.sha1(password_new).hexdigest()
member.auth = hashlib.sha1(
str(member.num) + ':' + member.password).hexdigest()
member.put()
memcache.set(member.auth, member.num, 86400 * 14)
memcache.set('Member_' + str(member.num), member, 86400 * 14)
self.session['message'] = '密码已成功更新，下次请用新密码登录'
self.response.headers[
'Set-Cookie'] = 'auth=' + member.auth + '; expires=' + (
datetime.datetime.now() + datetime.timedelta(days=365)
).strftime("%a, %d-%b-%Y %H:%M:%S GMT") + '; path=/'
self.redirect('/settings')
else:
if browser['ios']:
path = os.path.join(os.path.dirname(__file__), 'tpl',
'mobile',
'member_settings_password.html')
else:
path = os.path.join(os.path.dirname(__file__), 'tpl',
'desktop',
'member_settings_password.html')
output = template.render(path, template_values)
self.response.out.write(output)
else:
self.redirect('/signin')
def incr(self, value=1):
if value < 0:
raise ValueError('CachedCounter cannot handle negative numbers.')
def update_count(name, incr, error_possible=False):
entity = Counter.get_by_key_name(name)
if entity:
entity.count += incr
logging.debug(
"incr(%s): update_count on retrieved entity by %d to %d",
name, incr, entity.count)
else:
entity = Counter(key_name=name, count=incr)
logging.debug("incr(%s): update_count on new entity set to %d",
name, incr)
if error_possible:
entity.error_possible = True
entity.put()
return entity.count
look_ahead_time = 10 + self._update_interval
memcache_ops = CapabilitySet('memcache', methods=['add'])
memcache_down = not memcache_ops.is_enabled()
if memcache_down or memcache.add(
self._lock_key, None, time=self._update_interval):
# Update the datastore
incr = int(memcache.get(self._incr_key) or 0) + value
logging.debug("incr(%s): updating datastore with %d", self._name,
incr)
memcache.set(self._incr_key, 0)
try:
stored_count = db.run_in_transaction(update_count, self._name,
incr)
except:
memcache.set(self._incr_key, incr)
logging.error(
'Counter(%s): unable to update datastore counter.',
self._name)
raise
memcache.set(self._count_key, stored_count)
return stored_count
else:
incr = memcache.get(self._incr_key)
if incr is None:
# _incr_key in memcache should be set. If not, two possibilities:
# 1) memcache has failed between last datastore update.
# 2) this branch has executed before memcache set in update branch (unlikely)
stored_count = db.run_in_transaction(update_count,
self._name,
value,
error_possible=True)
memcache.set(self._count_key, stored_count)
memcache.set(self._incr_key, 0)
logging.error(
'Counter(%s): possible memcache failure in update interval.',
self._name)
return stored_count
else:
memcache.incr(self._incr_key, delta=value)
logging.debug("incr(%s): incrementing memcache with %d",
self._name, value)
return self.count
def post(self):
self.session = Session()
site = GetSite()
browser = detect(self.request)
template_values = {}
template_values['site'] = site
template_values['system_version'] = SYSTEM_VERSION
errors = 0
member = CheckAuth(self)
l10n = GetMessages(self, member, site)
template_values['l10n'] = l10n
template_values[
'page_title'] = site.title + u' › ' + l10n.settings.decode('utf-8')
if (member):
template_values['member'] = member
template_values['member_username'] = member.username
template_values['member_email'] = member.email
template_values['member_website'] = member.website
template_values['member_twitter'] = member.twitter
# Verification: password
password_error = 0
password_update = False
password_error_messages = [
'', '新密码长度不能超过 32 个字符', '请输入当前密码', '当前密码不正确'
]
password_new = self.request.get('password_new').strip()
if (len(password_new) > 0):
password_update = True
if (len(password_new) > 32):
password_error = 1
else:
password_current = self.request.get(
'password_current').strip()
if (len(password_current) == 0):
password = 2
else:
password_current_sha1 = hashlib.sha1(
password_current).hexdigest()
if (password_current_sha1 != member.password):
password_error = 3
template_values['password_error'] = password_error
template_values[
'password_error_message'] = password_error_messages[
password_error]
if ((password_error == 0) and (password_update == True)):
member.password = hashlib.sha1(password_new).hexdigest()
member.auth = hashlib.sha1(
str(member.num) + ':' + member.password).hexdigest()
member.put()
self.response.headers[
'Set-Cookie'] = 'auth=' + member.auth + '; expires=' + (
datetime.datetime.now() + datetime.timedelta(days=365)
).strftime("%a, %d-%b-%Y %H:%M:%S GMT") + '; path=/'
self.redirect('/settings')
# Verification: email
member_email_error = 0
member_email_error_messages = [
'', u'请输入你的电子邮件地址', u'电子邮件地址长度不能超过 32 个字符', u'你输入的电子邮件地址不符合规则',
u'抱歉这个电子邮件地址已经有人注册过了'
]
member_email = self.request.get('email').strip()
if (len(member_email) == 0):
errors = errors + 1
member_email_error = 1
else:
if (len(member_email) > 32):
errors = errors + 1
member_email_error = 2
else:
p = re.compile(
r"(?:^|\s)[-a-z0-9_.+]+@(?:[-a-z0-9]+\.)+[a-z]{2,6}(?:\s|$)",
re.IGNORECASE)
if (p.search(member_email)):
q = db.GqlQuery(
'SELECT * FROM Member WHERE email = :1 AND num != :2',
member_email.lower(), member.num)
if (q.count() > 0):
errors = errors + 1
member_email_error = 4
else:
errors = errors + 1
member_email_error = 3
template_values['member_email'] = member_email
template_values['member_email_error'] = member_email_error
template_values[
'member_email_error_message'] = member_email_error_messages[
member_email_error]
# Verification: website
member_website_error = 0
member_website_error_messages = [
'', u'个人网站地址长度不能超过 200 个字符', u'这个网站地址不符合规则'
]
member_website = self.request.get('website').strip()
if (len(member_website) == 0):
member_website = ''
else:
if (len(member_website) > 200):
errors = errors + 1
member_website_error = 1
else:
p = re.compile(
'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
)
if (p.search(member_website)):
errors = errors
else:
errors = errors + 1
member_website_error = 2
template_values['member_website'] = member_website
template_values['member_website_error'] = member_website_error
template_values[
'member_website_error_message'] = member_website_error_messages[
member_website_error]
# Verification: Twitter
member_twitter_error = 0
member_twitter_error_messages = [
'', u'Twitter 用户名长度不能超过 20 个字符', u'Twitter 用户名不符合规则'
]
member_twitter = self.request.get('twitter').strip()
if (len(member_twitter) == 0):
member_twitter = ''
else:
if (len(member_twitter) > 20):
errors = errors + 1
member_twitter_error = 1
else:
p = re.compile('[a-zA-Z0-9\_]+')
if (p.search(member_twitter)):
errors = errors
else:
errors = errors + 1
member_twitter_error = 2
template_values['member_twitter'] = member_twitter
template_values['member_twitter_error'] = member_twitter_error
template_values[
'member_twitter_error_message'] = member_twitter_error_messages[
member_twitter_error]
# Verification: psn
member_psn_error = 0
member_psn_error_messages = [
'', u'PSN ID 长度不能超过 20 个字符', u'PSN ID 不符合规则'
]
member_psn = self.request.get('psn').strip()
if (len(member_psn) == 0):
member_psn = ''
else:
if (len(member_psn) > 20):
errors = errors + 1
member_psn_error = 1
else:
p = re.compile('^[a-zA-Z0-9\-\_]+$')
if (p.search(member_psn)):
errors = errors
else:
errors = errors + 1
member_psn_error = 2
template_values['member_psn'] = member_psn
template_values['member_psn_error'] = member_psn_error
template_values[
'member_psn_error_message'] = member_psn_error_messages[
member_psn_error]
# Verification: my_home
member_my_home_error = 0
member_my_home_error_messages = [
'', u'不是一个合法的自定义首页跳转位置', u'自定义首页跳转位置长度不能超过 32 个字符',
u'自定义首页跳转位置必须以 / 开头'
]
member_my_home = self.request.get('my_home').strip()
if len(member_my_home) > 0:
if member_my_home == '/' or member_my_home.startswith(
'/signout'):
member_my_home_error = 1
errors = errors + 1
else:
if len(member_my_home) > 32:
member_my_home_error = 2
errors = errors + 1
else:
if member_my_home.startswith('/') is not True:
member_my_home_error = 3
errors = errors + 1
template_values['member_my_home'] = member_my_home
template_values['member_my_home_error'] = member_my_home_error
template_values[
'member_my_home_error_message'] = member_my_home_error_messages[
member_my_home_error]
# Verification: btc
member_btc_error = 0
member_btc_error_messages = [
'', u'BTC 收款地址长度不能超过 40 个字符', u'BTC 收款地址不符合规则'
]
member_btc = self.request.get('btc').strip()
if (len(member_btc) == 0):
member_btc = ''
else:
if (len(member_btc) > 40):
errors = errors + 1
member_btc_error = 1
else:
p = re.compile('^[a-zA-Z0-9]+$')
if (p.search(member_btc)):
errors = errors
else:
errors = errors + 1
member_btc_error = 2
template_values['member_btc'] = member_btc
template_values['member_btc_error'] = member_btc_error
template_values[
'member_btc_error_message'] = member_btc_error_messages[
member_btc_error]
# Verification: github
member_github_error = 0
member_github_error_messages = [
'', u'GitHub 用户名长度不能超过 40 个字符', u'GitHub 用户名不符合规则'
]
member_github = self.request.get('github').strip()
if (len(member_github) == 0):
member_github = ''
else:
if (len(member_github) > 40):
errors = errors + 1
member_github_error = 1
else:
p = re.compile('^[a-zA-Z0-9\_]+$')
if (p.search(member_github)):
errors = errors
else:
errors = errors + 1
member_github_error = 2
template_values['member_github'] = member_github
template_values['member_github_error'] = member_github_error
template_values[
'member_github_error_message'] = member_github_error_messages[
member_github_error]
# Verification: location
member_location_error = 0
member_location_error_messages = ['', u'所在地长度不能超过 40 个字符']
member_location = self.request.get('location').strip()
if (len(member_location) == 0):
member_location = ''
else:
if (len(member_location) > 40):
errors = errors + 1
member_location_error = 1
template_values['member_location'] = member_location
template_values['member_location_error'] = member_location_error
template_values[
'member_location_error_message'] = member_location_error_messages[
member_location_error]
# Verification: tagline
member_tagline_error = 0
member_tagline_error_messages = ['', u'个人签名长度不能超过 70 个字符']
member_tagline = self.request.get('tagline').strip()
if (len(member_tagline) == 0):
member_tagline = ''
else:
if (len(member_tagline) > 70):
errors = errors + 1
member_tagline_error = 1
template_values['member_tagline'] = member_tagline
template_values['member_tagline_error'] = member_tagline_error
template_values[
'member_tagline_error_message'] = member_tagline_error_messages[
member_tagline_error]
# Verification: bio
member_bio_error = 0
member_bio_error_messages = ['', u'个人简介长度不能超过 2000 个字符']
member_bio = self.request.get('bio').strip()
if (len(member_bio) == 0):
member_bio = ''
else:
if (len(member_bio) > 2000):
errors = errors + 1
member_bio_error = 1
template_values['member_bio'] = member_bio
template_values['member_bio_error'] = member_bio_error
template_values[
'member_bio_error_message'] = member_bio_error_messages[
member_bio_error]
# Verification: show_home_top and show_quick_post
try:
member_show_home_top = int(self.request.get('show_home_top'))
except:
member_show_home_top = 1
try:
member_show_quick_post = int(
self.request.get('show_quick_post'))
except:
member_show_quick_post = 0
if member_show_home_top not in [0, 1]:
member_show_home_top = 1
if member_show_quick_post not in [0, 1]:
member_show_quick_post = 0
# Verification: l10n
member_l10n = self.request.get('l10n').strip()
supported = GetSupportedLanguages()
if member_l10n == '':
member_l10n = site.l10n
else:
if member_l10n not in supported:
member_l10n = site.l10n
s = GetLanguageSelect(member_l10n)
template_values['s'] = s
template_values['member_l10n'] = member_l10n
# Verification: twitter_sync
if member.twitter_oauth == 1:
member_twitter_sync = self.request.get('twitter_sync')
if member_twitter_sync == 'on':
member_twitter_sync = 1
else:
member_twitter_sync = 0
template_values['member_twitter_sync'] = member_twitter_sync
# Verification: use_my_css
member_use_my_css = self.request.get('use_my_css')
if member_use_my_css == 'on':
member_use_my_css = 1
else:
member_use_my_css = 0
template_values['member_use_my_css'] = member_use_my_css
# Verification: my_css
member_my_css_error = 0
member_my_css_error_messages = [
'', u'CSS Hack cannot be longer than 2000 characters'
]
member_my_css = self.request.get('my_css').strip()
if (len(member_my_css) == 0):
member_my_css = ''
else:
if (len(member_my_css) > 2000):
errors = errors + 1
member_my_css_error = 1
template_values['member_my_css'] = member_my_css
template_values['member_my_css_error'] = member_my_css_error
template_values[
'member_my_css_error_message'] = member_my_css_error_messages[
member_my_css_error]
template_values['errors'] = errors
if (errors == 0):
member.email = member_email.lower()
member.website = member_website
member.twitter = member_twitter
member.psn = member_psn
member.btc = member_btc
member.github = member_github
member.location = member_location
member.tagline = member_tagline
if member.twitter_oauth == 1:
member.twitter_sync = member_twitter_sync
member.use_my_css = member_use_my_css
member.my_css = member_my_css
if member_my_home_error == 0 and len(member_my_home) > 0:
member.my_home = member_my_home
else:
if member_my_home_error == 0:
member.my_home = None
member.bio = member_bio
member.show_home_top = member_show_home_top
member.show_quick_post = member_show_quick_post
member.l10n = member_l10n
member.put()
memcache.delete('Member::' + str(member.username))
memcache.delete('Member::' + str(member.username_lower))
memcache.set('Member_' + str(member.num), member, 86400)
self.session['message'] = '个人设置成功更新'
self.redirect('/settings')
else:
if browser['ios']:
path = os.path.join(os.path.dirname(__file__), 'tpl',
'mobile', 'member_settings.html')
else:
path = os.path.join(os.path.dirname(__file__), 'tpl',
'desktop', 'member_settings.html')
output = template.render(path, template_values)
self.response.out.write(output)
else:
self.redirect('/signin')
def testSet(self): """Tests set with a good key.""" self.assertTrue(memcache.set(self.key1, self.value1)) self.assertTrue(memcache.set(self.key2, self.value2)) self.assertEqual(self.value1, memcache.get(self.key1)) self.assertEqual(self.value2, memcache.get(self.key2))
def updateCache (self):
"""
Puts data in memcache.
"""
memcache.set (key = MyFXCommunitySample.last_data_key, value = pickle.dumps (self.data))
def testUnicodeValue(self): """Tests when a value is a unicode string with set() and get().""" self.assertTrue(memcache.set(self.key1, u'the valu\xe9')) self.assertEqual(u'the valu\xe9', memcache.get(self.key1))
def _get_examples():
examples = memcache.get('legacy_examples')
if examples is None:
examples = os.listdir(EXAMPLES_DIR)
memcache.set('legacy_examples', examples)
return examples
def testDecrementBadValue(self):
"""Tests decrementing a value that can't be interpreted as an integer."""
self.assertTrue(memcache.set(self.key1, 'some data'))
self.assertEqual(None, memcache.decr(self.key1))
self.assertEqual('some data', memcache.get(self.key1))
def testPickledValue(self): """Tests when a value is a pickled object with set() and get().""" self.assertTrue(memcache.set(self.key1, 1234)) self.assertEqual(1234, memcache.get(self.key1))
def testDecrementByDelta(self):
"""Tests decrementing a key by a delta."""
self.assertTrue(memcache.set(self.key1, '11'))
self.assertEqual(1, memcache.decr(self.key1, delta=10))
self.assertEqual('1', memcache.get(self.key1))
def testDecrementANegativeInteger(self): """Tests that decrementing a negative value fails.""" self.assertTrue(memcache.set(self.key1, -5)) self.assertEqual(None, memcache.decr(self.key1)) self.assertEqual(-5, memcache.get(self.key1))
def testIncrementAnIntegerPromotedToLong(self): """Tests that incrementing a int into a long works.""" self.assertTrue(memcache.set(self.key1, 2147483647)) self.assertEqual(2147483647, memcache.get(self.key1)) self.assertEqual(long(2147483648), memcache.incr(self.key1)) self.assertEqual(long(2147483648), memcache.get(self.key1))
def testDecrementCap(self):
"""Tests that decrements are capped at 0."""
self.assertTrue(memcache.set(self.key1, '5'))
self.assertEqual(0, memcache.decr(self.key1, delta=10))
self.assertEqual('0', memcache.get(self.key1))
def testIncrementALong(self): """Tests that incrementing a long works.""" self.assertTrue(memcache.set(self.key1, long(99))) self.assertEqual(long(100), memcache.incr(self.key1)) self.assertEqual(long(100), memcache.get(self.key1))
def testDecrementByOne(self):
"""Tests decrementing a key by one."""
self.assertTrue(memcache.set(self.key1, '10'))
self.assertEqual(9, memcache.decr(self.key1))
self.assertEqual('9', memcache.get(self.key1))
