Community Membership

let invitationPage = AmityCommunityInvitationPage(community: community)
let viewController = AmitySwiftUIHostingController(rootView: invitationPage)
navigationController?.pushViewController(viewController, animated: true)

@Composable
fun composeInvitationPage(community: AmityCommunity) {
    AmityCommunityInvitationPage(
        community = community,
        onInvitationSent = { users ->
            // Handle successful invitations
        },
        onInvitationError = { error ->
            // Handle invitation errors
        }
    )
}

import React from 'react';
import { AmityUiKitProvider, AmityCommunityInvitationPage } from '@amityco/ui-kit';

const InvitationManagement = ({ community }) => {
  return (
    <AmityUiKitProvider
      apiKey="API_KEY"
      apiRegion="API_REGION"
      userId="userId"
      displayName="displayName"
    >
      <AmityCommunityInvitationPage 
        community={community}
        onInvitationSent={(users) => {
          // Handle successful invitations
        }}
        onInvitationError={(error) => {
          // Handle invitation errors
        }}
      />
    </AmityUiKitProvider>
  );
};

// The Flutter UIKit exposes member addition through AmityCommunityAddMemberPage.
Widget addMemberPage(List<AmityUser> selectedUsers) {
  return AmityCommunityAddMemberPage(
    users: selectedUsers,
    onAddedAction: (users) {
      // Handle the selected users to add to the community
    },
  );
}

// Handle invitation success
func handleInvitationSuccess(users: [AmityUser]) {
    // Show success message
    let alert = UIAlertController(
        title: "Invitations Sent",
        message: "Successfully invited \(users.count) users",
        preferredStyle: .alert
    )
    alert.addAction(UIAlertAction(title: "OK", style: .default))
    present(alert, animated: true)
}

// Navigate to invitation status
func showInvitationStatus() {
    let statusPage = AmityInvitationStatusPage(community: community)
    let viewController = AmitySwiftUIHostingController(rootView: statusPage)
    navigationController?.pushViewController(viewController, animated: true)
}

// Handle invitation success
fun handleInvitationSuccess(users: List<AmityUser>) {
    // Show success message
    Toast.makeText(
        context,
        "Successfully invited ${users.size} users",
        Toast.LENGTH_SHORT
    ).show()
}

// Navigate to invitation status
fun showInvitationStatus() {
    val statusPage = AmityInvitationStatusPage(community = community)
    // Navigate to status page
}

// Handle invitation workflows
const handleInvitationWorkflow = {
    onSuccess: (users) => {
        // Show success notification
        showNotification(`Successfully invited ${users.length} users`);
    },
    onError: (error) => {
        // Handle invitation error
        showError(`Failed to send invitations: ${error.message}`);
    },
    showStatus: () => {
        // Navigate to invitation status page
        navigate('/community/invitations/status');
    }
};

// Handle invitation success
void handleInvitationSuccess(List<AmityUser> users) {
    ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(
            content: Text('Successfully invited ${users.length} users'),
        ),
    );
}

// Navigate to the community membership page to review members
void showMembership(AmityCommunity community) {
    Navigator.push(
        context,
        MaterialPageRoute(
            builder: (context) => AmityCommunityMembershipPage(community: community),
        ),
    );
}

// Focus on join request functionality of pending request page
let page = AmityPendingRequestPage(community: community)
let viewController = AmitySwiftUIHostingController(rootView: page)
navigationController?.pushViewController(viewController, animated: true)

@Composable
fun composeJoinRequestManagement(community: AmityCommunity) {
    AmityPendingRequestPage(
        community = community,
        onJoinRequestAction = { action, request ->
            // Handle join request approval/rejection
            when (action) {
                is JoinRequestAction.Approve -> {
                    // Approve join request
                }
                is JoinRequestAction.Reject -> {
                    // Reject join request
                }
            }
        }
    )
}

import React from 'react';
import { AmityUiKitProvider, AmityPendingRequestPage } from '@amityco/ui-kit';

const JoinRequestManagement = ({ community }) => {
  return (
    <AmityUiKitProvider
      apiKey="API_KEY"
      apiRegion="API_REGION"
      userId="userId"
      displayName="displayName"
    >
      <AmityPendingRequestPage 
        community={community}
        onJoinRequestAction={(action, request) => {
          // Handle join request actions
          if (action === 'approve') {
            // Approve join request
          } else if (action === 'reject') {
            // Reject join request
          }
        }}
      />
    </AmityUiKitProvider>
  );
};

Widget joinRequestManagement(AmityCommunity community) {
  return AmityPendingRequestPage(
    community: community,
  );
}

let component = AmityJoinRequestContentComponent(community: community)
let viewController = AmitySwiftUIHostingController(rootView: component)

@Composable
fun composeJoinRequestComponent(joinRequest: AmityJoinRequest) {
    AmityJoinRequestContentComponent(
        joinRequest = joinRequest,
        onAcceptAction = {
            // Handle accept action
        },
        onDeclineAction = {
            // Handle decline action
        }
    )
}

import React from 'react';
import { AmityUiKitProvider, AmityJoinRequestContentComponent } from '@amityco/ui-kit';

const JoinRequestComponent = () => {
  return (
    <AmityUiKitProvider
      apiKey="API_KEY"
      apiRegion="API_REGION"
      userId="userId"
      displayName="displayName"
      configs={{}} // put your customized config json object
    >
      <AmityJoinRequestContentComponent
        pageId={'*'} // optional, default is '*'
        joinRequests={null} // join requests array, can be null
        isLoading={false} // loading state, default is false
      />
    </AmityUiKitProvider>
  );
};

// The Flutter UIKit does not expose a standalone join request content widget.
// Join request content is rendered inside AmityPendingRequestPage.
Widget joinRequestComponent(AmityCommunity community) {
  return AmityPendingRequestPage(
    community: community,
  );
}

// Handle join request approval
func approveJoinRequest(request: AmityJoinRequest) {
    // Approve the request
    request.approve { [weak self] result in
        DispatchQueue.main.async {
            switch result {
            case .success:
                // Show success message
                self?.showSuccessAlert("Join request approved")
            case .failure(let error):
                // Handle error
                self?.showErrorAlert("Failed to approve request: \(error.localizedDescription)")
            }
        }
    }
}

// Navigate to user profile
func showRequestingUserProfile(user: AmityUser) {
    let profilePage = AmityUserProfilePage(user: user)
    let viewController = AmitySwiftUIHostingController(rootView: profilePage)
    navigationController?.pushViewController(viewController, animated: true)
}

// Handle join request actions
fun handleJoinRequestAction(action: JoinRequestAction, request: AmityJoinRequest) {
    when (action) {
        is JoinRequestAction.Approve -> {
            // Approve join request
            request.approve()
                .subscribe(
                    {
                        // Show success message
                        showSuccessToast("Join request approved")
                    },
                    { error ->
                        // Handle error
                        showErrorToast("Failed to approve request: ${error.message}")
                    }
                )
        }
        is JoinRequestAction.Reject -> {
            // Reject join request
            request.reject()
        }
    }
}

// Navigate to user profile
fun showRequestingUserProfile(user: AmityUser) {
    val profilePage = AmityUserProfilePage(user = user)
    // Navigate to profile page
}

// Handle join request workflows
const handleJoinRequestWorkflow = {
    approve: async (request) => {
        try {
            await request.approve();
            showNotification('Join request approved successfully');
            // Refresh the request list
            refreshRequests();
        } catch (error) {
            showError(`Failed to approve request: ${error.message}`);
        }
    },
    reject: async (request) => {
        try {
            await request.reject();
            showNotification('Join request rejected');
            refreshRequests();
        } catch (error) {
            showError(`Failed to reject request: ${error.message}`);
        }
    },
    viewProfile: (user) => {
        // Navigate to user profile
        navigate(`/profile/${user.userId}`);
    }
};

// Handle join request approval
Future<void> approveJoinRequest(AmityJoinRequest request) async {
    try {
        await request.approve();
        ScaffoldMessenger.of(context).showSnackBar(
            SnackBar(content: Text('Join request approved')),
        );
        // Refresh the request list
        refreshRequests();
    } catch (error) {
        ScaffoldMessenger.of(context).showSnackBar(
            SnackBar(content: Text('Failed to approve request: $error')),
        );
    }
}

// Navigate to user profile
void showRequestingUserProfile(AmityUser user) {
    Navigator.push(
        context,
        MaterialPageRoute(
            builder: (context) => AmityUserProfilePage(userId: user.userId!),
        ),
    );
}