def test_case_5(self): song = song_list[5]['song'] true_genre = song.genre run_all(rule_list=self.rules, defined_variables=SongVariables(song), defined_actions=SongActions(song), stop_on_first_trigger=False)
def checkout_order(order_number): order = Order.objects.get(order_number=order_number) rules = get_rules() # implement promotion rules order_regular_price = 0 order_actual_price = 0 for od in order.details.all(): run_all(rule_list=rules, defined_variables=OrderDetailVariables(od), defined_actions=OrderDetailActions(od), ) order_regular_price += od.regular_price order_actual_price += od.actual_price or 0 order.regular_price = order_regular_price order.actual_price = order_actual_price order.status = Order.ORDER_STATUS_READY order.save() return order
def renewal_event_is_fired_after_one_month(context): # after 1 month , AllocationSourceSnapshot is first updated. report_start_date = context.ts report_end_date = context.ts + timedelta(days=30) query = EventTable.objects.filter(name='allocation_source_renewed', payload__name__exact='DefaultAllocationSource') assert len(query) == 0 source_snapshot = AllocationSourceSnapshot.objects.filter(allocation_source=context.allocation_source_2).order_by( 'updated').last() assert total_usage(context.amit.user.username, report_start_date, allocation_source_name=context.allocation_source_2.name, end_date=report_end_date) == 72.0 source_snapshot.compute_used = total_usage(context.amit.user.username, report_start_date, allocation_source_name=context.allocation_source_2.name, end_date=report_end_date) source_snapshot.updated = context.ts + timedelta(days=29) source_snapshot.save() assert AllocationSourceSnapshot.objects.filter(allocation_source=context.allocation_source_2).order_by( 'updated').last().compute_used == 72.0 # rules engine is explicitly run current_time = context.ts + timedelta(days=30) run_all(rule_list=cyverse_rules, defined_variables=CyverseTestRenewalVariables(context.allocation_source_2, current_time), defined_actions=CyverseTestRenewalActions(context.allocation_source_2, current_time), ) query = EventTable.objects.filter(name='allocation_source_renewed', payload__name__exact='DefaultAllocationSource') assert len(query) == 1
def get_feed_for_username(username): Logger(__name__).info('Getting feed for user {}.'.format(username)) # get all stories by iterating over usernames, use username to filter private, non-friend ones stories_feed_data = User.get_feed_data(username) Logger(__name__).info( 'Prioritizing {} stories for user {}\'s feed.'.format( len(stories_feed_data), username)) # calculate priorities for story_feed_data in stories_feed_data: set_score(story_feed_data, INITIAL_SCORE) run_all(rule_list=rules, stop_on_first_trigger=False, defined_actions=StoryActions(story_feed_data), defined_variables=StoryVariables(story_feed_data)) prioritized_stories = [ story_feed_data['story_id'] for story_feed_data in sorted(stories_feed_data, key=lambda sfd: get_score(sfd), reverse=True) ] Logger(__name__).info('Serving feed for user {}.'.format(username)) # get stories in according order, add feed-specific fields of user's name and profile pic return [ FeedBuilder._format_feed_story(story_id) for story_id in prioritized_stories ]
def iterate(self, *args, **kwargs): vehicles = Vehicle.objects.filter(Vehicle_DELETED=False) for i in vehicles: run_all(rule_list=self.rules, defined_variables=VehicleVariable(i), defined_actions=VehicleActions(i, self.recall), stop_on_first_trigger=False)
def update(self, request, *args, **kwargs): order = self.get_object() new_status = order.status if order.status == UNASSIGNED_STATUS: if not request.user.is_delivery: return Response( {'error': 'only a delivery user can self-assign an order'}, status=status.HTTP_400_BAD_REQUEST) new_status = IN_PROGRESS_STATUS order.delivery_price = BASE_PRICE run_all(rule_list=rules, defined_variables=OrderVariables(order), defined_actions=OrderActions(order)) order.delivery_user = request.user elif order.status == IN_PROGRESS_STATUS: new_status = DELIVERED_STATUS order.delivery_user.balance += DELIVERY_PERCENTAGE_FEE * order.delivery_price order.delivery_user.save() elif order.status == DELIVER_ERROR_STATUS: return Response(status=status.HTTP_400_BAD_REQUEST) order.status = new_status order.save() self.notify_client(new_status, order.client_user, order.delivery_user) return Response(status=status.HTTP_200_OK)
def update_snapshot_cyverse(start_date=None, end_date=None): logger.debug("update_snapshot_cyverse task started at %s." % datetime.now()) end_date = timezone.now().replace( microsecond=0) if not end_date else end_date for allocation_source in AllocationSource.objects.order_by('name'): # calculate and save snapshots here allocation_source_name = allocation_source.name last_renewal_event = EventTable.objects.filter( name='allocation_source_created_or_renewed', payload__allocation_source_name__exact=str( allocation_source_name)).order_by('timestamp') if not last_renewal_event: logger.info('Allocation Source %s Create/Renewal event missing', allocation_source_name) continue start_date = last_renewal_event.last().timestamp.replace( microsecond=0) if not start_date else start_date total_compute_used = 0 total_burn_rate = 0 for user in allocation_source.all_users: compute_used, burn_rate = total_usage( user.username, start_date=start_date, end_date=end_date, allocation_source_name=allocation_source_name, burn_rate=True) UserAllocationSnapshot.objects.update_or_create( allocation_source=allocation_source, user=user, defaults={ 'compute_used': compute_used, 'burn_rate': burn_rate }) total_compute_used += compute_used total_burn_rate += burn_rate AllocationSourceSnapshot.objects.update_or_create( allocation_source=allocation_source, defaults={ 'compute_used': total_compute_used, 'global_burn_rate': total_burn_rate }) run_all( rule_list=cyverse_rules, defined_variables=CyverseTestRenewalVariables( allocation_source, end_date, start_date), defined_actions=CyverseTestRenewalActions(allocation_source, end_date), ) # At the end of the task, fire-off an allocation threshold check logger.debug("update_snapshot_cyverse task finished at %s." % datetime.now()) allocation_threshold_check.apply_async()
def test_case_26_to_50(self): for i in range(26, 50): song = song_list[i]['song'] true_genre = song.genre run_all(rule_list=self.rules, defined_variables=SongVariables(song), defined_actions=SongActions(song), stop_on_first_trigger=False)
def set_importance(video, rules): video['importance'] = 0 variables = VideoVariables(video) actions = VideoActions(video, variables) run_all(rule_list=rules, defined_variables=variables, defined_actions=actions, stop_on_first_trigger=False)
def run(self): self.get_attribs() run_all(rule_list=self.rules, defined_variables=SongVariables(self.song), defined_actions=SongActions(self.song), stop_on_first_trigger=False) self.genre_var.set(self.song.genre) self.update_idletasks()
def calculate_price(self): run_all( rule_list=self.user_rules, defined_actions=DeliveryActions(self), defined_variables=DeliveryVariables(self) ) price = self.base_price - self.get_total_discounts() + self.get_total_charges() if price < 0: return 0 return price
def calculate_delivery_pay(self): if not self.base_price: self.calculate_price() price = self.base_price*0.85 run_all( rule_list=self.delivery_rules, defined_actions=DeliveryActions(self), defined_variables=DeliveryVariables(self) ) price = price - self.get_delivery_discounts(price) + self.get_delivery_raises(price) if price < 0: return 0 return price
def evaluate_rule_set(self, rule_set: RuleSet, data: dict, stop_on_first_trigger: bool = True): variables = self._build_variables_object(data) actions = self._build_action_object() run_all(rule_list=self._generate_rules(rule_set, data), defined_variables=variables(data), defined_actions=actions(data), stop_on_first_trigger=stop_on_first_trigger)
def runRule(request, physicianId): p = get_object_or_404(Physician, pk=physicianId) objs = Rule.objects.all() rules = [] for obj in objs: rules.append(json.loads(obj.content)) products = Physician.objects.all() for product in products: run_all(rules, ProductVariables(product), ProductActions(product), False) return HttpResponseRedirect(reverse('view', args=[physicianId]))
def process_data(data): rules = [] rules.extend(comments_rules) rules.extend(reactions_rules) rules.extend(past_days_rules) rules.extend(friends_rules) rules.extend(stories_rules) run_all(rule_list=rules, defined_variables=StoriePriorityDataVariables(data), defined_actions=StoriePriorityDataActions(data), stop_on_first_trigger=False)
def confusion_matrix(self): df = DataFrame(index=range(0, 50), columns=['true', 'predict']) for i in range(0, 50): song = song_list[i]['song'] true_genre = str(song.genre) run_all(rule_list=self.rules, defined_variables=SongVariables(song), defined_actions=SongActions(song), stop_on_first_trigger=False) df.loc[i] = [true_genre, song.genre] cnf_matrix = ConfusionMatrix(df['true'], df['predict']) cnf_matrix.plot() plt.show()
def priorizar(self, videos, autores): ''' Dado un iterable de diccionarios que representan videos, devuelve una lista con los diccionarios ordenados por importancia. ''' videos_procesados = [] for video in map(lambda va: Video(va[0], va[1]), zip(videos, autores)): run_all(self.reglas, defined_variables=VariablesVideo(video), defined_actions=AccionesVideo(video)) videos_procesados.append(video) return [(video.importancia, video.datos_video) for video in sorted( videos_procesados, key=lambda e: e.importancia, reverse=True)]
def info(request,patient_id): hb = request.POST.get('heartratebeat') ol = request.POST.get('oxygenlevel') ll = request.POST.get('liquidlevel') patient = Patient.objects.get(id=int(patient_id)) try: monitoring = MonitoringInfo.objects.create(heartratebeat=int(hb),oxygenlevel=int(ol),liquidlevel=int(ll),patient=patient) monitoring.save() except: return HttpResponse(status=400) rules = Rule.objects.filter(ruletype=Rule.monitoringRule).order_by('-priority') engRules = [] for rule in rules: engRules.append(json.loads(rule.content)) my_file = Path("./monitoring/custom_variables_m.py") if my_file.is_file(): module = import_module('.custom_variables_m',package="monitoring") for rule in engRules: l = [] l.append(rule) monitoringActions = MonitoringActions() run_all(rule_list=l, defined_variables=module.CustomMonitoringVariables(monitoring,patient), defined_actions=monitoringActions, stop_on_first_trigger=False ) if monitoringActions.alarm: if Alarm.objects.filter(alarm=monitoringActions.name,patientId=patient.id,solved=False).first() is None: alarm = Alarm.objects.create(alarm=monitoringActions.name,patientId=patient.id,patient=patient.name+" "+patient.surname,solved=False) alarm.save() else: for rule in engRules: l = [] l.append(rule) monitoringActions = MonitoringActions() run_all(rule_list=l, defined_variables=MonitoringVariables(monitoring,patient), defined_actions=monitoringActions, stop_on_first_trigger=False ) if monitoringActions.alarm: if Alarm.objects.filter(alarm=monitoringActions.name,patientId=patient.id,solved=False).first() is None: alarm = Alarm.objects.create(alarm=monitoringActions.name,patientId=patient.id,patient=patient.name+" "+patient.surname,solved=False) alarm.save() return HttpResponse(status=200)
def test_renewal_rules(self): """Check renewal rules""" import datetime from business_rules import run_all from django.utils import timezone from cyverse_allocation.cyverse_rules_engine_setup import CyverseTestRenewalVariables, \ CyverseTestRenewalActions, cyverse_rules from core.models import EventTable source_01 = AllocationSourceFactory.create( uuid='98e9aed3-1f4c-415c-9ea3-618a8c318eaa', name='default_source_01', compute_allowed=168, start_date=datetime.datetime(2017, 7, 4, hour=12, tzinfo=timezone.utc), end_date=None, renewal_strategy='default' ) renewal_events_count_before = EventTable.objects.filter(name='allocation_source_created_or_renewed').count() self.assertEqual(renewal_events_count_before, 0) current_time = datetime.datetime(2017, 7, 5, hour=12, tzinfo=timezone.utc) run_all(rule_list=cyverse_rules, defined_variables=CyverseTestRenewalVariables(source_01, current_time=current_time, last_renewal_event_date=source_01.start_date), defined_actions=CyverseTestRenewalActions(source_01, current_time=current_time)) renewal_events_count_after_one = EventTable.objects.filter(name='allocation_source_created_or_renewed').count() self.assertEqual(renewal_events_count_after_one, 0) current_time = datetime.datetime(2017, 8, 1, hour=12, tzinfo=timezone.utc) run_all(rule_list=cyverse_rules, defined_variables=CyverseTestRenewalVariables(source_01, current_time=current_time, last_renewal_event_date=source_01.start_date), defined_actions=CyverseTestRenewalActions(source_01, current_time=current_time)) renewal_events_count_after_two = EventTable.objects.filter(name='allocation_source_created_or_renewed').count() self.assertEqual(renewal_events_count_after_two, 1) last_renewal_event_date = current_time current_time = datetime.datetime(2017, 8, 3, hour=12, tzinfo=timezone.utc) run_all(rule_list=cyverse_rules, defined_variables=CyverseTestRenewalVariables(source_01, current_time=current_time, last_renewal_event_date=last_renewal_event_date), defined_actions=CyverseTestRenewalActions(source_01, current_time=current_time)) renewal_events_count_after_three = EventTable.objects.filter( name='allocation_source_created_or_renewed').count() self.assertEqual(renewal_events_count_after_three, 1) current_time = datetime.datetime(2017, 9, 1, hour=12, tzinfo=timezone.utc) run_all(rule_list=cyverse_rules, defined_variables=CyverseTestRenewalVariables(source_01, current_time=current_time, last_renewal_event_date=last_renewal_event_date), defined_actions=CyverseTestRenewalActions(source_01, current_time=current_time)) renewal_events_count_after_four = EventTable.objects.filter(name='allocation_source_created_or_renewed').count() self.assertEqual(renewal_events_count_after_four, 2)
def run_rules_t(self, a): # executa a regra obj_parameters = Parameters( 10, 30, 10) #id_gateway futuramente será trabalhado rules = self.get_rules(a) # print(rules) for i in range(0, len(rules), 1): # percorre a lista que contem as regras #print(i) if (rules[i]['status']): rule = json.loads( rules[i]['jsonRule']) # extrai as regras do json run_all(rule_list=rule, defined_variables=ConditionsRules(obj_parameters), defined_actions=ActionRules(obj_parameters), stop_on_first_trigger=True)
def process_rules(custom_rule_file, descriptor_file_name): rules = load_rules_yaml(custom_rule_file) storage = DescriptorStorage() func = storage.create_function(descriptor_file_name) if not func: evtLOG.log( "Invalid function descriptor, Couldn't store " "VNF of file '{0}'".format(descriptor_file_name), descriptor_file_name, 'evt_function_invalid_descriptor') exit(1) for vdu in func.content.get("virtual_deployment_units"): descriptor = DescriptorVDU(func.id) descriptor._vdu_id = vdu.get("id") descriptor._storage = vdu.get("resource_requirements").get("storage") descriptor._cpu = vdu.get("resource_requirements").get("cpu") descriptor._memory = vdu.get("resource_requirements").get("memory") descriptor._network = vdu.get("resource_requirements").get("network") descriptor._vdu_images_format = vdu.get("vm_image_format") triggered = run_all( rule_list=rules, defined_variables=DescriptorVariablesVDU(descriptor), defined_actions=DescriptorActions(descriptor), stop_on_first_trigger=False) return descriptor._errors
def _callback(ch, method, properties, body): try: d = json.loads(body) idx = np.argwhere(np.asarray(d['idxs']) == args.class_idx) if idx.shape[0] < 1: return conf = d['inferences'][idx[0, 0]] inf.last_conf = conf run_all(rule_list=rules, defined_variables=InferenceVars(inf), defined_actions=InferenceActs(inf), stop_on_first_trigger=False) except Exception as e: print('exception ', e)
def test_rule_engine(self): triggered = run_all(rule_list=rules, defined_variables=ProductVariables(product), defined_actions=ProductActions(product), stop_on_first_trigger=True ) assert triggered == True assert product.action_triggered == True
def test_accuracy(self): total = 50 correct = 0 df = DataFrame(index=range(0, 50), columns=['true', 'predict']) for i in range(0, 50): song = song_list[i]['song'] true_genre = song.genre run_all(rule_list=self.rules, defined_variables=SongVariables(song), defined_actions=SongActions(song), stop_on_first_trigger=False) df.loc[i] = [true_genre, song.genre] if true_genre == song.genre: correct += 1 print(correct / total) cnf_matrix = ConfusionMatrix(df['true'], df['predict']) cnf_matrix.plot() plt.show() self.assertGreater((correct / total), 0.5)
def _callback(ch, method, properties, body): try: d = json.loads(body) idx = np.argwhere(np.asarray(d['idxs']) == 500) if idx.shape[0] < 1: print('no receiving inference for class idx', 500) sys.exit() conf = d['inferences'][idx[0, 0]] inf.last_conf = conf run_all(rule_list=rules, defined_variables=base.InferenceVars(inf), defined_actions=BackoffActs(inf), stop_on_first_trigger=False) except Exception as e: print('exception ', e)
def test_rule_engine_custom_operator(self): triggered = run_all(rule_list=rules_custom_operator, defined_variables=ProductVariables(product), defined_actions=ProductActions(product), defined_operators=CustomOperator(CustomType), stop_on_first_trigger=False ) assert triggered == True assert product.action_triggered == True
def _callback(ch, method, properties, body): try: d = json.loads(body) idx = np.argwhere(np.asarray(d['idxs']) == args.index) if idx.shape[0] < 1: return conf = d['inferences'][idx[0, 0]] inf.last_conf = conf inf.embeddings = np.asarray(d['embeddings'], dtype=np.uint8) inf.time = d['time'] run_all(rule_list=rules, defined_variables=base.InferenceVars(inf), defined_actions=NotificationActs(inf), stop_on_first_trigger=False) except Exception as e: print('exception ', e)
def update_snapshot_cyverse(start_date=None, end_date=None): logger.debug("update_snapshot_cyverse task started at %s." % datetime.now()) end_date = timezone.now().replace(microsecond=0) if not end_date else end_date for allocation_source in AllocationSource.objects.order_by('name'): # calculate and save snapshots here allocation_source_name = allocation_source.name last_renewal_event = EventTable.objects.filter( name='allocation_source_created_or_renewed', payload__allocation_source_name__exact=str(allocation_source_name)).order_by('timestamp') if not last_renewal_event: logger.info('Allocation Source %s Create/Renewal event missing', allocation_source_name) continue start_date = last_renewal_event.last().timestamp.replace(microsecond=0) if not start_date else start_date total_compute_used = 0 total_burn_rate = 0 for user in allocation_source.all_users: compute_used, burn_rate = total_usage(user.username, start_date=start_date, end_date=end_date, allocation_source_name=allocation_source_name, burn_rate=True) UserAllocationSnapshot.objects.update_or_create(allocation_source=allocation_source, user=user, defaults={'compute_used': compute_used, 'burn_rate': burn_rate}) total_compute_used += compute_used total_burn_rate += burn_rate AllocationSourceSnapshot.objects.update_or_create(allocation_source=allocation_source, defaults={'compute_used': total_compute_used, 'global_burn_rate': total_burn_rate}) run_all(rule_list=cyverse_rules, defined_variables=CyverseTestRenewalVariables(allocation_source, current_time=end_date, last_renewal_event_date=start_date), defined_actions=CyverseTestRenewalActions(allocation_source, current_time=end_date)) # At the end of the task, fire-off an allocation threshold check logger.debug("update_snapshot_cyverse task finished at %s." % datetime.now()) allocation_threshold_check.apply_async()
def run_rules_event( self, datas_of_rules ): # atributos do datas_of_rules: id da regra que gerou o evento, o status de execução, o valor de sensor, a regra a ser executada data_received_of_broker = json.loads(datas_of_rules) obj_parameters = Parameters( datas_of_rules) #gera os parametros para executar a regra rules = self.get_rules(datas_of_rules) obj_parameters = Parameters( ) #aqui vai passar o true/false da regra que gerou o evento for i in range(0, len(rules), 1): # percorre a lista que contem as regras if (rules[i]['status']): rule = json.loads( rules[i]['jsonRule']) # extrai as regras do json run_all(rule_list=rule, defined_variables=ConditionsRules( obj_parameters, self.core), defined_actions=ActionRules(obj_parameters, self.core), stop_on_first_trigger=True)
def run_business(): beispiel = Vehicle.objects.get(pk=1) rules = [{ "conditions": { "all": [ { "name": "first_registration_date_from", "operator": "greater_than_or_equal_to", "value": "2017-08-01" }, ] }, "actions": [ { "name": "print_result", }, ], }] run_all(rule_list=rules, defined_variables=VehicleVariable(beispiel), defined_actions=VehicleActions(beispiel), stop_on_first_trigger=True)
def mediainfoRuleEngine(event, context): logger.info(json.dumps(event)) try: rulesTable = dynamodb_resource.Table(os.environ['RULEWEB_RULETABLE']) mediaInfo = event['mediainfo'] ruleMappings = event['ruleMappings'] video = Mediainfo(mediaInfo) # Determine Encoding template by running the encoding rules and selecting # the first mapped template whose rules is true. for ruleMapping in event['ruleMappings']: ruleMapping['testCreateTime'] = datetime.utcnow().strftime( '%Y-%m-%d %H:%M.%S') logger.info("rule: {}".format( json.dumps(ruleMapping, indent=4, sort_keys=True))) # retrieve the rule expression from the dyanamodb response = rulesTable.get_item( Key={'name': ruleMapping['ruleName']}, ConsistentRead=True) businessRules = response['Item']['rules'] logger.info("running test {}".format( json.dumps(businessRules, cls=DecimalEncoder))) ruleMapping['testResult'] = run_all( rule_list=[businessRules], defined_variables=MediainfoVariables(video), defined_actions=MediainfoActions(video), stop_on_first_trigger=True) logger.info("test result {}".format( json.dumps(ruleMapping['testResult'], cls=DecimalEncoder))) # Stop on the first rule that evaluates to True as we have found our mapping if ruleMapping['testResult'] == True: event['selectedRuleString'] = ruleMapping['ruleString'] break except Exception as e: logger.info("Exception {}".format(e)) raise ChaliceViewError("Exception '%s'" % e) logger.info('Event: %s', json.dumps(event)) return event
def process_rules(custom_rule_file, descriptor_file_name): # def process_rules(custom_rule_file): # Read YAML rule file if not os.path.isfile(custom_rule_file): log.error("Invalid custom rule file") exit(1) try: fn_custom_rule = open(custom_rule_file, "r") except IOError: log.error("Error opening custom rule file: " "File does not appear to exist.") exit(1) try: rules = yaml.load(fn_custom_rule) except (yaml.YAMLError, yaml.MarkedYAMLError) as e: log.error("The rule file seems to have contain invalid YAML syntax." " Please fix and try again. Error: {}".format(str(e))) exit(1) storage = DescriptorStorage() # descriptor_source = read_descriptor_file(descriptor_file_name) func = storage.create_function(descriptor_file_name) if not func: evtlog.log( "Invalid function descriptor, Couldn't store " "VNF of file '{0}'".format(descriptor_file_name), descriptor_file_name, 'evt_function_invalid_descriptor') exit(1) # TODO populate descriptor from file # descriptor= Descriptor(func,"cona",1000,5,5,1) descriptor = Descriptor(func) variables = DescriptorVariables(descriptor) rule_to_export = export_rule_data(DescriptorVariables, DescriptorActions) # print("DUMP OF RULES: \n"+json.dumps(rules)) # Execute all the rules triggered = run_all(rule_list=rules, defined_variables=DescriptorVariables(descriptor), defined_actions=DescriptorActions(descriptor), stop_on_first_trigger=False) return descriptor.errors
def run(self, rules, variables, patient): # load variables and actions for rule; v = Variables(variables) a = Actions(patient) # if rule is not a list, wrap the rule in list; if isinstance(rules, dict): rules = [rules] # run all the rules given progressively; check = run_all(rule_list=rules, defined_variables=v, defined_actions=a, stop_on_first_trigger=False) return a._patient
def renewal_event_is_fired_twice(context): # after another 14 days , AllocationSourceSnapshot is updated. report_start_date = context.ts + timedelta(days=30) report_end_date = report_start_date + timedelta(days=43) query = EventTable.objects.filter(name='allocation_source_renewed', payload__name__exact='DefaultAllocationSource') assert len(query) == 1 source_snapshot = AllocationSourceSnapshot.objects.filter(allocation_source=context.allocation_source_2).order_by( 'updated').last() amit_usage = total_usage(context.amit.user.username, report_start_date, allocation_source_name=context.allocation_source_2.name, end_date=report_end_date) julian_usage = total_usage(context.julian.user.username, report_start_date, allocation_source_name=context.allocation_source_2.name, end_date=report_end_date) assert amit_usage == 120.0 assert julian_usage == 96.0 source_snapshot.compute_used = amit_usage + julian_usage source_snapshot.updated = context.ts + timedelta(days=43) source_snapshot.save() assert AllocationSourceSnapshot.objects.filter(allocation_source=context.allocation_source_2).order_by( 'updated').last().compute_used == 216.0 # rules engine is explicitly run current_time = context.ts + timedelta(days=44) run_all(rule_list=cyverse_rules, defined_variables=CyverseTestRenewalVariables(context.allocation_source_2, current_time), defined_actions=CyverseTestRenewalActions(context.allocation_source_2, current_time), ) assert EventTable.objects.filter(name='allocation_source_renewed') == 2 # after another 14 days , AllocationSourceSnapshot is updated. report_start_date = context.ts + timedelta(days=44) report_end_date = report_start_date + timedelta(days=57) query = EventTable.objects.filter(name='allocation_source_renewed', payload__name__exact='DefaultAllocationSource') source_snapshot = AllocationSourceSnapshot.objects.filter(allocation_source=context.allocation_source_2).order_by( 'updated').last() amit_usage = total_usage(context.amit.user.username, report_start_date, allocation_source_name=context.allocation_source_2.name, end_date=report_end_date) julian_usage = total_usage(context.julian.user.username, report_start_date, allocation_source_name=context.allocation_source_2.name, end_date=report_end_date) assert amit_usage == 0.0 assert julian_usage == 192.0 source_snapshot.compute_used = amit_usage + julian_usage source_snapshot.updated = context.ts + timedelta(days=57) source_snapshot.save() assert AllocationSourceSnapshot.objects.filter(allocation_source=context.allocation_source_2).order_by( 'updated').last().compute_used == 192.0 # rules engine is explicitly run current_time = context.ts + timedelta(days=58) run_all(rule_list=cyverse_rules, defined_variables=CyverseTestRenewalVariables(context.allocation_source_2, current_time), defined_actions=CyverseTestRenewalActions(context.allocation_source_2, current_time), ) assert EventTable.objects.filter(name='allocation_source_renewed') == 3
"value": "True", }, { "name": "today", "operator": "after_than_or_equal_to", "value": "2017-01-16", }] }, "actions": [{ "name": "log", "params": { "message": "All criteria met!", } }] }, { "actions": [{ "name": "log", "params": { "message": "Rule with no conditions triggered!", } }] }] hot_drink = Item(code=1, name='Hot Drink', line_number=1, quantity=1) pastry = Item(code=2, name='Pastry', line_number=2, quantity=1) basket = Basket(id=0, items=[hot_drink, pastry]) run_all( rule_list=rules, defined_variables=ExampleVariables(basket), defined_actions=ExampleActions(basket), )