/**
 * A POJO account object used for query containing four fields: 
 * firstName, lastName, amount and riskAllowed
 * 
 * Annotations:
 * @SpaceProperty(index=IndexType.BASIC) annotated getters mark the attribute as indexed.
 * Querying indexed fields speeds up read and take operations. 	
 * 
 * @SpaceClass annotation in this example is only to indicate that this class is a space class.
 */
@SpaceClass 
public class Account {
	
	private String firstName;
	private String lastName;
	private Integer amount;
	private Integer riskAllowed;
	.
	.
	/** 
	 *  <code>@SpaceProperty</code> Defines this field data as indexed.
	 *  Querying indexed fields speeds up read and take operations. Possible values of NONE and BASIC.
	 */
	@SpaceProperty(index=IndexType.BASIC)
	public String getFirstName() {
		return firstName;
	}
	.
	.
	more constructors/setters/getters	
}

/**
 * Some important properties:
 * orderID - annotated as the object unique space id (see the getter method for the annotation).
 * firstName (used to perform routing when working with partitioned space, see getter method for annotation).
 * status - indicating if this OrderEvent object in new, processed, or rejected.
 * type - Normal or Insecure
 * 
 * Annotations:
 * 
 * Fields with getters annotated as @SpaceProperty(index=IndexType.BASIC) are indexed.
 * Querying indexed fields speeds up read and take operations.
 * 
 * @SpaceRouting annotation (see getFirstName()) indicates that firstName field 
 * will be used as a routing index to perform routing when working with partitioned space.
 *
 * @SpaceClass annotation in this example is only to indicate that this class is a space class.
 */ 
@SpaceClass
public class OrderEvent {
	
	public static final String STATUS_NEW = "New";	
	public static final String STATUS_APPROVED = "Approved";	
	public static final String STATUS_REJECTED = "Rejected";
	public static final String PRIORITY_URGENT = "Insecure";
	public static final String PRIORITY_NORMAL = "Normal";
    
    private String orderID;
    private String feederID;
    private String firstName;
    private String lastName;
    private Integer riskInvolved;
    private Integer price;

    /**	Order status, Possible values: New, Approved, Rejected. */
    private String status;
    
    /**	Order type, Possible values: Normal, Insecure */
    private String type;		
    
    /** 
     * Gets the ID of the orderEvent.
     * @SpaceID annotation indicates that its value will be auto generated 
     * when it is written to the space. 
     */
    @SpaceId(autoGenerate = true)
    public String getOrderID() {
        return orderID;
    }
    
    /** 
     * @return userName - Gets the user name of the orderEvent object.
     * @SpaceProperty Defines if this field data is indexed.
	 */
    @SpaceProperty(index = IndexType.BASIC)
    public String getFirstName() {
        return firstName;
    }
    .
    .
    more constructors/getters/setters
    
}

/*
 * Copyright 2008 GigaSpaces Technologies Ltd. All rights reserved.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY AND 
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. GIGASPACES WILL NOT 
 * BE LIABLE FOR ANY DAMAGE OR LOSS IN CONNECTION WITH THE SOFTWARE.
 */

package com.gigaspaces.examples.tutorials.queries.feeder;

import org.openspaces.core.GigaSpace;
import org.openspaces.core.context.GigaSpaceContext;

import org.springframework.beans.factory.InitializingBean;
import com.gigaspaces.examples.tutorials.queries.common.Account;

/**
 * A loader bean that writes Account objects with unique user names to the
 * space. Since the write is executed in the init() method called directly in the afterPropertiesSet method
 * (and not in a new thread), the processing unit waits until the loading is
 * finished before initializing the next bean.
 */
public class AccountPreLoader implements InitializingBean {

	/**
	 * Number of accounts to be loaded by the loader, hard-coded to 100, can be overridden 
	 * in the pu.xml (by setting the prop key "numberOfAccounts")
	 */
	private int numberOfAccounts = 100;
	
	@GigaSpaceContext(name = "gigaSpace")
    private GigaSpace gigaSpace;
	
	public void setGigaSpace(GigaSpace gigaSpace) {
		this.gigaSpace = gigaSpace;
	}

	/**
	 * Allows to control the number of accounts that will be initially
	 * loaded to the Space. Defaults to <code>100</code>.
	 */
	public void setNumberOfAccounts(int numberOfAccounts) {
		this.numberOfAccounts = numberOfAccounts;
	}

	/**
	 * The first method to run upon bean Initialization when implementing InitializingBean.
	 * Runs the pre-loader init() method 
	 */
	public void afterPropertiesSet() throws Exception {
		init();	
	}
	
	/**
	 * init - Initializes the pre-loader:
	 * Writes <numberOfAccounts> unique accounts to the space.
	 */
	public void init() throws Exception {
		
		System.out.println("\nFeeder Pre-Loader Starts writing accounts");
		// Writing <numberOfAccounts> accountData objects to the space.
		for (int i = 1; i <= numberOfAccounts; i++) {
			Account account = new Account("FN"+i /* firstName */
								,"LN"+i /* lastName */
								,1000 /* amount */
								,50); /* riskAllowedFactor */
			gigaSpace.write(account);
		}

		System.out.println("Feeder Wrote "+numberOfAccounts+" Accounts\n");
	}
	
}

/*
 * Copyright 2008 GigaSpaces Technologies Ltd. All rights reserved.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY AND 
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. GIGASPACES WILL NOT 
 * BE LIABLE FOR ANY DAMAGE OR LOSS IN CONNECTION WITH THE SOFTWARE.
 */

package com.gigaspaces.examples.tutorials.queries.feeder;

import org.openspaces.core.GigaSpace;
import org.openspaces.core.context.GigaSpaceContext;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

import com.gigaspaces.examples.tutorials.queries.common.OrderEvent;

import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

/**
 * A feeder bean that starts a scheduled task that writes a new OrderEvent object to the space.
 * The orderEvent type attribute is set randomly to "normal" or "Insecure". <p>
 * 
 * The space is injected into this bean using OpenSpaces support for @GigaSpaceContext
 * annotation. <p>
 * 
 * The scheduled support uses the java.util.concurrent Scheduled Executor Service. It
 * is started and stopped based on Spring life-cycle events.
 */
public class OrderEventFeeder implements InitializingBean, DisposableBean {

	private Random randomGen = new Random();
	
    private ScheduledExecutorService executorService;

    //	Delayed result bearing action
    private ScheduledFuture<?> sf;
    
    /**
     * Delay between scheduled tasks
     */
    private long defaultDelay = 1000;
    
    /**
     * The scheduled orderEvent feeding task.
     */ 
    private OrderEventFeederTask orderEventFeederTask;
    
    @GigaSpaceContext(name = "gigaSpace")
    private GigaSpace gigaSpace;
    
    public void setGigaSpace(GigaSpace gigaSpace) {
		this.gigaSpace = gigaSpace;
	}
    
    /**
     * Unique ID for this client
     */
    private Double feederID;
    
    /**
     * @param defaultDelay - Sets default delay between feeding tasks.
     */
    public void setDefaultDelay(long defaultDelay) {
        this.defaultDelay = defaultDelay;
    }
    
	/**
	 * The first method to run upon bean Initialization, when implementing InitializingBean.
	 * Runs init() method which starts a scheduled orderEvent feeding task. 
	 */
	public void afterPropertiesSet() throws Exception {
		init();
    }
	
	/**
	 * init - Starts a scheduled orderEvent feeding task.
	 * @throws Exception
	 */
	public void init() throws Exception {
    	
		//	Create unique ID for this feeder
		feederID = new Double(System.nanoTime()); 
		
		System.out.println("Feeder ["+feederID.toString()+"], Starting order feeding cycles (Delay between cycles "+defaultDelay+" msec)");
        
		//	Create a thread pool containing 1 thread capable of performing scheduled tasks
        executorService = Executors.newScheduledThreadPool(1);
        
        orderEventFeederTask = new OrderEventFeederTask();
        
        //	Schedule the thread to execute the task at fixed rate with the default delay defined 
        sf = executorService.scheduleAtFixedRate(
        										orderEventFeederTask	// The task to schedule
        										,defaultDelay 			// Initial Delay before starting
        										,defaultDelay			// Delay between tasks
        										,TimeUnit.MILLISECONDS	// Time unit for the delay
        										);
    }
	
    public void destroy() throws Exception {
    	//	Shutting down the thread pool upon bean disposal
    	sf.cancel(true);
        sf = null;
        executorService.shutdown();
    }

    public class OrderEventFeederTask implements Runnable {
    	
    	//	Counts number of fed orderEvents
        private int counter;

    	Integer randomizedNameSuffix;
    	String randomizedType;
    	
        public void run() {
            try { 
            	
            	//	Prepare randomized values to set the orderEvent attributes with
            	randomizedNameSuffix = randomGen.nextInt(99)+1;
            	if (randomGen.nextBoolean()) {
            		randomizedType=OrderEvent.TYPE_NORMAL;
            	}
            	else {
            		randomizedType=OrderEvent.TYPE_INSECURE;
            	}
            	
            	//	Create a new orderEvent with randomized attributes
            	OrderEvent orderEvent = new OrderEvent("FN" + randomizedNameSuffix /* firstName */
            											,"LN" + randomizedNameSuffix/* lastName */
            											,feederID.toString() /* feederID */
            											,randomizedType /* type */
            											,randomGen.nextInt(99)+1 /* riskInvolvedFactor */
            											,(randomGen.nextInt(19)+1)*100); /* price */
            	            	
                //	Write the new orderEvent to the space
            	gigaSpace.write(orderEvent);
                System.out.println("\nFeeder wrote order:\n"+orderEvent);
            } 
            catch (Exception e) {
                e.printStackTrace();
            }
        }

        public int getCounter() {
            return counter;
        }
    }

    public int getFeedCount() {
        return orderEventFeederTask.getCounter();
    }

	public void setFeederID(Double feederID) {
		this.feederID = feederID;
	}

	public Double getFeederID() {
		return feederID;
	}
}

/*
 * Copyright 2008 GigaSpaces Technologies LTD. All rights reserved.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY AND 
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. GIGASPACES WILL NOT 
 * BE LIABLE FOR ANY DAMAGE OR LOSS IN CONNECTION WITH THE SOFTWARE.
 */

package com.gigaspaces.examples.tutorials.queries.validator;

import org.openspaces.core.GigaSpace;
import org.openspaces.events.adapter.SpaceDataEvent;

import com.gigaspaces.examples.tutorials.queries.common.Account;
import com.gigaspaces.examples.tutorials.queries.common.OrderEvent;

import com.j_spaces.core.client.SQLQuery;

/**
 * Simple bean used to validate the "Normal" orderEvent objects.
 * Showing use of template parameterized query.
 */
public class NormalOrderEventValidator {
	
	private long workDuration = 100;
    
	/**
     * Sets the simulated work duration (in milliseconds). Default to 100.
     */
    public void setWorkDuration(long workDuration) {
        this.workDuration = workDuration;
    }

    /**
     * Validates the given OrderEvent object and returns the validated OrderEvent with
     * status field set to Approved/Rejected according to the validation.
     * Can be invoked using OpenSpaces Events when a matching event
     * occurs.
     * The order is approved if an account for the user is found holding enough money 
     * to buy the order (compared to orderEvent.price attribute).
     */
    @SpaceDataEvent	//	This annotation marks the method as the event listener.
    public OrderEvent validatesOrderEvent(OrderEvent orderEvent, GigaSpace gigaSpace) {
            	    	
    	// sleep to simulate some work
        try {
            Thread.sleep(workDuration);
        } catch (InterruptedException e) {
            // do nothing
        }
     
        System.out.println("\nValidator validates [Normal] order: First Name["+orderEvent.getFirstName()+
        															"] Last Name ["+orderEvent.getLastName()+
        															"] Price ["+orderEvent.getPrice()+"]");
        
        // Querying using template query
        // =============================
        // Create the template for the query
        Account queryTemplate = new Account(orderEvent.getFirstName()/* account first name*/ 
        									,orderEvent.getLastName()/* account last name*/ 
        									,orderEvent.getPrice());/* account amount*/
        
        // Create the query using the values from the template, each ? sign is replaced with the corresponding value 
        // The query is actually "firstName=(queryTemplate.firstName) and lastName=(queryTemplate.lastName) and amount>(queryTemplate.amount)" 
        SQLQuery<Account> query = new SQLQuery<Account>(queryTemplate,"firstName = ? and lastName = ? and amount > ?");
		
        // REMARK: Instead of using the constructor the query can also be 
        // set using the setTemplate and setQuery methods:
        // ===============================================
        // query.setTemplate(queryTemplate);
        // query.setQuery("firstName = ? and lastName = ? and amount > ?");
        
        // Read from the space the account matching the query
        Account account=(Account)gigaSpace.read((Object)query);

        // Set the order status according to the query result
        if (account!= null)
		{
			orderEvent.setStatus(OrderEvent.STATUS_APPROVED);
		}
		else 
		{
			orderEvent.setStatus(OrderEvent.STATUS_REJECTED);
		}       
        
		System.out.println("Validator set order status to: ["+orderEvent.getStatus()+"]");
		
        //  orderID is declared as primary key and as auto-generated. 
    	//	It must be null before writing an operation.
    	orderEvent.setOrderID(null);
    	
        return orderEvent;
    }
}

/*
 * Copyright 2008 GigaSpaces Technologies LTD. All rights reserved.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY AND 
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. GIGASPACES WILL NOT 
 * BE LIABLE FOR ANY DAMAGE OR LOSS IN CONNECTION WITH THE SOFTWARE.
 */

package com.gigaspaces.examples.tutorials.queries.counter;

import java.util.concurrent.atomic.AtomicInteger;

import org.openspaces.core.GigaSpace;
import org.openspaces.core.IteratorBuilder;
import org.openspaces.core.context.GigaSpaceContext;

import org.springframework.beans.factory.InitializingBean;

import com.gigaspaces.examples.tutorials.queries.common.Account;
import com.gigaspaces.examples.tutorials.queries.common.OrderEvent;

import com.j_spaces.core.client.GSIterator;
import com.j_spaces.core.client.SQLQuery;

/**
 * Simple bean used to read and display the "Insecure" orderEvent objects.
 * Shows use of GSIterator.
 */
public class RiskyOrderEventCounter implements InitializingBean{
	
	private AtomicInteger riskyOrderEventCounter = new AtomicInteger(0);
	
	@GigaSpaceContext(name = "gigaSpace")
    private GigaSpace gigaSpace;
	
	public void setGigaSpace(GigaSpace gigaSpace) {
		this.gigaSpace = gigaSpace;
	}
	
	/**
	 * The first method to run upon bean Initialization when implementing InitializingBean.
	 * Runs the init() method 
	 */
	public void afterPropertiesSet() throws Exception {
		init();	
	}

	/**
	 * Starts a new thread running the OrderEventIteratorTask. 
	 */
	public void init(){
		Thread thread = new Thread(new OrderEventIteratorTask());
		thread.start();
	}
	
    /**
     * Iterates through all the orderEvents matching the specified templates.
     * Counts every orderEvent read, that has an associated account (same user name as the orderEvent) 
     * with a satisfying risk allowed.
     */
	public class OrderEventIteratorTask implements Runnable {
	    
		// Create a query for "New" and "Insecure" orderEvent objects.
		SQLQuery<OrderEvent> queryInsecureOrders = new SQLQuery<OrderEvent>(OrderEvent.class,"status='"+OrderEvent.STATUS_NEW+"' and type='"+OrderEvent.TYPE_INSECURE+"'");
		
		// Create and configure an iteratorBuilder to build iterators for the space with the specified templates.
		IteratorBuilder iteratorBuilder = new IteratorBuilder(gigaSpace)
											.addTemplate(queryInsecureOrders)
											.bufferSize(100) // Limit of the number of objects to store for each iteration.
											.withHistory(); // Indicates that this iterator will be first pre-filled with matching objects,
															// otherwise it will start iterating only on newly arriving objects to the space.
	    
	    public void run()
	    {
	    	try
	    	{
	    		System.out.println("Counter creats iterator over the space insecure orders:");
	    		// Build the iterator using the previously configured iteratorBuilder.
	    		GSIterator gsIterator = iteratorBuilder.iterate();
	    		
	    		System.out.println("Counter iterator thread reading messages");
	    		
	    		OrderEvent insecureOrderEvent;
	    		
	    		// Create the query for an account object, each ? place-holder will be replaced inside the following loop using the setParameters method.
	    		SQLQuery<Account> accountQuery = new SQLQuery<Account>(Account.class,"firstName = ? and lastName = ? and riskAllowed > ?");
	    		
	    		while (true)
	    		{
	    			while (gsIterator.hasNext())
	    			{
	    				insecureOrderEvent = (OrderEvent)gsIterator.next();
	    				System.out.println("\nCounter examines order: "+insecureOrderEvent);
	    				// Updating the query parameters, the query will actually equal:
	    				// firstName=(accountQuery.firstName value) and lastName=(accountQuery.lastName value) and amount>(accountQuery.amount value) 
	    		        accountQuery.setParameters(insecureOrderEvent.getFirstName(), /* account user first name*/
	    		        							insecureOrderEvent.getLastName(), /* account user last name*/
	    		        							insecureOrderEvent.getRiskInvolved()); /* account amount*/
	    		        
	    		        // Read an account matching the query
	    		        Account account = (Account)gigaSpace.read((Object)accountQuery);
	    				
	    		        // Set the order status according to the query result
	    		        if (account != null)
	    				{
	    		        	System.out.println("Counter - examined order's risk is higher then allowed.");
	    		        	riskyOrderEventCounter.incrementAndGet();
	    				}
	    		        else
	    		        {
	    		        	System.out.println("Counter - examined order's risk is allowed.");
	    		        }
	    		        	System.out.println("Counter - total of ["+riskyOrderEventCounter+"] insecure risky orders (with risk higher then allowed) counted.");
	    			}
	    		}
    		}
    		catch(Exception e)
    		{
    			e.printStackTrace();
    		}
    	}
	}
}