public IHttpActionResult Manipulate(UserFavoritesManipulateDto favorite)
{
UserFavorite favoriteDB;
string id = User.Identity.GetUserId();
var favorites = new List <UserFavorite>();
favorites = userFavoritesRepository.GetSimpleUserFavorites(id);
var flightIDs = new HashSet <int>();
if (favorites != null)
{
favorites.ForEach(f => flightIDs.Add(f.FlightID));
}
if (flightIDs.Count > 0 && flightIDs.Contains(favorite.FlightID))
{
favoriteDB = favorites.SingleOrDefault(f => f.FlightID == favorite.FlightID);
userFavoritesRepository.Remove(favoriteDB);
unitOfWork.Complete();
return(Ok());
}
favoriteDB = UserFavorite.Create(id, favorite.FlightID);
userFavoritesRepository.Add(favoriteDB);
unitOfWork.Complete();
return(Ok());
}
private void PopulateFavoriteTypeFilterCombo(UserFavorite favorite)
{
if (!cmbBxFavoriteTypeFilter.Items.Contains(favorite.MediaType))
{
cmbBxFavoriteTypeFilter.Items.Add(favorite.MediaType);
}
}
public ActionResult RateText(int rating, int textId, int ratingId)
{
ActionResult result = null;
if (User.Identity.IsAuthenticated)
{
UserFavorite userFavorite = new UserFavorite()
{
Rating = rating,
SubtitleTextId = textId,
UserIdentification = User.Identity.GetUserId(),
IdentificationSource = User.Identity.AuthenticationType,
UserFavoriteId = ratingId
};
BusinessLogic logic = new BusinessLogic();
long recordId = logic.AddUpdateUserFavorite(userFavorite);
result = new ContentResult()
{
Content = recordId.ToString()
};
}
return(result);
}
public async Task <List <Result> > GenerateResultPool(string genreQuery, string tagQuery)
{
//utilizes constructed query to pull a pool of games to apply the recommendation scoring to
SearchResult singlePageResults = new SearchResult();
List <Result> recommendationResultPool = new List <Result>();
string activeUserId = GetActiveUser();
genreQuery.Replace("RPG", "role-playing-games-rpg");
for (int i = 1; i < 15; i++)
{
singlePageResults = await _gameDAL.GetGameListByGenreAndTag($"genres={genreQuery}&page={i}");
foreach (var result in singlePageResults.results)
{
UserFavorite checkForDupes = _gameContext.UserFavorite.Where(f => f.UserId == activeUserId && f.GameId == result.id).FirstOrDefault();
if (checkForDupes == null)
{
recommendationResultPool.Add(result);
}
}
}
return(recommendationResultPool);
}
public UserFavorite GetFavorite(OrderDetail od)
{
UserFavorite favorite = _repository.GetAll <UserFavorite>()
.First(x => x.FavoriteId == od.FavoriteId);
return(favorite);
}
public IHttpActionResult Post([FromBody] Project entity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
UserFavorite userFavorites = new UserFavorite();
try
{
//Validation if project belong to the user
var user = this.GetUser();
var projects = ServiceProvider.EntityContext.Projects.Get(user);
if (projects.Count(p => p.ProjectID == entity.ProjectID) < 1)
{
return(BadRequest());
}
userFavorites.ProjectID = entity.ProjectID;
userFavorites.UserID = user.UserID;
ServiceProvider.EntityContext.UserFavorites.Add(userFavorites);
}
catch (DbUpdateException)
{
throw;
}
return(Ok(userFavorites));
}
public IActionResult DeleteFavorite(int id)
{
//deletes specific favorite game from user's list
string activeUserId = GetActiveUser();
var gameToDelete = _gameContext.UserFavorite.Find(id);
UserFavorite deleteItem = _gameContext.UserFavorite.Where(uf => uf.UserId == activeUserId && uf.GameId == id).FirstOrDefault();
if (deleteItem != null)
{
_gameContext.UserFavorite.Remove(deleteItem);
_gameContext.SaveChanges();
}
List <UserFavorite> favorite = _gameContext.UserFavorite.Where(f => f.GameId == id).ToList();
if (favorite.Count > 0)
{
int count = favorite.Max(m => m.FavoriteCount) - 1;
foreach (var fav in favorite)
{
fav.FavoriteCount = count;
_gameContext.Entry(fav).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
_gameContext.Update(fav);
_gameContext.SaveChanges();
}
}
return(RedirectToAction("DisplayFavorites"));
}
public bool ToggleRecipeAsFavorite(int UserId, int RecipeId)
{
Recipe recipe = db.Recipes.Find(RecipeId);
UserFavorite fav = db.UserFavorites.Where(x => x.UserId == UserId && x.RecipeId == RecipeId).FirstOrDefault();
if (fav == null)
{
fav = new UserFavorite
{
CreatedDate = DateTime.Now,
UserId = UserId,
RecipeId = RecipeId
};
db.UserFavorites.Add(fav);
db.SaveChanges();
return(true);
}
else
{
if (fav.DeletedDate != null)
{
fav.DeletedDate = null;
}
else
{
fav.DeletedDate = DateTime.Now;
}
db.Entry(fav).State = EntityState.Modified;
db.SaveChanges();
recipe.CheckIfIsFavorite(1);
return(fav.DeletedDate == null ? true : false);
}
}
public ActionResult SuccessView(string MerchantTradeNo)
{
Order order = _checkoutService.GetOrder(MerchantTradeNo);
OrderDetail od = _checkoutService.GetOrderDetail(order);
UserFavorite userF = _checkoutService.GetFavorite(od);
SuccessViewModel viewModel = new SuccessViewModel
{
FavoriteId = userF.FavoriteId,
IsPackage = userF.IsPackage,
Package = null,
UserDefinedList = null,
RoomTypeList = _checkoutService.GetRoomTypeList(),
SquareFeetList = _checkoutService.GetSquareFeetList(),
DateService = order.DateService,
Address = order.Address,
DiscountAmount = _checkoutService.GetCouponAmount(order.CouponDetailId),
FinalPrice = od.FinalPrice,
};
if (userF.IsPackage)
{
viewModel.Package = _checkoutService.GetPackage(userF);
}
else
{
viewModel.UserDefinedList = _checkoutService.GetUserDefinedList(userF);
}
return(View(viewModel));
}
public async Task <bool> Handle(Command request, CancellationToken cancellationToken)
{
var user = await dataContext.Users.FirstOrDefaultAsync(x => x.Id == currentUser.UserId);
if (user is null)
{
throw new HttpContextException(System.Net.HttpStatusCode.NotFound, new { User = "******" });
}
var advertise = await dataContext.Advertise.FirstOrDefaultAsync(x => x.UniqueId == request.AdvertiseId);
if (advertise is null)
{
throw new HttpContextException(System.Net.HttpStatusCode.NotFound, new { Advertise = "Advertise is not found" });
}
var userAdFav = new UserFavorite
{
Advertise = advertise,
AppUser = user
};
await dataContext.UserFavorites.AddAsync(userAdFav);
return(await dataContext.SaveChangesAsync() > 0);
}
public void CreateUserDefinedDataInFavorite(IEnumerable <UserDefinedAll> model, string name, Guid TempGuid)
{
var result = new OperationResult();
using (var transcation = _context.Database.BeginTransaction())
{
try
{
foreach (var i in model)
{
var product = new UserDefinedProduct
{
UserDefinedProductId = Guid.NewGuid(),
UserDefinedId = TempGuid,
IsDelete = false,
AccountName = name,
ServiceItems = i.ServiceItem,
RoomType = i.RoomType,
Squarefeet = i.Squarefeet,
Name = i.Title,
Hour = countHour(i.RoomType, i.Squarefeet),
Price = Convert.ToDecimal(countHour(i.RoomType, i.Squarefeet)) * 500,
CreateTime = DateTime.UtcNow.AddHours(8),
CreateUser = name,
EditTime = DateTime.UtcNow.AddHours(8),
EditUser = name,
};
_repository.Create <UserDefinedProduct>(product);
}
_context.SaveChanges();
var userfavorite = new UserFavorite
{
FavoriteId = Guid.NewGuid(),
AccountName = name,
UserDefinedId = TempGuid,
PackageProductId = null,
IsPackage = false,
IsDelete = false,
CreateTime = DateTime.UtcNow.AddHours(8),
CreateUser = name,
EditTime = DateTime.UtcNow.AddHours(8),
EditUser = name,
};
_repository.Create <UserFavorite>(userfavorite);
_context.SaveChanges();
result.IsSuccessful = true;
transcation.Commit();
}
catch (Exception ex)
{
result.IsSuccessful = false;
result.Exception = ex;
transcation.Rollback();
}
}
}
public UserFavorite GetFavorite(Guid favoriteId, string accountName)
{
UserFavorite favorite = _repository
.GetAll <UserFavorite>()
.First(f => f.FavoriteId == favoriteId && f.AccountName == accountName);
return(favorite);
}
public void Add(UserFavorite entity)
{
using (var Context = GetContext())
{
Context.UserFavorites.Add(entity);
Context.SaveChanges();
}
}
public void Edit(UserFavorite entity)
{
using (var Context = GetContext())
{
Context.Entry(entity).State = EntityState.Modified;
Context.SaveChanges();
}
}
public int Insert(UserFavorite user_favorite)
{
using (IDbConnection dbConnection = Connection)
{
dbConnection.Open();
return(dbConnection.Query <InsertID>("Team2.AddUserFavorite", user_favorite, commandType: CommandType.StoredProcedure).First().ID);
}
}
public PackageProduct GetPackage(UserFavorite favorite)
{
PackageProduct data = _repository
.GetAll <PackageProduct>()
.First(x => x.PackageProductId == favorite.PackageProductId);
return(data);
}
public void Update(UserFavorite user_favorite)
{
using (IDbConnection dbConnection = Connection)
{
dbConnection.Open();
dbConnection.Execute("Team2.UpdateUserFavorite", user_favorite, commandType: CommandType.StoredProcedure);
}
}
public ActionResult DeleteConfirmed(string id)
{
UserFavorite userFavorite = db.UserFavorites.Find(id);
db.UserFavorites.Remove(userFavorite);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public List <UserDefinedProduct> GetUserDefinedList(UserFavorite favorite)
{
List <UserDefinedProduct> data = _repository
.GetAll <UserDefinedProduct>()
.Where(x => x.UserDefinedId == favorite.UserDefinedId && x.IsDelete == false).ToList();
return(data);
}
public ActionResult Edit([Bind(Include = "UserId,EventId")] UserFavorite userFavorite)
{
if (ModelState.IsValid)
{
db.Entry(userFavorite).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(userFavorite));
}
public async Task <IActionResult> SeeMoreGamesLikeThis(string id)
{
Game game = await _gameDAL.GetGameByName(id);
string genreQuery = "";
string tagQuery = "";
//creates queries from genres and tags from the game id passed to this method
foreach (var genre in game.genres)
{
genreQuery += genre.name.ToLower() + ",";
}
foreach (var tag in game.tags)
{
tagQuery += tag.name.Replace(" ", "-").ToLower() + ",";
}
SearchResult similarGameResults = new SearchResult();
//selects appropriate endpoint based on if genre or tag queries are empty
if (genreQuery == "" && tagQuery != "")
{
similarGameResults = await _gameDAL.GetGameListByGenreAndTag($"tags={tagQuery}");
}
else if (genreQuery != "" && tagQuery == "")
{
similarGameResults = await _gameDAL.GetGameListByGenreAndTag($"genres={genreQuery}");
}
else if (genreQuery == "" && tagQuery == "")
{
ViewBag.NoResults = "No Results Found";
ViewBag.Header = $"More games like {game.name}.";
return(View("SearchResults", similarGameResults));
}
else
{
similarGameResults = await _gameDAL.GetGameListByGenreAndTag($"genres={genreQuery}&tags={tagQuery}");
}
//flags results as favorites as necessary to allow for proper button display in SearchResults view
foreach (var result in similarGameResults.results)
{
string activeUserId = GetActiveUser();
UserFavorite checkForDupes = _gameContext.UserFavorite.Where(f => f.UserId == activeUserId && f.GameId == result.id).FirstOrDefault();
if (checkForDupes != null)
{
result.isfavorite = checkForDupes.IsFavorite;
}
}
ViewBag.Header = $"More games like {game.name}.";
return(View("SearchResults", similarGameResults));
}
public ActionResult SuccessView()
{
string MerchantTradeNo = Request.Form["MerchantTradeNo"] ?? "";
string TradeNo = Request.Form["TradeNo"] ?? "";
string RtnCode = Request.Form["RtnCode"];
//string PaymentType = Request.Form["PaymentType"];
//string SimulatePaid = Request.Form["SimulatePaid"];
//string CheckMacValue = Request.Form["CheckMacValue"];
//string MerchantID = Request.Form["MerchantID"];
//string StoreID = Request.Form["StoreID"];
//string RtnMsg = Request.Form["RtnMsg"];
//string TradeAmt = Request.Form["TradeAmt"];
//string PaymentDate = Request.Form["PaymentDate"];
//string PaymentTypeChargeFee = Request.Form["PaymentTypeChargeFee"];
//string TradeDate = Request.Form["TradeDate"];
foreach (var key in Request.Form.AllKeys)
{
Debug.WriteLine($"success: {key}, {Request.Form[key]}");
}
if (RtnCode != "1")
{
ViewData["Title"] = "付款失敗";
ViewData["Content"] = "付款失敗，請前往會員中心，並重新付款";
return(View("Message"));
}
Order order = _checkoutService.GetOrder(MerchantTradeNo, TradeNo);
OrderDetail od = _checkoutService.GetOrderDetail(order);
UserFavorite userF = _checkoutService.GetFavorite(od);
SuccessViewModel viewModel = new SuccessViewModel {
FavoriteId = userF.FavoriteId,
IsPackage = userF.IsPackage,
Package = null,
UserDefinedList = null,
RoomTypeList = _checkoutService.GetRoomTypeList(),
SquareFeetList = _checkoutService.GetSquareFeetList(),
DateService = order.DateService,
Address = order.Address,
DiscountAmount = _checkoutService.GetCouponAmount(order.CouponDetailId),
FinalPrice = od.FinalPrice,
};
if (userF.IsPackage)
{
viewModel.Package = _checkoutService.GetPackage(userF);
}
else
{
viewModel.UserDefinedList = _checkoutService.GetUserDefinedList(userF);
}
return(View(viewModel));
}
public IResult Add(UserFavorite userFavorite)
{
var result = _userFavoriteDal.Get(x => x.ProductId == userFavorite.ProductId);
if (result != null)
{
return(new ErrorResult());
}
_userFavoriteDal.Add(userFavorite);
return(new SuccessResult());
}
public void FavoriteUpdate_Multiple()
{
string connstr = ConfigurationManager.AppSettings["mongoDBTest"];
var mongo = new Mongo(connstr);
mongo.Connect();
var testDB = mongo.GetDatabase("myTest");
UserFavorite fav = new UserFavorite(testDB, "lynn");
fav.Update("q", 1, "t1,t2,t2");
}
public ActionResult Create([Bind(Include = "UserId,EventId")] UserFavorite userFavorite)
{
if (ModelState.IsValid)
{
db.UserFavorites.Add(userFavorite);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(userFavorite));
}
public ActionResult addToFavourite(int id)//product id
{
UserFavorite f = new UserFavorite();
f.ProductId = id;
f.MemeberId = Convert.ToInt32(Session["userId"]);
f.Date = DateTime.Now;
_UserFavoriteService.Insert(f);
return(RedirectToAction("details", new { id = id }));
}
public bool Insert(UserFavorite userfavorite)
{
if (_context.Set <UserFavorite>().Add(userfavorite) == userfavorite)
{
_context.SaveChanges();
return(true);
}
else
{
return(false);
}
}
public async Task IsOfferFavoritedByUserAsync_WithValidData_ShouldReturnTrue()
{
var expected = 4;
var guid = Guid.NewGuid().ToString();
var guid2 = Guid.NewGuid().ToString();
var guidOffer = Guid.NewGuid().ToString();
var moqHttpContextAccessor = new Mock <IHttpContextAccessor>();
var moqCategoriesService = new Mock <ICategoryService>();
var moqCloudinaryService = new Mock <ICloudinaryService>();
var moqIFormFile = new Mock <IFormFile>();
var context = InitializeContext.CreateContextForInMemory();
this.userService = new UserService(context, moqHttpContextAccessor.Object);
var user1 = new ApplicationUser()
{
Id = guid,
UserName = "******",
ProfilePhotoUrl = "TestUrl.com",
};
var createOfferInputModel = new CreateOfferModel()
{
Name = "Wow Account",
CategotyName = "Wow",
CreatorId = guid,
Description = "Some Test Description",
Price = 10.00,
PicUrl = "link",
};
this.offerService = new OfferService(context, moqCategoriesService.Object, moqCloudinaryService.Object);
var offer = await this.offerService.CreateOfferAsync(createOfferInputModel);
var fav = new UserFavorite()
{
OfferId = offer.Id,
UserId = guid,
};
context.Users.Add(user1);
context.UserFavorites.Add(fav);
await context.SaveChangesAsync();
// Assert
var userGet = await this.userService.IsOfferFavoritedByUserAsync(offer.Id, guid);
Assert.True(userGet);
}
public UserFavoriteViewModel(UserFavorite favorite)
{
UserFavoriteID = favorite.UserFavoriteID;
FlightID = favorite.FlightID;
ApplicationUserID = favorite.ApplicationUserID;
Date = favorite.Flight.Date;
BasePrice = favorite.Flight.BasePrice;
Destination = favorite.Flight.FlightPath.Destination;
Departure = favorite.Flight.FlightPath.Departure;
Starship = favorite.Flight.Starship;
IsVIP = favorite.Flight.IsVIP;
}
public IActionResult ClearUserRating(int id)
{
string activeUserId = GetActiveUser();
UserFavorite favorite = _gameContext.UserFavorite.Where(f => f.UserId == activeUserId && f.GameId == id).FirstOrDefault();
favorite.UserRating = -1;
_gameContext.Entry(favorite).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
_gameContext.Update(favorite);
_gameContext.SaveChanges();
return(RedirectToAction("DisplayFavorites"));
}
private static void HandleLoadingVideoFavorite(UserFavorite favorite, PictureBox pictureBox)
{
if (favorite.MediaType == MediaFilterType.Video)
{
pictureBox.ImageLocation = null;
pictureBox.Image = pictureBox.InitialImage;
}
else
{
pictureBox.Image = null;
pictureBox.ImageLocation = favorite.FullPath;
}
}
public void FavoriteAdd()
{
string connstr = ConfigurationManager.AppSettings["mongoDBTest"];
var mongo = new Mongo(connstr);
mongo.Connect();
var testDB = mongo.GetDatabase("myTest");
UserFavorite fav = new UserFavorite(testDB, "testUserName" + DateTime.Now.ToShortTimeString());
fav.Update("question", 101, "tag1,tag2");
fav.Update("question", 102, "tag3,tag4");
fav.Update("question", 104, "tag3,tag4,tag5");
fav.Update("question", 103, "tag1,tag2");
fav.Update("k", 101, "tag1,tag2");
fav.Update("k", 102, "tag2,tag7");
fav.Update("k", 103, "tag1,tag5");
fav.Update("k", 104, "tag1,tag5");
fav.Update("k", 105, "tag1,tag5");
fav.Update("k", 106, "tag1,tag5");
Assert.IsTrue(Compare(fav.GetTags("k"), "tag1,tag2,tag7,tag5"));
Assert.IsTrue(Compare(fav.GetTags("question"), "tag1,tag2,tag3,tag4,tag5"));
Assert.AreEqual("tag1,tag5", fav.GetTags("k", 103));
Assert.AreEqual("tag1,tag2", fav.GetTags("question", 103));
Assert.IsTrue(fav.GetIDs("question", "tag1").Contains(101));
Assert.IsTrue(fav.GetIDs("question", "tag1").Contains(103));
Assert.AreEqual(5, fav.GetIDs("k", "tag1").Count);
Assert.AreEqual(6, fav.GetIDs("k").Count);
Assert.AreEqual(0, fav.GetIDs("foofoo").Count);
Assert.AreEqual(4, fav.GetIDs("question").Count);
Assert.IsTrue(fav.HasFavorite("question", 103));
Assert.IsFalse(fav.HasFavorite("k", 203));
fav.Remove("question", 103);
Assert.IsFalse(fav.HasFavorite("question", 103));
mongo.Disconnect();
}
