Subversion Repositories SmartDukaan

Rev

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

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