originate function

void originate(Channel channel, Bridge holdingBridge)

Implementation

void originate(Channel channel, Bridge holdingBridge) async {
  bool callSucceed = false;

  holdingBridge.addChannel((err) {
    if (err) {
      throw err;
    }

    holdingBridge.startMoh((err) {
      // ignore error
    });
  }, channels: [channel.id]);
  //var endpoint = "SIP/7000/2035";

  var dialed = await client.channel(endpoint: endpoint);
  //var bridge = await client.bridge();
  // var externalChannel = await client.channel(
  //     app: 'hello',
  //     endpoint: endpoint,
  //     variables: {'CALLERID(name)': endpoint, 'recording': 'yes'});

  // String rtpIp = "10.100.54.52";
  // int port = 5464;
  final filename = dialed.caller.number +
      DateTime.now()
          .toString()
          .replaceAll(RegExp(regex, unicode: true), '')
          .replaceAll(" ", '');

  rtp_server(rtpIp, port + rtpPortCounter, filename);

  Channel externalChannel = await client.externalMedia(
    (err, externalChannel) {
      if (err) throw err;
    },
    app: 'hello',
    variables: {'CALLERID(name)': endpoint, 'recording': 'yes'},
    external_host: '$rtpIp:${port + rtpPortCounter}',
    format: 'alaw',
  );

  //print("Externa channel: ${externalChannel}");
  Bridge mixingBridge = await client.bridge(type: ['mixing']);

  channel.on('StasisEnd', (event, channel) {
    print("Saftely hungup up in originate on stasisEnd");
    //errors.set(channel.id, errors.get(channel.id)! + 1);
    //if (errors.get(channel.id)! > 1) throw 'event is already handled';
    //actveCalls.delete(channel.id);
    //callsWaiting.delete(channel.id);
    //CallsInConversation.delete(channel.id);
    //cdr.hangupdate = event.timestamp;
    //cdr.lastapp = event.application;
    //print('Posting to CDR');
    channel.removeAllListeners('StasisEnd');
    //postCdr(cdr);
    //sendCdr();

    actveCalls.remove(channel.id);

    callsWaiting.remove(channel.id);

    CallsInConversation.remove(channel.id);
    safeHangup(dialed);
    safeHangup(externalChannel);

    if (cdrRecords[channel.id] != null) {
      cdrRecords[channel.id]!.hangupdate = event.timestamp.toString();

      if (dsbClient != null) {
        dsbClient!.send_cdr(cdrRecords[channel.id]!);
      }
    }

    if (voiceRecords[channel.id] != null && dsbClient != null) {
      voiceRecords[channel.id]!.duration_number = event.timestamp.toString();
      dsbClient!.send_call_records(voiceRecords[channel.id]!);
    }
    voiceRecords.remove(channel.id);
    cdrRecords.remove(channel.id);
  });

  // externalChannel.on('StasisStart', (event, streamed) {
  //   throw externalChannel.name;
  //   print('Adding recording channel ${externalChannel.name} to the bridge');
  //   addChannelsToExistingBridge(externalChannel, mixingBridge);
  // });

  //print(externalChannel.handlers);

  dialed.on('ChannelDestroyed', (event, dialed) {
    print("Saftely hangup up in originate on ChannelDestroyed");
    //sendCdr(event);
    //CallsInConversation.delete(channel.id);
    //cdr.hangupdate = event.timestamp;
    //if (!callSucceed) cdr.disposition = 'Busy';
    //print("Call succeded: ${callSucceed}");

    if (callSucceed) {
      channel.continueInDialplan((err) {
        if (err) safeHangup(channel);
      }, context: 'call-rating', priority: 1, extension: 's');
    } else {
      channel.continueInDialplan((err) {
        if (err) safeHangup(channel);
      }, context: 'IVR-15', priority: 1);

      safeHangup(channel);
    }
    //postCdr(cdr);
    //sendCdr(cdr);
    //print(cdr);
    safeHangup(externalChannel);
    safeHangup(channel);
  });
  //var agent = {} as Agent;
  dialed.on('ChannelStateChange', (event, dialed) {
    print('Dialed status to: ${event.channel.state}');
    //print(event);

    //cdr.dstchannel = dialed.id;
    //cdr.dst = event.channel.caller;
    //cdr.dst = event.channel.connected;
    //event.channel.connected
    //print(dialed.caller);
    //cdr.answerdate = event.timestamp;
    // CallsInConversation.set(channel.id, channel.id);
    //callsWaiting.delete(channel.id);
    if (event.channel.state == 'Up') {
      //CallsInConversation.set(channel.id, channel.id);
      print('Dialed status to: ${event.channel.state}');
      // cdr.disposition = 'Answered';

      callsWaiting.remove(channel.id);
      CallsInConversation[channel.id] = channel.id;

      //CallsInConversation.remove(channel.id);
      callSucceed = true;
      //if (agent != null) agent.loggedIn = true;

      if (cdrRecords[channel.id] != null) {
        cdrRecords[channel.id]!.answerdate = event.timestamp.toString();
        cdrRecords[channel.id]!.dstchannel = dialed.id;
      }

      voiceRecords[channel.id] = CallRecording(
          file_name: filename,
          file_path: filename,
          agent_number: endpoint,
          phone_number: cdrRecords[channel.id]!.src!);
    }
    //var e =JSON.parse(event);
    //sendCdr();
    //safeHangup(channel);
  });

  dialed.on('StasisStart', (event, dialed) {
    print('Dialed ${dialed.id} entered stasis application');
    //print(event);
    //CallsInConversation.set(channel.id, channel.id);
    //sendCdr();

    joinMixingBridge(channel, dialed, holdingBridge, mixingBridge);
    // addChannelsToExistingBridge(externalChannel, mixingBridge);
    addChannelsToExistingBridge(externalChannel, mixingBridge);
  });

  // dialed.on('StasisEnd', (event, dialed) {
  //   print('Dialed ${dialed.id} entered stasis application');
  //   //print(event);
  //   //CallsInConversation.set(channel.id, channel.id);
  //   //sendCdr();

  //   //joinMixingBridge(channel, dialed, holdingBridge);
  //   safeHangup(channel);
  // });

  if (client.statisChannels[dialed.id] == null) {
    throw "Dialed should be in statisChannels array";
  }
  //else
  //print(dialed.handlers);

  // agents.forEach((value, key) => {d
  //     print(value);
  // });

  // var agentFilter = Array.from(agents.values()).filter(
  //     (value: Agent) => value.state == AgentState.UNKNOWN || value.state == AgentState.IDLE,
  // );

  // agentFilter.forEach(value => {
  //     if (agent == null || agent.agentSetNumber == undefined) agent = value;
  //     else if (value.callsServed >= agent.callsServed) {
  //         agent = value;
  //     }
  // });

  //     agent.agentSetNumber == undefined || agent.agentSetNumber == null
  //         ? 'SIP/7000/3636'
  //         : 'SIP/7000/' + agent.agentSetNumber;
  // print('Calling agent:', endpoint);

  //client.statisChannels[dialed.id] = dialed;

  dialed.originate((err, dialed) async {
    if (err) {
      //debug('originate error:', err);
      throw err;
    }
  },
      endpoint: endpoint,
      app: 'hello',
      appArgs: ['dialed'],
      callerId: channel.caller.number);
}