<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.polarsparc</groupId>
        <artifactId>Drools</artifactId>
        <version>1.0</version>
    </parent>

    <artifactId>Third</artifactId>
    <version>1.0</version>
    <name>Third</name>
</project>

/*
 * Name:   third_r1.drl
 * Author: Bhaskar S
 * Date:   06/11/2021
 * Blog:   https://www.polarsparc.com
 */

package com.polarsparc.third.r1;

import com.polarsparc.third.model.Third;
import org.slf4j.Logger;

global org.slf4j.Logger log;

rule "Third_R1"
    when
        $t: Third()
    then
        log.info("{}: supplier: {}, product: {}, price: {}",
            drools.getRule().getName(),
            $t.getSupplier(),
            $t.getProduct(),
            $t.getPrice());
end

/*
 * Name:   third_r2.drl
 * Author: Bhaskar S
 * Date:   06/11/2021
 * Blog:   https://www.polarsparc.com
 */

package com.polarsparc.third.r2;

import com.polarsparc.third.model.Third;
import org.slf4j.Logger;

global org.slf4j.Logger log;

rule "Third_R2"
    when
        $t: Third()
    then
        log.info("{}: Supplier: {}, Product: {}, Price: {}",
            drools.getRule().getName(),
            $t.getSupplier(),
            $t.getProduct(),
            $t.getPrice());
end

/*
 * Name:   Third
 * Author: Bhaskar S
 * Date:   06/11/2021
 * Blog:   https://www.polarsparc.com
 */

package com.polarsparc.third.model;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.ToString;

@AllArgsConstructor
@Getter
@ToString
public class Third {
    private final String supplier;
    private final String product;
    private final double price;
}

/*
 * Name:   ThirdDroolsConfig
 * Author: Bhaskar S
 * Date:   06/11/2021
 * Blog:   https://www.polarsparc.com
 */

package com.polarsparc.third.config;

import org.kie.api.KieServices;
import org.kie.api.builder.*;
import org.kie.api.builder.model.KieBaseModel;
import org.kie.api.builder.model.KieModuleModel;
import org.kie.api.builder.model.KieSessionModel;
import org.kie.api.conf.EqualityBehaviorOption;
import org.kie.api.conf.EventProcessingOption;
import org.kie.api.io.KieResources;
import org.kie.api.io.Resource;
import org.kie.api.io.ResourceType;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.conf.ClockTypeOption;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ThirdDroolsConfig {
    private final static String THIRD_R1_DRL = "src/main/resources/com/polarsparc/third/r1/third_r1.drl";
    private final static String THIRD_R2_DRL = "src/main/resources/com/polarsparc/third/r2/third_r2.drl";

    @Bean
    public KieContainer thirdKieContainer() {
        KieServices services = KieServices.Factory.get();

        ReleaseId releaseId = services.newReleaseId("com.polarsparc.third", "third", "1.0");

        KieFileSystem fileSystem = services.newKieFileSystem();

        KieResources resources = services.getResources();

        Resource drlResource_1 = resources.newFileSystemResource(THIRD_R1_DRL)
                .setResourceType(ResourceType.DRL);
        Resource drlResource_2 = resources.newFileSystemResource(THIRD_R2_DRL)
                .setResourceType(ResourceType.DRL);

        KieModuleModel model = services.newKieModuleModel();

        KieBaseModel base_1 = model.newKieBaseModel("third-r1-base")
                .setDefault(true)
                .addPackage("com.polarsparc.third.r1")
                .setEqualsBehavior(EqualityBehaviorOption.EQUALITY)
                .setEventProcessingMode(EventProcessingOption.CLOUD);
        base_1.newKieSessionModel("third-r1-session")
                .setDefault(true)
                .setType(KieSessionModel.KieSessionType.STATEFUL)
                .setClockType(ClockTypeOption.REALTIME);

        KieBaseModel base_2 = model.newKieBaseModel("third-r2-base")
                .addPackage("com.polarsparc.third.r2")
                .setEqualsBehavior(EqualityBehaviorOption.EQUALITY)
                .setEventProcessingMode(EventProcessingOption.CLOUD);
        base_2.newKieSessionModel("third-r2-session")
                .setType(KieSessionModel.KieSessionType.STATEFUL)
                .setClockType(ClockTypeOption.REALTIME);

        fileSystem.generateAndWritePomXML(releaseId)
                .write(drlResource_1)
                .write(drlResource_2)
                .writeKModuleXML(model.toXML());

        KieBuilder builder = services.newKieBuilder(fileSystem);
        Results results = builder.buildAll().getResults();
        if (results.hasMessages(Message.Level.ERROR)) {
            throw new BeanCreationException("Error building rules: " + results.getMessages());
        }

        KieModule module = builder.getKieModule();

        return services.newKieContainer(module.getReleaseId());
    }
}

/*
 * Name:   ThirdApplication
 * Author: Bhaskar S
 * Date:   06/11/2021
 * Blog:   https://www.polarsparc.com
 */

package com.polarsparc.third;

import com.polarsparc.third.model.Third;
import lombok.extern.slf4j.Slf4j;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@Slf4j
public class ThirdApplication implements ApplicationRunner {
    private KieContainer container;

    @Autowired
    public void setKieContainer(KieContainer container) {
        this.container = container;
    }

    public static void main(String[] args) {
        SpringApplication.run(ThirdApplication.class, args);
    }

    @Override
    public void run(ApplicationArguments args) {
        log.info("ReleaseId: {}", container.getReleaseId());
        log.info("KieBases: {}", container.getKieBaseNames());
        container.getKieBaseNames().forEach(name ->
                log.info("KieBase: {}, KieSessions: {}", name, container.getKieSessionNamesInKieBase(name)));

        Third t1 = new Third("S1", "P1", 19.99);
        Third t2 = new Third("S2", "P1", 19.79);

        // Default - third-r1-session
        KieSession ks1 = container.newKieSession();
        ks1.setGlobal("log", log);
        ks1.insert(t1);
        ks1.insert(t2);
        ks1.fireAllRules();
        ks1.dispose();

        log.info("ks1 - Done !!!");

        // Specific - third-r2-session
        KieSession ks2 = container.newKieSession("third-r2-session");
        ks2.setGlobal("log", log);
        ks2.insert(t1);
        ks2.insert(t2);
        ks2.fireAllRules();
        ks2.dispose();

        log.info("ks2 - Done !!!");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.polarsparc</groupId>
        <artifactId>Drools</artifactId>
        <version>1.0</version>
    </parent>

    <artifactId>Fourth</artifactId>
    <version>1.0</version>
    <name>Fourth</name>
</project>

/*
 * Name:   fourth.drl
 * Author: Bhaskar S
 * Date:   06/11/2021
 * Blog:   https://www.polarsparc.com
 */

package com.polarsparc.fourth;

import com.polarsparc.fourth.model.*;
import org.slf4j.Logger;
import java.util.Collection;
import java.util.Comparator;

global org.slf4j.Logger log;

rule "Find_Best_Supplier"
    when
        $suppliers: Collection(size > 0)
        $best: Supplier($low: price) from $suppliers
        not Supplier(price < $low) from $suppliers
    then
        log.info("{}: Supplier {} is preferred for Product {}",
            drools.getRule().getName(),
            $best.getSupplier(),
            $best.getProduct());

        delete($suppliers);
        insert($best);
end

rule "Compute_Threshold"
    when
        $best: Supplier()
        $invt: Inventory()
        $thr: Threshold()
        $pm: Promotion()
    then
        double pct = ($invt.getPrice() - $best.getPrice()) / $invt.getPrice();

        log.info("{}: Threshold: {}, Computed: {}",
            drools.getRule().getName(),
            $thr.getThreshold(),
            String.format("%.3f", pct));

            delete($invt);
        modify($pm){
            setComputed(pct),
            setSupplier($best)
        }
        delete($best);
end

rule "Compute_Discount"
    when
        $thr: Threshold()
        $pm: Promotion(computed > $thr.getThreshold())
    then
        log.info("{}: Threshold: {}, Computed: {} -> Discount eligible",
            drools.getRule().getName(),
            $thr.getThreshold(),
            String.format("%.3f", $pm.getComputed()));

        delete($thr);
        modify($pm){
            setDiscount($pm.getComputed()/2.0)
        }
end

rule "Display_Discount"
    when
        $p: Promotion(discount > 0.0)
    then
        log.info("{}: Product {} allows a Discount of {}%",
            drools.getRule().getName(),
            $p.getSupplier().getProduct(),
            String.format("%.2f", $p.getDiscount() * 100.0));
end

/*
 * Name:   Supplier
 * Author: Bhaskar S
 * Date:   06/11/2021
 * Blog:   https://www.polarsparc.com
 */

package com.polarsparc.fourth.model;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@AllArgsConstructor
@Getter
@Setter
@ToString
public class Supplier {
    private String supplier;
    private String product;
    private double price;
}

/*
 * Name:   Inventory
 * Author: Bhaskar S
 * Date:   06/11/2021
 * Blog:   https://www.polarsparc.com
 */

package com.polarsparc.fourth.model;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@AllArgsConstructor
@Getter
@Setter
@ToString
public class Inventory {
    private String product;
    private double price;
}

/*
 * Name:   Threshold
 * Author: Bhaskar S
 * Date:   06/11/2021
 * Blog:   https://www.polarsparc.com
 */

package com.polarsparc.fourth.model;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@AllArgsConstructor
@Getter
@Setter
@ToString
public class Threshold {
    private String product;
    private double threshold;
}

/*
 * Name:   Promotion
 * Author: Bhaskar S
 * Date:   06/11/2021
 * Blog:   https://www.polarsparc.com
 */

package com.polarsparc.fourth.model;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@ToString
public class Promotion {
    private double computed = 0.0;
    private double discount = 0.0;
    private Supplier supplier;
}

/*
 * Name:   FourthDroolsConfig
 * Author: Bhaskar S
 * Date:   06/11/2021
 * Blog:   https://www.polarsparc.com
 */

package com.polarsparc.fourth.config;

import org.kie.api.KieServices;
import org.kie.api.builder.*;
import org.kie.api.io.KieResources;
import org.kie.api.runtime.KieContainer;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FourthDroolsConfig {
    private final static String FOURTH_DRL = "com/polarsparc/fourth/fourth.drl";

    @Bean
    public KieContainer fourthKieContainer() {
        KieServices services = KieServices.Factory.get();
        KieResources resources = services.getResources();

        KieFileSystem fileSystem = services.newKieFileSystem();
        fileSystem.write(resources.newClassPathResource(FOURTH_DRL));

        KieBuilder builder = services.newKieBuilder(fileSystem);
        Results results = builder.buildAll().getResults();
        if (results.hasMessages(Message.Level.ERROR)) {
            throw new BeanCreationException("Error building rules: " + results.getMessages());
        }

        KieModule module = builder.getKieModule();

        return services.newKieContainer(module.getReleaseId());
    }
}

/*
 * Name:   FourthApplication
 * Author: Bhaskar S
 * Date:   06/11/2021
 * Blog:   https://www.polarsparc.com
 */

package com.polarsparc.fourth;

import com.polarsparc.fourth.model.Inventory;
import com.polarsparc.fourth.model.Promotion;
import com.polarsparc.fourth.model.Supplier;
import com.polarsparc.fourth.model.Threshold;
import lombok.extern.slf4j.Slf4j;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.Arrays;

@SpringBootApplication
@Slf4j
public class FourthApplication implements ApplicationRunner {
    private KieContainer container;

    @Autowired
    public void setKieContainer(KieContainer container) {
        this.container = container;
    }

    public static void main(String[] args) {
        SpringApplication.run(FourthApplication.class, args);
    }

    @Override
    public void run(ApplicationArguments args) {
        // Test Case - 1
        {
            // Suppliers for Product P1
            Supplier s1 = new Supplier("S1", "P1", 18.99);
            Supplier s2 = new Supplier("S2", "P1", 18.59);
            Supplier s3 = new Supplier("S3", "P1", 18.79);

            // Current inventory
            Inventory in = new Inventory("P1", 18.99);

            // Price difference threshold
            Threshold th = new Threshold("P1", 0.05);

            // Promotion
            Promotion pm = new Promotion();

            KieSession ks = container.newKieSession();
            ks.setGlobal("log", log);
            ks.insert(Arrays.asList(s1, s2, s3));
            ks.insert(in);
            ks.insert(th);
            ks.insert(pm);
            ks.fireAllRules();
            ks.dispose();

            log.info("{}: [1] Supplier: {}, Product: {}, Discount: {}",
                    FourthApplication.class.getName(),
                    pm.getSupplier(),
                    pm.getSupplier().getProduct(),
                    String.format("%.3f", pm.getDiscount()));
        }

        // Test Case - 2
        {
            // Suppliers for Product P1
            Supplier s1 = new Supplier("S2", "P2", 18.99);
            Supplier s2 = new Supplier("S3", "P2", 17.49);
            Supplier s3 = new Supplier("S4", "P2", 16.99);

            // Current inventory
            Inventory in = new Inventory("P2", 19.99);

            // Price difference threshold
            Threshold th = new Threshold("P2", 0.10);

            // Promotion
            Promotion pm = new Promotion();

            KieSession ks = container.newKieSession();
            ks.setGlobal("log", log);
            ks.insert(Arrays.asList(s1, s2, s3));
            ks.insert(in);
            ks.insert(th);
            ks.insert(pm);
            ks.fireAllRules();
            ks.dispose();

            log.info("{}: [2] Supplier: {}, Product: {}, Discount: {}",
                    FourthApplication.class.getName(),
                    pm.getSupplier(),
                    pm.getSupplier().getProduct(),
                    String.format("%.3f", pm.getDiscount()));
        }
    }
}