public ActionResult Recommended()
{
var model = new RecommendationViewModel();
model = getData(model);
return(View(model));
}
public RecommendationDTO AddNewRecommendation(int userId, RecommendationViewModel newRecommendation)
{
var user = (from u in _db.Users
where u.Id == userId
select u).SingleOrDefault();
var book = (from b in _db.Books
where b.Id == newRecommendation.BookId
select b).SingleOrDefault();
if (user == null || book == null)
{
return(null);
}
var newRec = new Recommendation
{
UserId = userId,
BookId = newRecommendation.BookId
};
_db.Recommendations.Add(newRec);
_db.SaveChanges();
return(new RecommendationDTO
{
Id = newRec.Id,
Title = book.Title,
Author = book.Author
});
}
public void LoadRecommendations()
{
var context = TaskScheduler.FromCurrentSynchronizationContext();
IsBusy = true;
Recommendations.Clear();
Task.Factory.StartNew(() =>
{
var users = dataLoader.LoadFollowings(settings.Username);
var token = Task.Factory.CancellationToken;
foreach (
var recommendation in
readLaterManager.GetReadLaterRecommendations().Select(
recommendationId =>
dataLoader.GetRecommendationById(recommendationId)))
{
var current = recommendation;
Task.Factory.StartNew(() => Recommendations.Add(
RecommendationViewModel.FromModel(
current,
users.Followings.Single(
c => c.Id == current.UserId),
settings.Font)), token,
TaskCreationOptions.None, context);
}
}).ContinueWith(_ => IsBusy = false, context);
}
public async Task <ActionResult> VoteOnNomination(VoteViewModel voteViewModel)
{
if (voteViewModel.Vote.Id != 0)
{
VoteAPI.Update(voteViewModel.Vote);
}
else if (voteViewModel.Vote.Id == 0)
{
VoteAPI.Create(voteViewModel.Vote);
}
;
Nomination nomination = await NominationAPI.GetById(voteViewModel.Vote.NominationId);
YearCategoryModel returnParameters = new YearCategoryModel(nomination.Year, nomination.AwardCategory);
Nomination nominationVotedFor = await NominationAPI.GetById(voteViewModel.Vote.NominationId);
RecommendationViewModel recommendationViewModel = new RecommendationViewModel()
{
Year = nominationVotedFor.Year,
Category = nominationVotedFor.AwardCategory
};
recommendationViewModel.Movie = await MovieAPI.GetById(nominationVotedFor.MovieId);
recommendationViewModel.MovieId = recommendationViewModel.Movie.Id;
return(RedirectToAction(nameof(MovieRecommendation), recommendationViewModel));
}
public ActionResult Index(RecommendationViewModel model)
{
Populate(model);
if (!model.GenreQuery.Any() && !model.MoodQuery.Any() && !model.StyleQuery.Any() && !model.StartYearQuery.HasValue && !model.EndYearQuery.HasValue)
{
ModelState.AddModelError("Query", "Please select something!");
}
if (!ModelState.IsValid)
{
return(View(model));
}
var args = new RecommendationQueryArgs
{
Genre = model.GenreQuery,
Mood = model.MoodQuery,
Style = model.StyleQuery,
StartYear = model.StartYearQuery,
EndYear = model.EndYearQuery
};
model.Artists = _service.GetArtists(args);
model.Songs = _service.GetSongs(args);
model.IsSearch = true;
return(View(model));
}
public IActionResult Recommendation(RecommendationViewModel vm)
{
recommendationLogic.CreateRecommendation(vm.CreateRecommendation);
return(RedirectToAction("Recommendation", "Recommendation", new { serieid = vm.CreateRecommendation.Serie1.Id }));
}
public ActionResult Index()
{
var model = new RecommendationViewModel();
Populate(model);
return(View(model));
}
public void MarkForLaterReading(RecommendationViewModel context)
{
if (context == null)
{
return;
}
ServiceLocator.Current.GetInstance <IReadLaterManager>().MarkForLaterReading(context.Id);
}
public async Task <JsonCamelCaseResult> SaveRecommendation(RecommendationViewModel recommendation)
{
// Save Recommendation.
var update = await Factory.SaveAsync(Mapper.Map <ITroubleCodeRecommendationDto>(recommendation));
// Return.
return(new JsonCamelCaseResult(update));
}
public IActionResult Recommendation(int serieid)
{
RecommendationViewModel vm = new RecommendationViewModel();
vm.GetRecommendations = recommendationLogic.GetRecommendatinsBySerieId(serieid);
vm.GetSerieNames = serieLogic.Series();
vm.Serieid = serieid;
return(View(vm));
}
private RecommendationViewModel getData(RecommendationViewModel model)
{
model.allTopics = TopM.getAllTopics();
string currentUserId = User.Identity.GetUserId();
model.TeamMembers = UserManager.Users.Where(x => x.teamLead.Id == currentUserId).ToList();
model.myRecommendedTopics = TopM.getRecommendedTopics(currentUserId);
return(model);
}
public void MarkAsRead(RecommendationViewModel context)
{
if (context == null)
{
return;
}
readLaterManager.DeleteReadLaterEntry(context.Id);
Recommendations.Remove(context);
}
public async Task <IActionResult> IndexAsync()
{
RecommendationViewModel recommendationViewModel = new RecommendationViewModel();
recommendationViewModel.RecommendedComputer = null;
ViewData["CategoryId"] = new SelectList(await _context.Category.ToListAsync(), "Id", "Name");
return(View(recommendationViewModel));
}
public async Task <IActionResult> Index(RecommendationViewModel recommendationViewModel)
{
if (ModelState.IsValid)
{
Computer requestedComputer = recommendationViewModel.RequestedComputer;
int requestedCores = recommendationViewModel.CoresNotImportant ? 0 : requestedComputer.Cores;
double requestedCpuClockSpeed = recommendationViewModel.ClockSpeedNotImportant ? 0 : requestedComputer.ClockSpeed;
int requestedRAM = recommendationViewModel.RAMNotImportant ? 0 : requestedComputer.RAM;
int requestedStorage = recommendationViewModel.StorageNotImportant ? 0 : requestedComputer.Storage;
double requestedPrice = recommendationViewModel.PriceNotImportant ? 0 : requestedComputer.Price;
double coresPriority = recommendationViewModel.CoresNotImportant ? 0 : recommendationViewModel.CorePriority;
double clockSpeedPriority = recommendationViewModel.ClockSpeedNotImportant ? 0 : recommendationViewModel.ClockSpeedPriority;
double ramPriority = recommendationViewModel.RAMNotImportant ? 0 : recommendationViewModel.RAMPriority;
double storagePriority = recommendationViewModel.StorageNotImportant ? 0 : recommendationViewModel.StoragePriority;
double pricePriority = recommendationViewModel.PriceNotImportant ? 0 : recommendationViewModel.PricePriority;
IList <Computer> computers = await _context.Computer
.Where(c => c.CategoryId == requestedComputer.CategoryId)
.ToListAsync();
RecommendationStats recommendationStats = _context.RecommendationStats.FirstOrDefault();
recommendationStats.RecommendedCount += 1;
_context.RecommendationStats.Update(recommendationStats);
_context.Entry(recommendationStats).Property("BoughtCount").IsModified = false;
await _context.SaveChangesAsync();
IDictionary <double, Computer> offers = new Dictionary <double, Computer>();
foreach (Computer computer in computers)
{
double distance = Math.Sqrt(coresPriority * Math.Pow(requestedCores - computer.Cores, 2)
+ clockSpeedPriority * Math.Pow(requestedCpuClockSpeed - computer.ClockSpeed, 2)
+ ramPriority * Math.Pow(requestedRAM - computer.RAM, 2)
+ storagePriority * Math.Pow(requestedStorage - computer.Storage, 2)
+ pricePriority * Math.Pow(requestedPrice - computer.Price, 2));
offers.Add(distance, computer);
}
IOrderedEnumerable <KeyValuePair <double, Computer> > sortedOffers = offers.OrderBy(key => key.Key);
Computer bestOffer = sortedOffers.FirstOrDefault().Value;
bestOffer.Category = _context.Category.Where(c => c.Id == bestOffer.CategoryId).FirstOrDefault();
recommendationViewModel.RecommendedComputer = bestOffer;
}
ViewData["CategoryId"] = new SelectList(await _context.Category.ToListAsync(), "Id", "Name");
return(View(recommendationViewModel));
}
//public ActionResult Create( RecommendationViewModel RVM,int id)
//{
// //Recomendation R = new Recomendation();
// //R.IdRecom = RVM.IdRecom;
// //R.ParticipantId = int.Parse(User.Identity.GetUserId());
// //R.MailRecomd = "test";
// //R.RefRecommendation = RVM.RefRecommendation;
// //R.EtaRec = Domain.Entities.EtatRecom.inprogress;
// //R.EventId = RVM.EventId=id;
// //SendingMail("*****@*****.**", R.MailRecomd, "recommendation", "test recommendation ");
// //RS.Add(R);
// //RS.Commit();
// //return View(RVM);
//}
public ActionResult Create(RecommendationViewModel rvm, int id)
{
Recomendation r = new Recomendation();
r.ID = rvm.ID;
r.IdParticipant = int.Parse(User.Identity.GetUserId());
r.IdEvent = rvm.IdEvent = id;
r.Nom = us.GetUserById(r.IdParticipant).FirstName;
r.Prenom = us.GetUserById(r.IdParticipant).LastName;
r.EmailParticipent = rvm.EmailParticipent;
SendingMail("*****@*****.**", r.EmailParticipent, "[Recommendation for an Event]", "check this link :http://localhost:59686/Evenement/details/" + id);
RS.Add(r);
RS.Commit();
return(RedirectToAction("DetailsParticipant", "Evenement"));
}
public ActionResult Recommend()
{
var artistsA = Request.Form.GetValues("artists");
var tracksA = Request.Form.GetValues("tracks");
List <Artist> artists = artistsA.Any() ? JsonConvert.DeserializeObject <List <Artist> >(artistsA[0]) : null;
List <Track> tracks = tracksA.Any() ? JsonConvert.DeserializeObject <List <Track> >(tracksA[0]) : null;
var result = service.GetRecommendations(artists, tracks);
if (result != null)
{
var vm = new RecommendationViewModel
{
Tracks = result
};
return(View(vm));
}
return(RedirectToAction("Error"));
}
// GET: Recommendation
public ActionResult Index(int id)
{
List <RecommendationViewModel> list = new List <RecommendationViewModel>();
var r = RS.GetAll();
foreach (var i in r)
{
RecommendationViewModel recommendationModel = new RecommendationViewModel();
if (i.IdEvent == id)
{
recommendationModel.EmailParticipent = i.EmailParticipent;
recommendationModel.Nom = i.Nom;
recommendationModel.Prenom = i.Prenom;
list.Add(recommendationModel);
}
}
return(View(list));
}
public async Task <ActionResult> Recommended(RecommendationViewModel model)
{
model = getData(model);
ModelState.Remove("newTopicParentId");
if (UserManager.Users.Single(x => x.Id == model.selectedTeamMemberId) == null)
{
ModelState.AddModelError("", "Team Member not found");
}
if (ModelState.IsValid)
{
Debug.WriteLine("Parent id " + model.newTopicParentId);
Debug.WriteLine("Testing recommend " + model.selectFromList);
if (model.selectFromList == true)
{
Debug.WriteLine("Testing recommend " + model.recommendedTopicId);
if (TopM.recommendTopic(model.recommendedTopicId, model.selectedTeamMemberId))
{
ViewBag.Confirmation = "The Topic was successfuly recommended";
}
else
{
ModelState.AddModelError("", "Topic recommendation failed, try again");
}
}
else
{
Topic topic;
topic = TopM.createTopic(model.newTopicTitle, model.newTopicDescription, model.newTopicParentId);
if (TopM.recommendTopic(topic.TopicsId, model.selectedTeamMemberId))
{
ViewBag.Confirmation = "The Topic was successfuly recommended";
}
else
{
ModelState.AddModelError("", "The user already has this Topic in his recommendations");
}
}
return(View(model));
}
ViewBag.Confirmation = "";
return(View(model));
}
public IActionResult AddRecommendation(int userId, RecommendationViewModel newRecommendation)
{
if (newRecommendation == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(StatusCode(412));
}
var recommendation = _recommendationService.AddNewRecommendation(userId, newRecommendation);
if (recommendation == null)
{
return(NotFound());
}
return(Ok(recommendation));
}
public async Task <IActionResult> ViewRecommendation(RecommendationViewModel recommendationViewModels)
{
var username = HttpContext.Session.GetString("username");
var customerData = await _customerProfileService.CustomerProfile(username);
List <Promotion> promotionsbyregion = await _promotionService.RetrievePromotionByRegionAsync(customerData.Region);
//to add recommendation based on new promotions
IEnumerable <Promotion> allnewpromotions = await _promotionService.RetrieveNewestPromotionsAsync();
//popular promotions
List <Claim> allpopularpromotions = await _recommendationService.GetClaimCountByPromotion();
var promotionViewModel = new RecommendationViewModel();
int mostClaimed = allpopularpromotions.Count > 0 ? allpopularpromotions.Max(s => s.TotalClaim) : 0;
var ItemsList = new List <Promotion>();
foreach (var claimedpromo in allpopularpromotions)
{
if (claimedpromo.TotalClaim == mostClaimed)
{
var toppromo = await _promotionService.RetrievePromotionAsync(claimedpromo.PromotionId);
ItemsList.Add(new Promotion {
PromotionId = toppromo.PromotionId, ShopProfileId = toppromo.ShopProfileId, Description = toppromo.Description, EndDate = toppromo.EndDate, Header = toppromo.Header, IsActive = toppromo.IsActive, Qty = toppromo.Qty, Region = toppromo.Region, StartDate = toppromo.StartDate, Type = toppromo.Type
});
}
}
promotionViewModel.AllPopularPromotions = ItemsList;
promotionViewModel.AllPromotionsByRegion = promotionsbyregion;
//to add recommendation based on new promotions
promotionViewModel.AllNewPromotions = allnewpromotions.ToList();
return(View(promotionViewModel));
}
public async Task <ActionResult> MovieRecommendation(string year, string category, int?movieId)
{
Movie movieVotedFor = await MovieAPI.GetById(movieId.Value);
List <Movie> movies = await MovieAPI.GetAll();
movies = movies.Where(m => m.Title != movieVotedFor.Title && m.Actors != null).Distinct().ToList();
Dictionary <Movie, int> movieRecommendations = BuildMovieDictionary(movies);
RecommendationViewModel recommendation = new RecommendationViewModel()
{
Year = year,
Category = category
};
foreach (Movie potentialRecommendation in movies)
{
movieRecommendations[potentialRecommendation] = GetMovieRecommendationScore(potentialRecommendation, movieVotedFor);
}
List <Movie> moviesWithHighestScore = FindMovieDictionaryItemsWithGreatestScore(movieRecommendations);
recommendation.Movie = PickRandomMovieFromList(moviesWithHighestScore);
return(View(recommendation));
}
public async Task ExecuteAsync()
{
try
{
#region GetAll Data
var getAllProviderNew = await _providerNewRepository.FindAllAsync(x => x.DateCreated < DateTime.Now &&
x.DateCreated >= DateTime.Now.AddDays(-1) && x.Status == Model.Enums.Status.Active);
var getAllService = await _serviceRepository.FindAllAsync(x => x.DateCreated <DateTime.Now &&
x.DateCreated> DateTime.Now.AddDays(-1) && x.Status == Model.Enums.Status.Active);
var getAllFollowing = await _providerFollowingRepository.FindAllAsync();
var getAllUser = await _userManager.Users.ToListAsync();
var getAllProvider = await _providerRepository.FindAllAsync(x => x.Status == Model.Enums.Status.Active);
var getAllProviderService = await _providerServiceRepository.FindAllAsync();
#endregion GetAll Data
// User-->UserFollowing-->Provider-->ProviderNews
var joinAllInformation = (from user in getAllUser.ToList()
join following in getAllFollowing.ToList()
on user.Id equals following.UserId
join provider in getAllProvider.ToList()
on following.ProviderId equals provider.Id
join news in getAllProviderNew.ToList()
on provider.Id equals news.ProviderId
where (following.IsReceiveEmail == true && news.Status == Model.Enums.Status.Active)
orderby user.Id
select new
{
IdUser = user.Id,
Information = news.Id.ToString()
}).ToList().
Union(from user in getAllUser.ToList()
join following in getAllFollowing.ToList()
on user.Id equals following.UserId
join providerService in getAllProviderService.ToList()
on following.ProviderId equals providerService.ProviderId
join service in getAllService.ToList()
on providerService.ServiceId equals service.Id
where (following.IsReceiveEmail == true && service.Status == Model.Enums.Status.Active)
select new
{
IdUser = user.Id,
Information = service.Id.ToString()
}).ToList();
if (joinAllInformation.Count > 0)
{
var groupInformatin = joinAllInformation.GroupBy(p => p.IdUser).Select(x => new
{
IdUser = x.Key,
Information = x.Select(t => new { t.Information }).ToList()
});
//Create List for add.
List <RecommendationViewModel> listRecommendService = new List <RecommendationViewModel>();
foreach (var item in groupInformatin)
{
RecommendationViewModel recommendService = new RecommendationViewModel();
recommendService.EmailUser = _userManager.FindByIdAsync(item.IdUser.ToString()).Result.Email;
foreach (var detail in item.Information)
{
var number = 0;
if (Int32.TryParse(detail.Information, out number))
{
var resultNews = await _getByIdProviderNewService.ExecuteAsync(number);
recommendService.NewsProviderViewModel.Add(resultNews.myModel);
}
else
{
var resultProvider = await _getPostServiceByIdQuery.ExecuteAsync(detail.Information);
recommendService.PostServiceViewModel.Add(resultProvider);
}
}
listRecommendService.Add(recommendService);
}
foreach (var item in listRecommendService)
{
ContentEmail(_configEmail.Value.SendGridKey, "Email recommendation",
item.NewsProviderViewModel.ToString() + "</br>" + item.PostServiceViewModel.ToString(), item.EmailUser).Wait();
}
}
}
catch (Exception)
{
throw;
}
}
public RecommendationPage()
{
InitializeComponent();
BindingContext = viewModel = new RecommendationViewModel();
}
private void AddModel(Recommendation recommendation, bool isRead)
{
var currentUser = User.Followings.Single(c => c.Id == recommendation.UserId);
Recommendations.Add(RecommendationViewModel.FromModel(recommendation, currentUser, settings.Font, isRead));
}
public RecommendationDTO AddNewRecommendation(int userId, RecommendationViewModel newRecommendation)
{
var recommendation = _repo.AddNewRecommendation(userId, newRecommendation);
return(recommendation);
}
private void Populate(RecommendationViewModel model)
{
model.Genres = _service.GetAllGenres();
model.Moods = _service.GetAllMoods();
model.Styles = _service.GetAllStyles();
}
