def add_indicator(data, result_id, commit=True):
i = models.ActivityResultIndicator()
i.indicator_title = data.get('indicator_title')
i.indicator_description = data.get('indicator_description')
if data.get("baseline_year"):
i.baseline_year = isostring_year(data.get('baseline_year'))
i.baseline_value = data.get('baseline_value')
i.baseline_description = data.get('baseline_description')
i.measurement_type = data.get('measurement_type')
i.measurement_unit_type = data.get('measurement_unit_type')
i.result_id = result_id
db.session.add(i)
db.session.commit()
if data.get("periods"):
[
add_indicator_period(period, i.id, False)
for period in data['periods']
]
activity_updated(
i.result.activity_id, {
"user_id": current_user.id,
"mode": "add",
"target": "ActivityResultIndicator",
"target_id": i.id,
"old_value": None,
"value": i.as_dict()
})
return i
def update_attr(data):
finance = models.ActivityFinances.query.filter_by(
id=data['finances_id']
).first()
old_value = getattr(finance, data['attr'])
if data['attr'].endswith('date'):
if data["value"] == "":
data["value"] = None
else:
data['value'] = isostring_date(data['value'])
elif data['attr'] == "transaction_value":
if data['value'] == "":
data['value'] = 0.0
setattr(finance, data['attr'], data['value'])
db.session.add(finance)
db.session.commit()
activity_updated(finance.activity_id,
{
"user_id": current_user.id,
"mode": "update",
"target": "ActivityFinances",
"target_id": finance.id,
"old_value": {data['attr']: old_value},
"value": {data['attr']: data['value']}
}
)
return finance
def update_activity_policy_marker(activity_id, policy_marker_code, data):
activity_policy_marker = models.ActivityPolicyMarker.query.filter_by(
activity_id=activity_id,
policy_marker_code=policy_marker_code).first()
if activity_policy_marker:
old_value = getattr(activity_policy_marker, data['attr'])
mode = "update"
else:
activity_policy_marker = models.ActivityPolicyMarker()
activity_policy_marker.activity_id = activity_id
activity_policy_marker.policy_marker_code = policy_marker_code
old_value = {}
mode = "add"
setattr(activity_policy_marker, data['attr'], data['value'])
db.session.add(activity_policy_marker)
db.session.commit()
activity_updated(
activity_id, {
"user_id": current_user.id,
"mode": mode,
"target": "ActivityPolicyMarker",
"target_id": activity_policy_marker.id,
"old_value": old_value,
"value": {
data['attr']: data['value']
}
})
return True
def add_finances(activity_id, data):
activity_finance = models.ActivityFinances()
activity_finance.activity_id = activity_id
classifications = data.get("classifications")
data.pop("classifications")
data["transaction_date"] = isostring_date(data["transaction_date"])
activity_finance.currency_automatic = True
activity_finance.currency_source, activity_finance.currency_rate, activity_finance.currency_value_date = qexchangerates.get_exchange_rate(
data["transaction_date"], data.get("currency", "USD"))
for key, value in data.items():
setattr(activity_finance, key, value)
_classifications = []
for key, value in classifications.items():
_c = models.ActivityFinancesCodelistCode()
_c.codelist_id = key
_c.codelist_code_id = value
_classifications.append(_c)
activity_finance.classifications = _classifications
db.session.add(activity_finance)
db.session.commit()
activity_updated(activity_id,
{
"user_id": current_user.id,
"mode": "add",
"target": "ActivityFinances",
"target_id": activity_finance.id,
"old_value": None,
"value": activity_finance.as_dict()
}
)
return activity_finance
def update_attr(data):
if data['attr'] in ["mtef-sector", "aligned-ministry-agency", "sdg-goals"]:
# Delete existing database entry
old_clc = models.ActivityCodelistCode.query.filter(
models.ActivityCodelistCode.activity_id == data['id'],
models.CodelistCode.codelist_code == data['attr']).join(
models.CodelistCode).all()
for code in old_clc:
db.session.delete(code)
new_clc = models.ActivityCodelistCode()
new_clc.activity_id = data["id"]
new_clc.codelist_code_id = data['value']
db.session.add(new_clc)
db.session.commit()
return True
activity = models.Activity.query.filter_by(id=data['id']).first()
if data['attr'].endswith('date'):
data['value'] = isostring_date(data['value'])
if data['attr'] == "start_date":
if data['value'].date() < activity.start_date:
new_fs = qfinances.create_missing_forward_spends(
data['value'].date(), activity.end_date, activity.id)
activity.forwardspends += new_fs
print("Warning: activity start date moved earlier")
if data['value'].date() > activity.start_date:
# FIXME: need to remove 0-valued forward spend periods
print("Warning: activity start date moved later")
if data['attr'] == "end_date":
if data['value'].date() > activity.end_date:
new_fs = qfinances.create_missing_forward_spends(
activity.start_date, data['value'].date(), activity.id)
activity.forwardspends += new_fs
print("Warning: activity end date moved later")
if data['value'].date() < activity.end_date:
# FIXME: need to remove 0-valued forward spend periods
print("Warning: activity end date moved earlier")
if (data['attr'].startswith("total_") and data['value'] == ""):
data['value'] = 0
old_value = getattr(activity, data['attr'])
setattr(activity, data['attr'], data['value'])
activity.updated_date = datetime.datetime.utcnow()
db.session.add(activity)
db.session.commit()
activity_updated(
activity.id, {
"user_id": current_user.id,
"mode": "update",
"target": "Activity",
"target_id": activity.id,
"old_value": {
data['attr']: old_value
},
"value": {
data['attr']: data['value']
}
})
return True
def create_activity(data):
# FIXME check this org doesn't already exist?
act = models.Activity()
# Dates have to be converted to date format
data["start_date"] = isostring_date(data["start_date"])
data["end_date"] = isostring_date(data["end_date"])
classifications = []
for cl in [
"sdg-goals", "mtef-sector", "aft-pillar",
"aligned-ministry-agency", "papd-pillar"
]:
cl_id = 'classification_id_{}'.format(cl)
cl_pct = 'classification_percentage_{}'.format(cl)
classification = models.ActivityCodelistCode()
classification.codelist_code_id = data[cl_id]
classifications.append(classification)
data.pop(cl_id)
data.pop(cl_pct)
act.classifications = classifications
orgs = []
for org_id, org_role in ((data["org_4"], 4), (data["org_1"], 1)):
org = models.ActivityOrganisation()
org.organisation_id = org_id
org.role = org_role
data.pop("org_{}".format(org_role))
orgs.append(org)
act.organisations = orgs
for attr, val in data.items():
if attr.startswith("total_"):
if val == "":
val = 0
setattr(act, attr, val)
if not "forwardspends" in data:
act.forwardspends = qfinances.create_forward_spends(
data["start_date"], data["end_date"])
db.session.add(act)
db.session.commit()
activity_updated(
act.id, {
"user_id": current_user.id,
"mode": "add",
"target": "Activity",
"target_id": act.id,
"old_value": None,
"value": act.as_dict()
})
return act
def update_result_attr(data):
result = models.ActivityResult.query.filter_by(id=data['id']).first()
oldresult = result.as_dict()
setattr(result, data['attr'], data['value'])
db.session.add(result)
db.session.commit()
activity_updated(
result.activity_id, {
"user_id": current_user.id,
"mode": "update",
"target": "ActivityResult",
"target_id": result.id,
"old_value": oldresult,
"value": result.as_dict()
})
return result
def create_or_update_forwardspend(activity_id, quarter, year, value, currency):
# NB quarters are in calendar quarters, not Liberian fiscal quarters
start_day, start_month = QUARTERS_MONTH_DAY[quarter]["start"]
end_day, end_month = QUARTERS_MONTH_DAY[quarter]["end"]
start_date = datetime.datetime(year, start_month, start_day).date()
end_date = datetime.datetime(year, end_month, end_day).date()
forward_spend = models.ActivityForwardSpend.query.filter_by(activity_id=activity_id,
period_start_date=start_date).first()
if forward_spend:
old_value = forward_spend.value
forward_spend.value = value
db.session.add(forward_spend)
db.session.commit()
activity_updated(forward_spend.activity_id,
{
"user_id": current_user.id,
"mode": "update",
"target": "ActivityForwardSpend",
"target_id": forward_spend.id,
"old_value": {"value": old_value},
"value": {"value": value}
}
)
return forward_spend
else:
forward_spend = models.ActivityForwardSpend()
forward_spend.activity_id = activity_id
forward_spend.value = value
forward_spend.value_date = start_date
forward_spend.value_currency = currency
forward_spend.period_start_date = start_date
forward_spend.period_end_date = end_date
db.session.add(forward_spend)
db.session.commit()
activity_updated(forward_spend.activity_id,
{
"user_id": current_user.id,
"mode": "add",
"target": "ActivityForwardSpend",
"target_id": forward_spend.id,
"old_value": None,
"value": forward_spend.as_dict()
}
)
return forward_spend
def delete_activity(activity_id):
activity = models.Activity.query.filter_by(id=activity_id).first()
if ((getattr(current_user, "id") == activity.user_id)
or (getattr(current_user, "administrator"))):
# Allow this activity to be deleted
db.session.delete(activity)
db.session.commit()
return True
activity_updated(
activity.id, {
"user_id": current_user.id,
"mode": "delete",
"target": "Activity",
"target_id": activity.id,
"old_value": activity.as_dict(),
"value": None
})
return False
def update_indicator_attr(data):
indicator = models.ActivityResultIndicator.query.filter_by(
id=data['id']).first()
oldindicator = indicator.as_dict()
if (data['attr'].endswith("year")) and not (data['value'] in (None, '')):
data['value'] = isostring_year(str(data['value']))
setattr(indicator, data['attr'], data['value'])
db.session.add(indicator)
db.session.commit()
activity_updated(
indicator.result.activity_id, {
"user_id": current_user.id,
"mode": "update",
"target": "ActivityResultIndicator",
"target_id": indicator.id,
"old_value": oldindicator,
"value": indicator.as_dict()
})
return indicator
def update_fs_attr(data):
forward_spend = models.ActivityForwardSpend.query.filter_by(
id=data['id']
).first()
old_value = forward_spend.value
forward_spend.value = data['value']
db.session.add(forward_spend)
db.session.commit()
activity_updated(forward_spend.activity_id,
{
"user_id": current_user.id,
"mode": "update",
"target": "ActivityForwardSpend",
"target_id": forward_spend.id,
"old_value": {"value": old_value},
"value": {"value": data['value']}
}
)
return True
def update_indicator_period_attr(data):
period = models.ActivityResultIndicatorPeriod.query.filter_by(
id=data['id']).first()
oldperiod = period.as_dict()
if data['attr'].startswith("period_"):
data['value'] = isostring_date(data['value'])
if hasattr(period, data['attr']):
setattr(period, data['attr'], data['value'])
db.session.add(period)
db.session.commit()
activity_updated(
period.result_indicator.result.activity_id, {
"user_id": current_user.id,
"mode": "update",
"target": "ActivityResultIndicatorPeriod",
"target_id": period.id,
"old_value": oldperiod,
"value": period.as_dict()
})
return period
def delete_location(activity_id, location_id):
check_location = models.ActivityLocation.query.filter_by(
activity_id=activity_id,
location_id=location_id
).first()
if check_location:
db.session.delete(check_location)
db.session.commit()
activity_updated(activity_id,
{
"user_id": current_user.id,
"mode": "delete",
"target": "ActivityLocation",
"target_id": check_location.id,
"old_value": {'location_id': location_id},
"value": None
}
)
return True
return False
def add_indicator_period(data, indicator_id, commit=True):
p = models.ActivityResultIndicatorPeriod()
p.period_start = isostring_date(data.get("period_start"))
p.period_end = isostring_date(data.get("period_end"))
p.target_value = data.get("target_value")
p.target_comment = data.get("target_comment")
p.actual_value = data.get("actual_value")
p.actual_comment = data.get("actual_comment")
p.indicator_id = indicator_id
db.session.add(p)
db.session.commit()
activity_updated(
p.result_indicator.result.activity_id, {
"user_id": current_user.id,
"mode": "add",
"target": "ActivityResultIndicatorPeriod",
"target_id": p.id,
"old_value": None,
"value": p.as_dict()
})
return p
def update_finances_classification(data):
check_finance = models.ActivityFinancesCodelistCode.query.filter_by(
activityfinance_id=data["finances_id"],
codelist_id=data["attr"]
).first()
if not check_finance:
return False
old_value = check_finance.codelist_code_id
check_finance.codelist_code_id = data["value"]
db.session.add(check_finance)
db.session.commit()
activity_updated(data["activity_id"],
{
"user_id": current_user.id,
"mode": "update",
"target": "ActivityFinancesCodelistCode",
"target_id": check_finance.id,
"old_value": {data["attr"]: old_value},
"value": {data["attr"]: data["value"]}
}
)
return models.ActivityFinances.query.filter_by(id=data["finances_id"]).first()
def delete_finances(activity_id, finances_id):
print("Delete activity id {} finances id {}".format(activity_id, finances_id))
check_finance = models.ActivityFinances.query.filter_by(
activity_id=activity_id,
id=finances_id
).first()
if check_finance:
old_value = check_finance.as_dict()
db.session.delete(check_finance)
db.session.commit()
activity_updated(check_finance.activity_id,
{
"user_id": current_user.id,
"mode": "delete",
"target": "ActivityFinances",
"target_id": old_value["id"],
"old_value": old_value,
"value": None
}
)
return {"result": True}
return False
def update_activity_codelist(activitycodelistcode_id, data):
activity_codelist = models.ActivityCodelistCode.query.filter_by(
id=activitycodelistcode_id).first()
if not activity_codelist:
return False
old_value = getattr(activity_codelist, data['attr'])
setattr(activity_codelist, data['attr'], data['value'])
db.session.add(activity_codelist)
db.session.commit()
activity_updated(
activity_codelist.activity_id, {
"user_id": current_user.id,
"mode": "update",
"target": "ActivityCodelistCode",
"target_id": activity_codelist.id,
"old_value": {
data['attr']: old_value
},
"value": {
data['attr']: data['value']
}
})
return True
def make_updated_info(updated, activity, num_updated_activities):
if (updated.get("mtef_years") or updated.get("counterpart_years") or
updated.get("disbursements") or updated.get("activity")):
num_updated_activities += 1
activity_updated(activity.id)
else:
return None, num_updated_activities
msg = "Updated {} (Project ID: {}): ".format(
activity.title,
activity.id)
msgs = []
if updated.get("activity"):
msgs.append("updated activity data")
if updated.get("mtef_years"):
msgs.append("updated MTEF projections for {}".format(
", ".join(updated["mtef_years"])))
if updated.get("counterpart_years"):
msgs.append("updated counterpart funding for {}".format(
", ".join(updated["counterpart_years"])))
if updated.get("disbursements"):
msgs.append("updated disbursement data for {}".format(
", ".join(updated["disbursements"])))
return msg + "; ".join(msgs), num_updated_activities
def add_result(data, activity_id, organisation_slug=None, commit=True):
r = models.ActivityResult()
r.result_title = data.get('result_title')
r.result_description = data.get('result_description')
r.result_type = data.get('result_type')
r.activity_id = activity_id
db.session.add(r)
db.session.commit()
if data.get("indicators"):
[
add_indicator(indicator, r.id, False)
for indicator in data['indicators']
]
activity_updated(
activity_id, {
"user_id": current_user.id,
"mode": "add",
"target": "ActivityResult",
"target_id": r.id,
"old_value": None,
"value": r.as_dict()
})
return r
def delete_result_data(data):
if data['result_type'] == "ActivityResult":
r = models.ActivityResult.query.filter_by(id=data['id']).first()
activity_id = r.activity_id
elif data['result_type'] == "ActivityResultIndicator":
r = models.ActivityResultIndicator.query.filter_by(
id=data['id']).first()
activity_id = r.result.activity_id
elif data['result_type'] == "ActivityResultIndicatorPeriod":
r = models.ActivityResultIndicatorPeriod.query.filter_by(
id=data['id']).first()
activity_id = r.result_indicator.result.activity_id
activity_updated(
activity_id, {
"user_id": current_user.id,
"mode": "delete",
"target": data["result_type"],
"target_id": r.id,
"old_value": r.as_dict(),
"value": None
})
db.session.delete(r)
db.session.commit()
def add_location(activity_id, location_id):
check_location = models.ActivityLocation.query.filter_by(
activity_id=activity_id,
location_id=location_id
).first()
if not check_location:
activity_location = models.ActivityLocation()
activity_location.activity_id = activity_id
activity_location.location_id = location_id
db.session.add(activity_location)
db.session.commit()
activity_updated(activity_id,
{
"user_id": current_user.id,
"mode": "add",
"target": "ActivityLocation",
"target_id": activity_location.id,
"old_value": None,
"value": {'location_id': location_id}
}
)
return True
return False