def item_status(self, orderid, itemid='ALL', username=None, filters=None):
user = User.by_username(username)
if not isinstance(filters, dict):
if filters is None:
filters = dict()
else:
raise TypeError('supplied filters invalid')
if orderid:
orders = Order.where({'orderid': orderid})
else:
orders = Order.where({'user_id': user.id})
search = dict()
if 'status' in filters:
search.update(status=(filters.get('status'), ))
if 'name' in filters:
search.update(name=(filters.get('name'), ))
elif itemid is not "ALL":
search.update(name=(itemid, ))
response = dict()
for order in orders:
response[order.orderid] = order.scenes(search)
return response
def cancel_order(self, orderid, request_ip_address):
"""
Cancels an order, and all scenes contained within it
:return:
"""
order = Order.where({'id': orderid})
if len(order) != 1:
raise OrderingProviderException('Order not found')
else:
order = order.pop()
logger.info('Received request to cancel {} from {}'.format(
orderid, request_ip_address))
killable_scene_states = ('submitted', 'oncache', 'onorder', 'queued',
'retry', 'error', 'unavailable', 'complete')
scenes = order.scenes(sql_dict={'status': killable_scene_states})
if len(scenes) > 0:
Scene.bulk_update([s.id for s in scenes], Scene.cancel_opts())
else:
logger.info('No scenes to cancel for order {}'.format(
orderid, request_ip_address))
order.status = 'cancelled'
order.save()
logger.info('Request to cancel {} from {} successful.'.format(
orderid, request_ip_address))
return order
def fetch_user_orders(self,
username='',
email='',
user_id='',
filters=None):
if filters and not isinstance(filters, dict):
raise OrderingProviderException('filters must be dict')
if username:
usearch = {'username': username}
elif email:
usearch = {'email': email}
elif user_id:
usearch = {'id': user_id}
user = User.where(usearch)
if len(user) != 1:
return list()
else:
user = user.pop()
if filters:
params = dict(filters)
params.update({'user_id': user.id})
else:
params = {'user_id': user.id}
resp = Order.where(params)
return resp
def check_open_scenes(self, order, user_id='', filters=None):
"""
Perform a check to determine if the new order plus current open scenes for the current user
is less than the maximum allowed open scene limit (currently 10,000).
"""
limit = config.configuration_keys['policy.open_scene_limit']
if filters and not isinstance(filters, dict):
raise OrderingProviderException('filters must be dict')
user_orders = Order.where({'user_id': user_id})
if len(user_orders) > 0:
scenes = Order.get_user_scenes(user_id=user_id, params=filters)
ids = sensor.SensorCONST.instances.keys()
# count number of scenes in the order
order_scenes = 0
for key in order:
if key in ids:
order_scenes += len(order[key]['inputs'])
if (len(scenes) + order_scenes) > int(limit):
diff = (len(scenes) + order_scenes) - int(limit)
msg = "Order will exceed open scene limit of {lim}, please reduce number of ordered scenes by {diff}"
raise OpenSceneLimitException(msg.format(lim=limit, diff=diff))
def test_get_scenes_for_new_user(self):
"""
Make sure that checking the number of open scenes for a new user
with no orders will not raise an exception
"""
mock = MockOrder()
user = MockUser()
user_id = user.add_testing_user()
user_id = user_id + random.randint(1, 200)
user_orders = Order.where({'user_id': user_id})
self.assertTrue(len(user_orders) == 0)
try:
ordering_provider.check_open_scenes(order=mock.base_order,
user_id=user_id,
filters={
'status':
('submitted', 'oncache',
'onorder', 'queued',
'processing')
})
except:
self.fail(
'ordering_provider.check_open_scenes() raised Exception for new user'
)
def send_all_initial(self):
'''Finds all the orders that have not had their initial emails sent and
sends them'''
orders = Order.where({'status': 'ordered'})
for o in orders:
if not o.initial_email_sent:
self.send_initial(o.orderid)
o.update('initial_email_sent', datetime.datetime.now())
return True
def send_all_initial(self):
'''Finds all the orders that have not had their initial emails sent and
sends them'''
orders = Order.where({'status': 'ordered'})
for o in orders:
if not o.initial_email_sent:
self.send_initial(o.orderid)
o.update('initial_email_sent', datetime.datetime.now())
return True
def active_hadoop_job_names(self):
order_ids = tuple([
o.id for o in Order.where({
'status': 'ordered',
'user_id': self.id
})
])
return [
s.job_name for s in Scene.where({
'status': ('processing', 'queued'),
'order_id': order_ids
})
]
def fetch_user_orders(self, uid, filters=None):
# deal with unicode uid
if isinstance(uid, basestring):
uid = str(uid)
try:
user = User.where({'username': uid}).pop()
except IndexError:
try:
user = User.where({'email': uid}).pop()
except IndexError:
return {'msg': 'sorry, no user matched {0}'.format(uid)}
if filters and not isinstance(filters, dict):
raise OrderingProviderException('filters param must be of type dict')
elif filters:
params = dict(filters)
params.update({'user_id': user.id})
else:
params = {'user_id': user.id}
return {'orders': [o.orderid for o in Order.where(params)]}
def fetch_order(self, ordernum):
orders = Order.where({'orderid': ordernum})
return orders
