humanTask.drl

/*
 * Copyright 2011 JBoss Inc
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.drools.informer.interaction;


import org.drools.informer.generator.Surveyable;

import org.drools.informer.generator.annotations.*;
import org.drools.informer.generator.*;
import org.drools.informer.*;


import java.util.Date;
import java.util.Map;
import java.util.Set;
import java.util.List;


import org.jbpm.task.TaskHelper;
import org.jbpm.task.TaskService;
import org.jbpm.task.HumanTaskServiceFactory;
import org.jbpm.task.service.ContentData;


    declare Surveyable end

    declare enum TaskStates
        CREATED( "Created" ),
        READY( "Not Started" ),
        RESERVED( "Reserved"),
        SUSPENDED_READY( "Suspended(Ready)"),
        IN_PROGRESS( "Started" ),
        SUSPENDED_RESERVED( "Suspended(Reserved)" ),
        SUSPENDED_IN_PROGRESS( "Suspended(Started)" ),
        COMPLETED( "Completed" ),
        FAILED( "Failed" ),
        ERROR( "Error" ),
        OBSOLETE( "Expired" ),
        EXITED( "Canceled" );

        label  : String
    end

    declare enum TaskTransitions
        ACTIVATE( "Activate"),
        FORWARD( "Forward" ),
        SUSPEND( "Suspend" ),
        CLAIM( "Claim" ),
        DELEGATE( "Delegate" ),
        START( "Start" ),
        RESUME( "Resume" ),
        REVOKE( "Revoke" ),
        COMPLETE( "Complete" ),
        STOP( "Stop" ),
        FAIL( "Fail" ),
        EXIT( "Exit" ),
        ERROR( "Error" ),
        SKIP( "Skip" );

        label  : String
    end

    declare HumanTask

        taskId              : String        = java.util.UUID.randomUUID().toString()   @key

        foreignTaskId       : long

        description         : String

        owner               : String

        potentialOwners     : List          = java.util.Collections.emptyList()

        state               : TaskStates

        lastChange          : Date          = new java.util.Date()

        persistent          : boolean       = false

        simple              : boolean       = false

        args                : List          = new java.util.ArrayList()

    end

    declare InteractiveTask extends HumanTask

        surveyableState     : boolean   = false

        surveyableStateFId  : String

        surveyableTx        : boolean   = true

        controlQuestId      : String

    end


    declare AllowedTransition
        taskId              : String

        oldState            : TaskStates

        event               : TaskTransitions

        newState            : TaskStates
    end

    declare TaskStateTransition
    @role(event)
    @timestamp(timestamp)

        taskId              : String

        type                : TaskTransitions

        owner               : String

        timestamp           : Date

    end





    query allowedTransition( String $taskId, TaskStates $oldState, TaskTransitions $tx, TaskStates $newState )
        AllowedTransition( $taskId, $oldState, $tx, $newState ; )
    end

    query transitionHolder( String $thid, String $taskId, String $owner )
        TaskTransitionHolder( $thid := questionnaireId, $taskId := taskId, $owner := owner )
    end

    query taskInfo( String $taskId, String $descr, String $owner, List $potentialOwners, TaskStates $state, Date $lastChange, boolean $persistent )
        HumanTask( $taskId, $descr, $owner, $potentialOwners, $state, $lastChange, $persistent ; )
    end


    /*
    declare TaskStateHolder extends Surveyable
        @Questionable( label = "Manage Task State", language = "EN" )

        questionnaireId     : String    = java.util.UUID.randomUUID().toString()   @key

        taskId              : String

        owner               : String
                @QuestionMark( type = Question.QuestionType.TYPE_TEXT, label = " Actor ", required = false )
                @AllowedAnswers( values = { } )

        state               : String
                @QuestionMark( type = Question.QuestionType.TYPE_TEXT, label = " Status ", required = false )
                @AllowedAnswers( values = { TaskStates.CREATED } )
    end
    */


    declare TaskTransitionHolder extends Surveyable
        @Questionable( label = "Manage Task Transition", language = "EN" )

        questionnaireId     : String  @key

        taskId              : String

        owner               : String
                @QuestionMark( type = Question.QuestionType.TYPE_TEXT, label = " Actor ", required = false )
                @AllowedAnswers( )

        transition          : String
                @QuestionMark( type = Question.QuestionType.TYPE_TEXT, label = " Transition ", required = false )
                @AllowedAnswers( values = { TaskTransitions.ACTIVATE } )

    end

     query taskForArg( Object $arg, HumanTask $task )
        $task := HumanTask( args contains $arg )
     end




rule "Install Survey"
salience 9999
when
then
    FormRegistry.register( TaskTransitionHolder.class );
end




rule "Created -> Reserved"
salience 10010
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.CREATED, potentialOwners == null || potentialOwners.size() == 0 )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.CREATED, TaskTransitions.ACTIVATE, TaskStates.RESERVED ) );
end


rule "Created -> Ready"
salience 10000
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.CREATED, potentialOwners != null, potentialOwners.size() > 0 )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.CREATED, TaskTransitions.ACTIVATE, TaskStates.READY ) );
end


rule "Ready -> Simple"
salience 9990
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.READY )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.READY, TaskTransitions.START, TaskStates.IN_PROGRESS ) );
end


rule "Ready -> Xfull"
salience 9980
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.READY, simple == false )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.READY, TaskTransitions.CLAIM, TaskStates.RESERVED ) );
    insertLogical( new AllowedTransition( $tid, TaskStates.READY, TaskTransitions.SUSPEND, TaskStates.SUSPENDED_READY ) );
end

rule "Ready -> X"
salience 9970
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.READY, potentialOwners != null, potentialOwners.size() > 0 )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.READY, TaskTransitions.FORWARD, TaskStates.READY ) );
    insertLogical( new AllowedTransition( $tid, TaskStates.READY, TaskTransitions.DELEGATE, TaskStates.RESERVED ) );
end





rule "SupendedReady -> Ready"
salience 9960
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.SUSPENDED_READY, simple == false )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.SUSPENDED_READY, TaskTransitions.RESUME, TaskStates.READY ) );
end

rule "Reserved -> Xsimple"
salience 9950
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.RESERVED )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.RESERVED, TaskTransitions.START, TaskStates.IN_PROGRESS ) );
end


rule "Reserved -> X"
salience 9940
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.RESERVED, potentialOwners != null, potentialOwners.size() > 0 )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.RESERVED, TaskTransitions.REVOKE, TaskStates.READY ) );
    insertLogical( new AllowedTransition( $tid, TaskStates.RESERVED, TaskTransitions.FORWARD, TaskStates.READY ) );
    insertLogical( new AllowedTransition( $tid, TaskStates.RESERVED, TaskTransitions.DELEGATE, TaskStates.RESERVED ) );
end


rule "Reserved -> Xfull"
salience 9930
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.RESERVED, simple == false )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.RESERVED, TaskTransitions.SUSPEND, TaskStates.SUSPENDED_RESERVED ) );
end


rule "SupendedReserved -> Reserved"
salience 9920
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.SUSPENDED_RESERVED, simple == false )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.SUSPENDED_RESERVED, TaskTransitions.RESUME, TaskStates.RESERVED ) );
end



rule "In Progress -> Xsimple"
salience 9910
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.IN_PROGRESS )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.IN_PROGRESS, TaskTransitions.COMPLETE, TaskStates.COMPLETED ) );
    insertLogical( new AllowedTransition( $tid, TaskStates.IN_PROGRESS, TaskTransitions.STOP, TaskStates.RESERVED ) );
    insertLogical( new AllowedTransition( $tid, TaskStates.IN_PROGRESS, TaskTransitions.FAIL, TaskStates.FAILED ) );
end

rule "In Progress -> Xfull"
salience 9900
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.IN_PROGRESS, simple == false )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.IN_PROGRESS, TaskTransitions.SUSPEND, TaskStates.SUSPENDED_IN_PROGRESS ) );
end


rule "In Progress -> X"
salience 9890
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.IN_PROGRESS, potentialOwners != null, potentialOwners.size() > 0 )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.IN_PROGRESS, TaskTransitions.DELEGATE, TaskStates.RESERVED ) );
    insertLogical( new AllowedTransition( $tid, TaskStates.IN_PROGRESS, TaskTransitions.REVOKE, TaskStates.READY ) );
    insertLogical( new AllowedTransition( $tid, TaskStates.IN_PROGRESS, TaskTransitions.FORWARD, TaskStates.READY ) );
end







rule "Supended In Progress -> In Progress"
salience 9880
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.SUSPENDED_IN_PROGRESS )
then
    insertLogical( new AllowedTransition( $tid, TaskStates.SUSPENDED_IN_PROGRESS, TaskTransitions.RESUME, TaskStates.IN_PROGRESS ) );
end


rule "Any -> Cancelled"
salience 9870
when
    $task   : HumanTask( $tid : taskId,
                                   $s: state == TaskStates.CREATED
                                          || == TaskStates.READY
                                          || == TaskStates.RESERVED
                                          || == TaskStates.IN_PROGRESS )

then
    insertLogical( new AllowedTransition( $tid, $s, TaskTransitions.EXIT, TaskStates.EXITED ) );
    insertLogical( new AllowedTransition( $tid, $s, TaskTransitions.SKIP, TaskStates.OBSOLETE ) );
    insertLogical( new AllowedTransition( $tid, $s, TaskTransitions.ERROR, TaskStates.ERROR ) );
end









rule "Init"
when
    $task   : HumanTask( $tid : taskId, state == null )
then
//    org.jbpm.task.Task jTask = new org.jbpm.task.Task();
//    TaskHelper.getTaskService().addTask( jTask, new ContentData() );
//    //System.out.println( jTask.getId() + " " + jTask );

    modify ( $task ) {
        //setForeignTaskId( jTask.getId() );
        setState( TaskStates.CREATED );
    }

end

rule "Nomination"
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.CREATED, $owner : owner != null, potentialOwners == null || potentialOwners.size() <= 1 )
then
//    //System.out.println( "Nomination" ) ;
    insert( new TaskStateTransition( $tid, TaskTransitions.ACTIVATE, $owner, new Date() ) );
end

rule "Guess who's gonna take it"
when
    $task   : HumanTask( $tid : taskId, state == TaskStates.READY, owner == null, potentialOwners.size() == 1, $owner : potentialOwners[0] )
then
    //System.out.println( "Guess.... " + $owner ) ;
    modify ( $task ) {
        setOwner( (String) $owner );
    }
end



rule "Transitions"
when
    $t      : HumanTask( $tid := taskId, $oldState := state )
    $tx     : TaskStateTransition( $tid, $tran, $owner, $time ; )
              allowedTransition( $tid, $oldState, $tran, $newState ; )
then
    //System.out.println( "Task " + $tx  + " : Trasition detected " + $tran +" into state " + $newState + " for owner " + $owner + " task is now \n\t " + $t );

    retract( $tx );

    modify ( $t ) {
        setOwner( $owner != null ? $owner : $t.getOwner() ),
        setState( $newState ),
        setLastChange( $time );
    }
end



rule "Allowed Transitions"
when
    $task   : HumanTask( $tid : taskId, $curr : state != null )
              TaskTransitionHolder( $xid : questionnaireId, taskId == $tid )
    $tst    : List() from accumulate ( AllowedTransition( $tid, $s, $tx, $new ; ) collectList( $tx.name() ) )
    $tranx:   MultipleChoiceQuestion( type == "transition", context == $xid, $prev : possibleAnswersValuesAsList != $tst ) @watch( * )
then
    //System.out.println( "SETTING TRANSITIONS " + $tst );
    modify ( $tranx ) { setPossibleAnswersByValue( $tst ); }
end


rule "Allowed Owners"
when
    $task   : HumanTask( $tid : taskId, $owner : owner, $potential : potentialOwners )
              TaskTransitionHolder( $xid : questionnaireId, taskId == $tid, $owner := owner )
              transitionHolder( $xid, $tid, $owner ; )
    $owners : MultipleChoiceQuestion( type == "owner", context == $xid,
                                      $prev : possibleAnswersValuesAsList != $potential
                                    ) @watch( * )
then
    //System.out.println( "SETTING OWNERS " + $potential + " when prev was " + $prev ) ;
    modify ( $owners ) { setPossibleAnswersByValue( $potential ); }
end




rule "Persist"
salience 1
when
    $task   : HumanTask( $tid : taskId, $state : state != null, $owner : owner )
then
    //System.out.println( "TODO Persist in HTS that : State changed for " + $tid + " >> " + $state + "(" + $owner + ")" );
end










rule "Create Tx Qs"
salience 1
when
    $t :  InteractiveTask( $tid : taskId, surveyableTx == true, $own : owner, controlQuestId == null )
    not   TaskTransitionHolder( taskId == $tid )
then
    TaskTransitionHolder holder = new TaskTransitionHolder( );
        holder.setQuestionnaireId( java.util.UUID.randomUUID().toString() );
        holder.setTaskId( $tid );
        holder.setOwner( $t.getOwner() );
    //System.out.println( "Create interactive task transition Quest' >>>>>>>>>>>" +  holder + " for " + $t + " with owner " + $t.getOwner() );
    insert( holder );
    modify ( $t ) {
        setControlQuestId( holder.getQuestionnaireId() );
    }
end

rule "Clear Tx Qs"
when
    $t : TaskTransitionHolder( $tid : taskId )
    not  InteractiveTask( $tid == taskId )
then
    //System.out.println(" @@@@ Retracting TTH " + $tid );
    retract( $t );
end






rule "Answer tx"
when
    $holder : TaskTransitionHolder( $tid : taskId, $tranx : transition != null,
                                    $designatedOwner : owner,
                                    owner != null
                                    || transition == TaskTransitions.ACTIVATE.name
                                    || transition == TaskTransitions.SUSPEND.name
                                    || transition == TaskTransitions.RESUME.name )
    ?taskInfo( $tid, $descr, $owner, $owners, $state, $lastChange, $persistent ; )
then
    //System.out.println(" Preparing a tx " + $tranx );
    modify ( $holder ) {
        setTransition( null );
    }
    insert( new TaskStateTransition( $tid, TaskTransitions.valueOf( $tranx ), $designatedOwner, new Date() ) );
end

rule "Undo Answer tx"
when
    $holder : TaskTransitionHolder( $tid : taskId, owner == null,
                                    transition != null
                                    && != TaskTransitions.ACTIVATE.name
                                    && != TaskTransitions.SUSPEND.name
                                    && != TaskTransitions.RESUME.name )
    ?taskInfo( $tid, $descr, $owner, $owners, $state, $lastChange, $persistent ; )
then
    //System.out.println("Trax nont allowed since user is null");
    modify ( $holder ) {
        setTransition( null );
    }
end

rule "Infer owner"
when
    $holder : TaskTransitionHolder( $tid : taskId, owner == null,
                                    $tranx : transition != null )
    ?taskInfo( $tid, $descr, $owner, null, $state, $lastChange, $persistent ; )
//    HumanTask( $tid, $descr, $owner, null, $state, $lastChange, $persistent ; )
then
    //System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><Trax with INFERRED OWNER " + $owner );
    modify ( $holder ) {
        setTransition( null );
    }

    TaskStateTransition tst = new TaskStateTransition( $tid, TaskTransitions.valueOf( $tranx ), $owner, new Date() );
    insert( tst );
end





rule "Clear transition when owner changes"
salience 99999
when
    $ans: MultipleChoiceQuestion( type == "owner", lastAnswer != null, $ctrlQuestId : context )
          InteractiveTask( $taskId : taskId, controlQuestId == $ctrlQuestId )
    $trn: MultipleChoiceQuestion( type == "transition", $qid : id, lastAnswer != null, context == $ctrlQuestId )
//    $dma: DomainModelAssociation( questionId == $qid )
then
    //System.out.println( " I SHOULD NULLIFY THE TRANSITION ! " );
    modify ( $trn ) { setLastAnswer( null ); }
//    modify ( $dma ) { setLastAnswer( null ); }
end