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, ""); } }