开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llgroupmgr.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：51k
源码类别：

游戏引擎

开发平台：

C++ Builder

llgroupmgr.cpp：源码内容
  1. /** 
  2.  * @file llgroupmgr.cpp
  3.  * @brief LLGroupMgr class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2004&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2004-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. /**
  34.  * Manager for aggregating all client knowledge for specific groups
  35.  * Keeps a cache of group information.
  36.  */
  38. #include "llviewerprecompiledheaders.h"
  40. #include "llgroupmgr.h"
  42. #include <vector>
  43. #include <algorithm>
  45. #include "llagent.h"
  46. #include "llui.h"
  47. #include "message.h"
  48. #include "roles_constants.h"
  49. #include "lltransactiontypes.h"
  50. #include "llstatusbar.h"
  51. #include "lleconomy.h"
  52. #include "llviewerwindow.h"
  53. #include "llpanelgroup.h"
  54. #include "llgroupactions.h"
  55. #include "llnotificationsutil.h"
  56. #include "lluictrlfactory.h"
  57. #include <boost/regex.hpp>
  60. const U32 MAX_CACHED_GROUPS = 10;
  62. //
  63. // LLRoleActionSet
  64. //
  65. LLRoleActionSet::LLRoleActionSet()
  66. : mActionSetData(NULL)
  67. { }
  69. LLRoleActionSet::~LLRoleActionSet()
  70. {
  71. delete mActionSetData;
  72. std::for_each(mActions.begin(), mActions.end(), DeletePointer());
  73. }
  75. //
  76. // LLGroupMemberData
  77. //
  79. LLGroupMemberData::LLGroupMemberData(const LLUUID& id, 
  80. S32 contribution,
  81. U64 agent_powers,
  82. const std::string& title,
  83. const std::string& online_status,
  84. BOOL is_owner) : 
  85. mID(id), 
  86. mContribution(contribution), 
  87. mAgentPowers(agent_powers), 
  88. mTitle(title), 
  89. mOnlineStatus(online_status),
  90. mIsOwner(is_owner)
  91. {
  92. }
  94. LLGroupMemberData::~LLGroupMemberData()
  95. {
  96. }
  98. void LLGroupMemberData::addRole(const LLUUID& role, LLGroupRoleData* rd)
  99. {
  100. mRolesList[role] = rd;
  101. }
  103. bool LLGroupMemberData::removeRole(const LLUUID& role)
  104. {
  105. role_list_t::iterator it = mRolesList.find(role);
  107. if (it != mRolesList.end())
  108. {
  109. mRolesList.erase(it);
  110. return true;
  111. }
  113. return false;
  114. }
  116. //
  117. // LLGroupRoleData
  118. //
  120. LLGroupRoleData::LLGroupRoleData(const LLUUID& role_id, 
  121. const std::string& role_name,
  122. const std::string& role_title,
  123. const std::string& role_desc,
  124. const U64 role_powers,
  125. const S32 member_count) :
  126. mRoleID(role_id),
  127. mMemberCount(member_count),
  128. mMembersNeedsSort(FALSE)
  129. {
  130. mRoleData.mRoleName = role_name;
  131. mRoleData.mRoleTitle = role_title;
  132. mRoleData.mRoleDescription = role_desc;
  133. mRoleData.mRolePowers = role_powers;
  134. mRoleData.mChangeType = RC_UPDATE_NONE;
  135. }
  137. LLGroupRoleData::LLGroupRoleData(const LLUUID& role_id, 
  138. LLRoleData role_data,
  139. const S32 member_count) :
  140. mRoleID(role_id),
  141. mRoleData(role_data),
  142. mMemberCount(member_count),
  143. mMembersNeedsSort(FALSE)
  144. {
  146. }
  148. LLGroupRoleData::~LLGroupRoleData()
  149. {
  150. }
  152. S32 LLGroupRoleData::getMembersInRole(std::vector<LLUUID> members,
  153.   BOOL needs_sort)
  154. {
  155. if (mRoleID.isNull())
  156. {
  157. // This is the everyone role, just return the size of members, 
  158. // because everyone is in the everyone role.
  159. return members.size();
  160. }
  162. // Sort the members list, if needed.
  163. if (mMembersNeedsSort)
  164. {
  165. std::sort(mMemberIDs.begin(), mMemberIDs.end());
  166. mMembersNeedsSort = FALSE;
  167. }
  168. if (needs_sort)
  169. {
  170. // Sort the members parameter.
  171. std::sort(members.begin(), members.end());
  172. }
  174. // Return the number of members in the intersection.
  175. S32 max_size = llmin( members.size(), mMemberIDs.size() );
  176. std::vector<LLUUID> in_role( max_size );
  177. std::vector<LLUUID>::iterator in_role_end;
  178. in_role_end = std::set_intersection(mMemberIDs.begin(), mMemberIDs.end(),
  179. members.begin(), members.end(),
  180. in_role.begin());
  181. return in_role_end - in_role.begin();
  182. }
  183.   
  184. void LLGroupRoleData::addMember(const LLUUID& member)
  185. {
  186. mMembersNeedsSort = TRUE;
  187. mMemberIDs.push_back(member);
  188. }
  190. bool LLGroupRoleData::removeMember(const LLUUID& member)
  191. {
  192. std::vector<LLUUID>::iterator it = std::find(mMemberIDs.begin(),mMemberIDs.end(),member);
  194. if (it != mMemberIDs.end())
  195. {
  196. mMembersNeedsSort = TRUE;
  197. mMemberIDs.erase(it);
  198. return true;
  199. }
  201. return false;
  202. }
  204. void LLGroupRoleData::clearMembers()
  205. {
  206. mMembersNeedsSort = FALSE;
  207. mMemberIDs.clear();
  208. }
  211. //
  212. // LLGroupMgrGroupData
  213. //
  215. LLGroupMgrGroupData::LLGroupMgrGroupData(const LLUUID& id) : 
  216. mID(id), 
  217. mShowInList(TRUE), 
  218. mOpenEnrollment(FALSE), 
  219. mMembershipFee(0),
  220. mAllowPublish(FALSE),
  221. mListInProfile(FALSE),
  222. mMaturePublish(FALSE),
  223. mChanged(FALSE),
  224. mMemberCount(0),
  225. mRoleCount(0),
  226. mReceivedRoleMemberPairs(0),
  227. mMemberDataComplete(FALSE),
  228. mRoleDataComplete(FALSE),
  229. mRoleMemberDataComplete(FALSE),
  230. mGroupPropertiesDataComplete(FALSE),
  231. mPendingRoleMemberRequest(FALSE)
  232. {
  233. }
  235. BOOL LLGroupMgrGroupData::getRoleData(const LLUUID& role_id, LLRoleData& role_data)
  236. {
  237. role_data_map_t::const_iterator it;
  239. // Do we have changes for it?
  240. it = mRoleChanges.find(role_id);
  241. if (it != mRoleChanges.end()) 
  242. {
  243. if ((*it).second.mChangeType == RC_DELETE) return FALSE;
  245. role_data = (*it).second;
  246. return TRUE;
  247. }
  249. // Ok, no changes, hasn't been deleted, isn't a new role, just find the role.
  250. role_list_t::const_iterator rit = mRoles.find(role_id);
  251. if (rit != mRoles.end())
  252. {
  253. role_data = (*rit).second->getRoleData();
  254. return TRUE;
  255. }
  257. // This role must not exist.
  258. return FALSE;
  259. }
  262. void LLGroupMgrGroupData::setRoleData(const LLUUID& role_id, LLRoleData role_data)
  263. {
  264. // If this is a newly created group, we need to change the data in the created list.
  265. role_data_map_t::iterator it;
  266. it = mRoleChanges.find(role_id);
  267. if (it != mRoleChanges.end())
  268. {
  269. if ((*it).second.mChangeType == RC_CREATE)
  270. {
  271. role_data.mChangeType = RC_CREATE;
  272. mRoleChanges[role_id] = role_data;
  273. return;
  274. }
  275. else if ((*it).second.mChangeType == RC_DELETE)
  276. {
  277. // Don't do anything for a role being deleted.
  278. return;
  279. }
  280. }
  282. // Not a new role, so put it in the changes list.
  283. LLRoleData old_role_data;
  284. role_list_t::iterator rit = mRoles.find(role_id);
  285. if (rit != mRoles.end())
  286. {
  287. bool data_change = ( ((*rit).second->mRoleData.mRoleDescription != role_data.mRoleDescription)
  288. || ((*rit).second->mRoleData.mRoleName != role_data.mRoleName)
  289. || ((*rit).second->mRoleData.mRoleTitle != role_data.mRoleTitle) );
  290. bool powers_change = ((*rit).second->mRoleData.mRolePowers != role_data.mRolePowers);
  292. if (!data_change && !powers_change)
  293. {
  294. // We are back to the original state, the changes have been 'undone' so take out the change.
  295. mRoleChanges.erase(role_id);
  296. return;
  297. }
  299. if (data_change && powers_change)
  300. {
  301. role_data.mChangeType = RC_UPDATE_ALL;
  302. }
  303. else if (data_change)
  304. {
  305. role_data.mChangeType = RC_UPDATE_DATA;
  306. }
  307. else
  308. {
  309. role_data.mChangeType = RC_UPDATE_POWERS;
  310. }
  312. mRoleChanges[role_id] = role_data;
  313. }
  314. else
  315. {
  316. llwarns << "Change being made to non-existant role " << role_id << llendl;
  317. }
  318. }
  320. BOOL LLGroupMgrGroupData::pendingRoleChanges()
  321. {
  322. return (!mRoleChanges.empty());
  323. }
  325. // This is a no-op if the role has already been created.
  326. void LLGroupMgrGroupData::createRole(const LLUUID& role_id, LLRoleData role_data)
  327. {
  328. if (mRoleChanges.find(role_id) != mRoleChanges.end())
  329. {
  330. llwarns << "create role for existing role! " << role_id << llendl;
  331. }
  332. else
  333. {
  334. role_data.mChangeType = RC_CREATE;
  335. mRoleChanges[role_id] = role_data;
  336. }
  337. }
  339. void LLGroupMgrGroupData::deleteRole(const LLUUID& role_id)
  340. {
  341. role_data_map_t::iterator it;
  343. // If this was a new role, just discard it.
  344. it = mRoleChanges.find(role_id);
  345. if (it != mRoleChanges.end() 
  346. && (*it).second.mChangeType == RC_CREATE)
  347. {
  348. mRoleChanges.erase(it);
  349. return;
  350. }
  352. LLRoleData rd;
  353. rd.mChangeType = RC_DELETE;
  354. mRoleChanges[role_id] = rd;
  355. }
  357. void LLGroupMgrGroupData::addRolePower(const LLUUID &role_id, U64 power)
  358. {
  359. LLRoleData rd;
  360. if (getRoleData(role_id,rd))
  361. {
  362. rd.mRolePowers |= power;
  363. setRoleData(role_id,rd);
  364. }
  365. else
  366. {
  367. llwarns << "addRolePower: no role data found for " << role_id << llendl;
  368. }
  369. }
  371. void LLGroupMgrGroupData::removeRolePower(const LLUUID &role_id, U64 power)
  372. {
  373. LLRoleData rd;
  374. if (getRoleData(role_id,rd))
  375. {
  376. rd.mRolePowers &= ~power;
  377. setRoleData(role_id,rd);
  378. }
  379. else
  380. {
  381. llwarns << "removeRolePower: no role data found for " << role_id << llendl;
  382. }
  383. }
  385. U64 LLGroupMgrGroupData::getRolePowers(const LLUUID& role_id)
  386. {
  387. LLRoleData rd;
  388. if (getRoleData(role_id,rd))
  389. {
  390. return rd.mRolePowers;
  391. }
  392. else
  393. {
  394. llwarns << "getRolePowers: no role data found for " << role_id << llendl;
  395. return GP_NO_POWERS;
  396. }
  397. }
  399. void LLGroupMgrGroupData::removeData()
  400. {
  401. // Remove member data first, because removeRoleData will walk the member list
  402. removeMemberData();
  403. removeRoleData();
  404. }
  406. void LLGroupMgrGroupData::removeMemberData()
  407. {
  408. for (member_list_t::iterator mi = mMembers.begin(); mi != mMembers.end(); ++mi)
  409. {
  410. delete mi->second;
  411. }
  412. mMembers.clear();
  413. mMemberDataComplete = FALSE;
  414. }
  416. void LLGroupMgrGroupData::removeRoleData()
  417. {
  418. for (member_list_t::iterator mi = mMembers.begin(); mi != mMembers.end(); ++mi)
  419. {
  420. LLGroupMemberData* data = mi->second;
  421. if (data)
  422. {
  423. data->clearRoles();
  424. }
  425. }
  427. for (role_list_t::iterator ri = mRoles.begin(); ri != mRoles.end(); ++ri)
  428. {
  429. LLGroupRoleData* data = ri->second;
  430. delete data;
  431. }
  432. mRoles.clear();
  433. mReceivedRoleMemberPairs = 0;
  434. mRoleDataComplete = FALSE;
  435. mRoleMemberDataComplete = FALSE;
  436. }
  438. void LLGroupMgrGroupData::removeRoleMemberData()
  439. {
  440. for (member_list_t::iterator mi = mMembers.begin(); mi != mMembers.end(); ++mi)
  441. {
  442. LLGroupMemberData* data = mi->second;
  443. if (data)
  444. {
  445. data->clearRoles();
  446. }
  447. }
  449. for (role_list_t::iterator ri = mRoles.begin(); ri != mRoles.end(); ++ri)
  450. {
  451. LLGroupRoleData* data = ri->second;
  452. if (data)
  453. {
  454. data->clearMembers();
  455. }
  456. }
  458. mReceivedRoleMemberPairs = 0;
  459. mRoleMemberDataComplete = FALSE;
  460. }
  462. LLGroupMgrGroupData::~LLGroupMgrGroupData()
  463. {
  464. removeData();
  465. }
  467. bool LLGroupMgrGroupData::changeRoleMember(const LLUUID& role_id, 
  468.    const LLUUID& member_id, 
  469.    LLRoleMemberChangeType rmc)
  470. {
  471. role_list_t::iterator ri = mRoles.find(role_id);
  472. member_list_t::iterator mi = mMembers.find(member_id);
  474. if (ri == mRoles.end()
  475. || mi == mMembers.end() )
  476. {
  477. if (ri == mRoles.end()) llwarns << "LLGroupMgrGroupData::changeRoleMember couldn't find role " << role_id << llendl;
  478. if (mi == mMembers.end()) llwarns << "LLGroupMgrGroupData::changeRoleMember couldn't find member " << member_id << llendl;
  479. return false;
  480. }
  482. LLGroupRoleData* grd = ri->second;
  483. LLGroupMemberData* gmd = mi->second;
  485. if (!grd || !gmd)
  486. {
  487. llwarns << "LLGroupMgrGroupData::changeRoleMember couldn't get member or role data." << llendl;
  488. return false;
  489. }
  491. if (RMC_ADD == rmc)
  492. {
  493. llinfos << " adding member to role." << llendl;
  494. grd->addMember(member_id);
  495. gmd->addRole(role_id,grd);
  497. //TODO move this into addrole function
  498. //see if they added someone to the owner role and update isOwner
  499. gmd->mIsOwner = (role_id == mOwnerRole) ? TRUE : gmd->mIsOwner;
  500. }
  501. else if (RMC_REMOVE == rmc)
  502. {
  503. llinfos << " removing member from role." << llendl;
  504. grd->removeMember(member_id);
  505. gmd->removeRole(role_id);
  507. //see if they removed someone from the owner role and update isOwner
  508. gmd->mIsOwner = (role_id == mOwnerRole) ? FALSE : gmd->mIsOwner;
  509. }
  511. lluuid_pair role_member;
  512. role_member.first = role_id;
  513. role_member.second = member_id;
  515. change_map_t::iterator it = mRoleMemberChanges.find(role_member);
  516. if (it != mRoleMemberChanges.end())
  517. {
  518. // There was already a role change for this role_member
  519. if (it->second.mChange == rmc)
  520. {
  521. // Already recorded this change?  Weird.
  522. llinfos << "Received duplicate change for "
  523. << " role: " << role_id << " member " << member_id 
  524. << " change " << (rmc == RMC_ADD ? "ADD" : "REMOVE") << llendl;
  525. }
  526. else
  527. {
  528. // The only two operations (add and remove) currently cancel each other out
  529. // If that changes this will need more logic
  530. if (rmc == RMC_NONE)
  531. {
  532. llwarns << "changeRoleMember: existing entry with 'RMC_NONE' change! This shouldn't happen." << llendl;
  533. LLRoleMemberChange rc(role_id,member_id,rmc);
  534. mRoleMemberChanges[role_member] = rc;
  535. }
  536. else
  537. {
  538. mRoleMemberChanges.erase(it);
  539. }
  540. }
  541. }
  542. else
  543. {
  544. LLRoleMemberChange rc(role_id,member_id,rmc);
  545. mRoleMemberChanges[role_member] = rc;
  546. }
  548. recalcAgentPowers(member_id);
  550. mChanged = TRUE;
  551. return true;
  552. }
  554. void LLGroupMgrGroupData::recalcAllAgentPowers()
  555. {
  556. LLGroupMemberData* gmd;
  558. for (member_list_t::iterator mit = mMembers.begin();
  559.  mit != mMembers.end(); ++mit)
  560. {
  561. gmd = mit->second;
  562. if (!gmd) continue;
  564. gmd->mAgentPowers = 0;
  565. for (LLGroupMemberData::role_list_t::iterator it = gmd->mRolesList.begin();
  566.  it != gmd->mRolesList.end(); ++it)
  567. {
  568. LLGroupRoleData* grd = (*it).second;
  569. if (!grd) continue;
  571. gmd->mAgentPowers |= grd->mRoleData.mRolePowers;
  572. }
  573. }
  574. }
  576. void LLGroupMgrGroupData::recalcAgentPowers(const LLUUID& agent_id)
  577. {
  578. member_list_t::iterator mi = mMembers.find(agent_id);
  579. if (mi == mMembers.end()) return;
  581. LLGroupMemberData* gmd = mi->second;
  583. if (!gmd) return;
  585. gmd->mAgentPowers = 0;
  586. for (LLGroupMemberData::role_list_t::iterator it = gmd->mRolesList.begin();
  587.  it != gmd->mRolesList.end(); ++it)
  588. {
  589. LLGroupRoleData* grd = (*it).second;
  590. if (!grd) continue;
  592. gmd->mAgentPowers |= grd->mRoleData.mRolePowers;
  593. }
  594. }
  596. bool packRoleUpdateMessageBlock(LLMessageSystem* msg, 
  597. const LLUUID& group_id,
  598. const LLUUID& role_id, 
  599. const LLRoleData& role_data, 
  600. bool start_message)
  601. {
  602. if (start_message)
  603. {
  604. msg->newMessage("GroupRoleUpdate");
  605. msg->nextBlock("AgentData");
  606. msg->addUUID("AgentID",gAgent.getID());
  607. msg->addUUID("SessionID",gAgent.getSessionID());
  608. msg->addUUID("GroupID",group_id);
  609. start_message = false;
  610. }
  612. msg->nextBlock("RoleData");
  613. msg->addUUID("RoleID",role_id);
  614. msg->addString("Name", role_data.mRoleName);
  615. msg->addString("Description", role_data.mRoleDescription);
  616. msg->addString("Title", role_data.mRoleTitle);
  617. msg->addU64("Powers", role_data.mRolePowers);
  618. msg->addU8("UpdateType", (U8)role_data.mChangeType);
  620. if (msg->isSendFullFast())
  621. {
  622. gAgent.sendReliableMessage();
  623. start_message = true;
  624. }
  626. return start_message;
  627. }
  629. void LLGroupMgrGroupData::sendRoleChanges()
  630. {
  631. // Commit changes locally
  632. LLGroupRoleData* grd;
  633. role_list_t::iterator role_it;
  634. LLMessageSystem* msg = gMessageSystem;
  635. bool start_message = true;
  637. bool need_role_cleanup = false;
  638. bool need_role_data = false;
  639. bool need_power_recalc = false;
  641. // Apply all changes
  642. for (role_data_map_t::iterator iter = mRoleChanges.begin();
  643.  iter != mRoleChanges.end(); )
  644. {
  645. role_data_map_t::iterator it = iter++; // safely incrament iter
  646. const LLUUID& role_id = (*it).first;
  647. const LLRoleData& role_data = (*it).second;
  649. // Commit to local data set
  650. role_it = mRoles.find((*it).first);
  651. if ( (mRoles.end() == role_it 
  652. && RC_CREATE != role_data.mChangeType)
  653. || (mRoles.end() != role_it
  654. && RC_CREATE == role_data.mChangeType))
  655. {
  656. continue;
  657. }
  659. // NOTE: role_it is valid EXCEPT for the RC_CREATE case
  660. switch (role_data.mChangeType)
  661. {
  662. case RC_CREATE:
  663. {
  664. // NOTE: role_it is NOT valid in this case
  665. grd = new LLGroupRoleData(role_id, role_data, 0);
  666. mRoles[role_id] = grd;
  667. need_role_data = true;
  668. break;
  669. }
  670. case RC_DELETE:
  671. {
  672. LLGroupRoleData* group_role_data = (*role_it).second;
  673. delete group_role_data;
  674. mRoles.erase(role_it);
  675. need_role_cleanup = true;
  676. need_power_recalc = true;
  677. break;
  678. }
  679. case RC_UPDATE_ALL:
  680. // fall through
  681. case RC_UPDATE_POWERS:
  682. need_power_recalc = true;
  683. // fall through
  684. case RC_UPDATE_DATA:
  685. // fall through
  686. default: 
  687. {
  688. LLGroupRoleData* group_role_data = (*role_it).second;
  689. group_role_data->setRoleData(role_data); // NOTE! might modify mRoleChanges!
  690. break;
  691. }
  692. }
  694. // Update dataserver
  695. start_message = packRoleUpdateMessageBlock(msg,getID(),role_id,role_data,start_message);
  696. }
  698. if (!start_message)
  699. {
  700. gAgent.sendReliableMessage();
  701. }
  703. // If we delete a role then all the role-member pairs are invalid!
  704. if (need_role_cleanup)
  705. {
  706. removeRoleMemberData();
  707. }
  709. // If we create a new role, then we need to re-fetch all the role data.
  710. if (need_role_data)
  711. {
  712. LLGroupMgr::getInstance()->sendGroupRoleDataRequest(getID());
  713. }
  715. // Clean up change lists
  716. mRoleChanges.clear();
  718. // Recalculate all the agent powers because role powers have now changed.
  719. if (need_power_recalc)
  720. {
  721. recalcAllAgentPowers();
  722. }
  723. }
  725. void LLGroupMgrGroupData::cancelRoleChanges()
  726. {
  727. // Clear out all changes!
  728. mRoleChanges.clear();
  729. }
  730. //
  731. // LLGroupMgr
  732. //
  734. LLGroupMgr::LLGroupMgr()
  735. {
  736. }
  738. LLGroupMgr::~LLGroupMgr()
  739. {
  740. clearGroups();
  741. }
  743. void LLGroupMgr::clearGroups()
  744. {
  745. std::for_each(mRoleActionSets.begin(), mRoleActionSets.end(), DeletePointer());
  746. mRoleActionSets.clear();
  747. std::for_each(mGroups.begin(), mGroups.end(), DeletePairedPointer());
  748. mGroups.clear();
  749. mObservers.clear();
  750. }
  752. void LLGroupMgr::clearGroupData(const LLUUID& group_id)
  753. {
  754. group_map_t::iterator iter = mGroups.find(group_id);
  755. if (iter != mGroups.end())
  756. {
  757. delete (*iter).second;
  758. mGroups.erase(iter);
  759. }
  760. }
  762. void LLGroupMgr::addObserver(LLGroupMgrObserver* observer) 
  763. { 
  764. if( observer->getID() != LLUUID::null )
  765. mObservers.insert(std::pair<LLUUID, LLGroupMgrObserver*>(observer->getID(), observer));
  766. }
  768. void LLGroupMgr::addObserver(const LLUUID& group_id, LLParticularGroupObserver* observer)
  769. {
  770. if(group_id.notNull() && observer)
  771. {
  772. mParticularObservers[group_id].insert(observer);
  773. }
  774. }
  776. void LLGroupMgr::removeObserver(LLGroupMgrObserver* observer)
  777. {
  778. if (!observer)
  779. {
  780. return;
  781. }
  782. observer_multimap_t::iterator it;
  783. it = mObservers.find(observer->getID());
  784. while (it != mObservers.end())
  785. {
  786. if (it->second == observer)
  787. {
  788. mObservers.erase(it);
  789. break;
  790. }
  791. else
  792. {
  793. ++it;
  794. }
  795. }
  796. }
  798. void LLGroupMgr::removeObserver(const LLUUID& group_id, LLParticularGroupObserver* observer)
  799. {
  800. if(group_id.isNull() || !observer)
  801. {
  802. return;
  803. }
  805.     observer_map_t::iterator obs_it = mParticularObservers.find(group_id);
  806.     if(obs_it == mParticularObservers.end())
  807.         return;
  809.     obs_it->second.erase(observer);
  811.     if (obs_it->second.size() == 0)
  812.      mParticularObservers.erase(obs_it);
  813. }
  815. LLGroupMgrGroupData* LLGroupMgr::getGroupData(const LLUUID& id)
  816. {
  817. group_map_t::iterator gi = mGroups.find(id);
  819. if (gi != mGroups.end())
  820. {
  821. return gi->second;
  822. }
  823. return NULL;
  824. }
  826. // Helper function for LLGroupMgr::processGroupMembersReply
  827. // This reformats date strings from MM/DD/YYYY to YYYY/MM/DD ( e.g. 1/27/2008 -> 2008/1/27 )
  828. // so that the sorter can sort by year before month before day.
  829. static void formatDateString(std::string &date_string)
  830. {
  831. using namespace boost;
  832. cmatch result;
  833. const regex expression("([0-9]{1,2})/([0-9]{1,2})/([0-9]{4})");
  834. if (regex_match(date_string.c_str(), result, expression))
  835. {
  836. std::string year = result[3];
  837. std::string month = result[1];
  838. std::string day = result[2];
  840. // ISO 8601 date format
  841. date_string = llformat("%02s/%02s/%04s", month.c_str(), day.c_str(), year.c_str());
  842. }
  843. }
  845. // static
  846. void LLGroupMgr::processGroupMembersReply(LLMessageSystem* msg, void** data)
  847. {
  848. lldebugs << "LLGroupMgr::processGroupMembersReply" << llendl;
  849. LLUUID agent_id;
  850. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );
  851. if (gAgent.getID() != agent_id)
  852. {
  853. llwarns << "Got group properties reply for another agent!" << llendl;
  854. return;
  855. }
  857. LLUUID group_id;
  858. msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_GroupID, group_id );
  860. LLUUID request_id;
  861. msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_RequestID, request_id);
  863. LLGroupMgrGroupData* group_datap = LLGroupMgr::getInstance()->createGroupData(group_id);
  864. if (group_datap->mMemberRequestID != request_id)
  865. {
  866. llwarns << "processGroupMembersReply: Received incorrect (stale?) request id" << llendl;
  867. return;
  868. }
  870. msg->getS32(_PREHASH_GroupData, "MemberCount", group_datap->mMemberCount );
  872. if (group_datap->mMemberCount > 0)
  873. {
  874. S32 contribution = 0;
  875. std::string online_status;
  876. std::string title;
  877. U64 agent_powers = 0;
  878. BOOL is_owner = FALSE;
  880. S32 num_members = msg->getNumberOfBlocksFast(_PREHASH_MemberData);
  881. for (S32 i = 0; i < num_members; i++)
  882. {
  883. LLUUID member_id;
  885. msg->getUUIDFast(_PREHASH_MemberData, _PREHASH_AgentID, member_id, i );
  886. msg->getS32(_PREHASH_MemberData, _PREHASH_Contribution, contribution, i);
  887. msg->getU64(_PREHASH_MemberData, "AgentPowers", agent_powers, i);
  888. msg->getStringFast(_PREHASH_MemberData, _PREHASH_OnlineStatus, online_status, i);
  889. msg->getString(_PREHASH_MemberData, "Title", title, i);
  890. msg->getBOOL(_PREHASH_MemberData,"IsOwner",is_owner,i);
  892. if (member_id.notNull())
  893. {
  894. formatDateString(online_status); // reformat for sorting, e.g. 12/25/2008 -> 2008/12/25
  896. //llinfos << "Member " << member_id << " has powers " << std::hex << agent_powers << std::dec << llendl;
  897. LLGroupMemberData* newdata = new LLGroupMemberData(member_id, 
  898. contribution, 
  899. agent_powers, 
  900. title,
  901. online_status,
  902. is_owner);
  903. #if LL_DEBUG
  904. LLGroupMgrGroupData::member_list_t::iterator mit = group_datap->mMembers.find(member_id);
  905. if (mit != group_datap->mMembers.end())
  906. {
  907. llinfos << " *** Received duplicate member data for agent " << member_id << llendl;
  908. }
  909. #endif
  910. group_datap->mMembers[member_id] = newdata;
  911. }
  912. else
  913. {
  914. llinfos << "Received null group member data." << llendl;
  915. }
  916. }
  918. //if group members are loaded while titles are missing, load the titles.
  919. if(group_datap->mTitles.size() < 1)
  920. {
  921. LLGroupMgr::getInstance()->sendGroupTitlesRequest(group_id);
  922. }
  923. }
  925. if (group_datap->mMembers.size() ==  (U32)group_datap->mMemberCount)
  926. {
  927. group_datap->mMemberDataComplete = TRUE;
  928. group_datap->mMemberRequestID.setNull();
  929. // We don't want to make role-member data requests until we have all the members
  930. if (group_datap->mPendingRoleMemberRequest)
  931. {
  932. group_datap->mPendingRoleMemberRequest = FALSE;
  933. LLGroupMgr::getInstance()->sendGroupRoleMembersRequest(group_datap->mID);
  934. }
  935. }
  937. group_datap->mChanged = TRUE;
  938. LLGroupMgr::getInstance()->notifyObservers(GC_MEMBER_DATA);
  939. }
  941. //static 
  942. void LLGroupMgr::processGroupPropertiesReply(LLMessageSystem* msg, void** data)
  943. {
  944. lldebugs << "LLGroupMgr::processGroupPropertiesReply" << llendl;
  945. LLUUID agent_id;
  946. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );
  947. if (gAgent.getID() != agent_id)
  948. {
  949. llwarns << "Got group properties reply for another agent!" << llendl;
  950. return;
  951. }
  953. LLUUID group_id;
  954. std::string name;
  955. std::string charter;
  956. BOOL show_in_list = FALSE;
  957. LLUUID founder_id;
  958. U64 powers_mask = GP_NO_POWERS;
  959. S32 money = 0;
  960. std::string member_title;
  961. LLUUID insignia_id;
  962. LLUUID owner_role;
  963. U32 membership_fee = 0;
  964. BOOL open_enrollment = FALSE;
  965. S32 num_group_members = 0;
  966. S32 num_group_roles = 0;
  967. BOOL allow_publish = FALSE;
  968. BOOL mature = FALSE;
  970. msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_GroupID, group_id );
  971. msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_FounderID, founder_id);
  972. msg->getStringFast(_PREHASH_GroupData, _PREHASH_Name, name );
  973. msg->getStringFast(_PREHASH_GroupData, _PREHASH_Charter, charter );
  974. msg->getBOOLFast(_PREHASH_GroupData, _PREHASH_ShowInList, show_in_list );
  975. msg->getStringFast(_PREHASH_GroupData, _PREHASH_MemberTitle, member_title );
  976. msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_InsigniaID, insignia_id );
  977. msg->getU64Fast(_PREHASH_GroupData, _PREHASH_PowersMask, powers_mask );
  978. msg->getU32Fast(_PREHASH_GroupData, _PREHASH_MembershipFee, membership_fee );
  979. msg->getBOOLFast(_PREHASH_GroupData, _PREHASH_OpenEnrollment, open_enrollment );
  980. msg->getS32Fast(_PREHASH_GroupData, _PREHASH_GroupMembershipCount, num_group_members);
  981. msg->getS32(_PREHASH_GroupData, "GroupRolesCount", num_group_roles);
  982. msg->getS32Fast(_PREHASH_GroupData, _PREHASH_Money, money);
  983. msg->getBOOL("GroupData", "AllowPublish", allow_publish);
  984. msg->getBOOL("GroupData", "MaturePublish", mature);
  985. msg->getUUID(_PREHASH_GroupData, "OwnerRole", owner_role);
  987. LLGroupMgrGroupData* group_datap = LLGroupMgr::getInstance()->createGroupData(group_id);
  989. group_datap->mName = name;
  990. group_datap->mCharter = charter;
  991. group_datap->mShowInList = show_in_list;
  992. group_datap->mInsigniaID = insignia_id;
  993. group_datap->mFounderID = founder_id;
  994. group_datap->mMembershipFee = membership_fee;
  995. group_datap->mOpenEnrollment = open_enrollment;
  996. group_datap->mAllowPublish = allow_publish;
  997. group_datap->mMaturePublish = mature;
  998. group_datap->mOwnerRole = owner_role;
  999. group_datap->mMemberCount = num_group_members;
  1000. group_datap->mRoleCount = num_group_roles + 1; // Add the everyone role.
  1002. group_datap->mGroupPropertiesDataComplete = TRUE;
  1003. group_datap->mChanged = TRUE;
  1005. LLGroupMgr::getInstance()->notifyObservers(GC_PROPERTIES);
  1006. }
  1008. // static
  1009. void LLGroupMgr::processGroupRoleDataReply(LLMessageSystem* msg, void** data)
  1010. {
  1011. lldebugs << "LLGroupMgr::processGroupRoleDataReply" << llendl;
  1012. LLUUID agent_id;
  1013. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );
  1014. if (gAgent.getID() != agent_id)
  1015. {
  1016. llwarns << "Got group properties reply for another agent!" << llendl;
  1017. return;
  1018. }
  1020. LLUUID group_id;
  1021. msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_GroupID, group_id );
  1023. LLUUID request_id;
  1024. msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_RequestID, request_id);
  1026. LLGroupMgrGroupData* group_data = LLGroupMgr::getInstance()->createGroupData(group_id);
  1027. if (group_data->mRoleDataRequestID != request_id)
  1028. {
  1029. llwarns << "processGroupRoleDataReply: Received incorrect (stale?) request id" << llendl;
  1030. return;
  1031. }
  1033. msg->getS32(_PREHASH_GroupData, "RoleCount", group_data->mRoleCount );
  1035. std::string name;
  1036. std::string title;
  1037. std::string desc;
  1038. U64 powers = 0;
  1039. U32 member_count = 0;
  1040. LLUUID role_id;
  1042. U32 num_blocks = msg->getNumberOfBlocks("RoleData");
  1043. U32 i = 0;
  1044. for (i=0; i< num_blocks; ++i)
  1045. {
  1046. msg->getUUID("RoleData", "RoleID", role_id, i );
  1048. msg->getString("RoleData","Name",name,i);
  1049. msg->getString("RoleData","Title",title,i);
  1050. msg->getString("RoleData","Description",desc,i);
  1051. msg->getU64("RoleData","Powers",powers,i);
  1052. msg->getU32("RoleData","Members",member_count,i);
  1054. lldebugs << "Adding role data: " << name << " {" << role_id << "}" << llendl;
  1055. LLGroupRoleData* rd = new LLGroupRoleData(role_id,name,title,desc,powers,member_count);
  1056. group_data->mRoles[role_id] = rd;
  1057. }
  1059. if (group_data->mRoles.size() == (U32)group_data->mRoleCount)
  1060. {
  1061. group_data->mRoleDataComplete = TRUE;
  1062. group_data->mRoleDataRequestID.setNull();
  1063. // We don't want to make role-member data requests until we have all the role data
  1064. if (group_data->mPendingRoleMemberRequest)
  1065. {
  1066. group_data->mPendingRoleMemberRequest = FALSE;
  1067. LLGroupMgr::getInstance()->sendGroupRoleMembersRequest(group_data->mID);
  1068. }
  1069. }
  1071. group_data->mChanged = TRUE;
  1072. LLGroupMgr::getInstance()->notifyObservers(GC_ROLE_DATA);
  1073. }
  1075. // static
  1076. void LLGroupMgr::processGroupRoleMembersReply(LLMessageSystem* msg, void** data)
  1077. {
  1078. lldebugs << "LLGroupMgr::processGroupRoleMembersReply" << llendl;
  1079. LLUUID agent_id;
  1080. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );
  1081. if (gAgent.getID() != agent_id)
  1082. {
  1083. llwarns << "Got group properties reply for another agent!" << llendl;
  1084. return;
  1085. }
  1087. LLUUID request_id;
  1088. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_RequestID, request_id);
  1090. LLUUID group_id;
  1091. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_GroupID, group_id );
  1093. U32 total_pairs;
  1094. msg->getU32(_PREHASH_AgentData, "TotalPairs", total_pairs);
  1096. LLGroupMgrGroupData* group_data = LLGroupMgr::getInstance()->createGroupData(group_id);
  1098. if (group_data->mRoleMembersRequestID != request_id)
  1099. {
  1100. llwarns << "processGroupRoleMembersReply: Received incorrect (stale?) role member request id" << llendl;
  1101. return;
  1102. }
  1104. U32 num_blocks = msg->getNumberOfBlocks("MemberData");
  1105. U32 i;
  1106. LLUUID member_id;
  1107. LLUUID role_id;
  1108. LLGroupRoleData* rd = NULL;
  1109. LLGroupMemberData* md = NULL;
  1111. LLGroupMgrGroupData::role_list_t::iterator ri;
  1112. LLGroupMgrGroupData::member_list_t::iterator mi;
  1114. // If total_pairs == 0, there are no members in any custom roles.
  1115. if (total_pairs > 0)
  1116. {
  1117. for (i = 0;i < num_blocks; ++i)
  1118. {
  1119. msg->getUUID("MemberData","RoleID",role_id,i);
  1120. msg->getUUID("MemberData","MemberID",member_id,i);
  1122. if (role_id.notNull() && member_id.notNull() )
  1123. {
  1124. rd = NULL;
  1125. ri = group_data->mRoles.find(role_id);
  1126. if (ri != group_data->mRoles.end())
  1127. {
  1128. rd = ri->second;
  1129. }
  1131. md = NULL;
  1132. mi = group_data->mMembers.find(member_id);
  1133. if (mi != group_data->mMembers.end())
  1134. {
  1135. md = mi->second;
  1136. }
  1138. if (rd && md)
  1139. {
  1140. lldebugs << "Adding role-member pair: " << role_id << ", " << member_id << llendl;
  1141. rd->addMember(member_id);
  1142. md->addRole(role_id,rd);
  1143. }
  1144. else
  1145. {
  1146. if (!rd) llwarns << "Received role data for unkown role " << role_id << " in group " << group_id << llendl;
  1147. if (!md) llwarns << "Received role data for unkown member " << member_id << " in group " << group_id << llendl;
  1148. }
  1149. }
  1150. }
  1152. group_data->mReceivedRoleMemberPairs += num_blocks;
  1153. }
  1155. if (group_data->mReceivedRoleMemberPairs == total_pairs)
  1156. {
  1157. // Add role data for the 'everyone' role to all members
  1158. LLGroupRoleData* everyone = group_data->mRoles[LLUUID::null];
  1159. if (!everyone)
  1160. {
  1161. llwarns << "Everyone role not found!" << llendl;
  1162. }
  1163. else
  1164. {
  1165. for (LLGroupMgrGroupData::member_list_t::iterator mi = group_data->mMembers.begin();
  1166.  mi != group_data->mMembers.end(); ++mi)
  1167. {
  1168. LLGroupMemberData* data = mi->second;
  1169. if (data)
  1170. {
  1171. data->addRole(LLUUID::null,everyone);
  1172. }
  1173. }
  1174. }
  1176.         group_data->mRoleMemberDataComplete = TRUE;
  1177. group_data->mRoleMembersRequestID.setNull();
  1178. }
  1180. group_data->mChanged = TRUE;
  1181. LLGroupMgr::getInstance()->notifyObservers(GC_ROLE_MEMBER_DATA);
  1182. }
  1184. // static
  1185. void LLGroupMgr::processGroupTitlesReply(LLMessageSystem* msg, void** data)
  1186. {
  1187. lldebugs << "LLGroupMgr::processGroupTitlesReply" << llendl;
  1188. LLUUID agent_id;
  1189. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );
  1190. if (gAgent.getID() != agent_id)
  1191. {
  1192. llwarns << "Got group properties reply for another agent!" << llendl;
  1193. return;
  1194. }
  1196. LLUUID group_id;
  1197. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_GroupID, group_id );
  1199. LLGroupMgrGroupData* group_data = LLGroupMgr::getInstance()->createGroupData(group_id);
  1201. LLUUID request_id;
  1202. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_RequestID, request_id);
  1204. if (group_data->mTitlesRequestID != request_id)
  1205. {
  1206. llwarns << "processGroupTitlesReply: Received incorrect (stale?) title request id" << llendl;
  1207. return;
  1208. }
  1210. LLGroupTitle title;
  1212. S32 i = 0;
  1213. S32 blocks = msg->getNumberOfBlocksFast(_PREHASH_GroupData);
  1214. for (i=0; i<blocks; ++i)
  1215. {
  1216. msg->getString("GroupData","Title",title.mTitle,i);
  1217. msg->getUUID("GroupData","RoleID",title.mRoleID,i);
  1218. msg->getBOOL("GroupData","Selected",title.mSelected,i);
  1220. if (!title.mTitle.empty())
  1221. {
  1222. lldebugs << "LLGroupMgr adding title: " << title.mTitle << ", " << title.mRoleID << ", " << (title.mSelected ? 'Y' : 'N') << llendl;
  1223. group_data->mTitles.push_back(title);
  1224. }
  1225. }
  1227. group_data->mChanged = TRUE;
  1228. LLGroupMgr::getInstance()->notifyObservers(GC_TITLES);
  1229. }
  1231. // static
  1232. void LLGroupMgr::processEjectGroupMemberReply(LLMessageSystem* msg, void ** data)
  1233. {
  1234. lldebugs << "processEjectGroupMemberReply" << llendl;
  1235. LLUUID group_id;
  1236. msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_GroupID, group_id);
  1237. BOOL success;
  1238. msg->getBOOLFast(_PREHASH_EjectData, _PREHASH_Success, success);
  1240. // If we had a failure, the group panel needs to be updated.
  1241. if (!success)
  1242. {
  1243. LLGroupActions::refresh(group_id);
  1244. }
  1245. }
  1247. // static
  1248. void LLGroupMgr::processJoinGroupReply(LLMessageSystem* msg, void ** data)
  1249. {
  1250. lldebugs << "processJoinGroupReply" << llendl;
  1251. LLUUID group_id;
  1252. BOOL success;
  1253. msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_GroupID, group_id);
  1254. msg->getBOOLFast(_PREHASH_GroupData, _PREHASH_Success, success);
  1256. if (success)
  1257. {
  1258. // refresh all group information
  1259. gAgent.sendAgentDataUpdateRequest();
  1261. LLGroupMgr::getInstance()->clearGroupData(group_id);
  1262. // refresh the floater for this group, if any.
  1263. LLGroupActions::refresh(group_id);
  1264. }
  1265. }
  1267. // static
  1268. void LLGroupMgr::processLeaveGroupReply(LLMessageSystem* msg, void ** data)
  1269. {
  1270. lldebugs << "processLeaveGroupReply" << llendl;
  1271. LLUUID group_id;
  1272. BOOL success;
  1273. msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_GroupID, group_id);
  1274. msg->getBOOLFast(_PREHASH_GroupData, _PREHASH_Success, success);
  1276. if (success)
  1277. {
  1278. // refresh all group information
  1279. gAgent.sendAgentDataUpdateRequest();
  1281. LLGroupMgr::getInstance()->clearGroupData(group_id);
  1282. // close the floater for this group, if any.
  1283. LLGroupActions::closeGroup(group_id);
  1284. }
  1285. }
  1287. // static
  1288. void LLGroupMgr::processCreateGroupReply(LLMessageSystem* msg, void ** data)
  1289. {
  1290. LLUUID group_id;
  1291. BOOL success;
  1292. std::string message;
  1294. msg->getUUIDFast(_PREHASH_ReplyData, _PREHASH_GroupID, group_id );
  1296. msg->getBOOLFast(_PREHASH_ReplyData, _PREHASH_Success, success );
  1297. msg->getStringFast(_PREHASH_ReplyData, _PREHASH_Message, message );
  1299. if (success)
  1300. {
  1301. // refresh all group information
  1302. gAgent.sendAgentDataUpdateRequest();
  1304. // HACK! We haven't gotten the agent group update yet, so ... um ... fake it.
  1305. // This is so when we go to modify the group we will be able to do so.
  1306. // This isn't actually too bad because real data will come down in 2 or 3 miliseconds and replace this.
  1307. LLGroupData gd;
  1308. gd.mAcceptNotices = TRUE;
  1309. gd.mListInProfile = TRUE;
  1310. gd.mContribution = 0;
  1311. gd.mID = group_id;
  1312. gd.mName = "new group";
  1313. gd.mPowers = GP_ALL_POWERS;
  1315. gAgent.mGroups.push_back(gd);
  1317. LLPanelGroup::refreshCreatedGroup(group_id);
  1318. //FIXME
  1319. //LLFloaterGroupInfo::closeCreateGroup();
  1320. //LLFloaterGroupInfo::showFromUUID(group_id,"roles_tab");
  1321. }
  1322. else
  1323. {
  1324. // *TODO: Translate
  1325. LLSD args;
  1326. args["MESSAGE"] = message;
  1327. LLNotificationsUtil::add("UnableToCreateGroup", args);
  1328. }
  1329. }
  1331. LLGroupMgrGroupData* LLGroupMgr::createGroupData(const LLUUID& id)
  1332. {
  1333. LLGroupMgrGroupData* group_datap;
  1335. group_map_t::iterator existing_group = LLGroupMgr::getInstance()->mGroups.find(id);
  1336. if (existing_group == LLGroupMgr::getInstance()->mGroups.end())
  1337. {
  1338. group_datap = new LLGroupMgrGroupData(id);
  1339. LLGroupMgr::getInstance()->addGroup(group_datap);
  1340. }
  1341. else
  1342. {
  1343. group_datap = existing_group->second;
  1344. }
  1346. return group_datap;
  1347. }
  1349. void LLGroupMgr::notifyObservers(LLGroupChange gc)
  1350. {
  1351. for (group_map_t::iterator gi = mGroups.begin(); gi != mGroups.end(); ++gi)
  1352. {
  1353. LLUUID group_id = gi->first;
  1354. if (gi->second->mChanged)
  1355. {
  1356. // notify LLGroupMgrObserver
  1357. // Copy the map because observers may remove themselves on update
  1358. observer_multimap_t observers = mObservers;
  1360. // find all observers for this group id
  1361. observer_multimap_t::iterator oi = observers.lower_bound(group_id);
  1362. observer_multimap_t::iterator end = observers.upper_bound(group_id);
  1363. for (; oi != end; ++oi)
  1364. {
  1365. oi->second->changed(gc);
  1366. }
  1367. gi->second->mChanged = FALSE;
  1370. // notify LLParticularGroupObserver
  1371.     observer_map_t::iterator obs_it = mParticularObservers.find(group_id);
  1372.     if(obs_it == mParticularObservers.end())
  1373.         return;
  1375.     observer_set_t& obs = obs_it->second;
  1376.     for (observer_set_t::iterator ob_it = obs.begin(); ob_it != obs.end(); ++ob_it)
  1377.     {
  1378.         (*ob_it)->changed(group_id, gc);
  1379.     }
  1380. }
  1381. }
  1382. }
  1384. void LLGroupMgr::addGroup(LLGroupMgrGroupData* group_datap)
  1385. {
  1386. if (mGroups.size() > MAX_CACHED_GROUPS)
  1387. {
  1388. // get rid of groups that aren't observed
  1389. for (group_map_t::iterator gi = mGroups.begin(); gi != mGroups.end() && mGroups.size() > MAX_CACHED_GROUPS / 2; )
  1390. {
  1391. observer_multimap_t::iterator oi = mObservers.find(gi->first);
  1392. if (oi == mObservers.end())
  1393. {
  1394. // not observed
  1395. LLGroupMgrGroupData* unobserved_groupp = gi->second;
  1396. delete unobserved_groupp;
  1397. mGroups.erase(gi++);
  1398. }
  1399. else
  1400. {
  1401. ++gi;
  1402. }
  1403. }
  1404. }
  1405. mGroups[group_datap->getID()] = group_datap;
  1406. }
  1409. void LLGroupMgr::sendGroupPropertiesRequest(const LLUUID& group_id)
  1410. {
  1411. lldebugs << "LLGroupMgr::sendGroupPropertiesRequest" << llendl;
  1412. // This will happen when we get the reply
  1413. //LLGroupMgrGroupData* group_datap = createGroupData(group_id);
  1415. LLMessageSystem* msg = gMessageSystem;
  1416. msg->newMessage("GroupProfileRequest");
  1417. msg->nextBlock("AgentData");
  1418. msg->addUUID("AgentID",gAgent.getID());
  1419. msg->addUUID("SessionID",gAgent.getSessionID());
  1420. msg->nextBlock("GroupData");
  1421. msg->addUUID("GroupID",group_id);
  1422. gAgent.sendReliableMessage();
  1423. }
  1425. void LLGroupMgr::sendGroupMembersRequest(const LLUUID& group_id)
  1426. {
  1427. lldebugs << "LLGroupMgr::sendGroupMembersRequest" << llendl;
  1428. LLGroupMgrGroupData* group_datap = createGroupData(group_id);
  1429. if (group_datap->mMemberRequestID.isNull())
  1430. {
  1431. group_datap->removeMemberData();
  1432. group_datap->mMemberRequestID.generate();
  1434. LLMessageSystem* msg = gMessageSystem;
  1435. msg->newMessage("GroupMembersRequest");
  1436. msg->nextBlock("AgentData");
  1437. msg->addUUID("AgentID",gAgent.getID());
  1438. msg->addUUID("SessionID",gAgent.getSessionID());
  1439. msg->nextBlock("GroupData");
  1440. msg->addUUID("GroupID",group_id);
  1441. msg->addUUID("RequestID",group_datap->mMemberRequestID);
  1442. gAgent.sendReliableMessage();
  1443. }
  1444. }
  1446. void LLGroupMgr::sendGroupRoleDataRequest(const LLUUID& group_id)
  1447. {
  1448. lldebugs << "LLGroupMgr::sendGroupRoleDataRequest" << llendl;
  1449. LLGroupMgrGroupData* group_datap = createGroupData(group_id);
  1450. if (group_datap->mRoleDataRequestID.isNull())
  1451. {
  1452. group_datap->removeRoleData();
  1453. group_datap->mRoleDataRequestID.generate();
  1455. LLMessageSystem* msg = gMessageSystem;
  1456. msg->newMessage("GroupRoleDataRequest");
  1457. msg->nextBlock("AgentData");
  1458. msg->addUUID("AgentID",gAgent.getID());
  1459. msg->addUUID("SessionID",gAgent.getSessionID());
  1460. msg->nextBlock("GroupData");
  1461. msg->addUUID("GroupID",group_id);
  1462. msg->addUUID("RequestID",group_datap->mRoleDataRequestID);
  1463. gAgent.sendReliableMessage();
  1464. }
  1465. }
  1467. void LLGroupMgr::sendGroupRoleMembersRequest(const LLUUID& group_id)
  1468. {
  1469. lldebugs << "LLGroupMgr::sendGroupRoleMembersRequest" << llendl;
  1470. LLGroupMgrGroupData* group_datap = createGroupData(group_id);
  1472. if (group_datap->mRoleMembersRequestID.isNull())
  1473. {
  1474. // Don't send the request if we don't have all the member or role data
  1475. if (!group_datap->isMemberDataComplete()
  1476. || !group_datap->isRoleDataComplete())
  1477. {
  1478. // *TODO: KLW FIXME: Should we start a member or role data request?
  1479. llinfos << " Pending: " << (group_datap->mPendingRoleMemberRequest ? "Y" : "N")
  1480. << " MemberDataComplete: " << (group_datap->mMemberDataComplete ? "Y" : "N")
  1481. << " RoleDataComplete: " << (group_datap->mRoleDataComplete ? "Y" : "N") << llendl;
  1482. group_datap->mPendingRoleMemberRequest = TRUE;
  1483. return;
  1484. }
  1486. group_datap->removeRoleMemberData();
  1487. group_datap->mRoleMembersRequestID.generate();
  1489. LLMessageSystem* msg = gMessageSystem;
  1490. msg->newMessage("GroupRoleMembersRequest");
  1491. msg->nextBlock("AgentData");
  1492. msg->addUUID("AgentID",gAgent.getID());
  1493. msg->addUUID("SessionID",gAgent.getSessionID());
  1494. msg->nextBlock("GroupData");
  1495. msg->addUUID("GroupID",group_id);
  1496. msg->addUUID("RequestID",group_datap->mRoleMembersRequestID);
  1497. gAgent.sendReliableMessage();
  1498. }
  1499. }
  1501. void LLGroupMgr::sendGroupTitlesRequest(const LLUUID& group_id)
  1502. {
  1503. lldebugs << "LLGroupMgr::sendGroupTitlesRequest" << llendl;
  1504. LLGroupMgrGroupData* group_datap = createGroupData(group_id);
  1506. group_datap->mTitles.clear();
  1507. group_datap->mTitlesRequestID.generate();
  1509. LLMessageSystem* msg = gMessageSystem;
  1510. msg->newMessage("GroupTitlesRequest");
  1511. msg->nextBlock("AgentData");
  1512. msg->addUUID("AgentID",gAgent.getID());
  1513. msg->addUUID("SessionID",gAgent.getSessionID());
  1514. msg->addUUID("GroupID",group_id);
  1515. msg->addUUID("RequestID",group_datap->mTitlesRequestID);
  1517. gAgent.sendReliableMessage();
  1518. }
  1520. void LLGroupMgr::sendGroupTitleUpdate(const LLUUID& group_id, const LLUUID& title_role_id)
  1521. {
  1522. lldebugs << "LLGroupMgr::sendGroupTitleUpdate" << llendl;
  1524. LLMessageSystem* msg = gMessageSystem;
  1525. msg->newMessage("GroupTitleUpdate");
  1526. msg->nextBlock("AgentData");
  1527. msg->addUUID("AgentID",gAgent.getID());
  1528. msg->addUUID("SessionID",gAgent.getSessionID());
  1529. msg->addUUID("GroupID",group_id);
  1530. msg->addUUID("TitleRoleID",title_role_id);
  1532. gAgent.sendReliableMessage();
  1534. // Save the change locally
  1535. LLGroupMgrGroupData* group_datap = createGroupData(group_id);
  1536. for (std::vector<LLGroupTitle>::iterator iter = group_datap->mTitles.begin();
  1537.  iter != group_datap->mTitles.end(); ++iter)
  1538. {
  1539. if (iter->mRoleID == title_role_id)
  1540. {
  1541. iter->mSelected = TRUE;
  1542. }
  1543. else if (iter->mSelected)
  1544. {
  1545. iter->mSelected = FALSE;
  1546. }
  1547. }
  1548. }
  1550. // static
  1551. void LLGroupMgr::sendCreateGroupRequest(const std::string& name,
  1552. const std::string& charter,
  1553. U8 show_in_list,
  1554. const LLUUID& insignia,
  1555. S32 membership_fee,
  1556. BOOL open_enrollment,
  1557. BOOL allow_publish,
  1558. BOOL mature_publish)
  1559. {
  1560. LLMessageSystem* msg = gMessageSystem;
  1561. msg->newMessage("CreateGroupRequest");
  1562. msg->nextBlock("AgentData");
  1563. msg->addUUID("AgentID",gAgent.getID());
  1564. msg->addUUID("SessionID",gAgent.getSessionID());
  1566. msg->nextBlock("GroupData");
  1567. msg->addString("Name",name);
  1568. msg->addString("Charter",charter);
  1569. msg->addBOOL("ShowInList",show_in_list);
  1570. msg->addUUID("InsigniaID",insignia);
  1571. msg->addS32("MembershipFee",membership_fee);
  1572. msg->addBOOL("OpenEnrollment",open_enrollment);
  1573. msg->addBOOL("AllowPublish",allow_publish);
  1574. msg->addBOOL("MaturePublish",mature_publish);
  1576. gAgent.sendReliableMessage();
  1577. }
  1579. void LLGroupMgr::sendUpdateGroupInfo(const LLUUID& group_id)
  1580. {
  1581. lldebugs << "LLGroupMgr::sendUpdateGroupInfo" << llendl;
  1582. LLGroupMgrGroupData* group_datap = createGroupData(group_id);
  1584. LLMessageSystem* msg = gMessageSystem;
  1586. msg->newMessageFast(_PREHASH_UpdateGroupInfo);
  1587. msg->nextBlockFast(_PREHASH_AgentData);
  1588. msg->addUUIDFast(_PREHASH_AgentID,gAgent.getID());
  1589. msg->addUUIDFast(_PREHASH_SessionID,gAgent.getSessionID());
  1591. msg->nextBlockFast(_PREHASH_GroupData);
  1592. msg->addUUIDFast(_PREHASH_GroupID,group_datap->getID());
  1593. msg->addStringFast(_PREHASH_Charter,group_datap->mCharter);
  1594. msg->addBOOLFast(_PREHASH_ShowInList,group_datap->mShowInList);
  1595. msg->addUUIDFast(_PREHASH_InsigniaID,group_datap->mInsigniaID);
  1596. msg->addS32Fast(_PREHASH_MembershipFee,group_datap->mMembershipFee);
  1597. msg->addBOOLFast(_PREHASH_OpenEnrollment,group_datap->mOpenEnrollment);
  1598. msg->addBOOLFast(_PREHASH_AllowPublish,group_datap->mAllowPublish);
  1599. msg->addBOOLFast(_PREHASH_MaturePublish,group_datap->mMaturePublish);
  1601. gAgent.sendReliableMessage();
  1603. // Not expecting a response, so let anyone else watching know the data has changed.
  1604. group_datap->mChanged = TRUE;
  1605. notifyObservers(GC_PROPERTIES);
  1606. }
  1608. void LLGroupMgr::sendGroupRoleMemberChanges(const LLUUID& group_id)
  1609. {
  1610. lldebugs << "LLGroupMgr::sendGroupRoleMemberChanges" << llendl;
  1611. LLGroupMgrGroupData* group_datap = createGroupData(group_id);
  1613. if (group_datap->mRoleMemberChanges.empty()) return;
  1615. LLMessageSystem* msg = gMessageSystem;
  1617. bool start_message = true;
  1618. for (LLGroupMgrGroupData::change_map_t::const_iterator citer = group_datap->mRoleMemberChanges.begin();
  1619.  citer != group_datap->mRoleMemberChanges.end(); ++citer)
  1620. {
  1621. if (start_message)
  1622. {
  1623. msg->newMessage("GroupRoleChanges");
  1624. msg->nextBlockFast(_PREHASH_AgentData);
  1625. msg->addUUIDFast(_PREHASH_AgentID,gAgent.getID());
  1626. msg->addUUIDFast(_PREHASH_SessionID,gAgent.getSessionID());
  1627. msg->addUUIDFast(_PREHASH_GroupID,group_id);
  1628. start_message = false;
  1629. }
  1630. msg->nextBlock("RoleChange");
  1631. msg->addUUID("RoleID",citer->second.mRole);
  1632. msg->addUUID("MemberID",citer->second.mMember);
  1633. msg->addU32("Change",(U32)citer->second.mChange);
  1635. if (msg->isSendFullFast())
  1636. {
  1637. gAgent.sendReliableMessage();
  1638. start_message = true;
  1639. }
  1640. }
  1642. if (!start_message)
  1643. {
  1644. gAgent.sendReliableMessage();
  1645. }
  1647. group_datap->mRoleMemberChanges.clear();
  1649. // Not expecting a response, so let anyone else watching know the data has changed.
  1650. group_datap->mChanged = TRUE;
  1651. notifyObservers(GC_ROLE_MEMBER_DATA);
  1652. }
  1654. //static
  1655. void LLGroupMgr::sendGroupMemberJoin(const LLUUID& group_id)
  1656. {
  1657. LLMessageSystem *msg = gMessageSystem;
  1659. msg->newMessageFast(_PREHASH_JoinGroupRequest);
  1660. msg->nextBlockFast(_PREHASH_AgentData);
  1661. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1662. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1663. msg->nextBlockFast(_PREHASH_GroupData);
  1664. msg->addUUIDFast(_PREHASH_GroupID, group_id);
  1666. gAgent.sendReliableMessage();
  1667. }
  1669. // member_role_pairs is <member_id,role_id>
  1670. // static
  1671. void LLGroupMgr::sendGroupMemberInvites(const LLUUID& group_id, std::map<LLUUID,LLUUID>& member_role_pairs)
  1672. {
  1673. bool start_message = true;
  1674. LLMessageSystem* msg = gMessageSystem;
  1676. for (std::map<LLUUID,LLUUID>::iterator it = member_role_pairs.begin();
  1677.  it != member_role_pairs.end(); ++it)
  1678. {
  1679. if (start_message)
  1680. {
  1681. msg->newMessage("InviteGroupRequest");
  1682. msg->nextBlock("AgentData");
  1683. msg->addUUID("AgentID",gAgent.getID());
  1684. msg->addUUID("SessionID",gAgent.getSessionID());
  1685. msg->nextBlock("GroupData");
  1686. msg->addUUID("GroupID",group_id);
  1687. start_message = false;
  1688. }
  1690. msg->nextBlock("InviteData");
  1691. msg->addUUID("InviteeID",(*it).first);
  1692. msg->addUUID("RoleID",(*it).second);
  1694. if (msg->isSendFull())
  1695. {
  1696. gAgent.sendReliableMessage();
  1697. start_message = true;
  1698. }
  1699. }
  1701. if (!start_message)
  1702. {
  1703. gAgent.sendReliableMessage();
  1704. }
  1705. }
  1707. //static
  1708. void LLGroupMgr::sendGroupMemberEjects(const LLUUID& group_id,
  1709.    std::vector<LLUUID>& member_ids)
  1710. {
  1711. bool start_message = true;
  1712. LLMessageSystem* msg = gMessageSystem;
  1716. LLGroupMgrGroupData* group_datap = LLGroupMgr::getInstance()->getGroupData(group_id);
  1717. if (!group_datap) return;
  1719. for (std::vector<LLUUID>::iterator it = member_ids.begin();
  1720.  it != member_ids.end(); ++it)
  1721. {
  1722. LLUUID& ejected_member_id = (*it);
  1724. // Can't use 'eject' to leave a group.
  1725. if (ejected_member_id == gAgent.getID()) continue;
  1727. // Make sure they are in the group, and we need the member data
  1728. LLGroupMgrGroupData::member_list_t::iterator mit = group_datap->mMembers.find(ejected_member_id);
  1729. if (mit != group_datap->mMembers.end())
  1730. {
  1731. LLGroupMemberData* member_data = (*mit).second;
  1732. // Add them to the message
  1733. if (start_message)
  1734. {
  1735. msg->newMessage("EjectGroupMemberRequest");
  1736. msg->nextBlock("AgentData");
  1737. msg->addUUID("AgentID",gAgent.getID());
  1738. msg->addUUID("SessionID",gAgent.getSessionID());
  1739. msg->nextBlock("GroupData");
  1740. msg->addUUID("GroupID",group_id);
  1741. start_message = false;
  1742. }
  1744. msg->nextBlock("EjectData");
  1745. msg->addUUID("EjecteeID",ejected_member_id);
  1747. if (msg->isSendFull())
  1748. {
  1749. gAgent.sendReliableMessage();
  1750. start_message = true;
  1751. }
  1753. // Clean up groupmgr
  1754. for (LLGroupMemberData::role_list_t::iterator rit = member_data->roleBegin();
  1755.  rit != member_data->roleEnd(); ++rit)
  1756. {
  1757. if ((*rit).first.notNull() && (*rit).second!=0)
  1758. {
  1759. (*rit).second->removeMember(ejected_member_id);
  1760. }
  1761. }
  1763. group_datap->mMembers.erase(ejected_member_id);
  1765. delete member_data;
  1766. }
  1767. }
  1769. if (!start_message)
  1770. {
  1771. gAgent.sendReliableMessage();
  1772. }
  1773. }
  1775. void LLGroupMgr::sendGroupRoleChanges(const LLUUID& group_id)
  1776. {
  1777. lldebugs << "LLGroupMgr::sendGroupRoleChanges" << llendl;
  1778. LLGroupMgrGroupData* group_datap = getGroupData(group_id);
  1780. if (group_datap && group_datap->pendingRoleChanges())
  1781. {
  1782. group_datap->sendRoleChanges();
  1784. // Not expecting a response, so let anyone else watching know the data has changed.
  1785. group_datap->mChanged = TRUE;
  1786. notifyObservers(GC_ROLE_DATA);
  1787. }
  1788. }
  1790. void LLGroupMgr::cancelGroupRoleChanges(const LLUUID& group_id)
  1791. {
  1792. lldebugs << "LLGroupMgr::cancelGroupRoleChanges" << llendl;
  1793. LLGroupMgrGroupData* group_datap = getGroupData(group_id);
  1795. if (group_datap) group_datap->cancelRoleChanges();
  1796. }
  1798. //static
  1799. bool LLGroupMgr::parseRoleActions(const std::string& xml_filename)
  1800. {
  1801. LLXMLNodePtr root;
  1803. BOOL success = LLUICtrlFactory::getLayeredXMLNode(xml_filename, root);
  1805. if (!success || !root || !root->hasName( "role_actions" ))
  1806. {
  1807. llerrs << "Problem reading UI role_actions file: " << xml_filename << llendl;
  1808. return false;
  1809. }
  1811. LLXMLNodeList role_list;
  1813. root->getChildren("action_set", role_list, false);
  1815. for (LLXMLNodeList::iterator role_iter = role_list.begin(); role_iter != role_list.end(); ++role_iter)
  1816. {
  1817. LLXMLNodePtr action_set = role_iter->second;
  1819. LLRoleActionSet* role_action_set = new LLRoleActionSet();
  1820. LLRoleAction* role_action_data = new LLRoleAction();
  1822. // name=
  1823. std::string action_set_name;
  1824. if (action_set->getAttributeString("name", action_set_name))
  1825. {
  1826. lldebugs << "Loading action set " << action_set_name << llendl;
  1827. role_action_data->mName = action_set_name;
  1828. }
  1829. else
  1830. {
  1831. llwarns << "Unable to parse action set with no name" << llendl;
  1832. delete role_action_set;
  1833. delete role_action_data;
  1834. continue;
  1835. }
  1836. // description=
  1837. std::string set_description;
  1838. if (action_set->getAttributeString("description", set_description))
  1839. {
  1840. role_action_data->mDescription = set_description;
  1841. }
  1842. // long description=
  1843. std::string set_longdescription;
  1844. if (action_set->getAttributeString("longdescription", set_longdescription))
  1845. {
  1846. role_action_data->mLongDescription = set_longdescription;
  1847. }
  1849. // power mask=
  1850. U64 set_power_mask = 0;
  1852. LLXMLNodeList action_list;
  1853. LLXMLNodeList::iterator action_iter;
  1855. action_set->getChildren("action", action_list, false);
  1857. for (action_iter = action_list.begin(); action_iter != action_list.end(); ++action_iter)
  1858. {
  1859. LLXMLNodePtr action = action_iter->second;
  1861. LLRoleAction* role_action = new LLRoleAction();
  1863. // name=
  1864. std::string action_name;
  1865. if (action->getAttributeString("name", action_name))
  1866. {
  1867. lldebugs << "Loading action " << action_name << llendl;
  1868. role_action->mName = action_name;
  1869. }
  1870. else
  1871. {
  1872. llwarns << "Unable to parse action with no name" << llendl;
  1873. delete role_action;
  1874. continue;
  1875. }
  1876. // description=
  1877. std::string description;
  1878. if (action->getAttributeString("description", description))
  1879. {
  1880. role_action->mDescription = description;
  1881. }
  1882. // long description=
  1883. std::string longdescription;
  1884. if (action->getAttributeString("longdescription", longdescription))
  1885. {
  1886. role_action->mLongDescription = longdescription;
  1887. }
  1888. // description=
  1889. S32 power_bit = 0;
  1890. if (action->getAttributeS32("value", power_bit))
  1891. {
  1892. if (0 <= power_bit && power_bit < 64)
  1893. {
  1894. role_action->mPowerBit = 0x1LL << power_bit;
  1895. }
  1896. }
  1898. set_power_mask |= role_action->mPowerBit;
  1900. role_action_set->mActions.push_back(role_action);
  1901. }
  1903. role_action_data->mPowerBit = set_power_mask;
  1904. role_action_set->mActionSetData = role_action_data;
  1906. LLGroupMgr::getInstance()->mRoleActionSets.push_back(role_action_set);
  1907. }
  1908. return true;
  1909. }
  1911. // static
  1912. void LLGroupMgr::debugClearAllGroups(void*)
  1913. {
  1914. LLGroupMgr::getInstance()->clearGroups();
  1915. LLGroupMgr::parseRoleActions("role_actions.xml");
  1916. }