public void AddNewFriend(string name)
{
Friend friend = new Friend(name);
Friends.Add(friend);
Console.WriteLine($"Welcome to the {Name} group!\n");
}
public void AddFriend(IClient client)
{
lock (Friends)
{
Friends.Add(client);
}
}
public void Load()
{
foreach (var friend in _dataProvider.GetAllFriends())
{
Friends.Add(friend);
}
}
public ActionResult Create(Movie movie)
{
// Retreive from the Application dictionary the reference of the contacts instance
Movies movies = (Movies)HttpRuntime.Cache["Movies"];
// Pass the Http post Request object to UpLoadAvatar
// so that it can retreive its uploaded image file
movie.UpLoadAvatar(Request);
// insert the new contact and retreive its Id
int newMovieID = movies.Add(movie);
// Retreive from the Application dictionary the reference of the Friends instance
Friends Friends = (Friends)HttpRuntime.Cache["Friends"];
// Extract the friends Id list from the hidden input FriendsListItems
// embedded in the Http post request
String[] FriendsListItems = Request["FriendsListItems"].Split(',');
// Add friends to the Friends collection
foreach (String friendId in FriendsListItems)
{
if (!String.IsNullOrEmpty(friendId))
{
Friends.Add(new Friend(newMovieID, int.Parse(friendId)));
}
}
// Return the Index action of this controller
return(RedirectToAction("index"));
}
public async Task LoadAsync()
{
//lookup - contained friends list
var lookup = await _friendLookupDataService.GetFriendLookupAsync();
Friends.Clear();
foreach (var item in lookup)
{
Friends.Add(new NavigationItemViewModel(item.Id,
item.DisplayMember,
nameof(FriendDetailViewModel),
_eventAggregator));
}
//lookup - contained friends list
lookup = await _meetingLookupDataService.GetMeetingLookupAsync();
Meetings.Clear();
foreach (var item in lookup)
{
Meetings.Add(new NavigationItemViewModel(item.Id,
item.DisplayMember,
nameof(MeetingDetailViewModel),
_eventAggregator));
}
}
public void AddFriend(string ip, ushort port)
{
FriendViewModel friend = Friends.Where(x => x.Ip == ip && x.Port == port).FirstOrDefault();
if (friend != null)
{
friend.UpdateFilter(LanListFilter);
friend.Remembered = true;
return;
}
try
{
friend = new FriendViewModel(ip, port);
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(string.Format("Failed to connect new friend :(\n\n{0}\n{1}", ex.Message, ex.StackTrace), "Failed To Connect");
}
if (friend != null)
{
friend.UpdateFilter(LanListFilter);
Friends.Add(friend);
friend.Remembered = true;
}
}
private async void SaveFriend(object friendObject)
{
Friend friend = friendObject as Friend;
if (friend != null)
{
if (friend.Id > 0)
{
Friend updatedFriend = await friendsService.Update(friend);
// заменяем объект в списке на новый
if(updatedFriend != null)
{
int pos = Friends.IndexOf(updatedFriend);
Friends.RemoveAt(pos);
Friends.Insert(pos, updatedFriend);
}
}
// добавление
else
{
Friend addedFriend = await friendsService.Add(friend);
if (addedFriend != null)
{
Friends.Add(addedFriend);
}
}
}
}
public void Load()
{
foreach (var friend in _friendDataProvider.LoadFriends())
{
Friends.Add(friend);
}
}
public async Task AddFriend(FriendDto friendDto)
{
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Friends.Add(friendDto);
});
}
void OnCommunityLoaded(SK.SteamFriends.FriendsListCallback callback)
{
foreach (SteamFriend friend in callback.FriendList)
{
SteamUser friendUser = new SteamUser
{
AvatarHash = community.GetFriendAvatar(friend.SteamID),
SteamId = new SteamUserId(friend.SteamID),
Name = community.GetFriendPersonaName(friend.SteamID),
IsOnline = community.GetFriendPersonaState(friend.SteamID) != 0,
IsScammer = GetScammerStatus(friend.SteamID.ToString())
};
if (friendUser.Name == "[unknown]")
{
continue;
}
Friends.Add(friendUser);
if (friend.Relationship == SK.EFriendRelationship.RequestRecipient)
{
Console.WriteLine($"Pending friend request: {friendUser.Name}");
}
}
int onlineFriendsCount = Friends.Count(f => f.IsOnline);
CommunityLoaded?.Invoke(this, null);
}
public void AddFriend(int id, MessengerFriend friend)
{
if (!Friends.ContainsKey(id))
{
Friends.Add(id, friend);
}
}
public void AddFriendToUser(Account account)
{
if (AlreadyHasFriend(account))
{
Friends.Add(account);
}
}
public void Add()
{
Person p = new Person();
p.FirstName = NewPerson.FirstName;
p.Age = NewPerson.Age;
p.Gender = NewPerson.Gender;
p.Address = NewPerson.Address;
p.Hobby = NewPerson.Hobby;
SelectedPerson = p;
if (NewPerson.IsEnemy)
{
p.DeleteCommand = new DeleteCommand(this, true);
p.ID = Enemies.Count + 1;
Enemies.Add(p);
MessageBox.Show("Enemy is added to list.", "Information");
}
else
{
p.DeleteFriendCommand = new DeleteCommand(this, false);
p.ID = Friends.Count + 1;
Friends.Add(p);
MessageBox.Show("Friend is added to list.", "Information");
}
NewPerson = new Person();
}
public override void UpdateListenedFriends()
{
Collider[] cols = Physics.OverlapSphere(GameObject.transform.position, ListenMessageRadius, FriendMask);
foreach (Collider col in cols)
{
if (col.gameObject == GameObject)
{
continue;
}
SharedProps sp = col.GetComponent <SharedProps>();
if (sp && sp.memory != null)
{
if (Vector3.Distance(GameObject.transform.position, sp.transform.position) < ListenMessageRadius && sp.GetComponent <Health>() && sp.GetComponent <Health>().health > 0)
{
// Listen
sp.memory.onMessageSendToListeners -= OnMessageReceived;
sp.memory.onMessageSendToListeners += OnMessageReceived;
if (!Friends.Contains(sp.memory))
{
Friends.Add(sp.memory);
}
}
else
{
// Don't Listen
if (Friends.Contains(sp.memory))
{
Friends.Find(x => x == sp.memory).onMessageSendToListeners -= OnMessageReceived;
Friends.Remove(sp.memory);
}
sp.memory.onMessageSendToListeners -= OnMessageReceived;
}
}
}
}
public async Task LoadAsync()
{
Friends.Clear();
var lookup = await _friendLookupDataService.GetFriendLookupAsync();
foreach (var friend in lookup)
{
Friends.Add(new NavigationItemViewModel(friend.Id, friend.DisplayMember,
nameof(FriendDetailViewModel),
_eventAggregator));
}
Meetings.Clear();
lookup = await _meetingLookUpService.GetMeetingLookupAsync();
foreach (var meeting in lookup)
{
Meetings.Add(new NavigationItemViewModel(meeting.Id, meeting.DisplayMember,
nameof(MeetingDetailViewModel),
_eventAggregator));
}
}
public async Task <bool> AcceptFriendship(User friend)
{
PendingFriends.Remove(friend);
Friends.Add(friend);
using (var handler = new ZumoAuthHeaderHandler(AccountService))
{
using (var client = MobileServiceClientFactory.CreateClient(handler))
{
var existingFriendshipList = await client.GetTable <Friendship>()
.Where(friendship => friendship.UserId == friend.Id)
.Where(friendship => friendship.FriendId == AccountService.Account.UserId).Select(user => user.Id).ToListAsync();
if (existingFriendshipList.Count == 0)
{
return(false);
}
else
{
var friendship = await client.GetTable <Friendship>().LookupAsync(existingFriendshipList[0]);
friendship.Accepted = true;
await client.GetTable <Friendship>().UpdateAsync(friendship);
return(true);
}
}
}
}
private void Xmpp_OnRosterItem(object sender, RosterItem item)
{
if (!Friends.ContainsKey(item.Jid.User))
{
Friends.Add(item.Jid.User, new ChatFriend(item));
}
}
private void OnGetPresenceOfFriendsSuccess(string in_stringData, object in_obj)
{
GStateManager.Instance.EnableLoadingSpinner(false);
GDebug.Log(string.Format("OnGetPresenceOfFriends Success | {0}", in_stringData));
Friends.Clear();
Dictionary <string, object> jsonMessage = (Dictionary <string, object>)JsonReader.Deserialize(in_stringData);
Dictionary <string, object> jsonData = (Dictionary <string, object>)jsonMessage[BrainCloudConsts.JSON_DATA];
if (jsonData.ContainsKey(BrainCloudConsts.JSON_PRESENCE))
{
PlayerData pData = null;
object[] friends = ((object[])jsonData[BrainCloudConsts.JSON_PRESENCE]);
if (friends.Length > 0)
{
for (int it = 0; it < friends.Length; ++it)
{
pData = new PlayerData();
pData.ReadPresencePlayerData(friends[it]);
Friends.Add(pData);
}
}
}
GEventManager.TriggerEvent(ON_FRIENDS_LIST_UPDATED);
}
private void AddFriend()
{
var friend = new Person();
CurrentChild.Friends.Add(friend);
Friends.Add(friend);
}
public void Get_friends() // Getting friend list
{
int Count = 0;
var query = new FriendsGetParams {
UserId = api.UserId, Fields = ProfileFields.All
}; // Getting needed fields
var users = api.Friends.Get(query).OrderByDescending(x => x.Online); // Friends sort
foreach (var x in users)
{
SolidColorBrush status;
if (x.Online == true) // Setting status color
{
status = x.OnlineMobile == true
? new SolidColorBrush(Colors.CornflowerBlue)
: new SolidColorBrush(Colors.DarkGreen);
}
else
{
status = new SolidColorBrush(Colors.Red);
Count++;
}
Friend fr = new Friend(x.FirstName, x.LastName, new BitmapImage(x.Photo50), status, x.Id); // Get instances of friend's class
Friends.Add(fr); //adding it to list of all friends
}
TotalFriends = Friends.Count;
OnlineFriends = Friends.Count - Count;
}
public async Task UndoRedo()
{
RegisterProperty(x => x.Name)
.EnableRecording();
RegisterCollectionProperty(x => x.Friends)
.EnableRecording();
await BeginScope(sc => Name = "Aaaa").StartAsync();
await BeginScope(sc => Name = "Bbbb").StartAsync();
await BeginScope(sc => Name = "Cccc").StartAsync();
await BeginScope(sc => Name = "Dddd").StartAsync();
await BeginScope(sc => Friends.Add(new ContactViewModelTest())).StartAsync();
Assert.AreEqual("Dddd", Name);
Assert.AreEqual(1, Friends.Count);
await Undo();
Assert.AreEqual(0, Friends.Count);
Assert.AreEqual("Dddd", Name);
await Undo();
Assert.AreEqual("Cccc", Name);
await Undo();
Assert.AreEqual("Bbbb", Name);
await Redo();
Assert.AreEqual("Cccc", Name);
}
public void AddMeetingFriend(Profile profile)
{
Friends.Add(new MeetingProfile
{
Meeting = this,
Profile = profile,
});
}
public void Load()
{
Friends.Clear();
foreach (var friend in _dataProvider.GetAllFriends())
{
Friends.Add(new NavigationItemViewModel(friend.Id, friend.DisplayMember, _eventAggregator));
}
}
public void Load()
{
Friends.Clear();
foreach (var item in _dataProvider.GetAllFriends())
{
Friends.Add(item);
}
}
public void Load()
{
var dataService = new FileDataService();
foreach (var friend in dataService.GetAllFriends())
{
Friends.Add(friend);
}
}
public async Task LoadAsync()
{
var lookup = await LookupDataService.GetFriendLookupAsync();
foreach (var item in lookup)
{
Friends.Add(new NavigationItemViewModel(item.Id, item.DisplayMember));
}
}
//更新friends
public List <User> FriendsChange(List <User> users)
{
Friends.Clear();
foreach (User user in users)
{
Friends.Add(user);
}
return(users);
}
public virtual Member addFriend(Member friend)
{
if (friend == this)
{
return(null);
}
Friends.Add(friend);
return(friend);
}
public void Load()
{
var friends = _friendDataService.GetAll();
foreach (var friend in friends)
{
Friends.Add(friend);
}
}
private void RemoveFriend()
{
if (SelectedInvitedFriend == null)
{
return;
}
Friends.Add(SelectedInvitedFriend);
InvitedFriends.Remove(SelectedInvitedFriend);
}
