def get(self):
level_map = {1: "Option",
2: "Asset Class Level 1",
3: "Asset Class Level 2",
4: "Manager"
}
page = request.args.get('page', default = 1, type = int)
page_size = request.args.get('page_size', default = 6, type = int)
entity_id = request.args.get('entity', default = None, type = int)
type = request.args.get('type', default = 1, type = int)
level = request.args.get('level', type = int, default = None)
if level:
level = level_map.get(level)
date = request.args.get('as_of_date', type = float, default = datetime_to_timestamp(datetime.datetime.utcnow()))
as_of_date = datetime.datetime.fromtimestamp(date / 1000)
res = {
'IntelligentCharts': IntelligentChartTab(IntelligentChartType(type), level, page, page_size, entity_id, as_of_date).to_dict()
}
return res
def get_growthOfunit(**kwargs):
account = kwargs.get("account")
rates_rules = kwargs.get("return_type")
end_date = kwargs.get("end_date")
starting_value = kwargs.get("starting_value")
account_list = tuple(account.lstrip("[").rstrip("]").split(","))
gpa = pd.read_sql(
GPATotalMonthly.query.from_statement(text(growth_of_unit_sql)).params(
account_codes=account_list,
rates_rules=rates_rules,
start=('2014-11-30'),
end=end_date).statement, db.session.bind)
growthOfunit = GrowthOfUnit(total_level_mon=gpa,
account=list(account_list),
starting_value=starting_value)
gc = growthOfunit._calculate()
formatdate = []
for date in gc['growth_of_unit']['xAxis']:
if isinstance(date, datetime.date):
date = datetime_to_timestamp(date)
date = int_to_timestamp(date)
formatdate.append(date)
gc['growth_of_unit']['xAxis'] = formatdate
return gc
def post(self, task_id):
comment = task_services.create_comment(task_id)
return {
'commentId': comment.id,
'createdTime': datetime_to_timestamp(comment.created_time)
}
def get(self, alert_id):
res = {}
alert = alert_services.get_alert_by_id(alert_id)
entity = asset_services.get_entity_by_id(alert.entity_id)
date = request.args.get('as_of_date', type = float, default = datetime_to_timestamp(datetime.datetime.utcnow()))
as_of_date = datetime.datetime.fromtimestamp(date / 1000)
res['chart'] = chart_services.get_chart_details_without_additional_info(alert.chart_id, as_of_date)
res['chart']['alert'] = alert.description
res['chart']['entityName'] = entity.name
res['relatedAlerts'] = alert_services.get_related_alerts(alert).to_dict()
res['alertsOfEntity'] = alert_services.get_alerts_of_entity_in_specific_page(alert)
effectiveDate = datetime.datetime.strptime(alert.chart_id[:7],'%Y_%m')
res['effectiveDate'] = datetime_to_timestamp(effectiveDate)
return res
def get(self, chart_id):
res = {}
res['chartData'] = chart_services.get_chart_details_without_additional_info(chart_id, None)
effectiveDate = datetime.datetime.strptime(chart_id[:7],'%Y_%m')
res['effectiveDate'] = datetime_to_timestamp(effectiveDate)
return res
def get(self):
page = request.args.get('page', default = 1, type = int)
page_size = request.args.get('page_size', default = 6, type = int)
entity_id = request.args.get('entity', default = None, type = int)
date = request.args.get('as_of_date', type = float, default = datetime_to_timestamp(datetime.datetime.utcnow()))
as_of_date = datetime.datetime.fromtimestamp(date / 1000)
return chart_services.get_intelligent_chart_list(entity_id, page, page_size, type, as_of_date)
def _reduce_datetimes(row):
"""Receives a row, converts datetimes to strings."""
row = list(row)
for i in range(len(row)):
if hasattr(row[i], 'isoformat'):
row[i] = time_utils.datetime_to_timestamp(row[i])
return tuple(row)
def post(self, chart_id):
page = request.args.get('page', default = 1, type = int)
page_size = request.args.get('page_size', default = 6, type = int)
entity_id = g.args.get('entity')#, default = None, type = int
date = g.args.get('as_of_date', datetime_to_timestamp(datetime.datetime.utcnow()))#, type = float, default = datetime_to_timestamp(datetime.datetime.utcnow())
# temp
if date == 'undefined':
date = datetime_to_timestamp(datetime.datetime.utcnow())
as_of_date = datetime.datetime.fromtimestamp(float(date) / 1000)
history_charts = g.args.get('history_charts')#, default = None
res = chart_services.get_chart_details(chart_id, entity_id, page, page_size, as_of_date, True, history_charts)
relatedCharts = res.get('relatedCharts')
chartData = res.get('chartData')
newSummary = chart_extend_service.query_chart_insight(chartData.get('chart_id'), g.user.id)
if newSummary:
# if newSummary.to_dict()[0].get('is_show_original') == 0:
chartData['new_summary'] = newSummary.to_dict()[0].get('insight')
chartData['is_show_original'] = newSummary.to_dict()[0].get('isShowOriginal')
else:
chartData['new_summary'] = None
chartData['is_show_original'] = 1
samePageCharts = []
if history_charts:
# history_charts = set(history_charts)
for chart_id in history_charts:
history_chart = chart_services.get_chart_details(chart_id, entity_id, page, page_size, as_of_date, False)
samePageCharts.append({"chart_id":history_chart.get('chartData').get('chart_id') ,"chart_data":history_chart.get('chartData')})
else:
samePageCharts.append({"chart_id":chartData.get('chart_id'),"chart_data":chartData})
res['samePageCharts'] = samePageCharts
effectiveDate = datetime.datetime.strptime(chart_id[:7],'%Y_%m')
res['effectiveDate'] = datetime_to_timestamp(effectiveDate)
return res
def get(self):
entity_id = request.args.get('entity', type = int, default = None)
metric_id = request.args.get('metric', type = int, default = 1)
page = request.args.get('page', type = int, default = 1)
date = request.args.get('as_of_date', type = float, default = datetime_to_timestamp(datetime.datetime.utcnow()))
as_of_date = datetime.datetime.fromtimestamp(date / 1000)
level = request.args.get('level', type = int, default = None)
entity_ids = []
if level:
entity_ids = alert_services.get_entity_ids_by_level(level)
res = {}
# to get the latest date
default_set = asset_services.get_default_set(as_of_date)
sankey_data = asset_services.generate_sankey_for_entity(default_set, entity_id, metric_id)
if entity_id:
sankey_data = asset_services.generate_sankey_for_entity(default_set, entity_id, metric_id)
res['sankeyData'] = alert_services.set_alert_flag_on_map(sankey_data, default_set)
res['alerts'] = alert_services.get_alerts_by_page_and_entity(default_set, entity_id, page, 9)
else:
sankey_data = asset_services.generate_sankey_for_whole_set(default_set, metric_id)
res['sankeyData'] = alert_services.set_alert_flag_on_map(sankey_data, default_set)
res['alerts'] = alert_services.get_alerts_by_page(default_set, page, 9, entity_ids)
access_entity_ids = user_services.get_access_entity_ids()
for item in res.get('sankeyData').get('nodes'):
if item.get('id') in access_entity_ids:
item['access'] = 1
else:
item['access'] = 1
res['sankeyData']['title'] = 'Alerts Map'
res['effectiveDate'] = datetime_to_timestamp(default_set.date_key)
res['availableStartDate'] = datetime_to_timestamp(chart_services.get_available_start_date())
return res
def get(self):
client_id = request.args.get('client_id')
ret_dic = {}
report = Report.query.filter_by(client_id=client_id,
author=g.user.id,
status=3).first()
user = User.query.filter_by(id=g.user.id).first()
if report is None:
ret_dic['report_id'] = None
ret_dic['previous_report_id'] = None
ret_dic['showtime'] = None
ret_dic['user_name'] = user.email
else:
ret_dic['report_id'] = report.id
ret_dic['previous_report_id'] = report.previous_report_id
ret_dic['showtime'] = time_utils.datetime_to_timestamp(
report.updated_time)
ret_dic['user_name'] = user.email
return ret_dic
def get(self, page, per_page):
ret_dic = []
reports = Report.query.filter_by(status=3, author=g.user.id).order_by(
Report.updated_time.desc()).paginate(int(page),
int(per_page),
error_out=False)
for report in reports.items:
temp_dic = {}
temp_dic['report_id'] = report.id
if report.previous_report_id == None:
report.previous_report_id = "0"
_, temp_dic['color_flag'] = check_drafts_detail(
report.id, report.previous_report_id)
temp_dic['client_name'] = report.client_name
temp_dic['update_time'] = time_utils.datetime_to_timestamp(
report.updated_time)
temp_dic['previous_report_id'] = report.previous_report_id
ret_dic.append(temp_dic)
return ret_dic
def to_dict(self, camelcase = True, ordered=False):
"""Returns the row as a dictionary, as ordered."""
# modified the keys to the rules of ca for front-end
if camelcase:
keys = [ self._named_as_camelcase(key) for key in self.keys()]
else:
keys = [ key for key in self.keys() ]
items = zip(keys, self.values())
result_dict = OrderedDict(items) if ordered else dict(items)
for key, value in result_dict.items():
if isinstance(value, (datetime.datetime, datetime.date)):
result_dict[key] = datetime_to_timestamp(value)
return result_dict
def get(self, entity_id = None):
page = request.args.get('page', default = 1, type = int)
page_size = request.args.get('page_size', default = 9, type = int)
entity_id = request.args.get('entity', default = None, type = int)
level = request.args.get('level', type = int, default = None)
date = request.args.get('as_of_date', type = float, default = datetime_to_timestamp(datetime.datetime.utcnow()))
as_of_date = datetime.datetime.fromtimestamp(date / 1000)
entity_ids = []
if level:
entity_ids = alert_services.get_entity_ids_by_level(level)
default_set = asset_services.get_default_set(as_of_date)
if entity_id:
res = alert_services.get_alerts_by_page_and_entity(default_set, entity_id, page, page_size)
else:
res = alert_services.get_alerts_by_page(default_set, page, page_size, entity_ids)
return res
def get(self, alert_id):
res = {}
page = request.args.get('page', default = 1, type = int)
page_size = request.args.get('page_size', default = 6, type = int)
alert = alert_services.get_alert_by_id(alert_id)
entity = asset_services.get_entity_by_id(alert.entity_id)
date = request.args.get('as_of_date', type = float, default = datetime_to_timestamp(datetime.datetime.utcnow()))
as_of_date = datetime.datetime.fromtimestamp(date / 1000)
res['chart'] = chart_services.get_chart_details_without_additional_info(alert.chart_id, as_of_date)
res['chart']['alert'] = alert.description
res['chart']['entityName'] = entity.name
res['relatedAlerts'] = alert_services.get_related_alerts(alert).to_dict()
res['alertsOfEntity'] = alert_services.get_alerts_of_entity(alert, page, page_size)
return res
def to_dict(self, excludes=[], camelcase=True):
dic = {}
for key, value in self.__dict__.items():
if re.match('_[^_]', key) or key in excludes:
# we don't process the private variables for class
pass
else:
if key.startswith('__'):
key = re.sub(r'__', '', key)
if camelcase:
key = underscore_to_camelcase(key)
if isinstance(value, date):
value = datetime_to_timestamp(value)
if isinstance(value, Record) or isinstance(
value, RecordCollection):
value = value.to_dict()
dic[key] = value
return dic
def post(self):
report_list_ret = []
report_list = []
data = request.get_json()
taglist = data.get('tag_list')
text= data.get('text')
page = data.get('page')
page_size = data.get('page_size')
if not page:
page = 1
if not page_size:
page_size = 10
if taglist is None or taglist is None:
return "taglist or text is None",400
if len(taglist)==0:
report_list = search_services.get_search_list_by_text(text, page, page_size)
ret_type = 0
for report in report_list.items:
report_dic = {}
report_dic['type'] = ret_type
report_dic['client_id'] = report.client_id
report_dic['client_name'] = report.client_name
report_list_ret.append(report_dic)
else:
report_list = search_services.get_search_list_by_clientId(taglist[0]['client_id'], page, page_size)
ret_type = 1
filter_values = []
timestample_dict = [(report.id, report.updated_time.strftime("%Y-%m-%d"), time_utils.datetime_to_timestamp(report.updated_time), report.author) for report in report_list.items]
for item in timestample_dict:
if text in item[1]:
user = User.query.filter_by(id=item[3]).first()
filter_values.append((item[0], item[2], user.email))
for report in filter_values:
ret_dic = {}
ret_dic['type'] = 1
ret_dic['plan_date'] = report[1]
ret_dic['report_id'] = report[0]
ret_dic['user_name'] = report[2]
report_list_ret.append(ret_dic)
return report_list_ret
