private void DeleteMember(Member objMember)
{
MemberList.Remove(objMember);
MembershipData.SaveMemberships(MemberList);
Messenger.Default.Send(new NotificationMessage(objMember.DisplayText + " is removed successfully."));
CloseWindow(objMemberUpdate);
}
protected void DeleteMethod(object obj)
{
try
{
if (MessageBox.Show("You are going to Delete this Member.Do you want to proceed?", MessageBoxCaption, MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No)
{
return;
}
using (SqlConnection conn = new SqlConnection(GlobalClass.TConnectionString))
{
conn.Open();
using (SqlTransaction tran = conn.BeginTransaction())
{
member.Delete(tran);
tran.Commit();
}
}
MemberList.Remove(MemberList.First(x => x.MemberId == member.MemberId));
MessageBox.Show("Member Successfully Deleted.", MessageBoxCaption, MessageBoxButton.OK, MessageBoxImage.Information);
UndoMethod(null);
}
catch (Exception ex)
{
while (ex.InnerException != null)
{
ex = ex.InnerException;
}
MessageBox.Show(ex.Message, MessageBoxCaption, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
/// <summary>
/// Remove the currently selected employee.
/// </summary>
private void Remove_Employee()
{
if (MemberList.Count > 0)
{
MemberList.Remove(SelectedMember);
}
}
private void ExecuteDeleteMember()
{
MessageBoxResult result = MessageBox.Show("Are you sure to delete " + currentMember.MemberName, "Delete", MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result == MessageBoxResult.Yes)
{
if (currentMember != null)
{
using (var unitofWork = new UnitOfWork(new MahalluDBContext())) {
ResidenceMember member = unitofWork.ResidenceMembers.Get(CurrentMember.Id);
if (member != null)
{
unitofWork.ResidenceMembers.Remove(member);
unitofWork.Complete();
ResidenceMemberType residenceMemberType = new ResidenceMemberType {
ResidenceMember = CurrentMember,
Operation = MahalluManager.Model.Common.Operation.Delete
};
eventAggregator.GetEvent <PubSubEvent <ResidenceMemberType> >().Publish(residenceMemberType);
MemberList.Remove(CurrentMember);
CurrentMember = null;
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="msg"></param>
public void ReceiveMessage(NotificationMessage msg)
{
if (msg.Notification == "Delete")
{
MemberList.Remove(selectedMember);
database.SaveMemberships();
}
}
/// <summary>
/// deletes the selected member
/// </summary>
public void DelMember()
{
if (MemberList.Count > 0)
{
MemberList.Remove(this.SelectedMember);
this.RaisePropertyChanged(() => this.MemberList);
}
}
public void SuccessfullyRemoveMemberListMember()
{
_memberList.Add(_methodA);
_memberList.Add(_propertyA);
Assert.Contains(_propertyA, _memberList);
_memberList.Remove(_propertyA);
Assert.DoesNotContain(_propertyA, _memberList);
Assert.Single(_memberList);
}
/// <summary>
/// Gets text messages.
/// </summary>
/// <param name="msg">The received message. "Delete" means the currently selected member is deleted.</param>
public void ReceiveMessage(NotificationMessage msg)
{
if (msg.Notification == "Delete")
{
MemberList.Remove(SelectedMember);
RaisePropertyChanged(() => MemberList);
database.SaveMemberships();
}
}
private static void RemoveMemberList(List <List <PossibleMembers> > ValidMembers)
{
foreach (var MemberList in ValidMembers)
{
foreach (var Member in MemberList.ToArray())
{
if (Member.members.Count == 1)
{
MemberList.Remove(Member);
}
}
}
}
/// <summary>
/// Gets a new member for the list.
/// </summary>
/// <param name="m">The member to add. The message denotes how it is added.
/// "Update" replaces at the specified index, "Add" adds it to the list.</param>
public void ReceiveMember(MessageMember m)
{
if (m.Message == "Update")
{
MemberList.Remove(SelectedMember);
MemberList.Add(m);
database.SaveMemberships();
}
else if (m.Message == "Add")
{
MemberList.Add(m);
database.SaveMemberships();
}
}
public void RemoveMemberFromLobby(User user)
{
foreach (var bet in this.Bets)
{
foreach (var outcome in bet.Outcomes)
{
foreach (var participant in outcome.Participants)
{
if (user.Username == participant.Username)
{
outcome.Participants.Remove(participant);
}
}
}
}
MemberList.Remove(user);
user.MemberOfLobbies.Remove(this);
}
/// <summary>
/// Return the elements (package, types, etc) visible from the current file
/// </summary>
/// <param name="typesOnly">Return only packages & types</param>
/// <returns></returns>
public override MemberList GetVisibleExternalElements(bool typesOnly)
{
MemberList visibleElements = new MemberList();
if (!IsFileValid) return visibleElements;
// top-level elements
if (!typesOnly && topLevel != null)
{
if (topLevel.OutOfDate) InitTopLevelElements();
visibleElements.Add(topLevel.Members);
}
if (completionCache.IsDirty)
{
MemberList elements = new MemberList();
// root types & packages
FileModel baseElements = ResolvePackage(null, false);
if (baseElements != null)
{
elements.Add(baseElements.Imports);
elements.Add(baseElements.Members);
}
elements.Add(new MemberModel(features.voidKey, features.voidKey, FlagType.Class | FlagType.Intrinsic, 0));
bool qualify = Settings.CompletionShowQualifiedTypes && settings.GenerateImports;
// other classes in same package
if (features.hasPackages && cFile.Package != "")
{
FileModel packageElements = ResolvePackage(cFile.Package, false);
if (packageElements != null)
{
foreach (MemberModel member in packageElements.Imports)
{
if (member.Flags != FlagType.Package)
{
if (qualify) member.Name = member.Type;
elements.Add(member);
}
}
foreach (MemberModel member in packageElements.Members)
{
string pkg = member.InFile.Package;
if (qualify && pkg != "") member.Name = pkg + "." + member.Name;
elements.Add(member);
}
}
}
// other classes in same file
if (cFile.PrivateSectionIndex > 0)
{
if (inPrivateSection && cFile.Classes.Count > 1)
{
ClassModel mainClass = cFile.GetPublicClass();
if (!mainClass.IsVoid())
{
MemberModel toRemove = elements.Search(mainClass.Name, 0, 0);
if (toRemove != null && toRemove.Type == mainClass.QualifiedName)
elements.Remove(toRemove);
}
}
MemberModel member;
foreach (ClassModel aClass in cFile.Classes)
{
if (features.hasMultipleDefs || aClass.Access == Visibility.Private)
{
member = aClass.ToMemberModel();
elements.Add(member);
}
}
}
// imports
elements.Add(ResolveImports(CurrentModel));
// in cache
elements.Sort();
completionCache = new CompletionCache(this, elements);
// known classes colorization
if (!CommonSettings.DisableKnownTypesColoring && !settings.LazyClasspathExploration && CurSciControl != null)
{
try
{
CurSciControl.KeyWords(1, completionCache.Keywords); // additional-keywords index = 1
CurSciControl.Colourise(0, -1); // re-colorize the editor
}
catch (AccessViolationException){} // catch memory errors
}
}
visibleElements.Merge(completionCache.Elements);
return visibleElements;
}
public void RemoveMember(int move)
{
Members.Remove(move);
MemberList.Remove(move);
}
public bool DeleteMember(Member member)
{
return(MemberList.Remove(member));
}
public void RemoveMember(GuildCharacter character)
{
MemberList.Remove(character);
}
public void DeleteMember(ulong guid)
{
Player player = ObjMgr.FindPlayer(guid);
if (GetLeaderGuid() == guid)
{
Member oldLeader = null;
Member newLeader = null;
foreach (var member in MemberList.OrderBy(p => p.RankId))
{
if (member.CharGuid == guid)
{
oldLeader = member;
}
else if (newLeader == null || newLeader.RankId > member.RankId)
{
newLeader = member;
}
}
if (newLeader == null)
{
Disband();
return;
}
SetLeader(newLeader);
Player newLeaderPlayer = ObjMgr.FindPlayer(newLeader.CharGuid);
if (newLeaderPlayer != null)
{
newLeaderPlayer.SetGuildRank((uint)GuildDefaultRanks.Master);
}
if (oldLeader != null)
{
SendBroadcastEvent(GuildEvents.LeaderChanged, 0, oldLeader.Name, newLeader.Name);
SendBroadcastEvent(GuildEvents.Left, guid, oldLeader.Name);
}
}
Member m = GetMember(guid);
if (m == null)
{
return;
}
MemberList.Remove(m);
if (player != null)
{
player.SetInGuild(0);
player.SetGuildRank(0);
player.SetGuildLevel(0);
/*
* for (uint32 i = 0; i < sGuildPerkSpellsStore.GetNumRows(); ++i)
* if (GuildPerkSpellsEntry const* entry = sGuildPerkSpellsStore.LookupEntry(i))
* if (entry->Level >= GetLevel())
* player->removeSpell(entry->SpellId, false, false);
*/
}
PreparedStatement stmt = DB.Characters.GetPreparedStatement(CharStatements.GuildDelMember);
stmt.AddValue(0, guid);
DB.Characters.Execute(stmt);
}
