Intelligentes Routing mit sipgate.io

brew install coreutils
ln -s /usr/local/bin/greadlink /usr/local/bin/readlink

# Use the service localhost.run or ngrok which set up a reverse ssh tunnel that forwards traffic from a public URL to your localhost
# Enter the public URL that was generated by localhost.run or ngrok.
WEBHOOK_URL="https://xxxxxxxxxxxxxxxxxxxxxx"

# Your Personal-Access-Token and the ID.
# Open https://app.sipgate.com and create a new token by navigating to "Benutzereinstellungen" / "User Settings" -> "Personal-Access-Tokens".
# The token should have the `numbers:read` and `devices:read` scopes (see https://sipgate.io/rest-api/authentication#personalAccessToken for more information).
TOKEN_ID='YOUR_SIPGATE_TOKEN_ID'
TOKEN='YOUR_SIPGATE_TOKEN'

# The central phone number that is called by clients.
CENTRAL_SERVICE_PHONE="+49xxxxxxxxxxxx0"

# Choose a database configuration.
# The Docker container will use these values to create the database.
DATABASE_HOST=localhost
DATABASE_NAME=database
DATABASE_USERNAME=admin
DATABASE_PASSWORT=root 
DATABASE_ROOT_PASSWORD=root
DATABASE_TIMEZONE=Europe/Berlin
 

   mv .env.example .env

db.initialize().then(async () => {
  console.log('Database initialized :card_file_box:');
  db.synchronize();
});

@Entity()
export class CallHistory {
  @PrimaryGeneratedColumn('uuid')
  id: string;
  @Column({
    type: 'datetime',
    default: () => 'NOW()',
  })
  timestamp: Date;
  @Column()
  customerPhone: string;
  @Column()
  servicePhone: string;
}

const webhookModule = createWebhookModule();
async function main() {
  const client = sipgateIO({
    tokenId: personalAccessTokenId,
    token: personalAccessToken,
  });

  ...

  const webhookModule = createWebhookModule();
  const webhookServer = await webhookModule.createServer({
    port: 8080,
    serverAddress,
    hostname,
  });

  console.log(
    `Server running at ${serverAddress}\n` +
      'Please set this URL for incoming calls at https://console.sipgate.com/webhooks/urls\n' +
      "ProTip: To see how to do that automatically, check out the example at 'examples/settings/settings_set_url_incoming.ts'\n" +
      'Ready for calls 📞',
  );

  webhookServer.onNewCall(async (newCallEvent) => {
    const onlineNumbers = await getOnlineNumbers(
      client,
      authenticatedWebuser,
      numbers.items,
    );
    return respondToNewCall(newCallEvent, centralPhone, db, onlineNumbers);
  });

  webhookServer.onAnswer(async (newAnswerEvent) =>
    respondToOnAnswer(newAnswerEvent, centralPhone, db),
  );
}

async function getOnlineNumbers(
  client: SipgateIOClient,
  authenticatedWebuser: string,
  numbers: NumberResponseItem[],
) {
  const devicesModule = createDevicesModule(client);
  const devices = await devicesModule.getDevices(authenticatedWebuser);
  const onlineDevices: Device[] = devices.filter((device) => device.online);
  const onlineIds = onlineDevices.flatMap((device) =>
    (device.activePhonelines ?? []).map((phoneline) => phoneline.id),
  );
  const onlineNumbers = onlineIds.flatMap((id) =>
    numbers
      .filter((number) => number.endpointId === id)
      .map((number) => number.number),
  );
  return [...new Set(onlineNumbers)]; // remove duplicate numbers
}

async function main() {

  ...

  const numbersModule = createNumbersModule(client);
  const authenticatedWebuser = await client.getAuthenticatedWebuserId();
  const numbers = (await numbersModule.getAllNumbers()).items.filter(
    (number) => number.number !== centralPhone,
  );

  ...

  webhookServer.onNewCall(async (newCallEvent) => {
    const onlineNumbers = await getOnlineNumbers(
      client,
      authenticatedWebuser,
      numbers.items,
    );
    return respondToNewCall(newCallEvent, centralPhone, db, onlineNumbers);
  });
}

@Entity()
webhookServer.onNewCall(async (newCallEvent) =>
      respondToNewCall(newCallEvent, centralPhone, db, serviceTeamNumbers),
    );

export async function getRedirectNumber(
  customerPhone: string,
  database: DataSource,
  serviceTeamNumbers: string[],
): Promise {
  let redirectNumber = '';
  let maxAcceptedCalls = 0;
  let totalAcceptedCalls = 0;
  /* eslint-disable no-await-in-loop */
  /* eslint-disable no-restricted-syntax */
  for (const servicePhone of serviceTeamNumbers) {
    const acceptedCalls = await acceptedCallsCount(
      database,
      customerPhone,
      servicePhone,
    );
    if (acceptedCalls > maxAcceptedCalls) {
      maxAcceptedCalls = acceptedCalls;
      redirectNumber = servicePhone;
    }
    totalAcceptedCalls += acceptedCalls;
    console.log(
      `Service Phone ${servicePhone} has accepted ${acceptedCalls} call(s) by ${customerPhone}`,
    );
  }
  if (checkRedirectThreshold(maxAcceptedCalls, totalAcceptedCalls)) {
    console.log(`Redirecting to ${redirectNumber}`);
    return redirectNumber;
  }
  console.log('Random redirect');
  return serviceTeamNumbers[getRandomIntInRange(serviceTeamNumbers.length)];
}

function checkRedirectThreshold(
  maxAcceptedCalls: number,
  totalAcceptedCalls: number,
): boolean {
  return maxAcceptedCalls > FACTOR * totalAcceptedCalls;
}

export async function respondToOnAnswer(
  newAnswerEvent: AnswerEvent,
  centralPhone: string,
  db: DataSource,
) {
  // ignore answerEvents from central phone
  if (newAnswerEvent.from !== centralPhone) {
    console.log(
      `New answer: ${newAnswerEvent.from} by ${newAnswerEvent.answeringNumber}`,
    );
    await createHistoryEntry(db, newAnswerEvent);
  }
}