private void AddFavoriteToModel(FavoriteViewModel newFavorite)
{
if (newFavorite != null)
{
// First remove this favorite if already in the model
RemoveRBFavoriteFromModelByFavoriteId(newFavorite.Id);
lock (lockObservableFavorites)
{
Boolean itemAdded = false;
int nb = FavoritesList.Count;
for (int i = 0; i < nb; i++)
{
if (newFavorite.Position < FavoritesList[i].Position)
{
FavoritesList.Insert(i, newFavorite);
log.LogDebug("[AddFavoriteToModel] INSERT Favorite.id:[{0}] IN index:[{1}]", newFavorite.Id, i);
itemAdded = true;
break;
}
}
if (!itemAdded)
{
FavoritesList.Add(newFavorite);
log.LogDebug("[AddFavoriteToModel] ADD Favorite.id:[{0}] ", newFavorite.Id);
}
}
}
}
public ActionResult AddFavorite(FavoriteViewModel favorite)
{
//Need to make sure it's not adding favorites that already exist
ViewBag.Message = "Your Favorites Page";
var userloggedIn = UserManager.User.employeeID;
int selectedActivity = favorite.selectedActivityID;
if (selectedActivity != 0)
{
favorite AddFavorite = new favorite();
AddFavorite.Activity_activityID = selectedActivity;
AddFavorite.Employee_employeeID = userloggedIn;
// Check if selected activity is already a favorite. If not, add to Favorite Table
var existsQuery = from f in db.favorites
where (f.Activity_activityID.Equals(AddFavorite.Activity_activityID) && f.Employee_employeeID.Equals(userloggedIn))
select f;
if (!existsQuery.Any())
{
new FavoriteController().Create(AddFavorite);
}
}
favorite.Activities = db.activities.ToList();
favorite.ActivityNames = new SelectList(favorite.Activities, "activityID", "activityName");
var query = from a in db.activities
join b in db.favorites
on a.activityID equals b.Activity_activityID
where b.Employee_employeeID.Equals(userloggedIn)
select new FavoriteViewModel {
SelectedActivity = a, SelectedFavorite = b
};
favorite.UserFavorites = new SelectList(query.ToArray(), "SelectedFavorite.favoriteID", "SelectedActivity.ActivityName");
return(View("Favorite", favorite));
}
public IActionResult FavoriteAdd([FromRoute] int touristSpotId)
{
try
{
var body = new FavoriteViewModel {
TouristSpotId = touristSpotId
};
if (this.UserId.HasValue)
{
body.UserId = this.UserId.Value;
}
var _added = this.favoriteAppService.Add(body);
return(this.Response(_added, HttpStatusCode.Created, Messages.SaveSuccess));
}
catch (SnowmanLabsChallengeException slcex)
{
return(this.Response(slcex));
}
catch (Exception ex)
{
return(this.Response(ex));
}
}
public ActionResult RemoveFavorite(FavoriteViewModel favorite)
{
var userloggedIn = UserManager.User.employeeID;
ViewBag.Message = "Your Favorites Page";
if (favorite != null)
{
int[] removeFav = favorite.RemoveFavorites;
if (removeFav != null)
{
for (int i = 0; i < removeFav.Length; i++)
{
if (removeFav[i] != 0)
{
new FavoriteController().DeleteConfirmed(removeFav[i]);
}
}
}
}
favorite = new FavoriteViewModel();
favorite.Activities = db.activities.ToList();
favorite.ActivityNames = new SelectList(favorite.Activities, "activityID", "activityName");
var query = from a in db.activities
join b in db.favorites
on a.activityID equals b.Activity_activityID
where b.Employee_employeeID.Equals(userloggedIn)
select new FavoriteViewModel {
SelectedActivity = a, SelectedFavorite = b
};
favorite.UserFavorites = new SelectList(query.ToArray(), "SelectedFavorite.favoriteID", "SelectedActivity.ActivityName");
return(View("Favorite", favorite));
}
/// <summary>
/// Gets all survey data from DB
/// </summary>
/// <returns>a List of Survey objects</returns>
public List <FavoriteViewModel> GetSurveys()
{
List <FavoriteViewModel> result = new List <FavoriteViewModel>();
using (SqlConnection connection = new SqlConnection(_connection))
{
connection.Open();
const string sqlParkCommand = "select COUNT(survey_result.parkCode) as parkCount, park.parkCode, Park.parkName, Park.parkDescription " +
"from survey_result JOIN park on park.parkCode = survey_result.parkCode " +
"group by Park.parkDescription, park.parkName, park.parkCode " +
"order by COUNT(survey_result.parkCode) desc;";
SqlCommand cmd = new SqlCommand();
cmd.CommandText = sqlParkCommand;
cmd.Connection = connection;
//Pull data off the table
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
var favorites = new FavoriteViewModel();
favorites.ParkCode = Convert.ToString(reader["parkCode"]);
favorites.ParkName = Convert.ToString(reader["parkName"]);
favorites.NumOfSurveys = Convert.ToInt32(reader["parkCount"]);
result.Add(favorites);
}
}
return(result);
}
public void FavoriteModelNotNullAfterInitialization()
{
var fav = new FavoriteViewModel();
//fav.LoadFavorites.Execute(null);
Assert.IsNotNull(fav.favorites);
}
public FavoriteController(ApplicationDbContext db)
{
_db = db;
FavoriteVM = new FavoriteViewModel()
{
Stories = new List <Stories>()
};
}
//我的收藏
public ActionResult Favorite()
{
MemberService service = new MemberService();
FavoriteViewModel model = new FavoriteViewModel();
model.Favorlist = service.GetFavoritelist(Int32.Parse(Request.Cookies["upid"].Value));
return(PartialView(model));
}
public void UpdateFavoriteNameByPeerId(string peerId, String name)
{
FavoriteViewModel result = GetFavoriteByPeerId(peerId);
if (result != null)
{
result.Name = name;
}
}
public void UpdateFavoriteUsingPresence(String jid, Presence presence)
{
FavoriteViewModel result = GetFavoriteByJid(jid);
if (result != null)
{
result.PresenceSource = InstantMessaging.Helpers.Helper.GetPresenceSourceFromPresence(presence, jid == CurrentApplication.CurrentUserJid);
}
}
public void UpdateFavoriteUsingUpdatedConversation(Conversation conversation)
{
FavoriteViewModel result = GetFavoriteByPeerId(conversation.PeerId);
if (result != null)
{
result.NbMsgUnread = conversation.UnreadMessageNumber;
}
}
public FavoriteController(ApplicationDbContext db, UserManager <IdentityUser> userManager)
{
_db = db;
_userManager = userManager;
FavoriteVM = new FavoriteViewModel()
{
Stories = new List <Stories>()
};
}
public void RemoveRBFavoriteFromModelByPeerId(String peerId)
{
FavoriteViewModel result = GetFavoriteByPeerId(peerId);
if (result != null)
{
lock (lockObservableFavorites)
FavoritesList.Remove(result);
}
}
public FavoriteListAdapter(Activity ParentActivity, FavoriteViewModel ViewModel)
{
this.ParentActivity = ParentActivity;
this.ViewModel = ViewModel;
ViewModel.Items.CollectionChanged += (sender, args) =>
{
this.ParentActivity.RunOnUiThread(NotifyDataSetChanged);
};
}
public static FavoriteViewModel Convert(Favorite favorite)
{
FavoriteViewModel favoriteViewModel = new FavoriteViewModel();
favoriteViewModel.FavoriteID = favorite.FavoriteID;
favoriteViewModel.UserID = int.Parse(favorite.UserID);
favoriteViewModel.MovieID = favorite.MovieID;
favoriteViewModel.Note = favorite.Note;
return(favoriteViewModel);
}
public ActionResult Manager(SitePageData currentPage)
{
var model = new FavoriteViewModel();
model.Favorites = FavoriteRepository
.GetFavorites(PrincipalInfo.Current.Name);
model.CurrentPageContentReference = currentPage.ContentLink;
return(PartialView("FavoritesManager", model));
}
public async Task <IActionResult> InsertFavoriteAsync([FromBody] FavoriteViewModel favoriteViewModel)
{
var result = await _service.InsertFavoriteAsync(favoriteViewModel);
if (result.error)
{
return(StatusCode((int)result.errorInfo?.FirstOrDefault().statusCode, result));
}
return(Ok(result));
}
public static List <FavoriteViewModel> ConvertList(IEnumerable <Favorite> favorites)
{
return(favorites.Select(f =>
{
FavoriteViewModel favoriteViewModel = new FavoriteViewModel();
favoriteViewModel.FavoriteID = f.FavoriteID;
favoriteViewModel.UserID = int.Parse(f.UserID);
favoriteViewModel.MovieID = f.MovieID;
favoriteViewModel.Note = f.Note;
return favoriteViewModel;
}).ToList());
}
public async Task <ResponseModel <Favorite> > InsertFavoriteAsync(FavoriteViewModel favoriteViewModel)
{
try
{
var product = await _productRepository.GetProduct(favoriteViewModel.ProductId);
if (product is null)
{
return(new ResponseModel <Favorite>(true, new List <ErrorInfo>
{
new ErrorInfo(HttpStatusCode.NotFound, _messages.ProductDoesNotExist,
string.Format(_messages.ProductDoesNotExistDescription, favoriteViewModel.ProductId))
}));
}
Favorite favorite = new Favorite(favoriteViewModel);
var inserted = await _favoriteRepository.Insert(favorite);
if (inserted == 0)
{
return(new ResponseModel <Favorite>(true, new List <ErrorInfo>
{
new ErrorInfo(HttpStatusCode.Conflict, _messages.NoFavoriteChanged, _messages.NoFavoriteChangedDescription)
}));
}
return(new ResponseModel <Favorite>(favorite));
}
catch (Exception ex)
{
var message = "";
if (ex.HResult == -2146233088)
{
message = string.Format(_messages.ProductAlreadyInFavoritesDescription, ex.InnerException.Message);
_logger.LogError(ex, message);
return(new ResponseModel <Favorite>(true, new List <ErrorInfo>
{
new ErrorInfo(HttpStatusCode.Conflict, _messages.ProductAlreadyInFavorites, message)
}));
}
message = string.Format(_messages.InternalErrorDescription, ex.Message);
_logger.LogError(ex, message);
return(new ResponseModel <Favorite>(true, new List <ErrorInfo>
{
new ErrorInfo(HttpStatusCode.InternalServerError, _messages.InternalError, message)
}));
}
}
public Favorite()
{
BindingContext = favViewModel = new FavoriteViewModel();
MessagingCenter.Subscribe <Object>(this, "Favorite", (obj) =>
{
try
{
favViewModel.LoadFavorites.Execute(null);
}
catch { }
});
InitializeComponent();
}
public Favorite MapperToFavorite(FavoriteViewModel favoriteViewModel)
{
Favorite favorite = new Favorite
{
Description = favoriteViewModel.Description,
Id = favoriteViewModel.Id,
Language = favoriteViewModel.Language,
Name = favoriteViewModel.Name,
Owner = favoriteViewModel.Owner,
UpdateLast = favoriteViewModel.UpdateLast
};
return(favorite);
}
public async Task <IActionResult> Upload([FromBody] FavoriteViewModel favorite)
{
if (favorite.Stream == null)
{
return(BadRequest("Failed to upload file"));
}
var user = await _userManager.FindByEmailAsync(User.Identity.Name);
await _favoriteLogic.For(user.Id).UploadFavorite(favorite.Filename, new MemoryStream(
Convert.FromBase64String(favorite.Stream)
));
return(Ok("Successfully uploaded stream"));
}
public override View OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
// Use this to return your custom view for this Fragment
// return
ViewModel = new FavoriteViewModel();
var rootView = inflater.Inflate(Resource.Layout.fragment_favorite, container, false);
recycleFavorite = rootView.FindViewById <RecyclerView>(Resource.Id.recycleFavorite);
swipeRefresh = rootView.FindViewById <SwipeRefreshLayout>(Resource.Id.swipeRefresh);
InitSwipeRefreshLayout(swipeRefresh);
fragStatus = rootView.FindViewById <LinearLayout>(Resource.Id.fragStatus);
return(rootView);
}
public async Task <FavoriteViewModel> AddFavoriteAsync(FavoriteViewModel FavoriteViewModel, CancellationToken ct = default(CancellationToken))
{
Favorite favorites = new Favorite()
{
MovieID = FavoriteViewModel.MovieID,
UserID = FavoriteViewModel.UserID.ToString(),
Note = FavoriteViewModel.Note
};
favorites = await _favoriteRepository.AddAsync(favorites, ct);
FavoriteViewModel.FavoriteID = favorites.FavoriteID;
return(FavoriteViewModel);
}
public IActionResult Favorite(Guid verseId)
{
// Get the claims values
User user = GetUser();
if (user == null)
{
return(Json(new FavoriteViewModel {
IsLoggedIn = false
}));
}
var favoriteViewModel = new FavoriteViewModel()
{
IsLoggedIn = true,
VerseId = verseId,
IsFavorited = false
};
if (!dataContext.Verses.Any(v => v.Id == verseId))
{
return(Json(favoriteViewModel));
}
var favorite = dataContext.Favorites.Where(f => f.UserId == user.Id && f.VerseId == verseId).FirstOrDefault();
//toggle off
if (favorite != null)
{
dataContext.Favorites.Remove(favorite);
dataContext.SaveChanges();
return(Json(favoriteViewModel));
}
//toggle on
favorite = new Favorite
{
Id = Guid.NewGuid(),
UserId = user.Id,
VerseId = verseId,
CreatedDateTime = DateTime.Now
};
dataContext.Favorites.Add(favorite);
dataContext.SaveChanges();
favoriteViewModel.IsFavorited = true;
return(Json(favoriteViewModel));
}
public List <HierarchicalViewModelBase> GetChildViewModels(FavoriteViewModel <SiteFavorite> parent)
{
var fav = parent as SiteFavoriteViewModel;
var list = new List <HierarchicalViewModelBase>();
if (fav != null)
{
var service = new MaterialService(User);
var models = service.GetExplorerElementsForParent(fav.ElemID, fav.ElemType);
list.AddRange(models.ConvertAll((m) => {
return(new SiteExplorerNodeViewModel(m));
}));
}
return(list);
}
public List <FavoriteViewModel> MapperToListFavoriteViewModel(List <Favorite> favortes)
{
foreach (var favorite in favortes)
{
FavoriteViewModel favoriteViewModel = new FavoriteViewModel
{
Description = favorite.Description,
Id = favorite.Id,
Language = favorite.Language,
Name = favorite.Name,
Owner = favorite.Owner,
UpdateLast = favorite.UpdateLast
};
favoritesViewModel.Add(favoriteViewModel);
}
return(favoritesViewModel);
}
private FavoriteViewModel GetFavoriteByJid(String jid)
{
FavoriteViewModel result = null;
lock (lockObservableFavorites)
{
foreach (FavoriteViewModel favorite in FavoritesList)
{
if (favorite.Jid == jid)
{
result = favorite;
break;
}
}
}
return(result);
}
public ActionResult <FavoriteViewModel> SaveFavoriteRepository(FavoriteViewModel view)
{
// declaration
ActionResult <FavoriteViewModel> result = new ActionResult <FavoriteViewModel>();
Favorite favorite = new Favorite();
// instantiation
favorite.Id = view.Id;
favorite.Description = view.Description;
favorite.Language = view.Language;
favorite.UpdateLast = view.UpdateLast;
favorite.Owner = view.Owner;
favorite.Name = view.Name;
result.IsValid = _context.Insert(favorite);
return(result);
}
public ActionResult FavoriteSave(string owner, string name, string language, string lastUpdat, string description)
{
ActionResult <FavoriteViewModel> model = new ActionResult <FavoriteViewModel>();
if (string.IsNullOrEmpty(owner) && string.IsNullOrEmpty(name) && string.IsNullOrEmpty(language) &&
string.IsNullOrEmpty(lastUpdat) && string.IsNullOrEmpty(description))
{
model.IsValid = false;
model.Message = "Não foi possivel realizar esta operação";
return(Json(new
{
Data = model
}, JsonRequestBehavior.AllowGet));
}
else
{
FavoriteViewModel view = new FavoriteViewModel()
{
Description = description,
Language = language,
Owner = owner,
UpdateLast = DateTime.Parse(lastUpdat),
Name = name
};
var response = _business.SaveFavoriteRepository(view);
if (model.IsValid)
{
TempData["success"] = model.Message;
}
else
{
TempData["warning"] = model.Message;
}
return(Json(new
{
Data = response
}, JsonRequestBehavior.AllowGet));
}
}
