def set_tf(self, term, doc_id, frequency):
"""
Set tf data for (term, doc_id) pair
:param term: term to set tf data for
:param doc_id: document to set tf data for
:param frequency: data to put in the hash for the (term, doc_id) pair
"""
key = self._tf_key(term)
term_data = RedisHash(key)
term_data.set(doc_id, frequency)
def get_tf(self, term, doc_id=None):
"""
Get term frequency data for term
:param term: term to get tf data for
:param doc_id: (optional) provide doc_id to only get tf data for the associated document
:return: dict containing tf_data
"""
key = self._tf_key(term)
if doc_id is None:
return RedisHash(key).to_dict()
return RedisHash(key).get(doc_id)
def create_user(self, email):
session_id = self.redis.get_value("usersession: {}".format(email))
user_data = RedisHash(email).to_dict()
if session_id and user_data:
return User(user_data['school'], email, user_data['displayName'],
session_id)
return None
def get_content(content_id):
"""
Get content data for content with given ID
:param content_id: ID of content
:return: dict containing content data
"""
return RedisHash(content_id).to_dict()
def content_exists(identifier):
"""
Checks if content with specified ID exists.
:param identifier: ID of content to check for
:return: boolean indicating if content exists or not
"""
return RedisHash(identifier).exists()
def delete(self, ip_address, key_to_delete):
"""
Removes (key, value) pair from IP address hash
:param ip_address: IP address of cached data
:param key_to_delete: key to delete
"""
ip_address_key = self._get_key_for(ip_address)
return RedisHash(ip_address_key).delete(key_to_delete)
def set(self, ip_address, data):
"""
Sets cached data for given IP address
:param ip_address: IP address to set cached data for
:param data: data to set in cache
"""
key = self._get_key_for(ip_address)
return RedisHash(key).update(data)
def get(self, ip_address):
"""
Returns cached data for IP address
:param ip_address: IP address to get cached data for
:return: dict containing cached data
"""
key = self._get_key_for(ip_address)
return RedisHash(key).to_dict()
def get_request(self, request_id):
"""
Retrieves request with ID request_id.
:param request_id: ID of request to find
:return: dict containing request data
"""
app.logger.debug("fetching request with id: {}".format(request_id))
request_data = RedisHash(request_id).to_dict()
app.logger.debug("request id {} has data {}".format(
request_id, request_data))
return request_data
def request_content(self, identifier, data):
"""
Creates new redis hash with specified data representing a user request to create content.
:param identifier: string identifier for hash in redis
:param data: request data
:return: string identifier if operation is successful, otherwise None
"""
user_manager.created_content(data["email"], identifier)
data.update({"requestType": self.type, "time": get_time()})
app.logger.debug("Storing {} in {}".format(data, identifier))
if RedisHash(identifier).update(data) is not None:
return identifier
def make_content(self, identifier, data):
"""
Creates new redis hash with specified data representing some type of user-created content.
:param identifier: string identifier for hash in redis
:param data: content data
:return: string identifier if operation is successful, otherwise None
"""
user_manager.created_content(data["email"], identifier)
data.update({"postType": self.type})
app.logger.debug("Storing {} in {}".format(data, identifier))
if RedisHash(identifier).update(data) is not None:
return identifier
def store_user_in_redis(self, email, password_hash, school, display_name):
self.emails.add(email)
self.displayNames.add(display_name)
user_data = {'school': school, 'displayName': display_name}
RedisHash(email).update(user_data)
self.redis.set("hash: {}".format(email), password_hash)