def _parse_date_params(self, params):
"""Parse the date params from the request
:param MultiDict params: HTTP request arguments
"""
date_filter_param = (params.get('date_filter') or '').strip().lower()
try:
start_date = params.get('start_date')
if start_date:
str_to_date(params.get(
'start_date')) # validating if date can be parsed
except: # noqa
raise SuperdeskApiError.badRequestError(
'Invalid value for start date')
try:
end_date = params.get('end_date')
if end_date:
str_to_date(
params.get('end_date')) # validating if date can be parsed
except: # noqa
raise SuperdeskApiError.badRequestError(
'Invalid value for end date')
return date_filter_param, start_date, end_date
def try_cast(v):
try:
str_to_date(v) # try if it matches format
return arrow.get(v).datetime # return timezone aware time
except:
try:
return ObjectId(v)
except:
return v
def try_cast(v):
try:
str_to_date(v) # try if it matches format
return arrow.get(v).datetime # return timezone aware time
except:
try:
return ObjectId(v)
except:
return v
def try_cast(v):
# False and 0 are getting converted to datetime by arrow
if v is None or isinstance(v, bool) or v == 0:
return v
try:
str_to_date(v) # try if it matches format
return arrow.get(v).datetime # return timezone aware time
except Exception:
try:
return ObjectId(v)
except Exception:
return v
def try_cast(v):
"""Cast string value to date or ObjectId if possible.
:param v: string value
"""
try:
str_to_date(v) # try if it matches format
return arrow.get(v).datetime # return timezone aware time
except ValueError:
try:
return ObjectId(v)
except InvalidId:
return v
def try_cast(v):
# False and 0 are getting converted to datetime by arrow
if v is None or isinstance(v, bool) or v is 0:
return v
try:
str_to_date(v) # try if it matches format
return arrow.get(v).datetime # return timezone aware time
except:
try:
return ObjectId(v)
except:
return v
def assert_head(self, url):
h = self.test_client.head(url)
r = self.test_client.get(url)
self.assertTrue(not h.data)
if 'Expires' in r.headers:
# there's a tiny chance that the two expire values will differ by
# one second. See #316.
head_expire = str_to_date(r.headers.pop('Expires'))
get_expire = str_to_date(h.headers.pop('Expires'))
d = head_expire - get_expire
self.assertTrue(d.seconds in (0, 1))
self.assertEqual(r.headers, h.headers)
def producer_blogs_syndicate(producer_id, blog_id):
data = request.get_json(silent=True) or {}
consumer_blog_id = data.get('consumer_blog_id')
auto_publish = data.get('auto_publish')
auto_retrieve = data.get('auto_retrieve', True)
start_date = data.get('start_date')
if not consumer_blog_id:
return api_error('Missing "consumer_blog_id" in form data.', 422)
if start_date:
try:
start_date = str_to_date(start_date)
except ValueError:
return api_error('start_date is not valid.', 400)
if request.method == 'DELETE':
return _delete_producer_blogs_syndicate(producer_id, blog_id,
consumer_blog_id)
elif request.method == 'PATCH':
return _update_producer_blogs_syndicate(producer_id, blog_id,
consumer_blog_id,
auto_retrieve, start_date)
else:
return _create_producer_blogs_syndicate(producer_id, blog_id,
consumer_blog_id, auto_publish,
auto_retrieve, start_date)
def visit_Str(self, node):
""" Strings """
try:
value = str_to_date(node.s)
self.current_value = value if value is not None else node.s
except ValueError:
self.current_value = node.s
def visit_Str(self, node):
""" Strings """
try:
value = str_to_date(node.s)
self.current_value = value if value is not None else node.s
except ValueError:
self.current_value = node.s
def date_hook(json_data):
for key, value in json_data.items():
try:
json_data[key] = str_to_date(value)
except:
pass
return json_data
def parse_date(datetime):
"""Return datetime instance for datetime."""
if isinstance(datetime, str):
try:
return str_to_date(datetime)
except ValueError:
return arrow.get(datetime).datetime
return datetime
def test_parse_string_to_date(self):
expected_expression = \
sqla_op.gt(self.model._updated,
str_to_date('Sun, 06 Nov 1994 08:49:37 GMT'))
r = parse('_updated > "Sun, 06 Nov 1994 08:49:37 GMT"', self.model)
self.assertEqual(type(r), list)
self.assertTrue(len(r) == 1)
self.assertTrue(expected_expression.compare(r[0]))
def test_parse_string_to_date(self):
expected_expression = \
sqla_op.gt(self.model._updated,
str_to_date('Sun, 06 Nov 1994 08:49:37 GMT'))
r = parse('_updated > "Sun, 06 Nov 1994 08:49:37 GMT"', self.model)
self.assertEqual(type(r), list)
self.assertTrue(len(r) == 1)
self.assertTrue(expected_expression.compare(r[0]))
def range_date(query: ElasticRangeParams):
date = str_to_date(query.date)
return field_range(
ElasticRangeParams(field=query.field,
time_zone=query.time_zone,
value_format=query.value_format,
gte=date.strftime('%Y-%m-%d') + '||/d',
lt=(date + timedelta(days=1)).strftime('%Y-%m-%d') +
'||/d'))
def __init__(self, asset: Dict[str, Any], file: Response):
super().__init__()
self.write(file.content)
self.seek(0)
self.content_type = asset["mimetype"]
self.length = asset["length"]
self._name = asset["name"]
self.filename = asset["filename"]
self.upload_date = str_to_date(asset["_updated"])
self.md5 = asset["_etag"]
self._id = asset["_id"]
def process_where(where, in_date_value=False):
if not where:
return where
if isinstance(where, dict):
for k, v in where.iteritems():
where[k] = process_where(v, in_date_value or k == 'date_of_receipt')
elif isinstance(where, (list, tuple)):
return [process_where(x, in_date_value) for x in where]
elif in_date_value and isinstance(where, basestring):
try:
return str_to_date(where)
except ValueError:
return where
return where
def _test_default_values(self, app, cls, updated_name='updated',
created_name='created'):
# test updated and created fields if they are correctly generated
now = datetime.utcnow()
d = cls(a="xyz", b=29)
updated = getattr(d, updated_name)
created = getattr(d, created_name)
self.assertEqual(type(updated), datetime)
self.assertEqual(type(created), datetime)
self.assertDateTimeAlmostEqual(updated, now)
self.assertDateTimeAlmostEqual(created, now)
d.save()
# test real returned values
json_data = app.get('/simpledoc/').get_json()
created_attr = app.application.config['DATE_CREATED']
created_str = json_data[config.ITEMS][0][created_attr]
date_created = str_to_date(created_str)
self.assertDateTimeAlmostEqual(now, date_created)
d.delete()
def __init__(self,
field: str,
gt: str = None,
gte: str = None,
lt: str = None,
lte: str = None,
value_format: str = None,
time_zone: str = None,
start_of_week: int = None,
date_range: DATE_RANGE = None,
date: str = None):
"""Allows to easily set fields by name using kwargs"""
self.field = field
self.gt = gt
self.gte = gte
self.lt = lt
self.lte = lte
self.value_format = value_format
self.time_zone = time_zone if time_zone else get_timezone_offset(
app.config['DEFAULT_TIMEZONE'], utcnow())
self.start_of_week = int(start_of_week or 0)
self.date_range = date_range
self.date = str_to_date(date) if date else None
def test_str_to_date(self):
self.assertEqual(str_to_date(self.datestr), self.valid)
self.assertRaises(ValueError, str_to_date, 'not-a-date')
self.assertRaises(ValueError, str_to_date,
self.datestr.replace('GMT', 'UTC'))
def test_str_to_date(self):
self.assertEqual(str_to_date(self.datestr), self.valid)
self.assertRaises(ValueError, str_to_date, "not-a-date")
self.assertRaises(ValueError, str_to_date, self.datestr.replace("GMT", "UTC"))
def test_str_to_date(self):
self.assertEqual(str_to_date(self.datestr), self.valid)
self.assertRaises(ValueError, str_to_date, "not-a-date")
self.assertRaises(ValueError, str_to_date,
self.datestr.replace("GMT", "UTC"))
def approveExtensionRequest():
"""
Approve ```extensionRequest```
Accepts ```{_id: <extension request id>, reviewd_by: <reviewer user id>, status: <"APPROVED"/"REJECTED">}```
as request json argument
"""
response = {}
try:
# Get request parameters and perform sanity check
if not request.json:
raise ValueError("Empty json body provided!!!")
_id = request.json['_id'] if '_id' in request.json else None
reviewed_by = request.json[
'reviewed_by'] if 'reviewed_by' in request.json else None
status = request.json['status'] if 'status' in request.json else None
logger.debug("_id: " + str(_id) + " reviewed_by: " +
str(reviewed_by) + " status: " + str(status))
if not _id or not reviewed_by or not status in [
"APPROVED", "REJECTED"
]:
raise ValueError(
"Must provide extensionRequest id, reviewer id and approval status!!!"
)
# Get extension request
extensionRequests = app.data.driver.db['extensionRequests']
extension_query = {"_id": ObjectId(_id)}
extension_request = extensionRequests.find_one(extension_query,
sort=[("_created", -1)])
if not extension_request:
raise ValueError("Extension Request does not exist")
if extension_request['status'] not in ['REQUESTED']:
raise ValueError("Provision Request cannot be reviewed in " +
str(extension_request['status']) + " state")
# Get provision request
provisionRequests = app.data.driver.db['provisionRequests']
provision_query = {
"_id": ObjectId(extension_request['provision_request'])
}
provision_request = provisionRequests.find_one(provision_query,
sort=[("_created", -1)])
if not provision_request:
raise ValueError("Provision Request does not exist")
if provision_request['status'] not in [
'APPROVED', 'INITIATED', 'DEPLOYED', 'EXPIRED'
]:
raise ValueError(
"Provision Request cannot be extended in state: " +
str(provision_request['status']))
# Update provision request if extension "APPROVED"
if status == "APPROVED":
# find new expiration time
expires_by = str_to_date(
provision_request['expires_by']) + timedelta(
hours=extension_request['extend_by'])
update = {"$set": {"status": "EXTENDED", "expires_by": expires_by}}
ret = provisionRequests.update(provision_query,
update,
upsert=False)
logger.debug("provision request update response: " + str(ret))
# Update extension request
update = {
"$set": {
"reviewed_by": ObjectId(reviewed_by),
"status": status,
}
}
ret = extensionRequests.update(extension_query, update, upsert=False)
logger.debug("extension request update response: " + str(ret))
# Create response object
response = {"status": status, "_id": str(provision_request['_id'])}
# Create notification for developer (requester)
create_notification(title="Provision Request" + str(status),
description="Your provision request " +
str(provision_request["_id"]) + " has been " +
str(status),
user=provision_request["requested_by"])
except ValueError as e:
return Response(toJSON(failure_resp(str(e), 400)),
400,
mimetype='application/json')
except Exception as e:
return Response(toJSON(failure_resp(str(e), 500)),
500,
mimetype='application/json')
return Response(toJSON(response), 200, mimetype='application/json')
def test_str_to_date(self):
self.assertEqual(str_to_date(self.datestr), self.valid)
self.assertRaises(ValueError, str_to_date, 'not-a-date')
self.assertRaises(ValueError, str_to_date,
self.datestr.replace('GMT', 'UTC'))