WebSVN – opensim-development – Blame – Rev 1 – /OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/XmlRpcGroupsServicesConnectorModule.cs

        /// Create a Group, including Everyone and Owners Role, place FounderID in both groups, select Owner as selected role, and newly created group as agent's active role.

251

/// </summary>

252

public UUID CreateGroup(UUID requestingAgentID, string name, string charter, bool showInList, UUID insigniaID,

253

int membershipFee, bool openEnrollment, bool allowPublish,

254

bool maturePublish, UUID founderID)

255

{

256

UUID GroupID = UUID.Random();

257

UUID OwnerRoleID = UUID.Random();

258

259

Hashtable param = new Hashtable();

260

param["GroupID"] = GroupID.ToString();

261

param["Name"] = name;

262

param["Charter"] = charter;

263

param["ShowInList"] = showInList == true ? 1 : 0;

264

param["InsigniaID"] = insigniaID.ToString();

265

param["MembershipFee"] = membershipFee;

266

param["OpenEnrollment"] = openEnrollment == true ? 1 : 0;

267

param["AllowPublish"] = allowPublish == true ? 1 : 0;

268

param["MaturePublish"] = maturePublish == true ? 1 : 0;

269

param["FounderID"] = founderID.ToString();

270

param["EveryonePowers"] = ((ulong)DefaultEveryonePowers).ToString();

271

param["OwnerRoleID"] = OwnerRoleID.ToString();

272

param["OwnersPowers"] = ((ulong)DefaultOwnerPowers).ToString();

273

274

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.createGroup", param);

275

276

if (respData.Contains("error"))

277

{

278

// UUID is not nullable

return UUID.Zero;

}

return UUID.Parse((string)respData["GroupID"]);

284

}

285

286

public void UpdateGroup(UUID requestingAgentID, UUID groupID, string charter, bool showInList,

287

UUID insigniaID, int membershipFee, bool openEnrollment,

288

bool allowPublish, bool maturePublish)

289

{

290

Hashtable param = new Hashtable();

291

param["GroupID"] = groupID.ToString();

292

param["Charter"] = charter;

293

param["ShowInList"] = showInList == true ? 1 : 0;

294

param["InsigniaID"] = insigniaID.ToString();

295

param["MembershipFee"] = membershipFee;

296

param["OpenEnrollment"] = openEnrollment == true ? 1 : 0;

297

param["AllowPublish"] = allowPublish == true ? 1 : 0;

298

param["MaturePublish"] = maturePublish == true ? 1 : 0;

299

300

XmlRpcCall(requestingAgentID, "groups.updateGroup", param);

301

}

302

303

public void AddGroupRole(UUID requestingAgentID, UUID groupID, UUID roleID, string name, string description,

304

string title, ulong powers)

305

{

306

Hashtable param = new Hashtable();

307

param["GroupID"] = groupID.ToString();

308

param["RoleID"] = roleID.ToString();

309

param["Name"] = name;

310

param["Description"] = description;

311

param["Title"] = title;

312

param["Powers"] = powers.ToString();

313

314

XmlRpcCall(requestingAgentID, "groups.addRoleToGroup", param);

315

}

316

317

public void RemoveGroupRole(UUID requestingAgentID, UUID groupID, UUID roleID)

318

{

319

Hashtable param = new Hashtable();

320

param["GroupID"] = groupID.ToString();

321

param["RoleID"] = roleID.ToString();

322

323

XmlRpcCall(requestingAgentID, "groups.removeRoleFromGroup", param);

324

}

325

326

public void UpdateGroupRole(UUID requestingAgentID, UUID groupID, UUID roleID, string name, string description,

327

string title, ulong powers)

328

{

329

Hashtable param = new Hashtable();

330

param["GroupID"] = groupID.ToString();

331

param["RoleID"] = roleID.ToString();

332

if (name != null)

333

{

334

param["Name"] = name;

335

}

336

if (description != null)

337

{

338

param["Description"] = description;

}

if (title != null)

{

param["Title"] = title;

343

}

344

param["Powers"] = powers.ToString();

345

346

XmlRpcCall(requestingAgentID, "groups.updateGroupRole", param);

347

}

348

349

public GroupRecord GetGroupRecord(UUID requestingAgentID, UUID GroupID, string GroupName)

350

{

351

Hashtable param = new Hashtable();

352

if (GroupID != UUID.Zero)

353

{

354

param["GroupID"] = GroupID.ToString();

355

}

356

if (!string.IsNullOrEmpty(GroupName))

357

{

358

param["Name"] = GroupName.ToString();

359

}

360

361

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroup", param);

362

363

if (respData.Contains("error"))

{

return null;

}

return GroupProfileHashtableToGroupRecord(respData);

}

public GroupProfileData GetMemberGroupProfile(UUID requestingAgentID, UUID GroupID, UUID AgentID)

373

{

374

Hashtable param = new Hashtable();

375

param["GroupID"] = GroupID.ToString();

376

377

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroup", param);

378

379

if (respData.Contains("error"))

380

{

381

// GroupProfileData is not nullable

382

return new GroupProfileData();

383

}

384

385

GroupMembershipData MemberInfo = GetAgentGroupMembership(requestingAgentID, AgentID, GroupID);

386

GroupProfileData MemberGroupProfile = GroupProfileHashtableToGroupProfileData(respData);

387

388

MemberGroupProfile.MemberTitle = MemberInfo.GroupTitle;

389

MemberGroupProfile.PowersMask = MemberInfo.GroupPowers;

390

391

return MemberGroupProfile;

392

}

393

394

public void SetAgentActiveGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID)

395

{

396

Hashtable param = new Hashtable();

397

param["AgentID"] = AgentID.ToString();

398

param["GroupID"] = GroupID.ToString();

399

400

XmlRpcCall(requestingAgentID, "groups.setAgentActiveGroup", param);

401

}

402

403

public void SetAgentActiveGroupRole(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)

404

{

405

Hashtable param = new Hashtable();

406

param["AgentID"] = AgentID.ToString();

407

param["GroupID"] = GroupID.ToString();

408

param["SelectedRoleID"] = RoleID.ToString();

409

410

XmlRpcCall(requestingAgentID, "groups.setAgentGroupInfo", param);

411

}

412

413

        public void SetAgentGroupInfo(UUID requestingAgentID, UUID AgentID, UUID GroupID, bool AcceptNotices, bool ListInProfile)

414

{

415

Hashtable param = new Hashtable();

416

param["AgentID"] = AgentID.ToString();

417

param["GroupID"] = GroupID.ToString();

418

param["AcceptNotices"] = AcceptNotices ? "1" : "0";

419

param["ListInProfile"] = ListInProfile ? "1" : "0";

420

421

XmlRpcCall(requestingAgentID, "groups.setAgentGroupInfo", param);

}

        public void AddAgentToGroupInvite(UUID requestingAgentID, UUID inviteID, UUID groupID, UUID roleID, UUID agentID)

426

{

427

Hashtable param = new Hashtable();

428

param["InviteID"] = inviteID.ToString();

429

param["AgentID"] = agentID.ToString();

430

param["RoleID"] = roleID.ToString();

431

param["GroupID"] = groupID.ToString();

432

433

XmlRpcCall(requestingAgentID, "groups.addAgentToGroupInvite", param);

}

public GroupInviteInfo GetAgentToGroupInvite(UUID requestingAgentID, UUID inviteID)

438

{

439

Hashtable param = new Hashtable();

440

param["InviteID"] = inviteID.ToString();

441

442

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentToGroupInvite", param);

443

444

if (respData.Contains("error"))

{

return null;

}

GroupInviteInfo inviteInfo = new GroupInviteInfo();

450

inviteInfo.InviteID = inviteID;

451

inviteInfo.GroupID = UUID.Parse((string)respData["GroupID"]);

452

inviteInfo.RoleID = UUID.Parse((string)respData["RoleID"]);

453

inviteInfo.AgentID = UUID.Parse((string)respData["AgentID"]);

return inviteInfo;

}

public void RemoveAgentToGroupInvite(UUID requestingAgentID, UUID inviteID)

459

{

460

Hashtable param = new Hashtable();

461

param["InviteID"] = inviteID.ToString();

462

463

XmlRpcCall(requestingAgentID, "groups.removeAgentToGroupInvite", param);

464

}

465

466

public void AddAgentToGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)

467

{

468

Hashtable param = new Hashtable();

469

param["AgentID"] = AgentID.ToString();

470

param["GroupID"] = GroupID.ToString();

471

param["RoleID"] = RoleID.ToString();

472

473

XmlRpcCall(requestingAgentID, "groups.addAgentToGroup", param);

474

}

475

476

public void RemoveAgentFromGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID)

477

{

478

Hashtable param = new Hashtable();

479

param["AgentID"] = AgentID.ToString();

480

param["GroupID"] = GroupID.ToString();

481

482

XmlRpcCall(requestingAgentID, "groups.removeAgentFromGroup", param);

483

}

484

485

public void AddAgentToGroupRole(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)

486

{

487

Hashtable param = new Hashtable();

488

param["AgentID"] = AgentID.ToString();

489

param["GroupID"] = GroupID.ToString();

490

param["RoleID"] = RoleID.ToString();

491

492

XmlRpcCall(requestingAgentID, "groups.addAgentToGroupRole", param);

493

}

494

495

public void RemoveAgentFromGroupRole(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)

496

{

497

Hashtable param = new Hashtable();

498

param["AgentID"] = AgentID.ToString();

499

param["GroupID"] = GroupID.ToString();

500

param["RoleID"] = RoleID.ToString();

501

502

XmlRpcCall(requestingAgentID, "groups.removeAgentFromGroupRole", param);

503

}

504

505

public List<DirGroupsReplyData> FindGroups(UUID requestingAgentID, string search)

506

{

507

Hashtable param = new Hashtable();

508

param["Search"] = search;

509

510

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.findGroups", param);

511

512

List<DirGroupsReplyData> findings = new List<DirGroupsReplyData>();

513

514

if (!respData.Contains("error"))

515

{

516

Hashtable results = (Hashtable)respData["results"];

517

foreach (Hashtable groupFind in results.Values)

518

{

519

DirGroupsReplyData data = new DirGroupsReplyData();

520

data.groupID = new UUID((string)groupFind["GroupID"]); ;

521

data.groupName = (string)groupFind["Name"];

522

data.members = int.Parse((string)groupFind["Members"]);

523

// data.searchOrder = order;

524

525

findings.Add(data);

}

}

return findings;

}

public GroupMembershipData GetAgentGroupMembership(UUID requestingAgentID, UUID AgentID, UUID GroupID)

533

{

534

Hashtable param = new Hashtable();

535

param["AgentID"] = AgentID.ToString();

536

param["GroupID"] = GroupID.ToString();

537

538

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentGroupMembership", param);

539

540

if (respData.Contains("error"))

{

return null;

}

GroupMembershipData data = HashTableToGroupMembershipData(respData);

return data;

}

public GroupMembershipData GetAgentActiveMembership(UUID requestingAgentID, UUID AgentID)

551

{

552

Hashtable param = new Hashtable();

553

param["AgentID"] = AgentID.ToString();

554

555

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentActiveMembership", param);

556

557

if (respData.Contains("error"))

{

return null;

}

return HashTableToGroupMembershipData(respData);

563

}

564

565

public List<GroupMembershipData> GetAgentGroupMemberships(UUID requestingAgentID, UUID AgentID)

566

{

567

Hashtable param = new Hashtable();

568

param["AgentID"] = AgentID.ToString();

569

570

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentGroupMemberships", param);

571

572

List<GroupMembershipData> memberships = new List<GroupMembershipData>();

573

574

if (!respData.Contains("error"))

575

{

576

foreach (object membership in respData.Values)

577

{

578

memberships.Add(HashTableToGroupMembershipData((Hashtable)membership));

}

}

return memberships;

583

}

584

585

public List<GroupRolesData> GetAgentGroupRoles(UUID requestingAgentID, UUID AgentID, UUID GroupID)

586

{

587

Hashtable param = new Hashtable();

588

param["AgentID"] = AgentID.ToString();

589

param["GroupID"] = GroupID.ToString();

590

591

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentRoles", param);

592

593

List<GroupRolesData> Roles = new List<GroupRolesData>();

594

595

if (respData.Contains("error"))

{

return Roles;

}

foreach (Hashtable role in respData.Values)

601

{

602

GroupRolesData data = new GroupRolesData();

603

data.RoleID = new UUID((string)role["RoleID"]);

604

data.Name = (string)role["Name"];

605

data.Description = (string)role["Description"];

606

data.Powers = ulong.Parse((string)role["Powers"]);

607

data.Title = (string)role["Title"];

Roles.Add(data);

}

return Roles;

}

public List<GroupRolesData> GetGroupRoles(UUID requestingAgentID, UUID GroupID)

616

{

617

Hashtable param = new Hashtable();

618

param["GroupID"] = GroupID.ToString();

619

620

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupRoles", param);

621

622

List<GroupRolesData> Roles = new List<GroupRolesData>();

623

624

if (respData.Contains("error"))

{

return Roles;

}

foreach (Hashtable role in respData.Values)

630

{

631

GroupRolesData data = new GroupRolesData();

632

data.Description = (string)role["Description"];

633

data.Members = int.Parse((string)role["Members"]);

634

data.Name = (string)role["Name"];

635

data.Powers = ulong.Parse((string)role["Powers"]);

636

data.RoleID = new UUID((string)role["RoleID"]);

637

data.Title = (string)role["Title"];

Roles.Add(data);

}

return Roles;

}

public List<GroupMembersData> GetGroupMembers(UUID requestingAgentID, UUID GroupID)

646

{

647

Hashtable param = new Hashtable();

648

param["GroupID"] = GroupID.ToString();

649

650

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupMembers", param);

651

652

List<GroupMembersData> members = new List<GroupMembersData>();

653

654

if (respData.Contains("error"))

{

return members;

}

foreach (Hashtable membership in respData.Values)

660

{

661

GroupMembersData data = new GroupMembersData();

662

663

data.AcceptNotices = ((string)membership["AcceptNotices"]) == "1";

664

data.AgentID = new UUID((string)membership["AgentID"]);

665

data.Contribution = int.Parse((string)membership["Contribution"]);

666

data.IsOwner = ((string)membership["IsOwner"]) == "1";

667

data.ListInProfile = ((string)membership["ListInProfile"]) == "1";

668

data.AgentPowers = ulong.Parse((string)membership["AgentPowers"]);

669

data.Title = (string)membership["Title"];

members.Add(data);

}

return members;

}

public List<GroupRoleMembersData> GetGroupRoleMembers(UUID requestingAgentID, UUID GroupID)

678

{

679

Hashtable param = new Hashtable();

680

param["GroupID"] = GroupID.ToString();

681

682

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupRoleMembers", param);

683

684

List<GroupRoleMembersData> members = new List<GroupRoleMembersData>();

685

686

if (!respData.Contains("error"))

687

{

688

foreach (Hashtable membership in respData.Values)

689

{

690

GroupRoleMembersData data = new GroupRoleMembersData();

691

692

data.MemberID = new UUID((string)membership["AgentID"]);

693

data.RoleID = new UUID((string)membership["RoleID"]);

members.Add(data);

}

}

return members;

}

public List<GroupNoticeData> GetGroupNotices(UUID requestingAgentID, UUID GroupID)

702

{

703

Hashtable param = new Hashtable();

704

param["GroupID"] = GroupID.ToString();

705

706

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupNotices", param);

707

708

List<GroupNoticeData> values = new List<GroupNoticeData>();

709

710

if (!respData.Contains("error"))

711

{

712

foreach (Hashtable value in respData.Values)

713

{

714

GroupNoticeData data = new GroupNoticeData();

715

data.NoticeID = UUID.Parse((string)value["NoticeID"]);

716

data.Timestamp = uint.Parse((string)value["Timestamp"]);

717

data.FromName = (string)value["FromName"];

718

data.Subject = (string)value["Subject"];

719

data.HasAttachment = false;

720

data.AssetType = 0;

values.Add(data);

}

}

return values;

}

public GroupNoticeInfo GetGroupNotice(UUID requestingAgentID, UUID noticeID)

730

{

731

Hashtable param = new Hashtable();

732

param["NoticeID"] = noticeID.ToString();

733

734

Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupNotice", param);

735

736

if (respData.Contains("error"))

{

return null;

}

GroupNoticeInfo data = new GroupNoticeInfo();

742

data.GroupID = UUID.Parse((string)respData["GroupID"]);

743

data.Message = (string)respData["Message"];

744

data.BinaryBucket = Utils.HexStringToBytes((string)respData["BinaryBucket"], true);

745

data.noticeData.NoticeID = UUID.Parse((string)respData["NoticeID"]);

746

data.noticeData.Timestamp = uint.Parse((string)respData["Timestamp"]);

747

data.noticeData.FromName = (string)respData["FromName"];

748

data.noticeData.Subject = (string)respData["Subject"];

749

data.noticeData.HasAttachment = false;

750

data.noticeData.AssetType = 0;

751

752

if (data.Message == null)

753

{

754

data.Message = string.Empty;

}

return data;

}

        public void AddGroupNotice(UUID requestingAgentID, UUID groupID, UUID noticeID, string fromName, string subject, string message, byte[] binaryBucket)

761

{

762

string binBucket = OpenMetaverse.Utils.BytesToHexString(binaryBucket, "");

763

764

Hashtable param = new Hashtable();

765

param["GroupID"] = groupID.ToString();

766

param["NoticeID"] = noticeID.ToString();

767

param["FromName"] = fromName;

768

param["Subject"] = subject;

769

param["Message"] = message;

770

param["BinaryBucket"] = binBucket;

771

param["TimeStamp"] = ((uint)Util.UnixTimeSinceEpoch()).ToString();

772

773

XmlRpcCall(requestingAgentID, "groups.addGroupNotice", param);

}

#endregion

#region GroupSessionTracking

779

780

public void ResetAgentGroupChatSessions(UUID agentID)

781

{

782

foreach (List<UUID> agentList in m_groupsAgentsDroppedFromChatSession.Values)

783

{

784

agentList.Remove(agentID);

}

}

public bool hasAgentBeenInvitedToGroupChatSession(UUID agentID, UUID groupID)

789

{

790

// If we're tracking this group, and we can find them in the tracking, then they've been invited

791

return m_groupsAgentsInvitedToChatSession.ContainsKey(groupID)

792

&& m_groupsAgentsInvitedToChatSession[groupID].Contains(agentID);

793

}

794

795

public bool hasAgentDroppedGroupChatSession(UUID agentID, UUID groupID)

796

{

797

// If we're tracking drops for this group,

798

// and we find them, well... then they've dropped

799

return m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID)

800

&& m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID);

801

}

802

803

public void AgentDroppedFromGroupChatSession(UUID agentID, UUID groupID)

804

{

805

if (m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID))

806

{

807

// If not in dropped list, add

808

if (!m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID))

809

{

810

m_groupsAgentsDroppedFromChatSession[groupID].Add(agentID);

}

}

}

public void AgentInvitedToGroupChatSession(UUID agentID, UUID groupID)

816

{

817

// Add Session Status if it doesn't exist for this session

818

CreateGroupChatSessionTracking(groupID);

819

820

// If nessesary, remove from dropped list

821

if (m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID))

822

{

823

m_groupsAgentsDroppedFromChatSession[groupID].Remove(agentID);

}

}

private void CreateGroupChatSessionTracking(UUID groupID)

828

{

829

if (!m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID))

830

{

831

m_groupsAgentsDroppedFromChatSession.Add(groupID, new List<UUID>());

832

m_groupsAgentsInvitedToChatSession.Add(groupID, new List<UUID>());

}

}

#endregion

#region XmlRpcHashtableMarshalling

839

private GroupProfileData GroupProfileHashtableToGroupProfileData(Hashtable groupProfile)

840

{

841

GroupProfileData group = new GroupProfileData();

842

group.GroupID = UUID.Parse((string)groupProfile["GroupID"]);

843

group.Name = (string)groupProfile["Name"];

844

845

if (groupProfile["Charter"] != null)

846

{

847

group.Charter = (string)groupProfile["Charter"];

848

}

849

850

group.ShowInList = ((string)groupProfile["ShowInList"]) == "1";

851

group.InsigniaID = UUID.Parse((string)groupProfile["InsigniaID"]);

852

group.MembershipFee = int.Parse((string)groupProfile["MembershipFee"]);

853

group.OpenEnrollment = ((string)groupProfile["OpenEnrollment"]) == "1";

854

group.AllowPublish = ((string)groupProfile["AllowPublish"]) == "1";

855

group.MaturePublish = ((string)groupProfile["MaturePublish"]) == "1";

856

group.FounderID = UUID.Parse((string)groupProfile["FounderID"]);

857

group.OwnerRole = UUID.Parse((string)groupProfile["OwnerRoleID"]);

858

859

group.GroupMembershipCount = int.Parse((string)groupProfile["GroupMembershipCount"]);

860

group.GroupRolesCount = int.Parse((string)groupProfile["GroupRolesCount"]);

return group;

}

private GroupRecord GroupProfileHashtableToGroupRecord(Hashtable groupProfile)

866

{

867

GroupRecord group = new GroupRecord();

868

group.GroupID = UUID.Parse((string)groupProfile["GroupID"]);

869

group.GroupName = groupProfile["Name"].ToString();

870

if (groupProfile["Charter"] != null)

871

{

872

group.Charter = (string)groupProfile["Charter"];

873

}

874

group.ShowInList = ((string)groupProfile["ShowInList"]) == "1";

875

group.GroupPicture = UUID.Parse((string)groupProfile["InsigniaID"]);

876

group.MembershipFee = int.Parse((string)groupProfile["MembershipFee"]);

877

group.OpenEnrollment = ((string)groupProfile["OpenEnrollment"]) == "1";

878

group.AllowPublish = ((string)groupProfile["AllowPublish"]) == "1";

879

group.MaturePublish = ((string)groupProfile["MaturePublish"]) == "1";

880

group.FounderID = UUID.Parse((string)groupProfile["FounderID"]);

881

group.OwnerRoleID = UUID.Parse((string)groupProfile["OwnerRoleID"]);

return group;

}

private static GroupMembershipData HashTableToGroupMembershipData(Hashtable respData)

887

{

888

GroupMembershipData data = new GroupMembershipData();

889

data.AcceptNotices = ((string)respData["AcceptNotices"] == "1");

890

data.Contribution = int.Parse((string)respData["Contribution"]);

891

data.ListInProfile = ((string)respData["ListInProfile"] == "1");

892

893

data.ActiveRole = new UUID((string)respData["SelectedRoleID"]);

894

data.GroupTitle = (string)respData["Title"];

895

896

data.GroupPowers = ulong.Parse((string)respData["GroupPowers"]);

897

898

// Is this group the agent's active group

899

900

data.GroupID = new UUID((string)respData["GroupID"]);

901

902

UUID ActiveGroup = new UUID((string)respData["ActiveGroupID"]);

903

data.Active = data.GroupID.Equals(ActiveGroup);

904

905

data.AllowPublish = ((string)respData["AllowPublish"] == "1");

906

if (respData["Charter"] != null)

907

{

908

data.Charter = (string)respData["Charter"];

909

}

910

data.FounderID = new UUID((string)respData["FounderID"]);

911

data.GroupID = new UUID((string)respData["GroupID"]);

912

data.GroupName = (string)respData["GroupName"];

913

data.GroupPicture = new UUID((string)respData["InsigniaID"]);

914

data.MaturePublish = ((string)respData["MaturePublish"] == "1");

915

data.MembershipFee = int.Parse((string)respData["MembershipFee"]);

916

data.OpenEnrollment = ((string)respData["OpenEnrollment"] == "1");

917

data.ShowInList = ((string)respData["ShowInList"] == "1");

return data;

}

#endregion

/// <summary>

/// Encapsulate the XmlRpc call to standardize security and error handling.

926

/// </summary>

927

private Hashtable XmlRpcCall(UUID requestingAgentID, string function, Hashtable param)

928

{

929

XmlRpcResponse resp = null;

930

string CacheKey = null;

931

932

// Only bother with the cache if it isn't disabled.

933

if (m_cacheTimeout > 0)

934

{

935

if (!function.StartsWith("groups.get"))

936

{

937

// Any and all updates cause the cache to clear

938

m_memoryCache.Clear();

}

else

{

StringBuilder sb = new StringBuilder(requestingAgentID + function);

943

foreach (object key in param.Keys)

944

{

945

if (param[key] != null)

946

{

947

sb.AppendFormat(",{0}:{1}", key.ToString(), param[key].ToString());

}

}

CacheKey = sb.ToString();

952

m_memoryCache.TryGetValue(CacheKey, out resp);

}

}

if (resp == null)

{

if (m_debugEnabled)

959

m_log.DebugFormat("[XMLRPC-GROUPS-CONNECTOR]: Cache miss for key {0}", CacheKey);

960

961

string UserService;

962

UUID SessionID;

963

GetClientGroupRequestID(requestingAgentID, out UserService, out SessionID);

964

965

param.Add("RequestingAgentID", requestingAgentID.ToString());

966

param.Add("RequestingAgentUserService", UserService);

967

param.Add("RequestingSessionID", SessionID.ToString());

968

param.Add("ReadKey", m_groupReadKey);

969

param.Add("WriteKey", m_groupWriteKey);

970

971

IList parameters = new ArrayList();

972

parameters.Add(param);

973

974

ConfigurableKeepAliveXmlRpcRequest req;

975

req = new ConfigurableKeepAliveXmlRpcRequest(function, parameters, m_disableKeepAlive);

try

{

resp = req.Send(m_groupsServerURI, 10000);

980

981

if ((m_cacheTimeout > 0) && (CacheKey != null))

982

{

983

m_memoryCache.AddOrUpdate(CacheKey, resp, TimeSpan.FromSeconds(m_cacheTimeout));

984

}

985

}

986

catch (Exception e)

987

{

988

m_log.ErrorFormat(

989

                        "[XMLRPC-GROUPS-CONNECTOR]: An error has occured while attempting to access the XmlRpcGroups server method {0} at {1}",

990

function, m_groupsServerURI);

991

992

m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: {0}{1}", e.Message, e.StackTrace);

993

994

                    foreach (string ResponseLine in req.RequestResponse.Split(new string[] { Environment.NewLine }, StringSplitOptions.None))

995

{

996

m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: {0} ", ResponseLine);

997

}

998

999

foreach (string key in param.Keys)

1000

{

1001

m_log.WarnFormat("[XMLRPC-GROUPS-CONNECTOR]: {0} :: {1}", key, param[key].ToString());

1002

}

1003

1004

Hashtable respData = new Hashtable();

1005

respData.Add("error", e.ToString());

return respData;

}

}

if (resp.Value is Hashtable)

1011

{

1012

Hashtable respData = (Hashtable)resp.Value;

1013

if (respData.Contains("error") && !respData.Contains("succeed"))

1014

{

1015

LogRespDataToConsoleError(respData);

}

return respData;

}

            m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: The XmlRpc server returned a {1} instead of a hashtable for {0}", function, resp.Value.GetType().ToString());

1022

1023

if (resp.Value is ArrayList)

1024

{

1025

ArrayList al = (ArrayList)resp.Value;

1026

m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: Contains {0} elements", al.Count);

1027

1028

foreach (object o in al)

1029

{

1030

m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: {0} :: {1}", o.GetType().ToString(), o.ToString());

}

}

else

{

m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: Function returned: {0}", resp.Value.ToString());

1036

}

1037

1038

Hashtable error = new Hashtable();

1039

error.Add("error", "invalid return value");

return error;

}

private void LogRespDataToConsoleError(Hashtable respData)

1044

{

1045

m_log.Error("[XMLRPC-GROUPS-CONNECTOR]: Error:");

1046

1047

foreach (string key in respData.Keys)

1048

{

1049

m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: Key: {0}", key);

1050

1051

string[] lines = respData[key].ToString().Split(new char[] { '\n' });

1052

foreach (string line in lines)

1053

{

1054

m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: {0}", line);

}

}

}

/// <summary>

/// Group Request Tokens are an attempt to allow the groups service to authenticate

1061

/// requests.

1062

/// TODO: This broke after the big grid refactor, either find a better way, or discard this

1063

/// </summary>

1064

/// <param name="client"></param>

1065

/// <returns></returns>

1066

private void GetClientGroupRequestID(UUID AgentID, out string UserServiceURL, out UUID SessionID)

1067

{

1068

UserServiceURL = "";

1069

SessionID = UUID.Zero;

1070

1071

1072

// Need to rework this based on changes to User Services

1073

/*

1074

UserAccount userAccount = m_accountService.GetUserAccount(UUID.Zero,AgentID);

1075

if (userAccount == null)

1076

{

1077

// This should be impossible. If I've been passed a reference to a client

1078

// that client should be registered with the UserService. So something

1079

// is horribly wrong somewhere.

1080

1081

m_log.WarnFormat("[GROUPS]: Could not find a UserServiceURL for {0}", AgentID);

1082

1083

}

1084

else if (userProfile is ForeignUserProfileData)

1085

{

1086

// They aren't from around here

1087

ForeignUserProfileData fupd = (ForeignUserProfileData)userProfile;

1088

UserServiceURL = fupd.UserServerURI;

1089

SessionID = fupd.CurrentAgent.SessionID;

}

else

{

// They're a local user, use this:

1095

UserServiceURL = m_commManager.NetworkServersInfo.UserURL;

1096

SessionID = userProfile.CurrentAgent.SessionID;

}

*/

}

}

}

namespace Nwc.XmlRpc

1105

{

1106

using System;

1107

using System.Collections;

using System.IO;

using System.Xml;

using System.Net;

using System.Text;

using System.Reflection;

1113

1114

/// <summary>Class supporting the request side of an XML-RPC transaction.</summary>

1115

public class ConfigurableKeepAliveXmlRpcRequest : XmlRpcRequest

1116

{

1117

private XmlRpcRequestSerializer _serializer = new XmlRpcRequestSerializer();

1118

private XmlRpcResponseDeserializer _deserializer = new XmlRpcResponseDeserializer();

1119

private bool _disableKeepAlive = true;

1120

1121

public string RequestResponse = String.Empty;

1122

1123

/// <summary>Instantiate an <c>XmlRpcRequest</c> for a specified method and parameters.</summary>

1124

/// <param name="methodName"><c>String</c> designating the <i>object.method</i> on the server the request

1125

/// should be directed to.</param>

1126

/// <param name="parameters"><c>ArrayList</c> of XML-RPC type parameters to invoke the request with.</param>

1127

public ConfigurableKeepAliveXmlRpcRequest(String methodName, IList parameters, bool disableKeepAlive)

1128

{

1129

MethodName = methodName;

1130

_params = parameters;

1131

_disableKeepAlive = disableKeepAlive;

1132

}

1133

1134

/// <summary>Send the request to the server.</summary>

1135

/// <param name="url"><c>String</c> The url of the XML-RPC server.</param>

1136

/// <returns><c>XmlRpcResponse</c> The response generated.</returns>

1137

public XmlRpcResponse Send(String url)

1138

{

1139

HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);

1140

if (request == null)

1141

throw new XmlRpcException(XmlRpcErrorCodes.TRANSPORT_ERROR,

1142

XmlRpcErrorCodes.TRANSPORT_ERROR_MSG + ": Could not create request with " + url);

1143

request.Method = "POST";

1144

request.ContentType = "text/xml";

1145

request.AllowWriteStreamBuffering = true;

1146

request.KeepAlive = !_disableKeepAlive;

1147

1148

using (Stream stream = request.GetRequestStream())

1149

{

1150

using (XmlTextWriter xml = new XmlTextWriter(stream, Encoding.ASCII))

1151

{

1152

_serializer.Serialize(xml, this);

xml.Flush();

}

}

XmlRpcResponse resp;

1158

1159

using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())

1160

{

1161

using (Stream s = response.GetResponseStream())

1162

{

1163

using (StreamReader input = new StreamReader(s))

1164

{

1165

string inputXml = input.ReadToEnd();

try

{

resp = (XmlRpcResponse)_deserializer.Deserialize(inputXml);

1170

}

1171

catch (Exception e)

1172

{

1173

RequestResponse = inputXml;

throw e;

}

}

}

}

return resp;

}

}

}

opensim-development – Blame information for rev 1