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