def split_keys(self, arr, size):
arrs = []
num = 0
while len(arr) > size:
pice = arr[:size]
num += 1
id = 'page'+str(num)
logger.info("Search Key Id: %s " % id)
logger.debug("Search Keys: " + str(pice))
prev_data = self.get_search_page(id)
logger.debug('mc_prev_data: ' + str(prev_data))
del_data = mc_delete(cache_keys.get_search_page_cache_key(id))
logger.debug('mc_del_data: ' + str(del_data))
final_data = mc_wrap(cache_keys.get_search_page_cache_key(id), ENTITY_CACHE_EXPIRATION,
lambda x: pice)
logger.debug('mc_final_data: ' + str(final_data))
arrs.append(pice)
arr = arr[size:]
arrs.append(arr)
return arrs
def get_upcoming(self,
city_name=None,
sport=None,
locality_name=None,
no_records=8):
return mc_wrap(
cache_keys.get_upcoming_event_cache_key(city_name, sport),
ENTITY_CACHE_EXPIRATION, lambda x: self.eventDao.get_upcoming(
city_name, sport, locality_name, no_records))
def search_index_suggest(self, user_ip, status, **params):
logger.debug('Suggest Search Param Results: ' + str(params))
#locality = params['address.locality'] #TODO: Hardcoded for testing. To be made generic.
suggest_playgrounds = []
if status != 'all':
status_value = STATUS_DICT.get(status)
logger.debug('Status %d ' % (status_value))
query_str = 'status:'+str(status_value)
for key, value in params.items():
if key == 'latlong' and value is not None:
query_str += ' AND distance(latlong, geopoint('+str(value)+')) < 5000'
if '.' in key and value is not None:
struct, attr = key.split('.')
if struct == 'address':
if attr == 'locality':
query_str += ' NOT locality:'+str(value)
try:
index = search.Index(PLAYGROUND)
sortopts = search.SortOptions(expressions=[
search.SortExpression(expression='name', direction='ASCENDING')])
search_query = search.Query(
query_string=query_str,
options=search.QueryOptions(
limit=PAGE_SIZE,
sort_options=sortopts))
search_results = index.search(search_query)
#logger.debug('Suggest Search Result:' + str(search_results))
except search.Error:
logger.exception("NdbPlaygroundDao:: Search query failed for suggest playgrounds")
#Retrieve the doc_id from the search results and then use that to query the datastore to fetch the entity
keys = []
for doc in search_results:
keys.append(ndb.Key(Playground, long(doc.doc_id)))
#suggest_playgrounds = ndb.get_multi(keys)
#return suggest_playgrounds
cache_id = 'suggest_'+str(PLAYGROUND)+'_'+str(user_ip)
get_keys = mc_get(cache_keys.get_suggest_keys_cache_key(cache_id))
if get_keys is not None:
del_keys = mc_delete(cache_keys.get_suggest_keys_cache_key(cache_id))
add_keys = mc_wrap(cache_keys.get_suggest_keys_cache_key(cache_id), ENTITY_CACHE_EXPIRATION,
lambda x: keys)
logger.info('No of Suggest Playground Added to cache : %s' % len(add_keys))
return keys
def get_record(self, id):
playground = mc_wrap(cache_keys.get_playground_cache_key(id), ENTITY_CACHE_EXPIRATION,
lambda x: self.playgroundDao.get_record(id))
return playground
def get_record(self, id):
bulkdata = mc_wrap(cache_keys.get_bulkdata_cache_key(id),
ENTITY_CACHE_EXPIRATION,
lambda x: self.bulkdataDao.get_record(id))
return bulkdata
def get_record(self, id):
return mc_wrap(cache_keys.get_match_cache_key(id),
ENTITY_CACHE_EXPIRATION,
lambda x: self.matchDao.get_record(id))
def get_record(self, id):
register = mc_wrap(cache_keys.get_register_cache_key(id), ENTITY_CACHE_EXPIRATION,
lambda x: self.registerDao.get_record(id))
return register
def get_record(self, id):
profile = mc_wrap(cache_keys.get_user_cache_key(id),
ENTITY_CACHE_EXPIRATION,
lambda x: self.profileDao.get_record(id))
return profile
def get_recommend(self, locality=None, sport=None, no_records=8):
return mc_wrap(cache_keys.get_recommend_playground_cache_key(locality, sport), ENTITY_CACHE_EXPIRATION,
lambda x: self.playgroundDao.get_recommend(locality, sport, no_records))
def get_record(self, id):
event = mc_wrap(cache_keys.get_event_cache_key(id),
ENTITY_CACHE_EXPIRATION,
lambda x: self.eventDao.get_record(id))
return event
def get_child_events(self, entity_id, no_records=-1):
return mc_wrap(
cache_keys.get_event_children_cache_key(entity_id),
ENTITY_CACHE_EXPIRATION, lambda x: self.eventDao.get_child_events(
entity_id, 'desc', no_records))
def get_record(self, id):
business = mc_wrap(get_business_cache_key(id), ENTITY_CACHE_EXPIRATION,
lambda x: self.businessDao.get_record(id))
return business
def get_record(self, id):
childevent = mc_wrap(get_childevent_cache_key(id), ENTITY_CACHE_EXPIRATION,
lambda x: self.childeventDao.get_record(id))
return childevent
def get_record(self, id):
locality = mc_wrap(cache_keys.get_locality_cache_key(id),
ENTITY_CACHE_EXPIRATION,
lambda x: self.importDao.get_record(id))
return locality
def get_active(self, city_name=None, sport=None, no_records=4):
return mc_wrap(
cache_keys.get_active_event_cache_key(city_name, sport),
ENTITY_CACHE_EXPIRATION,
lambda x: self.eventDao.get_active(city_name, sport, no_records))
def get_active(self, city_name=None, sport=None, no_records=8):
return mc_wrap(cache_keys.get_active_playground_cache_key(city_name, sport), ENTITY_CACHE_EXPIRATION,
lambda x: self.playgroundDao.get_active(city_name, sport, no_records))
def get_record(self, id):
media = mc_wrap(cache_keys.get_media_cache_key(id),
ENTITY_CACHE_EXPIRATION,
lambda x: self.mediaDao.get_record(id))
return media
def get_suggest_keys(self, id):
logger.info('NdbPlaygroundDao:: DBHIT: get_suggest_keys for playground')
return mc_wrap(cache_keys.get_suggest_keys_cache_key(id), ENTITY_CACHE_EXPIRATION,
lambda x: None)
def get_localities(city_name):
return mc_wrap(cache_keys.get_localities_cache_key(city_name),
STATIC_CACHE_EXPIRATION,
lambda x: _get_localities_from_dao(city_name))
