/// <summary>
/// Adds a url to the user's saved favourites list.
/// Will not work if name entered is a duplicate.
/// </summary>
/// <param name="name">The name to be associated with this favourite</param>
/// <param name="url">THe url to be favourited</param>
public static void AddFavourite(String name, String url)
{
if (!Favourites.ContainsKey(name))
{
try
{
using (StreamWriter sw = File.AppendText(savedPagesFileName))
{
sw.WriteLine("f," + name + "," + url);
}
logBox.Text = "Favourite added with name: " + name;
//Add favourite within program before writing to file. Ensures user doesn't see update in program but changes are not saved.
Favourites.Add(name, url);
foreach (TabUserControl tab in AllTabs)
{
tab.RefreshFavouritesBox();
}
}
catch (IOException ioe)
{
logBox.Text = "Failed to add favourite, error saving data.";
}
catch (Exception e)
{
logBox.Text = "Failed to add favourite, unknown error." + e.Message;;
}
}
else
{
logBox.Text = "You tried to add a favourite with a duplicate name. Favourite not added. Name: " + name;
}
}
public IdenticaClient(string username, string password)
{
Statuses = new Statuses(this);
Account = new Account(this);
DirectMessages = new DirectMessages(this);
Favourites = new Favourites(this);
Block = new Block(this);
Friendships = new Friendship(this);
Lists = new List(this);
Search = new Search(this);
Users = new Users(this);
FriendsAndFollowers = new FriendsAndFollowers(this);
Credentials = new BasicAuthCredentials
{
Username = username,
Password = password
};
Client = new RestClient
{
Authority = "http://identi.ca/api",
};
Authority = "http://identi.ca/api";
Encode = false;
}
private void TimerTickSearch(object sender, EventArgs e)
{
timerSearch.Stop();
ShowHeaderLoader();
if (isFavouritesView)
{
IEnumerable <Favourite> favourites = UnitOfWork.FavouriteRepository.GetByName(searchText);
Favourites.Clear();
Favourites.AddRange(favourites);
}
else
{
IEnumerable <Recent> recentTrips = UnitOfWork.RecentTripRepository.GetByName(searchText);
RecentTrips.Clear();
RecentTrips.AddRange(recentTrips);
}
HideHeaderLoader();
ShowList();
}
public ContactWithFavouritesViewModel(Contact contact, Outlook outlook, Favourites favourites)
{
if (contact == null)
throw new ArgumentNullException("Contact");
if (outlook == null)
throw new ArgumentNullException("Outlook");
Outlook = outlook;
Contact = contact;
Contact.PropertyChanged += Contact_PropertyChanged;
Favourites = favourites;
Favourites.PropertyChanged += Favourites_PropertyChanged;
//Contact = favourites.FirstOrDefault(x => x.FullName == contact.FullName);
//ParentContact = contact;
//if (Contact.IsEmpty() && !ParentContact.IsEmpty())
// Contact.Copy(ParentContact);
//Contact.PropertyChanged += Contact_PropertyChanged;
AddressBookCommand = new RelayCommand(AddressBookPressed);
ClearCommand = new RelayCommand(ClearPressed, CanClear);
AddFavouriteCommand = new RelayCommand(AddFavouritePressed, CanAddFavourite);
RemoveFavouriteCommand = new RelayCommand(RemoveFavouritePressed);
}
public void Set_Home_URL()
{
Favourites h = Favourites.InstanceNoFileWrite;
h.SetHomeURL("http://www.example.com");
Assert.AreEqual(h.HomeUrl, "http://www.example.com", "Home URL not being set correctly");
}
public void Test_KeyExists_Method()
{
Favourites h = Favourites.InstanceNoFileWrite;
h.AddEntry("http://www.duckduckgo.com", "DuckDuckGo", false);
Assert.ThrowsException <System.ArgumentException>(() => h.AddEntry("http://www.duckduckgo.com", "DuckDuckGo", false));
}
public IActionResult AddToFavourite([FromForm] AddToFavouriteRequestModel model)
{
var responseModel = new ResponseModel();
string authorizeTokenKey = _httpContextAccessor.HttpContext.Request.Headers["AuthorizeTokenKey"];
var singleUser = _context.Users.Where(x => x.AuthorizeTokenKey == authorizeTokenKey).AsNoTracking();
if (singleUser.Any())
{
var user = singleUser.FirstOrDefault();
if (_context.Favourites.Any(x => x.EntityId == model.EntityId && x.EntityName == model.EntityName && x.UserId == user.Id))
{
responseModel.Message = "Already added to Favourite list";
}
else
{
Favourites favourites = new Favourites();
favourites.EntityId = model.EntityId;
favourites.EntityName = model.EntityName;
favourites.UserId = user.Id;
_context.Favourites.Add(favourites);
_context.SaveChanges();
responseModel.Message = "Add to Favourite Added Successfully";
}
return(StatusCode((int)HttpStatusCode.OK, responseModel));
}
else
{
responseModel.Message = "no authorization";
return(StatusCode((int)HttpStatusCode.Unauthorized, responseModel));
}
}
public void Instantiate_Multiple_History()
{
Favourites h = Favourites.InstanceNoFileWrite;
Favourites hi = Favourites.InstanceNoFileWrite;
Assert.AreSame(h, hi, "Instances of Favourites are not the same object");
}
public Favourites getFavourite(string pid, int cid)
{
Favourites fav = null;
int favID;
string queryStr = "SELECT favId FROM Favourites WHERE pID = @pID AND cID = @cID";
SqlConnection con = new SqlConnection(connStr);
SqlCommand cmd = new SqlCommand(queryStr, con);
cmd.Parameters.AddWithValue("@pID", pid);
cmd.Parameters.AddWithValue("@cID", cid);
con.Open();
SqlDataReader dr = cmd.ExecuteReader();
if (dr.HasRows && dr.Read())
{
favID = int.Parse(dr["favId"].ToString());
fav = new Favourites(favid);
}
else
{
fav = null;
}
con.Close();
dr.Close();
dr.Dispose();
return(fav);
}
public List <Favourites> getAllFavourites(int id)
{
List <Favourites> favList = new List <Favourites>();
string prodID;
int favid;
string queryStr = "SELECT favId, pID FROM Favourites WHERE cID = @cID";
SqlConnection con = new SqlConnection(connStr);
SqlCommand cmd = new SqlCommand(queryStr, con);
cmd.Parameters.AddWithValue("@cID", id);
con.Open();
SqlDataReader dr = cmd.ExecuteReader();
while (dr.Read())
{
prodID = dr["pID"].ToString();
favid = int.Parse(dr["favId"].ToString());
Favourites fav = new Favourites(prodID, favid);
favList.Add(fav);
}
con.Close();
dr.Close();
dr.Dispose();
return(favList);
}
public void AddFavouriteMonster(Monster monster)
{
Favourites.Add(new CustomerFavourite()
{
MonsterId = monster.Id, CustomerId = CustomerId, Monster = monster, Customer = this
});
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Uuid,Type,StructureId")] Favourites favourites)
{
if (id != favourites.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(favourites);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FavouritesExists(favourites.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(favourites));
}
public async Task <PageContent> instantiatePageContent(string url)
{
History h = History.InstanceNoFileWrite;
Favourites f = Favourites.InstanceNoFileWrite;
return(await PageContent.AsyncCreate(url, h, f));
}
public void AddOrUpdate(Favourites favourites)
{
var entry = _context.Entry(favourites);
switch (entry.State)
{
case EntityState.Detached:
Add(favourites);
break;
case EntityState.Modified:
Update(favourites);
break;
case EntityState.Added:
Add(favourites);
break;
case EntityState.Unchanged:
break;
case EntityState.Deleted:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
protected void Page_Load(object sender, EventArgs e)
{
Product p = new Product();
Favourites f = new Favourites();
string pID = Request.QueryString["pID"].ToString();
prod = p.getProduct(pID);
acc = (Account)Session["Id"];
img_product.ImageUrl = "~/img/" + prod.gsImage;
lbl_prodname.Text = string.Format("<b>PRODUCT DETAILS</b> <br/> <span style='color:#2196f3'>{0}</span>", prod.gsProdName);
lbl_prodid.Text = string.Format("<b>PRODUCT CODE</b> <br/> <span style='color:#2196f3'>{0}</span>", prod.gsProdID);
lbl_prodprice.Text = string.Format("<strong>${0}</strong>", prod.gsPrice);
lbl_description.Text = string.Format("<center><b>PRODUCT DESCRIPTION</b> <br/> <span style='color:#212121'>{0}</span> </center>", prod.gsLongDesc);
if (acc != null)
{
if (f.getFavourite(pID, acc.gsID) != null)
{
linkbtn_favourite.Text = "<i class='material-icons pink-text'>favorite</i>";
}
else
{
linkbtn_favourite.Text = "<i class='material-icons pink-text'>favorite_border</i>";
}
}
}
public async void WriteInMemory(Favourites favourites)
{
clubCollection = await apiMethods.GetAllClubs("GetAllCLubs", 1083);
favourites.FavClubs = clubCollection;
await BlobCache.InMemory.InsertObject("favourites", Favourites);
}
public RacePreviewModel(Race race, Track track, List <Trait> traits, List <Strategy> strategies, List <SeasonTeam> favourites)
{
Race = race;
Track = track;
if (traits != null)
{
foreach (var trait in traits)
{
TrackTraits.Add(trait);
}
}
if (strategies != null)
{
foreach (var strat in strategies)
{
Strategies.Add(strat);
}
}
if (favourites != null)
{
foreach (var team in favourites)
{
Favourites.Add(team);
}
}
}
private void searchBox_KeyUp(object sender, KeyEventArgs e)
{
if (e.Key == Key.Return)
{
this.cityToRefresh = searchBox.Text;
setupTimer();
bool found = false;
string selected_city = searchBox.Text;
for (int i = 0; i < Favourites.Count; i++)
{
if (selected_city == Favourites.ElementAt(i).name + "," + Favourites.ElementAt(i).country)
{
this.favouriteYES.Visibility = Visibility.Visible;
this.favouriteNO.Visibility = Visibility.Hidden;
found = true;
break;
}
}
if (!found)
{
this.favouriteYES.Visibility = Visibility.Hidden;
this.favouriteNO.Visibility = Visibility.Visible;
}
}
else
{
return;
}
}
public void Save_Activated(object sender, ToggledEventArgs e)
{
DisplayAlert("Alert", "(TO BE IMPLEMENTED) Save is clicked", "OK");
iDataFavourite = DependencyService.Get <IDataStore>();
Favourites favourites = new Favourites()
{
UserId = 001,
FashionAndBeauty = Convert.ToInt32(FashionAndBeauty.IsToggled),
SportsAndOutdoor = Convert.ToInt32(SportsAndOutdoorName.IsToggled),
Pets = Convert.ToInt32(Pets.IsToggled),
Vehicles = Convert.ToInt32(Vehicles.IsToggled),
HomeImprovement = Convert.ToInt32(HomeImprovement.IsToggled),
BabiesChildren = Convert.ToInt32(BabiesChildren.IsToggled),
HobbiesInterests = Convert.ToInt32(HobbiesInterests.IsToggled),
MobilePhonesAndAccessories = Convert.ToInt32(MobilePhonesAndAccessories.IsToggled),
HomeAppliances = Convert.ToInt32(HomeAppliances.IsToggled),
Gaming = Convert.ToInt32(Gaming.IsToggled),
Books = Convert.ToInt32(Books.IsToggled),
Music = Convert.ToInt32(Music.IsToggled),
};
iDataFavourite.AddFavouriteAsync(favourites);
}
private void favourite_Checked(object sender, RoutedEventArgs e)
{
this.favouriteNO.Visibility = Visibility.Hidden;
this.favouriteYES.Visibility = Visibility.Visible;
if (product.city == null)
{
this.favouriteNO.Visibility = Visibility.Visible;
this.favouriteYES.Visibility = Visibility.Hidden;
return;
}
bool exists = false;
for (int i = 0; i < Favourites.Count; i++)
{
if (product.city.id == Favourites.ElementAt(i).id)
{
exists = true;
}
}
if (!exists)
{
Favourites.Add(new City(product.city.id, product.city.name, product.city.coord, product.city.country, product.city.population));
favWin.listView.Items.Add(product.city.name + "," + product.city.country);
SaveFavourites();
}
}
public TwitterClient(IRestClient client, string consumerKey, string consumerSecret, string callback)
: base(client)
{
Encode = true;
Statuses = new Statuses(this);
Account = new Account(this);
DirectMessages = new DirectMessages(this);
Favourites = new Favourites(this);
Block = new Block(this);
Friendships = new Friendship(this);
Lists = new List(this);
Search = new Search(this);
Users = new Users(this);
FriendsAndFollowers = new FriendsAndFollowers(this);
OAuthBase = "https://api.twitter.com/oauth/";
TokenRequestUrl = "request_token";
TokenAuthUrl = "authorize";
TokenAccessUrl = "access_token";
Authority = "https://api.twitter.com/";
Version = "1";
#if !SILVERLIGHT
ServicePointManager.Expect100Continue = false;
#endif
Credentials = new OAuthCredentials
{
ConsumerKey = consumerKey,
ConsumerSecret = consumerSecret,
};
if (!string.IsNullOrEmpty(callback))
((OAuthCredentials)Credentials).CallbackUrl = callback;
}
internal static void DeleteFavourite(Favourites form, Form1 form1)
{
ListBox favouritesListBox = form.favouritesListBox;
int selectedIndex = favouritesListBox.SelectedIndex;
FileListManager.DeleteExistingFavouriteFile(form1, selectedIndex);
favouritesListBox.Items.Clear();
form.InitializeForm(true);
if (favouritesListBox.Items.Count <= 0)
{
return;
}
if (selectedIndex < favouritesListBox.Items.Count)
{
favouritesListBox.SelectedIndex = selectedIndex;
}
else
{
favouritesListBox.SelectedIndex = selectedIndex - 1;
}
}
private int AddToFav(string ISBN, Favourites model, List <Favourites> List)
{
BookDetails Details = SearchBook(ISBN);
if (List == null)
{
model.UserId = Session["Username"].ToString();
model.LinkForThumbnail.Add(Details.VolumeInfo.ImageLinks.SmallThumbnail);
model.Publisher.Add(Details.VolumeInfo.Publisher);
model.NameOfBook.Add(Details.VolumeInfo.Title);
model.IsbnOfBook.Add("ISBN:" + Details.VolumeInfo.IndustryIdentifiers[0].Identifier);
model.Authors.Add(Details.VolumeInfo.Authors.ToList());
model.Category.Add(Details.VolumeInfo.Categories.ToList());
List = new List <Favourites>();
List.Add(model);
return(Write(List));
}
else if (List.Exists(e => e.UserId.Equals(Session["Username"].ToString()) && !e.IsbnOfBook.Contains(ISBN)))
{
foreach (var item in List)
{
if (item.UserId.Equals(Session["Username"].ToString()) && !item.IsbnOfBook.Contains(ISBN))
{
item.LinkForThumbnail.Add(Details.VolumeInfo.ImageLinks.SmallThumbnail);
item.Publisher.Add(Details.VolumeInfo.Publisher);
item.NameOfBook.Add(Details.VolumeInfo.Title);
item.IsbnOfBook.Add(ISBN);
item.Authors.Add(Details.VolumeInfo.Authors.ToList());
item.Category.Add(Details.VolumeInfo.Categories.ToList());
return(Write(List));
}
}
}
return(2);
}
private void checkBox_Click(object sender, RoutedEventArgs e)
{
City = this.CityText.Text;
if (checkBox.IsChecked == true)
{
if (loadedData.cityExists(City) == true)
{
if (PomocniFavourites.Contains(City.ToUpper()) == false)
{
Favourites.Add(City);
PomocniFavourites.Add(City.ToUpper());
if (Favourites.Count() == 6)
{
Favourites.RemoveAt(0);
PomocniFavourites.RemoveAt(0);
}
this.errorMessage.Content = "";
}
else
{
this.errorMessage.Content = "City is already added to favourites.";
}
}
else
{
this.errorMessage.Content = "City couldn't be added to favourites. Please check the spelling and internet connection.";
}
}
else
{
this.errorMessage.Content = "";
}
WriteFavorites();
}
public void ReadFavourites()
{
string currentDirectory = Directory.GetCurrentDirectory();
string path = System.IO.Path.Combine(currentDirectory, "Favourites.txt");
if (!File.Exists(path))
{
using (StreamWriter sw = File.CreateText(path))
{
sw.Close();
}
}
try
{
using (StreamReader sr = File.OpenText(path))
{
string s = "";
while ((s = sr.ReadLine()) != null)
{
Favourites.Add(s);
PomocniFavourites.Add(s.ToUpper());
}
}
}
catch (FileNotFoundException fnf)
{
Console.WriteLine(fnf.ToString());
}
}
public void updateFavourite()
{
var value = IsFavourite;
if (value)
{
bool exists = false;
for (int i = 0; i < Favourites.Count; i++)
{
if (CurrentCityId == Favourites.ElementAt(i).Id)
{
exists = true;
}
}
if (!exists)
{
Favourites.Add(new City(CurrentCityName, CurrentCityId));
SaveFavourites();
}
}
else
{
for (int i = 0; i < Favourites.Count; i++)
{
if (CurrentCityId == Favourites.ElementAt(i).Id)
{
Favourites.Remove(Favourites.ElementAt(i));
SaveFavourites();
break;
}
}
}
}
private void AddFavourites()
{
ShowLoader();
Favourites.Clear();
Favourites.AddRange(UnitOfWork.FavouriteRepository.GetAll().OrderByDescending(x => x.LastUsedDate));
ShowList();
}
public Favourites Update(Favourites favourites)
{
var c = _context.Favourites.Attach(favourites);
c.State = Microsoft.EntityFrameworkCore.EntityState.Modified;
_context.SaveChanges();
return(favourites);
}
public async Task <Favourites> AddToFavourites(Favourites favourite)
{
var added = await _favouritesRepository.AddAsync(favourite);
await _unitOfWork.SaveChangesAsync();
return(added);
}
public async Task <IActionResult> DeleteOne([FromBody] Favourites body)
{
await Db.Connection.OpenAsync();
body.Db = Db;
await body.DeleteOne();
return(new OkObjectResult(body));
}
public void DeleteSubjectFromFavourite(int _UserId, int _SubjId)
{
var favouriteToDelete = new Favourites {
UserId = _UserId, SubjectId = _SubjId
};
database.Remove(favouriteToDelete);
database.SaveChanges();
}
internal static void ShowFavourites(Form form)
{
Favourites favouritesWindow = new Favourites {
Owner = form
};
favouritesWindow.InitializeForm(false);
favouritesWindow.ShowDialog(form);
}
/// <summary>Handle the list of favourite instruments changing</summary>
private void HandleFavouritesListChanging(object sender, ListChgEventArgs <Instrument> e)
{
switch (e.ChangeType)
{
case ListChg.ItemAdded:
case ListChg.ItemRemoved:
Settings.General.FavouriteInstruments = Favourites.Select(x => x.SymbolCode).ToArray();
break;
}
}
public void SetUp()
{
twitterClient = Substitute.For<IBaseTwitterClient>();
favourites = new Favourites(twitterClient);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
favourites = new Favourites((IMainWindow)this);
uiFavouritesListView.ItemsSource = favourites.Servers;
if (Config.Settings.ServerBrowserFavourites != null)
{
foreach (String s in Config.Settings.ServerBrowserFavourites)
{
favourites.Add(s);
}
}
uiOptionsStartListenServerCheckBox.IsChecked = Config.Settings.ServerBrowserStartListenServer;
uiOptionsCloseWhenFinishedCheckBox.IsChecked = Config.Settings.ServerBrowserCloseWhenFinished;
WindowState = Config.Settings.ServerBrowserWindowState;
}
