Subversion Repositories SmartDukaan

Rev

Details | Last modification | View Log | RSS feed

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