Very new to constraint streams. Maybe somebody can point me in the right direction?

[GilfalasOrcbane]

Hello,

I have been using Optaplanner with drools for some time now and I am have trouble ajusting to constraint streams.
I apologize in advance if the solution to this question is trivial. Maybe somebody can point me in the right direction?
I have aleady managed to create some more simple constraints but I have trouble with certain concepts.
I want to add that I am not a professional software developer (veterinarian by trade) and english is not my first language.

Here's what I am trying to achieve:

I have a class Planning_event (Planning Entity) which represents certain events. Each event can be attributed a class Planning_day which has of course a date. Each Planning_event also has a certain type.

I also have a list of rules (Planning_rule.class) collected from a database. I use this to parameter my constraints.
Ex: Certain events can only occur on certain days.

Now I would like to implement that certain events can only happen x times per week. And I want to get this "x times per week" from my database.

Here's my line of thought:

I need to match the events of a certain type to the rule that defines the frequency per week of this type of event.
Then I need to count how many times per specific week this event occurs.
For each day over the allocated frequency I must penalize by ONE_HARD.

Here's an example of a rule which seems to work and which would force events not to occur on certain day:

Constraint generic_day_never(ConstraintFactory constraintFactory) {
    	return constraintFactory
    			.forEach(Planning_event.class)
    			.join(Planning_rule.class)
    			.filter((p,r) -> r.getRule_type().equals("DAY_NEVER") && (p.getPlanning_dayname().equals(r.getRule_day()) && p.getType().equals(r.getRule_target_type())))	    
    			.penalize(HardSoftBigDecimalScore.ONE_HARD)
        		.asConstraint("Generic Day Never Conflict")
    			;
    }

This constraint tries to match a certain rule with a certain type of event and checks if it happens on a forbidden day.

So say my Planning_rule class has a rule type "WEEK_FREQ_MAX" which should apply to a certain type of event which can be fetched with p.getType(). Also this Planning_rule has a frequency attributed to this event (ex: once per week)
And each event has a week which can be fetched with a function p.getPlanning_week().

Here's the begining of what I tried but which does not seem to be the right way:

Constraint generic_week_freqency_max(ConstraintFactory constraintFactory) {
    	return constraintFactory
    			.forEach(Planning_rule.class)
    			.join(Planning_event.class)
    			.filter((r,p) -> r.getRule_type().equals("WEEK_FREQ_MAX") && p.getType().equals(r.getRule_target_type()))	
    			.groupBy((r,p) -> p.getPlanning_week())

Am I correct to assume that this way I should have a stream with a certain type of event grouped by week?
How do I get from there to counting how many times a week a specific event occurs and compare it to the maximum frequency defined in my Planning_rule?

Thank you in advance for all your efforts.

Best regards,

Eric

[ge0ffrey]

How about something like

forEach(Event)
.groupBy(event.week, event.type, count())
.join(MaxCountPerTypeRule, equal(event.type, maxCountPerTypeRule.type)
.filter((week, type, count, rule) -> count > rule.maxCount)
.penalize(..., -> count -> rule.maxCount)

This is pseudo code. Actual code is a bit more verbose.

[GilfalasOrcbane]

Thank you very much for the help!
Much appreciated. I will try to figure something out based on your suggestions.
I will let you know when it works.

Best regards,

Eric

[GilfalasOrcbane]

This is what I came up with. It does seem to produce the desired results:

Constraint generic_week_freqency_max(ConstraintFactory constraintFactory) {
    	return constraintFactory
    			.forEach(Planning_event.class)
    			.groupBy(Planning_event::getType,Planning_event::getPlanning_week,ConstraintCollectors.count())
    			.join(Planning_rule.class)
    			.filter((eventtype,week,count,rule) -> rule.getRule_type().equals("WEEK_FREQ_MAX"))
    			.filter((eventtype,week,count,rule) -> rule.getRule_target_type().equals(eventtype))	
    			.filter((eventtype,week,count,rule) -> count >  rule.getRule_wlimit())	 			
    			.penalize(HardSoftBigDecimalScore.ONE_HARD,(eventtype,week,count,rule) -> count -  rule.getRule_wlimit())
    			.asConstraint("Generic Week Freqency Max")
    ;
    }

Thank you again for pointing me in the right direction!

Best regards,

Eric