def convert_column_to_string(type, column, registry=None):
return String(description=column.doc, required=not (column.nullable))
def convert_field_to_string(field, registry=None):
return String(description=field.help_text, required=not field.null)
class Arguments:
string = String(required=True)
class MiniSeries(RiotGrapheneObject):
progress = String()
losses = Int()
target = Int()
wins = Int()
class LeagueList(RiotGrapheneObject):
leagueId = String()
tier = String()
entries = List(LeagueItem)
queue = String()
name = String()
class PeopleCountType(ObjectType):
room = String()
status_in = Int()
status_out = Int()
occupancy = Int()
def convert_column_to_string(type, column, registry=None):
return String(description=getattr(column, 'doc', None),
required=not (getattr(column, 'nullable', True)))
class AcceptanceInput(InputObjectType):
date = String()
time = String()
pati_id = String()
pati_sei = String()
pati_mei = String()
pati_sei_kana = String()
pati_mei_kana = String()
pati_birth = String()
pati_sex = String()
status = String()
depart_code = String()
depart_name = String()
physic_code = String()
physic_name = String()
appoint_id = String()
appoint_time = String()
account_time = String()
medi_contents = String()
place = String()
memo = String()
class Query(ObjectType):
node = relay.Node.Field()
# Acceptance List
acceptances = List(Acceptance, status=List(String))
def resolve_acceptances(self,
info,
status=["診療待ち", "会計待ち", "会計済み"],
**kwargs):
query = Acceptance.get_query(info)
wait_post_d = req_to_xml(
req_key="tmedicalgetreq",
req_data={
"Perform_Date": "",
},
)
wait_json_d = post_request(
api_uri=orca.wait_accounting,
res_key="tmedicalgetres",
post_data=wait_post_d,
)
if "Tmedical_List_Information" in wait_json_d:
pprint(wait_json_d)
for dd in wait_json_d["Tmedical_List_Information"]:
query.filter(AcceptanceModel.date == date_to_string(
datetime.now())).filter(
AcceptanceModel.pati_id == dd["Patient_Information"]
["Patient_ID"]).filter(
AcceptanceModel.depart_code ==
dd["Department_Code"]).filter(
AcceptanceModel.physic_code ==
dd["Physician_Code"]).update(
{"status": "会計待ち"})
all_data = (
query.filter(AcceptanceModel.status.in_(status), ).filter(
AcceptanceModel.date == date_to_string(datetime.now())).all()
if len(status) != 0 else query.filter(
AcceptanceModel.date == date_to_string(datetime.now())).all())
result = [dd for dd in all_data if dd.status != "会計済み"]
for rslt in result:
ended_json_d = post_request(
api_uri=orca.ended_account,
res_key="medicalget01res",
post_data=req_to_xml(
req_key="medicalgetreq",
req_data={
"Patient_ID": rslt.pati_id,
"Perform_Date": "",
},
),
)
if ended_json_d["Api_Result"] == "K1":
# rslt.status = "会計済み"
today = date_to_string(datetime.now())
pati_id = ended_json_d["Patient_Information"]["Patient_ID"]
for medi in ended_json_d["Medical_List_Information"]:
if medi["Perform_Date"] == today:
query.filter(AcceptanceModel.date == today).filter(
AcceptanceModel.pati_id == pati_id).filter(
AcceptanceModel.depart_code ==
medi["Department_Code"]).update(
{"status": "会計済み"})
database.SessionLocal.commit()
return all_data
# Patient List
patients = List(Patient, pati_id=List(String))
def resolve_patients(self, info, pati_id=[], **kwargs):
query = Patient.get_query(info)
result = (query.filter(PatientModel.Patient_ID.in_(pati_id), ).all()
if len(pati_id) != 0 else query.all())
return result
# New Patient List
new_pati_list = List(ORPatient,
start_date=String(required=True),
end_date=String(required=True))
def resolve_new_pati_list(self, info, start_date, end_date, **kwargs):
data = diff_new(start_date, end_date)
return data
# Patient Detail
pati_detail = Field(ORPatiDetail, pati_id=String(required=True))
def resolve_pati_detail(self, info, pati_id, **kwargs):
orp = ORPatientClass(pati_id=pati_id)
p_info = orp.get_info()
data = (p_info["Patient_Information"]
if "Patient_Information" in p_info.keys() else {})
return {"data": data}
#
#
# Department
get_department = List(Department, code=List(String))
def resolve_get_department(self, info, code=[], **kwargs):
query = Department.get_query(info)
result = (query.filter(DepartmentModel.code.in_(code), ).all()
if len(code) != 0 else query.all())
return result
#
#
# Physician
get_physician = List(Physician, code=List(String))
def resolve_get_physician(self, info, code=[], **kwargs):
query = Physician.get_query(info)
result = (query.filter(PhysicianModel.code.in_(code), ).all()
if len(code) != 0 else query.all())
return result
#
#
# Physician
get_account_data = String(data=String())
def resolve_get_account_data(self, info, data="", **kwargs):
result = data
print(data)
# query = Physician.get_query(info)
# result = (
# query.filter(
# PhysicianModel.code.in_(code),
# ).all()
# if len(code) != 0
# else query.all()
# )
return result
class Extra(ObjectType):
name = String()
value = String()
class TopicListQuery(ObjectType):
topics = Field(
TopicList,
slug=String(required=True),
year=Int(),
page=Int(),
search_keys=String(),
refresh=Boolean(),
tab=String(),
exclusions=List(String),
extra=JSONString(),
)
@staticmethod
def resolve_topics(_parent, info, slug, **kwargs):
# Convert string query parameters to actual dictionary to use it in TopicListHandler
search_keys = dict(parse_qsl(
kwargs.get("search_keys"))) if kwargs.get("search_keys") else {}
manager = TopicListManager(
slug,
info.context.user,
kwargs.get("year"),
search_keys,
kwargs.get("tab"),
kwargs.get("exclusions"),
extra=kwargs.get("extra"),
)
if kwargs.get("refresh"):
manager.delete_cache(delimiter=True)
frame = LeftFrame(manager, kwargs.get("page"))
page = frame.page # May raise PermissionDenied or Http404
object_list = [
Topic(title=t["title"],
slug=t["slug"],
count=humanize_count(t.get("count")))
for t in page["object_list"]
]
paginator = {
"num_pages": page["paginator"]["num_pages"],
"page_range": page["paginator"]["page_range"]
}
tabs = (Tabs(
current=frame.tabs["current"],
available=[
Tab(name=key, safename=value)
for key, value in frame.tabs["available"].items()
],
) if frame.tabs else None)
exclusions = (Exclusions(active=frame.exclusions["active"],
available=frame.exclusions["available"])
if frame.exclusions else None)
extra = [
Extra(name=key, value=value) for key, value in frame.extra.items()
] if frame.extra else None
page_data = {
"has_next": page.get("has_next"),
"has_other_pages": page.get("has_other_pages"),
"has_previous": page.get("has_previous"),
"number": page.get("number"),
"object_list": object_list,
"paginator": Paginator(**paginator),
}
data = {
"page": Page(**page_data),
"parameters": frame.parameters,
"refresh_count": frame.refresh_count,
"year": frame.year,
"year_range": frame.year_range,
"safename": frame.safename,
"slug": frame.slug,
"slug_identifier": frame.slug_identifier,
"tabs": tabs,
"exclusions": exclusions,
"extra": extra,
}
return TopicList(**data)
class Tabs(ObjectType):
current = String()
available = List(Tab)
class Tab(ObjectType):
name = String()
safename = String()
class Topic(ObjectType):
title = String()
slug = String()
count = String()
class User(GrokObjectType):
id = ID()
name = String()
class Query(ObjectType):
hello = String()
def resolve_hello(root, info):
return "Hello, world!"
class StreamRendition(ObjectType):
name = String()
class Query(ObjectType):
hello = String()
class MediaStreamingEpisode(ObjectType):
title = String()
thumbnail = String()
url = String()
site = String()
class Query(object):
accountSearch = Field(
AccountSearchResults,
query=String(required=True),
profile=String(),
grade=Int(),
sort=String(),
page=Int(),
page_size=Int(),
)
courseSearch = Field(
CourseSearchResults,
query=String(required=True),
course_type=String(),
course_size=Int(),
availability=String(),
sort=String(),
page=Int(),
page_size=Int(),
)
sessionSearch = Field(
SessionSearchResults,
query=String(required=True),
time=String(),
sort=String(),
page=Int(),
page_size=Int(),
)
@login_required
def resolve_accountSearch(self, info, **kwargs):
# access control results based on user type
user_id = info.context.user.id
is_student = Student.objects.filter(user=user_id).exists()
is_instructor = Instructor.objects.filter(user=user_id).exists()
is_parent = Parent.objects.filter(user=user_id).exists()
if is_student:
profiles = ["ADMIN", "INSTRUCTOR", "PARENT"]
elif is_instructor:
profiles = ["ADMIN", "INSTRUCTOR", "PARENT", "STUDENT"]
elif is_parent:
profiles = ["ADMIN", "INSTRUCTOR", "STUDENT"]
else: # admin
profiles = ["ADMIN", "PARENT", "INSTRUCTOR", "STUDENT"]
# query on profile filter if set else all account types
profile = kwargs.get("profile", None)
if profile in profiles: # only use profile if accessible
profiles = [profile]
# define filter param to django manager/object mappings
filterToSearch = {
"STUDENT": getattr(StudentManager, "search"),
"INSTRUCTOR": getattr(InstructorManager, "search"),
"PARENT": getattr(ParentManager, "search"),
"ADMIN": getattr(AdminManager, "search"),
}
filterToModel = {
"STUDENT": Student.objects,
"INSTRUCTOR": Instructor.objects,
"PARENT": Parent.objects,
"ADMIN": Admin.objects,
}
# set results and query
results = Student.objects.none()
query = kwargs.get("query")
# iterate over account types to search
for profile in profiles:
profile_results = filterToModel[profile].none()
# filter for ADMIN if profile is admin type
admin_profile = None
if profile.lower() in [t[0] for t in Admin.TYPE_CHOICES]:
admin_profile = profile.lower()
profile = "ADMIN"
for token in query.split():
if filterToSearch.get(profile):
profile_results = filterToSearch[profile](
filterToModel[profile], token, profile_results)
# filter for admin types
if admin_profile is not None:
profile_results = profile_results.filter(
admin_type=admin_profile)
if profile == "STUDENT":
# filter for grade if STUDENT
try:
grade = int(kwargs.get("grade", None))
if 1 <= grade and grade <= 13:
profile_results = profile_results.filter(grade=grade)
except:
pass
# students in instructor's courses
if is_instructor:
courses = Course.objects.filter(instructor=user_id)
student_ids = set()
for course in courses:
student_ids.update(course.enrollment_list)
profile_results = profile_results.filter(
user_id__in=student_ids)
# parent's students
if is_parent:
parent = Parent.objects.get(user=user_id)
profile_results = profile_results.filter(
user_id__in=parent.student_list)
# parent
if profile == "PARENT":
# parents of students in instructor's courses
if is_instructor:
# find students
courses = Course.objects.filter(instructor=user_id)
student_ids = set()
for course in courses:
student_ids.update(course.enrollment_list)
# students' parents
parent_ids = set()
for student_id in student_ids:
student = Student.objects.get(user_id=student_id)
if student.primary_parent:
parent_ids.add(student.primary_parent.user.id)
if student.secondary_parent:
parent_ids.add(student.secondary_parent.user.id)
profile_results = profile_results.filter(
user_id__in=parent_ids)
# student's parents
if is_student:
student = Student.objects.get(user=user_id)
primary_parent_id = (None if not student.primary_parent
else student.primary_parent.user.id)
secondary_parent_id = (None if not student.secondary_parent
else student.primary_parent.user.id)
profile_results = profile_results.filter(
user_id__in=[primary_parent_id, secondary_parent_id])
results = chain(results, profile_results)
# sort results
sort = kwargs.get("sort", None)
if sort is not None:
if sort == "alphaAsc":
results = sorted(results,
key=attrgetter("user.first_name",
"user.last_name"))
elif sort == "alphaDesc":
results = sorted(
results,
key=attrgetter("user.first_name", "user.last_name"),
reverse=True,
)
elif sort == "idAsc":
results = sorted(results, key=lambda obj: obj.user.id)
elif sort == "idDesc":
results = sorted(results,
key=lambda obj: obj.user.id,
reverse=True)
elif sort == "updateAsc":
results = sorted(results, key=lambda obj: obj.updated_at)
elif sort == "updateDesc":
results = sorted(results,
key=lambda obj: obj.updated_at,
reverse=True)
results = list(results)
total = len(results)
results = paginate(results, kwargs.get("page", None),
kwargs.get("page_size", None))
return AccountSearchResults(results=results, total=total)
@login_required
def resolve_courseSearch(self, info, **kwargs):
results = Course.objects.none()
query = kwargs.get("query")
for word in query.split():
dayOfWeekDic = {
"monday": "MON",
"tuesday": "TUE",
"wednesday": "WED",
"thursday": "THU",
"friday": "FRI",
"saturday": "SAT",
"sunday": "SUN",
}
# date check
if dayOfWeekDic.get(word.lower()):
word = dayOfWeekDic.get(word.lower())
results = Course.objects.search(word, results)
# course filter
course_type = kwargs.get("course_type", None)
if course_type is not None:
if course_type == "tutoring":
results = results.filter(max_capacity=1)
if course_type == "group":
results = results.filter(max_capacity__lte=5,
max_capacity__gt=1)
if course_type == "class":
results = results.filter(max_capacity__gt=5)
# size filter
course_size = kwargs.get("course_size", None)
if course_size is not None:
course_size = int(course_size)
course_ids = []
for course in results:
curr_size = len(Enrollment.objects.filter(course=course.id))
if curr_size <= course_size:
course_ids.append(course.id)
results = Course.objects.filter(id__in=course_ids)
# availability filter
availability = kwargs.get("availability", None)
if availability is not None and (availability == "open"
or availability == "filled"):
# calculate availability
course_ids = []
for course in results:
capacity = len(Enrollment.objects.filter(course=course.id))
if availability == "open" and capacity < course.max_capacity:
course_ids.append(course.id)
if availability == "filled" and capacity >= course.max_capacity:
course_ids.append(course.id)
results = Course.objects.filter(id__in=course_ids)
# sort results
sort = kwargs.get("sort", None)
if sort is not None:
sortToParameter = {
"dateAsc": "start_date",
"dateDesc": "-start_date",
"timeAsc": "start_time",
"timeDesc": "-start_time",
}
if sortToParameter.get(sort):
results = results.order_by(sortToParameter[sort])
results = list(results)
total = len(results)
results = paginate(results, kwargs.get("page", None),
kwargs.get("page_size", None))
return CourseSearchResults(results=results, total=total)
@login_required
def resolve_sessionSearch(self, info, **kwargs):
results = Session.objects.all()
query = kwargs.get("query", None)
if query is not None:
for word in query.split():
results = Session.objects.search(word, results)
# time filter
time = kwargs.get("time", None)
if time is not None: # all is default
if time == "future":
results = results.filter(start_datetime__gte=datetime.utcnow())
elif time == "past":
results = results.filter(start_datetime__lte=datetime.utcnow())
elif time == "today":
results = results.filter(
start_datetime__date=datetime.utcnow())
# sort results
sort = kwargs.get("sort", None)
if sort is not None:
sortToParameter = {
"timeAsc": "start_datetime",
"timeDesc": "-start_datetime",
}
if sortToParameter.get(sort):
results = results.order_by(sortToParameter[sort])
results = list(results)
total = len(results)
results = paginate(results, kwargs.get("page", None),
kwargs.get("page_size", None))
return SessionSearchResults(results=results, total=total)
class Arguments:
name = String()
email = String()
city = String()
state = String()
class Query(ObjectType):
all_orders = List(OrderType)
all_salary_in_month = Field(UsersMonthsType, user_id=IntID(), date=String(required=True), company_filter=IntID())
user_salary_info = Field(UserSalaryInfoType, date=String(required=True))
user_salary_bonus_info = List(BonusType, date=String())
last_salary_month = String()
all_grade_coefficients = List(GradeCoefficientType)
b7_export = String()
paged_salary_payments = Field(PagedSalaryPayments, paged=PagedInput())
accruals = List(CompanyAccrualType)
user_salary_sum_avg_year = Field(SumAvgYearType, date=String())
def resolve_all_salary_in_month(self, info, user_id=None, date=None, company_filter=None):
if user_id != info.context.user.id and not info.context.user.has_perm('users.view_salary'):
raise SngyException('Недостаточно прав')
flush_cache()
date = Date(int('20' + date[-2:]), int(date[:-2]), 1)
if date > get_last_salary_month().date():
calculation_result = calculation_all_salary_in_month(user_id, company_filter)
users = calculation_result['users']
classifier = calculation_result['classifier']
attributes = calculation_result['attributes']
else:
users = {}
r_totals = {}
if user_id:
try:
users[user_id] = pickle.loads(SalaryArchive.objects.get(worker_id=user_id, date=date).object)
except SalaryArchive.DoesNotExist:
pass
else:
archive = SalaryArchive.objects.filter(date=date)
users = {a.worker_id: pickle.loads(a.object) for a in archive}
for u in users:
for obj in users[u][1].items():
try:
r_totals[obj[0]] += float(obj[1])
except KeyError:
r_totals[obj[0]] = 0
r_totals[obj[0]] += float(obj[1])
for k in r_totals:
r_totals[k] = '{0:.2f}'.format(r_totals[k])
r_totals = TotalsType(**r_totals)
result = []
db_users = {u.id: u for u in User.objects.select_related('occupation')}
for u in users:
user = db_users[u]
months = []
for m in users[u][0]:
totals = TotalsType(**users[u][0][m])
months.append(MonthType(month=m, totals=totals))
totals = TotalsType(**users[u][1])
bonus = users[u][2]
advance = users[u][3]
result.append(UserMonthsType(user=user, months=months, totals=totals, bonus=bonus, advance=advance))
if date > get_last_salary_month().date():
r_totals = {}
for a in attributes:
if isinstance(getattr(classifier.storage.totals, a), timedelta):
r_totals[a] = '{0:.2f}'.format(getattr(classifier.storage.totals, a).total_seconds() / 3600)
else:
r_totals[a] = getattr(classifier.storage.totals, a)
r_totals = TotalsType(**r_totals)
return UsersMonthsType(users=result, totals=r_totals)
def resolve_user_salary_info(self, info, date):
fields = ['general', 'welding', 'experience', 'etech', 'schematic', 'initiative', 'discipline']
date = Date(int('20' + date[-2:]), int(date[:-2]), 1)
if date > get_last_salary_month().date():
date = get_salary_limits(get_last_salary_month())[1]
str_month = str(date.year) + str(date.month)
work_hours = work_hours_in_month(str_month)
costs = cost_hours(info.context.user, str_month)
salary = info.context.user.occupation.salary
base = info.context.user.occupation.base
advance = info.context.user.occupation.advance
if not salary:
coefficients = {obj.name: obj.value for obj in GlobalCoefficient.objects.all() if obj.name in fields}
my_coefficients = info.context.user.coefficients
for f in fields:
coefficients['my_' + f] = getattr(my_coefficients, f)
base_cost_hour = my_coefficients.avg * my_coefficients.max_hour
return UserSalaryInfoType(salary=salary, base=base, cost_hour=costs['salary'], advance=advance,
work_hours_in_month=work_hours, avg=my_coefficients.avg,
base_cost_hour=base_cost_hour, **coefficients)
return UserSalaryInfoType(salary=salary, base=base, cost_hour=costs['salary'], advance=advance,
work_hours_in_month=work_hours)
else:
user_data = pickle.loads(SalaryArchive.objects.get(date=date, worker=info.context.user).object)
if len(user_data) > 4:
salary = user_data[4]
base = user_data[5]
advance = user_data[3]
cost_hour = user_data[13]
base_cost_hour = user_data[14]
str_month = str(date.year) + str(date.month)
work_hours = work_hours_in_month(str_month)
my_coefficients = user_data[10]
if my_coefficients:
coefficients = pickle.loads(CoefficientsArchive.objects.get(date=date).global_coefficients)
coefficients = {c['name']: c['value'] for c in coefficients if c['name'] in fields}
for f in fields:
coefficients['my_' + f] = my_coefficients[f]
avg = user_data[12]
return UserSalaryInfoType(salary=salary, base=base, advance=advance, cost_hour=cost_hour,
base_cost_hour=base_cost_hour, work_hours_in_month=work_hours, avg=avg,
**coefficients)
return UserSalaryInfoType(salary=salary, base=base, advance=advance, cost_hour=cost_hour,
base_cost_hour=base_cost_hour, work_hours_in_month=work_hours)
else:
return UserSalaryInfoType()
def resolve_user_salary_bonus_info(self, info, date=None):
if date:
last_day = monthrange(year=int('20' + date[-2:]), month=int(date[:-2]))[1]
date = Date(year=int('20' + date[-2:]), month=int(date[:-2]), day=last_day)
bonuses = Bonus.objects.filter(user=info.context.user, month=date)
return bonuses
def resolve_user_salary_sum_avg_year(self, info, date):
end = Date.today()
year = int('20' + date[-2:])
if year < end.year:
end = end.replace(year=year, month=12, day=31)
begin = end.replace(day=1, month=1)
sum_year = 0
archive = SalaryArchive.objects.filter(worker=info.context.user, date__range=(begin, end))
for d in archive:
data = pickle.loads(d.object)
totals = data[1]
sum_year += sum(totals[mn] for mn in totals if mn.endswith('_money') and mn not in ('ideal_grade_money', 'negative_grade_money'))
sum_year -= totals['negative_grade_money']
sum_year += data[2] # бонус
sum_year += totals['private_car'] + totals['duty_car']
avg_year = sum_year / end.month
return SumAvgYearType(sum_year=sum_year, avg_year=avg_year)
@permission_required('users.view_order')
def resolve_all_orders(self, info):
return Order.objects.all()
def resolve_last_salary_month(self, info):
date = get_salary_limits(get_last_salary_month())[1]
return str(date.year) + str(date.month)
def resolve_all_grade_coefficients(self, info):
return GradeCoefficient.objects.all()
@permission_required('salary.generate_b7_export')
def resolve_b7_export(self, info):
return generate_b7_export()
@permission_required('salary.can_view_salarypayment')
def resolve_paged_salary_payments(self, info, paged, **kwargs):
paged = {k: v for k, v in paged.items() if v is not None}
result = SalaryPayment.objects.list_paged_payments(**kwargs, **paged)
keys = ('salary_payments', 'total_count')
return PagedSalaryPayments(**dict(zip(keys, result)))
@permission_required('users.view_salary')
def resolve_accruals(self, info):
users = calculation_all_salary_in_month()['users']
companies = {c.id: [] for c in Company.objects.all()}
companies['cash'] = []
user_objects = {u.id: u for u in User.objects.all()}
for id in users:
advance = users[id][3]
bonus = users[id][2]
# users[id][1] - totals по пользователю
main_part = sum(users[id][1][m] for m in users[id][1] if m.endswith('_money') and m not in
('ideal_grade_money', 'negative_grade_money', 'vacation_money')) + bonus - advance - \
users[id][1]['negative_grade_money']
auto = users[id][1]['private_car'] + users[id][1]['duty_car']
other = users[id][1]['vacation_money']
salary_payments = SalaryPayment.objects.filter(user_id=id, company__minimize_salary=True)
for sp in salary_payments:
if sp.company == user_objects[id].occupation.main_company:
main_part = main_part - sp.amount
else:
main_part = main_part - (sp.advance + sp.amount)
if main_part < 0:
main_part_result = main_part
else:
main_part_result = sp.amount
companies[sp.company_id].append(AccrualType(user=user_objects[id].short_name, bonus=0,
advance=sp.advance, main_part=main_part_result))
positions = Position.objects.filter(user=id, company__minimize_salary=False)
if positions:
companies[positions[0].company_id].append(AccrualType(user=user_objects[id].short_name,
bonus=bonus, advance=advance, main_part=main_part))
else:
if not auto and not other and main_part < 0:
pass
else:
companies['cash'].append(AccrualType(user=user_objects[id].short_name, auto=auto, other=other,
bonus=bonus, advance=advance, main_part=main_part))
result = []
for c_id in companies:
companies[c_id] = sorted(companies[c_id], key=lambda obj: obj.user) # Сортировка
if c_id != 'cash':
result.append(CompanyAccrualType(id=c_id, name=Company.objects.get(id=c_id).client.name, accruals=companies[c_id]))
else:
result.append(CompanyAccrualType(id=c_id, name='Наличными', accruals=companies[c_id]))
return result
class LeagueEntry(LeagueItem):
queueType = String()
leagueId = String()
tier = String()
class Input(object):
"""
Input to create a trading account. Right now it's only a name.
"""
name = String()
class Arguments:
username = String()
password = String()
class GDataPoint(ObjectType):
"""
GraphQL definition of the DataPoint above
"""
date = String()
value = Float()
class Viewer(ObjectType, PollQueries):
id = GlobalID()
user = Field(UserNode, jwt_token=String())
class Meta:
interfaces = (TokensInterface, )
class GUserBank(DjangoObjectType):
"""
GraphQL representation of a UserBank
"""
balance = Float()
income = Float()
name = String()
outcome = Float()
history = List(GDataPoint, args={'start': Argument(NonNull(String))})
class Meta(object):
"""
Meta Model for UserBank
"""
model = UserBank
only_fields = ('id', 'balance', 'income', 'outcome')
interfaces = (relay.Node, )
@staticmethod
def resolve_history(data, args, context, _info):
"""
Builds the financial history for the user
"""
start = args['start']
end = datetime.datetime.now().strftime("%Y-%m-%d")
response = context.plaid.Transactions.get(data.access_token,
start_date=start,
end_date=end)
transactions = response['transactions']
value = GUserBank.resolve_balance(data, {}, context, None)
value_list = [DataPoint(end, value)]
for transaction in transactions:
value = value - transaction['amount']
if not value_list[-1].date == transaction['date']:
value_list.append(DataPoint(transaction['date'], value))
return value_list
@staticmethod
def resolve_balance(data, _args, context, _info):
"""
Finds the current balance of the user
"""
balances = context.plaid.Accounts.balance.get(
data.access_token)['accounts']
extracted_balances = [
((b['balances']['available'] if b['balances']['available']
is not None else b['balances']['current']) *
(1 if b['subtype'] == 'credit card' else -1)) for b in balances
]
balance = sum(extracted_balances)
return float(balance)
@staticmethod
def resolve_name(data, _args, context, _info):
"""
Returns the name of the bank account
"""
name = context.plaid.Accounts.get(
data.access_token)['accounts'][0]['name']
return name
@staticmethod
def resolve_income(data, _args, context, _info):
"""
Calculates the income a user has per month
"""
start = (datetime.datetime.now() -
datetime.timedelta(days=30)).strftime("%Y-%m-%d")
end = datetime.datetime.now().strftime("%Y-%m-%d")
response = context.plaid.Transactions.get(
data.access_token,
start_date=start,
end_date=end,
)
transactions = response['transactions']
plus = sum(
filter(lambda x: x > 0, [tx['amount'] for tx in transactions]))
return float(plus)
@staticmethod
def resolve_outcome(data, _args, context, _info):
"""
Calculates the expenses a user has
"""
start = (datetime.datetime.now() -
datetime.timedelta(days=30)).strftime("%Y-%m-%d")
end = datetime.datetime.now().strftime("%Y-%m-%d")
response = context.plaid.Transactions.get(
data.access_token,
start_date=start,
end_date=end,
)
transactions = response['transactions']
plus = sum(
filter(lambda x: x < 0, [tx['amount'] for tx in transactions]))
return float(plus)
def mutate(self, info, string):
storage.append(string)
return String(string=string)
class QueryType(ObjectType):
class Meta:
name = "Query"
description = "..."
# User
login = Field(Login,
email=String(required=True),
password=String(required=True),
remember_me=Boolean(),
required=True)
# Company
company = Field(CompanyType, _id=ID(required=True))
company_list = List(CompanyType)
company_members = List(UserType, company_id=ID(required=True))
# Product
product_category_list = List(ProductCategoryType)
product_category = Field(ProductCategoryType, _id=ID(required=True))
product = Field(ProductType, _id=ID(required=True))
product_list = List(ProductType, company_id=ID(required=True))
# Contact
customer = Field(CustomerType, _id=ID(required=True))
customer_list = List(CustomerType, company_id=ID(required=True))
# Campaign
campaign = Field(CampaignType, _id=ID(required=True))
campaign_list = List(CampaignType, company_id=ID(required=True))
# RESOLVERS
@staticmethod
def resolve_login(root, info, email, password, remember_me=False):
user = UserModel.find_by_email(email)
if user and check_password_hash(user.password, password):
return Login(user=user, token=create_tokens(user, remember_me))
raise Exception("email or password were incorrect")
@staticmethod
def resolve_company(root, info, _id):
return CompanyModel.find_by_id(_id)
@staticmethod
def resolve_company_list(root, info):
return CompanyModel.find_all()
@staticmethod
def resolve_company_members(root, info, company_id):
return UserModel.find_many_by("company", company_id)
@staticmethod
def resolve_product_category_list(root, info):
return ProductCategoryModel.find_all()
@staticmethod
def resolve_product_category(root, info, _id):
return ProductCategoryModel.find_by_id(_id)
@staticmethod
def resolve_product_list(root, info, company_id):
return ProductModel.find_many_by(company_id)
@staticmethod
def resolve_product(root, info, _id):
return ProductModel.find_by_id(_id)
@staticmethod
def resolve_customer(root, info, _id):
return CustomerModel.find_by_id(_id)
@staticmethod
def resolve_customer_list(root, info, company_id):
return CustomerModel.find_many_by(company_id)
@staticmethod
def resolve_campaign(root, info, _id):
return CampaignModel.find_by_id(_id)
@staticmethod
def resolve_campaign_list(root, info, company_id):
return CampaignModel.find_many_by(company_id)
