def reverse_transform(req, data, datatype):
'''
Transform the PyAmf data to GAE data
'''
gae_obj = None
gae_klazz = utils.loadModuleType(req.metadata.name, datatype)
if ('id' in data):
key = data['id']
key_obj = db.Key.from_path(datatype, key)
gae_obj = db.Model.get(key_obj)
else:
key = utils.new_key()
if not gae_obj:
gae_obj = gae_klazz(key_name=key)
'''
em = metadataservice.find_entity_metadata(req, datatype)
for k in em.entity_property_metadatas(req):
if data.has_key(k.name) and data[k.name]:
'''
for k in data.keys():
val = data[k]
setattr(gae_obj, k, val)
return gae_obj
def reverse_transform(req, data, datatype):
'''
Transform the PyAmf data to GAE data
'''
gae_obj = None
gae_klazz = utils.loadModuleType(req.metadata.name, datatype)
if ('id' in data):
key = data['id']
key_obj = db.Key.from_path(datatype, key)
gae_obj = db.Model.get(key_obj)
else:
key = utils.new_key()
if not gae_obj:
gae_obj = gae_klazz(key_name = key)
'''
em = metadataservice.find_entity_metadata(req, datatype)
for k in em.entity_property_metadatas(req):
if data.has_key(k.name) and data[k.name]:
'''
for k in data.keys():
val = data[k]
setattr(gae_obj, k, val)
return gae_obj
def get(req, datakey, datatype):
'''
item lookup
'''
ret = None
#req.app.metadata.name
gae_klazz = utils.loadModuleType(req.metadata.name, datatype)
key_obj = db.Key.from_path(datatype, datakey)
data = gae_klazz.get(key_obj)
logging.info('getting data')
if data and hasattr(data, 'is_deleted') and data.is_deleted:
data = None
em = metadataservice.find_entity_metadata(req, datatype)
if not em:
logging.error('Invalid entity metadata type:%s' % (datatype))
return False
if em.public_columns:
res = DataService.filter_data(req, [data], em)
data = res[0]
return data
def save(req, entity, datatype):
# special logic for ensuring unique friends.
if datatype == 'Friends_User':
gae_klazz = utils.loadModuleType(req.metadata.name, "Friends_User")
q = gae_klazz.all()
q.filter('nick =', entity.nick)
friendUser = q.get()
if friendUser:
if friendUser.org == req.org.name and friendUser.owner == req.user.name:
logging.info('Found user:'******'peerId'):
friendUser.peerId = entity.peerId
if hasattr(entity, 'photo'):
friendUser.photo = entity.photo
if hasattr(entity, 'location'):
friendUser.location = entity.location
if hasattr(entity, 'approved'):
friendUser.approved = '1' if entity.approved == '1' else 0
entity = friendUser
else:
logging.info('User doesnt own this friend:' + entity.nick )
return entity
else:
logging.info('New friend to be saved:' + entity.nick)
entity.org = req.org.name
entity.owner = req.user.name
entity.updated = datetime.datetime.now()
entity.bookmark = utils.bookmark_for_kind(datatype, req.user.name, entity.updated)
entity.is_deleted = False
entity.put()
return entity
def get(req, datakey, datatype):
'''
item lookup
'''
ret = None
#req.app.metadata.name
gae_klazz = utils.loadModuleType(req.metadata.name, datatype)
key_obj = db.Key.from_path(datatype, datakey)
data = gae_klazz.get(key_obj)
logging.info('getting data')
if data and hasattr(data, 'is_deleted') and data.is_deleted:
data = None
em = metadataservice.find_entity_metadata(req, datatype)
if not em:
logging.error('Invalid entity metadata type:%s' % (datatype))
return False
if em.public_columns:
res = DataService.filter_data(req, [data], em)
data = res[0]
return data
def cron_push(app, datatype, max_count=10):
total_pushed = 0
gae_klazz = utils.loadModuleType(app, datatype)
devtok_query = datamodel.UserDevice.all()
devtoks = devtok_query.fetch(5)
for devtok in devtoks:
query = db.Query(gae_klazz)
now = datetime.datetime.utcnow()
#today = datetime.datetime(now.year, now.month, now.day)
query.filter('AlertTime >=', now)
query.filter('owner =', devtok.owner)
query.order('AlertTime')
items = query.fetch(max_count)
try:
#get 10 items and ensure that they already had
push_count = DataService.cron_push_items(items, devtok)
total_pushed += push_count
except Exception, e:
logging.error('Error sending notifications for: ' +
devtok.owner)
logging.error(traceback.format_exc())
def post(self):
message = xmpp.Message(self.request.POST)
to_address = message.to.split('@')[0]
from_email_address = message.sender.split('/')[0]
logging.info('xmpp searching for: ' + to_address + ' from ' +
from_email_address)
chat_message_sent = False
gae_klazz_user = utils.loadModuleType("Friends", "Friends_User")
uq = gae_klazz_user.all()
uq.filter('nick =', to_address)
friend = uq.get()
uq = gae_klazz_user.all()
uq.filter('emailAddress =', from_email_address)
sender = uq.get()
if friend and sender:
status_code = xmpp.send_message(friend.emailAddress, message.body)
chat_message_sent = (status_code != xmpp.NO_ERROR)
logging.info('XMPP send to:' + friend.emailAddress + ' = ' +
str(status_code))
if not chat_message_sent:
logging.info('Failed to send message')
gae_klazz_queue = utils.loadModuleType("Friends",
"Friends_Queue")
q = gae_klazz_queue(key_name=utils.new_key())
q.owner = sender.name
q.targetUser = to_address
q.comments = message.body
q.org = 'ParabayOrg'
q.isPrivate = False
q.itemType = 1
q.updated = datetime.datetime.now()
q.bookmark = utils.bookmark_for_kind('Friends_Queue',
sender.name, q.updated)
q.put()
message.reply(
"The user is currently offline. Your message will be delivered when the user is online."
)
else:
logging.info('Sent message')
else:
logging.info('invalid friend:' + to_address + ', ' +
from_email_address)
def cron_erase(app, datatype, max_count=50):
gae_klazz = utils.loadModuleType(app, datatype)
query = db.Query(gae_klazz, keys_only=True)
query.filter('StartDate <', datetime.datetime.now() - datetime.timedelta(days=1))
items = query.fetch(max_count)
db.delete(items)
return 0
def post(self):
token = None
ret = {}
ret['status'] = constants.STATUS_INVALID_PARAM
try:
app = get_request_value(self.request, 'app')
org = get_request_value(self.request, 'org')
friend = get_request_value(self.request, 'friend')
u = users.get_current_user()
if u:
user = securityservice.SecurityService.userid_to_user(
u.email())
if user:
token = securityservice.SecurityService.generate_user_token(
user)
else:
new_user = {}
new_user['name'] = u.email()
new_user['email'] = u.email()
new_user['password'] = utils.new_key()
user = securityservice.SecurityService.register_user(
new_user, app, org)
if user:
token = securityservice.SecurityService.generate_user_token(
user)
fd = {}
if friend and friend == '1':
gae_klazz = utils.loadModuleType('Friends', 'Friends_User')
query = gae_klazz.all()
query.filter('owner =', user.name)
query.filter('nick =', user.name)
friendUser = query.get()
if friendUser:
fd["nick"] = friendUser.nick
fd["age"] = friendUser.age
fd["gender"] = friendUser.gender
fd["description"] = friendUser.description
fd["photo"] = friendUser.photo
fd["location"] = friendUser.location
fd["approved"] = 1 if friendUser.approved == '1' else 0
ret['name'] = user.name
ret['email'] = user.email
ret['token'] = token
ret['friend'] = fd
ret['status'] = constants.STATUS_OK
#if u
except Exception, e:
ret['status'] = constants.STATUS_FATAL_ERROR
ret['error_message'] = str(e)
logging.error(traceback.format_exc())
def list(req, q, limit, offset=0, bookmark=None):
data_query = None
kind = None
if 'data_query' in q and q['data_query']:
data_query = metadataservice.find_data_query(req, q['data_query'])
kind = data_query.type_of
else:
kind = q['kind']
'''
em = metadataservice.find_entity_metadata(req, kind)
if not em:
logging.error('Invalid entity metadata type:%s' % (kind))
return None
'''
#req.app.metadata.name
gae_klazz = utils.loadModuleType(req.metadata.name, kind)
if 'fulltext_search' in q and q['fulltext_search']:
gq = gae_klazz.all().search(q.query)
elif data_query:
gq = DataService.build_data_query(gae_klazz, q, data_query)
else:
gq = DataService.build_query(gae_klazz, q)
#apply generic filters
gq = DataService.filter_query(req, gq)
if not ('include_deleted_items' in q and q['include_deleted_items']):
gq.filter('is_deleted =', False)
if bookmark is None:
data = gq.fetch(limit, offset)
result = {
'data': data,
'count': gq.count(),
'sync_token': datetime.datetime.now()
}
else:
nextBookmark = None
data = gq.fetch(limit + 1)
if len(data) == limit + 1:
#logging.info('More rows with bookmark=' + str(data[-1].bookmark))
nextBookmark = data[-1].bookmark
data = data[:limit]
else:
logging.info('No more rows')
if nextBookmark is None:
nextBookmark = ""
count = generalcounter.get_count(kind)
result = {'data': data, 'count': 0, 'sync_token': nextBookmark}
#logging.info("List request: result count = %d.", gq.count());
return result
def cron_erase(app, datatype, max_count=50):
gae_klazz = utils.loadModuleType(app, datatype)
query = db.Query(gae_klazz, keys_only=True)
query.filter('StartDate <',
datetime.datetime.now() - datetime.timedelta(days=1))
items = query.fetch(max_count)
db.delete(items)
return 0
def bulk_erase(req, datatype, id_list):
gae_klazz = utils.loadModuleType(req.metadata.name, datatype)
for id_value in id_list:
key_obj = db.Key.from_path(datatype, id_value)
data = gae_klazz.get(key_obj)
if data:
data.is_deleted = True
data.put()
return 0
def bulk_erase(req, datatype, id_list):
gae_klazz = utils.loadModuleType(req.metadata.name, datatype)
for id_value in id_list:
key_obj = db.Key.from_path(datatype, id_value)
data = gae_klazz.get(key_obj)
if data:
data.is_deleted = True
data.put()
return 0
def list(req, q, limit, offset=0, bookmark=None):
data_query = None
kind = None
if 'data_query' in q and q['data_query']:
data_query = metadataservice.find_data_query(req, q['data_query'])
kind = data_query.type_of
else:
kind = q['kind']
'''
em = metadataservice.find_entity_metadata(req, kind)
if not em:
logging.error('Invalid entity metadata type:%s' % (kind))
return None
'''
#req.app.metadata.name
gae_klazz = utils.loadModuleType(req.metadata.name, kind)
if 'fulltext_search' in q and q['fulltext_search']:
gq = gae_klazz.all().search(q.query)
elif data_query:
gq = DataService.build_data_query(gae_klazz, q, data_query)
else:
gq = DataService.build_query(gae_klazz, q)
#apply generic filters
gq = DataService.filter_query(req, gq)
if not ('include_deleted_items' in q and q['include_deleted_items']):
gq.filter('is_deleted =', False)
if bookmark is None:
data = gq.fetch(limit, offset)
result = {'data': data, 'count': gq.count(), 'sync_token': datetime.datetime.now()}
else:
nextBookmark = None
data = gq.fetch(limit+1)
if len(data) == limit+1:
#logging.info('More rows with bookmark=' + str(data[-1].bookmark))
nextBookmark = data[-1].bookmark
data = data[:limit]
else:
logging.info('No more rows')
if nextBookmark is None:
nextBookmark = ""
count = generalcounter.get_count(kind)
result = {'data': data, 'count': 0, 'sync_token': nextBookmark}
#logging.info("List request: result count = %d.", gq.count());
return result
def post(self):
message = xmpp.Message(self.request.POST)
to_address = message.to.split('@')[0]
from_email_address = message.sender.split('/')[0]
logging.info('xmpp searching for: ' + to_address + ' from ' + from_email_address )
chat_message_sent = False
gae_klazz_user = utils.loadModuleType("Friends", "Friends_User")
uq = gae_klazz_user.all()
uq.filter('nick =', to_address)
friend = uq.get()
uq = gae_klazz_user.all()
uq.filter('emailAddress =', from_email_address)
sender = uq.get()
if friend and sender:
status_code = xmpp.send_message(friend.emailAddress, message.body)
chat_message_sent = (status_code != xmpp.NO_ERROR)
logging.info('XMPP send to:' + friend.emailAddress + ' = ' + str(status_code))
if not chat_message_sent:
logging.info('Failed to send message')
gae_klazz_queue = utils.loadModuleType("Friends", "Friends_Queue")
q = gae_klazz_queue(key_name=utils.new_key())
q.owner = sender.name
q.targetUser = to_address
q.comments = message.body
q.org = 'ParabayOrg'
q.isPrivate = False
q.itemType = 1
q.updated = datetime.datetime.now()
q.bookmark = utils.bookmark_for_kind('Friends_Queue', sender.name, q.updated)
q.put()
message.reply("The user is currently offline. Your message will be delivered when the user is online.")
else:
logging.info('Sent message')
else:
logging.info('invalid friend:' + to_address + ', ' + from_email_address)
def post(self):
token=None
ret = {}
ret['status'] = constants.STATUS_INVALID_PARAM
try:
app = get_request_value(self.request, 'app')
org = get_request_value(self.request, 'org')
friend = get_request_value(self.request, 'friend')
u = users.get_current_user()
if u:
user = securityservice.SecurityService.userid_to_user(u.email())
if user:
token = securityservice.SecurityService.generate_user_token(user)
else:
new_user = {}
new_user['name'] = u.email()
new_user['email'] = u.email()
new_user['password'] = utils.new_key()
user = securityservice.SecurityService.register_user(new_user, app, org)
if user:
token = securityservice.SecurityService.generate_user_token(user)
fd = {}
if friend and friend == '1':
gae_klazz = utils.loadModuleType('Friends', 'Friends_User')
query = gae_klazz.all()
query.filter('owner =', user.name)
query.filter('nick =', user.name)
friendUser = query.get()
if friendUser:
fd["nick"] = friendUser.nick
fd["age"] = friendUser.age
fd["gender"] = friendUser.gender
fd["description"] = friendUser.description
fd["photo"] = friendUser.photo
fd["location"] = friendUser.location
fd["approved"] = 1 if friendUser.approved == '1' else 0
ret['name'] = user.name
ret['email'] = user.email
ret['token'] = token
ret['friend'] = fd
ret['status'] = constants.STATUS_OK
#if u
except Exception, e:
ret['status'] = constants.STATUS_FATAL_ERROR
ret['error_message'] = str(e)
logging.error(traceback.format_exc())
def delete(req, datakey, datatype):
key_obj = db.Key.from_path(datatype, datakey)
em = metadataservice.find_entity_metadata(req, datatype)
if not em:
logging.error('Invalid entity metadata type:%s' % (datatype))
return False
gae_klazz = utils.loadModuleType(em.metadata.name, em.name)
data = gae_klazz.get(key_obj)
if data and (data.org == req.org.name or data.owner == req.user.name):
data.is_deleted = True
data.put()
return True
return False
def lookup_entity_prefix(req, prefix, datatype, lookup_key):
'''
Foreign key lookup
'''
gae_klazz = utils.loadModuleType(req.app.metadata.name, datatype)
query = gae_klazz.all()
query.filter( lookup_key + ' >=', prefix)
query.filter( lookup_key + ' <=', prefix + 'z')
res = query.fetch(10)
result = []
for data in res:
item = { 'id' : str(data.key().name()), 'name' : getattr(data, lookup_key)}
result.append(item)
return result
def delete(req, datakey, datatype):
key_obj = db.Key.from_path(datatype, datakey)
em = metadataservice.find_entity_metadata(req, datatype)
if not em:
logging.error('Invalid entity metadata type:%s' % (datatype))
return False
gae_klazz = utils.loadModuleType(em.metadata.name, em.name)
data = gae_klazz.get(key_obj)
if data and (data.org == req.org.name or data.owner == req.user.name):
data.is_deleted = True
data.put()
return True
return False
def get(req, datakey, datatype):
'''
item lookup
'''
ret = None
#req.app.metadata.name
gae_klazz = utils.loadModuleType(req.metadata.name, datatype)
key_obj = db.Key.from_path(datatype, datakey)
data = gae_klazz.get(key_obj)
logging.info('getting data')
if data and hasattr(data, 'is_deleted') and data.is_deleted:
data = None
return data
def lookup_entity_prefix(req, prefix, datatype, lookup_key):
'''
Foreign key lookup
'''
gae_klazz = utils.loadModuleType(req.app.metadata.name, datatype)
query = gae_klazz.all()
query.filter(lookup_key + ' >=', prefix)
query.filter(lookup_key + ' <=', prefix + 'z')
res = query.fetch(10)
result = []
for data in res:
item = {
'id': str(data.key().name()),
'name': getattr(data, lookup_key)
}
result.append(item)
return result
def get(req, datakey, datatype):
'''
item lookup
'''
ret = None
#req.app.metadata.name
gae_klazz = utils.loadModuleType(req.metadata.name, datatype)
key_obj = db.Key.from_path(datatype, datakey)
data = gae_klazz.get(key_obj)
logging.info('getting data')
if data and hasattr(data, 'is_deleted') and data.is_deleted:
data = None
return data
def save(req, entity, datatype):
# special logic for ensuring unique friends.
if datatype == 'Friends_User':
gae_klazz = utils.loadModuleType(req.metadata.name, "Friends_User")
q = gae_klazz.all()
q.filter('nick =', entity.nick)
friendUser = q.get()
if friendUser:
if friendUser.org == req.org.name and friendUser.owner == req.user.name:
logging.info('Found user:'******'peerId'):
friendUser.peerId = entity.peerId
if hasattr(entity, 'photo'):
friendUser.photo = entity.photo
if hasattr(entity, 'location'):
friendUser.location = entity.location
if hasattr(entity, 'approved'):
friendUser.approved = '1' if entity.approved == '1' else 0
entity = friendUser
else:
logging.info('User doesnt own this friend:' + entity.nick)
return entity
else:
logging.info('New friend to be saved:' + entity.nick)
entity.org = req.org.name
entity.owner = req.user.name
entity.updated = datetime.datetime.now()
entity.bookmark = utils.bookmark_for_kind(datatype, req.user.name,
entity.updated)
entity.is_deleted = False
entity.put()
return entity
def cron_push(app, datatype, max_count=10):
total_pushed = 0
gae_klazz = utils.loadModuleType(app, datatype)
devtok_query = datamodel.UserDevice.all()
devtoks = devtok_query.fetch(5)
for devtok in devtoks:
query = db.Query(gae_klazz)
now = datetime.datetime.utcnow()
#today = datetime.datetime(now.year, now.month, now.day)
query.filter('AlertTime >=', now)
query.filter('owner =', devtok.owner)
query.order('AlertTime')
items = query.fetch(max_count)
try:
#get 10 items and ensure that they already had
push_count = DataService.cron_push_items(items, devtok)
total_pushed += push_count
except Exception, e:
logging.error('Error sending notifications for: ' + devtok.owner)
logging.error(traceback.format_exc())
def list(req, q, limit, offset=0, bookmark=None, cursor=None):
data_query = None
kind = None
if 'data_query' in q and q['data_query']:
data_query = metadataservice.find_data_query(req, q['data_query'])
kind = data_query.type_of
else:
kind = q['kind']
em = metadataservice.find_entity_metadata(req, kind)
if not em:
logging.error('Invalid entity metadata type:%s' % (kind))
return None
#req.app.metadata.name
gae_klazz = utils.loadModuleType(req.metadata.name, kind)
gq = gae_klazz.all()
# handle bookmark
if bookmark:
gq.filter("bookmark <", bookmark)
gq.order("-bookmark")
if 'fulltext_search' in q and q['fulltext_search']:
gq = gq.search(q.query)
elif data_query:
gq = DataService.build_data_query(gq, q, data_query)
else:
gq = DataService.build_query(gq, q)
#apply generic filters
if not em.public_columns:
gq = DataService.filter_query(req, gq)
if not ('include_deleted_items' in q and q['include_deleted_items']):
gq.filter('is_deleted =', False)
if bookmark is None:
logging.info('legacy query')
data = gq.fetch(limit + 1, offset)
nextBookmark = None
if len(data) == limit + 1:
nextBookmark = data[-1].bookmark
data = data[:limit]
if nextBookmark is None:
nextBookmark = ""
result = {
'data': data,
'count': gq.count(),
'sync_token': nextBookmark,
'cursor': gq.cursor()
}
elif cursor:
data = gq.with_cursor(cursor).fetch(limit)
result = {'data': data, 'count': 0, 'sync_token': gq.cursor()}
else:
nextBookmark = None
#logging.info('Data bookmark=' + bookmark)
data = gq.fetch(limit + 1)
if len(data) == limit + 1:
#logging.info('More rows with bookmark=' + str(data[-1].bookmark))
nextBookmark = data[-1].bookmark
#logging.info('Next Data bookmark=' + nextBookmark)
data = data[:limit]
#elif len(data) > 0:
# nextBookmark = "data[-1].bookmark"
if nextBookmark is None:
nextBookmark = ""
count = generalcounter.get_count(kind)
result = {'data': data, 'count': count, 'sync_token': nextBookmark}
#logging.info("List request: result count = %d.", gq.count());
if em.public_columns:
result['data'] = DataService.filter_data(req, result['data'], em)
return result
def list(req, q, limit, offset=0, bookmark=None, cursor=None):
data_query = None
kind = None
if 'data_query' in q and q['data_query']:
data_query = metadataservice.find_data_query(req, q['data_query'])
kind = data_query.type_of
else:
kind = q['kind']
em = metadataservice.find_entity_metadata(req, kind)
if not em:
logging.error('Invalid entity metadata type:%s' % (kind))
return None
#req.app.metadata.name
gae_klazz = utils.loadModuleType(req.metadata.name, kind)
gq = gae_klazz.all()
# handle bookmark
if bookmark:
gq.filter("bookmark <", bookmark)
gq.order("-bookmark")
if 'fulltext_search' in q and q['fulltext_search']:
gq = gq.search(q.query)
elif data_query:
gq = DataService.build_data_query(gq, q, data_query)
else:
gq = DataService.build_query(gq, q)
#apply generic filters
if not em.public_columns:
gq = DataService.filter_query(req, gq)
if not ('include_deleted_items' in q and q['include_deleted_items']):
gq.filter('is_deleted =', False)
if bookmark is None :
logging.info('legacy query')
data = gq.fetch(limit+1, offset)
nextBookmark = None
if len(data) == limit+1:
nextBookmark = data[-1].bookmark
data = data[:limit]
if nextBookmark is None:
nextBookmark = ""
result = {'data': data, 'count': gq.count(), 'sync_token': nextBookmark, 'cursor':gq.cursor()}
elif cursor:
data = gq.with_cursor(cursor).fetch(limit)
result = {'data': data, 'count': 0, 'sync_token': gq.cursor()}
else:
nextBookmark = None
#logging.info('Data bookmark=' + bookmark)
data = gq.fetch(limit+1)
if len(data) == limit+1:
#logging.info('More rows with bookmark=' + str(data[-1].bookmark))
nextBookmark = data[-1].bookmark
#logging.info('Next Data bookmark=' + nextBookmark)
data = data[:limit]
#elif len(data) > 0:
# nextBookmark = "data[-1].bookmark"
if nextBookmark is None:
nextBookmark = ""
count = generalcounter.get_count(kind)
result = {'data': data, 'count': count, 'sync_token': nextBookmark}
#logging.info("List request: result count = %d.", gq.count());
if em.public_columns:
result['data'] = DataService.filter_data(req, result['data'], em)
return result
