async def change_date(ctx, old_date:str = "-", new_date:str = "-", room:str = 1):
'''Change date of event'''
room, err_msg = validate_room(room)
if not room:
await ctx.send(err_msg)
return
old_event_date = string_to_date(old_date)
new_event_date = string_to_date(new_date)
if not old_event_date:
await ctx.send(ERROR_MSG['invalid_date'].format(old_date))
return
if not new_event_date:
await ctx.send(ERROR_MSG['invalid_date'].format(new_date))
return
event = cal.get_event(old_event_date, room)
if not event:
await ctx.send("Couldn't find any event at {} on room {}.".format(
old_event_date.strftime(TIME_FORMATER), room))
return
event.date = new_event_date
cal.upload_event(event)
await print_date_pretty(ctx, "We changed the date of event", event)
def __init__(self, first_date, second_date):
"""
:param first_date: first date string to be compared
:param second_date: second date string to be compared
"""
self.first_date = string_to_date(first_date, "%Y-%m-%d")
self.second_date = string_to_date(second_date, "%Y-%m-%d")
def get_rates(self, currency, tenor, start=None, end=None):
if tenor is not None:
match = re.search('(\\d+)([mMwW])', tenor)
if match is not None:
tenor_i = int(match.group(1))
m_w = match.group(2)
key = 'rates-' + str(
datetime.date.today()) + str(tenor_i) + m_w
res = self.__storage.get(key)
if res is None:
end = datetime.date.today()
start = None
if m_w in ['m', 'M']:
start = utils.month_delta(end, tenor_i * -1)
elif m_w in ['w', 'W']:
start = end - datetime.timedelta(days=7 * tenor_i)
rates = self.__rates_service.get_rates_dynamics(
currency, start, end).to_json()
self.__storage.add(key, rates)
return rates
else:
return res
else:
s_start = utils.string_to_date(start, "%Y-%m-%d")
s_end = utils.string_to_date(end, "%Y-%m-%d")
return self.__rates_service.get_rates_dynamics(
currency, s_start, s_end).to_json()
def get_services(agency, day=None, exp=True):
"""
Read the calendar.txt file and return a dict where the key
is the service_id and the value is a tuple with the rest of the
fields. If today is provided, will filter them and return only
those service_id's active today. If exp = True (default), accounts
for service exceptions included in calendar_dates.txt
:param agency: a str identifying the transit agency. Assumes a agency.zip GTFS archive.
:param day: an 8-char str or int specifying a day. Optional.
:param exp: bool, whether or not to account for CalException s active today
:returns a dict of tuples, representing calendar information in the agency GTFS file.
If today is provided then this dict includes only services active today.
"""
dicto = {}
cal = get_gtfs_df(webloc, agency, 'calendar')
# calendar.txt header:
# service_id,monday,tuesday,wednesday,thursday,friday,saturday,sunday,start_date,end_date
if day is not None:
date = u.string_to_date(day)
dow = date.strftime("%A").lower() # lowercase name not number
for _, row in cal.iterrows():
startstring, endstring = row['start_date'], row['end_date']
startdate, enddate = u.string_to_date(startstring), u.string_to_date(
endstring)
if day is None or\
(row[dow]==1 and startdate <= date <= enddate): #
dicto[row['service_id']] = Service(int(row['monday']),
int(row['tuesday']),
int(row['wednesday']),
int(row['thursday']),
int(row['friday']),
int(row['saturday']),
int(row['sunday']), startstring,
endstring)
# Start accounting for exceptions:
if day is not None and exp is True:
exceptions = get_exceptions(agency, day)
for x in exceptions:
thisserviceid = x.service_id
if x.exception_type == 1:
# Service ID is activated today
if thisserviceid not in dicto: # service ID should be added and is not currently in dict
servicetup = get_services(
agency
)[thisserviceid] # Write tuple by recursively calling function
dicto[x.service_id] = servicetup
elif x.exception_type == 2:
if thisserviceid in dicto: # Service has been disabled for today
del dicto[x.service_id] # remove it from dict
# print 'Returning ', len(dicto), 'service types active for today.'
return dicto
def filter_stats(self, stats):
"""
cut runtime from 24s -> 15s
:param stats:
:return: list of Statistics objects
"""
pred_dates = [string_to_date(d.date) for d in self.preds]
oldest_pred = dt.date.today()
for date in pred_dates:
if date < oldest_pred:
oldest_pred = date
return [s for s in stats if not string_to_date(s.date) < oldest_pred]
def rotate(dataset, new):
cur_date = datetime.datetime.now()
cur_date_string = utils.date_to_string(cur_date)
cur_month = cur_date.month
cur_weekday = cur_date.isoweekday()
cur_week = cur_date.isocalendar()[1]
cur_day = cur_date.day
yst_day = (cur_date - datetime.timedelta(days=1)).day
cur_hour = cur_date.hour
cur_year = cur_date.year
utils.create_snapshot(dataset, cur_date_string)
snap_list = utils.get_snapshot_list(dataset)
for snap in snap_list:
snap_tag = snap.split("@")[-1]
snap_date = utils.string_to_date(snap_tag)
if \
snap_date.year != cur_year or \
(snap_date.month != cur_month
and snap_date.day != 1) or \
(snap_date.isoweekday() < cur_weekday
and snap_date.isocalendar()[1] != cur_week
and snap_date.isoweekday() != 1
and snap_date.day != 1) or \
(snap_date.day != cur_day
and snap_date.day != yst_day
and snap_date.hour != 0) or \
(snap_date.day == yst_day
and snap_date.hour < cur_hour
and snap_date.hour != 0):
print("Deleting snapshot {}".format(snap))
utils.delete_snapshot(snap)
async def new(ctx, date:str="today", room:str=None, as_gm:str=False):
'''Set up new event'''
if room:
room, err_msg = validate_room(room)
if not room:
await ctx.send(err_msg)
return
event_date = string_to_date(date)
if not event_date:
await ctx.send(ERROR_MSG['invalid_date'].format(date))
return
free_slots = cal.get_free_slot(event_date)
if not free_slots:
await ctx.send("Sorry, on {} we don't have any room available :frowning2:".format(event_date.strftime(TIME_FORMATER)))
return
if room in free_slots:
old_slot = room
room = free_slots[0]
await ctx.send("Sorry, on {} room {} is already book, but we reserved you room {}".format(
event_date.strftime(TIME_FORMATER), old_slot, room))
if not room:
room = free_slots[0]
event = PnPParty(event_date, ctx.author.name if as_gm else None, [], room)
cal.upload_event(event)
await print_date_pretty(ctx, "We create a new event", event)
def get_fetch_date(self, user_id):
datetime_str = self._db.child("users").child(user_id).child(
"last_fetch").get().val()
if datetime_str:
return string_to_date(datetime_str)
else:
return None
def test_date():
import datetime
now = datetime.datetime.now()
d = utils.string_to_date("201810010900")
yesterday_date = (d - datetime.timedelta(days=1)).day
print yesterday_date
async def del_gm(ctx, date:str ="today", room:str = 1):
'''Remove yourself as a game master'''
room, err_msg = validate_room(room)
if not room:
await ctx.send(err_msg)
return
event_date = string_to_date(date)
if not event_date:
await ctx.send(ERROR_MSG['invalid_date'].format(date))
return
event = cal.get_event(event_date, room)
if event and event.gm == ctx.author.name:
del event.gm
cal.upload_event(event)
await ctx.send("Remove you successful from event: {} - room {}".format(
event_date.strftime(TIME_FORMATER), room
))
return
else:
await ctx.send("There is no event to remove you as gm from to given date {} on room {}".format(
event_date.strftime(TIME_FORMATER), room
))
async def gm(ctx, date:str ="today", room:str = 1):
'''Register yourself as a game master'''
room, err_msg = validate_room(room)
if not room:
await ctx.send(err_msg)
return
event_date = string_to_date(date)
if not event_date:
await ctx.send(ERROR_MSG['invalid_date'].format(date))
return
event = cal.get_event(event_date, room)
if event:
if event.gm == "":
event.gm = ctx.author.name
else:
await ctx.send("There can be only one GM: {}".format(event.gm))
return
else:
event = PnPParty(event_date, ctx.author.name, [], room)
cal.upload_event(event)
await print_date_pretty(ctx, "Add you as new GM for", event)
def add_event(title: str,
description: str,
name: str,
email: str,
url: str,
source: str,
start_now: bool,
end_now: bool,
offset: int = None,
start_date: str = None,
end_date: str = None):
assert not (offset is not None and start_now and end_now)
assert (start_date is None) == (end_date is None)
if start_date is None and end_date is None:
day = datetime.now()
if offset is not None:
day += timedelta(days=offset)
CalendarApiAdapter(
creds_path=os.environ['GOOGLE_CALENDAR_API_CREDS_PATH']).add_event(
title=title,
description=description,
email=email,
name=name,
url=url,
source=source,
start_now=start_now,
end_now=end_now,
date=day)
else:
start_date_ = string_to_date(start_date)
end_date_ = string_to_date(end_date)
for date in [
start_date_ + timedelta(days=i)
for i in range((end_date_ - start_date_).days)
]:
CalendarApiAdapter(
creds_path=os.environ['GOOGLE_CALENDAR_API_CREDS_PATH']
).add_event(title=title,
description=description,
email=email,
name=name,
url=url,
source=source,
start_now=start_now,
end_now=end_now,
date=date)
def fetch_artices(self, date_limit=None):
self.create_result_csv()
if date_limit is None:
date_limit = '1970-01-01'
logger.debug('Fetching articles data')
self.articles = []
for counter, url in enumerate(self.urls):
logger.info('Fetching article {}/{}'.format(
counter + 1, len(self.urls)))
article = ArticleParser.get_article_obj_from_url(url)
if string_to_date(article.date) >= string_to_date(date_limit):
self.add_article(article, True)
else:
logger.info('Stopped fetching as articles too old')
break
print('..')
self.csv_file.close()
def get_persons_between_dates(self):
"""
Returns filtered list of all persons born between dates
:return: list of person dictionaries
"""
return list(
filter(
lambda person: self.first_date < string_to_date(
person["dob"]["date"], "%Y-%m-%dT%H:%M:%S.%fZ") < self.
second_date,
self.get_all_persons().dicts()))
def load_more(driver, date_limit=None):
date_limit = string_to_date(date_limit)
logger.debug('Will now load more articles. Date limit: ' + str(date_limit))
while True:
last_article_date = string_to_date(get_last_date(driver))
logger.debug('Last article date = ' + str(last_article_date))
if last_article_date < date_limit:
logger.debug('Article too old. Not loading any more articles')
break
else:
logger.debug('Article under limit. Loading more articles')
load_more_button = driver.find_element_by_xpath(
"//button[@class='btn posts-listing__more-btn']")
logger.debug("Found load more button")
load_more_button.click()
logger.debug('Pressed load more button')
sleep(4)
def parse_tender(html):
""" Parse a tender HTML and return a dictionary with information such
as: title, description, published etc
"""
soup = BeautifulSoup(html, 'html.parser')
documents = find_by_class(soup, "lnkShowDocument", "a")
description = find_by_class(soup, "ungm-list-item ungm-background", "div")
description = description[1].text.strip().lstrip('Description')
nodes = find_by_class(soup, "nodeName", "span")
scraped_nodes = [parent.find_all("span")[0].text for parent in nodes[1:]]
with open(json_unspsc_codes, 'rb') as fp:
codes = json.load(fp)
unspsc_codes = [
code['id'] for code in codes
if code['id_ungm'] in scraped_nodes
]
notice_type = find_by_class(soup, "status-tag", "span", True)
title = find_by_class(soup, "title", "span", True)
organization = find_by_class(soup, "highlighted", "span", True)
reference = soup.find('span', text = re.compile('Reference:')).next_sibling.next_sibling.text
published = soup.find('span', text = re.compile('Published on:')).next_sibling.next_sibling.text
deadline = soup.find('span', text = re.compile('Deadline on:')).next_sibling.next_sibling.text
tender = {
'source': 'UNGM',
'notice_type': notice_type,
'title': title,
'organization': organization,
'reference': reference,
'published': string_to_date(published) or date.today(),
'deadline': string_to_datetime(deadline[:17]),
'description': description,
'unspsc_codes': ', '.join(unspsc_codes),
'documents': [
{
'name': document.text.strip(),
'download_url': ENDPOINT_URI + documents[0]['href']
}
for document in documents
],
}
gmt = deadline
gmt = gmt[gmt.find("GMT")+4:gmt.find(")")]
if gmt:
tender['deadline'] -= timedelta(hours=float(gmt))
tender['deadline'] += timedelta(hours=get_local_gmt())
return tender
def __init__(self, start_date, num_of_days):
self.files: List[str] = get_files_of_dir(self.const.DIR_MACHINE_CSVS)
self.num_of_days: int = num_of_days
self.max_length: int = self.num_of_days * 86400
date: datetime.datetime = string_to_date(start_date)
self.dates: List[datetime.datetime] = [
date + datetime.timedelta(days=x) for x in range(0, num_of_days)
]
self.dates = sorted(self.dates)
self.dates: List[str] = [
date.strftime('%Y-%m-%d') for date in self.dates
]
if not exists(self.const.DIR_PLOTS):
mkdir(self.const.DIR_PLOTS)
async def overview(ctx, date:str = None):
'''Show an overview over future pnp parties'''
if date:
event_date = string_to_date(date)
if not event_date:
await ctx.send(ERROR_MSG['invalid_date'].format(date))
return
events = cal.get_events_on_date(event_date)
else:
events = cal.get_all_future_events()
if not events:
await ctx.send("Couldn't find any date!")
return
await print_date_pretty(ctx, "You ask for an overview", events)
async def add_title(ctx, title:str, date:str ="today", room:str ="1"):
'''Add title to event'''
room, err_msg = validate_room(room)
if not room:
await ctx.send(err_msg)
return
event_date = string_to_date(date)
if not event_date:
await ctx.send(ERROR_MSG['invalid_date'].format(date))
return
event = cal.get_event(event_date, room)
if event:
event.title = title
cal.upload_event(event)
await print_date_pretty(ctx, "We changed title of event", event)
async def del_player(ctx, date:str ="today", room:str = 1, player_name:str=None):
'''Remove yourself from a event.'''
room, err_msg = validate_room(room)
if not room:
await ctx.send(err_msg)
return
event_date = string_to_date(date)
if not event_date:
await ctx.send(ERROR_MSG['invalid_date'].format(date))
return
event = cal.get_event(event_date, room)
if not player_name:
success = event.remove_player(ctx.author.name)
if success:
await ctx.send("Successful removed you from player list on {} at room {}".format(
event_date.strftime(TIME_FORMATER), room
))
cal.upload_event(event)
return
await ctx.send("Couldn't find you on {} room {} as player. We searched with your name {}".format(
event_date.strftime(TIME_FORMATER), room, ctx.author.name
))
return
if player_name and event.gm == ctx.author.name:
success = event.remove_player(player_name)
if success:
await ctx.send("Successful removed {} from player list on {} at room {}".format(
player_name, event_date.strftime(TIME_FORMATER), room
))
cal.upload_event(event)
return
await ctx.send("Couldn't find {} on {} room {} as player.".format(
player_name, event_date.strftime(TIME_FORMATER), room
))
return
await ctx.send(ERROR_MSG['insufficient_rights'])
def populate_deceased(self):
logger.info('Populating deceased.')
session = self._db_client.get_session()
for row in self._read_workbook('Deceased'):
(r_inquest_id, r_last_name, r_given_name, r_age, r_age_unit, r_sex,
r_death_location, r_death_date, r_death_cause, r_death_cause_id,
r_death_manner_id, r_inquest_reason_id) = row
# Validate inquest type.
# TODO: remove.
if r_inquest_reason_id.startswith('MANDATORY_'):
# An inquest is either 'Discretionary' or 'Mandatory-<reason>'; this makes 'Mandatory' redundant.
inquest_reason_id = r_inquest_reason_id.replace(
'MANDATORY_', '')
else:
inquest_reason_id = r_inquest_reason_id
# TODO: validate that deceased age is < 18.
last_name = utils.format_as_title(r_last_name,
utils.NullBehaviour.NULL_TO_NULL)
given_names = utils.format_string(r_given_name,
utils.NullBehaviour.NULL_TO_NULL)
session.add(
models.Deceased(
inquestId=r_inquest_id,
inquestReasonId=inquest_reason_id,
deathMannerId=utils.format_as_id(
r_death_manner_id), # TODO: remove format_as_id call.
deathCauseId=r_death_cause_id,
deathCause=utils.format_string(r_death_cause),
deathDate=utils.string_to_date(r_death_date),
deathLocation=utils.format_string(
r_death_location, utils.NullBehaviour.NULL_TO_NULL),
lastName=last_name,
givenNames=given_names,
age=utils.string_to_int(r_age),
ageUnit=utils.format_string(r_age_unit),
sex=utils.format_string(r_sex)))
session.commit()
async def attend(ctx, date:str ="today", room:str=1):
'''Attend at a event'''
room, err_msg = validate_room(room)
if not room:
await ctx.send(err_msg)
return
event_date = string_to_date(date)
if not event_date:
await ctx.send(ERROR_MSG['invalid_date'].format(date))
return
event = cal.get_event(event_date, room)
if event:
event.add_player(ctx.author.name)
else:
event = PnPParty(event_date,player_list=[ctx.author.name])
await ctx.send("We create a new event on {} at room {}".format(event_date.strftime(TIME_FORMATER), room))
cal.upload_event(event)
await ctx.send("You're registered as player for {} in room {}".format(event_date.strftime(TIME_FORMATER), room))
def task_4():
'''
Return the data for rentals with 01/06/1999 <= lease start date <= 31/08/2007
'''
reader = utils.get_masts_as_list()
lease_start_header = 'Lease Start Date'
lease_start_header_index = utils.get_header_index(lease_start_header)
range_start = date(1999, 6, 1)
range_end = date(2007, 8, 31)
res = []
for item in reader:
lease_start_date_str = item[lease_start_header_index]
if utils.is_date_string_in_range(lease_start_date_str, range_start,
range_end):
item[lease_start_header_index] = utils.date_to_string(
utils.string_to_date(lease_start_date_str))
res.append(item)
return res
def get_rates_dynamics(self, currency, from_date, to_date):
if self.__cur_mapping is None:
self.__cur_mapping = self.get_currencies()
if self.__cur_mapping is None or len(self.__cur_mapping) == 0:
logging.debug(u'Initialization failed')
return ApiResponse(
has_error=True,
error_description='Connection error on initialization')
if currency not in self.__cur_mapping:
return ApiResponse(
has_error=True,
error_description='Unsupported/unknown currency')
currency_id = self.__cur_mapping[currency]
uri = self.url_dynamics \
.replace("{ccy_id}", str(currency_id)) \
.replace("{from}", utils.date_to_string(from_date, self.DATE_FORMAT)) \
.replace("{to}", utils.date_to_string(to_date, self.DATE_FORMAT))
response = self.__client.get_response(uri)
if response.has_error:
return ApiResponse(has_error=True,
error_description='Connection error')
j_resp = json.loads(response.response_text)
rates = {}
for item in j_resp:
date = utils.string_to_date(item['Date'], self.ISO_DATE_FORMAT)
str_date = utils.date_to_string(date, self.DATE_FORMAT)
rate = item['Cur_OfficialRate']
rates[str_date] = rate
return ApiResponse(
result=collections.OrderedDict(sorted(rates.items())))
async def add_player(ctx, date:str ="no value given", room:str = "no value given", player_name:str=None):
'''As gm add players to your event'''
room, err_msg = validate_room(room)
if not room:
await ctx.send(err_msg)
return
event_date = string_to_date(date)
if not event_date:
await ctx.send(ERROR_MSG['invalid_date'].format(date))
return
event = cal.get_event(event_date, room)
if event and ctx.author.name == event.gm:
event.add_player(player_name)
else:
await ctx.send("Couldn't find any event at {} on room {} with you as GM. Please create an event first.".format(
event_date.strftime(TIME_FORMATER), room))
return
cal.upload_event(event)
await ctx.send("You're registered {} as player for {} in room {}".format(player_name, event_date.strftime(TIME_FORMATER), room))
def parse_winner(html):
""" Parse a contract award HTML and return a dictionary with information
such as: title, reference, vendor etc
"""
soup = BeautifulSoup(html, 'html.parser')
description = soup.find_all('div', CSS_DESCRIPTION)
vendor_list = []
for vendors_div in soup.find_all(id=CSS_VENDOR_LIST):
vendors = vendors_div.descendants
for vendor in vendors:
if vendor.name == 'div' and vendor.get('class', '') == ['editableListItem']:
vendor_list.append(vendor.text.strip())
vendor_list = ', '.join(vendor_list)
title = find_by_label(soup, CSS_TITLE)
organization = find_by_label(soup, CSS_ORGANIZATION)
reference = find_by_label(soup, CSS_REFERENCE)
tender_fields = {
'source': 'UNGM',
'title': to_unicode(title.string),
'organization': to_unicode(organization.string),
'reference': to_unicode(reference.string.strip()),
'description': to_unicode(str(description[0])),
}
award_date = find_by_label(soup, CSS_AWARD_DATE)
value = find_by_label(soup, CSS_VALUE)
winner_fields = {
'award_date': string_to_date(award_date.string) or date.today(),
'vendor': vendor_list,
'value': float(value.string or 0) if value.string
else None
}
if winner_fields['value']:
winner_fields['currency'] = 'USD'
return tender_fields, winner_fields
async def delete(ctx, date:str="no date given", room:str= "no room given"):
'''Delete an event on given date and room.'''
room, err_msg = validate_room(room)
if not room:
await ctx.send(err_msg)
return
event_date = string_to_date(date)
if not event_date:
await ctx.send(ERROR_MSG['invalid_date'].format(date))
return
event = cal.get_event(event_date, room)
if not event:
await ctx.send("No event found to delete :frowning2:")
return
if not event.gm or event.gm == ctx.author.name:
cal.delet_event(event)
await ctx.send("Deleted event on {} in room {}!".format(event_date.strftime(TIME_FORMATER), room))
return
await ctx.send(ERROR_MSG['insufficient_rights'])
with open('../files/dados_safra_milho_conab.csv', 'r') as arquivo_csv:
reader = csv.reader(arquivo_csv, delimiter=',')
year = 2013
month = 1
collection = 'historical_data_daily'
for colunm in reader:
if year < 2021:
for week in calendar.monthcalendar(year, month):
for day in week:
if day != 0:
date = utils.format_number(
day, 2) + '.' + utils.format_number(
month, 2) + '.' + str(year)
date = utils.string_to_date(date)
if server.db_select(collection, ['date'],
[date]) == None:
server.db_insert(
collection, ['date', 'br_production'],
[date, utils.string_to_float(colunm[1])])
else:
server.db_update(collection, {"date": date}, {
'br_production':
utils.string_to_float(colunm[1])
})
if server.db_select(collection, ['date'],
[date]) == None:
server.db_insert(
collection, ['date', 'br_plateau_area'],
import csv
import server as server
from datetime import timedelta
import utils
with open('../files/dolar_brl_semanal.csv', 'r') as arquivo_csv:
reader = csv.reader(arquivo_csv, delimiter=',')
for idx, colunm in enumerate(reader):
if idx > 1:
collection = 'historical_data_weekly'
keys = [
'date', 'dolar', 'open_dolar', 'max_dolar', 'min_dolar',
'var_dolar'
]
values = [
utils.string_to_date(colunm[0]),
utils.string_to_float(colunm[1]),
utils.string_to_float(colunm[2]),
utils.string_to_float(colunm[3]),
utils.string_to_float(colunm[4]),
utils.string_to_float(colunm[5])
]
colunm[0] = utils.string_to_date(colunm[0]) - timedelta(days=1)
if server.db_select(collection, [keys[0]], [values[0]]) == None:
server.db_insert(collection, keys, values)
else:
for i, *_ in enumerate(colunm):
if i >= 1:
server.db_update(collection, {keys[0]: values[0]},
{keys[i]: values[i]})
def test_string_to_date():
# testing with the default input format
test_str_date = '23 Nov 2019'
tester_output = date(2019, 11, 23)
assert string_to_date(test_str_date) == tester_output
def populate_documents(self):
logger.info('Populating documents.')
session = self._db_client.get_session()
document_sources = set('NO PUBLISH')
for row in self._read_workbook('Documents'):
(r_serial, r_reference_type, r_name, r_citation, r_date, r_link,
r_document_source, r_source_id, r_reference_id, r_primary,
r_document_type) = row
document_source_id = utils.format_as_id(r_document_source)
# Create document source type if it does not exist.
# TODO: create export table?
if utils.format_as_id(r_document_source) not in document_sources:
session.add(
models.DocumentSource(
documentSourceId=document_source_id,
name=utils.format_string(r_document_source),
))
session.flush()
document_sources.add(document_source_id)
# Upload document to S3 if respective file exists locally.
link = None
if document_source_id == 'INQUESTS_CA':
s3_link = self._upload_document_if_exists(
r_reference_type, r_name, r_date, r_source_id, r_serial,
int(r_reference_id))
if s3_link is not None:
link = s3_link
elif document_source_id != 'NO PUBLISH':
link = r_link
if r_reference_type == self._REFERENCE_TYPE_AUTHORITY:
authority_document = models.AuthorityDocument(
authorityId=r_reference_id,
authorityDocumentTypeId=utils.format_as_id(
r_document_type, utils.NullBehaviour.NULL_TO_NULL),
sourceId=r_source_id,
isPrimary=r_primary,
name=utils.format_string(r_name),
citation=utils.format_string(
r_citation, utils.NullBehaviour.NULL_TO_NULL),
created=utils.string_to_date(
r_date, utils.NullBehaviour.NULL_TO_NULL),
)
session.add(authority_document)
session.flush()
if link is not None:
session.add(
models.AuthorityDocumentLinks(
authorityDocumentId=authority_document.
authorityDocumentId,
documentSourceId=document_source_id,
link=link,
))
elif r_reference_type == self._REFERENCE_TYPE_INQUEST:
inquest_document = models.InquestDocument(
inquestId=r_reference_id,
inquestDocumentTypeId=utils.format_as_id(
r_document_type, utils.NullBehaviour.NULL_TO_NULL),
name=utils.format_string(r_name),
created=utils.string_to_date(r_date),
)
session.add(inquest_document)
session.flush()
if link is not None:
session.add(
models.InquestDocumentLinks(
inquestDocumentId=inquest_document.
inquestDocumentId,
documentSourceId=document_source_id,
link=link,
))
session.commit()
for data in list_of_json:
call_uuid = data["variables"].get("call_uuid", None)
domain_uuid = data["variables"].get("domain_uuid", None)
domain_name = data["variables"].get("domain_name", None)
call_direction = data["variables"].get("call_direction", None)
last_bridge_hangup_cause = data["variables"].get(
"last_bridge_hangup_cause", None)
caller_id_name = data["variables"].get("caller_id_name", None)
caller_destination = data["variables"].get("caller_destination", None)
origination_callee_id_name = data["variables"].get(
"origination_callee_id_name", None)
last_sent_callee_id_number = data["variables"].get(
"last_sent_callee_id_number", None)
str_start_stamp = clean_string(data["variables"].get("start_stamp", None))
start_stamp = string_to_date(str_start_stamp)
str_end_stamp = clean_string(data["variables"].get("end_stamp", None))
end_stamp = string_to_date(str_end_stamp)
str_voicemail_answer_stamp = clean_string(data["variables"].get(
"voicemail_answer_stamp", None))
voicemail_answer_stamp = string_to_date(str_voicemail_answer_stamp)
billsec = data["variables"].get("billsec", None)
dialstatus = data["variables"].get("dialstatus", None)
hangup_cause = data["variables"].get("hangup_cause", None)
intercept = data["variables"].get("intercept", None)
read_result = data["variables"].get("read_result", None)
cur.execute(
