Subversion Repositories SmartDukaan

package in.shop2020.util;

import java.util.ArrayList;

import java.util.Date;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import in.shop2020.metamodel.core.Entity;

import in.shop2020.metamodel.core.EntityState;

import in.shop2020.metamodel.core.EntityStatus;

import in.shop2020.metamodel.util.CreationUtils;

import in.shop2020.metamodel.util.ExpandedEntity;

import in.shop2020.model.v1.catalog.InventoryService.Client;

import in.shop2020.model.v1.catalog.Item;

import in.shop2020.model.v1.catalog.status;

import in.shop2020.thrift.clients.CatalogServiceClient;

import in.shop2020.ui.util.NewVUI;

import org.apache.commons.cli.*;

public class ContentGenerationUtility {

    private static Options options = null; // Command line options

    private static final String GENERATION_TYPE_OPTION = "t";

    private static final String ENTITY_ID_OPTION = "e";

    private static String GENERATION_TYPE = "INCREMENTAL";

    private static String ENTITY_ID = "ALL";

    Map<Long, Entity> entities;

    List<Item> items;

    List<Item> contentCompleteItems;

    CatalogServiceClient csc;

    Client client;

    Map<Long, List<Item>> entityIdItemMap = new LinkedHashMap<Long, List<Item>>();

    private CommandLine cmd = null; // Command Line arguments

    Long lastGenerationTime;

    static{

        options = new Options();

        options.addOption(GENERATION_TYPE_OPTION, true, "Generation type");

        options.addOption(ENTITY_ID_OPTION, true, "all entities " + ENTITY_ID + " by default");

    }

    public ContentGenerationUtility() throws Exception{

        csc = new CatalogServiceClient();

        client = csc.getClient();

    }

    /**

     * @param args

     * @throws Exception 

     */

    public static void main(String[] args) throws Exception {

        ContentGenerationUtility cgu = new ContentGenerationUtility();

        cgu.loadArgs(args);

        cgu.generateContent();

    }

    /**

     * Validate and set command line arguments.

     * Exit after printing usage if anything is astray

     * @param args String[] args as featured in public static void main()

     */

    private void loadArgs(String[] args){

        CommandLineParser parser = new PosixParser();

        try {

            cmd = parser.parse(options, args);

        } catch (ParseException e) {

            System.err.println("Error parsing arguments");

            e.printStackTrace();

            System.exit(1);

        }

        // Check for mandatory args

        if (! cmd.hasOption(GENERATION_TYPE_OPTION)){

            HelpFormatter formatter = new HelpFormatter();

            formatter.printHelp("java ContentGenerationUtility.class -t {ALL,INCREMENTAL,ONE} -e {EntityId} ", options);

            System.exit(1);

        }

        GENERATION_TYPE = cmd.getOptionValue(GENERATION_TYPE_OPTION);

        // Look for optional args.

        if(GENERATION_TYPE.equals("ONE")){

            if (cmd.hasOption(ENTITY_ID_OPTION)){

                ENTITY_ID = cmd.getOptionValue(ENTITY_ID_OPTION);

            }else{

                HelpFormatter formatter = new HelpFormatter();

                formatter.printHelp("java ContentGenerationUtility.class -t {ALL,INCREMENTAL,ONE} -e {EntityId} ", options);

                System.exit(1);

            }

        }

    }

    /**

     * Generates content for the specified entity embedding links to the

     * specified domain name.

     * 

     * The method updates the member variable problems in any of the following

     * four cases:

     * <ol>

     * <li>The entity is not ready.

     * <li>The category has not been updated yet. (Set to -1).

     * <li>There are no items in the catalog corresponding to this entity.

     * <li>There are no active or content-complete items in the catalog

     * corresponding to this entity.

     * <li>Neither the items have been updated nor the content has been updated.

     * </ol>

     * 

     * @param entity

     *            - Entity for which the content has to be generated.

     * @param domain

     *            - The domain name to be used to serve static content.

     * @param exportPath

     *            - Local file system path where content has to be generated.

     * @return -True if content is generated successfully, False otherwise.

     * @throws Exception

     */

    /**

     * 

     */

    private void generateContent() throws Exception{

        if(GENERATION_TYPE.equals("ALL") || GENERATION_TYPE.equals("ONE")) {

            lastGenerationTime = new Long(0);   

        }else{

            lastGenerationTime = CreationUtils.getLastContentGenerationTime();

            if(lastGenerationTime==null){

                lastGenerationTime = new Long(0);

            }    

        }

        if(GENERATION_TYPE.equals("ONE")) {

            items = client.getItemsByCatalogId(Long.parseLong(ENTITY_ID));

            contentCompleteItems = new ArrayList<Item>();

            for(Item item: items){

                if(item.getItemStatus() == status.CONTENT_COMPLETE){

                    contentCompleteItems.add(item);

                }

            }

        }else{

            contentCompleteItems = client.getAllItemsByStatus(status.CONTENT_COMPLETE);

            items = client.getAllItemsByStatus(status.ACTIVE);

            items.addAll(client.getAllItemsByStatus(status.PAUSED));

            items.addAll(contentCompleteItems);

        }

        //If non incremental content needs to be generated

        if(GENERATION_TYPE.equals("INCREMENTAL")) {

        }

        removeInvalidItems();

        NewCMP cmp = new NewCMP(entityIdItemMap);

        Map<Long, Map<Long, Double>> slideScoresByEntity = cmp.getSlideScores();

//        Utils.info("slideScoresByEntity=" + slideScoresByEntity);

        CreationUtils.storeSlideScores(slideScoresByEntity);

        NewVUI vui = new NewVUI(lastGenerationTime);

        for(long entityID: entityIdItemMap.keySet()){

            //TODO Domain name and destination  directory should be read from properties file 

            vui.generateHtmlForOneEntity(CreationUtils.getEntity(entityID), "saholic.com", Utils.EXPORT_ENTITIES_PATH_SAHOLIC, entityIdItemMap.get(entityID));

            vui.generateHtmlForOneEntity(CreationUtils.getEntity(entityID), "shop2020.in", Utils.EXPORT_ENTITIES_PATH_SHOP2020, entityIdItemMap.get(entityID));

            vui.generateHtmlForOneEntity(CreationUtils.getEntity(entityID), "localhost:8090", Utils.EXPORT_ENTITIES_PATH_LOCALHOST, entityIdItemMap.get(entityID));

        }

        // Mark content-complete items as active after the content has been

        // generated

        for(Item item:contentCompleteItems){

            item.setItemStatus(status.ACTIVE);

            item.setStatus_description("This item is active");

            client.updateItem(item);

        }

        NewIR ir = new NewIR(entityIdItemMap);

        ir.exportIRData();

        ir.transformIrDataXMLtoSolrXML();

        ir.exportIRMetaData();

        ir.transformIrMetaDataXMLSolrSchemaXML();

    }

    /**

     * Iterate through all candidate items and remove item if one of following conditions met.

     * <li> If item is not in one  of three states ( ACTIVE, CONTENT_COMPLETE, PAUSED)

     * <li> If Entity is invalid 

     * <li> If neither content nor item is updated after last content generation

     *   

     * @throws Exception 

     *   

     */

    private void removeInvalidItems() throws Exception{

        entities =  CreationUtils.getEntities();

        Date todate = new Date();

        for(Item item: items){            

            List<Item> itemList = entityIdItemMap.get(item.getCatalogItemId());

            //TODO Can be removed as we are checking in calling function

            if(!(item.getItemStatus()==status.ACTIVE || item.getItemStatus()==status.CONTENT_COMPLETE || item.getItemStatus() == status.PAUSED)){

                continue;

            }

            if(todate.getTime() < item.getStartDate()){

                continue;

            }

            if(itemList == null){

                if(!isValidEntity(entities.get(item.getCatalogItemId()))){

                    continue;

                }

                itemList = new ArrayList<Item>();

            }

            itemList.add(item);

            entityIdItemMap.put(item.getCatalogItemId(), itemList);

        }

        /**

         * Remove all items which have not been updated ever.

         */

        List<Long> removeEntities = new ArrayList<Long>();

        for(Long entityId:entityIdItemMap.keySet()){

            boolean isValidEntity = false;

            //If any one of the items has been updated since last generation timestamp, than we generate content for whole entity

            for(Item item: entityIdItemMap.get(entityId)){

                if(item.getUpdatedOn() > this.lastGenerationTime){

                    isValidEntity = true;

                }

            }

            if(!isValidEntity){

                removeEntities.add(entityId);

            }

        }

        for(Long entityId: removeEntities){

            entityIdItemMap.remove(entityId);

        }

    }

    /**

     * Checks weather entity is valid or not. Entity will be invalid in one of these cases:

     * <ol>

     * <li>The entity is not ready.

     * <li>The category has not been updated yet. (Set to -1).

     * <li>Content has not been updated after last content generation timestamp.

     * </ol>

     * 

     * @param entity

     * @return

     * @throws Exception

     */

    private boolean isValidEntity(Entity entity) throws Exception{

        ExpandedEntity expEntity = new ExpandedEntity(entity);

        EntityState state = CreationUtils.getEntityState(entity.getID());

        long categoryID = expEntity.getCategoryID();

        if(state.getStatus() != EntityStatus.READY ||  categoryID == -1){

            return false;

        }

        if(state.getMerkedReadyOn().getTime() < this.lastGenerationTime){

            return false;

        }

        return true;

    }

}