Purposive without Foresight

/**
 * Created on 28 May 2007, 00:01:23 Copyright Ning Zhao. All rights
 * reserved.
 */
package org.ningning.eatsmart.entity;
 
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
 
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.OrderBy;
import javax.persistence.Table;
 
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.LazyCollection;
import org.hibernate.annotations.LazyCollectionOption;
import org.jboss.seam.annotations.Logger;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.Scope;
import org.jboss.seam.log.Log;
 
import static org.jboss.seam.ScopeType.*;
 
/**
 * @author ningning
 * @version $Id: Recipe.java 141 2007-07-20 18:14:06Z ningning $
 */
@Entity
@Name("recipe")
@Scope(SESSION)
@Table(name = "recipes")
public class Recipe implements Serializable {
 
  private static final long serialVersionUID = -1482691873171646032L;
 
  public static final Character CREATING = 'a';
  public static final Character CREATED = 'b';
  public static final Character UPDATING = 'c';
  public static final Character UPDATED = 'd';
 
  private Integer id;
 
  private String name;
 
  private String descEn;
 
  private Short cookTime; // in minute
 
  private Short prepTime; // in minute
 
  private Double heatPower; // in watt
 
  private BigDecimal ingredientTotalWeight; // in gram
 
  private Character status;
 
  /**
   * Bags have the most efficient performance characteristics of all the
   * collections we can use for a bidirectional one-to-many entity
   * assionciation. Because a bag does not have to maintain the index of
   * its elements (like a list) or check for duplicate elements (like a
   * set), new elements can be added to the bag without trigering the
   * loading. This is an important feature if the collection of entity
   * references is large. To map a bidirectional one-to-many association
   * as a bag, we must use the Collection interface and the ArrayList
   * implementation.
   */
  private Collection<Ingredient> ingredients = new ArrayList<Ingredient>();
 
  private Collection<RecipeNutrient> nutrients = new ArrayList<RecipeNutrient>();
 
  private List<CookStep> cookSteps = new ArrayList<CookStep>();
 
  private Collection<RecipeNote> notes = new ArrayList<RecipeNote>();
 
  private Collection<RecipeXTag> tags = new ArrayList<RecipeXTag>();
 
  private Collection<UserOpinion4Recipe> userOpinions = new ArrayList<UserOpinion4Recipe>();
 
  @Logger
  private Log log;
  public Recipe() {}
 
  @OneToMany(mappedBy = "recipe", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
  @Cascade(value = org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
  @OrderBy("seq")
  public List<CookStep> getCookSteps() {
    return cookSteps;
  }
 
  public void setCookSteps(List<CookStep> cookSteps) {
    this.cookSteps = cookSteps;
  }
 
  public void addACookStep(CookStep cookStep) {
    cookStep.setRecipe(this);
    this.cookSteps.add(cookStep);
  }
 
  /**
   * @return the cooking time in minutes
   */
  @Column(name = "cook_time", nullable = true)
  public Short getCookTime() {
    return cookTime;
  }
 
  public void setCookTime(Short cookTime) {
    this.cookTime = cookTime;
  }
 
  /**
   * @return The detailed English description of the recipe.
   */
  @Column(name = "desc_en", nullable = true, length = 2047)
  public String getDescEn() {
    return descEn;
  }
 
  /**
   * @param descEn Should not be longer than 2047 bytes.
   */
  public void setDescEn(String desc) {
    this.descEn = desc;
  }
 
  /**
   * @return the heatPower
   */
  @Column(name = "heat_power", nullable = true)
  public Double getHeatPower() {
    return heatPower;
  }
 
  /**
   * @param heatPower the heatPower to set
   */
  public void setHeatPower(Double heatPower) {
    this.heatPower = heatPower;
  }
 
  /**
   * @return
   */
  @Id
  @Column(name = "id")
  @GeneratedValue(strategy = GenerationType.AUTO)
  public Integer getId() {
    return id;
  }
 
  /**
   * should not be called. The id of recipe is automatically generated
   * by the underlying DB.
   * 
   * @param id
   */
  public void setId(Integer id) {
    this.id = id;
  }
 
  /**
   * @return the set of ingredients of the recipe
   */
  @OneToMany(mappedBy = "recipe", cascade = CascadeType.ALL)
  @Cascade(value = org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
  public Collection<Ingredient> getIngredients() {
    return ingredients;
  }
 
  public void setIngredients(Collection<Ingredient> ingredients) {
    this.ingredients = ingredients;
  }
 
  /**
   * @return the ingredientTotalWeight
   */
  @Column(name = "ingredient_total_weight", scale = 2, precision = 7, nullable = false)
  public BigDecimal getIngredientTotalWeight() {
    return ingredientTotalWeight;
  }
 
  /**
   * @param ingredientTotalWeight
   *          the ingredientTotalWeight to set
   */
  public void setIngredientTotalWeight(BigDecimal newWeight) {
    this.ingredientTotalWeight = newWeight;
  }
 
  /**
   * @return
   */
  @Column(name = "name_en", length = 255, nullable = false)
  public String getName() {
    return name;
  }
 
  public void setName(String name) {
    this.name = name;
  }
 
  @OneToMany(mappedBy = "recipe", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
  @Cascade(value = org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
  public Collection<RecipeNote> getNotes() {
    return notes;
  }
 
  public void setNotes(Collection<RecipeNote> notes) {
    this.notes = notes;
  }
 
  public void addANote(RecipeNote recipeNote) {
    recipeNote.setRecipe(this);
    this.getNotes().add(recipeNote);
  }
 
  /**
   * @return the nutrientNormalizeFactor
   */
  public Double normalizedNutrientFactor() {
    return (this.ingredientTotalWeight.doubleValue() / 100);
  }
 
  @OneToMany(mappedBy = "recipe", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
  @Cascade(value = org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
  public Collection<RecipeNutrient> getNutrients() {
    return nutrients;
  }
 
  public void setNutrients(Collection<RecipeNutrient> nutrients) {
    this.nutrients = nutrients;
  }
 
  /**
   * @return time for preparation for the recipe in minutes
   */
  @Column(name = "prep_time", nullable = true)
  public Short getPrepTime() {
    return prepTime;
  }
 
  public void setPrepTime(Short prepTime) {
    this.prepTime = prepTime;
  }
 
  /**
   * @return the status of this recipe
   */
  @Column(name = "status", nullable = false)
  public Character getStatus() {
    return status;
  }
 
  /**
   * @param status
   *          the status to set
   */
  public void setStatus(Character status) {
    this.status = status;
  }
 
  @OneToMany(mappedBy = "recipe", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
  @Cascade(value = org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
  public Collection<RecipeXTag> getTags() {
    return tags;
  }
 
  public void setTags(Collection<RecipeXTag> tags) {
    this.tags = tags;
  }
 
  /**
   * @return users' opinions for this recipe.
   */
  @OneToMany(mappedBy = "recipe", cascade = CascadeType.ALL)
  @Cascade(value = org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
  public Collection<UserOpinion4Recipe> getUserOpinions() {
    return userOpinions;
  }
 
  public void setUserOpinions(
      Collection<UserOpinion4Recipe> userOpinions) {
    this.userOpinions = userOpinions;
  }
 
  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result
        + ((descEn == null) ? 0 : descEn.hashCode());
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
  }
 
  @Override
  public boolean equals(Object obj) {
    if (this == obj) return true;
    if (obj == null) return false;
    if (!(obj instanceof Recipe)) return false;
    final Recipe other = (Recipe) obj;
    if (descEn == null) {
      if (other.getDescEn() != null) return false;
    } else if (!descEn.equals(other.getDescEn())) return false;
    if (name == null) {
      if (other.getName() != null) return false;
    } else if (!name.equals(other.getName())) return false;
    return true;
  }
 
  // ----------------------business logic methods-----------------------
  public Double doPrice(Double wantedWeight) {
    double price = 0.0d;
    for (Ingredient ingre : this.ingredients) {
      double weightPercent = ingre.toGramWeight()
          / this.getIngredientTotalWeight().doubleValue();
      double actualAmount = wantedWeight * weightPercent;
      double delta = ingre.getFood().getPricePer100g()
          * (actualAmount / 100);
      price = price + delta;
    }
    return price;
  }
 
  public Double doTotalTime(Double wantedWeight, Double heatPower) {
    double time = this.prepTime + this.cookTime;
    double weightScale = wantedWeight / this.ingredientTotalWeight.doubleValue();
    double heatScale = heatPower / this.heatPower;
    time = time * weightScale / heatScale;    
    return time;
  }  
}