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;
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) {
403 rajveer 775
 
776
				// Mandatory
777
				// or optional/recommended but allows blanck and not skipped
310 rajveer 778
				if(slideFeatureDef.getEditorialImportance() == 
403 rajveer 779
					EditorialImportance.MANDATORY || expFeatureDef.allowsBlank()) {		
310 rajveer 780
					features.add(feature);
781
				}
782
 
783
				continue;
784
			}
785
 
786
			// Bullets
787
			List<Bullet> bullets = new ArrayList<Bullet>();
788
 
206 naveen 789
			// Collect unit
790
			String[] unitIDs = this.reqparams.get(featureDefIDString + "_unit");
791
			long unitID = 0L;
792
			if(unitIDs != null && unitIDs.length > 0) {
793
				unitID = Long.parseLong(unitIDs[0]);
794
			}
795
 
201 naveen 796
			// Composite
797
			if(expBulletDef.isComposite()) {
204 naveen 798
				log.info("Composite");
201 naveen 799
 
204 naveen 800
				CompositeDataObject compositeDataObject = 
801
					new CompositeDataObject();
802
 
803
				CompositeDefinition compositeDef = 
804
					(CompositeDefinition)expBulletDef.getDatatypeDefinition(); 
805
 
806
				List<CompositePartDefinition> compositeParts = 
807
					compositeDef.getCompositePartDefinitions();
808
 
809
				for(int j=0;j<compositeParts.size();j++) {
810
					String[] partValues = this.reqparams.get(
208 naveen 811
							featureDefIDString + "_" + (j + 1));
204 naveen 812
 
813
					if(partValues != null && partValues.length > 0) {
814
						compositeDataObject.addPrimitiveDataObject(
815
							new PrimitiveDataObject(partValues[0]));
816
					}
817
				}
818
 
819
				Bullet bullet = new Bullet(compositeDataObject);
820
 
206 naveen 821
				if(unitID != 0L) {
822
					bullet.setUnitID(unitID);
823
				}
824
 
204 naveen 825
				bullets.add(bullet);
201 naveen 826
			}
827
 
828
			// Enumerated
829
			else if(expBulletDef.isEnumerated()) {
204 naveen 830
				log.info("Enumerated");
310 rajveer 831
 
204 naveen 832
				String[] bulletValues = this.reqparams.get(featureDefIDString);
833
				log.info("bulletValues:" + Arrays.toString(bulletValues));
206 naveen 834
 
204 naveen 835
 
206 naveen 836
				for(int i=0;i<bulletValues.length;i++) {
837
					EnumDataObject enumDataObject = 
838
						new EnumDataObject(Long.parseLong(bulletValues[i]));
839
 
840
					Bullet bullet = new Bullet(enumDataObject);
841
 
842
					if(unitID != 0L) {
843
						bullet.setUnitID(unitID);
844
					}
845
 
846
					bullets.add(bullet);
847
				}
201 naveen 848
			}
849
 
850
			// Primitive
851
			else {
204 naveen 852
				log.info("Primitive");
310 rajveer 853
 
204 naveen 854
				String[] bulletValues = this.reqparams.get(featureDefIDString);
855
				log.info("bulletValues:" + Arrays.toString(bulletValues));
856
 
206 naveen 857
				for(int i=0;i<bulletValues.length;i++) {
858
					Bullet bullet = new Bullet(
859
							new PrimitiveDataObject(bulletValues[i]));
860
 
861
					if(unitID != 0L) {
862
						bullet.setUnitID(unitID);
863
					}
864
 
865
					bullets.add(bullet);
866
				}
201 naveen 867
			}
868
 
869
			feature.setBullets(bullets);
870
 
871
			// FFC
872
			FreeformContent featureFFC = 
873
				this.getFreeformContent(featureDefIDString);
874
 
875
			feature.setFreeformContent(featureFFC);
876
 
877
			features.add(feature);
878
		}
879
 
880
		return features;
881
	}
882
 
242 naveen 883
    // DELETE /entity/1000001
884
    /**
885
     * 
886
     */
887
    public String destroy() {
250 naveen 888
    	log.info("#### EntityController.destroy ####");
242 naveen 889
 
890
    	long entityID = Long.parseLong(this.getId());
891
    	log.info("entityID:" + entityID);
892
 
893
		// Store
894
		try {
250 naveen 895
	    	Entity entity = this.getEntity(entityID);
242 naveen 896
	    	EntityContainer ents = this.getEntityContainer();
897
 
898
	    	Map<Long, Entity> entities = ents.getEntities();
899
	    	Map<Long, List<Entity>> entitiesbycat = 
900
	    		ents.getEntitiesbyCategory();
901
 
902
	    	entities.remove(new Long(entityID));
903
 
904
	    	List<Entity> catentities = 
905
	    		entitiesbycat.get(new Long(entity.getCategoryID()));
906
 
907
	    	Entity entitytodelete = null;
908
	    	for(Entity catentity : catentities) {
909
	    		if(catentity.getID() == entityID) {
910
	    			entitytodelete = catentity;
911
	    			break;
912
	    		}
913
	    	}
914
 
915
	    	if(entitytodelete != null) {
916
	    		catentities.remove(entitytodelete);
917
	    	}
918
 
250 naveen 919
	    	CreationUtils.deleteFromIncomplete(entity);
920
 
921
	    	CreationUtils.deleteEntity(entityID);
922
 
923
	    	CreationUtils.rewriteRepository(entities, entitiesbycat);
242 naveen 924
		} catch (Exception e) {
925
			log.error(CreationUtils.getStackTrace(e));
926
			this.setErrorString(CreationUtils.getStackTrace(e));
927
			return "fatal";
928
		}
929
 
930
        addActionMessage("Entity deleted successfully");
931
        return "success";
932
    }
201 naveen 933
	/**
934
     * 
935
     * @param ID
936
     * @return
937
     */
938
    private FreeformContent getFreeformContent(String ID) {
939
		FreeformContent ffc = new FreeformContent();
940
		String[] ffts = this.reqparams.get(ID + "_fft");
941
		if(ffts != null) {
942
			ffc.setFreeformTexts(Arrays.asList(ffts));
943
		}
944
 
210 naveen 945
		String[] imgRefs = this.reqparams.get(ID + "_image_references");
946
		if(imgRefs != null) {
947
			ffc.setMedia("image", Arrays.asList(imgRefs));
201 naveen 948
		}
949
 
210 naveen 950
		String[] youtubeRefs = 
951
			this.reqparams.get(ID + "_youtube_references");
952
		if(youtubeRefs != null) {
953
			ffc.setMedia("youtube", Arrays.asList(youtubeRefs));
201 naveen 954
		}
955
 
956
		log.info("ffc:" + ffc);
957
		return ffc;
958
	}
213 naveen 959
 
960
 
961
    /**
962
     * 
963
     * @param slideDefinitionID
964
     * @return
965
     */
966
	public ExpandedSlide getChildSlide(long slideDefinitionID) {
242 naveen 967
		if(this.expSlide == null) {
968
			return null;
969
		}
970
 
213 naveen 971
		return this.getChildSlide(this.expSlide, slideDefinitionID);
972
	}
973
 
974
 
975
    /**
976
     * 
977
     * @param expSlide
978
     * @param slideDefinitionID
979
     * @return
980
     */
981
	public ExpandedSlide getChildSlide(ExpandedSlide expSlide, 
982
			long slideDefinitionID) {
983
 
984
		List<ExpandedSlide> childrenSlides = 
985
			expSlide.getExpandedChildrenSlides();
986
 
987
		ExpandedSlide resultSlide = null;
988
 
989
		if(childrenSlides != null) {
990
			for(ExpandedSlide childSlide : childrenSlides) {
991
				if(childSlide.getSlideDefinitionID() == slideDefinitionID) {
992
					return childSlide;
993
				}
994
 
995
				resultSlide = this.getChildSlide(childSlide, slideDefinitionID);
996
				if(resultSlide == null) {
997
					continue;
998
				}
999
				else {
1000
					break;
1001
				}
1002
			}
1003
		}
1004
 
1005
		return resultSlide;
1006
	}
201 naveen 1007
 
1008
	/**
162 naveen 1009
	 * @return the entities
1010
	 */
1011
	public Collection<Entity> getEntities() {
1012
		return entities;
1013
	}
1014
 
250 naveen 1015
	/**
1016
	 * 
1017
	 * @return
1018
	 */
1019
	public List<Entity> getIncompleteEntities() {
1020
		try {
1021
			return CreationUtils.getIncomplete();
1022
		} catch (Exception e) {
1023
			log.error(CreationUtils.getStackTrace(e));
1024
			this.setErrorString(CreationUtils.getStackTrace(e));
1025
			return null;
1026
		}
1027
	}
1028
 
162 naveen 1029
    /**
1030
	 * @return the entities
1031
	 */
1032
	public ExpandedEntity getEntity() {
1033
		return expEntity;
1034
	}
1035
 
198 naveen 1036
    /**
1037
	 * @return the current slide to edit
1038
	 */
1039
	public ExpandedSlideDefinition getExpandedSlideDefinition() {
1040
		return expSlideDef;
1041
	}
213 naveen 1042
 
1043
	/**
1044
	 * 
1045
	 * @param slideDefID
1046
	 * @return
1047
	 */
1048
	public ExpandedSlideDefinition getExpandedSlideDefinition(long slideDefID) {
1049
		DefinitionsContainer defs = this.getDefinitionsContainer();
1050
 
1051
		try {
1052
			return defs.getExpandedSlideDefinition(slideDefID);
1053
		} catch (Exception e) {
1054
			return null;
1055
		}
1056
	}
162 naveen 1057
 
1058
	/**
1059
     * 
1060
     * @param id
1061
     */
1062
    public void setId(String id) {
1063
        this.id = id;
1064
    }
1065
 
1066
    /**
1067
     * 
1068
     */
1069
    public String getId() {
1070
    	return this.id;
1071
    }
1072
 
198 naveen 1073
	/**
1074
	 * @return the firstSlideID
1075
	 */
213 naveen 1076
	public long getFirstSlideDefID() {
1077
		return firstSlideDefID;
198 naveen 1078
	}
1079
 
162 naveen 1080
	@Override
1081
	public void setParameters(Map<String, String[]> reqmap) {
1082
		log.info("setParameters:" + reqmap);
1083
 
1084
		this.reqparams = reqmap;
1085
	}
1086
 
448 rajveer 1087
	public String getCategoriesTree()  throws Exception {
1088
		DefinitionsContainer defs = this.getDefinitionsContainer();
1089
		Map<String, String> cats = new HashMap<String, String>();
1090
 
1091
		List<Category> children = defs.getChildrenCategories(10000L);
1092
 
1093
		for(Category child : children) {
1094
			cats.put(new Long(child.getID()).toString(), child.getLabel());
1095
		}
1096
		return "";
1097
	}
1098
 
198 naveen 1099
	public Map<String, String> getCategories() throws Exception {
1100
		DefinitionsContainer defs = this.getDefinitionsContainer();
1101
		Map<String, String> cats = new HashMap<String, String>();
1102
 
448 rajveer 1103
		List<Category> children = defs.getChildrenCategories(10000L);
198 naveen 1104
		for(Category child : children) {
1105
			cats.put(new Long(child.getID()).toString(), child.getLabel());
1106
		}
1107
 
1108
		return cats;
1109
	}
448 rajveer 1110
 
1111
	public Map<String, String> getSubcategories() throws Exception {
1112
		DefinitionsContainer defs = this.getDefinitionsContainer();
1113
		Map<String, String> cats = new HashMap<String, String>();
1114
 
1115
		List<Category> children = defs.getChildrenCategories(10000L);
1116
		for(Category child : children) {
1117
			List<Category> grandChildren = defs.getChildrenCategories(child.getID());
1118
			for(Category grandchild : grandChildren) {
1119
				cats.put(new Long(grandchild.getID()).toString(), grandchild.getLabel());
1120
			}
1121
		}
1122
 
1123
		return cats;
1124
	}
1125
	public String getCategoriesString() throws Exception {
1126
		DefinitionsContainer defs = this.getDefinitionsContainer();
1127
		StringBuilder categoryString = new StringBuilder();
1128
 
1129
		categoryString.append("<label for=\"basecategory\">Category: </label>");
1130
		categoryString.append("\n");
1131
		categoryString.append("<select id=\"basecategory\"  name=\"basecategory\" >"); 
1132
		categoryString.append("\n");
1133
		List<Category> children = defs.getChildrenCategories(10000L);
1134
		for(Category child : children) {
1135
			categoryString.append("<option value=\"" + new Long(child.getID()).toString() + "\">" + child.getLabel() + "</option>");
1136
			categoryString.append("\n");
1137
		}
1138
		categoryString.append("</select>");
1139
		categoryString.append("\n");
1140
		categoryString.append("<br/>");
1141
		categoryString.append("\n");
1142
 
1143
		categoryString.append("<label for=\"category\">Sub Category: </label>");
1144
		categoryString.append("\n");
1145
		categoryString.append("<select id=\"category\" name=\"category\" >");
1146
		categoryString.append("\n");
1147
		for(Category child : children) {
1148
			List<Category> grandChildren = defs.getChildrenCategories(child.getID());
1149
			for(Category grandchild : grandChildren) {
1150
				categoryString.append("<option value=\"" + new Long(grandchild.getID()).toString() + "\" selected=\"$selected\" class = \""+ child.getID()  + "\">" + grandchild.getLabel() + "</option>");
1151
				categoryString.append("\n");
1152
			}
1153
		}
1154
		categoryString.append("</select>");
1155
		categoryString.append("\n");
1156
		categoryString.append("<br/>");
1157
 
1158
		return categoryString.toString();
1159
 
1160
	}
1161
 
1162
 
250 naveen 1163
	/**
1164
	 * 
1165
	 * @return
1166
	 * @throws Exception
1167
	 */
198 naveen 1168
	public String getBrandString() throws Exception {
1169
		List<String> brands = this.getBrands();
1170
		return "\"" + StringUtils.join(brands, "\", \"") + "\"";
1171
	}
1172
 
250 naveen 1173
	/**
1174
	 * 
1175
	 * @return
1176
	 * @throws Exception
1177
	 */
198 naveen 1178
	public List<String> getBrands() throws Exception {
1179
		EntityContainer ents = this.getEntityContainer();
1180
		List<String> brands = new ArrayList<String>();
1181
 
1182
		List<ExpandedBullet> expBullets;
1183
 
1184
		expBullets = ents.getLearnedBullets(
1185
				Utils.BRAND_FEATURE_DEFINITION_ID);
1186
 
1187
		for(ExpandedBullet expBullet : expBullets) {
1188
			brands.add(expBullet.getValue());
1189
		}
1190
 
1191
		return brands;
1192
	}
1193
 
245 naveen 1194
	/**
1195
	 * 
1196
	 * @return
1197
	 */
242 naveen 1198
    protected EntityContainer getEntityContainer() {
198 naveen 1199
    	if(this.ents == null) {
245 naveen 1200
    		this.ents = Catalog.getInstance().getEntityContainer();
198 naveen 1201
    	}
1202
 
1203
	    return this.ents;
1204
    }
245 naveen 1205
 
1206
    /**
1207
     * 
1208
     * @return
1209
     */
242 naveen 1210
    protected DefinitionsContainer getDefinitionsContainer() {
198 naveen 1211
    	if(this.defs == null) {
245 naveen 1212
    		this.defs = Catalog.getInstance().getDefinitionsContainer();
198 naveen 1213
    	}
1214
 
1215
	    return this.defs;
1216
    }
1217
 
1218
    /**
1219
     * 
1220
     * @param entity
1221
     * @throws Exception
1222
     */
250 naveen 1223
	private void addEntity(Entity entity) throws Exception {
1224
		log.info("#### EntityController.addEntity ####");
245 naveen 1225
		EntityContainer entContainer = this.getEntityContainer();
198 naveen 1226
 
1227
		entContainer.addEntity(entity);
1228
 
250 naveen 1229
		CreationUtils.storeEntity(entity);
1230
 
1231
		ContentValidator validator = new ContentValidator();
1232
		if(!validator.validate(entity)) {
1233
			CreationUtils.addToIncomplete(entity);
1234
		}
1235
		// Add to repository only if validations succeed
1236
		else {
1237
			CreationUtils.deleteFromIncomplete(entity);
1238
 
1239
			this.updateRepository();
1240
		}
198 naveen 1241
	}
1242
 
1243
    /**
1244
     * 
1245
     * @param entity
1246
     * @throws Exception
1247
     */
250 naveen 1248
	private void updateEntity(Entity entity) throws Exception {		
1249
		log.info("#### EntityController.updateEntity ####");
245 naveen 1250
		EntityContainer entContainer = this.getEntityContainer();
198 naveen 1251
 
250 naveen 1252
		ContentValidator validator = new ContentValidator();
1253
		if(!validator.validate(entity)) {
1254
			CreationUtils.addToIncomplete(entity);
1255
 
1256
			// Delete from repository if incomplete
1257
			entContainer.deleteEntity(entity);
1258
		}
1259
		else {
1260
			CreationUtils.deleteFromIncomplete(entity);
1261
 
1262
			entContainer.updateEntity(entity);
1263
		}
1264
 
1265
		CreationUtils.storeEntity(entity);
1266
 
1267
		this.updateRepository();
245 naveen 1268
	}
1269
 
1270
	/**
1271
	 * 
1272
	 * @throws Exception
1273
	 */
250 naveen 1274
	private void updateRepository() throws Exception {	
245 naveen 1275
		EntityContainer entContainer = this.getEntityContainer();
198 naveen 1276
 
249 naveen 1277
		Map<Long, Entity> entities = entContainer.getEntities();
1278
		log.info("entities.size():" + entities.size());
245 naveen 1279
 
249 naveen 1280
		Map<Long, List<Entity>> entitiesByCategory = 
1281
			entContainer.getEntitiesbyCategory();
1282
		log.info("entitiesByCategory.size():" + entitiesByCategory.size());
245 naveen 1283
 
250 naveen 1284
		CreationUtils.rewriteRepository(entities, entitiesByCategory);
198 naveen 1285
	}
1286
 
162 naveen 1287
	/**
198 naveen 1288
	 * @param exception the exception to set
1289
	 */
1290
	public void setException(Exception exception) {
1291
		this.exception = exception;
1292
	}
1293
 
1294
	/**
1295
	 * @return the exception
1296
	 */
1297
	public Exception getException() {
1298
		return exception;
1299
	}
1300
 
1301
	/**
1302
	 * @param errorString the exceptionString to set
1303
	 */
1304
	public void setErrorString(String errorString) {
1305
		this.errorString = errorString;
1306
	}
1307
 
1308
	/**
1309
	 * @return the exceptionString
1310
	 */
1311
	public String getErrorString() {
1312
		return errorString;
1313
	}
1314
 
1315
	/**
1316
	 * @param newCurrentSlideID the newCurrentSlideID to set
1317
	 */
1318
	public void setNewCurrentSlideDefinitionID(
1319
			long newCurrentSlideDefinitionID) {
1320
		this.newCurrentSlideDefinitionID = newCurrentSlideDefinitionID;
1321
	}
1322
 
1323
	/**
1324
	 * @return the newCurrentSlideID
1325
	 */
1326
	public long getNewCurrentSlideDefinitionID() {
1327
		return newCurrentSlideDefinitionID;
1328
	}
1329
 
1330
	/**
1331
	 * @param newNextSlideID the newNextSlideID to set
1332
	 */
1333
	public void setNewNextSlideDefinitionID(long newNextSlideDefinitionID) {
1334
		this.newNextSlideDefinitionID = newNextSlideDefinitionID;
1335
	}
1336
 
1337
	/**
1338
	 * @return the newNextSlideID
1339
	 */
1340
	public long getNewNextSlideDefinitionID() {
1341
		return newNextSlideDefinitionID;
1342
	}
1343
 
1344
	/**
1345
	 * @param expSlide the expSlide to set
1346
	 */
1347
	public void setExpandedSlide(ExpandedSlide expSlide) {
1348
		this.expSlide = expSlide;
1349
	}
1350
 
1351
	/**
1352
	 * @return the expSlide
1353
	 */
1354
	public ExpandedSlide getExpandedSlide() {
1355
		return expSlide;
1356
	}
1357
 
1358
	/**
1359
	 * @param newPrevSlideDefinitionID the newPrevSlideDefinitionID to set
1360
	 */
1361
	public void setNewPrevSlideDefinitionID(long newPrevSlideDefinitionID) {
1362
		this.newPrevSlideDefinitionID = newPrevSlideDefinitionID;
1363
	}
1364
 
1365
	/**
1366
	 * @return the newPrevSlideDefinitionID
1367
	 */
1368
	public long getNewPrevSlideDefinitionID() {
1369
		return newPrevSlideDefinitionID;
1370
	}
1371
 
1372
	/**
162 naveen 1373
	 * 
200 naveen 1374
	 * @param featureDefinitionID
1375
	 * @return
1376
	 * @throws Exception
1377
	 */
1378
	public String getLearnedValuesString(long featureDefinitionID) 
1379
			throws Exception {
206 naveen 1380
		List<String> learnedValues = this.getLearnedValues(featureDefinitionID);
1381
		if(learnedValues == null) {
1382
			return "";
1383
		}
1384
 
1385
		return "\"" + StringUtils.join(learnedValues, "\", \"") + "\"";
1386
	}
1387
 
1388
	/**
1389
	 * 
1390
	 * @param featureDefinitionID
1391
	 * @return
1392
	 * @throws Exception
1393
	 */
1394
	public List<String> getLearnedValues(long featureDefinitionID) 
1395
			throws Exception {
200 naveen 1396
		EntityContainer ents = this.getEntityContainer();
1397
		List<ExpandedBullet> learnedBullets = 
1398
			ents.getLearnedBullets(featureDefinitionID);
1399
 
201 naveen 1400
		if(learnedBullets == null) {
206 naveen 1401
			return null;
201 naveen 1402
		}
1403
 
200 naveen 1404
		List<String> learnedValues = new ArrayList<String>();
1405
		for(ExpandedBullet expBullet : learnedBullets) {
1406
			learnedValues.add(expBullet.getValue());
1407
		}
1408
 
206 naveen 1409
		return learnedValues;
200 naveen 1410
	}
1411
 
1412
	/**
1413
	 * 
201 naveen 1414
	 * @param featureDefinitionID
1415
	 * @return
1416
	 * @throws Exception
1417
	 */
1418
	public ExpandedFeature getFeature(long featureDefinitionID) 
1419
		throws Exception {
1420
		EntityContainer ents = this.getEntityContainer();
1421
 
215 naveen 1422
		if(this.expSlide != null) {
1423
			Feature feature = ents.getFeature(
1424
					this.expSlide, featureDefinitionID);
1425
 
1426
			if(feature == null) {
1427
				return null;
1428
			}
1429
			return new ExpandedFeature(feature);
201 naveen 1430
		}
1431
 
215 naveen 1432
		return null;
201 naveen 1433
	}
1434
 
1435
	/**
1436
	 * 
162 naveen 1437
	 * @return
1438
	 */
208 naveen 1439
	public String getEditorialImportance() {
242 naveen 1440
		// Now that slides are selected upfront
1441
		return "Mandatory";
1442
 
1443
		/*
208 naveen 1444
		long catID = this.expEntity.getCategoryID();
1445
		long slideDefID = this.getNewCurrentSlideDefinitionID();
1446
 
1447
		try {
1448
			List<CategorySlideDefinition> catSlideDefs =
1449
				defs.getCategorySlideDefinitions(catID);
1450
			for(CategorySlideDefinition catSlideDef : catSlideDefs) {
1451
				if(catSlideDef.getSlideDefintionID() == slideDefID) {
1452
					return catSlideDef.getEditorialImportance().toString();
1453
				}
1454
			}
1455
		} catch (Exception e) {
1456
			log.error(CreationUtils.getStackTrace(e));
1457
    	}
1458
 
1459
		return "";
242 naveen 1460
		*/
162 naveen 1461
	}
210 naveen 1462
 
1463
	/**
1464
	 * 
1465
	 * @return
1466
	 * @throws Exception 
1467
	 * @throws NumberFormatException 
1468
	 */
1469
	public List<String> getMediaLabels(String type) {
1470
		try {
1471
			return CreationUtils.getMediaLabels(Long.parseLong(this.getId()), 
1472
					type);
1473
		}
1474
		catch(Exception nfe) {
1475
			return null;
1476
		}
1477
	}
242 naveen 1478
 
1479
	/**
1480
	 * 
1481
	 * @return
1482
	 */
1483
	public String getCategoryName(long categoryID) {
1484
		try {
1485
			return this.getDefinitionsContainer().getCategory(categoryID).
1486
				getLabel();
1487
		} catch (Exception e) {
1488
			return null;
1489
		}
1490
	}
250 naveen 1491
 
1492
	/**
1493
	 * 
1494
	 * @return
1495
	 */
1496
	public List<String[]> getSlides() {
1497
		try {
1498
			long entityID = Long.parseLong(this.getId());
310 rajveer 1499
			long categoryID = this.getEntity().getCategoryID();
1500
			List<Long> slideDefIDs = CreationUtils.getSlideSequence(entityID, categoryID);
250 naveen 1501
 
1502
			List<String[]> slideData = new ArrayList<String[]>();
1503
 
1504
			DefinitionsContainer defs = this.getDefinitionsContainer();
1505
			for(Long slideDefID : slideDefIDs) {
1506
				SlideDefinition slideDef = defs.getSlideDefinition(slideDefID);
1507
				String label = slideDef.getLabel();
1508
 
1509
				slideData.add(new String[] {slideDefID.toString(), label});
1510
			}
1511
 
1512
			return slideData;
1513
		} catch (Exception e) {
1514
			log.error(CreationUtils.getStackTrace(e));
1515
 
1516
			return null;
1517
		}
1518
	} 
1519
 
1520
    /**
1521
     * 
1522
     * @param entityID
1523
     * @return
1524
     * @throws Exception 
1525
     */
1526
    private ExpandedEntity getExpandedEntity(long entityID) throws Exception {
1527
    	if(this.expEntity == null) {
1528
    		if(this.entity == null) {
1529
    			this.entity = this.getEntity(entityID);
1530
    		}
1531
 
1532
	    	this.expEntity = new ExpandedEntity(entity);
1533
    	}
1534
 
1535
    	return this.expEntity;
1536
    }
1537
 
1538
    /**
1539
     * 
1540
     * @param entityID
1541
     * @return
1542
     * @throws Exception 
1543
     */
1544
    private Entity getEntity(long entityID) throws Exception {
1545
    	log.info("#### EntityController.getEntity ####");
1546
		if(this.entity == null) {
1547
			this.entity = CreationUtils.getEntity(entityID);
1548
		}
1549
 
1550
		return this.entity;
1551
	}
448 rajveer 1552
 
1553
 
162 naveen 1554
}