def comments_add(self, request):
if request.apikey:
self.apikey_model = ApiKeys.get_apikey_by_id(request.apikey)
if self.apikey_model is None:
return CommentsAddResponse(message="the API key provided is no longer valid")
else:
new_comment = Comments()
self.user_model = User.get_user_by_id(self.apikey_model.user_id)
self.model_current_posts = Connection.get_connections_by_user_id_status(self.user_model.key)
new_comment.user_name = self.user_model.username
new_comment.user_key = self.user_model.key
self.apikey_model.total_calls += 1
self.apikey_model.put()
else:
return ConnectionAddResponse(message="you must provide an API key")
self.header_dict = self.parse_header(self.request_state.headers._headers)
# if len(Connection.get_connection_by_title(request.title)) > 0:
# return CommentsAddResponse(message="title already exists %s" % request.title)
if request.personthing_id:
self.personthing_model = PeopleThing.get_person_by_id(request.personthing_id)
new_comment.personthing_key = self.personthing_model.key
new_comment.personthing_name = self.personthing_model.name
if request.user_id:
self.user_model = User.get_user_by_id(request.user_id)
new_comment.user_key = self.user_model.key
new_comment.user_name = self.user_model.name
if request.connection_id:
try:
self.connection_model = Connection.get_connection_by_id(request.connection_id)
new_comment.connection_key = self.connection_model.key
new_comment.connection_title = self.connection_model.title
except:
return CommentsAddResponse(message="Connection ID not valid: %s" % request.connection_id)
if request.media:
new_comment.media = request.media
new_comment.post_type = request.post_type
new_comment.title = request.title
new_comment.tags = request.tags
new_comment.body = request.body
new_comment.uastring = self.header_dict['user-agent']
new_comment.ip = self.request_state.remote_address
new_blog_key = new_comment.put()
return CommentsAddResponse(message="successfully added comment", comment_id = new_blog_key.id())
def comments_list(self, request):
filter_dict = {}
self.curs = Cursor(urlsafe=request.cursor)
#If the user does not specify the limit of results, use 20
if not request.limit:
request.limit = 20
if request.created:
filter_dict['created'] = request.created
if request.updated:
filter_dict['updated'] = request.updated
if request.tags:
filter_dict['tags'] = request.connection_stage
if request.title:
filter_dict['title'] = request.title
if request.user_id:
filter_dict['user_key'] = User.get_user_by_id(request.user_id).key
if request.personthing_id:
filter_dict['personthing_key'] = PeopleThing.get_person_by_id(request.personthing_id).key
if request.connection_id:
filter_dict['connection_key'] = Connection.get_connection_by_id(request.connection_id).key
self.all_comments, next_curs, more_results = Comments.get_comments(self.curs, request.limit, filter_dict)
comments = [comment.to_comment_message() for comment in self.all_comments]
if more_results is True:
self.cursor=next_curs.urlsafe()
else:
self.cursor="No More Results"
return CommentsListResponse(comments=comments, cursor = self.cursor, num_of_results = len(self.all_comments))
def connection_update(self, request):
# Create New Connection DB Instance
self.header_dict = self.parse_header(self.request_state.headers._headers)
if request.apikey:
self.apikey_model = ApiKeys.get_apikey_by_id(request.apikey)
if self.apikey_model is None:
return ConnectionUpdateResponse(message="the API key provided is no longer valid")
else:
self.update_connection_model = Connection.get_connection_by_id(request.connection_id)
self.user_model = User.get_user_by_id(self.apikey_model.user_id)
self.update_connection_model.user_name = self.user_model.name
self.update_connection_model.user_key = self.user_model.key
self.apikey_model.total_calls += 1
self.apikey_model.put()
else:
return ConnectionAddResponse(message="you must provide an API key")
if self.update_connection_model is None:
return ConnectionUpdateResponse(message="ID not found: %s" % request.connection_id)
if request.personthing_id:
request.personthing_name = self.personthing_model.name
self.update_connection_model.personthing_key = self.personthing_model.key
if request.media:
self.update_connection_model.media = request.media
if request.type is not None:
self.update_connection_model.type = request.type
if request.title is not None:
self.update_connection_model.title = request.title
if request.summary is not None:
self.update_connection_model.summary = request.summary
if request.body is not None:
self.update_connection_model.body = request.body
if request.primary_media is not None:
self.update_connection_model.primary_media = request.primary_media
if request.connection_stage is not None:
self.update_connection_model.connection_stage = request.connection_stage
if request.personthing_name is not None:
self.update_connection_model.personthing_name = request.personthing_name
if request.request_reason is not None:
self.update_connection_model.request_reason = request.request_reason
if request.private_location is not None:
self.update_connection_model.private_loc = request.private_location
if request.personalized_message is not None:
self.update_connection_model.personalized_message = request.personalized_message
self.update_connection_model.uastring = self.header_dict['user-agent']
self.update_connection_model.ip = self.request_state.remote_address
update_connection_key = self.update_connection_model.put()
return ConnectionUpdateResponse(message="successfully updated connection", update_connection_id = update_connection_key.id())
def search_add(self, request):
# Create New Connection DB Instance
self.header_dict = self.parse_header(self.request_state.headers._headers)
index = search.Index(name="alcindex_01")
try:
self.user_key = User.get_user_by_id(request.user_id)
except:
return SearchAddResponse(message="user_id is a required field")
search_document_dictionary = {}
if request.user_id:
self.user_model = User.get_user_by_id(request.user_id)
if self.user_model is not None:
search_document_dictionary['user_name'] = self.user_model.name
else:
return SearchAddResponse(message="provided user id did not match")
else:
search_document_dictionary['user_name'] = None
if request.personthing_id:
self.personthing_model = PeopleThing.get_person_by_id(request.personthing_id)
search_document_dictionary['personthing_name'] = self.personthing_model.name
else:
search_document_dictionary['personthing_name'] = None
search_document_dictionary['type'] = request.type
search_document_dictionary['title'] = request.title
search_document_dictionary['blog_title'] = request.blog_title
search_document_dictionary['summary'] = request.summary
search_document_dictionary['tags'] = request.tags
search_document_dictionary['latitude'] = request.latitude
search_document_dictionary['longitude'] = request.longitude
search_document_dictionary['body'] = request.body
new_search_doc_id = self.search_doc_create(search_document_dictionary, index)
return SearchAddResponse(message="successfully added connection", new_search_id = new_search_doc_id[0].id)
def connection_add(self, request):
# Create New Connection DB Instance
index = search.Index(name="alcindex_01")
self.header_dict = self.parse_header(self.request_state.headers._headers)
new_connection = Connection()
search_document_dictionary = {}
search_document_dictionary['title'] = None
search_document_dictionary['loc_name'] = None
search_document_dictionary['personthing_name'] = None
search_document_dictionary['user_name'] = None
search_document_dictionary['blog_title'] = None
search_document_dictionary['type'] = None
search_document_dictionary['latitude'] = None
search_document_dictionary['longitude'] = None
search_document_dictionary['body'] = None
search_document_dictionary['summary'] = None
search_document_dictionary['tags'] = None
if request.apikey:
self.apikey_model = ApiKeys.get_apikey_by_id(request.apikey)
if self.apikey_model is None:
return ConnectionAddResponse(message="the API key provided is no longer valid")
else:
self.user_model = User.get_user_by_id(self.apikey_model.user_id)
self.model_current_posts = Connection.get_connections_by_user_id_status(self.user_model.key)
new_connection.user_name = self.user_model.username
new_connection.user_key = self.user_model.key
self.apikey_model.total_calls += 1
self.apikey_model.put()
search_document_dictionary['user_name'] = self.user_model.name
else:
return ConnectionAddResponse(message="you must provide an API key")
if self.model_current_posts and len(self.model_current_posts) > 4:
return ConnectionAddResponse(message="user can only have 5 pending requests: %s" % request.apikey)
# if len(Connection.get_connection_by_title(request.title)) > 0:
# return ConnectionAddResponse(message="title already exists %s" % request.title)
if request.personthing_id:
self.personthing_model = PeopleThing.get_person_by_id(request.personthing_id)
new_connection.personthing_name = self.personthing_model.name
new_connection.personthing_key = self.personthing_model.key
search_document_dictionary['personthing_name'] = self.personthing_model.name
#If the API only provides a name, I will create a personthing
elif request.personthing_name:
new_personthing = PeopleThing()
new_personthing.name = request.personthing_name
new_connection.personthing_name = new_personthing.name
new_connection.personthing_key = new_personthing.put()
search_document_dictionary['personthing_name'] = new_personthing.name
if request.media:
new_connection.media = request.media
# Add the API object for the media
self.media_response_full = []
self.json_gen = self.iterload(request.media)
self.media_response = []
for media_item in self.json_gen['results']:
self.media_response.append(MediaJsonMessage(width = int(media_item['width']),
height = int(media_item['height']),
filetype = media_item['filetype'],
file_cat = media_item['file_cat'],
blob_key = images.get_serving_url(media_item['blobstore_key'])))
self.media_response_full.append(MediaJsonFinalResponse(media_item_message=self.media_response,
filename = self.json_gen['filename']))
new_connection.media_binary = self.media_response_full
if request.latitude and request.longitude:
#temporarily storing as lat, lng, and geopt because I am unsure of how to interact with it later
new_connection.latitude = request.latitude
new_connection.longitude = request.longitude
new_connection.loc_geopt = ndb.GeoPt(float(request.latitude), float(request.longitude))
new_connection.type = request.type
new_connection.title = request.title
new_connection.summary = request.summary
new_connection.primary_media = request.primary_media
new_connection.request_reason = request.request_reason
new_connection.private_loc = request.private_location
new_connection.personalized_message = request.personalized_message
new_connection.uastring = self.header_dict['user-agent']
new_connection.ip = self.request_state.remote_address
new_connection_key = new_connection.put()
search_document_dictionary['type'] = request.type
search_document_dictionary['title'] = request.title
search_document_dictionary['summary'] = request.summary
search_document_dictionary['latitude'] = request.latitude
search_document_dictionary['longitude'] = request.longitude
search_document_dictionary['connection_id'] = str(new_connection_key.id())
new_search_doc_id = self.search_doc_create(search_document_dictionary, index)
short = new_connection_key.get()
short_url = 'http://www.bealittlecloser.com/map?node_id=%s&lat=%s&lng=%s&zoom=15' % (new_connection_key.id(), request.latitude, request.longitude)
short.social_media_json = self.create_short_url(short_url)
short.put()
return ConnectionAddResponse(message="successfully added connection", new_connection_id = new_connection_key.id())
def connection_list(self, request):
filter_dict = {}
if request.apikey:
self.apikey_model = self.lookup_api_key(request.apikey)
if self.apikey_model is not None:
self.apikey_model.total_calls += 1
self.apikey_model.put()
self.user_id = self.apikey_model.user_id
self.user_key = User.get_user_by_id(self.user_id).key
filter_dict['user_key'] = self.user_key
self.curs = Cursor(urlsafe=request.cursor)
#If the user does not specify the limit of results, use 20
if not request.limit:
request.limit = 20
if request.created:
filter_dict['created'] = request.created
if request.updated:
filter_dict['updated'] = request.updated
if request.connection_stage:
filter_dict['connection_stage'] = request.connection_stage
if request.connection_type:
filter_dict['connection_type'] = request.connection_type
if request.loc_name:
if request.loc_name != "all":
filter_dict['loc_name'] = request.loc_name
if request.user_name:
filter_dict['user_name'] = request.user_name
if request.title:
filter_dict['title'] = request.title
if request.type:
filter_dict['type'] = request.type
if request.personthing_id:
filter_dict['personthing_key'] = PeopleThing.get_by_id(request.personthing_id).key
self.all_connections, next_curs, more_results = Connection.get_connections(self.curs, request.limit, filter_dict)
connects = []
for entity in self.all_connections:
if request.loc_name != "all":
self.connection_response = entity.to_message(entity.media_binary)
else:
self.connection_response = entity.to_message_no_media()
connects.append(self.connection_response)
if more_results is True:
self.cursor=next_curs.urlsafe()
else:
self.cursor="No More Results"
return ConnectionListResponse(connections=connects, cursor = self.cursor, num_of_results = len(self.all_connections))