def get(request, time=None, lang=None):
#Validate the time that was provided to avoid spoofing.
if time is not None:
client_datetime = message_utils.get_struct_time(time)
current_time = datetime.utcnow()
time_diff = current_time - client_datetime
time_diff_in_hours = time_diff.total_seconds() / 3600
#No matter where you are in the world you should not have a time difference greater than 12 hours
if time_diff_in_hours > 12 or time_diff_in_hours < -12:
print('Time diff is {}'.format(time_diff_in_hours))
raise errors.ClientError('Invalid client time')
#This function will return UTC if no timestring is provided
client_time_as_number = message_utils.get_time_as_number(time)
response = message_utils.get_message_table().scan(
ProjectionExpression='message, priority, startTime, endTime',
FilterExpression=Attr('startTime').lte(client_time_as_number)
& Attr('endTime').gte(client_time_as_number))
data = []
for i in response['Items']:
conv = convert_table_entry(i)
data.append(conv)
return {"list": data}
def post(request, msg):
rand_uuid = uuid.uuid4()
unique_msg_id = rand_uuid.hex
message = msg.get('message')
if message is None:
raise errors.ClientError('Value message cannot be None')
if len(message.decode('utf8')) > message_utils.message_size_limit:
raise errors.ClientError(
'Maximum message size is {} UTF8 encoded characters'.format(
message_utils.message_size_limit))
priority = msg.get('priority', 0)
#If no start time specified set it to the min to deactivate filtering based on start
start_time = msg.get('startTime', message_utils.custom_datetime_min)
#If no start time specified set it to the max to deactivate filtering based on end
end_time = msg.get('endTime', message_utils.custom_datetime_max)
message_utils.validate_start_end_times(start_time, end_time)
start_time_as_number = message_utils.get_time_as_number(start_time)
end_time_as_number = message_utils.get_time_as_number(end_time)
message_utils.get_message_table().put_item(
Item={
'UniqueMsgID': unique_msg_id,
'message': message,
'priority': priority,
'startTime': start_time_as_number,
'endTime': end_time_as_number
})
# As opposed to the item that was added to the DB the return object uses the human readable time format
returnObj = {
'UniqueMsgID': unique_msg_id,
'message': message,
'priority': priority,
'startTime': start_time,
'endTime': end_time
}
return returnObj
def delete(request, msg_id):
try:
response = message_utils.get_message_table().delete_item(
Key={'UniqueMsgID': msg_id},
ConditionExpression='UniqueMsgID = :val',
ExpressionAttributeValues={":val": msg_id})
except ClientError as e:
#Our unique message ID was not found
if e.response['Error']['Code'] == 'ConditionalCheckFailedException':
raise errors.ClientError('Invalid message id: {}'.format(msg_id))
raise e
return 'MessageDeleted'
def put(request, msg_id, msg):
if msg_id is None:
raise errors.ClientError('Value msg_id cannot be None')
unique_msg_id = msg_id
message = msg.get('message')
if len(message.decode('utf8')) > message_utils.message_size_limit:
raise errors.ClientError(
'Maximum message size is {} UTF8 encoded characters'.format(
message_utils.message_size_limit))
priority = msg.get('priority', 0)
#If no start time specified set it to the min to deactivate filtering based on start
start_time = msg.get('startTime', message_utils.custom_datetime_min)
#If no end time specified set it to the max to deactivate filtering based on end
end_time = msg.get('endTime', message_utils.custom_datetime_max)
message_utils.validate_start_end_times(start_time, end_time)
try:
table = message_utils.get_message_table()
start_time_as_number = message_utils.get_time_as_number(start_time)
end_time_as_number = message_utils.get_time_as_number(end_time)
if message is not None:
table.update_item(
Key={'UniqueMsgID': unique_msg_id},
UpdateExpression=
'SET message = :val1, priority = :val2, startTime = :val3, endTime = :val4',
ConditionExpression='UniqueMsgID = :val',
ExpressionAttributeValues={
':val': unique_msg_id,
':val1': message,
':val2': priority,
':val3': start_time_as_number,
':val4': end_time_as_number
})
#Any value has a default so if you are doing a PUT if the Message is none then we want to leave it as is
#in other words for all the other fields in the table if you send a None they will get reset to the default
else:
table.update_item(
Key={'UniqueMsgID': unique_msg_id},
UpdateExpression=
'SET priority = :val1, startTime = :val2, endTime = :val3',
ConditionExpression='UniqueMsgID = :val',
ExpressionAttributeValues={
':val': unique_msg_id,
':val1': priority,
':val2': start_time_as_number,
':val3': end_time_as_number
})
except ClientError as e:
#Our unique message ID was not found
if e.response['Error']['Code'] == 'ConditionalCheckFailedException':
raise errors.ClientError(
'Invalid message id: {}'.format(unique_msg_id))
raise e
return 'MessageUpdated'
def get(request, index=None, count=None, filter=None):
start_index = 0
if index is not None:
start_index = index
page_size = 9999999
if count is not None:
page_size = count
end_index = start_index + page_size
print 'Start index : %d Page size : %d end index : %d' % (
start_index, page_size, end_index)
table = message_utils.get_message_table()
current_time = datetime.utcnow()
active_time_lower = message_utils.get_struct_time_as_number(current_time -
timedelta(
hours=12))
active_time_upper = message_utils.get_struct_time_as_number(current_time +
timedelta(
hours=12))
do_filter = False
lc_filter = filter.lower()
fe = ''
if lc_filter == 'active':
fe = Attr('endTime').gte(active_time_lower) & Attr('startTime').lte(
active_time_upper)
do_filter = True
elif lc_filter == 'expired':
fe = Attr('endTime').lt(active_time_lower)
do_filter = True
elif lc_filter == 'planned':
fe = Attr('startTime').gt(active_time_upper)
do_filter = True
else:
lc_filter = 'invalid'
if do_filter == True:
response = table.scan(FilterExpression=fe)
else:
response = table.scan()
data = []
current_index = 0
respLength = len(response['Items'])
print "Response length : %d" % respLength
#First test if there is something for us in this scan
if start_index < respLength:
for i in response['Items']:
if current_index >= start_index:
print "Appending index: %d" % current_index
conv = convert_table_entry(i)
data.append(conv)
current_index += 1
if current_index >= end_index:
return {"list": data}
#if not skip this whole loop and increment the current_index consequently
else:
current_index += len(response['Items'])
while 'LastEvaluatedKey' in response:
print "Looping"
if do_filter == True:
response = table.scan(
ExclusiveStartKey=response['LastEvaluatedKey'],
FilterExpression=fe)
else:
response = table.scan(
ExclusiveStartKey=response['LastEvaluatedKey'])
#First test if there is something for us in this scan
if start_index < current_index + len(response['Items']):
for i in response['Items']:
if current_index >= start_index:
print "Appending index: %d" % current_index
conv = convert_table_entry(i)
data.append(conv)
current_index += 1
if current_index >= end_index:
return {"list": data}
#if not skip this whole loop and increment the current_index consequently
else:
current_index += len(response)
return {"list": data}