شركة التطبيقات المتكاملة لتصميم النظم البرمجية الخاصة ش.ش.و.

Integrated Applications Programming Company

Skip Navigation LinksHome » Code Library » Ims

Public general use code classes and xml files that we've compiled and used over the years:

Optical Fiber Network's Operations Support System Management Intranet (OFN OSS) support class for Nokia's Optical Fiber Network (OFN) data model.

   1:  using Microsoft.EntityFrameworkCore;
   2:  using System;
   3:  using System.Collections.Generic;
   4:  using System.Data;
   5:  using System.Linq;
   6:  using System.Text;
   7:  using System.Web;
   8:   
   9:  namespace Ia.Ngn.Cl.Model.Data.Nokia
  10:  {
  11:      ////////////////////////////////////////////////////////////////////////////
  12:   
  13:      /// <summary publish="true">
  14:      /// Optical Fiber Network's Operations Support System Management Intranet (OFN OSS) support class for Nokia's Optical Fiber Network (OFN) data model.
  15:      /// </summary>
  16:      /// 
  17:      /// <remarks> 
  18:      /// Copyright © 2014-2019 Jasem Y. Al-Shamlan (info@ia.com.kw), Integrated Applications - Kuwait. All Rights Reserved.
  19:      ///
  20:      /// This library is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by
  21:      /// the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  22:      ///
  23:      /// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  24:      /// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  25:      /// 
  26:      /// You should have received a copy of the GNU General Public License along with this library. If not, see http://www.gnu.org/licenses.
  27:      /// 
  28:      /// Copyright notice: This notice may not be removed or altered from any source distribution.
  29:      /// </remarks> 
  30:      public class Ims
  31:      {
  32:          private static List<string> agcfGatewayRecordIp1sWithinWhichSubPartiesHaveServiceBundle2CategoryList, agcfGatewayRecordIp1sThatIndicateFsdb0List;
  33:   
  34:          private static readonly object objectLock = new object();
  35:   
  36:          ////////////////////////////////////////////////////////////////////////////
  37:   
  38:          /// <summary>
  39:          ///
  40:          /// </summary>
  41:          public Ims() { }
  42:   
  43:          ////////////////////////////////////////////////////////////////////////////
  44:   
  45:          /// <summary>
  46:          ///
  47:          /// </summary>
  48:          public static List<Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord> AgcfGatewayRecordsWithinNddOntListWithWrongSecondaryIpList()
  49:          {
  50:              string ip;
  51:              Dictionary<string, string> agcfGatewayRecordIpToMateExternalIPAddrDictionary;
  52:              Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord agcfGatewayRecord;
  53:              List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> ngnOntList;
  54:              List<Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord> agcfGatewayRecordList, agcfGatewayRecordList2;
  55:   
  56:              ngnOntList = Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList;
  57:              agcfGatewayRecordList = Ia.Ngn.Cl.Model.Data.Nokia.AgcfGatewayRecord.List();
  58:   
  59:              agcfGatewayRecordIpToMateExternalIPAddrDictionary = Ia.Ngn.Cl.Model.Data.Nokia.AgcfGatewayRecord.IpToMateExternalIPAddrDictionary;
  60:   
  61:              agcfGatewayRecordList2 = new List<Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord>();
  62:   
  63:              foreach (var v in ngnOntList)
  64:              {
  65:                  if (agcfGatewayRecordIpToMateExternalIPAddrDictionary.ContainsKey(v.Ip))
  66:                  {
  67:                      ip = agcfGatewayRecordIpToMateExternalIPAddrDictionary[v.Ip];
  68:   
  69:                      if (ip != v.MgcSecondaryIp)
  70:                      {
  71:                          agcfGatewayRecord = (from gr in agcfGatewayRecordList
  72:                                               where gr.IP1 == v.Ip
  73:                                               select gr).SingleOrDefault();
  74:   
  75:                          if (agcfGatewayRecord != null)
  76:                          {
  77:                              agcfGatewayRecordList2.Add(agcfGatewayRecord);
  78:                          }
  79:                      }
  80:                  }
  81:              }
  82:   
  83:              return agcfGatewayRecordList2;
  84:          }
  85:   
  86:          ////////////////////////////////////////////////////////////////////////////
  87:   
  88:          /// <summary>
  89:          ///
  90:          /// </summary>
  91:          public static List<string> ServiceWhereSubscriberAlternateOtasRealmGroupNumberDoesNotEqualSubPartyAssocOtasRealmGroupNumberList()
  92:          {
  93:              List<string> list;
  94:   
  95:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
  96:              {
  97:                  list = (from su in db.Subscribers
  98:                          join sp in db.SubParties on su.SubParty.Id equals sp.Id
  99:                          //join ep in db.AgcfEndpoints on sp.AgcfEndpoint.Id equals ep.Id
 100:                          where sp.AssocOtasRealm.Substring(0, 26) != su.AlternateOtasRealm.Substring(0, 26)
 101:                          // "stas-stdn.fsimsgroup0-001." length = 26
 102:                          select su.PartyId).AsNoTracking().ToList();
 103:              }
 104:   
 105:              return list;
 106:          }
 107:   
 108:          ////////////////////////////////////////////////////////////////////////////
 109:   
 110:          /// <summary>
 111:          ///
 112:          /// </summary>
 113:          public static void CreateH248SubscriberAndSubPartyAndAgcfEndpoint(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, int gwId, string service, int flatTermId, Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt, out string result)
 114:          {
 115:              Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response entNgfsSubscriberResponse, entNgfsAgcfEndpointResponse;
 116:   
 117:              alIms.EntNgfsSubscriberAndNgfsSubPartyV2_H248(service, gwId, nddOnt, out entNgfsSubscriberResponse);
 118:   
 119:              if (entNgfsSubscriberResponse.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful)
 120:              {
 121:                  alIms.EntNgfsAgcfEndpointV2(service, gwId, flatTermId, nddOnt, out entNgfsAgcfEndpointResponse);
 122:   
 123:                  // remove number if creation of endpoint failed
 124:                  if (entNgfsAgcfEndpointResponse.ResultCode != Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful)
 125:                  {
 126:                      alIms.DltNgfsSubscriberAndNgfsSubPartyV2(service, nddOnt, out entNgfsSubscriberResponse);
 127:                  }
 128:                  else
 129:                  {
 130:   
 131:                  }
 132:              }
 133:              else
 134:              {
 135:                  entNgfsAgcfEndpointResponse = new Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response();
 136:   
 137:                  entNgfsAgcfEndpointResponse.ResultCode = Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Null;
 138:              }
 139:   
 140:              result = service + "," + gwId + "," + flatTermId + "," + entNgfsSubscriberResponse.ResultCode.ToString() + "," + entNgfsAgcfEndpointResponse.ResultCode.ToString();
 141:          }
 142:   
 143:          ////////////////////////////////////////////////////////////////////////////
 144:   
 145:          /// <summary>
 146:          ///
 147:          /// </summary>
 148:          public static void CreateSipSubscriber(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, string service, Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt, out string result)
 149:          {
 150:              alIms.EntNgfsSubscriberAndNgfsSubPartyV2_Sip(service, nddOnt, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response);
 151:   
 152:              result = service + "," + response.ResultCode.ToString();
 153:          }
 154:   
 155:          ////////////////////////////////////////////////////////////////////////////
 156:   
 157:          /// <summary>
 158:          ///
 159:          /// </summary>
 160:          public static void Modify248SubscriberAndSubPartyAndDeleteAgcfEndpointToSip(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, string service, Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt, out string result)
 161:          {
 162:              Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response edNgfsSubscriberResponse, dltNgfsAgcfEndpointResponse;
 163:   
 164:              alIms.EdNgfsSubscriberAndNgfsSubPartyV2_H248ToSip(service, nddOnt, out edNgfsSubscriberResponse);
 165:   
 166:              if (edNgfsSubscriberResponse.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful)
 167:              {
 168:                  alIms.DltNgfsAgcfEndpointV2(service, nddOnt, out dltNgfsAgcfEndpointResponse);
 169:              }
 170:              else
 171:              {
 172:                  dltNgfsAgcfEndpointResponse = new Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response();
 173:   
 174:                  dltNgfsAgcfEndpointResponse.ResultCode = Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Null;
 175:              }
 176:   
 177:              result = service + "," + edNgfsSubscriberResponse.ResultCode.ToString() + "," + dltNgfsAgcfEndpointResponse.ResultCode.ToString();
 178:          }
 179:   
 180:          ////////////////////////////////////////////////////////////////////////////
 181:   
 182:          /// <summary>
 183:          ///
 184:          /// </summary>
 185:          public static void DeleteAgcfEndpointAndH248SubscriberAndSubParty(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, string service, Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt, out string result)
 186:          {
 187:              alIms.DltNgfsAgcfEndpointV2(service, nddOnt, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response dltNgfsAgcfEndpointResponse);
 188:   
 189:              alIms.DltNgfsSubscriberAndNgfsSubPartyV2(service, nddOnt, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response dltNgfsSubscriberResponse);
 190:   
 191:              result = service + "," + dltNgfsSubscriberResponse.ResultCode.ToString() + "," + dltNgfsAgcfEndpointResponse.ResultCode.ToString();
 192:          }
 193:   
 194:          ////////////////////////////////////////////////////////////////////////////
 195:   
 196:          /// <summary>
 197:          ///
 198:          /// </summary>
 199:          public static void DeleteAgcfEndpointAndH248SubscriberAndSubParty(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, string service, string primarySwitch, string fsdb, out string result)
 200:          {
 201:              alIms.DltNgfsAgcfEndpointV2(service, primarySwitch, fsdb, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response dltNgfsAgcfEndpointResponse);
 202:   
 203:              alIms.DltNgfsSubscriberAndNgfsSubPartyV2(service, primarySwitch, fsdb, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response dltNgfsSubscriberResponse);
 204:   
 205:              result = service + "," + dltNgfsSubscriberResponse.ResultCode.ToString() + "," + dltNgfsAgcfEndpointResponse.ResultCode.ToString();
 206:          }
 207:   
 208:          ////////////////////////////////////////////////////////////////////////////
 209:   
 210:          /// <summary>
 211:          ///
 212:          /// </summary>
 213:          public static void DeleteH248SubscriberAndSubParty(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, string service, Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt, out string result)
 214:          {
 215:              // I use this function sometimes to delete wrong subscriber entries by staff
 216:   
 217:              alIms.DltNgfsSubscriberAndNgfsSubPartyV2(service, nddOnt, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response dltNgfsSubscriberResponse);
 218:   
 219:              result = service + "," + dltNgfsSubscriberResponse.ResultCode.ToString();
 220:          }
 221:   
 222:          ////////////////////////////////////////////////////////////////////////////
 223:   
 224:          /// <summary>
 225:          ///
 226:          /// </summary>
 227:          public static void DeleteSipSubscriber(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, string service, Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt, out string result)
 228:          {
 229:              alIms.DltNgfsSubscriberAndNgfsSubPartyV2(service, nddOnt, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response dltNgfsSubscriberResponse);
 230:   
 231:              result = service + "," + dltNgfsSubscriberResponse.ResultCode.ToString();
 232:          }
 233:   
 234:          ////////////////////////////////////////////////////////////////////////////
 235:          ////////////////////////////////////////////////////////////////////////////
 236:   
 237:   
 238:   
 239:   
 240:   
 241:   
 242:          ////////////////////////////////////////////////////////////////////////////
 243:          ////////////////////////////////////////////////////////////////////////////
 244:   
 245:          /// <summary>
 246:          ///
 247:          /// </summary>
 248:          public static void AssignSupplementaryService(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, string service, Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt, Ia.Ngn.Cl.Model.Business.Service.SupplementaryService supplementaryService, bool supplementaryServiceState, out string result)
 249:          {
 250:              Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response;
 251:   
 252:              switch (supplementaryService)
 253:              {
 254:                  case (Ia.Ngn.Cl.Model.Business.Service.SupplementaryService.CallerId):
 255:                      {
 256:                          alIms.EdNgfsSubscriberV2_CallingLineId(service, nddOnt, supplementaryServiceState, out response);
 257:                          result = service + "," + nddOnt.Access.Name + ",CallerId: " + supplementaryServiceState.ToString().ToLower() + "," + response.ResultCode.ToString();
 258:                          break;
 259:                      }
 260:                  case (Ia.Ngn.Cl.Model.Business.Service.SupplementaryService.AbbriviatedCalling):
 261:                      {
 262:                          alIms.EdNgfsSubscriberV2_OneDigitSpeedDial(service, nddOnt, supplementaryServiceState, out response);
 263:                          result = service + "," + nddOnt.Access.Name + ",AbbriviatedCalling: " + supplementaryServiceState.ToString().ToLower() + "," + response.ResultCode.ToString();
 264:                          break;
 265:                      }
 266:                  case (Ia.Ngn.Cl.Model.Business.Service.SupplementaryService.CallForwarding):
 267:                      {
 268:                          alIms.EdNgfsSubscriberV2_CallForwardingVari(service, nddOnt, supplementaryServiceState, out response);
 269:                          result = service + "," + nddOnt.Access.Name + ",CallForwarding: " + supplementaryServiceState.ToString().ToLower() + "," + response.ResultCode.ToString();
 270:                          break;
 271:                      }
 272:                  case (Ia.Ngn.Cl.Model.Business.Service.SupplementaryService.CallWaiting):
 273:                      {
 274:                          alIms.EdNgfsSubscriberV2_CallWaiting(service, nddOnt, supplementaryServiceState, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response subscriberResponse);
 275:   
 276:                          if (nddOnt.Pon.PonGroup.Olt.IsSip == false) // if H.248
 277:                          {
 278:                              result = service + "," + nddOnt.Access.Name + ",CallWaiting: " + supplementaryServiceState.ToString().ToLower() + ", subscriber: " + subscriberResponse.ResultCode.ToString();
 279:                          }
 280:                          else
 281:                          {
 282:                              alIms.EdNgfsAgcfEndpointV2_CallWaiting(service, nddOnt, supplementaryServiceState, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response agcfEndpointResponse);
 283:   
 284:                              result = service + "," + nddOnt.Access.Name + ",CallWaiting: " + supplementaryServiceState.ToString().ToLower() + ", subscriber: " + subscriberResponse.ResultCode.ToString() + ", agcfEndpoint: " + agcfEndpointResponse.ResultCode.ToString();
 285:                          }
 286:   
 287:                          break;
 288:                      }
 289:                  case (Ia.Ngn.Cl.Model.Business.Service.SupplementaryService.ConferenceCall):
 290:                      {
 291:                          alIms.EdNgfsSubscriberV2_ConferenceCall(service, nddOnt, supplementaryServiceState, out response);
 292:                          result = service + "," + nddOnt.Access.Name + ",ConferenceCall: " + supplementaryServiceState.ToString().ToLower() + "," + response.ResultCode.ToString();
 293:                          break;
 294:                      }
 295:                  case (Ia.Ngn.Cl.Model.Business.Service.SupplementaryService.WakeupCall):
 296:                      {
 297:                          alIms.EdNgfsSubscriberV2_ReminderCall(service, nddOnt, supplementaryServiceState, out response);
 298:                          result = service + "," + nddOnt.Access.Name + ",WakeupCall: " + supplementaryServiceState.ToString().ToLower() + "," + response.ResultCode.ToString();
 299:                          break;
 300:                      }
 301:                  case (Ia.Ngn.Cl.Model.Business.Service.SupplementaryService.InternationalCallingUserControlled):
 302:                      {
 303:                          alIms.EdNgfsSubscriberV2_InternationalCallingUserControlled(service, nddOnt, supplementaryServiceState, out response);
 304:                          result = service + "," + nddOnt.Access.Name + ",InternationalCallingUserControlled: " + supplementaryServiceState.ToString().ToLower() + "," + response.ResultCode.ToString();
 305:                          break;
 306:                      }
 307:                  case (Ia.Ngn.Cl.Model.Business.Service.SupplementaryService.InternationalCalling):
 308:                      {
 309:                          alIms.EdNgfsSubscriberV2_InternationalCalling(service, nddOnt, supplementaryServiceState, out response);
 310:                          result = service + "," + nddOnt.Access.Name + ",InternationalCalling: " + supplementaryServiceState.ToString().ToLower() + "," + response.ResultCode.ToString();
 311:                          break;
 312:                      }
 313:                  case (Ia.Ngn.Cl.Model.Business.Service.SupplementaryService.ServiceSuspension):
 314:                      {
 315:                          alIms.EdNgfsSubscriberV2_ServiceSuspension(service, nddOnt, supplementaryServiceState, out response);
 316:                          result = service + "," + nddOnt.Access.Name + ",ServiceSuspension: " + supplementaryServiceState.ToString().ToLower() + "," + response.ResultCode.ToString();
 317:                          break;
 318:                      }
 319:                  default:
 320:                      {
 321:                          result = service + ",unknown SupplementaryService: " + supplementaryServiceState.ToString().ToLower();
 322:                          break;
 323:                      }
 324:              }
 325:          }
 326:   
 327:          ////////////////////////////////////////////////////////////////////////////
 328:   
 329:          /// <summary>
 330:          ///
 331:          /// </summary>
 332:          public static void AssignServiceSuspensionStateToServiceSubscriber(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, string service, Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt, bool serviceSuspensionState, out string result)
 333:          {
 334:              alIms.EdNgfsSubscriberV2_ServiceSuspension(service, nddOnt, serviceSuspensionState, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response);
 335:   
 336:              result = service + "," + nddOnt.Access.Name + ",service suspension: " + serviceSuspensionState.ToString().ToLower() + "," + response.ResultCode.ToString();
 337:          }
 338:   
 339:          ////////////////////////////////////////////////////////////////////////////
 340:   
 341:          /// <summary>
 342:          ///
 343:          /// </summary>
 344:          public static Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord ReadAgcfGatewayRecordForGwId(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, int gwId, out string result)
 345:          {
 346:              bool b;
 347:              string r;
 348:              Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord agcfGatewayRecord;
 349:   
 350:              r = string.Empty;
 351:   
 352:              agcfGatewayRecord = alIms.RtrvNgfsAgcfGatewayRecordV2(gwId, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response);
 353:   
 354:              if (response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist)
 355:              {
 356:                  b = Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateAgcfGatewayRecord(gwId, response, agcfGatewayRecord, out r);
 357:              }
 358:   
 359:              result = "GatewayRecord: " + gwId + ": " + response.ResultCode.ToString() + ": " + r;
 360:   
 361:              return agcfGatewayRecord;
 362:          }
 363:   
 364:          ////////////////////////////////////////////////////////////////////////////
 365:   
 366:          /// <summary>
 367:          ///
 368:          /// </summary>
 369:          public static Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecordTemp ReadAgcfGatewayRecordFromSkbForGwId(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, int gwId, out string result)
 370:          {
 371:              bool b;
 372:              Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecordTemp agcfGatewayRecord;
 373:   
 374:              agcfGatewayRecord = alIms.RtrvNgfsAgcfGatewayRecordFromSkbV2(gwId, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response);
 375:   
 376:              if (response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist)
 377:              {
 378:                  b = Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateAgcfGatewayRecordForSkb(gwId, response, agcfGatewayRecord);
 379:              }
 380:   
 381:              result = "GatewayRecord: " + gwId + ": " + response.ResultCode.ToString();
 382:   
 383:              return agcfGatewayRecord;
 384:          }
 385:   
 386:          /*
 387:          ////////////////////////////////////////////////////////////////////////////
 388:  
 389:          /// <summary>
 390:          ///
 391:          /// </summary>
 392:          public static void ReadAgcfEndpointListForGwId(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, int gwId, out string result)
 393:          {
 394:              bool b;
 395:              int agcfGatewayRecordId;
 396:              Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt;
 397:              Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord agcfGatewayRecord;
 398:              List<Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint> agcfEndpointList;
 399:  
 400:              // below: read the AgcfGatewayRecord
 401:              agcfGatewayRecordId = Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord.AgcfGatewayRecordId(Ia.Ngn.Cl.Model.Business.Nokia.AgcfGatewayTable.NgfsAgcfGatewayTableAid, gwId);
 402:              agcfGatewayRecord = Ia.Ngn.Cl.Model.Data.Nokia.AgcfGatewayRecord.Read(agcfGatewayRecordId);
 403:  
 404:              if (agcfGatewayRecord != null)
 405:              {
 406:                  nddOnt = Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntIpToOntDictionary.ContainsKey(agcfGatewayRecord.IP1) ? Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntIpToOntDictionary[agcfGatewayRecord.IP1] : null;
 407:  
 408:                  if (nddOnt != null)
 409:                  {
 410:                      agcfEndpointList = alIms.RtrvNgfsAgcfEndpointV2List(agcfGatewayRecord.GwId, nddOnt, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response);
 411:  
 412:                      if (response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.SuccessfulButNoParameters)
 413:                      {
 414:                          b = Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateNgfsAgcfEndpointList(gwId, agcfGatewayRecordId, response, agcfEndpointList);
 415:                      }
 416:                      else if (response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.SessionInvalid) 
 417:                      { 
 418:                      }
 419:                      else throw new Exception(@"Undefined result code """ + response + @""" seen in Ia.Ngn.Cl.Model.Data.Nokia.Ims.ResultCode");
 420:  
 421:                      result = "Endpoint: GwId:" + gwId + ", " + response.ResultCode.ToString();
 422:                  }
 423:                  else
 424:                  {
 425:                      result = "Endpoint: " + "Error: nddOnt == null, GwId:" + gwId;
 426:                  }
 427:              }
 428:              else
 429:              {
 430:                  result = "Endpoint: " + "GwId:" + gwId + ", Exception: " + @"agcfGatewayRecord is null, agcfGatewayRecordsId=" + agcfGatewayRecordId;
 431:              }
 432:          }
 433:          */
 434:   
 435:          ////////////////////////////////////////////////////////////////////////////
 436:   
 437:          /// <summary>
 438:          ///
 439:          /// </summary>
 440:          public static void CreateAgcfGatewayRecordForGwId(Ia.Ngn.Cl.Model.Client.Nokia.Ims nokiaIms, int gwId, Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt, out string result)
 441:          {
 442:              nokiaIms.EntNgfsAgcfGwCombinedRecV2(gwId, nddOnt, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response);
 443:   
 444:              result = response.ResultCode.ToString();
 445:          }
 446:   
 447:          ////////////////////////////////////////////////////////////////////////////
 448:   
 449:          /// <summary>
 450:          ///
 451:          /// </summary>
 452:          public static void ReadUpdateAgcfGatewayRecordAndAgcfEndpointListAndSubPartyAndSubscriberAndServiceForGwId(Ia.Ngn.Cl.Model.Client.Nokia.Ims nokiaIms/*, Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt*/, int gwId, out string result)
 453:          {
 454:              bool agcfGatewayRecordUpdated, agcfEndpointListUpdated, ngfsSubPartyUpdated, ngfsSubscriberUpdated;
 455:              int agcfGatewayRecordId, imsService;
 456:              string service, primarySwitch, partyId, prividUser, subPartyId, r;
 457:              //Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt;
 458:              Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord agcfGatewayRecord;
 459:              Ia.Ngn.Cl.Model.Nokia.SubParty subParty;
 460:              Ia.Ngn.Cl.Model.Nokia.Subscriber subscriber;
 461:              List<Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint> agcfEndpointList;
 462:   
 463:              // Read GwId->Ep(s)->Sp->Sub, and ask about non FSDB sub search on XML
 464:   
 465:              result = "gwId: " + gwId;
 466:   
 467:              agcfGatewayRecordId = Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord.AgcfGatewayRecordId(Ia.Ngn.Cl.Model.Business.Nokia.AgcfGatewayTable.NgfsAgcfGatewayTableAid, gwId);
 468:              agcfGatewayRecord = nokiaIms.RtrvNgfsAgcfGatewayRecordV2(gwId, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response);
 469:   
 470:              if (response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist)
 471:              {
 472:                  agcfGatewayRecordUpdated = Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateAgcfGatewayRecord(gwId, response, agcfGatewayRecord, out r);
 473:   
 474:                  if (!string.IsNullOrEmpty(r)) result += ", UpdateAgcfGatewayRecord: " + r;
 475:   
 476:                  if (agcfGatewayRecord != null)
 477:                  {
 478:                      imsService = Ia.Ngn.Cl.Model.Business.Nokia.Ims.ImsServiceFromAgcfSipIaPort(agcfGatewayRecord.AgcfSipIaPort);
 479:                      primarySwitch = Ia.Ngn.Cl.Model.Business.Nokia.Ims.PrimarySwitchFromAgcfGatewayRecord(agcfGatewayRecord.IsPrimary);
 480:   
 481:                      //if (nddOnt != null) result += " " + nddOnt.Access.Name;
 482:                      //else result += " warning: nddOnt is null for IP: " + agcfGatewayRecord.IP1;
 483:   
 484:                      agcfEndpointList = nokiaIms.RtrvNgfsAgcfEndpointV2List(agcfGatewayRecord.GwId, primarySwitch, imsService, out response);
 485:   
 486:                      if (response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.SuccessfulButNoParameters)
 487:                      {
 488:                          agcfEndpointListUpdated = Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateNgfsAgcfEndpointList(gwId, agcfGatewayRecordId, response, agcfEndpointList);
 489:   
 490:                          agcfEndpointList = Ia.Ngn.Cl.Model.Data.Nokia.AgcfEndpoint.List(gwId);
 491:   
 492:                          if (agcfEndpointList != null)
 493:                          {
 494:                              foreach (Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint agcfEndpoint in agcfEndpointList)
 495:                              {
 496:                                  prividUser = agcfEndpoint.PrividUser;
 497:                                  partyId = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.PartyId(prividUser);
 498:   
 499:                                  subParty = nokiaIms.RtrvNgfsSubPartyV2(partyId, primarySwitch, imsService, out response);
 500:   
 501:                                  if (response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist)
 502:                                  {
 503:                                      ngfsSubPartyUpdated = Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateNgfsSubParty(partyId, agcfEndpoint.Id, response, subParty);
 504:   
 505:                                      // below: read the SubParty
 506:                                      subPartyId = Ia.Ngn.Cl.Model.Nokia.SubParty.SubPartyId(partyId);
 507:                                      subParty = Ia.Ngn.Cl.Model.Data.Nokia.SubParty.Read(subPartyId);
 508:   
 509:                                      if (subParty != null)
 510:                                      {
 511:                                          subscriber = nokiaIms.RtrvNgfsSubscriberV2(partyId, primarySwitch, imsService, out response);
 512:   
 513:                                          if (response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist)
 514:                                          {
 515:                                              service = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.Service(partyId);
 516:   
 517:                                              ngfsSubscriberUpdated = Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateNgfsSubscriber(partyId, subPartyId, response, subscriber);
 518:   
 519:                                              Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateServiceFromAgcfGatewayRecordAndAgcfEndpointAndSubPartyAndSubscriber(service, agcfGatewayRecord, agcfEndpoint, subParty, subscriber);
 520:   
 521:                                              result += "," + service;
 522:                                          }
 523:                                          else
 524:                                          {
 525:                                              result += " error: subscriber: " + response.ResultCode.ToString();
 526:                                          }
 527:                                      }
 528:                                      else
 529:                                      {
 530:                                          result += " subParty is null";
 531:                                      }
 532:                                  }
 533:                                  else
 534:                                  {
 535:                                      result += " error: subParty: " + response.ResultCode.ToString();
 536:                                  }
 537:                              }
 538:                          }
 539:                          else
 540:                          {
 541:                              result += " agcfEndpointList is null";
 542:                          }
 543:                      }
 544:                      else
 545:                      {
 546:                          result += " error: agcfEndpointList: " + response.ResultCode.ToString();
 547:                      }
 548:                  }
 549:                  else
 550:                  {
 551:                      result += " agcfGatewayRecord is null";
 552:                  }
 553:              }
 554:              else
 555:              {
 556:                  result += " error: agcfGatewayRecord: " + response.ResultCode.ToString();
 557:              }
 558:   
 559:              // temp
 560:              //Ia.Ngn.Cl.Model.Data.Nokia.Ims.ReadAgcfGatewayRecordFromSkbForGwId(nokiaIms, gwId, out r2);
 561:              //result += ". AgcfGatewayRecord (SKB): " + r2;
 562:          }
 563:   
 564:          ////////////////////////////////////////////////////////////////////////////
 565:   
 566:          /// <summary>
 567:          ///
 568:          /// </summary>
 569:          public static void ReadUpdateSubPartyAndSubscriberAndServiceForService(Ia.Ngn.Cl.Model.Client.Nokia.Ims nokiaIms, string _service, Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt, out string result)
 570:          {
 571:              bool updated;
 572:              int imsService;
 573:              string service, primarySwitch, partyId, subPartyId;
 574:              Ia.Ngn.Cl.Model.Nokia.SubParty subParty;
 575:              Ia.Ngn.Cl.Model.Nokia.Subscriber subscriber;
 576:              Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response subPartyResponse, subscriberResponse;
 577:   
 578:              result = string.Empty;
 579:   
 580:              partyId = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.PartyId(_service);
 581:              subPartyId = Ia.Ngn.Cl.Model.Nokia.SubParty.SubPartyId(partyId);
 582:              service = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.Service(partyId);
 583:   
 584:              if (nddOnt != null)
 585:              {
 586:                  imsService = nddOnt.ImsService;
 587:                  primarySwitch = nddOnt.PrimarySwitch;
 588:   
 589:                  subParty = nokiaIms.RtrvNgfsSubPartyV2(subPartyId, primarySwitch, imsService, out subPartyResponse);
 590:                  subscriber = nokiaIms.RtrvNgfsSubscriberV2(partyId, primarySwitch, imsService, out subscriberResponse);
 591:   
 592:                  updated = Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateNgfsSubPartyAndNgfsSubscriberWithoutEndPoint(subPartyId, subParty, subPartyResponse, partyId, subscriber, subscriberResponse);
 593:                  Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateServiceFromSubPartyAndSubscriber(service, nddOnt.Access.Id);
 594:              }
 595:              else
 596:              {
 597:                  /*
 598:                  foreach (Ia.Ngn.Cl.Model.Business.Nokia.Ims.ImsBasicService ibs in Ia.Ngn.Cl.Model.Business.Nokia.Ims.ImsBasicServiceList)
 599:                  {
 600:                      Ia.Ngn.Cl.Model.Data.Nokia.Ims.ReadSubPartyAndSubscriber(nokiaIms, service, ibs.PrimarySwitch, ibs.Fsdb, ibs.Service, out string r);
 601:  
 602:                      result += r + ",";
 603:                  }
 604:                  */
 605:              }
 606:          }
 607:   
 608:          ////////////////////////////////////////////////////////////////////////////
 609:   
 610:          /// <summary>
 611:          ///
 612:          /// </summary>
 613:          public static void ReadSubPartyAndSubscriber(Ia.Ngn.Cl.Model.Client.Nokia.Ims nokiaIms, string _service, string primarySwitch, string fsdb, int imsService, out string result)
 614:          {
 615:              bool updated;
 616:              string service, partyId, subPartyId;
 617:              Ia.Ngn.Cl.Model.Nokia.SubParty subParty;
 618:              Ia.Ngn.Cl.Model.Nokia.Subscriber subscriber;
 619:              Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response subPartyResponse, subscriberResponse;
 620:   
 621:              result = string.Empty;
 622:   
 623:              partyId = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.PartyId(_service);
 624:              subPartyId = Ia.Ngn.Cl.Model.Nokia.SubParty.SubPartyId(partyId);
 625:              service = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.Service(partyId);
 626:   
 627:              subParty = nokiaIms.RtrvNgfsSubPartyV2(subPartyId, primarySwitch, imsService, out subPartyResponse);
 628:              subscriber = nokiaIms.RtrvNgfsSubscriberV2(partyId, primarySwitch, imsService, out subscriberResponse);
 629:   
 630:              updated = Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateNgfsSubPartyAndNgfsSubscriberWithoutEndPoint(subPartyId, subParty, subPartyResponse, partyId, subscriber, subscriberResponse);
 631:              Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateServiceFromSubPartyAndSubscriber(service, string.Empty);
 632:          }
 633:   
 634:          ////////////////////////////////////////////////////////////////////////////
 635:   
 636:          /// <summary>
 637:          ///
 638:          /// </summary>
 639:          public static void DeleteAgcfGatewayRecordForGwId(Ia.Ngn.Cl.Model.Client.Nokia.Ims nokiaIms, Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord agcfGatewayRecord, out string result)
 640:          {
 641:              string primarySwitch, secondarySwitch;
 642:   
 643:              primarySwitch = Ia.Ngn.Cl.Model.Business.Nokia.Ims.PrimarySwitchFromAgcfGatewayRecord(agcfGatewayRecord.IsPrimary);
 644:              secondarySwitch = Ia.Ngn.Cl.Model.Business.Nokia.Ims.SecondarySwitchFromAgcfGatewayRecord(agcfGatewayRecord.IsPrimary);
 645:   
 646:              nokiaIms.DltNgfsAgcfGwCombinedRecV2(agcfGatewayRecord.GwId, primarySwitch, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response primarySwitchDeleteResponse);
 647:              nokiaIms.DltNgfsAgcfGwCombinedRecV2(agcfGatewayRecord.GwId, secondarySwitch, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response secondarySwitchDeleteResponse);
 648:   
 649:              result = "Primary: " + primarySwitchDeleteResponse.ResultCode.ToString() + " (FailureReason: " + primarySwitchDeleteResponse.FailureReason.ToString() + "), Secondary: " + secondarySwitchDeleteResponse.ResultCode.ToString() + " (FailureReason: " + secondarySwitchDeleteResponse.FailureReason.ToString() + "). ";
 650:          }
 651:   
 652:          ////////////////////////////////////////////////////////////////////////////
 653:   
 654:          /// <summary>
 655:          ///
 656:          /// </summary>
 657:          public static void DeleteAgcfGatewayRecordForGwId(Ia.Ngn.Cl.Model.Client.Nokia.Ims nokiaIms, int gwId, out string result)
 658:          {
 659:              string firstSwitch, secondSwitch;
 660:   
 661:              firstSwitch = Ia.Ngn.Cl.Model.Business.Nokia.Ims.TEC;
 662:              secondSwitch = Ia.Ngn.Cl.Model.Business.Nokia.Ims.SKB;
 663:   
 664:              nokiaIms.DltNgfsAgcfGwCombinedRecV2(gwId, firstSwitch, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response primarySwitchDeleteResponse);
 665:              nokiaIms.DltNgfsAgcfGwCombinedRecV2(gwId, secondSwitch, out Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response secondarySwitchDeleteResponse);
 666:   
 667:              result = "First: " + primarySwitchDeleteResponse.ResultCode.ToString() + ", Second: " + secondarySwitchDeleteResponse.ResultCode.ToString() + ". ";
 668:          }
 669:   
 670:          /*
 671:          ////////////////////////////////////////////////////////////////////////////
 672:  
 673:          /// <summary>
 674:          ///
 675:          /// </summary>
 676:          public static void ReadAgcfEndpointAndSubPartyAndSubscriberForService(Ia.Ngn.Cl.Model.Client.Nokia.Ims alIms, int gwId, string service, out string result)
 677:          {
 678:              bool ngfsSubPartyUpdated, ngfsSubscriberUpdated;
 679:              int imsService;
 680:              string primarySwitch, partyId, prividUser, subPartyId;
 681:              Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt;
 682:              Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord agcfGatewayRecord;
 683:              Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint agcfEndpoint;
 684:              Ia.Ngn.Cl.Model.Nokia.SubParty subParty;
 685:              Ia.Ngn.Cl.Model.Nokia.Subscriber subscriber;
 686:              Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response;
 687:  
 688:              result = "service: " + service + ", gwId: " + gwId;
 689:  
 690:              prividUser = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.PrividUser(service);
 691:              partyId = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.PartyId(service);
 692:  
 693:              Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord agcfGatewayRecord;
 694:  
 695:              agcfEndpoint = alIms.RtrvNgfsAgcfEndpointV2(prividUser, primarySwitch, imsService, out response);
 696:  
 697:              if (response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PLX_SERVICE_OBJECT_DOES_NOT_EXIST || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.SuccessfulButNoParameters)
 698:              {
 699:                  agcfEndpoint = Ia.Ngn.Cl.Model.Data.Nokia.AgcfEndpoint.Read(prividUser);
 700:  
 701:                  if (agcfEndpoint != null)
 702:                  {
 703:                      nddOnt = (from q in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList where q.Ip == agcfEndpoint.AgcfGatewayRecord.IP1 select q).SingleOrDefault();
 704:                      imsService = Ia.Ngn.Cl.Model.Business.Nokia.Ims.ImsServiceFromAgcfSipIaPort(agcfEndpoint.AgcfGatewayRecord.AgcfSipIaPort);
 705:                      primarySwitch = Ia.Ngn.Cl.Model.Business.Nokia.Ims.PrimarySwitchFromAgcfGatewayRecord(agcfEndpoint.AgcfGatewayRecord.IsPrimary);
 706:  
 707:                      if (nddOnt != null) result += " " + nddOnt.Access.Name;
 708:                      else result += " warning: nddOnt is null for IP: " + agcfEndpoint.AgcfGatewayRecord.IP1;
 709:  
 710:                      subParty = alIms.RtrvNgfsSubPartyV2(partyId, primarySwitch, imsService, out response);
 711:  
 712:                      if (response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PLX_SERVICE_OBJECT_DOES_NOT_EXIST)
 713:                      {
 714:                          ngfsSubPartyUpdated = Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateNgfsSubParty(partyId, agcfEndpoint.Id, response, subParty);
 715:  
 716:                          // below: read the SubParty
 717:                          subPartyId = Ia.Ngn.Cl.Model.Nokia.SubParty.SubPartyId(partyId);
 718:                          subParty = Ia.Ngn.Cl.Model.Nokia.SubParty.Read(subPartyId);
 719:  
 720:                          if (subParty != null)
 721:                          {
 722:                              subscriber = alIms.RtrvNgfsSubscriberV2(partyId, primarySwitch, imsService, out response);
 723:  
 724:                              if (response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful || response.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PLX_SERVICE_OBJECT_DOES_NOT_EXIST)
 725:                              {
 726:                                  service = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.Service(partyId);
 727:  
 728:                                  ngfsSubscriberUpdated = Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateNgfsSubscriber(partyId, subPartyId, response, subscriber);
 729:  
 730:                                  Ia.Ngn.Cl.Model.Data.Nokia.Ims.UpdateServiceFromAgcfEndpointAndSubPartyAndSubscriber(service, agcfEndpoint, subParty, subscriber);
 731:  
 732:                                  result += "," + service;
 733:                              }
 734:                              else
 735:                              {
 736:                                  result += " error: subscriber: " + response.ResultCode.ToString();
 737:                              }
 738:                          }
 739:                          else
 740:                          {
 741:                              result += " subParty is null";
 742:                          }
 743:                      }
 744:                      else
 745:                      {
 746:                          result += " error: subParty: " + response.ResultCode.ToString();
 747:                      }
 748:                  }
 749:                  else
 750:                  {
 751:                      result += " agcfEndpoint is null";
 752:                  }
 753:              }
 754:              else
 755:              {
 756:                  result += " error: agcfEndpointList: " + response.ResultCode.ToString();
 757:              }
 758:          }
 759:          */
 760:   
 761:          ////////////////////////////////////////////////////////////////////////////
 762:   
 763:          /// <summary>
 764:          ///
 765:          /// </summary>
 766:          public static bool UpdateAgcfGatewayRecord(int gwId, Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response, Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord newAgcfGatewayRecord, out string result)
 767:          {
 768:              bool updated;
 769:              int id, tableId;
 770:              Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord agcfGatewayRecord;
 771:   
 772:              tableId = Ia.Ngn.Cl.Model.Business.Nokia.AgcfGatewayTable.NgfsAgcfGatewayTableAid;
 773:   
 774:              result = string.Empty;
 775:   
 776:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 777:              {
 778:                  id = Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord.AgcfGatewayRecordId(tableId, gwId);
 779:   
 780:                  agcfGatewayRecord = (from gr in db.AgcfGatewayRecords where gr.Id == id select gr).Include(gr => gr.AgcfEndpoints).SingleOrDefault();
 781:   
 782:                  switch (response.ResultCode)
 783:                  {
 784:                      case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful:
 785:                          {
 786:                              if (agcfGatewayRecord == null)
 787:                              {
 788:                                  newAgcfGatewayRecord.Created = newAgcfGatewayRecord.Updated = DateTime.UtcNow.AddHours(3);
 789:                                  db.AgcfGatewayRecords.Add(newAgcfGatewayRecord);
 790:   
 791:                                  updated = true;
 792:                              }
 793:                              else
 794:                              {
 795:                                  if (agcfGatewayRecord.Update(newAgcfGatewayRecord))
 796:                                  {
 797:                                      db.AgcfGatewayRecords.Attach(agcfGatewayRecord);
 798:                                      db.Entry(agcfGatewayRecord).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
 799:   
 800:                                      updated = true;
 801:                                  }
 802:                                  else updated = false;
 803:                              }
 804:   
 805:                              break;
 806:                          }
 807:                      case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist:
 808:                          {
 809:                              if (agcfGatewayRecord != null)
 810:                              {
 811:                                  // below: delete if foreign key is not null or zero
 812:                                  if (agcfGatewayRecord.AgcfEndpoints == null || agcfGatewayRecord.AgcfEndpoints.Count == 0)
 813:                                  {
 814:                                      db.AgcfGatewayRecords.Remove(agcfGatewayRecord);
 815:   
 816:                                      updated = true;
 817:                                  }
 818:                                  else
 819:                                  {
 820:                                      updated = false;
 821:   
 822:                                      result = "AGCF gateway record for GwId " + gwId + " does not exist in IMS, but agcfGatewayRecord.AgcfEndpoints != null && agcfGatewayRecord.AgcfEndpoints.Count > 0. ";
 823:                                  }
 824:                              }
 825:                              else updated = false;
 826:   
 827:                              break;
 828:                          }
 829:                      default: updated = false; break;
 830:                  }
 831:   
 832:                  db.SaveChanges();
 833:              }
 834:   
 835:              return updated;
 836:          }
 837:   
 838:          ////////////////////////////////////////////////////////////////////////////
 839:   
 840:          /// <summary>
 841:          ///
 842:          /// </summary>
 843:          public static bool UpdateAgcfGatewayRecordForSkb(int gwId, Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response, Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecordTemp newAgcfGatewayRecord)
 844:          {
 845:              bool updated;
 846:              int id, tableId;
 847:              Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecordTemp agcfGatewayRecord;
 848:   
 849:              tableId = Ia.Ngn.Cl.Model.Business.Nokia.AgcfGatewayTable.NgfsAgcfGatewayTableAid;
 850:   
 851:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 852:              {
 853:                  id = Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord.AgcfGatewayRecordId(tableId, gwId);
 854:   
 855:                  agcfGatewayRecord = (from gr in db.AgcfGatewayRecordTemps where gr.Id == id select gr).SingleOrDefault();
 856:   
 857:                  switch (response.ResultCode)
 858:                  {
 859:                      case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful:
 860:                          {
 861:                              if (agcfGatewayRecord == null)
 862:                              {
 863:                                  newAgcfGatewayRecord.Created = newAgcfGatewayRecord.Updated = DateTime.UtcNow.AddHours(3);
 864:                                  db.AgcfGatewayRecordTemps.Add(newAgcfGatewayRecord);
 865:   
 866:                                  updated = true;
 867:                              }
 868:                              else
 869:                              {
 870:                                  if (agcfGatewayRecord.Update(newAgcfGatewayRecord, out string result))
 871:                                  {
 872:                                      db.AgcfGatewayRecordTemps.Attach(agcfGatewayRecord);
 873:                                      db.Entry(agcfGatewayRecord).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
 874:   
 875:                                      updated = true;
 876:                                  }
 877:                                  else updated = false;
 878:                              }
 879:   
 880:                              break;
 881:                          }
 882:                      case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist:
 883:                          {
 884:                              if (agcfGatewayRecord != null)
 885:                              {
 886:                                  // below: delete if foreign key is not null or zero
 887:                                  if (agcfGatewayRecord.AgcfEndpoints == null || agcfGatewayRecord.AgcfEndpoints.Count == 0)
 888:                                  {
 889:                                      db.AgcfGatewayRecordTemps.Remove(agcfGatewayRecord);
 890:   
 891:                                      updated = true;
 892:                                  }
 893:                                  else updated = false;
 894:                              }
 895:                              else updated = false;
 896:   
 897:                              break;
 898:                          }
 899:                      default: updated = false; break;
 900:                  }
 901:   
 902:                  db.SaveChanges();
 903:              }
 904:   
 905:              return updated;
 906:          }
 907:   
 908:          ////////////////////////////////////////////////////////////////////////////
 909:   
 910:          /// <summary>
 911:          ///
 912:          /// </summary>
 913:          public static bool UpdateNgfsAgcfEndpoint(string prividUser, Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response, Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint newAgcfEndpoint)
 914:          {
 915:              bool isOk;
 916:              int agcfGatewayRecordsId;
 917:              string id;
 918:              Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint agcfEndpoint;
 919:   
 920:              isOk = false;
 921:   
 922:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 923:              {
 924:                  id = Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint.AgcfEndpointId(prividUser);
 925:   
 926:                  agcfEndpoint = (from ep in db.AgcfEndpoints where ep.Id == id select ep).SingleOrDefault();
 927:   
 928:                  switch (response.ResultCode)
 929:                  {
 930:                      case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful:
 931:                          {
 932:                              if (agcfEndpoint == null)
 933:                              {
 934:                                  newAgcfEndpoint.Created = newAgcfEndpoint.Updated = DateTime.UtcNow.AddHours(3);
 935:                                  db.AgcfEndpoints.Add(newAgcfEndpoint);
 936:                              }
 937:                              else
 938:                              {
 939:                                  // below: reference
 940:                                  agcfGatewayRecordsId = Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord.AgcfGatewayRecordId(Ia.Ngn.Cl.Model.Business.Nokia.AgcfGatewayTable.NgfsAgcfGatewayTableAid, newAgcfEndpoint.GwId);
 941:                                  newAgcfEndpoint.AgcfGatewayRecord = (from gr in db.AgcfGatewayRecords where gr.Id == agcfGatewayRecordsId select gr).SingleOrDefault();
 942:   
 943:                                  if (agcfEndpoint.Update(newAgcfEndpoint))
 944:                                  {
 945:                                      db.AgcfEndpoints.Attach(agcfEndpoint);
 946:                                      db.Entry(agcfEndpoint).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
 947:                                  }
 948:                              }
 949:   
 950:                              break;
 951:                          }
 952:                      case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist:
 953:                          {
 954:                              if (agcfEndpoint != null)
 955:                              {
 956:                                  // below: skip delete if the foreign key is not null
 957:                                  if (agcfEndpoint.SubParties == null)
 958:                                  {
 959:                                      db.AgcfEndpoints.Remove(agcfEndpoint);
 960:                                  }
 961:                              }
 962:                              break;
 963:                          }
 964:                  }
 965:   
 966:                  db.SaveChanges();
 967:   
 968:                  isOk = true;
 969:              }
 970:   
 971:              return isOk;
 972:          }
 973:   
 974:          ////////////////////////////////////////////////////////////////////////////
 975:   
 976:          /// <summary>
 977:          ///
 978:          /// </summary>
 979:          public static bool UpdateNgfsAgcfEndpointList(int gwId, int agcfGatewayRecordId, Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response, List<Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint> newAgcfEndpointList)
 980:          {
 981:              bool updated;
 982:              Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord agcfGatewayRecord;
 983:              Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint agcfEndpoint;
 984:              List<Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint> agcfEndpointList;
 985:   
 986:              updated = false;
 987:   
 988:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 989:              {
 990:                  agcfEndpointList = (from ep in db.AgcfEndpoints where ep.GwId == gwId select ep).Include(ep => ep.SubParties).ToList();
 991:   
 992:                  switch (response.ResultCode)
 993:                  {
 994:                      case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful:
 995:                          {
 996:                              // below: add or update read endpoints
 997:                              foreach (Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint newAgcfEndpoint in newAgcfEndpointList)
 998:                              {
 999:                                  // below: reference
                                agcfGatewayRecord = (from gr in db.AgcfGatewayRecords where gr.Id == agcfGatewayRecordId select gr).SingleOrDefault();
                                agcfEndpoint = (from ep in db.AgcfEndpoints where ep.Id == newAgcfEndpoint.Id select ep).SingleOrDefault();
                                newAgcfEndpoint.AgcfGatewayRecord = agcfGatewayRecord;
 
                                if (agcfEndpoint == null)
                                {
                                    newAgcfEndpoint.Created = newAgcfEndpoint.Updated = DateTime.UtcNow.AddHours(3);
                                    db.AgcfEndpoints.Add(newAgcfEndpoint);
 
                                    updated = updated || true;
                                }
                                else
                                {
                                    if (agcfEndpoint.Update(newAgcfEndpoint))
                                    {
                                        db.AgcfEndpoints.Attach(agcfEndpoint);
                                        db.Entry(agcfEndpoint).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
 
                                        updated = updated || true;
                                    }
                                    else updated = updated || false;
                                }
                            }
 
                            // below: remove stored endpoint that do not exist in read
                            if (agcfEndpointList != null && agcfEndpointList.Count > 0)
                            {
                                foreach (Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint storedAgcfEndpoint in agcfEndpointList)
                                {
                                    agcfEndpoint = (from a in newAgcfEndpointList where a.Id == storedAgcfEndpoint.Id select a).SingleOrDefault();
 
                                    if (agcfEndpoint == null && (storedAgcfEndpoint.SubParties == null || storedAgcfEndpoint.SubParties.Count == 0))
                                    {
                                        db.AgcfEndpoints.Remove(storedAgcfEndpoint);
 
                                        updated = updated || true;
                                    }
                                }
                            }
 
                            break;
                        }
                    case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.SuccessfulButNoParameters:
                    case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist:
                        {
                            if (agcfEndpointList != null && agcfEndpointList.Count > 0)
                            {
                                foreach (Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint deletedAgcfEndpoint in agcfEndpointList)
                                {
                                    // below: delete if foreign key is not null or zero
                                    if (deletedAgcfEndpoint.SubParties == null || deletedAgcfEndpoint.SubParties.Count == 0)
                                    {
                                        db.AgcfEndpoints.Remove(deletedAgcfEndpoint);
 
                                        updated = updated || true;
                                    }
                                    else updated = updated || false;
 
                                }
                            }
                            break;
                        }
                    default: updated = updated || false; break;
                }
 
                db.SaveChanges();
            }
 
            return updated;
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static bool UpdateNgfsSubParty(string partyId, string agcfEndpointId, Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response, Ia.Ngn.Cl.Model.Nokia.SubParty newSubParty)
        {
            bool updated;
            string id;
            Ia.Ngn.Cl.Model.Nokia.SubParty subParty;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                id = Ia.Ngn.Cl.Model.Nokia.SubParty.SubPartyId(partyId);
 
                subParty = (from sp in db.SubParties where sp.Id == id select sp).Include(sp => sp.Subscribers).SingleOrDefault();
 
                switch (response.ResultCode)
                {
                    case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful:
                        {
                            // below: reference
                            agcfEndpointId = Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint.AgcfEndpointId(agcfEndpointId);
                            newSubParty.AgcfEndpoint = (from ep in db.AgcfEndpoints where ep.Id == agcfEndpointId select ep).SingleOrDefault();
 
                            if (subParty == null)
                            {
                                newSubParty.Created = newSubParty.Updated = DateTime.UtcNow.AddHours(3);
                                db.SubParties.Add(newSubParty);
 
                                updated = true;
                            }
                            else
                            {
                                // below: they don't
                                // <PrimaryPUID>icsSubAgcfpuid</PrimaryPUID> in <SubParty> element of ent-ngfs-subscriber-v2 has to match <Dn>icsSubAgcfpuid</Dn> in ent-ngfs-agcfendpoint-v2
 
                                if (subParty.Update(newSubParty))
                                {
                                    db.SubParties.Attach(subParty);
                                    db.Entry(subParty).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
 
                                    updated = true;
                                }
                                else updated = false;
                            }
 
                            break;
                        }
                    case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist:
                        {
                            if (subParty != null)
                            {
                                // below: delete if foreign key is not null or zero
                                if (subParty.Subscribers == null || subParty.Subscribers.Count == 0)
                                {
                                    db.SubParties.Remove(subParty);
 
                                    updated = true;
                                }
                                else updated = false;
                            }
                            else updated = false;
                            break;
                        }
                    default: updated = false; break;
                }
 
                db.SaveChanges();
            }
 
            return updated;
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static bool UpdateNgfsSubPartyAndNgfsSubscriberWithoutEndPoint(string subPartyId, Ia.Ngn.Cl.Model.Nokia.SubParty retrievedSubParty, Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response retrievedSubPartyResponse, string partyId, Ia.Ngn.Cl.Model.Nokia.Subscriber retrievedSubscriber, Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response retrievedSubscriberResponse)
        {
            bool updated;
            Ia.Ngn.Cl.Model.Nokia.SubParty subParty;
            Ia.Ngn.Cl.Model.Nokia.Subscriber subscriber;
 
            updated = false;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                subParty = (from sp in db.SubParties where sp.Id == subPartyId select sp).SingleOrDefault();
                subscriber = (from s in db.Subscribers where s.Id == partyId select s).SingleOrDefault();
 
                if (retrievedSubParty != null && retrievedSubPartyResponse.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful && retrievedSubscriber != null && retrievedSubscriberResponse.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful)
                {
                    if (subParty == null)
                    {
                        retrievedSubParty.Created = retrievedSubParty.Updated = DateTime.UtcNow.AddHours(3);
                        db.SubParties.Add(retrievedSubParty);
 
                        updated = true;
                    }
                    else
                    {
                        if (subParty.Update(retrievedSubParty))
                        {
                            db.SubParties.Attach(subParty);
                            db.Entry(subParty).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
 
                            updated = true;
                        }
                    }
 
                    // below: reference
                    retrievedSubscriber.SubParty = (from sp in db.SubParties where sp.Id == retrievedSubParty.Id select sp).SingleOrDefault();
 
                    if (subscriber == null)
                    {
                        retrievedSubscriber.Created = retrievedSubscriber.Updated = DateTime.UtcNow.AddHours(3);
                        db.Subscribers.Add(retrievedSubscriber);
 
                        updated = true;
                    }
                    else
                    {
                        if (subscriber.Update(retrievedSubscriber))
                        {
                            db.Subscribers.Attach(subscriber);
                            db.Entry(subscriber).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
 
                            updated = true;
                        }
                    }
                }
                else if (retrievedSubParty == null && retrievedSubPartyResponse.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist && retrievedSubscriber == null && retrievedSubscriberResponse.ResultCode == Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist)
                {
                    if (subscriber != null)
                    {
                        db.Subscribers.Remove(subscriber);
 
                        updated = true;
                    }
 
                    if (subParty != null)
                    {
                        db.SubParties.Remove(subParty);
 
                        updated = true;
                    }
                }
                else
                {
 
                }
 
                db.SaveChanges();
            }
 
            return updated;
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static bool UpdateNgfsSubscriber(string partyId, string subPartyId, Ia.Ngn.Cl.Model.Business.Nokia.Ims.Response response, Ia.Ngn.Cl.Model.Nokia.Subscriber newSubscriber)
        {
            bool updated;
            string id;
            Ia.Ngn.Cl.Model.Nokia.Subscriber subscriber;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                id = Ia.Ngn.Cl.Model.Nokia.Subscriber.SubscriberId(partyId);
 
                subscriber = (from s in db.Subscribers where s.Id == id select s).SingleOrDefault();
 
                switch (response.ResultCode)
                {
                    case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.Successful:
                        {
                            // below: reference
                            newSubscriber.SubParty = (from s in db.SubParties where s.Id == subPartyId select s).SingleOrDefault();
 
                            if (subscriber == null)
                            {
                                newSubscriber.Created = newSubscriber.Updated = DateTime.UtcNow.AddHours(3);
                                db.Subscribers.Add(newSubscriber);
 
                                updated = true;
                            }
                            else
                            {
                                if (subscriber.Update(newSubscriber))
                                {
                                    db.Subscribers.Attach(subscriber);
                                    db.Entry(subscriber).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
 
                                    updated = true;
                                }
                                else updated = false;
                            }
 
                            break;
                        }
                    case Ia.Ngn.Cl.Model.Client.Nokia.Ims.ResultCode.PlxServiceObjectDoesNotExist:
                        {
                            if (subscriber != null)
                            {
                                db.Subscribers.Remove(subscriber);
 
                                updated = true;
                            }
                            else updated = false;
 
                            break;
                        }
                    default: updated = false; break;
                }
 
                db.SaveChanges();
            }
 
            return updated;
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static bool UpdateServiceFromAgcfGatewayRecordAndAgcfEndpointAndSubPartyAndSubscriber(string service, Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord agcfGatewayRecord, Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint agcfEndpoint, Ia.Ngn.Cl.Model.Nokia.SubParty subParty, Ia.Ngn.Cl.Model.Nokia.Subscriber subscriber)
        {
            bool insert, update, delete;
            int serviceType;
            string serviceId;
            Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont nddOnt;
            Ia.Ngn.Cl.Model.Service2 service2, newService;
 
            insert = update = delete = false;
            //result = new Ia.Cl.Model.Result();
 
            serviceType = Ia.Ngn.Cl.Model.Business.Service.ServiceType.ImsService;
            serviceId = Ia.Ngn.Cl.Model.Business.Service2.ServiceId(service, serviceType);
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (agcfGatewayRecord != null && agcfEndpoint != null && subParty != null && subscriber != null)
                {
                    newService = new Ia.Ngn.Cl.Model.Service2();
 
                    newService.Id = serviceId;
                    newService.AreaCode = Ia.Ngn.Cl.Model.Business.Service.CountryCode;
                    newService.Service = service;
                    newService.ServiceType = serviceType;
 
                    newService.CallerId = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.CallingLineIdIsAssigned(subscriber._CallingLineId);
                    newService.AbbriviatedCalling = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.OneDigitSpeedDialIsAssigned(subscriber._OneDigitSpeedDial);
                    newService.CallForwarding = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.CallForwardingIsAssigned(subscriber._CallForwardingVari);
                    newService.CallWaiting = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.CallWaitingIsAssigned(subscriber._CallWaiting, agcfEndpoint.CallWaitingLc);
                    newService.ConferenceCall = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.ConferenceCallIsAssigned(subscriber._ConferenceCalling);
                    newService.InternationalCalling = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.InternationalCallingIsAssigned(subscriber._CallBarring);
                    newService.InternationalCallingUserControlled = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.InternationalCallingUserControlledIsAssigned(subscriber._OutgoingCallBarring);
 
                    newService.AlarmCall = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.ReminderCallIsAssigned(subscriber._ReminderCall);
                    newService.WakeupCall = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.ReminderCallIsAssigned(subscriber._ReminderCall);
 
                    newService.ServiceSuspension = subParty.ServiceSuspension;
                    //newService.CallBarring = subParty.ServiceSuspension;
 
                    newService.Pin = int.TryParse(subParty.Pin, out int i) ? i : 0;
 
                    nddOnt = Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntIpToOntDictionary.ContainsKey(agcfGatewayRecord.IP1) ? Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntIpToOntDictionary[agcfGatewayRecord.IP1] : null;
 
                    if (nddOnt != null) newService.Access = (from a in db.Accesses where a.Id == nddOnt.Access.Id select a).SingleOrDefault();
                    else newService.Access = null;
 
                    service2 = (from s in db.Service2
                                where s.ServiceType == Ia.Ngn.Cl.Model.Business.Service.ServiceType.ImsService && s.Id == newService.Id
                                select s).SingleOrDefault();
 
                    if (service2 == null)
                    {
                        newService.Created = newService.Updated = DateTime.UtcNow.AddHours(3);
                        db.Service2.Add(newService);
 
                        insert = true;
                    }
                    else
                    {
                        if (service2.Update(newService))
                        {
                            db.Service2.Attach(service2);
                            db.Entry(service2).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
 
                            update = true;
                        }
                        else update = false;
                    }
                }
                else
                {
                    service2 = (from s in db.Service2
                                where s.ServiceType == Ia.Ngn.Cl.Model.Business.Service.ServiceType.ImsService && s.Id == serviceId
                                select s).SingleOrDefault();
 
                    if (service2 != null)
                    {
                        db.Service2.Remove(service2);
 
                        delete = true;
                    }
                }
 
                db.SaveChanges();
            }
 
            //result.AddSuccess(service + ": state: " + Ia.Ngn.Cl.Model.Ui.Text.ExpressionOfInsertOrUpdateOrDelete(insert, update, delete));
 
            return insert || update || delete;
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static bool UpdateServiceFromSubPartyAndSubscriber(string service, string accessId)
        {
            bool insert, update, delete;
            int serviceType;
            string serviceId;
            Ia.Ngn.Cl.Model.Nokia.SubParty subParty;
            Ia.Ngn.Cl.Model.Nokia.Subscriber subscriber;
            Ia.Ngn.Cl.Model.Service2 service2, newService;
 
            insert = update = delete = false;
            //result = new Ia.Cl.Model.Result();
 
            serviceType = Ia.Ngn.Cl.Model.Business.Service.ServiceType.ImsService;
            serviceId = Ia.Ngn.Cl.Model.Business.Service2.ServiceId(service, serviceType);
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                var partyId = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.PartyId(service);
                var subPartyId = Ia.Ngn.Cl.Model.Nokia.SubParty.SubPartyId(partyId);
 
                subParty = (from sp in db.SubParties where sp.Id == subPartyId select sp).SingleOrDefault();
                subscriber = (from s in db.Subscribers where s.Id == partyId select s).SingleOrDefault();
 
                if (subParty != null && subscriber != null)
                {
                    newService = new Ia.Ngn.Cl.Model.Service2();
 
                    newService.Id = serviceId;
                    newService.AreaCode = Ia.Ngn.Cl.Model.Business.Service.CountryCode;
                    newService.Service = service;
                    newService.ServiceType = serviceType;
 
                    newService.CallerId = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.CallingLineIdIsAssigned(subscriber._CallingLineId);
                    newService.AbbriviatedCalling = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.OneDigitSpeedDialIsAssigned(subscriber._OneDigitSpeedDial);
                    newService.CallForwarding = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.CallForwardingIsAssigned(subscriber._CallForwardingVari);
                    newService.CallWaiting = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.CallWaitingIsAssigned(subscriber._CallWaiting, false);// agcfEndpoint.CallWaitingLc);
                    newService.ConferenceCall = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.ConferenceCallIsAssigned(subscriber._ConferenceCalling);
                    newService.InternationalCalling = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.InternationalCallingIsAssigned(subscriber._CallBarring);
                    newService.InternationalCallingUserControlled = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.InternationalCallingUserControlledIsAssigned(subscriber._OutgoingCallBarring);
 
                    newService.AlarmCall = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.ReminderCallIsAssigned(subscriber._ReminderCall);
                    newService.WakeupCall = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.ReminderCallIsAssigned(subscriber._ReminderCall);
 
                    newService.ServiceSuspension = subParty.ServiceSuspension;
                    //newService.CallBarring = subParty.ServiceSuspension;
 
                    newService.Pin = int.TryParse(subParty.Pin, out int i) ? i : 0;
 
                    if (!string.IsNullOrEmpty(accessId)) newService.Access = (from a in db.Accesses where a.Id == accessId select a).SingleOrDefault();
                    else newService.Access = null;
 
                    service2 = (from s in db.Service2
                                where s.ServiceType == Ia.Ngn.Cl.Model.Business.Service.ServiceType.ImsService && s.Id == newService.Id
                                select s).SingleOrDefault();
 
                    if (service2 == null)
                    {
                        newService.Created = newService.Updated = DateTime.UtcNow.AddHours(3);
                        db.Service2.Add(newService);
 
                        insert = true;
                    }
                    else
                    {
                        if (service2.Update(newService))
                        {
                            db.Service2.Attach(service2);
                            db.Entry(service2).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
 
                            update = true;
                        }
                        else update = false;
                    }
                }
                else
                {
                    service2 = (from s in db.Service2
                                where s.ServiceType == Ia.Ngn.Cl.Model.Business.Service.ServiceType.ImsService && s.Id == serviceId
                                select s).SingleOrDefault();
 
                    if (service2 != null)
                    {
                        db.Service2.Remove(service2);
 
                        delete = true;
                    }
                }
 
                db.SaveChanges();
            }
 
            //result.AddSuccess(service + ": state: " + Ia.Ngn.Cl.Model.Ui.Text.ExpressionOfInsertOrUpdateOrDelete(insert, update, delete));
 
            return insert || update || delete;
        }
 
        /*
        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        ///
        /// </summary>
        public static bool UpdateServiceList(Dictionary<long, Ia.Ngn.Cl.Model.Service> dnServiceDictionary)
        {
            bool isOk;
            int serviceType;
            long dn;
            string serviceId;
            Ia.Ngn.Cl.Model.Service service;
            Ia.Ngn.Cl.Model.Service2 service2, newService2;
            isOk = false;
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                // below:
                foreach (KeyValuePair<long, Ia.Ngn.Cl.Model.Service> u in dnServiceDictionary)
                {
                    dn = u.Key;
                    service = u.Value;
                    serviceType = Ia.Ngn.Cl.Model.Business.Service.ServiceType.Ngn;
                    serviceId = Ia.Ngn.Cl.Model.Service2.ServiceId(dn.ToString().Remove(0, 3), serviceType); // temp: remove 3 digits
                    // below:
                    if (service != null)
                    {
                        newService2 = new Ia.Ngn.Cl.Model.Service2();
                        newService2.Id = serviceId;
                        newService2.AreaCode = Ia.Ngn.Cl.Model.Data.Service.CountryCode;
                        newService2.Service = dn.ToString();
                        newService2.ServiceType = serviceType;
                        //newService2.ServiceSuspension = ??
                        newService2.CallBarring = service.OCBUC_ass;
                        newService2.CallForwarding = service.CFU_ass;
                        newService2.ConferenceCall = service.CONF;
                        //newService2.ConferenceCall = service.TPS_ass;
                        newService2.AlarmCall = service.ALM_ass;
                        newService2.CallWaiting = service.CW_ass;
                        newService2.Pin = service.PIN_code;
                        newService2.CallerId = service.CLIP;
                        service2 = (from q in db.Service2s where s.ServiceType == Ia.Ngn.Cl.Model.Business.Service.ServiceType.NgnService && q.Id == newService2.Id select q).SingleOrDefault();
                        if (service2 == null)
                        {
                            newService2.Created = newService2.Updated = DateTime.UtcNow.AddHours(3);
                            db.Service2s.Add(newService2);
                        }
                        else
                        {
                            if (service2.Update(newService2))
                            {
                                db.Service2s.Attach(service2);
                                db.Entry(service2).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
                            }
                        }
                    }
                    else
                    {
                        service2 = (from q in db.Service2s where s.ServiceType == Ia.Ngn.Cl.Model.Business.Service.ServiceType.NgnService && q.Id == serviceId select q).SingleOrDefault();
                        if (service2 != null) db.Service2s.Remove(service2);
                    }
                }
                db.SaveChanges();
                isOk = true;
            }
            return isOk;
        }
         */
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static List<int> AllPossibleGatewayIdList
        {
            get
            {
                // below: GwId are defined by Nokia
 
                List<int> allPossibleGatewayIdList;
 
                allPossibleGatewayIdList = new List<int>(Ia.Ngn.Cl.Model.Business.Nokia.Ims.LastGatewayId - Ia.Ngn.Cl.Model.Business.Nokia.Ims.FirstGatewayId);
 
                //allPossibleGatewayIdList = Ia.Ngn.Cl.Model.Data.Nokia.Default.GatewayIdList;
 
                for (int i = Ia.Ngn.Cl.Model.Business.Nokia.Ims.FirstGatewayId; i <= Ia.Ngn.Cl.Model.Business.Nokia.Ims.LastGatewayId; i++)
                {
                    allPossibleGatewayIdList.Add(i);
                }
 
                return allPossibleGatewayIdList;
            }
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Ont> AllPossibleOntNotInAgcfGatewayRecordList(Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Olt olt)
        {
            DiscrepancyBetweenOntListAndAgctGatewayRecordList(olt, out List<Ia.Ngn.Cl.Model.Ont> ontsNotInAgcfGatewayRecordsList, out List<Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord> agcfGatewayRecordsNoInOntsList);
 
            return ontsNotInAgcfGatewayRecordsList;
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> NddOntNotInAgcfGatewayRecordList(Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Olt olt)
        {
            List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> ngnOntList;
            List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> ngnOntsNotInAgcfGatewayRecordsList;
            List<Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord> agcfGatewayRecordList;
 
            // below: NGN ONT list
            ngnOntList = (from o in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList
                          where o.Pon.PonGroup.Olt.Id == olt.Id
                          select o).ToList();
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                // below: AgcfGatewayRecord list
                agcfGatewayRecordList = (from a in db.AgcfGatewayRecords select a).AsNoTracking().ToList();
            }
 
            // below: ONTs not in AgcfGatewayRecord list
            ngnOntsNotInAgcfGatewayRecordsList = (from no in ngnOntList
                                                  join a in agcfGatewayRecordList on no.Ip equals a.IP1
                                                  into gj
                                                  from sub in gj.DefaultIfEmpty()
                                                  where sub == null
                                                  select no).ToList();
 
            return ngnOntsNotInAgcfGatewayRecordsList;
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> NddNokiaSwitchOntInNonSipOltWithAccessButNoAgcfGatewayRecordList()
        {
            var accessIdDictionary = Ia.Ngn.Cl.Model.Data.Access.IdDictionary;
 
            var ontList = Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList;
 
            var nddOntWithinAccessList = (from o in ontList
                                          where o.Pon.PonGroup.Olt.IsSip == false
                                          && o.Pon.PonGroup.Olt.Odf.Router.Vendor == Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Vendor.Nokia
                                          && accessIdDictionary.ContainsKey(o.Access.Id)
                                          //&& accessIdList.Contains(o.Access.Id) // very slow
                                          select o).ToList();
 
            var agcfGatewayRecordIp1List = Ia.Ngn.Cl.Model.Data.Nokia.AgcfGatewayRecord.IpList();
 
            // below: ONTs in Accesses but not in AgcfGatewayRecord list
            var nddOntList = (from no in nddOntWithinAccessList
                              join grip1 in agcfGatewayRecordIp1List on no.Ip equals grip1
                              into gj
                              from sub in gj.DefaultIfEmpty()
                              where sub == null
                              select no).ToList();
 
            return nddOntList;
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord> AgcfGatewayRecordWithNoNddNokiaSwitchOntInNonSipOltAndNullOrEmptyAgcfEndpointList()
        {
            List<string> accessIdList;
            List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> ontList, nddOntWithNoAccessList;
            List<Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord> agcfGatewayRecordList, agcfGatewayRecordWithNoNddOntList, agcfGatewayRecordWithNoNddOntAccessList;
            List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> nokiaSwitchOntInNonSipOltList;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                accessIdList = (from a in db.Accesses select a.Id).AsNoTracking().ToList();
 
                agcfGatewayRecordList = (from a in db.AgcfGatewayRecords
                                         select a)/*.Include(u => u.AgcfEndpoints)*/.AsNoTracking().ToList();
 
                ontList = Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList;
 
                nokiaSwitchOntInNonSipOltList = (from o in ontList
                                                 where o.Pon.PonGroup.Olt.IsSip == false
                                                 && o.Pon.PonGroup.Olt.Odf.Router.Vendor == Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Vendor.Nokia
                                                 select o).ToList();
 
                // below: AgcfGatewayRecord with no corresponding NDD ONT entries
                agcfGatewayRecordWithNoNddOntList = (from gr in agcfGatewayRecordList
                                                     join no in nokiaSwitchOntInNonSipOltList
                                                     on gr.IP1 equals no.Ip
                                                     into gj
                                                     from sub in gj.DefaultIfEmpty()
                                                     where sub == null
                                                     select gr).ToList();
 
                // below: NDD ONTs with no access
                nddOntWithNoAccessList = (from o in nokiaSwitchOntInNonSipOltList
                                          join a in accessIdList on o.Access.Id equals a
                                          into gj
                                          from sub in gj.DefaultIfEmpty()
                                          where sub == null
                                          select o).ToList();
 
                // below: AgcfGatewayRecord with no corresponding NDD ONT access entries
                agcfGatewayRecordWithNoNddOntAccessList = (from gr in agcfGatewayRecordList
                                                           join no in nddOntWithNoAccessList
                                                           on gr.IP1 equals no.Ip
                                                           select gr).ToList();
            }
 
            return agcfGatewayRecordWithNoNddOntList.Union(agcfGatewayRecordWithNoNddOntAccessList).ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> NddOntWithAgcfGatewayRecordAndNotEmptyAgcfEndpointAndNullAccessList()
        {
            List<string> accessIdList;
            List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> nddOntWithNoAccessList, nddOntWithAgcfGatewayRecordAndNotEmptyAgcfEndpointAndNullAccessList;
            List<Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord> agcfGatewayRecordList, agcfGatewayRecordWithNddOntAndNotEmptyAgcfEndpointList;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                accessIdList = (from a in db.Accesses select a.Id).AsNoTracking().ToList();
 
                agcfGatewayRecordList = (from a in db.AgcfGatewayRecords select a).Include(u => u.AgcfEndpoints).AsNoTracking().ToList();
 
                // below: AgcfGatewayRecord with corresponding NDD ONT entries and not empty AgcfEndpoints
                agcfGatewayRecordWithNddOntAndNotEmptyAgcfEndpointList = (from gr in agcfGatewayRecordList
                                                                          join no in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList
                                                                          on gr.IP1 equals no.Ip
                                                                          where gr.AgcfEndpoints != null && gr.AgcfEndpoints.Count > 0
                                                                          select gr).ToList();
 
                // below: NDD ONTs with no access
                nddOntWithNoAccessList = (from o in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList
                                          join a in accessIdList on o.Access.Id equals a
                                          into gj
                                          from sub in gj.DefaultIfEmpty()
                                          where sub == null
                                          select o).ToList();
 
                // below: AgcfGatewayRecord with corresponding NDD ONT entries and not empty AgcfEndpoints, but with no corresponding NDD ONT access entries
                nddOntWithAgcfGatewayRecordAndNotEmptyAgcfEndpointAndNullAccessList = (from no in nddOntWithNoAccessList
                                                                                       join gr in agcfGatewayRecordList
                                                                                       on no.Ip equals gr.IP1
                                                                                       select no).ToList();
            }
 
            return nddOntWithAgcfGatewayRecordAndNotEmptyAgcfEndpointAndNullAccessList.ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> NddOntWithNoAccessList()
        {
            List<string> accessIdList;
            List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> nddOntList;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                accessIdList = (from a in db.Accesses select a.Id).AsNoTracking().ToList();
 
                // below:
                nddOntList = (from o in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList
                              join a in accessIdList on o.Access.Id equals a
                              into gj
                              from sub in gj.DefaultIfEmpty()
                              where sub == null
                              select o).ToList();
            }
 
            return nddOntList;
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord> AllPossibleAgcfGatewayRecordsNoInOntsList(Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Olt olt)
        {
            DiscrepancyBetweenOntListAndAgctGatewayRecordList(olt, out List<Ia.Ngn.Cl.Model.Ont> ontsNotInAgcfGatewayRecordsList, out List<Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord> agcfGatewayRecordsNoInOntsList);
 
            return agcfGatewayRecordsNoInOntsList;
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        private static void DiscrepancyBetweenOntListAndAgctGatewayRecordList(Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Olt olt, out List<Ia.Ngn.Cl.Model.Ont> ontsNotInAgcfGatewayRecordsList, out List<Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord> agcfGatewayRecordsNoInOntsList)
        {
            List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> ngnOntList;
            List<Ia.Ngn.Cl.Model.Ont> ontList;
            List<Ia.Ngn.Cl.Model.Nokia.AgcfGatewayRecord> agcfGatewayRecordList;
 
            // below: NGN ONT list
            ngnOntList = (from o in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList
                          where o.Pon.PonGroup.Olt.Id == olt.Id
                          select o).ToList();
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                // below: ONT list
                ontList = (from o in db.Onts
                           where o.Access != null && o.Access.Olt == olt.Id
                           select o).AsNoTracking().ToList();
 
                // below: AgcfGatewayRecord list
                agcfGatewayRecordList = (from a in db.AgcfGatewayRecords select a).AsNoTracking().ToList();
            }
 
            // below: ONTs not in AgcfGatewayRecord list
            ontsNotInAgcfGatewayRecordsList = (from o in ontList
                                               join no in ngnOntList on o.Id equals no.Id
                                               join a in agcfGatewayRecordList on no.Ip equals a.IP1
                                               into gj
                                               from sub in gj.DefaultIfEmpty()
                                               where sub == null
                                               select o).ToList();
 
            // below: AgcfGatewayRecords with IPs that are not in NGN ONT list
            agcfGatewayRecordsNoInOntsList = (from a in agcfGatewayRecordList
                                              join no in ngnOntList on a.IP1 equals no.Ip
                                              into gj
                                              from sub in gj.DefaultIfEmpty()
                                              where sub == null
                                              select a).ToList();
 
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        private static List<Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint> AgcfEndpointsWithNoSubPartyReferenceList
        {
            get
            {
                List<Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint> agcfEndpointList;
 
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    agcfEndpointList = (from e in db.AgcfEndpoints
                                        join s in db.SubParties on e equals s.AgcfEndpoint
                                        into gj
                                        from u in gj.DefaultIfEmpty()
                                        where u == null
                                        select e).ToList();
                }
 
                return agcfEndpointList;
            }
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static List<string> ServiceProvisionedManuallyWithNonStandardHenceNotFunctionalPartyIdNames
        {
            get
            {
                List<string> list;
 
                list = new List<string>();
 
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    // exclude 1-800 numbers and numbers without AgcfEndpoints
 
                    // select Id from Subscribers where Id not like '+965________'
                    var subscriberSubpartyIdList = (from s in db.Subscribers where !(s.Id.StartsWith("+965") && s.Id.Length == 12) && !s.Id.StartsWith("+96518") select s.SubParty.Id).ToList();
 
                    // select DisplayName,PartyId from SubParties where AgcfEndpoint_Id not like 'priv____________'
                    var subPartyIdList = (from sp in db.SubParties where !(sp.AgcfEndpoint.Id.StartsWith("priv") && sp.AgcfEndpoint.Id.Length == 16) && !sp.Id.StartsWith("+96518") && sp.AgcfEndpoint != null select sp.Id).ToList();
 
                    // select PrividUser, GwId from AgcfEndpoints where Id not like 'priv____________'
                    var agcfEndpointDnList = (from ep in db.AgcfEndpoints where !(ep.Id.StartsWith("priv") && ep.Id.Length == 16) && !ep.Dn.StartsWith("+96518") select ep.Dn).ToList();
 
                    list.AddRange(subscriberSubpartyIdList);
                    list.AddRange(subPartyIdList);
                    list.AddRange(agcfEndpointDnList);
                }
 
                return list;
            }
        }
 
        ////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static List<string> AgcfGatewayRecordIp1sWithinWhichSubPartiesHaveServiceBundle2CategoryList
        {
            get
            {
                if (agcfGatewayRecordIp1sWithinWhichSubPartiesHaveServiceBundle2CategoryList == null || agcfGatewayRecordIp1sWithinWhichSubPartiesHaveServiceBundle2CategoryList.Count == 0)
                {
                    lock (objectLock)
                    {
                        agcfGatewayRecordIp1sWithinWhichSubPartiesHaveServiceBundle2CategoryList = Ia.Ngn.Cl.Model.Data.Nokia.Ims._AgcfGatewayRecordIp1sWithinWhichSubPartiesHaveServiceBundle2CategoryList;
                    }
                }
 
                return agcfGatewayRecordIp1sWithinWhichSubPartiesHaveServiceBundle2CategoryList;
            }
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        private static List<string> _AgcfGatewayRecordIp1sWithinWhichSubPartiesHaveServiceBundle2CategoryList
        {
            get
            {
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    agcfGatewayRecordIp1sWithinWhichSubPartiesHaveServiceBundle2CategoryList = (from sp in db.SubParties
                                                                                                where sp.Category == "SERVICEBUNDLE2"
                                                                                                join e in db.AgcfEndpoints on sp.AgcfEndpoint.Id equals e.Id
                                                                                                join gr in db.AgcfGatewayRecords on e.AgcfGatewayRecord.Id equals gr.Id
                                                                                                select gr.IP1).Distinct().ToList();
 
                    /*
select distinct gr.IP1 from AgcfGatewayRecords gr 
left outer join AgcfEndpoints ep on ep.AgcfGatewayRecord_Id = gr.Id
left outer join SubParties sp on sp.AgcfEndpoint_Id = ep.Id
where sp.Category = 'SERVICEBUNDLE2'
*/
                }
 
                return agcfGatewayRecordIp1sWithinWhichSubPartiesHaveServiceBundle2CategoryList;
            }
        }
 
        ////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        public static List<string> AgcfGatewayRecordIp1sThatIndicateFsdb0List
        {
            get
            {
                if (agcfGatewayRecordIp1sThatIndicateFsdb0List == null || agcfGatewayRecordIp1sThatIndicateFsdb0List.Count == 0)
                {
                    lock (objectLock)
                    {
                        agcfGatewayRecordIp1sThatIndicateFsdb0List = Ia.Ngn.Cl.Model.Data.Nokia.Ims._AgcfGatewayRecordIp1sThatIndicateFsdb0List;
                    }
                }
 
                return agcfGatewayRecordIp1sThatIndicateFsdb0List;
            }
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///
        /// </summary>
        private static List<string> _AgcfGatewayRecordIp1sThatIndicateFsdb0List
        {
            get
            {
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    agcfGatewayRecordIp1sThatIndicateFsdb0List = (from gr in db.AgcfGatewayRecords where gr.AgcfSipIaPort == "agcf-stdn.imsgroup0-000" select gr.IP1).Distinct().ToList();
 
                    // select distinct IP1 from AgcfGatewayRecords where AgcfSipIaPort = 'agcf-stdn.imsgroup0-000'
                }
 
                return agcfGatewayRecordIp1sThatIndicateFsdb0List;
            }
        }
 
        ////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////
    }
 
    ////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////   
}