public async Task SendGroupAsync_PublishesGroupCommandToBusAndHandlerWritesInvocationToClient()
{
using var client = new TestClient();
var connection = HubConnectionContextUtils.Create(connection: client.Connection);
var fakeBus = new FakeBus();
var hubLifetimeManager = ArrangeRebusLifetimeManager(fakeBus);
await hubLifetimeManager.OnConnectedAsync(connection).OrTimeout();
var groupName = "Group";
await hubLifetimeManager.SendGroupAsync(groupName, "Hello", new object[] { "World" });
var publishedEvent = fakeBus.Events.OfType <MessagePublished>().Select(m => m.EventMessage).OfType <Group <TestHub> >().FirstOrDefault();
Assert.NotNull(publishedEvent);
Assert.Null(publishedEvent.ExcludedConnectionIds);
var groupHandler = new GroupHandler <TestHub>(hubLifetimeManager, NullLogger <GroupHandler <TestHub> > .Instance);
hubLifetimeManager.AddToGroupLocal(connection, groupName);
await groupHandler.Handle(publishedEvent);
var message = client.TryRead() as InvocationMessage;
Assert.NotNull(message);
Assert.AreEqual("Hello", message.Target);
Assert.AreEqual(1, message.Arguments.Length);
Assert.AreEqual("World", (string)message.Arguments[0]);
}
public async Task SendGroupExceptAsync_PublishesGroupCommandToBusAndHandlerSkipsExcludedConnection()
{
using var client = new TestClient();
var connection = HubConnectionContextUtils.Create(connection: client.Connection);
var fakeBus = new FakeBus();
var hubLifetimeManager = ArrangeRebusLifetimeManager(fakeBus);
await hubLifetimeManager.OnConnectedAsync(connection).OrTimeout();
var groupName = "Group";
await hubLifetimeManager.SendGroupExceptAsync(groupName, "Hello", new object[] { "World" }, new List <string>(new[] { connection.ConnectionId }).AsReadOnly());
var publishedEvent = fakeBus.Events.OfType <MessagePublished>().Select(m => m.EventMessage).OfType <Group <TestHub> >().FirstOrDefault();
Assert.NotNull(publishedEvent);
Assert.True(publishedEvent.ExcludedConnectionIds?.Length == 1 && publishedEvent.ExcludedConnectionIds[0] == connection.ConnectionId);
var groupHandler = new GroupHandler <TestHub>(hubLifetimeManager, NullLogger <GroupHandler <TestHub> > .Instance);
hubLifetimeManager.AddToGroupLocal(connection, groupName);
await groupHandler.Handle(publishedEvent);
var message = client.TryRead() as InvocationMessage;
Assert.Null(message);
}
private static Dictionary <PwUuid, bool> CollectUuids(PwGroup pg)
{
Dictionary <PwUuid, bool> d = new Dictionary <PwUuid, bool>();
Action <IStructureItem> fAdd = delegate(IStructureItem it)
{
if (it == null)
{
Debug.Assert(false); return;
}
Debug.Assert(!d.ContainsKey(it.Uuid));
d[it.Uuid] = true;
PwGroup pgParent = it.ParentGroup;
while (pgParent != null)
{
d[pgParent.Uuid] = true;
pgParent = pgParent.ParentGroup;
}
};
GroupHandler gh = delegate(PwGroup pgCur) { fAdd(pgCur); return(true); };
EntryHandler eh = delegate(PwEntry peCur) { fAdd(peCur); return(true); };
fAdd(pg);
pg.TraverseTree(TraversalMethod.PreOrder, gh, eh);
return(d);
}
public void CanHandleGroupMessages()
{
var handler = new GroupHandler();
bool result = false;
var messageTestCases = new List <EventMessageBase>
{
new GroupArchive {
Type = EventType.GroupArchive
},
new GroupJoined {
Type = EventType.GroupJoined
},
new GroupLeft {
Type = EventType.GroupLeft
},
new GroupMarked {
Type = EventType.GroupMarked
},
new GroupRename {
Type = EventType.GroupRename
},
new GroupUnarchive {
Type = EventType.GroupUnarchive
}
};
foreach (var messageTestCase in messageTestCases)
{
result = handler.CanHandle(messageTestCase);
Assert.True(result);
}
}
private uint GetMinKdbxVersion()
{
if(m_uForceVersion != 0) return m_uForceVersion;
// See also KeePassKdb2x3.Export (KDBX 3.1 export module)
AesKdf kdfAes = new AesKdf();
if(!kdfAes.Uuid.Equals(m_pwDatabase.KdfParameters.KdfUuid))
return FileVersion32;
if(m_pwDatabase.PublicCustomData.Count > 0)
return FileVersion32;
bool bCustomData = false;
GroupHandler gh = delegate(PwGroup pg)
{
if(pg == null) { Debug.Assert(false); return true; }
if(pg.CustomData.Count > 0) { bCustomData = true; return false; }
return true;
};
EntryHandler eh = delegate(PwEntry pe)
{
if(pe == null) { Debug.Assert(false); return true; }
if(pe.CustomData.Count > 0) { bCustomData = true; return false; }
return true;
};
gh(m_pwDatabase.RootGroup);
m_pwDatabase.RootGroup.TraverseTree(TraversalMethod.PreOrder, gh, eh);
if(bCustomData) return FileVersion32;
return FileVersion32_3; // KDBX 3.1 is sufficient
}
internal bool ValidateUuidUniqueness()
{
#if DEBUG
List<PwUuid> l = new List<PwUuid>();
bool bAllUnique = true;
GroupHandler gh = delegate(PwGroup pg)
{
foreach(PwUuid u in l)
bAllUnique &= !pg.Uuid.EqualsValue(u);
l.Add(pg.Uuid);
return bAllUnique;
};
EntryHandler eh = delegate(PwEntry pe)
{
foreach(PwUuid u in l)
bAllUnique &= !pe.Uuid.EqualsValue(u);
l.Add(pe.Uuid);
return bAllUnique;
};
m_pgRootGroup.TraverseTree(TraversalMethod.PreOrder, gh, eh);
return bAllUnique;
#else
return true;
#endif
}
/// <summary>
/// Checks whether the given target exists in this group and whether the given requestMember has the given privs
/// </summary>
public GroupResult CheckAction(GroupMember requestMember, GroupMember target, string targetName, GroupPrivs reqPrivs)
{
GroupResult err;
if (target == null || (target.Group) != requestMember.Group)
{
// Character is offline or doesn't exist
err = GroupResult.NotInYourParty;
}
else if ((reqPrivs == GroupPrivs.Leader && m_leader != requestMember) ||
(reqPrivs == GroupPrivs.MainAsisstant && !requestMember.IsAtLeastMainAssistant) ||
(reqPrivs == GroupPrivs.Assistant && !requestMember.IsAtLeastAssistant))
{
err = GroupResult.DontHavePermission;
targetName = string.Empty;
}
else
{
return(GroupResult.NoError);
}
var requester = requestMember.Character;
if (requester != null)
{
GroupHandler.SendResult(requester.Client, err, targetName);
}
return(err);
}
private bool PreOrderTraverseTree(GroupHandler groupHandler, EntryHandler entryHandler)
{
if (entryHandler != null)
{
foreach (PwEntry pe in m_listEntries)
{
if (!entryHandler(pe))
{
return(false);
}
}
}
if (groupHandler != null)
{
foreach (PwGroup pg in m_listGroups)
{
if (!groupHandler(pg))
{
return(false);
}
pg.PreOrderTraverseTree(groupHandler, entryHandler);
}
}
else // groupHandler == null
{
foreach (PwGroup pg in m_listGroups)
{
pg.PreOrderTraverseTree(null, entryHandler);
}
}
return(true);
}
private bool UpdateMemoryProtection(int nIndex, bool bOldSetting, string strFieldID)
{
bool bNewProt = m_lbMemProt.GetItemChecked(nIndex);
if (bNewProt != bOldSetting)
{
m_pwDatabase.RootGroup.EnableStringFieldProtection(strFieldID, bNewProt);
}
#if DEBUG
GroupHandler gh = delegate(PwGroup pg)
{
return(true);
};
EntryHandler eh = delegate(PwEntry pe)
{
ProtectedString ps = pe.Strings.Get(strFieldID);
if (ps != null)
{
Debug.Assert(ps.IsProtected == bNewProt);
}
return(true);
};
Debug.Assert(m_pwDatabase.RootGroup.TraverseTree(TraversalMethod.PreOrder, gh, eh));
#endif
return(bNewProt);
}
public static PwObjectPool FromGroupRecursive(PwGroup pgRoot, bool bEntries)
{
if (pgRoot == null)
{
throw new ArgumentNullException("pgRoot");
}
PwObjectPool p = new PwObjectPool();
if (!bEntries)
{
p.m_dict[pgRoot.Uuid] = pgRoot;
}
GroupHandler gh = delegate(PwGroup pg)
{
p.m_dict[pg.Uuid] = pg;
return(true);
};
EntryHandler eh = delegate(PwEntry pe)
{
p.m_dict[pe.Uuid] = pe;
return(true);
};
pgRoot.TraverseTree(TraversalMethod.PreOrder, bEntries ? null : gh,
bEntries ? eh : null);
return(p);
}
public bool MigratePlaceholder(string from, string to, bool bTouchEntries)
{
bool bChanged = false;
if (!m_bInitialized)
{
return(bChanged);
}
GroupHandler gh = delegate(PwGroup pg)
{
if (pg == null)
{
return(true);
}
if (pg.DefaultAutoTypeSequence.Contains(from))
{
pg.DefaultAutoTypeSequence = pg.DefaultAutoTypeSequence.Replace(from, to);
pg.Touch(true, false);
bChanged = true;
}
return(true);
};
EntryHandler eh = delegate(PwEntry pe)
{
if (pe == null)
{
return(true);
}
foreach (var a in pe.AutoType.Associations)
{
if (a.Sequence.Contains(from))
{
a.Sequence = a.Sequence.Replace(from, to);
bChanged = true;
}
}
if (pe.AutoType.DefaultSequence.Contains(from))
{
pe.AutoType.DefaultSequence = pe.AutoType.DefaultSequence.Replace(from, to);
bChanged = true;
}
if (bTouchEntries)
{
pe.Touch(true);
}
return(true);
};
m_db.RootGroup.TraverseTree(TraversalMethod.PreOrder, gh, eh);
if (m_db.RootGroup.DefaultAutoTypeSequence.Contains(from))
{
m_db.RootGroup.DefaultAutoTypeSequence = m_db.RootGroup.DefaultAutoTypeSequence.Replace(from, to);
m_db.RootGroup.Touch(true, false);
bChanged = true;
}
return(bChanged);
}
private static void ExportDatabaseFile(EcasAction a, EcasContext ctx)
{
string strPath = EcasUtil.GetParamString(a.Parameters, 0, true);
// if(string.IsNullOrEmpty(strPath)) return; // Allow no-file exports
string strFormat = EcasUtil.GetParamString(a.Parameters, 1, true);
if (string.IsNullOrEmpty(strFormat))
{
return;
}
string strGroup = EcasUtil.GetParamString(a.Parameters, 2, true);
string strTag = EcasUtil.GetParamString(a.Parameters, 3, true);
PwDatabase pd = Program.MainForm.ActiveDatabase;
if ((pd == null) || !pd.IsOpen)
{
return;
}
PwGroup pg = pd.RootGroup;
if (!string.IsNullOrEmpty(strGroup))
{
char chSep = strGroup[0];
PwGroup pgSub = pg.FindCreateSubTree(strGroup.Substring(1),
new char[] { chSep }, false);
pg = (pgSub ?? (new PwGroup(true, true, KPRes.Group, PwIcon.Folder)));
}
if (!string.IsNullOrEmpty(strTag))
{
pg = pg.CloneDeep();
GroupHandler gh = delegate(PwGroup pgSub)
{
PwObjectList <PwEntry> l = pgSub.Entries;
long n = (long)l.UCount;
for (long i = n - 1; i >= 0; --i)
{
if (!l.GetAt((uint)i).HasTag(strTag))
{
l.RemoveAt((uint)i);
}
}
return(true);
};
gh(pg);
pg.TraverseTree(TraversalMethod.PreOrder, gh, null);
}
PwExportInfo pei = new PwExportInfo(pg, pd, true);
IOConnectionInfo ioc = (!string.IsNullOrEmpty(strPath) ?
IOConnectionInfo.FromPath(strPath) : null);
ExportUtil.Export(pei, strFormat, ioc);
}
private uint GetMinKdbxVersion()
{
if (m_uForceVersion != 0)
{
return(m_uForceVersion);
}
// See also KeePassKdb2x3.Export (KDBX 3.1 export module)
uint minVersionForKeys = m_pwDatabase.MasterKey.UserKeys.Select(key => key.GetMinKdbxVersion()).Max();
AesKdf kdfAes = new AesKdf();
if (!kdfAes.Uuid.Equals(m_pwDatabase.KdfParameters.KdfUuid))
{
return(Math.Max(FileVersion32, minVersionForKeys));
}
if (m_pwDatabase.PublicCustomData.Count > 0)
{
return(Math.Max(FileVersion32, minVersionForKeys));
}
bool bCustomData = false;
GroupHandler gh = delegate(PwGroup pg)
{
if (pg == null)
{
Debug.Assert(false); return(true);
}
if (pg.CustomData.Count > 0)
{
bCustomData = true; return(false);
}
return(true);
};
EntryHandler eh = delegate(PwEntry pe)
{
if (pe == null)
{
Debug.Assert(false); return(true);
}
if (pe.CustomData.Count > 0)
{
bCustomData = true; return(false);
}
return(true);
};
gh(m_pwDatabase.RootGroup);
m_pwDatabase.RootGroup.TraverseTree(TraversalMethod.PreOrder, gh, eh);
if (bCustomData)
{
return(Math.Max(FileVersion32, minVersionForKeys));
}
return(Math.Max(FileVersion32_3, minVersionForKeys));; // KDBX 3.1 is sufficient
}
public ActionResult AcceptGroupRequest(AspNetUser sender, string actionId, int message_id)
{
var group_id = int.Parse(actionId);
var receiver_id = User.Identity.GetUserId();
GroupHandler.addUserToGroup(sender.Id, group_id, message_id);
return(RedirectToAction("ShowChat", "Messenger", new { sendToUserId = sender.Id }));
}
private static bool CheckMemberInGroup(Character requester, Group group, uint memberLowId)
{
if (group[memberLowId] != null)
{
return(true);
}
GroupHandler.SendResult(requester.Client, GroupResult.NotInYourParty);
return(false);
}
private static bool CheckSameGroup(Character requester, Character character)
{
if (requester.Group != character.Group)
{
GroupHandler.SendResult(requester.Client, GroupResult.NotInYourParty, character.Name);
return(false);
}
return(true);
}
private static Dictionary <PwGroup, UInt32> WriteGroups(Kdb3Manager mgr,
PwGroup pgRoot)
{
Dictionary <PwGroup, UInt32> dictGroups = new Dictionary <PwGroup, uint>();
uint uGroupIndex = 1;
DateTime dtNeverExpire = Kdb3Manager.GetNeverExpireTime();
GroupHandler gh = delegate(PwGroup pg)
{
if (pg == pgRoot)
{
return(true);
}
Kdb3Group grp = new Kdb3Group();
grp.GroupId = uGroupIndex;
dictGroups[pg] = grp.GroupId;
grp.ImageId = (uint)pg.IconId;
grp.Name = pg.Name;
grp.CreationTime.Set(pg.CreationTime);
grp.LastModificationTime.Set(pg.LastModificationTime);
grp.LastAccessTime.Set(pg.LastAccessTime);
if (pg.Expires)
{
grp.ExpirationTime.Set(pg.ExpiryTime);
}
else
{
grp.ExpirationTime.Set(dtNeverExpire);
}
grp.Level = (ushort)(pg.GetLevel() - 1);
if (pg.IsExpanded)
{
grp.Flags |= (uint)Kdb3GroupFlags.Expanded;
}
if (!mgr.AddGroup(ref grp))
{
Debug.Assert(false);
throw new InvalidOperationException();
}
++uGroupIndex;
return(true);
};
pgRoot.TraverseTree(TraversalMethod.PreOrder, gh, null);
Debug.Assert(dictGroups.Count == (int)(uGroupIndex - 1));
return(dictGroups);
}
private async void RunHandler(EventMessageBase message, Mock <IBotState> mockState)
{
var handler = new GroupHandler();
handler.BotState = mockState.Object;
var result = await handler.HandleMessageAsync(message);
mockState.Verify();
}
/// <summary>
/// Check whether the given inviter may invite the given target
/// </summary>
public static GroupResult CheckInvite(Character inviter, out Character target, string targetName)
{
GroupResult err;
var inviterMember = inviter.GroupMember;
var group = inviterMember != null ? inviterMember.Group : null;
Character targetChar = World.GetCharacter(targetName, true);
if (group != null && group.IsFull)
{
// your group is full
err = GroupResult.GroupIsFull;
target = null;
targetName = string.Empty;
}
else if ((inviterMember != null && !inviterMember.IsAtLeastAssistant))
{
target = null;
err = GroupResult.DontHavePermission;
}
else if (group != null && group.Flags.HasFlag(GroupFlags.Raid) && targetChar != null && targetChar.IsAllowedLowLevelRaid && targetChar.Level < MinLevelToBeInvitedInRaid)
{
target = null;
err = GroupResult.RaidDisallowedByLevel;
}
else
{
target = World.GetCharacter(targetName, false);
if (target == null || inviter == target ||
(target.Role.IsStaff && !inviter.Role.IsStaff)) // cannot invite staff members without authorization
{
// Character is offline or doesn't exist
err = GroupResult.OfflineOrDoesntExist;
}
else if (inviter.Faction.Group != target.Faction.Group)
{
// you can't invite anyone from another faction
err = GroupResult.TargetIsUnfriendly;
}
else if (target.Group != null || target.IsInvitedToGroup)
{
err = GroupResult.AlreadyInGroup;
}
else if (target.IsIgnoring(inviter) && !inviter.Role.IsStaff)
{
err = GroupResult.TargetIsIgnoringYou;
}
else
{
return(GroupResult.NoError);
}
}
GroupHandler.SendResult(inviter.Client, err, GroupResultType.Invite, targetName);
return(err);
}
public ClipboardHandler(
ResourcePlayer resourcePlayer,
ResourceTroup resourceTroup,
ResourceVillage resourceVillage,
GroupHandler groupHandler)
{
_resourcePlayer = resourcePlayer;
_resourceTroup = resourceTroup;
_resourceVillage = resourceVillage;
_groupHandler = groupHandler;
}
private static bool CheckMemberInGroup(Character requester, Group group, uint memberLowId)
{
GroupMember member = group[memberLowId];
if (member == null)
{
// you can't uninvite people not from your group
GroupHandler.SendResult(requester.Client, GroupResult.NotInYourParty);
return(false);
}
return(true);
}
public bool CheckFull(GroupMember member, SubGroup group)
{
if (group.IsFull)
{
var chr = member.Character;
if (chr != null)
{
GroupHandler.SendResult(chr.Client, GroupResultType.Invite, GroupResult.GroupIsFull);
}
return(false);
}
return(true);
}
private void OnLeaderChanged(GroupMember oldLeader)
{
if (this.m_leader != null)
{
GroupHandler.SendLeaderChanged(this.m_leader);
}
Group.GroupLeaderChangedHandler leaderChanged = Group.LeaderChanged;
if (leaderChanged == null)
{
return;
}
leaderChanged(oldLeader, this.m_leader);
}
/// <summary>
/// Called before the given member is removed to clean up everything related to the given member
/// </summary>
protected void OnMemberRemoved(GroupMember member)
{
Character chr = member.Character;
if (chr != null && chr.IsInWorld)
{
if (!chr.IsInContext)
{
chr.ExecuteInContext(() => OnMemberRemoved(member));
return;
}
GroupMemberHandler memberRemoved = MemberRemoved;
if (memberRemoved != null)
{
memberRemoved(member);
}
--m_Count;
SendEmptyUpdate(chr);
chr.GroupMember = null;
GroupHandler.SendResult(chr.Client, GroupResult.NoError);
member.SubGroup.RemoveMember(member);
member.Character = null;
if (chr.Map is BaseInstance)
{
BaseInstance instance = (BaseInstance)chr.Map;
chr.Map.CallDelayed(GroupInstanceKickDelayMillis, () =>
{
if (!chr.IsInWorld || chr.Map != instance || instance.CanEnter(chr))
{
return;
}
chr.TeleportToNearestGraveyard();
});
}
}
else
{
GroupMemberHandler memberRemoved = MemberRemoved;
if (memberRemoved != null)
{
memberRemoved(member);
}
--m_Count;
Singleton <GroupMgr> .Instance.OfflineChars.Remove(member.Id);
member.m_subGroup = null;
}
member.m_nextMember = null;
}
private static bool CheckIsLeader(GroupMember member)
{
if (!member.IsLeader)
{
// you dont have permission
var chr = member.Character;
if (chr != null)
{
GroupHandler.SendResult(chr.Client, GroupResult.DontHavePermission);
}
return(false);
}
return(true);
}
void Start()
{
groupHandler = GameObject.FindGameObjectWithTag("Esentials").GetComponent <GroupHandler>();
switch (category)
{
case Category.Unit:
groupHandler.Units.Add(gameObject);
break;
case Category.Building:
groupHandler.Buildings.Add(gameObject);
break;
}
}
public bool CheckFull(GroupMember member, SubGroup group)
{
if (!group.IsFull)
{
return(true);
}
Character character = member.Character;
if (character != null)
{
GroupHandler.SendResult(character.Client, GroupResult.GroupIsFull);
}
return(false);
}
internal void ReorderEntries(PwObjectPool ppOrgStructure,
PwObjectPool ppSrcStructure)
{
GroupHandler gh = delegate(PwGroup pg)
{
ReorderObjectList<PwEntry>(pg.Entries, ppOrgStructure,
ppSrcStructure, true);
return true;
};
ReorderObjectList<PwEntry>(m_pgRootGroup.Entries, ppOrgStructure,
ppSrcStructure, true);
m_pgRootGroup.TraverseTree(TraversalMethod.PreOrder, gh, null);
}
private static bool CheckIsLeader(GroupMember member)
{
if (member.IsLeader)
{
return(true);
}
Character character = member.Character;
if (character != null)
{
GroupHandler.SendResult((IPacketReceiver)character.Client, GroupResult.DontHavePermission);
}
return(false);
}
private void tbx_AnidbID_KeyUp(object sender, System.Windows.Input.KeyEventArgs e)
{
AnidbResult ar = GroupHandler.SearchAniDBByID(anititles, tbx_AnidbID.Text.Trim());
if (ar != null)
{
RichTextBoxHepler.SetText(rtb_GroupMembers, ar.keywords);
RichTextBoxHepler.SetText(rtb_Presenter, ar.presenter);
}
else
{
RichTextBoxHepler.SetText(rtb_Presenter, "");
}
}
