def diseaseFinder(request):
patient = Patient.objects.get(id=int(request.GET.get('patient')))
highTmp = bool(request.GET.get("hadTemp"))
if highTmp==False:
tmp = 36
else:
tmp = request.GET.get("temp")
if tmp == "":
tmp = 36
else:
print(tmp)
tmp = int(tmp)
diagnosis = Diagnosis.objects.create(doctor=request.user,patient=patient,temp=tmp,highTemp=bool(highTmp))
symptoms = request.GET.get('symptoms').split(',')
for synid in symptoms:
if synid !="":
diagnosis.symptoms.add(Symptom.objects.get(id=int(synid)))
diagnosis.save()
helper = RezonerHelper()
rulesId = request.GET.get('rules')
if rulesId != None:
rulesId = rulesId.split(',')
else:
return HttpResponse(json.dumps({"disease":"None","probability":'N/A'}), content_type="application/json")
rules = Rule.objects.filter(ruletype=Rule.diseaseRule).order_by('-priority')
engRules = []
for rule in rules:
if str(rule.id) in rulesId:
engRules.append(json.loads(rule.content))
my_file = Path("./diagnostics/custom_variables_d.py")
if my_file.is_file():
module = import_module('.custom_variables_d',package="diagnostics")
for disease in Disease.objects.all():
print(disease.name)
diseaseVariables = module.CustomDiseaseVariables(diagnosis,disease,helper)
diseaseActions = DiseaseActions(helper,diseaseVariables)
run_all(rule_list=engRules,
defined_variables=diseaseVariables,
defined_actions=diseaseActions,
stop_on_first_trigger=False
)
print("Best:"+str(helper.diseaseName))
print("Best:"+str(helper.bestPercent))
print("====")
else:
for disease in Disease.objects.all():
diseaseVariables = DiseaseVariables(diagnosis,disease,helper)
diseaseActions = DiseaseActions(helper,diseaseVariables)
run_all(rule_list=engRules,
defined_variables=diseaseVariables,
defined_actions=diseaseActions,
stop_on_first_trigger=False
)
result = {}
result['disease'] = helper.diseaseName
result['probability'] = helper.bestPercent
diagnosis.delete()
return HttpResponse(json.dumps(result), content_type="application/json")
def _assert_rule_executed(self, product_for_order, product_not_for_order):
# GIVEN
mommy.make(ProductOrder,
product=product_for_order,
expiration_date=datetime.datetime.now() +
timezone.timedelta(days=4))
mommy.make(ProductOrder,
product=product_not_for_order,
expiration_date=datetime.datetime.now() +
timezone.timedelta(days=4))
self.assertFalse(
ProductOrder.objects.filter(product=product_for_order,
quantity=40).exists())
self.assertFalse(
ProductOrder.objects.filter(product=product_not_for_order,
quantity=40).exists())
rules = self._get_rules()
# WHEN
for product in Product.objects.all():
run_all(rule_list=rules,
defined_variables=ProductVariables(product),
defined_actions=ProductActions(product),
stop_on_first_trigger=True)
# THEN
self.assertTrue(
ProductOrder.objects.filter(product=product_for_order,
quantity=40).exists())
self.assertFalse(
ProductOrder.objects.filter(product=product_not_for_order,
quantity=40).exists())
def diseaselistPage(request):
template = loader.get_template("diseaseListPage.html")
diseasesRaw = []
diseases = []
diagnosis = DiagnosedSymptomes()
symptoms = request.GET.get('symptoms').split(',')
for synid in symptoms:
diagnosis.symptoms.append(Symptom.objects.get(id=int(synid)))
rules = Rule.objects.filter(ruletype=Rule.findDiseaseRule).order_by('-priority')
engRules = []
for rule in rules:
engRules.append(json.loads(rule.content))
for disease in Disease.objects.all():
#print(disease.name)
diseaseActions = DiseasesActions()
run_all(rule_list=engRules,
defined_variables=DiseasesVariables(diagnosis,disease),
defined_actions=diseaseActions,
stop_on_first_trigger=True
)
#print(diseaseActions.show)
if diseaseActions.show:
diseasesRaw.append((disease,diseaseActions.correctSyndromes))
for rawDis in sorted(diseasesRaw,key= lambda element:element[1],reverse=True):
diseases.append(rawDis[0])
return HttpResponse(template.render({'diseases':diseases,'user':request.user}))
def test_run_all_some_rule_triggered(self, *args):
"""
By default, does not stop on first triggered rule.
Returns True if any rule was triggered, otherwise False
"""
rule1 = {'conditions': 'condition1', 'actions': 'action name 1'}
rule2 = {'conditions': 'condition2', 'actions': 'action name 2'}
variables = BaseVariables()
actions = BaseActions()
def return_action1(rule, *args, **kwargs):
return rule['actions'] == 'action name 1'
engine.run.side_effect = return_action1
result = engine.run_all([rule1, rule2], variables, actions)
self.assertTrue(result)
self.assertEqual(engine.run.call_count, 2)
# switch order and try again
engine.run.reset_mock()
result = engine.run_all([rule2, rule1], variables, actions)
self.assertTrue(result)
self.assertEqual(engine.run.call_count, 2)
def test_run_all_some_rule_triggered(self, *args):
"""
By default, does not stop on first triggered rule. Returns a list of
booleans indicating whether each rule was triggered.
"""
rule1 = {'conditions': 'condition1', 'actions': 'action name 1'}
rule2 = {'conditions': 'condition2', 'actions': 'action name 2'}
variables = BaseVariables()
actions = BaseActions()
def return_action1(rule, *args, **kwargs):
return rule['actions'] == 'action name 1'
engine.run.side_effect = return_action1
results = engine.run_all([rule1, rule2], variables, actions)
self.assertEqual(results, [True, False])
self.assertEqual(engine.run.call_count, 2)
# switch order and try again
engine.run.reset_mock()
results = engine.run_all([rule2, rule1], variables, actions)
self.assertEqual(results, [False, True])
self.assertEqual(engine.run.call_count, 2)
def test_should_execute_rules_1(self):
# GIVEN
product_for_sale = mommy.make(Product, current_inventory=21, price=200)
product_not_for_sale_1 = mommy.make(Product,
current_inventory=20,
price=200)
product_not_for_sale_2 = mommy.make(Product,
current_inventory=21,
price=200)
mommy.make(ProductOrder,
product=product_for_sale,
expiration_date=timezone.now() + timezone.timedelta(days=4))
mommy.make(ProductOrder,
product=product_not_for_sale_1,
expiration_date=timezone.now() + timezone.timedelta(days=4))
mommy.make(ProductOrder,
product=product_not_for_sale_2,
expiration_date=timezone.now() + timezone.timedelta(days=5))
rules = self._get_rules()
# WHEN
for product in Product.objects.all():
run_all(rule_list=rules,
defined_variables=ProductVariables(product),
defined_actions=ProductActions(product),
stop_on_first_trigger=True)
# THEN
product_for_sale.refresh_from_db()
product_not_for_sale_1.refresh_from_db()
product_not_for_sale_2.refresh_from_db()
self.assertEqual(product_for_sale.price, 150)
self.assertEqual(product_not_for_sale_1.price, 200)
self.assertEqual(product_not_for_sale_2.price, 200)
def patientreportList(request):
template = loader.get_template("patientListPage.html")
patients = []
rulesId = request.GET.get('rules').split(',')
rules = Rule.objects.filter(ruletype=Rule.patientInfoRule).order_by('-priority')
engRules = []
for rule in rules:
if str(rule.id) in rulesId:
engRules.append(json.loads(rule.content))
my_file = Path("./diagnostics/custom_variables_p.py")
if my_file.is_file():
module = import_module('.custom_variables_p',package="diagnostics")
for patient in Patient.objects.all():
patientActions = PatientActions()
run_all(rule_list=engRules,
defined_variables=module.CustomPatientVariables(patient),
defined_actions=patientActions,
stop_on_first_trigger=True
)
if patientActions.show:
patients.append(patient)
else:
for patient in Patient.objects.all():
patientActions = PatientActions()
run_all(rule_list=engRules,
defined_variables=PatientVariables(patient),
defined_actions=patientActions,
stop_on_first_trigger=True
)
if patientActions.show:
patients.append(patient)
return HttpResponse(template.render({'patients':patients,'user':request.user}))
def test_run_with_no_conditions(self):
actions = [{'name': 'action_with_no_params'}]
rule = {'actions': actions}
result = run_all(rule_list=[rule],
defined_variables=SomeVariables(),
defined_actions=SomeActions())
self.assertTrue(result)
def test_run_all_stop_on_first(self, *args):
rule1 = {'conditions': 'condition1', 'actions': 'action name 1'}
rule2 = {'conditions': 'condition2', 'actions': 'action name 2'}
variables = BaseVariables()
actions = BaseActions()
result = engine.run_all([rule1, rule2], variables, actions,
stop_on_first_trigger=True)
self.assertEqual(result, True)
self.assertEqual(engine.run.call_count, 1)
engine.run.assert_called_once_with(rule1, variables, actions, None)
def test_run_all_stop_on_first(self, *args):
rule1 = {'conditions': 'condition1', 'actions': 'action name 1'}
rule2 = {'conditions': 'condition2', 'actions': 'action name 2'}
variables = BaseVariables()
actions = BaseActions()
result = engine.run_all([rule1, rule2], variables, actions,
stop_on_first_trigger=True)
self.assertEqual(result, True)
self.assertEqual(engine.run.call_count, 1)
engine.run.assert_called_once_with(rule1, variables, actions)
def test_should_get_all_actions_results(self):
result = run_all(**self._get_params_for_run_all())
self.assertEqual(result, [
{
'some_action_1': 'fooValue'
},
{
'some_action_2': 'foobarValue',
'some_action_3': None
},
])
def diseaseSyndList(request,disease_name):
template = loader.get_template("syndromeListPage.html")
symptoms = []
disease = Disease.objects.get(name=disease_name)
rules = Rule.objects.filter(ruletype=Rule.findDiseaseSymptomsRule).order_by('-priority')
engRules = []
for rule in rules:
engRules.append(json.loads(rule.content))
for symptom in Symptom.objects.all():
syndromeActions = SyndromeActions()
run_all(rule_list=engRules,
defined_variables=SyndromeVariables(disease,symptom),
defined_actions=syndromeActions,
stop_on_first_trigger=True
)
if syndromeActions.show:
if syndromeActions.top:
symptoms.insert(0,symptom)
else:
symptoms.append(symptom)
return HttpResponse(template.render({'symptoms':symptoms,'user':request.user}))
def test_run_all_some_rule_triggered(self, *args):
""" By default, does not stop on first triggered rule. Returns True if
any rule was triggered, otherwise False
"""
rule1 = {'conditions': 'condition1', 'actions': 'action name 1'}
rule2 = {'conditions': 'condition2', 'actions': 'action name 2'}
variables = BaseVariables()
actions = BaseActions()
def return_action1(rule, *args, **kwargs):
return rule['actions'] == 'action name 1'
engine.run.side_effect = return_action1
result = engine.run_all([rule1, rule2], variables, actions)
self.assertTrue(result)
self.assertEqual(engine.run.call_count, 2)
# switch order and try again
engine.run.reset_mock()
result = engine.run_all([rule2, rule1], variables, actions)
self.assertTrue(result)
self.assertEqual(engine.run.call_count, 2)
def alergyDetection(request):
meds = []
medicines = request.GET.get('medicines').split(',')
for medicine in medicines:
meds.append(Medicine.objects.get(id=int(medicine)))
patientId = int(request.GET.get('patient'))
patient = Patient.objects.get(id=patientId)
rules = Rule.objects.filter(ruletype=Rule.alergyRule).order_by('-priority')
engRules = []
result = False
for rule in rules:
engRules.append(json.loads(rule.content))
for medicine in meds:
alergyActions = AlergyActions()
run_all(rule_list=engRules,
defined_variables=AlergyVariables(patient,medicine),
defined_actions=alergyActions,
stop_on_first_trigger=True
)
if alergyActions.alarm:
result = True
break
data = {"alarm":result}
return HttpResponse(json.dumps(data), content_type="application/json")
def run_address_rule(address_info):
global rule_info
# 清空上次保留的数据
rule_info = {
'span_level': 0,
'CAPTCHA_phone': '',
'binding_phone': '',
'recipient_phone': '',
'phone_number_in_address': '',
'user_id': '',
}
# 提取rule规则所要的信息
get_rule_info(address_info)
result = engine.run_all(
rule_list=gen_rule(),
defined_variables=address_variable(rule_info),
defined_actions=address_action(rule_info),
)
return {
'spam_level': rule_info['span_level'],
'CAPTCHA_phone': rule_info['CAPTCHA_phone'],
}
def run_all(cls, obj, stop_on_first_trigger=True):
return engine.run_all(
rule_list=cls.get_rules(),
defined_variables=cls._get_variables_instance(obj),
defined_actions=cls._get_actions_instance(obj),
stop_on_first_trigger=stop_on_first_trigger)
def test_should_get_only_first_action_result(self):
params_as_dict = self._get_params_for_run_all()
params_as_dict['stop_on_first_trigger'] = True
result = run_all(**params_as_dict)
self.assertEqual(result, [{'some_action_1': 'fooValue'}])
