Source code for lambdas.date_util
from datetime import datetime, timedelta
import logging
from dateutil.relativedelta import relativedelta
from constant import SQS_DATE_TIME_FORMAT, FILE_DATE_FORMAT
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
[docs]def get_datetime_string(date_str, time_str):
"""
This method is used to get date time format
:param date_str:
:param time_str:
"""
format_str = '%d/%m/%Y'
datetime_obj = datetime.strptime(date_str, format_str).date()
return datetime_obj.strftime(f"%d%m%Y:{time_str}")
[docs]def get_verified_cap_date(cap_date):
"""
This method is used to check capping date should be greater than today's date
:param cap_date: capping date
:return :
"""
try:
if cap_date is not None and datetime.date(cap_date) >= datetime.date(datetime.now()):
return cap_date
return None
except ValueError as ex:
logger.error(ex)
return None
[docs]def add_end_daytime(cap_date):
"""
This method is used to add end time to capping date
:param cap_date: capping date
:return :
"""
time_delta = timedelta(hours=23, minutes=59, seconds=59)
return (cap_date + time_delta)
[docs]def add_start_daytime(cap_date):
"""
This method is used to add start time to capping date
:param cap_date: capping date
:return :
"""
time_delta = timedelta(hours=00, minutes=00, seconds=00)
return (cap_date + time_delta)
[docs]def is_valid_masking_date(mask_date):
"""
This method is used to check masking date should be greater than today's date
:param mask_date: masking date
:return :
"""
is_valid_date = True
try:
now = datetime.now()
today_datetime = datetime(now.year, now.month, now.day)
mask_datetime = datetime.strptime(mask_date, SQS_DATE_TIME_FORMAT)
is_valid_date = True if mask_datetime >= today_datetime else False
except ValueError as ex:
is_valid_date = False
logger.error(ex)
return is_valid_date
[docs]def validate_store(store_id):
"""
This method is used to verify the store id is valid or not
:param store_id: store id
:return : True if valid store_id
"""
if type(store_id) is int:
if store_id > 999 or store_id == 0:
return False
elif type(store_id) is str and (len(store_id) > 3 or not store_id.isdigit()):
return False
elif type(store_id) is float:
return False
return True
[docs]def is_validate_store_id(stores):
"""
This method is used to verify the store id is valid or not
:param stores: list of store id
:return : True if all valid store_ids in list
"""
if type(stores) is list and len(stores) > 0:
return all([validate_store(store_id) for store_id in stores])
return False
[docs]def get_updated_product_masking_for_overlapping(masking_data):
"""
This method is used to get updated masking if new masking overlapped with existing masking
:param masking_data: Override Periods Details
"""
override_periods = masking_data.get("overridePeriods")
new_overrides = []
from_date = ""
to_date = ""
override_periods = sorted(override_periods, key=lambda i: i["from"])
for idx, override in enumerate(override_periods):
is_delete = False
override_from_date = override.get("from")
override_to_date = override.get("to")
if idx == 0:
from_date = override_from_date
to_date = override_to_date
is_delete = True
else:
if override_from_date < to_date < override_to_date:
to_date = override_to_date
is_delete = True
if override_from_date < from_date:
from_date = override_from_date
is_delete = True
if not is_delete and from_date < override_from_date and to_date < override_to_date:
new_overrides.append(override)
new_overrides.append({
"from": from_date,
"to": to_date,
"available": False
})
masking_data["overridePeriods"] = new_overrides
return masking_data
[docs]def is_mask_date_overlapping(existing_mask_from, existing_mask_until, new_mask_from, new_mask_until):
"""
This method is used for finding the overlapping masking dates
:param existing_mask_from:
:param existing_mask_until:
:param new_mask_from:
:param new_mask_until:
:return:
"""
ex_mask_from_date = datetime.date(existing_mask_from)
ex_mask_until_date = datetime.date(existing_mask_until)
new_mask_from_datetime = datetime.strptime(new_mask_from, '%Y-%m-%dT%H:%M:%S.%f')
new_mask_from_date = datetime.date(new_mask_from_datetime)
new_mask_until_datetime = datetime.strptime(new_mask_until, '%Y-%m-%dT%H:%M:%S.%f')
new_mask_until_date = datetime.date(new_mask_until_datetime)
if ex_mask_from_date <= new_mask_from_date and new_mask_until_date <= ex_mask_until_date:
return True
return False
[docs]def is_more_than_one_year(new_mask_from, new_mask_until, date_format):
"""
This method is used for finding the masking dates is more than one year or not
:param new_mask_from: masking from date
:param new_mask_until: masking until date
:param date_format: date format
:return:
"""
new_mask_from_datetime = datetime.strptime(new_mask_from, date_format)
new_mask_from_date = datetime.date(new_mask_from_datetime)
new_mask_until_datetime = datetime.strptime(new_mask_until, date_format)
new_mask_until_date = datetime.date(new_mask_until_datetime)
now = datetime.now()
today_datetime = datetime(now.year, now.month, now.day)
from_time_difference = relativedelta(new_mask_from_datetime, today_datetime)
from_difference_in_years = from_time_difference.years
if from_difference_in_years >= 1:
return True
time_difference = relativedelta(new_mask_until_date, new_mask_from_date)
difference_in_years = time_difference.years
if difference_in_years >= 1:
return True
return False
[docs]def validate_if_masking_is_more_than_a_year(from_date, to_date, override_from_date, is_delete):
"""
Function to check if masking difference is more than a year.
params:
from_date: from date
to_date: until date
override_from_date: new suggested from date
is_delete: True or False
"""
if is_more_than_one_year(from_date, to_date, "%Y-%m-%dT%H:%M:%SZ"):
from_date = override_from_date
is_delete = True
return from_date, is_delete