Exemplo n.º 1
0
def get_loyalty_programs(doc):
    ''' returns applicable loyalty programs for a customer '''
    from frappe.desk.treeview import get_children

    lp_details = []
    loyalty_programs = frappe.get_all(
        "Loyalty Program",
        fields=["name", "customer_group", "customer_territory"],
        filters={
            "auto_opt_in": 1,
            "from_date": ["<=", today()],
            "ifnull(to_date, '2500-01-01')": [">=", today()]
        })

    for loyalty_program in loyalty_programs:
        customer_groups = [
            d.value for d in get_children("Customer Group",
                                          loyalty_program.customer_group)
        ] + [loyalty_program.customer_group]
        customer_territories = [
            d.value for d in get_children("Territory",
                                          loyalty_program.customer_territory)
        ] + [loyalty_program.customer_territory]

        if (not loyalty_program.customer_group or doc.customer_group in customer_groups)\
         and (not loyalty_program.customer_territory or doc.territory in customer_territories):
            lp_details.append(loyalty_program.name)

    return lp_details
Exemplo n.º 2
0
def get_loyalty_programs(doc):
	''' returns applicable loyalty programs for a customer '''
	from frappe.desk.treeview import get_children

	lp_details = []
	loyalty_programs = frappe.get_all("Loyalty Program",
		fields=["name", "customer_group", "customer_territory"],
		filters={"auto_opt_in": 1, "from_date": ["<=", today()],
			"ifnull(to_date, '2500-01-01')": [">=", today()]})

	for loyalty_program in loyalty_programs:
		customer_groups = [d.value for d in get_children("Customer Group", loyalty_program.customer_group)] + [loyalty_program.customer_group]
		customer_territories = [d.value for d in get_children("Territory", loyalty_program.customer_territory)] + [loyalty_program.customer_territory]

		if (not loyalty_program.customer_group or doc.customer_group in customer_groups)\
			and (not loyalty_program.customer_territory or doc.territory in customer_territories):
			lp_details.append(loyalty_program.name)

	return lp_details
def get_child_assessment_groups(assessment_group):
	assessment_groups = []
	group_type = frappe.get_value("Assessment Group", assessment_group, "is_group")
	if group_type:
		from frappe.desk.treeview import get_children
		assessment_groups = [d.get("value") for d in get_children("Assessment Group",
			assessment_group) if d.get("value") and not d.get("expandable")]
	else:
		assessment_groups = [assessment_group]
	return assessment_groups
def get_child_assessment_groups(assessment_group):
    assessment_groups = []
    group_type = frappe.get_value("Assessment Group", assessment_group,
                                  "is_group")
    if group_type:
        from frappe.desk.treeview import get_children
        assessment_groups = [
            d.get("value")
            for d in get_children("Assessment Group", assessment_group)
            if d.get("value") and not d.get("expandable")
        ]
    else:
        assessment_groups = [assessment_group]
    return assessment_groups
def get_formatted_result(args,
                         get_assessment_criteria=False,
                         get_course=False):
    cond, cond1, cond2, cond3, cond4 = " ", " ", " ", " ", " "
    args_list = [args.academic_year]

    if args.course:
        cond = " and ar.course=%s"
        args_list.append(args.course)

    if args.academic_term:
        cond1 = " and ar.academic_term=%s"
        args_list.append(args.academic_term)

    if args.student_group:
        cond2 = " and ar.student_group=%s"
        args_list.append(args.student_group)

    create_total_dict = False
    group_type = frappe.get_value("Assessment Group", args.assessment_group,
                                  "is_group")
    if group_type:
        from frappe.desk.treeview import get_children
        assessment_groups = [
            d.get("value")
            for d in get_children("Assessment Group", args.assessment_group)
            if d.get("value") and not d.get("expandable")
        ]
        cond3 = " and ar.assessment_group in (%s)" % (', '.join(
            ['%s'] * len(assessment_groups)))
    else:
        assessment_groups = [args.assessment_group]
        cond3 = " and ar.assessment_group=%s"
    args_list += assessment_groups

    if args.students:
        cond4 = " and ar.student in (%s)" % (', '.join(
            ['%s'] * len(args.students)))
        args_list += args.students

    assessment_result = frappe.db.sql('''
		SELECT
			ar.student, ar.student_name, ar.academic_year, ar.academic_term, ar.program, ar.course,
			ar.assessment_plan, ar.grading_scale, ar.assessment_group, ar.student_group,
			ard.assessment_criteria, ard.maximum_score, ard.grade, ard.score
		FROM
			`tabAssessment Result` ar, `tabAssessment Result Detail` ard
		WHERE
			ar.name=ard.parent and ar.docstatus=1 and ar.academic_year=%s {0} {1} {2} {3} {4}
		ORDER BY
			ard.assessment_criteria'''.format(cond, cond1, cond2, cond3, cond4),
                                      tuple(args_list),
                                      as_dict=1)

    # create the nested dictionary structure as given below:
    # <variable_name>.<student_name>.<course>.<assessment_group>.<assessment_criteria>.<grade/score/max_score>
    # "Total Score" -> assessment criteria used for totaling and args.assessment_group -> for totaling all the assesments

    student_details = {}
    formatted_assessment_result = defaultdict(dict)
    assessment_criteria_dict = OrderedDict()
    course_dict = OrderedDict()
    total_maximum_score = None
    if not (len(assessment_groups) == 1
            and assessment_groups[0] == args.assessment_group):
        create_total_dict = True

    # add the score for a given score and recalculate the grades
    def add_score_and_recalculate_grade(result, assessment_group,
                                        assessment_criteria):
        formatted_assessment_result[result.student][result.course][assessment_group]\
         [assessment_criteria]["maximum_score"] += result.maximum_score
        formatted_assessment_result[result.student][result.course][assessment_group]\
         [assessment_criteria]["score"] += result.score
        tmp_grade = get_grade(
            result.grading_scale,
            ((formatted_assessment_result[result.student][result.course]
              [assessment_group][assessment_criteria]["score"]) /
             (formatted_assessment_result[result.student][result.course]
              [assessment_group][assessment_criteria]["maximum_score"])) * 100)
        formatted_assessment_result[result.student][result.course][assessment_group]\
         [assessment_criteria]["grade"] = tmp_grade

    # create the assessment criteria "Total Score" with the sum of all the scores of the assessment criteria in a given assessment group
    def add_total_score(result, assessment_group):
        if "Total Score" not in formatted_assessment_result[result.student][
                result.course][assessment_group]:
            formatted_assessment_result[result.student][
                result.course][assessment_group]["Total Score"] = frappe._dict(
                    {
                        "assessment_criteria": "Total Score",
                        "maximum_score": result.maximum_score,
                        "score": result.score,
                        "grade": result.grade
                    })
        else:
            add_score_and_recalculate_grade(result, assessment_group,
                                            "Total Score")

    for result in assessment_result:
        if result.student not in student_details:
            student_details[result.student] = result.student_name

        assessment_criteria_details = frappe._dict({
            "assessment_criteria":
            result.assessment_criteria,
            "maximum_score":
            result.maximum_score,
            "score":
            result.score,
            "grade":
            result.grade
        })

        if not formatted_assessment_result[result.student]:
            formatted_assessment_result[result.student] = defaultdict(dict)
        if not formatted_assessment_result[result.student][result.course]:
            formatted_assessment_result[result.student][
                result.course] = defaultdict(dict)

        if not create_total_dict:
            formatted_assessment_result[result.student][result.course][result.assessment_group]\
             [result.assessment_criteria] = assessment_criteria_details
            add_total_score(result, result.assessment_group)

        # create the total of all the assessment groups criteria-wise
        elif create_total_dict:
            if not formatted_assessment_result[result.student][result.course][
                    args.assessment_group]:
                formatted_assessment_result[result.student][result.course][
                    args.assessment_group] = defaultdict(dict)
                formatted_assessment_result[result.student][result.course][args.assessment_group]\
                 [result.assessment_criteria] = assessment_criteria_details
            elif result.assessment_criteria not in formatted_assessment_result[
                    result.student][result.course][args.assessment_group]:
                formatted_assessment_result[result.student][result.course][args.assessment_group]\
                 [result.assessment_criteria] = assessment_criteria_details
            elif result.assessment_criteria in formatted_assessment_result[
                    result.student][result.course][args.assessment_group]:
                add_score_and_recalculate_grade(result, args.assessment_group,
                                                result.assessment_criteria)

            add_total_score(result, args.assessment_group)

        total_maximum_score = formatted_assessment_result[result.student][result.course][args.assessment_group]\
         ["Total Score"]["maximum_score"]
        if get_assessment_criteria:
            assessment_criteria_dict[result.assessment_criteria] = formatted_assessment_result[result.student][result.course]\
             [args.assessment_group][result.assessment_criteria]["maximum_score"]
        if get_course:
            course_dict[result.course] = total_maximum_score

    if get_assessment_criteria and total_maximum_score:
        assessment_criteria_dict["Total Score"] = total_maximum_score

    return {
        "student_details": student_details,
        "assessment_result": formatted_assessment_result,
        "assessment_criteria": assessment_criteria_dict,
        "course_dict": course_dict
    }