API Reference - ProjectMember API

Working with Project Members using Collections

Interactive Examples

Try these examples with your saved connection. If you haven't connected yet, visit the Try It Out page first.

Get First 10 Project Members

Fetch the first 10 project members using Collections.

const members = api.collections.projectmember;
await members.fetch({ limit: 10 });
console.log('Members:', members.models);
console.log('Has more:', members.hasMore);

Find Members by Project ID

Fetch members and filter by a specific project using the where() method.

const members = api.collections.projectmember;
await members.fetch({ limit: 100 });
const projectMembers = members.where({ project_id: 1 });
console.log(`Found ${projectMembers.length} members for project 1`);

Find All Project Managers

Fetch members and filter for those with management permissions.

const members = api.collections.projectmember;
await members.fetch({ limit: 100 });
const managers = members.filter(m => m.allow_manage);
console.log(`Found ${managers.length} managers`);

Check User Permissions for Project

Check if a specific user has permissions for a project using filtering.

const members = api.collections.projectmember;
// Fetch with filters for specific user and project
await members.fetch({ user_id: 1, project_id: 1 });
const membership = members.first();
if (membership) {
  console.log('User has access');
  console.log('Role:', membership.allow_manage ? 'Manager' :
    membership.allow_change ? 'Editor' : 'Viewer');
}

Group Members by Project

Fetch all members and group them by project to see membership distribution.

const members = api.collections.projectmember;
await members.fetchAll();
const byProject = members.groupBy('project_id');
Object.entries(byProject).forEach(([projectId, projectMembers]) => {
  console.log(`Project ${projectId}: ${projectMembers.length} members`);
});

ProjectMemberCollection

The ProjectMemberCollection class provides a Backbone.js-inspired interface for managing project member data with built-in indexing, pagination, and array operations.

Accessing the ProjectMemberCollection

import { initializeSGERP } from 'sgerp-frontend-lib';

const api = initializeSGERP({
  activeConnection: 'admin@staging',
  connections: {
    'admin@staging': {
      id: 'admin@staging',
      environment: 'staging',
      user: 'admin',
      password: 'your-password',
      baseUrl: 'https://sgerp-stage.d.gcdev.swatrider.com',
    },
  },
});

// Access the ProjectMemberCollection
const members = api.collections.projectmember;

Common ProjectMember Operations

Get All Project Members

Fetch and work with project member collections:

const members = api.collections.projectmember;

// Fetch first page
await members.fetch({ limit: 20 });
console.log('Total members:', members.length);
console.log('Has more:', members.hasMore);

// Iterate through members
members.forEach(member => {
  console.log(`User ${member.user_id} in Project ${member.project_id}`);
  console.log(`  Permissions: change=${member.allow_change}, manage=${member.allow_manage}`);
});

Find Members by Project

Use underscore.js methods to filter members by project:

const members = api.collections.projectmember;
await members.fetch({ limit: 100 });

// Get all members for a specific project
const projectId = 1;
const projectMembers = members.where({ project_id: projectId });

console.log(`Project ${projectId} has ${projectMembers.length} members`);
projectMembers.forEach(member => {
  console.log(`  User ID: ${member.user_id}`);
  console.log(`  Can change: ${member.allow_change}`);
  console.log(`  Can manage: ${member.allow_manage}`);
});

Find Members by User

Find all projects a user is a member of:

const members = api.collections.projectmember;
await members.fetch({ limit: 100 });

// Get all projects for a specific user
const userId = 42;
const userMemberships = members.where({ user_id: userId });

console.log(`User ${userId} is a member of ${userMemberships.length} projects`);
userMemberships.forEach(member => {
  console.log(`  Project ID: ${member.project_id}`);
  console.log(`  Permissions: change=${member.allow_change}, manage=${member.allow_manage}`);
});

Find Project Managers

Find members with management permissions:

const members = api.collections.projectmember;
await members.fetch({ limit: 100 });

// Find all managers (allow_manage = true)
const managers = members.filter(m => m.allow_manage);

console.log(`Found ${managers.length} managers`);
managers.forEach(manager => {
  console.log(`  User ${manager.user_id} manages Project ${manager.project_id}`);
});

Check User Permissions

Check if a user has specific permissions for a project:

const members = api.collections.projectmember;
await members.fetch({ limit: 100 });

// Check if user 42 can manage project 1
const membership = members.findWhere({
  user_id: 42,
  project_id: 1,
});

if (membership) {
  console.log('User has membership');
  console.log('Can change:', membership.allow_change);
  console.log('Can manage:', membership.allow_manage);
} else {
  console.log('User is not a member of this project');
}

Types

ProjectMember

interface ProjectMember {
  id: number;
  created_at: string;
  modified_at: string;
  user_id: number;
  project_id: number;
  allow_change: boolean;
  allow_manage: boolean;
  data: Record<string, any>;
}

Fields:

id - Unique identifier for the membership
created_at - ISO timestamp when membership was created
modified_at - ISO timestamp of last modification
user_id - ID of the user who is a member
project_id - ID of the project they belong to
allow_change - Whether the user can modify project data
allow_manage - Whether the user can manage project settings and members
data - Additional custom data associated with the membership

Complete Example

import {
  initializeSGERP,
  type ProjectMember,
} from 'sgerp-frontend-lib';

// Initialize the library
const api = initializeSGERP({
  activeConnection: 'admin@staging',
  connections: {
    'admin@staging': {
      id: 'admin@staging',
      environment: 'staging',
      user: 'admin',
      password: 'your-password',
      baseUrl: 'https://sgerp-stage.d.gcdev.swatrider.com',
    },
  },
});

// Fetch all project members
const members = api.collections.projectmember;
await members.fetchAll();

console.log(`Total memberships: ${members.length}`);

// Analyze permissions by project
const byProject = members.groupBy('project_id');

Object.entries(byProject).forEach(([projectId, projectMembers]) => {
  const managers = projectMembers.filter(m => m.allow_manage);
  const editors = projectMembers.filter(m => m.allow_change && !m.allow_manage);
  const viewers = projectMembers.filter(m => !m.allow_change && !m.allow_manage);

  console.log(`\nProject ${projectId}:`);
  console.log(`  Total members: ${projectMembers.length}`);
  console.log(`  Managers: ${managers.length}`);
  console.log(`  Editors: ${editors.length}`);
  console.log(`  Viewers: ${viewers.length}`);
});

// Find cross-project managers
const managerUserIds = new Set(
  members.filter(m => m.allow_manage).map(m => m.user_id)
);

console.log(`\nUnique managers across all projects: ${managerUserIds.size}`);

// Check specific user-project relationship
const userId = 42;
const projectId = 1;

const membership = members.findWhere({ user_id: userId, project_id: projectId });

if (membership) {
  console.log(`\nUser ${userId} access to Project ${projectId}:`);
  console.log(`  Role: ${
    membership.allow_manage ? 'Manager' :
    membership.allow_change ? 'Editor' :
    'Viewer'
  }`);
} else {
  console.log(`\nUser ${userId} is not a member of Project ${projectId}`);
}

Error Handling

import { initializeSGERP, APIError } from 'sgerp-frontend-lib';

const api = initializeSGERP({ /* config */ });

try {
  const members = api.collections.projectmember;
  await members.fetch({ limit: 20 });
  console.log('Members:', members.models);
} catch (error) {
  if (error instanceof APIError) {
    if (error.status === 401) {
      console.error('Authentication failed - check credentials');
    } else if (error.status === 403) {
      console.error('Access denied - insufficient permissions');
    } else {
      console.error('API error:', error.message);
    }
  } else {
    console.error('Unknown error:', error);
  }
}

Working with Combined Data

Combine project members with projects and users for rich queries:

const api = initializeSGERP({ /* config */ });

// Fetch all data
const projects = api.collections.project;
const users = api.collections.user;
const members = api.collections.projectmember;

await Promise.all([
  projects.fetchAll(),
  users.fetchAll(),
  members.fetchAll(),
]);

// Find all members with their project and user details
members.forEach(member => {
  const project = projects.get(member.project_id);
  const user = users.get(member.user_id);

  if (project && user) {
    console.log(`${user.username} is a member of ${project.name}`);
    console.log(`  Role: ${
      member.allow_manage ? 'Manager' :
      member.allow_change ? 'Editor' :
      'Viewer'
    }`);
  }
});

// Group members by project with full details
const projectDetails = projects.map(project => {
  const projectMembers = members.where({ project_id: project.id });
  const memberDetails = projectMembers.map(m => {
    const user = users.get(m.user_id);
    return {
      username: user?.username || 'Unknown',
      role: m.allow_manage ? 'Manager' : m.allow_change ? 'Editor' : 'Viewer',
    };
  });

  return {
    projectName: project.name,
    memberCount: projectMembers.length,
    members: memberDetails,
  };
});

console.log('Project Memberships:', projectDetails);