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
 
198 naveen 1087
	public Map<String, String> getCategories() throws Exception {
1088
		DefinitionsContainer defs = this.getDefinitionsContainer();
1089
		Map<String, String> cats = new HashMap<String, String>();
1090
 
1091
		List<Category> children = defs.getChildrenCategories(10001L);
1092
		for(Category child : children) {
1093
			cats.put(new Long(child.getID()).toString(), child.getLabel());
1094
		}
1095
 
1096
		return cats;
1097
	}
1098
 
250 naveen 1099
	/**
1100
	 * 
1101
	 * @return
1102
	 * @throws Exception
1103
	 */
198 naveen 1104
	public String getBrandString() throws Exception {
1105
		List<String> brands = this.getBrands();
1106
		return "\"" + StringUtils.join(brands, "\", \"") + "\"";
1107
	}
1108
 
250 naveen 1109
	/**
1110
	 * 
1111
	 * @return
1112
	 * @throws Exception
1113
	 */
198 naveen 1114
	public List<String> getBrands() throws Exception {
1115
		EntityContainer ents = this.getEntityContainer();
1116
		List<String> brands = new ArrayList<String>();
1117
 
1118
		List<ExpandedBullet> expBullets;
1119
 
1120
		expBullets = ents.getLearnedBullets(
1121
				Utils.BRAND_FEATURE_DEFINITION_ID);
1122
 
1123
		for(ExpandedBullet expBullet : expBullets) {
1124
			brands.add(expBullet.getValue());
1125
		}
1126
 
1127
		return brands;
1128
	}
1129
 
245 naveen 1130
	/**
1131
	 * 
1132
	 * @return
1133
	 */
242 naveen 1134
    protected EntityContainer getEntityContainer() {
198 naveen 1135
    	if(this.ents == null) {
245 naveen 1136
    		this.ents = Catalog.getInstance().getEntityContainer();
198 naveen 1137
    	}
1138
 
1139
	    return this.ents;
1140
    }
245 naveen 1141
 
1142
    /**
1143
     * 
1144
     * @return
1145
     */
242 naveen 1146
    protected DefinitionsContainer getDefinitionsContainer() {
198 naveen 1147
    	if(this.defs == null) {
245 naveen 1148
    		this.defs = Catalog.getInstance().getDefinitionsContainer();
198 naveen 1149
    	}
1150
 
1151
	    return this.defs;
1152
    }
1153
 
1154
    /**
1155
     * 
1156
     * @param entity
1157
     * @throws Exception
1158
     */
250 naveen 1159
	private void addEntity(Entity entity) throws Exception {
1160
		log.info("#### EntityController.addEntity ####");
245 naveen 1161
		EntityContainer entContainer = this.getEntityContainer();
198 naveen 1162
 
1163
		entContainer.addEntity(entity);
1164
 
250 naveen 1165
		CreationUtils.storeEntity(entity);
1166
 
1167
		ContentValidator validator = new ContentValidator();
1168
		if(!validator.validate(entity)) {
1169
			CreationUtils.addToIncomplete(entity);
1170
		}
1171
		// Add to repository only if validations succeed
1172
		else {
1173
			CreationUtils.deleteFromIncomplete(entity);
1174
 
1175
			this.updateRepository();
1176
		}
198 naveen 1177
	}
1178
 
1179
    /**
1180
     * 
1181
     * @param entity
1182
     * @throws Exception
1183
     */
250 naveen 1184
	private void updateEntity(Entity entity) throws Exception {		
1185
		log.info("#### EntityController.updateEntity ####");
245 naveen 1186
		EntityContainer entContainer = this.getEntityContainer();
198 naveen 1187
 
250 naveen 1188
		ContentValidator validator = new ContentValidator();
1189
		if(!validator.validate(entity)) {
1190
			CreationUtils.addToIncomplete(entity);
1191
 
1192
			// Delete from repository if incomplete
1193
			entContainer.deleteEntity(entity);
1194
		}
1195
		else {
1196
			CreationUtils.deleteFromIncomplete(entity);
1197
 
1198
			entContainer.updateEntity(entity);
1199
		}
1200
 
1201
		CreationUtils.storeEntity(entity);
1202
 
1203
		this.updateRepository();
245 naveen 1204
	}
1205
 
1206
	/**
1207
	 * 
1208
	 * @throws Exception
1209
	 */
250 naveen 1210
	private void updateRepository() throws Exception {	
245 naveen 1211
		EntityContainer entContainer = this.getEntityContainer();
198 naveen 1212
 
249 naveen 1213
		Map<Long, Entity> entities = entContainer.getEntities();
1214
		log.info("entities.size():" + entities.size());
245 naveen 1215
 
249 naveen 1216
		Map<Long, List<Entity>> entitiesByCategory = 
1217
			entContainer.getEntitiesbyCategory();
1218
		log.info("entitiesByCategory.size():" + entitiesByCategory.size());
245 naveen 1219
 
250 naveen 1220
		CreationUtils.rewriteRepository(entities, entitiesByCategory);
198 naveen 1221
	}
1222
 
162 naveen 1223
	/**
198 naveen 1224
	 * @param exception the exception to set
1225
	 */
1226
	public void setException(Exception exception) {
1227
		this.exception = exception;
1228
	}
1229
 
1230
	/**
1231
	 * @return the exception
1232
	 */
1233
	public Exception getException() {
1234
		return exception;
1235
	}
1236
 
1237
	/**
1238
	 * @param errorString the exceptionString to set
1239
	 */
1240
	public void setErrorString(String errorString) {
1241
		this.errorString = errorString;
1242
	}
1243
 
1244
	/**
1245
	 * @return the exceptionString
1246
	 */
1247
	public String getErrorString() {
1248
		return errorString;
1249
	}
1250
 
1251
	/**
1252
	 * @param newCurrentSlideID the newCurrentSlideID to set
1253
	 */
1254
	public void setNewCurrentSlideDefinitionID(
1255
			long newCurrentSlideDefinitionID) {
1256
		this.newCurrentSlideDefinitionID = newCurrentSlideDefinitionID;
1257
	}
1258
 
1259
	/**
1260
	 * @return the newCurrentSlideID
1261
	 */
1262
	public long getNewCurrentSlideDefinitionID() {
1263
		return newCurrentSlideDefinitionID;
1264
	}
1265
 
1266
	/**
1267
	 * @param newNextSlideID the newNextSlideID to set
1268
	 */
1269
	public void setNewNextSlideDefinitionID(long newNextSlideDefinitionID) {
1270
		this.newNextSlideDefinitionID = newNextSlideDefinitionID;
1271
	}
1272
 
1273
	/**
1274
	 * @return the newNextSlideID
1275
	 */
1276
	public long getNewNextSlideDefinitionID() {
1277
		return newNextSlideDefinitionID;
1278
	}
1279
 
1280
	/**
1281
	 * @param expSlide the expSlide to set
1282
	 */
1283
	public void setExpandedSlide(ExpandedSlide expSlide) {
1284
		this.expSlide = expSlide;
1285
	}
1286
 
1287
	/**
1288
	 * @return the expSlide
1289
	 */
1290
	public ExpandedSlide getExpandedSlide() {
1291
		return expSlide;
1292
	}
1293
 
1294
	/**
1295
	 * @param newPrevSlideDefinitionID the newPrevSlideDefinitionID to set
1296
	 */
1297
	public void setNewPrevSlideDefinitionID(long newPrevSlideDefinitionID) {
1298
		this.newPrevSlideDefinitionID = newPrevSlideDefinitionID;
1299
	}
1300
 
1301
	/**
1302
	 * @return the newPrevSlideDefinitionID
1303
	 */
1304
	public long getNewPrevSlideDefinitionID() {
1305
		return newPrevSlideDefinitionID;
1306
	}
1307
 
1308
	/**
162 naveen 1309
	 * 
200 naveen 1310
	 * @param featureDefinitionID
1311
	 * @return
1312
	 * @throws Exception
1313
	 */
1314
	public String getLearnedValuesString(long featureDefinitionID) 
1315
			throws Exception {
206 naveen 1316
		List<String> learnedValues = this.getLearnedValues(featureDefinitionID);
1317
		if(learnedValues == null) {
1318
			return "";
1319
		}
1320
 
1321
		return "\"" + StringUtils.join(learnedValues, "\", \"") + "\"";
1322
	}
1323
 
1324
	/**
1325
	 * 
1326
	 * @param featureDefinitionID
1327
	 * @return
1328
	 * @throws Exception
1329
	 */
1330
	public List<String> getLearnedValues(long featureDefinitionID) 
1331
			throws Exception {
200 naveen 1332
		EntityContainer ents = this.getEntityContainer();
1333
		List<ExpandedBullet> learnedBullets = 
1334
			ents.getLearnedBullets(featureDefinitionID);
1335
 
201 naveen 1336
		if(learnedBullets == null) {
206 naveen 1337
			return null;
201 naveen 1338
		}
1339
 
200 naveen 1340
		List<String> learnedValues = new ArrayList<String>();
1341
		for(ExpandedBullet expBullet : learnedBullets) {
1342
			learnedValues.add(expBullet.getValue());
1343
		}
1344
 
206 naveen 1345
		return learnedValues;
200 naveen 1346
	}
1347
 
1348
	/**
1349
	 * 
201 naveen 1350
	 * @param featureDefinitionID
1351
	 * @return
1352
	 * @throws Exception
1353
	 */
1354
	public ExpandedFeature getFeature(long featureDefinitionID) 
1355
		throws Exception {
1356
		EntityContainer ents = this.getEntityContainer();
1357
 
215 naveen 1358
		if(this.expSlide != null) {
1359
			Feature feature = ents.getFeature(
1360
					this.expSlide, featureDefinitionID);
1361
 
1362
			if(feature == null) {
1363
				return null;
1364
			}
1365
			return new ExpandedFeature(feature);
201 naveen 1366
		}
1367
 
215 naveen 1368
		return null;
201 naveen 1369
	}
1370
 
1371
	/**
1372
	 * 
162 naveen 1373
	 * @return
1374
	 */
208 naveen 1375
	public String getEditorialImportance() {
242 naveen 1376
		// Now that slides are selected upfront
1377
		return "Mandatory";
1378
 
1379
		/*
208 naveen 1380
		long catID = this.expEntity.getCategoryID();
1381
		long slideDefID = this.getNewCurrentSlideDefinitionID();
1382
 
1383
		try {
1384
			List<CategorySlideDefinition> catSlideDefs =
1385
				defs.getCategorySlideDefinitions(catID);
1386
			for(CategorySlideDefinition catSlideDef : catSlideDefs) {
1387
				if(catSlideDef.getSlideDefintionID() == slideDefID) {
1388
					return catSlideDef.getEditorialImportance().toString();
1389
				}
1390
			}
1391
		} catch (Exception e) {
1392
			log.error(CreationUtils.getStackTrace(e));
1393
    	}
1394
 
1395
		return "";
242 naveen 1396
		*/
162 naveen 1397
	}
210 naveen 1398
 
1399
	/**
1400
	 * 
1401
	 * @return
1402
	 * @throws Exception 
1403
	 * @throws NumberFormatException 
1404
	 */
1405
	public List<String> getMediaLabels(String type) {
1406
		try {
1407
			return CreationUtils.getMediaLabels(Long.parseLong(this.getId()), 
1408
					type);
1409
		}
1410
		catch(Exception nfe) {
1411
			return null;
1412
		}
1413
	}
242 naveen 1414
 
1415
	/**
1416
	 * 
1417
	 * @return
1418
	 */
1419
	public String getCategoryName(long categoryID) {
1420
		try {
1421
			return this.getDefinitionsContainer().getCategory(categoryID).
1422
				getLabel();
1423
		} catch (Exception e) {
1424
			return null;
1425
		}
1426
	}
250 naveen 1427
 
1428
	/**
1429
	 * 
1430
	 * @return
1431
	 */
1432
	public List<String[]> getSlides() {
1433
		try {
1434
			long entityID = Long.parseLong(this.getId());
310 rajveer 1435
			long categoryID = this.getEntity().getCategoryID();
1436
			List<Long> slideDefIDs = CreationUtils.getSlideSequence(entityID, categoryID);
250 naveen 1437
 
1438
			List<String[]> slideData = new ArrayList<String[]>();
1439
 
1440
			DefinitionsContainer defs = this.getDefinitionsContainer();
1441
			for(Long slideDefID : slideDefIDs) {
1442
				SlideDefinition slideDef = defs.getSlideDefinition(slideDefID);
1443
				String label = slideDef.getLabel();
1444
 
1445
				slideData.add(new String[] {slideDefID.toString(), label});
1446
			}
1447
 
1448
			return slideData;
1449
		} catch (Exception e) {
1450
			log.error(CreationUtils.getStackTrace(e));
1451
 
1452
			return null;
1453
		}
1454
	} 
1455
 
1456
    /**
1457
     * 
1458
     * @param entityID
1459
     * @return
1460
     * @throws Exception 
1461
     */
1462
    private ExpandedEntity getExpandedEntity(long entityID) throws Exception {
1463
    	if(this.expEntity == null) {
1464
    		if(this.entity == null) {
1465
    			this.entity = this.getEntity(entityID);
1466
    		}
1467
 
1468
	    	this.expEntity = new ExpandedEntity(entity);
1469
    	}
1470
 
1471
    	return this.expEntity;
1472
    }
1473
 
1474
    /**
1475
     * 
1476
     * @param entityID
1477
     * @return
1478
     * @throws Exception 
1479
     */
1480
    private Entity getEntity(long entityID) throws Exception {
1481
    	log.info("#### EntityController.getEntity ####");
1482
		if(this.entity == null) {
1483
			this.entity = CreationUtils.getEntity(entityID);
1484
		}
1485
 
1486
		return this.entity;
1487
	}
162 naveen 1488
}