public ActionResult AddCymbalToCart(List <CymbalPO> cymbalList)
{
if (Session["AccountID"] != null)
{
ProductModel cart = new ProductModel();
ProductModel productModel = new ProductModel();
if (Session["ShoppingCart"] == null)
{
Session["ShoppingCart"] = cart;
}
cart = (ProductModel)Session["ShoppingCart"];
foreach (CymbalPO cymbal in cymbalList)
{
CymbalPO cymbalPO = new CymbalPO();
cymbalPO = MappingMethods.MapCymbalDOtoPO(dataMethods.GetCymbalInfoByID(cymbal.CymbalID));
cymbalPO.CheckoutQty = cymbal.CheckoutQty;
if (cymbal.CheckoutQty > 0 && cymbal.CheckoutQty <= cymbal.CymbalQuantity)
{
cart.cymbalList.Add(cymbalPO);
}
else
{
}
}
Session["ShoppingCart"] = cart;
}
else
{
return(RedirectToAction("Login", "Home"));
}
return(RedirectToAction("BrowseCymbals", "Store"));
}
public ActionResult Login(AccountModel accountModel)
{
if (accountModel.aAccount.UserName != null)
{
accountModel.aAccount.PassWord = bllMethods.PassWordHash(accountModel.aAccount.PassWord);
AccountDO accountDO = dataMethods.GetAccountInfoByUserName(accountModel.aAccount.UserName);
if (ModelState.IsValid)
{
if (accountModel.aAccount.PassWord == accountDO.PassWord)
{
accountModel.aAccount = MappingMethods.MapAccountDOtoPO(accountDO);
Session["RoleID"] = accountModel.aAccount.RoleID;
Session["AccountID"] = accountModel.aAccount.AccountID;
Session["FirstName"] = accountModel.aAccount.FirstName;
Session["LastName"] = accountModel.aAccount.LastName;
Session["Email"] = accountModel.aAccount.Email;
return(View("Index"));
}
else
{
ModelState.AddModelError("", "Username or Password is invalid.");
}
}
}
return(View());
}
public ActionResult UpdateAccount(int AccountID)
{
AccountModel viewModel = new AccountModel();
viewModel.aAccount = MappingMethods.MapAccountDOtoPO(dataMethods.GetAccountInfoByID(AccountID));
viewModel.aAccount.AccountID = AccountID;
return(View(viewModel));
}
public ActionResult UpdateDrumProduct(int DrumID)
{
ProductModel drumModel = new ProductModel();
drumModel.aDrum = MappingMethods.MapDrumDOtoPO(dataMethods.GetDrumInfoByID(DrumID));
drumModel.aDrum.DrumID = DrumID;
return(View(drumModel));
}
public ActionResult UpdateCymbalProduct(int cymbalID)
{
ProductModel cymbalModel = new ProductModel();
cymbalModel.aCymbal = MappingMethods.MapCymbalDOtoPO(dataMethods.GetCymbalInfoByID(cymbalID));
cymbalModel.aCymbal.CymbalID = cymbalID;
return(View(cymbalModel));
}
public ActionResult AddCymbalProduct(ProductModel cymbalModel)
{
cymbalModel.aCymbal.AccountID = (int)Session["AccountID"];
CymbalDO cymbalDO = MappingMethods.MapCymbalPOtoDO(cymbalModel.aCymbal);
dataMethods.CreateCymbal(cymbalDO);
return(RedirectToAction("ViewProducts", "StoreManager"));
}
private Expression CreateItemEqualityExpression(MemberExpression fromItem, MemberExpression toItem)
{
Expression itemsAreMapEqual;
if (this.aItemMapping.ResolvedMapping is IMappingWithSpecialComparision)
{
itemsAreMapEqual = Expression.Call(
Expression.Constant(this.aItemMapping.ResolvedMapping),
MappingMethods.MapEqual(EnumerableReflection <TFrom> .ItemType, EnumerableReflection <TTo> .ItemType),
fromItem,
toItem
);
}
else
{
Expression fromMapped = fromItem;
if (!(this.aItemMapping.ResolvedMapping is IDirectMapping))
{
fromMapped = Expression.Call(
Expression.Constant(this.aItemMapping.ResolvedMapping),
MappingMethods.Map(EnumerableReflection <TFrom> .ItemType, EnumerableReflection <TTo> .ItemType),
fromMapped
);
}
itemsAreMapEqual = Expression.Call(
Expression.Constant(EqualityComparerMethods.GetEqualityComparer(EnumerableReflection <TTo> .ItemType)),
EqualityComparerMethods.Equals(EnumerableReflection <TTo> .ItemType),
fromMapped,
toItem
);
}
if (this.aEqualityRules != null)
{
var(selectIdFrom, selectIdTo) = this.aEqualityRules.GetIdSelectors();
itemsAreMapEqual = Expression.AndAlso(
Expression.Equal(
ExpressionHelper.Call(
selectIdFrom,
fromItem
),
ExpressionHelper.Call(
selectIdTo,
toItem
)
),
itemsAreMapEqual
);
}
return(itemsAreMapEqual);
}
public ActionResult UpdateDrumProduct(ProductModel drumModel)
{
if (ModelState.IsValid)
{
dataMethods.UpdateDrum(MappingMethods.MapDrumPOtoDO(drumModel.aDrum));
return(RedirectToAction("ViewProducts", "StoreManager"));
}
else
{
return(View());
}
}
private SwitchCase MakeIfConvertSynchronizeStatement(Type fromType, Type toType, IMapping mapping, ParameterExpression from, ParameterExpression to)
{
return(Expression.SwitchCase(
Expression.Call(
Expression.Constant(mapping),
MappingMethods.Synchronize(fromType, toType),
Expression.Convert(from, fromType),
Expression.Convert(to, toType)
),
Expression.Constant(fromType)
));
}
public ActionResult RemoveDrumFromCart(int drumID)
{
if (Session["ShoppingCart"] != null)
{
ProductModel cart = new ProductModel();
ProductModel productModel = new ProductModel();
productModel.aDrum = MappingMethods.MapDrumDOtoPO(dataMethods.GetDrumInfoByID(drumID));
cart = (ProductModel)Session["ShoppingCart"];
cart.drumList.RemoveAll(x => x.DrumID == productModel.aDrum.DrumID);
Session["ShoppingCart"] = cart;
}
return(RedirectToAction("ViewCart", "Store"));
}
public ActionResult RemoveCymbalFromCart(int cymbalID)
{
if (Session["ShoppingCart"] != null)
{
ProductModel cart = new ProductModel();
ProductModel productModel = new ProductModel();
productModel.aCymbal = MappingMethods.MapCymbalDOtoPO(dataMethods.GetCymbalInfoByID(cymbalID));
cart = (ProductModel)Session["ShoppingCart"];
cart.cymbalList.RemoveAll(x => x.CymbalID == productModel.aCymbal.CymbalID);
Session["ShoppingCart"] = cart;
}
return(RedirectToAction("ViewCart", "Store"));
}
public ActionResult ViewAccounts()
{
AccountModel viewModel = new AccountModel();
List <AccountDO> accountDOList = dataMethods.ViewAllAccounts();
foreach (AccountDO accountDO in accountDOList)
{
AccountPO accountPO = new AccountPO();
accountPO = MappingMethods.MapAccountDOtoPO(accountDO);
viewModel.accountList.Add(accountPO);
}
return(View(viewModel));
}
public ActionResult BrowseCymbals()
{
ProductModel productModel = new ProductModel();
List <CymbalDO> cymbalDOList = dataMethods.ViewAllCymbals();
foreach (CymbalDO cymbalDO in cymbalDOList)
{
CymbalPO cymbalPO = new CymbalPO();
cymbalPO = MappingMethods.MapCymbalDOtoPO(cymbalDO);
productModel.cymbalList.Add(cymbalPO);
}
return(View(productModel.cymbalList));
}
public ActionResult BrowseDrums()
{
ProductModel productModel = new ProductModel();
List <DrumDO> drumDOList = dataMethods.ViewAllDrums();
foreach (DrumDO drumDO in drumDOList)
{
DrumPO drumPO = new DrumPO();
drumPO = MappingMethods.MapDrumDOtoPO(drumDO);
productModel.drumList.Add(drumPO);
}
return(View(productModel.drumList));
}
public ActionResult RegisterAccount(AccountModel viewModel)
{
if (ModelState.IsValid)
{
viewModel.aAccount.PassWord = bllMethods.PassWordHash(viewModel.aAccount.PassWord);
AccountDO accountDO = MappingMethods.MapAccountPOtoDO(viewModel.aAccount);
dataMethods.CreateAccount(accountDO);
return(RedirectToAction("Login", "Home"));
}
else
{
return(View());
}
}
public ActionResult AddDrumProduct(ProductModel drumModel)
{
if (ModelState.IsValid)
{
drumModel.aDrum.AccountID = (int)Session["AccountID"];
DrumDO drumDO = MappingMethods.MapDrumPOtoDO(drumModel.aDrum);
dataMethods.CreateDrum(drumDO);
return(RedirectToAction("ViewProducts", "StoreManager"));
}
else
{
return(View());
}
}
public ActionResult ViewCart()
{
ProductModel productModel = new ProductModel();
if (Session["ShoppingCart"] != null)
{
productModel = (ProductModel)Session["ShoppingCart"];
BusinessModel businessModel = MappingMethods.MapProductModeltoBusinessModel(productModel);
productModel = MappingMethods.MapBusinessModeltoProductModel(businessModel);
productModel.CartTotal = bllMethods.CalculateTotalPrice(businessModel);
}
else if (Session["AccountID"] == null)
{
return(RedirectToAction("Login", "Home"));
}
return(View(productModel));
}
private Expression CreateItemMappingExpression(ParameterExpression from)
{
if (this.aItemMapping.ResolvedMapping is IDirectMapping)
{
return(from);
}
var mapMethod = Delegate.CreateDelegate(
typeof(Func <,>).MakeGenericType(EnumerableReflection <TFrom> .ItemType, EnumerableReflection <TTo> .ItemType),
this.aItemMapping.ResolvedMapping,
MappingMethods.Map(EnumerableReflection <TFrom> .ItemType, EnumerableReflection <TTo> .ItemType)
);
return(Expression.Call(null, LinqMethods.Select(EnumerableReflection <TFrom> .ItemType, EnumerableReflection <TTo> .ItemType),
from,
Expression.Constant(mapMethod)
));
}
public Expression CreateComparisionExpression(ParameterExpression from, ParameterExpression to, LabelTarget end)
{
if (this.Mapping.ResolvedMapping is IMappingWithSpecialComparision)
{
return(Expression.IfThen(
Expression.Not(
Expression.Call(
Expression.Constant(this.Mapping.ResolvedMapping),
MappingMethods.MapEqual(this.From.Type, this.To.Type),
this.From.CreateGetterExpression(from),
this.To.CreateGetterExpression(to)
)
),
Expression.Return(end, Expression.Constant(false))
));
}
else
{
var fromMapped = this.From.CreateGetterExpression(from);
if (!(this.Mapping.ResolvedMapping is IDirectMapping))
{
fromMapped = Expression.Call(
Expression.Constant(this.Mapping.ResolvedMapping),
MappingMethods.Map(this.From.Type, this.To.Type),
fromMapped
);
}
return(Expression.IfThen(
Expression.Not(
Expression.Call(
Expression.Constant(EqualityComparerMethods.GetEqualityComparer(this.To.Type)),
EqualityComparerMethods.Equals(this.To.Type),
fromMapped,
this.To.CreateGetterExpression(to)
)
),
Expression.Return(end, Expression.Constant(false))
));
}
}
public Expression CreateMappingAssignmentExpression(ParameterExpression from, ParameterExpression to, Delegate postprocess, ParameterExpression parent)
{
Expression ret = this.From.CreateGetterExpression(from);
if (!(this.Mapping.ResolvedMapping is IDirectMapping))
{
ret = Expression.Call(
Expression.Constant(this.Mapping.ResolvedMapping),
MappingMethods.Map(this.From.Type, this.To.Type),
ret
);
}
ret = this.To.CreateSetterExpression(
to,
ret
);
return(this.AddPostprocess(ret, to, postprocess, parent));
}
public ActionResult AddDrumToCart(List <DrumPO> drumList)
{
if (Session["AccountID"] != null)
{
ProductModel cart = new ProductModel();
ProductModel productModel = new ProductModel();
if (Session["ShoppingCart"] == null)
{
Session["ShoppingCart"] = cart;
}
cart = (ProductModel)Session["ShoppingCart"];
foreach (DrumPO drum in drumList)
{
DrumPO drumPO = new DrumPO();
drumPO = MappingMethods.MapDrumDOtoPO(dataMethods.GetDrumInfoByID(drum.DrumID));
drumPO.CheckoutQty = drum.CheckoutQty;
if (drum.CheckoutQty > 0 && drum.CheckoutQty <= drum.DrumQuantity)
{
cart.drumList.Add(drumPO);
}
else
{
}
}
//productModel.aDrum = MappingMethods.MapDrumDOtoPO(dataMethods.GetDrumInfoByID(drumID));
//productModel.aDrum.DrumID = drumID;
Session["ShoppingCart"] = cart;
}
else
{
return(RedirectToAction("Login", "Home"));
}
return(RedirectToAction("BrowseDrums", "Store"));
}
public ActionResult PlaceOrder()
{
ProductModel cart = new ProductModel();
cart = (ProductModel)Session["ShoppingCart"];
foreach (DrumPO drum in cart.drumList)
{
DrumDO drumDO = new DrumDO();
drumDO = MappingMethods.MapDrumPOtoDO(drum);
dataMethods.UpdateDrumQuantity(drum.DrumID, drum.CheckoutQty);
DrumPO drumPO = MappingMethods.MapDrumDOtoPO(drumDO);
}
foreach (CymbalPO cymbal in cart.cymbalList)
{
CymbalDO cymbalDO = new CymbalDO();
cymbalDO = MappingMethods.MapCymbalPOtoDO(cymbal);
dataMethods.UpdateCymbalQty(cymbal.CymbalID, cymbal.CheckoutQty);
CymbalPO cymbalPO = MappingMethods.MapCymbalDOtoPO(cymbalDO);
}
cart.cymbalList.Clear();
cart.drumList.Clear();
return(View());
}
public ActionResult ViewProducts()
{
ProductModel productModel = new ProductModel();
List <DrumDO> drumDOList = dataMethods.ViewAllDrums();
foreach (DrumDO drumDO in drumDOList)
{
DrumPO drumPO = new DrumPO();
drumPO = MappingMethods.MapDrumDOtoPO(drumDO);
productModel.drumList.Add(drumPO);
}
List <CymbalDO> cymbalDOList = dataMethods.ViewAllCymbals();
foreach (CymbalDO cymbalDO in cymbalDOList)
{
CymbalPO cymbalPO = new CymbalPO();
cymbalPO = MappingMethods.MapCymbalDOtoPO(cymbalDO);
productModel.cymbalList.Add(cymbalPO);
}
return(View(productModel));
}
public ActionResult UpdateCymbalProduct(ProductModel cymbalModel)
{
dataMethods.UpdateCymbal(MappingMethods.MapCymbalPOtoDO(cymbalModel.aCymbal));
return(RedirectToAction("ViewProducts", "StoreManager"));
}
public ActionResult UpdateAccount(AccountModel viewModel)
{
viewModel.aAccount.PassWord = bllMethods.PassWordHash(viewModel.aAccount.PassWord);
dataMethods.UpdateAccountAdmin(MappingMethods.MapAccountPOtoDO(viewModel.aAccount));
return(RedirectToAction("ViewAccounts", "Admin"));
}
public Expression CreateSynchronizationAssignmentExpression(ParameterExpression from, ParameterExpression to, Delegate postprocess, ParameterExpression parent)
{
IMappingWithSyncSupport mappingWithSync = this.Mapping.ResolvedMapping as IMappingWithSyncSupport;
if (mappingWithSync == null)
{
return(this.CreateMappingAssignmentExpression(from, to, postprocess, parent));
}
ParameterExpression tempFromValue = Expression.Parameter(this.From.Type, "tempFrom");
ParameterExpression tempToValue = Expression.Parameter(this.To.Type, "tempTo");
if (!this.To.Readable)
{
// TODO: ???
throw new InvalidMappingException($"Cannot synchronize object with setter method mapping destination without any getter method defined for {this.To} member of {this.To.DeclaringType} type");
}
Expression synchronize = Expression.Call(
Expression.Constant(mappingWithSync),
MappingMethods.Synchronize(this.From.Type, this.To.Type),
tempFromValue, tempToValue
);
if (mappingWithSync.SynchronizeCanChangeObject)
{
if (!this.To.Writable)
{
throw new InvalidMappingException($"Cannot synchronize non writtable member {this.To} using mapping {mappingWithSync.GetType().Name}");
}
if (postprocess != null)
{
var origToValue = Expression.Parameter(this.To.Type, "origTo");
var newToValue = Expression.Parameter(this.To.Type, "newTo");
synchronize = Expression.Block(
new[] { origToValue, newToValue },
Expression.Assign(origToValue, tempToValue),
Expression.Assign(newToValue, synchronize),
Expression.IfThen(
ExpressionHelper.NotSame(origToValue, newToValue),
ExpressionHelper.Call(postprocess, parent, newToValue)
),
this.To.CreateSetterExpression(
to,
newToValue
)
);
}
else
{
synchronize = this.To.CreateSetterExpression(
to,
synchronize
);
}
}
return(Expression.Block(
new ParameterExpression[] { tempFromValue, tempToValue },
Expression.Assign(tempFromValue, this.From.CreateGetterExpression(from)),
Expression.Assign(tempToValue, this.To.CreateGetterExpression(to)),
synchronize
));
}
