Subversion Repositories SmartDukaan

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
162 naveen 1 
package in.shop2020.creation.controllers;
2 
 
250 naveen 3 
import in.shop2020.creation.util.ContentValidator;
480 rajveer 4 
import in.shop2020.metamodel.util.CreationUtils;
201 naveen 5 
import in.shop2020.metamodel.core.Bullet;
204 naveen 6 
import in.shop2020.metamodel.core.CompositeDataObject;
162 naveen 7 
import in.shop2020.metamodel.core.Entity;
204 naveen 8 
import in.shop2020.metamodel.core.EnumDataObject;
201 naveen 9 
import in.shop2020.metamodel.core.Feature;
198 naveen 10 
import in.shop2020.metamodel.core.FreeformContent;
201 naveen 11 
import in.shop2020.metamodel.core.PrimitiveDataObject;
198 naveen 12 
import in.shop2020.metamodel.core.Slide;
242 naveen 13 
import in.shop2020.metamodel.definitions.Catalog;
198 naveen 14 
import in.shop2020.metamodel.definitions.Category;
204 naveen 15 
import in.shop2020.metamodel.definitions.CompositeDefinition;
16 
import in.shop2020.metamodel.definitions.CompositePartDefinition;
198 naveen 17 
import in.shop2020.metamodel.definitions.DefinitionsContainer;
310 rajveer 18 
import in.shop2020.metamodel.definitions.EditorialImportance;
162 naveen 19 
import in.shop2020.metamodel.definitions.EntityContainer;
201 naveen 20 
import in.shop2020.metamodel.definitions.FeatureDefinition;
21 
import in.shop2020.metamodel.definitions.SlideDefinition;
22 
import in.shop2020.metamodel.definitions.SlideFeatureDefinition;
480 rajveer 23 
import in.shop2020.metamodel.util.CN;
198 naveen 24 
import in.shop2020.metamodel.util.ExpandedBullet;
201 naveen 25 
import in.shop2020.metamodel.util.ExpandedBulletDefinition;
162 naveen 26 
import in.shop2020.metamodel.util.ExpandedEntity;
201 naveen 27 
import in.shop2020.metamodel.util.ExpandedFeature;
28 
import in.shop2020.metamodel.util.ExpandedFeatureDefinition;
198 naveen 29 
import in.shop2020.metamodel.util.ExpandedSlide;
30 
import in.shop2020.metamodel.util.ExpandedSlideDefinition;
162 naveen 31 
import in.shop2020.metamodel.util.SequenceGenerator;
739 chandransh 32 
import in.shop2020.model.v1.catalog.Item;
33 
import in.shop2020.model.v1.catalog.status;
34 
import in.shop2020.thrift.clients.CatalogServiceClient;
162 naveen 35 
import in.shop2020.util.Utils;
36 
 
208 naveen 37 
import java.util.ArrayList;
38 
import java.util.Arrays;
39 
import java.util.Collection;
40 
import java.util.HashMap;
41 
import java.util.List;
42 
import java.util.Map;
450 rajveer 43 
import java.util.StringTokenizer;
208 naveen 44 
 
45 
import org.apache.commons.lang.StringUtils;
162 naveen 46 
import org.apache.juli.logging.Log;
47 
import org.apache.juli.logging.LogFactory;
48 
import org.apache.struts2.convention.annotation.Result;
49 
import org.apache.struts2.convention.annotation.Results;
50 
import org.apache.struts2.interceptor.ParameterAware;
208 naveen 51 
import org.apache.struts2.rest.DefaultHttpHeaders;
52 
import org.apache.struts2.rest.HttpHeaders;
162 naveen 53 
 
242 naveen 54 
import com.opensymphony.xwork2.ValidationAwareSupport;
55 
 
162 naveen 56 
@Results({
57 
    @Result(name="success", type="redirectAction",
198 naveen 58 
    		params = {"actionName" , "entity"}),
59 
    @Result(name="redirect", location="${url}", type="redirect")
162 naveen 60 
})
242 naveen 61 
 
62 
public class EntityController extends ValidationAwareSupport
63 
	implements ParameterAware {
162 naveen 64 
 
65 
	/**
66 
	 *
67 
	 */
242 naveen 68 
	private static final long serialVersionUID = 1L;
69 
 
70 
	/**
71 
	 *
72 
	 */
162 naveen 73 
	private static Log log = LogFactory.getLog(EntityController.class);
74 
 
75 
	/**
76 
	 *
77 
	 */
78 
	private String id;
79 
 
80 
	private ExpandedEntity expEntity;
81 
 
250 naveen 82 
	private Entity entity;
83 
 
162 naveen 84 
	private Collection<Entity> entities;
85 
 
86 
	private Map<String, String[]> reqparams;
87 
 
198 naveen 88 
	private EntityContainer ents;
89 
 
90 
	private DefinitionsContainer defs;
91 
 
213 naveen 92 
	private long firstSlideDefID;
198 naveen 93 
 
94 
	private ExpandedSlideDefinition expSlideDef;
95 
 
96 
	private ExpandedSlide expSlide;
97 
 
98 
	private String redirectURL;
99 
 
100 
	private Exception exception;
101 
 
102 
	private String errorString;
103 
 
104 
	private long newCurrentSlideDefinitionID;
105 
 
106 
	private long newNextSlideDefinitionID;
107 
 
108 
	private long newPrevSlideDefinitionID;
242 naveen 109 
 
250 naveen 110 
	private Map<Long, List<Long>> catSlides;
516 rajveer 111 
 
112 
	private Map<Long, List<Entity>> catEntities;
250 naveen 113 
 
242 naveen 114 
    // GET /entity/1
115 
    public String show() {
116 
    	log.info("EntityController.show");
117 
 
118 
    	try {
119 
    		long entityID = Long.parseLong(this.getId());
120 
    		log.info("entityID:" + entityID);
121 
 
250 naveen 122 
			this.expEntity = this.getExpandedEntity(entityID);
242 naveen 123 
 
124 
			return "show";
125 
		} catch (Exception e) {
126 
			log.error(CreationUtils.getStackTrace(e));
127 
			this.setErrorString(CreationUtils.getStackTrace(e));
128 
			return "fatal";
129 
		}
130 
    }
198 naveen 131 
 
162 naveen 132 
    // GET /entity
133 
    public HttpHeaders index() {
134 
    	log.info("EntityController.index");
135 
 
136 
    	EntityContainer ents = new EntityContainer();
739 chandransh 137 
    	createEntitiesForItemsInProcess();
162 naveen 138 
    	try {
139 
			this.entities = ents.getEntities().values();
516 rajveer 140 
			this.catEntities = ents.getEntitiesbyCategory();
162 naveen 141 
		} catch (Exception e) {
208 naveen 142 
			log.error(CreationUtils.getStackTrace(e));
143 
			this.setErrorString(CreationUtils.getStackTrace(e));
198 naveen 144 
			return new DefaultHttpHeaders("fatal");
162 naveen 145 
		}
146 
 
208 naveen 147 
        return new DefaultHttpHeaders("index").disableCaching();
162 naveen 148 
    }
149 
 
150 
    // GET /entity
151 
    public String create() {
152 
    	log.info("EntityController.create");
153 
 
154 
		SequenceGenerator sg;
155 
		try {
156 
			sg = SequenceGenerator.getInstance();
157 
			long entityID = sg.getNextSequence(SequenceGenerator.ENTITY);
158 
 
159 
			String categoryID = this.reqparams.get("category")[0];
160 
			Entity entity = new Entity(entityID, Long.parseLong(categoryID));
161 
 
162 
			entity.setBrand(this.reqparams.get("brand")[0]);
163 
			entity.setModelName(this.reqparams.get("modelname")[0]);
164 
			entity.setModelNumber(this.reqparams.get("modelnumber")[0]);
165 
 
198 naveen 166 
			this.addEntity(entity);
162 naveen 167 
 
168 
	    	this.setId(new Long(entityID).toString());
169 
		} catch (Exception e) {
208 naveen 170 
			log.error(CreationUtils.getStackTrace(e));
171 
			this.setErrorString(CreationUtils.getStackTrace(e));
198 naveen 172 
			return "fatal";
162 naveen 173 
		}
198 naveen 174 
 
175 
		this.redirectURL = "entity/" + this.getId() + "/edit";
162 naveen 176 
 
198 naveen 177 
		return "redirect";
162 naveen 178 
    }
179 
 
180 
    // GET /entity/1/edit
181 
    public String edit() {
182 
    	log.info("EntityController.edit");
183 
 
184 
    	long entityID = Long.parseLong(this.getId());
185 
    	log.info("entityID:" + entityID);
186 
 
198 naveen 187 
    	DefinitionsContainer defs = this.getDefinitionsContainer();
162 naveen 188 
 
189 
    	try {
250 naveen 190 
			this.expEntity = this.getExpandedEntity(entityID);
198 naveen 191 
			//log.info("this.expEntity:" + this.expEntity);
242 naveen 192 
 
193 
			String[] inputSlideDefIDs = this.reqparams.get("slideDefID");
194 
			long inputSlideDefID = 0L;
195 
			if(inputSlideDefIDs != null && inputSlideDefIDs.length > 0) {
196 
				try {
197 
					inputSlideDefID = Long.parseLong(inputSlideDefIDs[0]);
198 
				} catch (NumberFormatException nfe) {}
199 
			}
310 rajveer 200 
			long categoryID = this.getEntity(entityID).getCategoryID();
201 
 
202 
			log.info("Entity ID:" + entityID + "   CategoryID " + categoryID );
203 
			//Changed to make correct order of borrowed slides
204 
			List<Long> slideDefIDs = CreationUtils.getSlideSequence(entityID, categoryID);
205 
 
242 naveen 206 
			log.info("slideDefIDs:" + slideDefIDs);
198 naveen 207 
 
242 naveen 208 
			// Edit the entity from a specific slide
209 
			if(slideDefIDs != null && inputSlideDefID != 0L) {
210 
 
211 
				// -2 : Not set
212 
				// -1 : Not found
213 
				int currentIndex = slideDefIDs.indexOf(
214 
						new Long(inputSlideDefID));
215 
 
216 
				int nextIndex = -2;
499 rajveer 217 
				if(currentIndex+1 != slideDefIDs.size()) {
242 naveen 218 
					nextIndex = currentIndex + 1;
219 
				}
499 rajveer 220 
;
242 naveen 221 
				int prevIndex = -2;
222 
				if(currentIndex != 0) {
223 
					prevIndex = currentIndex - 1;
224 
				}
499 rajveer 225 
 
242 naveen 226 
				this.setNewCurrentSlideDefinitionID(
227 
						slideDefIDs.get(currentIndex).longValue());
228 
				if(nextIndex != -2) {
499 rajveer 229 
					log.info("p7" + "---slidedefids:"+slideDefIDs+ "---nextIndex:"+nextIndex);
230 
					log.info("p7" + "---currentslide:"+currentIndex+ "---prevslide:"+prevIndex);
242 naveen 231 
					this.setNewNextSlideDefinitionID(
232 
							slideDefIDs.get(nextIndex).longValue());
233 
				}
234 
 
235 
				if(prevIndex != -2) {
236 
					this.setNewPrevSlideDefinitionID(
237 
							slideDefIDs.get(prevIndex).longValue());
238 
				}
198 naveen 239 
 
242 naveen 240 
				// Current Slide Definition
241 
				this.expSlideDef = defs.getExpandedSlideDefinition(
242 
						inputSlideDefID);
243 
				// Current Slide Instance
244 
				this.expSlide = this.expEntity.getExpandedSlide(
245 
						inputSlideDefID);
246 
				return "editSlide";
247 
			}
162 naveen 248 
		} catch (Exception e) {
208 naveen 249 
			log.error(CreationUtils.getStackTrace(e));
250 
			this.setErrorString(CreationUtils.getStackTrace(e));
198 naveen 251 
			return "fatal";
162 naveen 252 
		}
253 
 
254 
        return "edit";
255 
    }
198 naveen 256 
 
250 naveen 257 
    /**
258 
     *
259 
     * @return
260 
     */
198 naveen 261 
    public String getUrl() {
262 
    	return this.redirectURL;
263 
    }
250 naveen 264 
 
265 
    /**
266 
     *
267 
     * @return
268 
     */
162 naveen 269 
    // GET /entity/new
270 
    public String editNew() {
271 
    	log.info("EntityController.editNew");
272 
 
273 
        return "editNew";
274 
    }
250 naveen 275 
 
276 
    /**
277 
     *
278 
     * @return
279 
     */
162 naveen 280 
    // GET /entity/1
281 
    public String update() {
282 
    	log.info("EntityController.update");
283 
 
198 naveen 284 
    	long entityID = Long.parseLong(this.getId());
285 
    	log.info("entityID:" + entityID);
286 
 
287 
    	DefinitionsContainer defs = this.getDefinitionsContainer();
288 
 
289 
    	try {
250 naveen 290 
			this.expEntity = this.getExpandedEntity(entityID);
198 naveen 291 
			//log.info("this.expEntity:" + this.expEntity);
242 naveen 292 
 
293 
			// Save and Go to slides selection page
294 
			if (this.reqparams.containsKey("slides")) {
295 
				log.info("Slides");
296 
 
297 
				Entity entity = this.expEntity.getEntity();
298 
 
299 
				String categoryID = this.reqparams.get("category")[0];
300 
 
301 
				entity.setCategoryID(Long.parseLong(categoryID));
302 
				entity.setBrand(this.reqparams.get("brand")[0]);
303 
				entity.setModelName(this.reqparams.get("modelname")[0]);
304 
				entity.setModelNumber(this.reqparams.get("modelnumber")[0]);
305 
 
306 
				this.updateEntity(entity);
307 
 
308 
				this.redirectURL = "/slides/" + this.getId() + "/edit";
309 
				return "redirect";
310 
			}
198 naveen 311 
 
213 naveen 312 
			long currentSlideDefID = 0L;
313 
			long nextSlideDefID = 0L;
314 
			long prevSlideDefID = 0L;
250 naveen 315 
			long gotoSlideDefID = 0L;
198 naveen 316 
 
213 naveen 317 
			String[] currentslideDefIDStrings =
318 
				this.reqparams.get("currentslideDefID");
198 naveen 319 
 
213 naveen 320 
			String[] nextslideDefIDStrings =
321 
				this.reqparams.get("nextslideDefID");
198 naveen 322 
 
213 naveen 323 
			String[] prevslideDefIDStrings =
324 
				this.reqparams.get("prevslideDefID");
198 naveen 325 
 
250 naveen 326 
			String[] gotoslideDefIDStrings =
327 
				this.reqparams.get("gotoslideDefID");
328 
			log.info("gotoslideDefIDStrings:" +
329 
					Arrays.toString(gotoslideDefIDStrings));
330 
 
198 naveen 331 
			// Current Slide ID
213 naveen 332 
			if(currentslideDefIDStrings != null &&
333 
					currentslideDefIDStrings.length > 0) {
198 naveen 334 
				try {
213 naveen 335 
					currentSlideDefID = Long.parseLong(
336 
							currentslideDefIDStrings[0]);
198 naveen 337 
				}
338 
				catch (NumberFormatException nfe) {}
339 
			}
340 
 
341 
			// Next Slide ID
213 naveen 342 
			if(nextslideDefIDStrings != null &&
343 
					nextslideDefIDStrings.length > 0) {
198 naveen 344 
				try {
213 naveen 345 
					nextSlideDefID = Long.parseLong(nextslideDefIDStrings[0]);
198 naveen 346 
				}
347 
				catch (NumberFormatException nfe) {}
348 
			}
349 
 
350 
			// Prev Slide ID
213 naveen 351 
			if(prevslideDefIDStrings != null &&
352 
					prevslideDefIDStrings.length > 0) {
198 naveen 353 
				try {
213 naveen 354 
					prevSlideDefID = Long.parseLong(prevslideDefIDStrings[0]);
198 naveen 355 
				}
356 
				catch (NumberFormatException nfe) {}
357 
			}
250 naveen 358 
 
359 
			// Go to Slide ID
360 
			if(gotoslideDefIDStrings != null &&
361 
					gotoslideDefIDStrings.length > 0) {
362 
				try {
363 
					gotoSlideDefID = Long.parseLong(gotoslideDefIDStrings[0]);
364 
				}
365 
				catch (NumberFormatException nfe) {}
366 
			}
367 
 
213 naveen 368 
			log.info("currentSlideDefID:" + currentSlideDefID);
369 
			log.info("nextSlideDefID:" + nextSlideDefID);
370 
			log.info("prevSlideDefID:" + prevSlideDefID);
250 naveen 371 
			log.info("gotoSlideDefID:" + gotoSlideDefID);
198 naveen 372 
 
242 naveen 373 
 
198 naveen 374 
			// Save on basic info page
213 naveen 375 
			if (this.reqparams.containsKey("save") && currentSlideDefID == 0L) {
198 naveen 376 
				log.info("Save");
377 
 
378 
				Entity entity = this.expEntity.getEntity();
379 
 
380 
				String categoryID = this.reqparams.get("category")[0];
381 
 
382 
				entity.setCategoryID(Long.parseLong(categoryID));
383 
				entity.setBrand(this.reqparams.get("brand")[0]);
384 
				entity.setModelName(this.reqparams.get("modelname")[0]);
385 
				entity.setModelNumber(this.reqparams.get("modelnumber")[0]);
386 
 
387 
				this.updateEntity(entity);
388 
 
389 
				return "success";
390 
			}
391 
 
250 naveen 392 
			List<Long> slideIDs = this.getSlideSequence(entityID);
198 naveen 393 
			log.info("slideIDs:"+slideIDs);
242 naveen 394 
			if(slideIDs == null) {
395 
				this.setErrorString("Slides need to be picked first!");
396 
				return "fatal";
397 
			}
198 naveen 398 
 
208 naveen 399 
			boolean skip = false;
400 
			if(this.reqparams.containsKey("skipprev") ||
401 
					this.reqparams.containsKey("skipnext")) {
402 
				skip = true;
403 
			}
404 
 
405 
			boolean next = this.reqparams.containsKey("skipnext") ||
406 
				this.reqparams.containsKey("next");
407 
 
408 
			boolean prev = this.reqparams.containsKey("skipprev") ||
242 naveen 409 
				this.reqparams.containsKey("prev");
208 naveen 410 
 
250 naveen 411 
			boolean go = this.reqparams.containsKey("goto");
412 
 
413 
			// Save or Next or Prev or Go - When editing a slide
198 naveen 414 
			int currentSlideIndex = 0;
213 naveen 415 
			currentSlideIndex = slideIDs.indexOf(new Long(currentSlideDefID));
208 naveen 416 
			log.info("currentSlideIndex:" + currentSlideIndex);
198 naveen 417 
 
213 naveen 418 
			if(!skip && currentSlideDefID != 0L) {
198 naveen 419 
				Entity entity = this.expEntity.getEntity();
420 
 
213 naveen 421 
				// Create new instance and override existing
422 
				Slide currentSlide = this.createSlide(currentSlideDefID);
198 naveen 423 
 
213 naveen 424 
				entity.addSlide(currentSlide);
310 rajveer 425 
				long categoryID = this.getEntity().getCategoryID();
250 naveen 426 
				List<Long> orderedSlideIDs =
310 rajveer 427 
					CreationUtils.getSlideSequence(entityID, categoryID);
250 naveen 428 
 
429 
				if(orderedSlideIDs != null) {
430 
					entity.reorderSlides(orderedSlideIDs);
431 
				}
432 
 
198 naveen 433 
				// Store
434 
				this.updateEntity(entity);
435 
				//log.info("entity:" + entity);
436 
			}
437 
 
215 naveen 438 
			// Skip will delete current slide from entity
439 
			else if(skip && currentSlideDefID != 0L) {
440 
				Entity entity = this.expEntity.getEntity();
441 
				entity.removeSlide(currentSlideDefID);
310 rajveer 442 
				long categoryID = this.getEntity().getCategoryID();
250 naveen 443 
				List<Long> orderedSlideIDs =
310 rajveer 444 
					CreationUtils.getSlideSequence(entityID, categoryID);
250 naveen 445 
 
446 
				if(orderedSlideIDs != null) {
447 
					entity.reorderSlides(orderedSlideIDs);
448 
				}
449 
 
215 naveen 450 
				// Store
451 
				this.updateEntity(entity);
452 
				//log.info("entity:" + entity);
453 
			}
454 
 
198 naveen 455 
			boolean showAnotherSlide = false;
456 
 
457 
			// -2 : Not set
458 
			// -1 : Not found
459 
			int newCurrentIndex = -2;
460 
			int newNextIndex = -2;
461 
			int newPrevIndex = -2;
462 
 
463 
			// Next
213 naveen 464 
			if(next && nextSlideDefID != 0L) {
198 naveen 465 
				log.info("Next");
466 
 
467 
				// Decide on next slide ID
213 naveen 468 
				int nextSlideIndex = slideIDs.indexOf(new Long(nextSlideDefID));
198 naveen 469 
				log.info("nextSlideIndex:"+nextSlideIndex);
470 
 
471 
				// New Current
472 
				if (nextSlideIndex == -1) {
213 naveen 473 
					this.setErrorString("Invalid Next slide ID " +
474 
							nextSlideDefID);
198 naveen 475 
					return "fatal";
476 
				}
477 
 
478 
				newCurrentIndex = nextSlideIndex;
479 
 
480 
				// New Next
481 
				if (newCurrentIndex != slideIDs.size()-1) {
482 
					newNextIndex = newCurrentIndex + 1;
483 
				}
484 
 
485 
				// New Prev.
213 naveen 486 
				if(currentSlideDefID != 0L) {
198 naveen 487 
					newPrevIndex = currentSlideIndex;
488 
				}
489 
 
490 
				showAnotherSlide = true;
491 
			}
492 
 
493 
			// Prev
213 naveen 494 
			if(prev && prevSlideDefID != 0L) {
198 naveen 495 
				log.info("Prev");
496 
 
497 
				// Decide on prev slide ID
213 naveen 498 
				int prevSlideIndex = slideIDs.indexOf(new Long(prevSlideDefID));
198 naveen 499 
				log.info("prevSlideIndex:" + prevSlideIndex);
500 
 
501 
				if (prevSlideIndex == -1) {
213 naveen 502 
					this.setErrorString("Invalid Prev slide ID " +
503 
							prevSlideDefID);
198 naveen 504 
					return "fatal";
505 
				}
506 
 
507 
				// New Next
213 naveen 508 
				if(currentSlideDefID != 0L) {
198 naveen 509 
					newNextIndex = currentSlideIndex;
510 
				}
511 
 
512 
				// New Current
513 
				newCurrentIndex = prevSlideIndex;
514 
 
515 
				// New Prev.
516 
				if (newCurrentIndex != 0) {
517 
					newPrevIndex = newCurrentIndex - 1;
518 
				}
519 
 
520 
				showAnotherSlide = true;
521 
			}
522 
 
250 naveen 523 
			// Go to
524 
			if(go && gotoSlideDefID != 0) {
525 
				log.info("Goto");
526 
				int gotoSlideIndex = slideIDs.indexOf(new Long(gotoSlideDefID));
527 
				log.info("gotoSlideIndex:" + gotoSlideIndex);
528 
 
529 
				if (gotoSlideIndex == -1) {
530 
					this.setErrorString("Invalid Go to slide ID " +
531 
							gotoSlideDefID);
532 
					return "fatal";
533 
				}
534 
 
535 
				// New Next
536 
				if(gotoSlideIndex != slideIDs.size()-1) {
537 
					newNextIndex = gotoSlideIndex + 1;
538 
				}
539 
 
540 
				// New Current
541 
				newCurrentIndex = gotoSlideIndex;
542 
 
543 
				// New Prev.
544 
				if (gotoSlideIndex != 0) {
545 
					newPrevIndex = gotoSlideIndex - 1;
546 
				}
547 
 
548 
				showAnotherSlide = true;
549 
			}
550 
 
198 naveen 551 
			if(showAnotherSlide) {
213 naveen 552 
 				log.info("newCurrentIndex:" + newCurrentIndex);
553 
				log.info("newNextIndex:" + newNextIndex);
554 
				log.info("newPrevIndex:" + newPrevIndex);
198 naveen 555 
 
556 
				if(newCurrentIndex != -2) {
557 
					this.setNewCurrentSlideDefinitionID(
558 
							slideIDs.get(newCurrentIndex).longValue());
559 
				}
560 
 
561 
				if(newNextIndex != -2) {
562 
					this.setNewNextSlideDefinitionID(
563 
							slideIDs.get(newNextIndex).longValue());
564 
				}
565 
 
566 
				if(newPrevIndex != -2) {
567 
					this.setNewPrevSlideDefinitionID(
568 
							slideIDs.get(newPrevIndex).longValue());
569 
				}
242 naveen 570 
 
571 
				long newCurrentSlideDefID =
572 
					this.getNewCurrentSlideDefinitionID();
573 
				log.info("newCurrentSlideDefID:" + newCurrentSlideDefID);
198 naveen 574 
 
575 
				// Current Slide Definition
576 
				this.expSlideDef = defs.getExpandedSlideDefinition(
242 naveen 577 
						newCurrentSlideDefID);
198 naveen 578 
 
579 
				// Current Slide Instance
580 
				this.expSlide = this.expEntity.getExpandedSlide(
242 naveen 581 
						newCurrentSlideDefID);
198 naveen 582 
 
242 naveen 583 
				log.info("this.expSlide is null: " + (this.expSlide == null));
584 
 
198 naveen 585 
				return "editSlide";
586 
			}
587 
		}
588 
    	catch (Exception e) {
208 naveen 589 
			log.error(CreationUtils.getStackTrace(e));
590 
			this.setErrorString(CreationUtils.getStackTrace(e));
198 naveen 591 
			return "fatal";
592 
    	}
593 
 
594 
        return "success";
162 naveen 595 
    }
213 naveen 596 
 
162 naveen 597 
    /**
201 naveen 598 
     *
250 naveen 599 
     * @param entityID
600 
     * @return
601 
     * @throws Exception
602 
     */
603 
    public long getBorrowedCategoryID(long slideDefID) throws Exception {
604 
    	long entityID = Long.parseLong(this.getId());
605 
    	Entity entity = this.getEntity(entityID);
606 
    	Long entityCatID = new Long(entity.getCategoryID());
607 
 
608 
    	Map<Long, List<Long>> catSlides = this.getRawSlideSequence(entityID);
609 
 
610 
    	Long lSlideDefID = new Long(slideDefID);
611 
    	if(catSlides != null) {
612 
    		for(Long catID : catSlides.keySet()) {
613 
    			List<Long> slideDefIDs = catSlides.get(catID);
614 
    			if(slideDefIDs.contains(lSlideDefID) &&
615 
    					!catID.equals(entityCatID)) {
616 
    				return catID.longValue();
617 
    			}
618 
    		}
619 
    	}
620 
 
621 
    	return 0L;
622 
    }
623 
 
624 
	/**
625 
     *
626 
     * @param entityID
627 
     * @return
628 
     * @throws Exception
629 
     */
630 
    private List<Long> getSlideSequence(long entityID) throws Exception {
631 
    	this.catSlides = this.getRawSlideSequence(entityID);
632 
    	return CreationUtils.getSlideSequence(this.catSlides);
633 
	}
634 
 
635 
    /**
636 
     *
637 
     * @param entityID
638 
     * @return
639 
     * @throws Exception
640 
     */
641 
	private Map<Long, List<Long>> getRawSlideSequence(long entityID)
642 
		throws Exception {
643 
		if(this.catSlides == null) {
644 
			this.catSlides = CreationUtils.getRawSlideSequence(entityID);
645 
		}
646 
 
647 
		return this.catSlides;
648 
	}
649 
 
650 
 
651 
	/**
652 
     *
213 naveen 653 
     * @param slideDefID
654 
     * @return
655 
     * @throws Exception
656 
     */
657 
    private Slide createSlide(long slideDefID) throws Exception {
658 
		Slide slide = new Slide(slideDefID);
659 
 
250 naveen 660 
		long borrowedCategoryID = this.getBorrowedCategoryID(slideDefID);
661 
		log.info("borrowedCategoryID:" + borrowedCategoryID);
662 
 
663 
		if(borrowedCategoryID != 0L) {
664 
			slide.setBorrowedCategoryID(borrowedCategoryID);
665 
		}
666 
 
213 naveen 667 
		// Slide free-form content
668 
		FreeformContent slideFFC = this.getFreeformContent(
669 
				"slide_" + slideDefID);
670 
 
671 
		log.info("slideFFC:" + slideFFC);
672 
 
673 
		slide.setFreeformContent(slideFFC);
674 
		//log.info("currentSlide:" + currentSlide);
675 
 
676 
		// Collect Feature bullets
677 
		List<Feature> features = this.createFeatures(slide);
678 
		log.info("features:" + features);
679 
 
680 
		slide.setFeatures(features);
681 
 
682 
		// Collect children slides
683 
		SlideDefinition slideDef =
684 
			this.getDefinitionsContainer().getSlideDefinition(slideDefID);
685 
 
686 
		List<Long> childrenSlideIDs = slideDef.getChildrenSlideDefinitionIDs();
687 
		if(childrenSlideIDs != null) {
688 
			List<Slide> childrenSlides = new ArrayList<Slide>();
689 
			for (Long childSlideID : childrenSlideIDs) {
690 
				Slide childSlide = this.createSlide(childSlideID.longValue());
691 
				if(childSlide != null) {
692 
					childrenSlides.add(childSlide);
693 
				}
694 
			}
695 
 
696 
			slide.setChildrenSlides(childrenSlides);
697 
		}
698 
 
699 
		return slide;
700 
    }
701 
 
702 
    /**
703 
     *
201 naveen 704 
     * @param slide
705 
     * @return
706 
     * @throws Exception
707 
     */
708 
    private List<Feature> createFeatures(Slide slide) throws Exception {
709 
 
710 
		long slideDefID = slide.getSlideDefinitionID();
711 
		SlideDefinition slideDef = defs.getSlideDefinition(slideDefID);
712 
 
713 
		List<SlideFeatureDefinition> slideFeatureDefs =
714 
			slideDef.getSlideFeatureDefinitions();
715 
 
716 
		DefinitionsContainer defs = this.getDefinitionsContainer();
717 
 
718 
		List<Feature> features = new ArrayList<Feature>();
719 
		for(SlideFeatureDefinition slideFeatureDef : slideFeatureDefs) {
720 
			long featureDefinitionID = slideFeatureDef.getFeatureDefintionID();
215 naveen 721 
			log.info("featureDefinitionID:" + featureDefinitionID);
204 naveen 722 
 
215 naveen 723 
			// Ignore skipped featured
724 
			String[] skipvalue =
725 
				this.reqparams.get(featureDefinitionID + "_skip");
726 
			log.info("skipvalue:" + Arrays.toString(skipvalue));
727 
 
728 
			if(skipvalue != null && skipvalue.length > 0 &&
729 
					skipvalue[0].equals("on")) {
730 
				continue;
731 
			}
732 
 
201 naveen 733 
			String featureDefIDString =
734 
				new Long(featureDefinitionID).toString();
735 
 
736 
			Feature feature = new Feature(featureDefinitionID);
310 rajveer 737 
 
201 naveen 738 
			FeatureDefinition featureDef = defs.getFeatureDefinition(
739 
					featureDefinitionID);
204 naveen 740 
			log.info("featureDef:" + featureDef);
201 naveen 741 
 
742 
			ExpandedFeatureDefinition expFeatureDef =
743 
				new ExpandedFeatureDefinition(featureDef);
744 
 
745 
			ExpandedBulletDefinition expBulletDef =
746 
				expFeatureDef.getExpandedBulletDefinition();
747 
 
310 rajveer 748 
			boolean isBlank = false;
749 
 
750 
			// Check if feature has no bullets
751 
			// Composite
752 
			if(expBulletDef.isComposite()) {
753 
				CompositeDefinition compositeDef = (CompositeDefinition)
754 
					expBulletDef.getDatatypeDefinition();
755 
 
756 
				List<CompositePartDefinition> compositeParts =
757 
					compositeDef.getCompositePartDefinitions();
758 
 
759 
				boolean allPartsBlank = true;
760 
				for(int j=0;j<compositeParts.size();j++) {
761 
					String[] partValues = this.reqparams.get(
762 
							featureDefIDString + "_" + (j + 1));
763 
 
764 
					if(partValues != null && partValues.length > 0) {
765 
						allPartsBlank = false;
766 
					}
767 
				}
768 
 
769 
				isBlank = allPartsBlank;
770 
			}
771 
 
772 
			// Enumerated and Primitive
773 
			else {
774 
				String[] bulletValues =	this.reqparams.get(featureDefIDString);
775 
				if(bulletValues == null || bulletValues.length == 0) {
776 
					isBlank = true;
777 
				}
778 
			}
779 
 
780 
			// Has no bullets
781 
			if(isBlank) {
403 rajveer 782 
 
783 
				// Mandatory
784 
				// or optional/recommended but allows blanck and not skipped
310 rajveer 785 
				if(slideFeatureDef.getEditorialImportance() ==
480 rajveer 786 
					EditorialImportance.MANDATORY || expFeatureDef.allowsBlank()) {
787 
					// FFC
788 
					FreeformContent featureFFC =
789 
						this.getFreeformContent(featureDefIDString);
790 
 
791 
					feature.setFreeformContent(featureFFC);
792 
 
310 rajveer 793 
					features.add(feature);
794 
				}
795 
 
796 
				continue;
797 
			}
798 
 
799 
			// Bullets
800 
			List<Bullet> bullets = new ArrayList<Bullet>();
801 
 
206 naveen 802 
			// Collect unit
803 
			String[] unitIDs = this.reqparams.get(featureDefIDString + "_unit");
804 
			long unitID = 0L;
805 
			if(unitIDs != null && unitIDs.length > 0) {
806 
				unitID = Long.parseLong(unitIDs[0]);
807 
			}
808 
 
201 naveen 809 
			// Composite
810 
			if(expBulletDef.isComposite()) {
204 naveen 811 
				log.info("Composite");
201 naveen 812 
 
204 naveen 813 
				CompositeDataObject compositeDataObject =
814 
					new CompositeDataObject();
815 
 
816 
				CompositeDefinition compositeDef =
817 
					(CompositeDefinition)expBulletDef.getDatatypeDefinition();
818 
 
819 
				List<CompositePartDefinition> compositeParts =
820 
					compositeDef.getCompositePartDefinitions();
821 
 
822 
				for(int j=0;j<compositeParts.size();j++) {
823 
					String[] partValues = this.reqparams.get(
208 naveen 824 
							featureDefIDString + "_" + (j + 1));
204 naveen 825 
 
826 
					if(partValues != null && partValues.length > 0) {
827 
						compositeDataObject.addPrimitiveDataObject(
828 
							new PrimitiveDataObject(partValues[0]));
829 
					}
830 
				}
831 
 
832 
				Bullet bullet = new Bullet(compositeDataObject);
833 
 
206 naveen 834 
				if(unitID != 0L) {
835 
					bullet.setUnitID(unitID);
836 
				}
837 
 
204 naveen 838 
				bullets.add(bullet);
201 naveen 839 
			}
840 
 
841 
			// Enumerated
842 
			else if(expBulletDef.isEnumerated()) {
204 naveen 843 
				log.info("Enumerated");
310 rajveer 844 
 
204 naveen 845 
				String[] bulletValues = this.reqparams.get(featureDefIDString);
846 
				log.info("bulletValues:" + Arrays.toString(bulletValues));
206 naveen 847 
 
204 naveen 848 
 
206 naveen 849 
				for(int i=0;i<bulletValues.length;i++) {
850 
					EnumDataObject enumDataObject =
851 
						new EnumDataObject(Long.parseLong(bulletValues[i]));
852 
 
853 
					Bullet bullet = new Bullet(enumDataObject);
854 
 
855 
					if(unitID != 0L) {
856 
						bullet.setUnitID(unitID);
857 
					}
858 
 
859 
					bullets.add(bullet);
860 
				}
201 naveen 861 
			}
862 
 
863 
			// Primitive
864 
			else {
204 naveen 865 
				log.info("Primitive");
310 rajveer 866 
 
204 naveen 867 
				String[] bulletValues = this.reqparams.get(featureDefIDString);
868 
				log.info("bulletValues:" + Arrays.toString(bulletValues));
869 
 
206 naveen 870 
				for(int i=0;i<bulletValues.length;i++) {
871 
					Bullet bullet = new Bullet(
872 
							new PrimitiveDataObject(bulletValues[i]));
873 
 
874 
					if(unitID != 0L) {
875 
						bullet.setUnitID(unitID);
876 
					}
877 
 
878 
					bullets.add(bullet);
879 
				}
201 naveen 880 
			}
881 
 
882 
			feature.setBullets(bullets);
883 
 
884 
			// FFC
885 
			FreeformContent featureFFC =
886 
				this.getFreeformContent(featureDefIDString);
887 
 
888 
			feature.setFreeformContent(featureFFC);
889 
 
890 
			features.add(feature);
891 
		}
892 
 
893 
		return features;
894 
	}
895 
 
242 naveen 896 
    // DELETE /entity/1000001
897 
    /**
898 
     *
899 
     */
900 
    public String destroy() {
250 naveen 901 
    	log.info("#### EntityController.destroy ####");
242 naveen 902 
 
903 
    	long entityID = Long.parseLong(this.getId());
904 
    	log.info("entityID:" + entityID);
905 
 
906 
		// Store
907 
		try {
250 naveen 908 
	    	Entity entity = this.getEntity(entityID);
242 naveen 909 
	    	EntityContainer ents = this.getEntityContainer();
910 
 
911 
	    	Map<Long, Entity> entities = ents.getEntities();
912 
	    	Map<Long, List<Entity>> entitiesbycat =
913 
	    		ents.getEntitiesbyCategory();
914 
 
915 
	    	entities.remove(new Long(entityID));
916 
 
917 
	    	List<Entity> catentities =
918 
	    		entitiesbycat.get(new Long(entity.getCategoryID()));
919 
 
920 
	    	Entity entitytodelete = null;
921 
	    	for(Entity catentity : catentities) {
922 
	    		if(catentity.getID() == entityID) {
923 
	    			entitytodelete = catentity;
924 
	    			break;
925 
	    		}
926 
	    	}
927 
 
928 
	    	if(entitytodelete != null) {
929 
	    		catentities.remove(entitytodelete);
930 
	    	}
931 
 
250 naveen 932 
	    	CreationUtils.deleteFromIncomplete(entity);
933 
 
934 
	    	CreationUtils.deleteEntity(entityID);
935 
 
936 
	    	CreationUtils.rewriteRepository(entities, entitiesbycat);
480 rajveer 937 
			// Added automatic learning once someone rewrites repository
938 
			CN cn = new CN();
939 
			cn.learn();
242 naveen 940 
		} catch (Exception e) {
941 
			log.error(CreationUtils.getStackTrace(e));
942 
			this.setErrorString(CreationUtils.getStackTrace(e));
943 
			return "fatal";
944 
		}
945 
 
946 
        addActionMessage("Entity deleted successfully");
947 
        return "success";
948 
    }
201 naveen 949 
	/**
950 
     *
951 
     * @param ID
952 
     * @return
953 
     */
954 
    private FreeformContent getFreeformContent(String ID) {
450 rajveer 955 
 
956 
 
201 naveen 957 
		FreeformContent ffc = new FreeformContent();
958 
		String[] ffts = this.reqparams.get(ID + "_fft");
959 
		if(ffts != null) {
960 
			ffc.setFreeformTexts(Arrays.asList(ffts));
961 
		}
962 
 
450 rajveer 963 
    	System.out.println("String is " + ID);
964 
 
965 
    	StringTokenizer tokenizer = new StringTokenizer(ID,"_");
966 
    	if(tokenizer.nextToken().compareTo("slide") == 0  ){
967 
    		long slideId = Long.parseLong(tokenizer.nextToken());
968 
    		FreeformContent old_ffc = null;
969 
    		if(this.entity.getSlide(slideId) != null){
970 
    			old_ffc = this.entity.getSlide(slideId).getFreeformContent();
971 
    			if(old_ffc != null){
972 
    				ffc.setMedia("image", old_ffc.getImageRefs());
973 
    				ffc.setMedia("youtube", old_ffc.getYoutubeRefs());
974 
    			}
975 
    		}
976 
    	}
201 naveen 977 
 
978 
 
450 rajveer 979 
//		String[] imgRefs = this.reqparams.get(ID + "_image_references");
980 
//		if(imgRefs != null) {
981 
//			ffc.setMedia("image", Arrays.asList(imgRefs));
982 
//		}
983 
//
984 
//		String[] youtubeRefs =
985 
//			this.reqparams.get(ID + "_youtube_references");
986 
//		if(youtubeRefs != null) {
987 
//			ffc.setMedia("youtube", Arrays.asList(youtubeRefs));
988 
//		}
989 
 
201 naveen 990 
		log.info("ffc:" + ffc);
991 
		return ffc;
992 
	}
213 naveen 993 
 
994 
 
995 
    /**
996 
     *
997 
     * @param slideDefinitionID
998 
     * @return
999 
     */
1000 
	public ExpandedSlide getChildSlide(long slideDefinitionID) {
242 naveen 1001 
		if(this.expSlide == null) {
1002 
			return null;
1003 
		}
1004 
 
213 naveen 1005 
		return this.getChildSlide(this.expSlide, slideDefinitionID);
1006 
	}
1007 
 
1008 
 
1009 
    /**
1010 
     *
1011 
     * @param expSlide
1012 
     * @param slideDefinitionID
1013 
     * @return
1014 
     */
1015 
	public ExpandedSlide getChildSlide(ExpandedSlide expSlide,
1016 
			long slideDefinitionID) {
1017 
 
1018 
		List<ExpandedSlide> childrenSlides =
1019 
			expSlide.getExpandedChildrenSlides();
1020 
 
1021 
		ExpandedSlide resultSlide = null;
1022 
 
1023 
		if(childrenSlides != null) {
1024 
			for(ExpandedSlide childSlide : childrenSlides) {
1025 
				if(childSlide.getSlideDefinitionID() == slideDefinitionID) {
1026 
					return childSlide;
1027 
				}
1028 
 
1029 
				resultSlide = this.getChildSlide(childSlide, slideDefinitionID);
1030 
				if(resultSlide == null) {
1031 
					continue;
1032 
				}
1033 
				else {
1034 
					break;
1035 
				}
1036 
			}
1037 
		}
1038 
 
1039 
		return resultSlide;
1040 
	}
201 naveen 1041 
 
1042 
	/**
162 naveen 1043 
	 * @return the entities
1044 
	 */
1045 
	public Collection<Entity> getEntities() {
1046 
		return entities;
1047 
	}
1048 
 
250 naveen 1049 
	/**
516 rajveer 1050 
	 * @return the entities
1051 
	 */
1052 
	public Map<Long, List<Entity>> getEntitiesByCategory() {
1053 
		return catEntities;
1054 
	}
1055 
 
1056 
	/**
250 naveen 1057 
	 *
1058 
	 * @return
1059 
	 */
1060 
	public List<Entity> getIncompleteEntities() {
1061 
		try {
1062 
			return CreationUtils.getIncomplete();
1063 
		} catch (Exception e) {
1064 
			log.error(CreationUtils.getStackTrace(e));
1065 
			this.setErrorString(CreationUtils.getStackTrace(e));
1066 
			return null;
1067 
		}
1068 
	}
739 chandransh 1069 
 
1070 
	/**
1071 
	 * Inquires about items in the IN_PROCESS state with the Catalog service and
1072 
	 * creates those entities which do not exist in the CMS already.
1073 
	 *
1074 
	 * @return A List of entities fetched from the catalog.
1075 
	 */
1076 
	private void createEntitiesForItemsInProcess(){
1077 
		try {
1078 
			CatalogServiceClient csc = new CatalogServiceClient();
1079 
			in.shop2020.model.v1.catalog.InventoryService.Client iclient = csc.getClient();
1080 
			List<Item> items = iclient.getAllItemsByStatus(status.IN_PROCESS);
1081 
			for(Item item: items){
1082 
				long entityID = item.getCatalogItemId();
1083 
				if(CreationUtils.getEntity(entityID) == null){
1084 
					log.info("#### Going to add the entity with id: ####" + entityID);
1085 
					Entity entity = new Entity(entityID, -1);
1086 
					entity.setBrand(item.getManufacturerName());
1087 
					entity.setModelNumber(item.getModelNumber());
1088 
					entity.setModelName((item.getModelName()==null) ? "" : item.getModelName());
1089 
					addEntity(entity);
1090 
				}else
1091 
					log.info("###Everything went all right and we got an entity");
1092 
			}
1093 
		} catch (Exception e) {
1094 
			e.printStackTrace();
1095 
		}
1096 
	}
250 naveen 1097 
 
162 naveen 1098 
    /**
1099 
	 * @return the entities
1100 
	 */
1101 
	public ExpandedEntity getEntity() {
1102 
		return expEntity;
1103 
	}
1104 
 
198 naveen 1105 
    /**
1106 
	 * @return the current slide to edit
1107 
	 */
1108 
	public ExpandedSlideDefinition getExpandedSlideDefinition() {
1109 
		return expSlideDef;
1110 
	}
213 naveen 1111 
 
1112 
	/**
1113 
	 *
1114 
	 * @param slideDefID
1115 
	 * @return
1116 
	 */
1117 
	public ExpandedSlideDefinition getExpandedSlideDefinition(long slideDefID) {
1118 
		DefinitionsContainer defs = this.getDefinitionsContainer();
1119 
 
1120 
		try {
1121 
			return defs.getExpandedSlideDefinition(slideDefID);
1122 
		} catch (Exception e) {
1123 
			return null;
1124 
		}
1125 
	}
162 naveen 1126 
 
1127 
	/**
1128 
     *
1129 
     * @param id
1130 
     */
1131 
    public void setId(String id) {
1132 
        this.id = id;
1133 
    }
1134 
 
1135 
    /**
1136 
     *
1137 
     */
1138 
    public String getId() {
1139 
    	return this.id;
1140 
    }
1141 
 
198 naveen 1142 
	/**
1143 
	 * @return the firstSlideID
1144 
	 */
213 naveen 1145 
	public long getFirstSlideDefID() {
1146 
		return firstSlideDefID;
198 naveen 1147 
	}
1148 
 
162 naveen 1149 
	@Override
1150 
	public void setParameters(Map<String, String[]> reqmap) {
1151 
		log.info("setParameters:" + reqmap);
1152 
 
1153 
		this.reqparams = reqmap;
1154 
	}
1155 
 
448 rajveer 1156 
	public String getCategoriesTree()  throws Exception {
1157 
		DefinitionsContainer defs = this.getDefinitionsContainer();
1158 
		Map<String, String> cats = new HashMap<String, String>();
1159 
 
1160 
		List<Category> children = defs.getChildrenCategories(10000L);
1161 
 
1162 
		for(Category child : children) {
1163 
			cats.put(new Long(child.getID()).toString(), child.getLabel());
1164 
		}
1165 
		return "";
1166 
	}
1167 
 
198 naveen 1168 
	public Map<String, String> getCategories() throws Exception {
1169 
		DefinitionsContainer defs = this.getDefinitionsContainer();
1170 
		Map<String, String> cats = new HashMap<String, String>();
1171 
 
448 rajveer 1172 
		List<Category> children = defs.getChildrenCategories(10000L);
198 naveen 1173 
		for(Category child : children) {
1174 
			cats.put(new Long(child.getID()).toString(), child.getLabel());
1175 
		}
1176 
 
1177 
		return cats;
1178 
	}
448 rajveer 1179 
 
1180 
	public Map<String, String> getSubcategories() throws Exception {
1181 
		DefinitionsContainer defs = this.getDefinitionsContainer();
1182 
		Map<String, String> cats = new HashMap<String, String>();
1183 
 
1184 
		List<Category> children = defs.getChildrenCategories(10000L);
1185 
		for(Category child : children) {
1186 
			List<Category> grandChildren = defs.getChildrenCategories(child.getID());
1187 
			for(Category grandchild : grandChildren) {
1188 
				cats.put(new Long(grandchild.getID()).toString(), grandchild.getLabel());
1189 
			}
1190 
		}
1191 
 
1192 
		return cats;
1193 
	}
1194 
	public String getCategoriesString() throws Exception {
1195 
		DefinitionsContainer defs = this.getDefinitionsContainer();
1196 
		StringBuilder categoryString = new StringBuilder();
1197 
 
1198 
		categoryString.append("<label for=\"basecategory\">Category: </label>");
1199 
		categoryString.append("\n");
1200 
		categoryString.append("<select id=\"basecategory\"  name=\"basecategory\" >");
1201 
		categoryString.append("\n");
1202 
		List<Category> children = defs.getChildrenCategories(10000L);
1203 
		for(Category child : children) {
1204 
			categoryString.append("<option value=\"" + new Long(child.getID()).toString() + "\">" + child.getLabel() + "</option>");
1205 
			categoryString.append("\n");
1206 
		}
1207 
		categoryString.append("</select>");
1208 
		categoryString.append("\n");
1209 
		categoryString.append("<br/>");
1210 
		categoryString.append("\n");
1211 
 
1212 
		categoryString.append("<label for=\"category\">Sub Category: </label>");
1213 
		categoryString.append("\n");
1214 
		categoryString.append("<select id=\"category\" name=\"category\" >");
1215 
		categoryString.append("\n");
1216 
		for(Category child : children) {
1217 
			List<Category> grandChildren = defs.getChildrenCategories(child.getID());
1218 
			for(Category grandchild : grandChildren) {
1219 
				categoryString.append("<option value=\"" + new Long(grandchild.getID()).toString() + "\" selected=\"$selected\" class = \""+ child.getID()  + "\">" + grandchild.getLabel() + "</option>");
1220 
				categoryString.append("\n");
1221 
			}
1222 
		}
1223 
		categoryString.append("</select>");
1224 
		categoryString.append("\n");
1225 
		categoryString.append("<br/>");
1226 
 
1227 
		return categoryString.toString();
1228 
 
1229 
	}
1230 
 
1231 
 
250 naveen 1232 
	/**
1233 
	 *
1234 
	 * @return
1235 
	 * @throws Exception
1236 
	 */
198 naveen 1237 
	public String getBrandString() throws Exception {
1238 
		List<String> brands = this.getBrands();
1239 
		return "\"" + StringUtils.join(brands, "\", \"") + "\"";
1240 
	}
1241 
 
250 naveen 1242 
	/**
1243 
	 *
1244 
	 * @return
1245 
	 * @throws Exception
1246 
	 */
198 naveen 1247 
	public List<String> getBrands() throws Exception {
1248 
		EntityContainer ents = this.getEntityContainer();
1249 
		List<String> brands = new ArrayList<String>();
1250 
 
1251 
		List<ExpandedBullet> expBullets;
1252 
 
1253 
		expBullets = ents.getLearnedBullets(
1254 
				Utils.BRAND_FEATURE_DEFINITION_ID);
1255 
 
1256 
		for(ExpandedBullet expBullet : expBullets) {
1257 
			brands.add(expBullet.getValue());
1258 
		}
1259 
 
1260 
		return brands;
1261 
	}
1262 
 
245 naveen 1263 
	/**
1264 
	 *
1265 
	 * @return
1266 
	 */
242 naveen 1267 
    protected EntityContainer getEntityContainer() {
198 naveen 1268 
    	if(this.ents == null) {
245 naveen 1269 
    		this.ents = Catalog.getInstance().getEntityContainer();
198 naveen 1270 
    	}
1271 
 
1272 
	    return this.ents;
1273 
    }
245 naveen 1274 
 
1275 
    /**
1276 
     *
1277 
     * @return
1278 
     */
242 naveen 1279 
    protected DefinitionsContainer getDefinitionsContainer() {
198 naveen 1280 
    	if(this.defs == null) {
245 naveen 1281 
    		this.defs = Catalog.getInstance().getDefinitionsContainer();
198 naveen 1282 
    	}
1283 
 
1284 
	    return this.defs;
1285 
    }
1286 
 
1287 
    /**
1288 
     *
1289 
     * @param entity
1290 
     * @throws Exception
1291 
     */
250 naveen 1292 
	private void addEntity(Entity entity) throws Exception {
1293 
		log.info("#### EntityController.addEntity ####");
245 naveen 1294 
		EntityContainer entContainer = this.getEntityContainer();
198 naveen 1295 
 
1296 
		entContainer.addEntity(entity);
1297 
 
250 naveen 1298 
		CreationUtils.storeEntity(entity);
1299 
 
1300 
		ContentValidator validator = new ContentValidator();
1301 
		if(!validator.validate(entity)) {
1302 
			CreationUtils.addToIncomplete(entity);
1303 
		}
1304 
		// Add to repository only if validations succeed
1305 
		else {
1306 
			CreationUtils.deleteFromIncomplete(entity);
1307 
 
1308 
			this.updateRepository();
480 rajveer 1309 
			// Added automatic learning once someone rewrites repository
1310 
			CN cn = new CN();
1311 
			cn.learn();
250 naveen 1312 
		}
198 naveen 1313 
	}
1314 
 
1315 
    /**
1316 
     *
1317 
     * @param entity
1318 
     * @throws Exception
1319 
     */
250 naveen 1320 
	private void updateEntity(Entity entity) throws Exception {
1321 
		log.info("#### EntityController.updateEntity ####");
245 naveen 1322 
		EntityContainer entContainer = this.getEntityContainer();
198 naveen 1323 
 
250 naveen 1324 
		ContentValidator validator = new ContentValidator();
1325 
		if(!validator.validate(entity)) {
1326 
			CreationUtils.addToIncomplete(entity);
1327 
 
1328 
			// Delete from repository if incomplete
1329 
			entContainer.deleteEntity(entity);
1330 
		}
1331 
		else {
1332 
			CreationUtils.deleteFromIncomplete(entity);
1333 
 
1334 
			entContainer.updateEntity(entity);
480 rajveer 1335 
 
1336 
 
250 naveen 1337 
		}
1338 
 
1339 
		CreationUtils.storeEntity(entity);
1340 
 
1341 
		this.updateRepository();
480 rajveer 1342 
 
1343 
		if(validator.validate(entity)) {
1344 
			// Added automatic learning once someone rewrites repository
1345 
			CN cn = new CN();
1346 
			cn.learn();
1347 
		}
245 naveen 1348 
	}
1349 
 
480 rajveer 1350 
 
1351 
 
245 naveen 1352 
	/**
1353 
	 *
1354 
	 * @throws Exception
1355 
	 */
250 naveen 1356 
	private void updateRepository() throws Exception {
245 naveen 1357 
		EntityContainer entContainer = this.getEntityContainer();
198 naveen 1358 
 
249 naveen 1359 
		Map<Long, Entity> entities = entContainer.getEntities();
1360 
		log.info("entities.size():" + entities.size());
245 naveen 1361 
 
249 naveen 1362 
		Map<Long, List<Entity>> entitiesByCategory =
1363 
			entContainer.getEntitiesbyCategory();
1364 
		log.info("entitiesByCategory.size():" + entitiesByCategory.size());
245 naveen 1365 
 
250 naveen 1366 
		CreationUtils.rewriteRepository(entities, entitiesByCategory);
198 naveen 1367 
	}
1368 
 
162 naveen 1369 
	/**
198 naveen 1370 
	 * @param exception the exception to set
1371 
	 */
1372 
	public void setException(Exception exception) {
1373 
		this.exception = exception;
1374 
	}
1375 
 
1376 
	/**
1377 
	 * @return the exception
1378 
	 */
1379 
	public Exception getException() {
1380 
		return exception;
1381 
	}
1382 
 
1383 
	/**
1384 
	 * @param errorString the exceptionString to set
1385 
	 */
1386 
	public void setErrorString(String errorString) {
1387 
		this.errorString = errorString;
1388 
	}
1389 
 
1390 
	/**
1391 
	 * @return the exceptionString
1392 
	 */
1393 
	public String getErrorString() {
1394 
		return errorString;
1395 
	}
1396 
 
1397 
	/**
1398 
	 * @param newCurrentSlideID the newCurrentSlideID to set
1399 
	 */
1400 
	public void setNewCurrentSlideDefinitionID(
1401 
			long newCurrentSlideDefinitionID) {
1402 
		this.newCurrentSlideDefinitionID = newCurrentSlideDefinitionID;
1403 
	}
1404 
 
1405 
	/**
1406 
	 * @return the newCurrentSlideID
1407 
	 */
1408 
	public long getNewCurrentSlideDefinitionID() {
1409 
		return newCurrentSlideDefinitionID;
1410 
	}
1411 
 
1412 
	/**
1413 
	 * @param newNextSlideID the newNextSlideID to set
1414 
	 */
1415 
	public void setNewNextSlideDefinitionID(long newNextSlideDefinitionID) {
1416 
		this.newNextSlideDefinitionID = newNextSlideDefinitionID;
1417 
	}
1418 
 
1419 
	/**
1420 
	 * @return the newNextSlideID
1421 
	 */
1422 
	public long getNewNextSlideDefinitionID() {
1423 
		return newNextSlideDefinitionID;
1424 
	}
1425 
 
1426 
	/**
1427 
	 * @param expSlide the expSlide to set
1428 
	 */
1429 
	public void setExpandedSlide(ExpandedSlide expSlide) {
1430 
		this.expSlide = expSlide;
1431 
	}
1432 
 
1433 
	/**
1434 
	 * @return the expSlide
1435 
	 */
1436 
	public ExpandedSlide getExpandedSlide() {
1437 
		return expSlide;
1438 
	}
1439 
 
1440 
	/**
1441 
	 * @param newPrevSlideDefinitionID the newPrevSlideDefinitionID to set
1442 
	 */
1443 
	public void setNewPrevSlideDefinitionID(long newPrevSlideDefinitionID) {
1444 
		this.newPrevSlideDefinitionID = newPrevSlideDefinitionID;
1445 
	}
1446 
 
1447 
	/**
1448 
	 * @return the newPrevSlideDefinitionID
1449 
	 */
1450 
	public long getNewPrevSlideDefinitionID() {
1451 
		return newPrevSlideDefinitionID;
1452 
	}
1453 
 
1454 
	/**
162 naveen 1455 
	 *
200 naveen 1456 
	 * @param featureDefinitionID
1457 
	 * @return
1458 
	 * @throws Exception
1459 
	 */
1460 
	public String getLearnedValuesString(long featureDefinitionID)
1461 
			throws Exception {
206 naveen 1462 
		List<String> learnedValues = this.getLearnedValues(featureDefinitionID);
1463 
		if(learnedValues == null) {
1464 
			return "";
1465 
		}
1466 
 
1467 
		return "\"" + StringUtils.join(learnedValues, "\", \"") + "\"";
1468 
	}
1469 
 
1470 
	/**
1471 
	 *
1472 
	 * @param featureDefinitionID
1473 
	 * @return
1474 
	 * @throws Exception
1475 
	 */
1476 
	public List<String> getLearnedValues(long featureDefinitionID)
1477 
			throws Exception {
200 naveen 1478 
		EntityContainer ents = this.getEntityContainer();
1479 
		List<ExpandedBullet> learnedBullets =
1480 
			ents.getLearnedBullets(featureDefinitionID);
1481 
 
201 naveen 1482 
		if(learnedBullets == null) {
206 naveen 1483 
			return null;
201 naveen 1484 
		}
1485 
 
200 naveen 1486 
		List<String> learnedValues = new ArrayList<String>();
1487 
		for(ExpandedBullet expBullet : learnedBullets) {
1488 
			learnedValues.add(expBullet.getValue());
1489 
		}
1490 
 
206 naveen 1491 
		return learnedValues;
200 naveen 1492 
	}
1493 
 
1494 
	/**
1495 
	 *
201 naveen 1496 
	 * @param featureDefinitionID
1497 
	 * @return
1498 
	 * @throws Exception
1499 
	 */
1500 
	public ExpandedFeature getFeature(long featureDefinitionID)
1501 
		throws Exception {
1502 
		EntityContainer ents = this.getEntityContainer();
1503 
 
215 naveen 1504 
		if(this.expSlide != null) {
1505 
			Feature feature = ents.getFeature(
1506 
					this.expSlide, featureDefinitionID);
1507 
 
1508 
			if(feature == null) {
1509 
				return null;
1510 
			}
1511 
			return new ExpandedFeature(feature);
201 naveen 1512 
		}
1513 
 
215 naveen 1514 
		return null;
201 naveen 1515 
	}
1516 
 
1517 
	/**
1518 
	 *
162 naveen 1519 
	 * @return
1520 
	 */
208 naveen 1521 
	public String getEditorialImportance() {
242 naveen 1522 
		// Now that slides are selected upfront
1523 
		return "Mandatory";
1524 
 
1525 
		/*
208 naveen 1526 
		long catID = this.expEntity.getCategoryID();
1527 
		long slideDefID = this.getNewCurrentSlideDefinitionID();
1528 
 
1529 
		try {
1530 
			List<CategorySlideDefinition> catSlideDefs =
1531 
				defs.getCategorySlideDefinitions(catID);
1532 
			for(CategorySlideDefinition catSlideDef : catSlideDefs) {
1533 
				if(catSlideDef.getSlideDefintionID() == slideDefID) {
1534 
					return catSlideDef.getEditorialImportance().toString();
1535 
				}
1536 
			}
1537 
		} catch (Exception e) {
1538 
			log.error(CreationUtils.getStackTrace(e));
1539 
    	}
1540 
 
1541 
		return "";
242 naveen 1542 
		*/
162 naveen 1543 
	}
210 naveen 1544 
 
1545 
	/**
1546 
	 *
1547 
	 * @return
1548 
	 * @throws Exception
1549 
	 * @throws NumberFormatException
1550 
	 */
1551 
	public List<String> getMediaLabels(String type) {
1552 
		try {
1553 
			return CreationUtils.getMediaLabels(Long.parseLong(this.getId()),
1554 
					type);
1555 
		}
1556 
		catch(Exception nfe) {
1557 
			return null;
1558 
		}
1559 
	}
242 naveen 1560 
 
1561 
	/**
1562 
	 *
1563 
	 * @return
1564 
	 */
1565 
	public String getCategoryName(long categoryID) {
739 chandransh 1566 
		if(categoryID==-1)
1567 
			return "Yet to be Asssigned";
242 naveen 1568 
		try {
1569 
			return this.getDefinitionsContainer().getCategory(categoryID).
1570 
				getLabel();
1571 
		} catch (Exception e) {
1572 
			return null;
1573 
		}
1574 
	}
250 naveen 1575 
 
1576 
	/**
1577 
	 *
1578 
	 * @return
1579 
	 */
1580 
	public List<String[]> getSlides() {
1581 
		try {
1582 
			long entityID = Long.parseLong(this.getId());
310 rajveer 1583 
			long categoryID = this.getEntity().getCategoryID();
1584 
			List<Long> slideDefIDs = CreationUtils.getSlideSequence(entityID, categoryID);
250 naveen 1585 
 
1586 
			List<String[]> slideData = new ArrayList<String[]>();
1587 
 
1588 
			DefinitionsContainer defs = this.getDefinitionsContainer();
1589 
			for(Long slideDefID : slideDefIDs) {
1590 
				SlideDefinition slideDef = defs.getSlideDefinition(slideDefID);
1591 
				String label = slideDef.getLabel();
1592 
 
1593 
				slideData.add(new String[] {slideDefID.toString(), label});
1594 
			}
1595 
 
1596 
			return slideData;
1597 
		} catch (Exception e) {
1598 
			log.error(CreationUtils.getStackTrace(e));
1599 
 
1600 
			return null;
1601 
		}
1602 
	}
1603 
 
1604 
    /**
1605 
     *
1606 
     * @param entityID
1607 
     * @return
1608 
     * @throws Exception
1609 
     */
1610 
    private ExpandedEntity getExpandedEntity(long entityID) throws Exception {
1611 
    	if(this.expEntity == null) {
1612 
    		if(this.entity == null) {
1613 
    			this.entity = this.getEntity(entityID);
1614 
    		}
1615 
 
1616 
	    	this.expEntity = new ExpandedEntity(entity);
1617 
    	}
1618 
 
1619 
    	return this.expEntity;
1620 
    }
1621 
 
1622 
    /**
1623 
     *
1624 
     * @param entityID
1625 
     * @return
1626 
     * @throws Exception
1627 
     */
1628 
    private Entity getEntity(long entityID) throws Exception {
739 chandransh 1629 
    	log.info("Getting entity with id : " + entityID);
250 naveen 1630 
		if(this.entity == null) {
1631 
			this.entity = CreationUtils.getEntity(entityID);
1632 
		}
1633 
 
1634 
		return this.entity;
1635 
	}
448 rajveer 1636 
 
1637 
 
162 naveen 1638 
}