Exemplo n.º 1
0
	def render_dynamic(self, context):
		# dynamic
		if context.main_section and ("<!-- render-jinja -->" in context.main_section) \
			or ("{{" in context.main_section):
			try:
				context["main_section"] = render_template(context.main_section,
					context)
				context["no_cache"] = 1
			except TemplateSyntaxError:
				pass
Exemplo n.º 2
0
	def render_dynamic(self, context):
		# dynamic
		is_jinja = "<!-- jinja -->" in context.main_section
		if is_jinja or ("{{" in context.main_section):
			try:
				context["main_section"] = render_template(context.main_section,
					context)
				if not "<!-- static -->" in context.main_section:
					context["no_cache"] = 1
			except TemplateSyntaxError:
				if is_jinja:
					raise
Exemplo n.º 3
0
	def get_name_from_naming_series(self):
		"""
		Get a name generated for a Batch from the Batch's naming series.
		:return: The string that was generated.
		"""
		naming_series_prefix = _get_batch_prefix()
		# validate_template(naming_series_prefix)
		naming_series_prefix = render_template(str(naming_series_prefix), self.__dict__)
		key = _make_naming_series_key(naming_series_prefix)
		name = make_autoname(key)

		return name
Exemplo n.º 4
0
	def send_auto_reply(self, communication, email):
		"""Send auto reply if set."""
		if self.enable_auto_reply:
			set_incoming_outgoing_accounts(communication)

			frappe.sendmail(recipients = [email.from_email],
				sender = self.email_id,
				reply_to = communication.incoming_email_account,
				subject = _("Re: ") + communication.subject,
				content = render_template(self.auto_reply_message or "", communication.as_dict()) or \
					 frappe.get_template("templates/emails/auto_reply.html").render(communication.as_dict()),
				reference_doctype = communication.reference_doctype,
				reference_name = communication.reference_name,
				in_reply_to = email.mail.get("Message-Id"), # send back the Message-Id as In-Reply-To
				unsubscribe_message = _("Leave this conversation"))
Exemplo n.º 5
0
    def send_auto_reply(self, communication, email):
        """Send auto reply if set."""
        if self.enable_auto_reply:
            communication.set_incoming_outgoing_accounts()

            frappe.sendmail(
                recipients=[email.from_email],
                sender=self.email_id,
                reply_to=communication.incoming_email_account,
                subject=_("Re: ") + communication.subject,
                content=render_template(self.auto_reply_message or "", communication.as_dict())
                or frappe.get_template("templates/emails/auto_reply.html").render(communication.as_dict()),
                reference_doctype=communication.reference_doctype,
                reference_name=communication.reference_name,
                message_id=communication.name,
                bulk=True,
            )
Exemplo n.º 6
0
def irs_1099_print(filters):
    if not filters:
        frappe._dict({
            "company": frappe.db.get_default("Company"),
            "fiscal_year": frappe.db.get_default("Fiscal Year")
        })
    else:
        filters = frappe._dict(json.loads(filters))

    fiscal_year_doc = get_fiscal_year(fiscal_year=filters.fiscal_year,
                                      as_dict=True)
    fiscal_year = cstr(fiscal_year_doc.year_start_date.year)

    company_address = get_payer_address_html(filters.company)
    company_tin = frappe.db.get_value("Company", filters.company, "tax_id")

    columns, data = execute(filters)
    template = frappe.get_doc("Print Format", "IRS 1099 Form").html
    output = PdfFileWriter()

    for row in data:
        row["fiscal_year"] = fiscal_year
        row["company"] = filters.company
        row["company_tin"] = company_tin
        row["payer_street_address"] = company_address
        row["recipient_street_address"], row[
            "recipient_city_state"] = get_street_address_html(
                "Supplier", row.supplier)
        row["payments"] = fmt_money(row["payments"],
                                    precision=0,
                                    currency="USD")
        pdf = get_pdf(render_template(template, row),
                      output=output if output else None)

    frappe.local.response.filename = "{0} {1} IRS 1099 Forms{2}".format(
        filters.fiscal_year, filters.company, IRS_1099_FORMS_FILE_EXTENSION)
    frappe.local.response.filecontent = read_multi_pdf(output)
    frappe.local.response.type = "download"
Exemplo n.º 7
0
def get_print_content(print_format, doctype, docname, is_escpos=False, is_raw=False):
	if is_escpos or is_raw:
		doc = frappe.get_doc(doctype, docname)
		template = frappe.db.get_value("Print Format", print_format, "html")
		content = render_template(template, {"doc": doc})
		if is_escpos:
			content.replace("<br>", "<br/>")
	else:
		content = frappe.get_print(doctype, docname, print_format)

	if is_escpos:
		printer = IOPrinter()
		printer.receipt(content)
		raw = printer.get_content()
	elif is_raw:
		raw = content
	else:
		raw = get_pdf(content)

	#frappe.msgprint("<pre>%s</pre>" %raw)
	
	raw_encoded = raw.encode()
	return b64encode(raw_encoded)
Exemplo n.º 8
0
def generate_contract_terms_display(contract, method):
    if contract.contract_terms:
        contract.contract_terms_display = render_template(
            contract.contract_terms, {"doc": contract.as_dict()})
Exemplo n.º 9
0
def make_variant_description(variant, template=None):
    #Matière première en {{Wood Species}}, {{Wood Grad}},{{Wood Width}}
    #Raw material, {{Wood Species}}, {{Wood Grad}},{{Wood Width}}
    # {u'Wood Width': u'2-5/8"'
    #, u'Wood Grade': u'Colonial - (GRADE-CN)'
    #, u'Wood Species': u'Pine'
    #, u'Thickness': u'4/4'}

    if print_debug: frappe.logger().debug("variant : " + cstr(variant.name))
    if variant.variant_of is not None:
        template = template or frappe.get_doc("Item", variant.variant_of)
        variant.set('language', [])
        for template in template.language:
            jinjaTemplate = template.description
            values = {}

            if print_debug:
                frappe.logger().debug("template.language : " +
                                      template.language)
            """
				Passe chaque attribut du variant.
					Va chercher le document Item attribute de l'attribut
					Remplace les noms d'attributs de la desccription jinja par le field_name de l'attribut
					Atribut les paramètres de traduction
					
			"""
            for d in variant.attributes:
                attribute = frappe.get_doc("Item Attribute", d.attribute)
                jinjaTemplate = jinjaTemplate.replace(
                    "{{" + d.attribute, "{{" + attribute.field_name)
                target_field = "target_name"
                source_field = "source_name"
                template_language = template.language
                if template.language == "en":
                    target_field = "source_name"
                    source_field = "target_name"
                    template_language = "fr"

                filters = {
                    'language_code': template_language,
                    source_field: d.attribute_value
                }
                target_name = frappe.db.get_value("Translation", filters,
                                                  target_field, None, False,
                                                  False, False)
                values[attribute.field_name] = target_name or d.attribute_value
                #values[d.attribute] = target_name or d.attribute_value

            if print_debug:
                frappe.logger().debug("jinjaTemplate : " + jinjaTemplate)
            if print_debug: frappe.logger().debug("values : " + cstr(values))
            if print_debug:
                frappe.logger().debug("jinjaTemplate : " + jinjaTemplate)
            if print_debug: frappe.logger().debug("values : " + cstr(values))
            description = render_template(jinjaTemplate, values)

            if print_debug:
                frappe.logger().debug("description : " + description)

            filters = {
                "parent": variant.name,
                "parentfield": "language",
                "parenttype": "Item",
                "language": template.language
            }
            #name = frappe.db.get_value("Item Language",	filters,"name",None,False,False,False)
            #if print_debug and name: frappe.logger().debug("name : " + name)
            language_description = None
            # if print_debug and name: frappe.logger().debug("language_description : " )
            # for d in self.language:
            # if d.language = template.language
            # d.db_set('description', description, update_modified = False)
            # if name:
            # if print_debug: frappe.logger().debug("if name" + name)
            # if print_debug: frappe.logger().debug("description : " + description)
            # #language_description = frappe.get_doc("Item Language", name)
            # frappe.db.set_value("Item Language", name, "description", description)
            # else:
            #if print_debug: frappe.logger().debug("Else : " )
            values = filters
            values["doctype"] = "Item Language"
            language_description = frappe.get_doc(values)
            language_description.description = description
            variant.append("language", language_description)
Exemplo n.º 10
0
 def generate_contract_terms_display(self):
     if self.contract_terms:
         self.contract_terms_display = render_template(
             self.contract_terms, {"doc": self.as_dict()})
Exemplo n.º 11
0
	def render_dynamic(self, context):
		# dynamic
		if context.main_section and "<!-- render-jinja -->" in context.main_section:
			context["main_section"] = render_template(context.main_section,
				{"doc": self, "frappe": frappe})
			context["no_cache"] = 1
    def run_testcase(self, testcase, test_suite, testcase_srno,
                     total_testcases, suite_srno, total_suites, run_name):
        try:
            start_time = time.time()
            function_result = None

            # Populate generic test result fields
            test_result_doc = frappe.new_doc("Test Result")
            test_result_doc.test_run_name = run_name
            test_result_doc.test_suite = test_suite
            test_result_doc.action = "Test Case"
            testcase_doc = frappe.get_doc("Test Case", testcase)
            testcase_doc.testcase_type = testcase_doc.testcase_type.upper()
            test_result_doc.test_case = testcase_doc.name
            test_result_doc.test_data_id = testcase_doc.test_data
            test_result_doc.test_case_status = "Passed"
            test_result_doc.test_case_execution = "Executed"
            # test result fields ended
            print("Update function execution")
            print("Update function:" + test_result_doc.test_case)
            print(
                "\033[0;36;96m>> ({suite_srno}/{total_suites}) {testcase}:{testcase_type} [{testcase_srno}/{total_testcases}] :"
                .format(suite_srno=str(suite_srno),
                        total_suites=str(total_suites),
                        testcase=str(testcase),
                        testcase_type=testcase_doc.testcase_type,
                        testcase_srno=str(testcase_srno),
                        total_testcases=str(total_testcases)))
            testdata_generator = TestDataGenerator()
            # Test Data record doc
            if testcase_doc.test_data:
                testdata_doc = frappe.get_doc("Test Data",
                                              testcase_doc.test_data)
                # cannot use insert scripts in test case data generation as doctype.name will not be recorded
                if (testdata_doc.use_script == 1):
                    test_result_doc.test_case_execution = "Execution Failed"
                    test_result_doc.execution_result = "The test data - " + testdata_doc.name + \
                        " selected is genereted using script for which record name cannot be recorded"
                    test_result_doc.test_case_status = "Failed"

                # check if test case is create and test data already created then recreate the data
                testdata_doc_test_record_name = frappe.db.get_value(
                    'Test Run Log', {
                        'test_run_name': run_name,
                        'test_data': testcase_doc.test_data
                    }, 'test_record')

                if (testdata_doc_test_record_name
                        and testcase_doc.testcase_type == "CREATE"):
                    testdata_doc_test_record_name = None
                    create_test_run_log(run_name, testcase_doc.test_data, None)
                # get record document
                new_record_doc = testdata_generator.create_testdata(
                    testcase_doc.test_data, run_name)
                error_message = None
            if (testcase_doc.testcase_type == "CREATE"):
                try:
                    if new_record_doc:
                        try:
                            new_record_doc.save()
                            testdata_doc_test_record_name = new_record_doc.name

                            create_test_run_log(run_name,
                                                testcase_doc.test_data,
                                                new_record_doc.name)
                            testdata_generator.set_record_name_child_table(
                                new_record_doc, testdata_doc, True, run_name)
                            print("\033[0;33;93m    >>> Test Data created")
                        except frappe.DuplicateEntryError as e:
                            new_record_doc = resolve_duplicate_entry_error(
                                e, testdata_doc, run_name)

                            testdata_doc_test_record_name = new_record_doc.name

                            create_test_run_log(run_name,
                                                testcase_doc.test_data,
                                                new_record_doc.name)
                            testdata_generator.set_record_name_child_table(
                                new_record_doc, testdata_doc, True, run_name)
                            print("\033[0;33;93m    >>> Test Data created")
                    else:
                        frappe.throw(
                            'Test Data {test_data} generated None doc. Please check Test Data {test_data}'
                            .format(test_data=testcase_doc.test_data))
                except Exception as e:
                    frappe.log_error(frappe.get_traceback(),
                                     ('barista-CREATE-' + testcase_doc.name +
                                      '-' + str(e))[:error_log_title_len])
                    error_message = str(e)
                    print('\033[0;31;91m   Error occurred ---', str(e))

            elif (testcase_doc.testcase_type == "UPDATE"):
                try:
                    print("Update function execution")
                    create_new = False
                    if testcase_doc.testcase_doctype != testdata_doc.doctype_name:
                        value_from_test_record_doc = frappe.db.get_value(
                            testdata_doc.doctype_name,
                            testdata_doc_test_record_name,
                            testcase_doc.test_data_docfield)

                        all_existing_docs = frappe.get_all(
                            testcase_doc.testcase_doctype,
                            filters={
                                testcase_doc.test_case_docfield:
                                value_from_test_record_doc
                            })
                        if len(all_existing_docs) == 1:
                            existing_doc_name = all_existing_docs[0]['name']
                            new_record_doc = frappe.get_doc(
                                testcase_doc.testcase_doctype,
                                existing_doc_name)
                        else:
                            test_result_doc.test_case_execution = "Execution Failed"
                            test_result_doc.execution_result = "The Test Case DocType - {testcase_doctype} with reference field {test_case_docfield} value {testdata_doc_test_record_name} records found {all_existing_docs}".format(
                                testcase_doctype=testcase_doc.testcase_doctype,
                                test_case_docfield=testcase_doc.
                                test_case_docfield,
                                testdata_doc_test_record_name=
                                testdata_doc_test_record_name,
                                all_existing_docs=str(len(all_existing_docs)))
                            test_result_doc.test_case_status = "Failed"
                            frappe.throw(test_result_doc.execution_result)

                    # create the record if already not created
                    if (new_record_doc and new_record_doc.name == None):
                        try:
                            new_record_doc.save()
                        except frappe.UniqueValidationError as e:
                            new_record_doc = resolve_unique_validation_error(
                                e, testdata_doc, run_name)
                        testdata_doc_test_record_name = new_record_doc.name

                        create_test_run_log(run_name, testdata_doc.name,
                                            new_record_doc.name)

                    # now take the fields to be updated
                    update_fields = frappe.get_list(
                        "Testdatafield", filters={"parent": testcase_doc.name})
                    fields = frappe.get_meta(
                        testcase_doc.testcase_doctype).fields

                    for update_field in update_fields:

                        update_field_doc = frappe.get_doc(
                            "Testdatafield", update_field['name'])

                        for field in fields:
                            if field.fieldname == update_field_doc.docfield_fieldname:
                                field_doc = field
                                break
                        print("Field Name:" +
                              update_field_doc.docfield_fieldname)
                        if update_field_doc.docfield_fieldname == "name":
                            new_name = update_field_doc.docfield_value
                            print("Field Value:" + new_name)
                            if update_field_doc.docfield_code_value == "Code":
                                new_name = eval(update_field_doc.docfield_code)

                            rd.rename_doc(update_field_doc.doctype_name,
                                          testdata_doc_test_record_name,
                                          new_name,
                                          force=True)

                            testdata_doc_test_record_name = new_name

                            new_record_doc = frappe.get_doc(
                                update_field_doc.doctype_name, new_name)

                            create_test_run_log(run_name, testdata_doc.name,
                                                new_record_doc.name)
                        elif new_record_doc and update_field_doc.docfield_fieldname == "docstatus":
                            new_record_doc.set(
                                update_field_doc.docfield_fieldname,
                                int(update_field_doc.docfield_value))
                        elif new_record_doc:
                            if (field_doc.fieldtype == "Table"):
                                # if it is table then user will have to add multiple rows for multiple records.
                                # each test data field will link to one record.
                                child_testdata_doc = frappe.get_doc(
                                    "Test Data",
                                    update_field_doc.linkfield_name)
                                if (child_testdata_doc.doctype_type ==
                                        "Transaction"):
                                    create_new = True
                                child_doc = testdata_generator.create_testdata(
                                    update_field_doc.linkfield_name, run_name)

                                child_doc.parentfield = field_doc.fieldname
                                child_doc.parenttype = testcase_doc.testcase_doctype
                                new_record_doc.append(field_doc.fieldname,
                                                      child_doc)

                            elif (field_doc.fieldtype
                                  in ["Link", "Dynamic Link"]
                                  and update_field_doc.docfield_code_value
                                  == "Fixed Value"):
                                new_record_doc.set(
                                    field_doc.fieldname,
                                    update_field_doc.docfield_value)

                            elif (field_doc.fieldtype
                                  in ["Link", "Dynamic Link"]):
                                child_testdata_doc = frappe.get_doc(
                                    'Test Data',
                                    update_field_doc.linkfield_name)
                                if (child_testdata_doc.doctype_type ==
                                        "Transaction"):
                                    create_test_run_log(
                                        run_name, child_testdata_doc.name,
                                        None)

                                child_doc = testdata_generator.create_testdata(
                                    update_field_doc.linkfield_name, run_name)
                                try:
                                    if child_doc:
                                        child_doc.save()
                                    else:
                                        frappe.throw(
                                            "Child Doc is None. Test Data of Child {linkfield_name}. Test Data of Parent {name}"
                                            .format(
                                                linkfield_name=update_field_doc
                                                .linkfield_name,
                                                name=testdata_doc.name))
                                except frappe.DuplicateEntryError as e:
                                    child_doc = resolve_duplicate_entry_error(
                                        e, child_testdata_doc, run_name)
                                except frappe.UniqueValidationError as e:
                                    child_doc = resolve_unique_validation_error(
                                        e, child_testdata_doc, run_name)

                                child_testdata_doc_test_record_name = child_doc.name
                                create_test_run_log(run_name,
                                                    child_testdata_doc.name,
                                                    child_doc.name)
                                new_record_doc.set(field_doc.fieldname,
                                                   child_doc.name)
                            # for rest of data type.. either it should be code or fixed value
                            elif (update_field_doc.docfield_code_value ==
                                  "Code"):
                                if update_field_doc.docfield_code and not update_field_doc.linkfield_name:
                                    new_record_doc.set(
                                        field_doc.fieldname,
                                        eval(update_field_doc.docfield_code))
                                if not update_field_doc.docfield_code and update_field_doc.linkfield_name:
                                    value = frappe.db.get_value(
                                        'Test Run Log', {
                                            'test_run_name':
                                            run_name,
                                            'test_data':
                                            update_field_doc.linkfield_name
                                        }, 'test_record')
                                    new_record_doc.set(field_doc.fieldname,
                                                       value)
                            elif new_record_doc:
                                new_record_doc.set(
                                    update_field_doc.docfield_fieldname,
                                    update_field_doc.docfield_value)
                    try:
                        if new_record_doc:
                            new_record_doc.save()
                            print("\033[0;33;93m    >>> Test Data updated")
                        else:
                            frappe.throw(
                                "Test Data {name} generated None doc. Please check Test Data {test_data}"
                                .format(name=testdata_doc.name,
                                        test_data=testcase_doc.test_data))
                    except frappe.UniqueValidationError as e:
                        new_record_doc = resolve_unique_validation_error(
                            e, testdata_doc, run_name)

                except Exception as e:
                    frappe.log_error(frappe.get_traceback(),
                                     ('barista-UPDATE-' + testcase_doc.name +
                                      '-' + str(e))[:error_log_title_len])
                    error_message = str(e)
                    print('\033[0;31;91m   Error occurred ---', str(e))

                testdata_generator.set_record_name_child_table(
                    new_record_doc, testcase_doc, create_new, run_name)
            elif (testcase_doc.testcase_type == "READ"):
                pass
            elif (testcase_doc.testcase_type == "DELETE"):
                try:
                    record_doc = frappe.get_doc(testdata_doc.doctype_name,
                                                testdata_doc_test_record_name)
                    record_doc.delete()
                except Exception as e:
                    frappe.log_error(frappe.get_traceback(),
                                     ('barista-' + testcase_doc.name +
                                      '-DELETE-' +
                                      str(e))[:error_log_title_len])
                    error_message = str(e)
                    print("\033[0;31;91m    >>> Error in deleting - " + str(e))
            elif (testcase_doc.testcase_type == "WORKFLOW"):
                try:
                    start_time = time.time()
                    current_workflow_state = None
                    if (new_record_doc and new_record_doc.name == None):
                        current_workflow_state = new_record_doc.workflow_state
                        try:
                            new_record_doc = new_record_doc.save()
                        except frappe.UniqueValidationError as e:
                            new_record_doc = resolve_unique_validation_error(
                                e, testdata_doc, run_name)
                        testdata_doc_test_record_name = new_record_doc.name

                        create_test_run_log(run_name, testdata_doc.name,
                                            new_record_doc.name)
                    apply_workflow(new_record_doc, testcase_doc.workflow_state)
                    print("\033[0;32;92m    >>> Workflow Applied")
                except Exception as e:
                    frappe.log_error(
                        frappe.get_traceback(),
                        ("""barista-WORKFLOW-{testcase_doc.name}-{str(
                        e)}-DocType-[{doctype_name}]-WorkflowState-[{current_workflow_state}]-Action-[{workflow_state}]"""
                         .format(name=testcase_doc.name,
                                 current_workflow_state=current_workflow_state,
                                 doctype_name=testdata_doc.doctype_name,
                                 workflow_state=testcase_doc.workflow_state)
                         )[:error_log_title_len])
                    error_message = str(e)
                    print(
                        "\033[0;31;91m    >>> Error in applying Workflow - " +
                        str(e))

            elif (testcase_doc.testcase_type == "FUNCTION"):
                kwargs = {}
                error_message = ""
                try:
                    for param in testcase_doc.function_parameters:
                        parameter = param.parameter
                        print("------1-----")
                        print(parameter)
                        if param.value and param.value.strip()[0] in [
                                '{', '['
                        ]:
                            value = eval(param.value)
                        else:
                            value = param.value
                        kwargs[parameter] = value
                        print("------2-----")
                        print(kwargs)
                        if param.test_data:
                            test_record_name = frappe.db.get_value(
                                'Test Run Log', {
                                    'test_run_name': run_name,
                                    'test_data': param.test_data
                                }, 'test_record')
                            print("-----3------")
                            print(test_record_name)
                            test_record_doctype = frappe.db.get_value(
                                'Test Data', param.test_data, 'doctype_name')
                            print("-----4------")
                            print(test_record_doctype)
                            test_record_doc = frappe.get_doc(
                                test_record_doctype, test_record_name)
                            print("-----5------")
                            print(test_record_doc)
                            if param.is_object == 1:
                                kwargs[parameter] = test_record_doc.as_dict()
                            else:
                                kwargs[parameter] = test_record_doc.get(
                                    param.field)
                            print("-----6------")
                            print(kwargs)
                    print("\033[0;33;93m   >>> Executing Function --",
                          testcase_doc.function_name)
                    if testcase_doc.json_parameter and testcase_doc.json_parameter.strip(
                    ) != '':
                        context_dict = {}
                        resolved_jinja = ' '
                        if testcase_doc.testcase_doctype and testcase_doc.test_data:
                            test_record_name = frappe.db.get_value(
                                'Test Run Log', {
                                    'test_run_name': run_name,
                                    'test_data': testcase_doc.test_data
                                }, 'test_record')

                            context = frappe.get_doc(
                                testcase_doc.testcase_doctype,
                                test_record_name).as_dict()
                            context_dict = {"doc": context}
                        try:
                            validate_template(testcase_doc.json_parameter)
                            resolved_jinja = render_template(
                                testcase_doc.json_parameter, context_dict)
                        except Exception as e:
                            print(
                                "\033[0;31;91m       >>>> Error in Json Parameter\n      ",
                                str(e))

                        kwargs.update(eval(str(resolved_jinja)))

                    method = testcase_doc.function_name
                    if method and '.' in method:
                        print("------method------")
                        args = []
                        function_result = frappe.get_attr(method)(*args,
                                                                  **kwargs)
                        print("\033>>>>")
                        print("\033" + str(function_result))
                    else:
                        test_data_record_name = frappe.db.get_value(
                            'Test Run Log', {
                                'test_run_name': run_name,
                                'test_data': testcase_doc.test_data
                            }, 'test_record')

                        test_record_doc = frappe.get_doc(
                            testcase_doc.testcase_doctype,
                            test_data_record_name)
                        function_result = test_record_doc.run_method(
                            method, **kwargs)
                        print("\033>>>>")
                        print("\033" + str(function_result))
                    print("\033[0;32;92m     >>> Function Executed")
                except Exception as e:
                    frappe.log_error(frappe.get_traceback(),
                                     ('barista-FUNCTION-' + testcase_doc.name +
                                      '-' + str(e))[:error_log_title_len])
                    error_message = str(e)
                    print(
                        "\033[0;31;91m       >>>> Execution of function failed\n       Error occurred :",
                        str(e))

            test_result_doc.execution_time = get_execution_time(start_time)

            assertions = frappe.get_list("Assertion",
                                         filters={'parent': testcase})

            if len(assertions) == 0:
                test_result_doc.execution_result = 'Assertions are not present in the TestCase. Please add atleast one assertion.'
                test_result_doc.test_case_status = "Failed"
                test_result_doc.save()

            for assertion in assertions:
                self.process_assertion(assertion, testcase_doc, run_name,
                                       error_message, function_result,
                                       test_result_doc)

        except Exception as e:
            frappe.log_error(frappe.get_traceback(),
                             ('barista-Critical Error-' + testcase + '-' +
                              str(e))[:error_log_title_len])
            test_result_doc.test_case_execution = "Execution Failed"
            test_result_doc.execution_result = str(e)
            test_result_doc.test_case_status = "Failed"
            test_result_doc.save()
        finally:
            print("\033[0;36;96m>> " + "Execution Ended \n\n")
            test_result_doc.save()