Subversion Repositories SmartDukaan

Rev

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