Subversion Repositories SmartDukaan

package in.shop2020.creation.controllers;

import in.shop2020.content.security.UserManager;

import in.shop2020.creation.util.ContentValidator;

import in.shop2020.metamodel.core.Bullet;

import in.shop2020.metamodel.core.Entity;

import in.shop2020.metamodel.core.EntityState;

import in.shop2020.metamodel.core.EntityStatus;

import in.shop2020.metamodel.core.EnumDataObject;

import in.shop2020.metamodel.core.Feature;

import in.shop2020.metamodel.core.FreeformContent;

import in.shop2020.metamodel.core.Media;

import in.shop2020.metamodel.core.Media.Type;

import in.shop2020.metamodel.core.Slide;

import in.shop2020.metamodel.definitions.Catalog;

import in.shop2020.metamodel.util.CreationUtils;

import in.shop2020.thrift.clients.CatalogClient;

import in.shop2020.util.Utils;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.List;

import java.util.Map;

import org.apache.commons.io.IOUtils;

import org.apache.juli.logging.Log;

import org.apache.juli.logging.LogFactory;

import org.apache.struts2.convention.annotation.InterceptorRef;

import org.apache.struts2.convention.annotation.InterceptorRefs;

import org.apache.struts2.convention.annotation.Result;

import org.apache.struts2.convention.annotation.Results;

@InterceptorRefs({

    @InterceptorRef("myDefault"),

    @InterceptorRef("login")

})

@Results({

    @Result(name="success", type="redirectAction", 

    		params = {"actionName" , "entity"})

})

public class ItemUpdateController extends BaseController {

	private static final long serialVersionUID = 7180013499003793197L;

	private String id;

	private static Log log = LogFactory.getLog(ItemUpdateController.class);

	public String show(){

		if(this.reqparams.get("action") !=null){

			long entityId = Long.parseLong(getId());

			String action = this.reqparams.get("action")[0];

			if(action.equalsIgnoreCase("complete")){

				if(!UserManager.getUserManager().canComplete(getUsername(), entityId)){

					addActionError("Can not complete because this entity is not assigned to you.");

					return "success";	

				}

				try {

					Entity entity = CreationUtils.getEntity(entityId);

					ContentValidator validator = new ContentValidator();

					if(!validator.validate(entity)){

						addActionError("Entity is not yet complete because some mandatory fields are not filled.");

						return "success";

					}

					EntityState state = CreationUtils.getEntityState(entityId);

					state.completeEntity(this.getUsername());

					CreationUtils.updateEntityState(state);

				} catch (Exception e) {

					e.printStackTrace();

				}

				addActionMessage("Entity completed successfully");

				return "success";

			}

			if(action.equalsIgnoreCase("assign")){

				if(this.reqparams.get("username") !=null){

				    if(!UserManager.getUserManager().canAssign(getUsername(), entityId)){

						addActionError("You do not have rights to assign an entity");

						return "success";	

					}

					String assignTo = this.reqparams.get("username")[0];

					System.out.println("User name is " + assignTo);

					try {

						EntityState state = CreationUtils.getEntityState(entityId);

						if(state.getStatus() == EntityStatus.READY){

						    Calendar cl = Calendar.getInstance();

						    int hourOfDay = cl.get(Calendar.HOUR_OF_DAY);

						    int minuteOfHour = cl.get(Calendar.MINUTE);

						    int totalMinutes = 60*hourOfDay + minuteOfHour;  

		                    if(totalMinutes > 14*60 + 45 && totalMinutes < 15*60 + 30){

		                        addActionError("Sorry.... This is not right time to assign this entity. Please visit after 3.30 PM.");

		                        return "success";   

		                    }

						    List<Long> inconsistentEntities = CreationUtils.getInconsistentEntities();

						    if(inconsistentEntities == null){

						        inconsistentEntities = new ArrayList<Long>();

						    }

						    inconsistentEntities.add(state.getID());

						    CreationUtils.storeInconsistentEntities(inconsistentEntities);

						}

						state.assignEntity(this.getUsername(), assignTo);

						CreationUtils.updateEntityState(state);

					} catch (Exception e) {

						e.printStackTrace();

					}

					addActionMessage("Entity assigned to " + assignTo + " successfully");

					return "success";

				}

			}

			if (action.equalsIgnoreCase("dup-entity")) {

				if (!UserManager.getUserManager().canAssign(getUsername(),

						entityId)) {

					addActionError("You do not have rights to clone entites.");

					return "success";

				}

				String dupEntityId = this.reqparams.get("entity-old")[0];

				log.info("Duplicate Entity is " + dupEntityId);

				try {

					Entity newEntity = CreationUtils.getEntity(entityId);

					Entity dupEntity = CreationUtils.getEntity(Long

							.parseLong(dupEntityId));

					List<Slide> slides = dupEntity.getSlides();

					List<Slide> newSlides = new ArrayList<Slide>();

					for (Slide slide : slides) {

						// Serializing and deserializing to clone the slide

						// serialize

						ByteArrayOutputStream bos = new ByteArrayOutputStream();

						ObjectOutputStream out = new ObjectOutputStream(bos);

						out.writeObject(slide);

						// De-serialization

						ByteArrayInputStream bis = new ByteArrayInputStream(

								bos.toByteArray());

						ObjectInputStream in = new ObjectInputStream(bis);

						Slide newSlide = (Slide) in.readObject();

						newSlides.add(newSlide);

					}

					//for all new slides update the mediatypes and create new mediastore for this entity

					List<Slide> allSlides = new ArrayList<Slide>();

					allSlides.addAll(newSlides);

					for(Slide sl: newSlides){

						if(sl.hasChildrenSlides()){

							allSlides.addAll(sl.getChildrenSlides());

							for(Slide sl1 : sl.getChildrenSlides()){

								if(sl1.hasChildrenSlides()){

									allSlides.addAll(sl.getChildrenSlides());

								}

							}

						}

					}

					for(Slide sl : allSlides){

						FreeformContent ffc = sl.getFreeformContent();

						if(ffc==null){

							continue;

						}

						Map<String, Media> mediaMap = ffc.getMedias();

						if(mediaMap==null){

							continue;

						}

						for(Media media : mediaMap.values()){

							if(media.getType().equals(Type.IMAGE) || media.getType().equals(Type.DOCUMENT)){

								copyMedia(String.valueOf(entityId), dupEntityId, media);

							}

						}

					}

					List<Long> slideSequence = dupEntity.getSlideSequence();

					List<Long> newSlideSequence = new ArrayList<Long>(slideSequence);

					newEntity.setSlides(newSlides);

					newEntity.setSlideSequence(newSlideSequence);

					CreationUtils.updateEntity(newEntity);

				} catch (Exception e) {

					addActionError(dupEntityId + " is not a valid Entity.");

					e.printStackTrace();

					return "success";

				}

				addActionMessage("Entity " + entityId + " has been cloned successfully");

				return "success";

			}

			if(action.equalsIgnoreCase("ready")){

				if(!UserManager.getUserManager().canMarkReady(getUsername(), entityId)){

					addActionError("You do not have rights to mark entity as ready");

					return "success";	

				}

				try {

				    EntityState state = CreationUtils.getEntityState(entityId);

				    //For all android phones in mobile category, we should enable data pack. 

				    boolean isAndroid = false;

				    if(state.getCategoryID() == 10006){

				    	Entity e = CreationUtils.getEntity(entityId);

				    	Slide slide = e.getSlide(130020);

				    	if(slide != null)  {

				    		List<Feature> fs = slide.getFeatures();

				    		if (fs!=null){

				    			for (Feature f1 : fs){

				    				if(f1.getFeatureDefinitionID()==120043l){

				    					List <Bullet> bullets = f1.getBullets();

				    					if(bullets != null) {

				    						for(Bullet b : bullets){

				    							String bulletString = Catalog.getInstance().getDefinitionsContainer().getEnumValue(((EnumDataObject)b.getDataObject()).getEnumValueID()).getValue();

				    							if (bulletString.contains("Android")){

				    								isAndroid = true;

				    								log.info("Is android marked true for " + entityId);

				    								break;

				    							}

				    						}

				    					}

				    				}

				    			}

				    		}

				    	}

				    }

					CatalogClient csc = new CatalogClient();

					in.shop2020.model.v1.catalog.CatalogService.Client iclient = csc.getClient();

					iclient.markItemAsContentComplete(entityId, state.getCategoryID(), state.getBrand(), state.getModelName(), state.getModelNumber(), isAndroid);	

                    List<Long> inconsistentEntities = CreationUtils.getInconsistentEntities();

                    if(inconsistentEntities != null){

                        inconsistentEntities.remove(state.getID());

                        CreationUtils.storeInconsistentEntities(inconsistentEntities);

                    }

					state.readyEntity(getUsername());

					CreationUtils.updateEntityState(state);

					addActionMessage("Entity marked as ready successfully");

				} catch (Exception e) {

					addActionError("Unable to mark entity as ready.");

					e.printStackTrace();

				}

				return "success";

			}

			if(action.equalsIgnoreCase("iteminfo")){

				return "iteminfo";

			}

		}

		addActionError("There is some problem, please contact admin.");

		return "success";

	}

	public String getId(){

		return this.id;

	}

	public void setId(String id){

		this.id = id;

	}

	/**

	 * 

	 * @throws Exception

	 */

	private void copyMedia(String newEntityId, String oldEntityId, Media media) throws Exception {

		String mediaDirPath = Utils.CONTENT_DB_PATH + "media" + File.separator + newEntityId;

		File mediaDir = new File(mediaDirPath);

		if(!mediaDir.exists()) {

			mediaDir.mkdir();

		} 

		String mediaFilePath = mediaDirPath + File.separator + media.getFileName();

		String oldMediaFilePath = media.getLocation();

		File mediaFile = new File(mediaFilePath);

		log.info("Media File ---------" + mediaFile);

		mediaFile.createNewFile();

		File oldMediaFile = new File(oldMediaFilePath);

		InputStream in = new FileInputStream(oldMediaFile);

		// appending output stream

		// @rajveer : replacing the existing file 

		OutputStream out = new FileOutputStream(mediaFile); 

		try {

			IOUtils.copy(in, out);

		}

		finally {

			IOUtils.closeQuietly(in);

			IOUtils.closeQuietly(out);

		}

		media.setLocation(mediaFilePath);

	}

}