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

Integrated Applications Programming Company

Skip Navigation LinksHome » Code Library » Find

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

Find subscriber and network information support class for the Optical Fiber Network data model

   1:  using System.Data;
   2:  using System.Linq;
   3:  using System.Collections.Generic;
   4:  using Microsoft.EntityFrameworkCore;
   5:  using System.Diagnostics;
   6:   
   7:  namespace Ia.Ngn.Cl.Model.Data.Maintenance
   8:  {
   9:      ////////////////////////////////////////////////////////////////////////////
  10:   
  11:      /// <summary publish="true">
  12:      /// Find subscriber and network information support class for the Optical Fiber Network data model
  13:      /// </summary>
  14:      /// 
  15:      /// <remarks> 
  16:      /// Copyright © 2006-2021 Jasem Y. Al-Shamlan (info@ia.com.kw), Integrated Applications - Kuwait. All Rights Reserved.
  17:      ///
  18:      /// 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
  19:      /// the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  20:      ///
  21:      /// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  22:      /// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  23:      /// 
  24:      /// You should have received a copy of the GNU General Public License along with this library. If not, see http://www.gnu.org/licenses.
  25:      /// 
  26:      /// Copyright notice: This notice may not be removed or altered from any source distribution.
  27:      /// </remarks> 
  28:      public class Find
  29:      {
  30:          ////////////////////////////////////////////////////////////////////////////
  31:   
  32:          /// <summary>
  33:          ///
  34:          /// </summary>
  35:          public Find() { }
  36:   
  37:          ////////////////////////////////////////////////////////////////////////////
  38:   
  39:          /// <summary>
  40:          /// 
  41:          /// </summary>
  42:          public static List<Ia.Ngn.Cl.Model.Ui.ServiceRequestService> ServiceRequestServiceList(List<string> serviceRequestServiceIdList)
  43:          {
  44:              List<Ia.Ngn.Cl.Model.ServiceRequestService> inList;
  45:              List<Ia.Ngn.Cl.Model.Ui.ServiceRequestService> list;
  46:   
  47:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
  48:              {
  49:                  if (serviceRequestServiceIdList.Count > 0)
  50:                  {
  51:                      inList = (from srs in db.ServiceRequestServices where serviceRequestServiceIdList.Contains(srs.Id) select srs).Include(u => u.Access).AsNoTracking().ToList();
  52:   
  53:                      list = (from srs in inList
  54:                              select new Ia.Ngn.Cl.Model.Ui.ServiceRequestService()
  55:                              {
  56:                                  Id = srs.Id,
  57:                                  AbbriviatedCalling = srs.AbbriviatedCalling,
  58:                                  Access = srs.Access,
  59:                                  AlarmCall = srs.AlarmCall,
  60:                                  CallBarring = srs.CallBarring,
  61:                                  CallerId = srs.CallerId,
  62:                                  CallForwarding = srs.CallForwarding,
  63:                                  CallWaiting = srs.CallWaiting,
  64:                                  ConferenceCall = srs.ConferenceCall,
  65:                                  Created = srs.Created,
  66:                                  InternationalCalling = srs.InternationalCalling,
  67:                                  InternationalCallingUserControlled = srs.InternationalCallingUserControlled,
  68:                                  LastRequestDateTime = srs.LastRequestDateTime,
  69:                                  Provisioned = srs.Provisioned,
  70:                                  Service = srs.Service,
  71:                                  Serial = srs.Serial,
  72:                                  ServiceType = srs.ServiceType,
  73:                                  //ServiceSuspension = srs.ServiceSuspension,
  74:                                  Type = srs.Type,
  75:                                  Updated = srs.Updated
  76:                              }).ToList();
  77:                  }
  78:                  else list = new List<Ia.Ngn.Cl.Model.Ui.ServiceRequestService>();
  79:   
  80:                  return list.Distinct().ToList();
  81:              }
  82:          }
  83:   
  84:          ////////////////////////////////////////////////////////////////////////////
  85:   
  86:          /// <summary>
  87:          /// 
  88:          /// </summary>
  89:          public static List<Ia.Ngn.Cl.Model.ServiceRequest> ServiceRequestList(List<int> serviceRequestIdList)
  90:          {
  91:              List<Ia.Ngn.Cl.Model.ServiceRequest> list;
  92:   
  93:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
  94:              {
  95:                  if (serviceRequestIdList.Count > 0)
  96:                  {
  97:                      list = (from sr in db.ServiceRequests
  98:                              where serviceRequestIdList.Contains(sr.Id)
  99:                              select sr).AsNoTracking().ToList();
 100:                  }
 101:                  else list = new List<Ia.Ngn.Cl.Model.ServiceRequest>();
 102:              }
 103:   
 104:              return list.Distinct().ToList();
 105:          }
 106:   
 107:          ////////////////////////////////////////////////////////////////////////////
 108:   
 109:          /// <summary>
 110:          /// 
 111:          /// </summary>
 112:          public static List<Ia.Ngn.Cl.Model.ServiceRequestAdministrativeIssue> ServiceRequestAdministrativeIssueList(List<string> serviceRequestAdministrativeIssueIdList)
 113:          {
 114:              List<Ia.Ngn.Cl.Model.ServiceRequestAdministrativeIssue> list;
 115:   
 116:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 117:              {
 118:                  if (serviceRequestAdministrativeIssueIdList.Count > 0)
 119:                  {
 120:                      list = (from srai in db.ServiceRequestAdministrativeIssues
 121:                              where serviceRequestAdministrativeIssueIdList.Contains(srai.Id)
 122:                              select srai).AsNoTracking().ToList();
 123:                  }
 124:                  else list = new List<Ia.Ngn.Cl.Model.ServiceRequestAdministrativeIssue>();
 125:              }
 126:   
 127:              return list.Distinct().ToList();
 128:          }
 129:   
 130:          ////////////////////////////////////////////////////////////////////////////
 131:   
 132:          /// <summary>
 133:          /// 
 134:          /// </summary>
 135:          public static List<Ia.Ngn.Cl.Model.ServiceRequestHistory> ServiceRequestHistoryList(List<string> serviceRequestHistoryIdList)
 136:          {
 137:              List<Ia.Ngn.Cl.Model.ServiceRequestHistory> list;
 138:   
 139:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 140:              {
 141:                  if (serviceRequestHistoryIdList.Count > 0)
 142:                  {
 143:                      list = (from srh in db.ServiceRequestHistories
 144:                              where serviceRequestHistoryIdList.Contains(srh.Id)
 145:                              select srh).AsNoTracking().ToList();
 146:                  }
 147:                  else list = new List<Ia.Ngn.Cl.Model.ServiceRequestHistory>();
 148:              }
 149:   
 150:              return list.Distinct().ToList();
 151:          }
 152:   
 153:          ////////////////////////////////////////////////////////////////////////////
 154:   
 155:          /// <summary>
 156:          /// 
 157:          /// </summary>
 158:          public static List<Ia.Ngn.Cl.Model.ServiceRequest> ServiceRequestListForCustomerId(int customerId, int maxNumberOfResults)
 159:          {
 160:              List<Ia.Ngn.Cl.Model.ServiceRequest> list;
 161:   
 162:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 163:              {
 164:                  list = (from sr in db.ServiceRequests
 165:                          where sr.CustomerId == customerId
 166:                          select sr).AsNoTracking().Take(maxNumberOfResults).ToList();
 167:              }
 168:   
 169:              return list.Distinct().ToList();
 170:          }
 171:   
 172:          ////////////////////////////////////////////////////////////////////////////
 173:   
 174:          /// <summary>
 175:          /// 
 176:          /// </summary>
 177:          public static List<Ia.Ngn.Cl.Model.ServiceRequest> ServiceRequestListForCustomerName(string customerName, int maxNumberOfResults)
 178:          {
 179:              List<Ia.Ngn.Cl.Model.ServiceRequest> list;
 180:   
 181:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 182:              {
 183:                  if (!string.IsNullOrEmpty(customerName))
 184:                  {
 185:                      list = (from sr in db.ServiceRequests
 186:                              where sr.CustomerName == customerName || sr.CustomerName.Contains(customerName)
 187:                              select sr).Take(maxNumberOfResults).AsNoTracking().ToList();
 188:                  }
 189:                  else list = new List<Ia.Ngn.Cl.Model.ServiceRequest>();
 190:              }
 191:   
 192:              return list.Distinct().ToList();
 193:          }
 194:   
 195:          ////////////////////////////////////////////////////////////////////////////
 196:   
 197:          /// <summary>
 198:          /// 
 199:          /// </summary>
 200:          public static List<Ia.Ngn.Cl.Model.ServiceRequestType> ServiceRequestTypeList(List<int> serviceRequestTypeIdList)
 201:          {
 202:              List<Ia.Ngn.Cl.Model.ServiceRequestType> list;
 203:   
 204:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 205:              {
 206:                  if (serviceRequestTypeIdList.Count > 0)
 207:                  {
 208:                      list = (from srt in db.ServiceRequestTypes
 209:                              where serviceRequestTypeIdList.Contains(srt.Id)
 210:                              select srt).AsNoTracking().ToList();
 211:                  }
 212:                  else list = new List<Ia.Ngn.Cl.Model.ServiceRequestType>();
 213:              }
 214:   
 215:              return list.Distinct().ToList();
 216:          }
 217:   
 218:          ////////////////////////////////////////////////////////////////////////////
 219:   
 220:          /// <summary>
 221:          /// 
 222:          /// </summary>
 223:          public static List<Ia.Ngn.Cl.Model.Ui.Nokia.AgcfGatewayRecord> AgcfGatewayRecordList(List<int> agcfGatewayRecordIdList)
 224:          {
 225:              List<Ia.Ngn.Cl.Model.Ui.Nokia.AgcfGatewayRecord> list;
 226:   
 227:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 228:              {
 229:                  if (agcfGatewayRecordIdList.Count > 0)
 230:                  {
 231:                      list = (from gr in db.AgcfGatewayRecords
 232:                              where agcfGatewayRecordIdList.Contains(gr.Id)
 233:                              select new Ia.Ngn.Cl.Model.Ui.Nokia.AgcfGatewayRecord()
 234:                              {
 235:                                  Id = gr.Id,
 236:                                  GwId = gr.GwId,
 237:                                  GwUserId = gr.GwUserId,
 238:                                  GwDomain = gr.GwDomain,
 239:                                  GwName = gr.GwName,
 240:                                  IP1 = gr.IP1,
 241:                                  IP2 = gr.IP2,
 242:                                  MateExternalIPAddr = gr.MateExternalIPAddr,
 243:                                  IsPrimary = gr.IsPrimary,
 244:                                  Created = gr.Created,
 245:                                  Updated = gr.Updated
 246:                              }).AsNoTracking().ToList();
 247:                  }
 248:                  else list = new List<Ia.Ngn.Cl.Model.Ui.Nokia.AgcfGatewayRecord>();
 249:              }
 250:   
 251:              return list.Distinct().ToList();
 252:          }
 253:   
 254:          ////////////////////////////////////////////////////////////////////////////
 255:   
 256:          /// <summary>
 257:          /// 
 258:          /// </summary>
 259:          public static List<Ia.Ngn.Cl.Model.Ui.Nokia.AgcfEndpoint> AgcfEndpointList(List<string> agcfEndpointIdList)
 260:          {
 261:              List<Ia.Ngn.Cl.Model.Ui.Nokia.AgcfEndpoint> list;
 262:   
 263:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 264:              {
 265:                  if (agcfEndpointIdList.Count > 0)
 266:                  {
 267:                      list = (from e in db.AgcfEndpoints
 268:                              where agcfEndpointIdList.Contains(e.Id)
 269:                              select new Ia.Ngn.Cl.Model.Ui.Nokia.AgcfEndpoint()
 270:                              {
 271:                                  Id = e.Id,
 272:                                  PrividUser = e.PrividUser,
 273:                                  GwId = e.GwId,
 274:                                  Dn = e.Dn,
 275:                                  FlatTermID = e.FlatTermID,
 276:                                  CallHoldLc = e.CallHoldLc,
 277:                                  CallWaitingLc = e.CallWaitingLc,
 278:                                  CallToggleLc = e.CallToggleLc,
 279:                                  ThreeWayCallLc = e.ThreeWayCallLc,
 280:                                  McidLc = e.McidLc,
 281:                                  Password = e.Password,
 282:                                  CallTransferLc = e.CallTransferLc,
 283:                                  Created = e.Created,
 284:                                  Updated = e.Updated
 285:                              }).AsNoTracking().ToList();
 286:                  }
 287:                  else list = new List<Ia.Ngn.Cl.Model.Ui.Nokia.AgcfEndpoint>();
 288:              }
 289:   
 290:              return list.Distinct().ToList();
 291:          }
 292:   
 293:          ////////////////////////////////////////////////////////////////////////////
 294:   
 295:          /// <summary>
 296:          /// 
 297:          /// </summary>
 298:          public static List<Ia.Ngn.Cl.Model.Huawei.Mgw> MgwList(List<string> mgwIdList)
 299:          {
 300:              List<Ia.Ngn.Cl.Model.Huawei.Mgw> list;
 301:   
 302:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 303:              {
 304:                  if (mgwIdList.Count > 0)
 305:                  {
 306:                      list = (from m in db.Mgws
 307:                              where mgwIdList.Contains(m.Id)
 308:                              select m).AsNoTracking().ToList();
 309:                  }
 310:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.Mgw>();
 311:              }
 312:   
 313:              return list.Distinct().ToList();
 314:          }
 315:   
 316:          ////////////////////////////////////////////////////////////////////////////
 317:   
 318:          /// <summary>
 319:          /// 
 320:          /// </summary>
 321:          public static List<Ia.Ngn.Cl.Model.Huawei.Asbr> AsbrList(List<string> asbrIdList)
 322:          {
 323:              List<Ia.Ngn.Cl.Model.Huawei.Asbr> list;
 324:   
 325:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 326:              {
 327:                  if (asbrIdList.Count > 0)
 328:                  {
 329:                      list = (from a in db.Asbrs
 330:                              where asbrIdList.Contains(a.Id)
 331:                              select a).AsNoTracking().ToList();
 332:                  }
 333:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.Asbr>();
 334:              }
 335:   
 336:              return list.Distinct().ToList();
 337:          }
 338:   
 339:          ////////////////////////////////////////////////////////////////////////////
 340:   
 341:          /// <summary>
 342:          /// 
 343:          /// </summary>
 344:          public static List<Ia.Ngn.Cl.Model.Huawei.EmsDev> EmsDevList(List<int> emsDevIdList)
 345:          {
 346:              List<Ia.Ngn.Cl.Model.Huawei.EmsDev> list;
 347:   
 348:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 349:              {
 350:                  if (emsDevIdList.Count > 0)
 351:                  {
 352:                      list = (from ed in db.EmsDevs
 353:                              where emsDevIdList.Contains(ed.Id)
 354:                              select ed).AsNoTracking().ToList();
 355:                  }
 356:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.EmsDev>();
 357:              }
 358:   
 359:              return list.Distinct().ToList();
 360:          }
 361:   
 362:          ////////////////////////////////////////////////////////////////////////////
 363:   
 364:          /// <summary>
 365:          /// 
 366:          /// </summary>
 367:          public static List<Ia.Ngn.Cl.Model.Huawei.EmsDev> EmsDevListFromEmsOntIdList(List<string> emsOntIdList)
 368:          {
 369:              List<Ia.Ngn.Cl.Model.Huawei.EmsDev> list;
 370:   
 371:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 372:              {
 373:                  if (emsOntIdList.Count > 0)
 374:                  {
 375:                      list = (from ed in db.EmsDevs
 376:                              join eb in db.EmsBoards on ed.Id equals eb.EmsDev.Id
 377:                              join ep in db.EmsPorts on eb.Id equals ep.EmsBoard.Id
 378:                              join eo in db.EmsOnts on ep.Id equals eo.EmsPort.Id
 379:                              where emsOntIdList.Contains(eo.Id)
 380:                              select ed).AsNoTracking().ToList();
 381:                  }
 382:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.EmsDev>();
 383:              }
 384:   
 385:              return list.Distinct().ToList();
 386:          }
 387:   
 388:          ////////////////////////////////////////////////////////////////////////////
 389:   
 390:          /// <summary>
 391:          /// 
 392:          /// </summary>
 393:          public static List<Ia.Ngn.Cl.Model.Huawei.EmsBoard> EmsBoardList(List<string> emsBoardIdList)
 394:          {
 395:              List<Ia.Ngn.Cl.Model.Huawei.EmsBoard> list;
 396:   
 397:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 398:              {
 399:                  if (emsBoardIdList.Count > 0)
 400:                  {
 401:                      list = (from eb in db.EmsBoards
 402:                              where emsBoardIdList.Contains(eb.Id)
 403:                              select eb).AsNoTracking().ToList();
 404:                  }
 405:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.EmsBoard>();
 406:              }
 407:   
 408:              return list.Distinct().ToList();
 409:          }
 410:   
 411:          ////////////////////////////////////////////////////////////////////////////
 412:   
 413:          /// <summary>
 414:          /// 
 415:          /// </summary>
 416:          public static List<Ia.Ngn.Cl.Model.Huawei.EmsBoard> EmsBoardListFromEmsOntIdList(List<string> emsOntIdList)
 417:          {
 418:              List<Ia.Ngn.Cl.Model.Huawei.EmsBoard> list;
 419:   
 420:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 421:              {
 422:                  if (emsOntIdList.Count > 0)
 423:                  {
 424:                      list = (from eb in db.EmsBoards
 425:                              join ep in db.EmsPorts on eb.Id equals ep.EmsBoard.Id
 426:                              join eo in db.EmsOnts on ep.Id equals eo.EmsPort.Id
 427:                              where emsOntIdList.Contains(eo.Id)
 428:                              select eb).AsNoTracking().ToList();
 429:                  }
 430:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.EmsBoard>();
 431:              }
 432:   
 433:              return list.Distinct().ToList();
 434:          }
 435:   
 436:          ////////////////////////////////////////////////////////////////////////////
 437:   
 438:          /// <summary>
 439:          /// 
 440:          /// </summary>
 441:          public static List<Ia.Ngn.Cl.Model.Huawei.EmsPort> EmsPortList(List<string> emsPortIdList)
 442:          {
 443:              List<Ia.Ngn.Cl.Model.Huawei.EmsPort> list;
 444:   
 445:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 446:              {
 447:                  if (emsPortIdList.Count > 0)
 448:                  {
 449:                      list = (from ep in db.EmsPorts
 450:                              where emsPortIdList.Contains(ep.Id)
 451:                              select ep).AsNoTracking().ToList();
 452:                  }
 453:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.EmsPort>();
 454:              }
 455:   
 456:              return list.Distinct().ToList();
 457:          }
 458:   
 459:          ////////////////////////////////////////////////////////////////////////////
 460:   
 461:          /// <summary>
 462:          /// 
 463:          /// </summary>
 464:          public static List<Ia.Ngn.Cl.Model.Huawei.EmsPort> EmsPortListFromEmsOntIdList(List<string> emsOntIdList)
 465:          {
 466:              List<Ia.Ngn.Cl.Model.Huawei.EmsPort> list;
 467:   
 468:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 469:              {
 470:                  if (emsOntIdList.Count > 0)
 471:                  {
 472:                      list = (from ep in db.EmsPorts
 473:                              join eo in db.EmsOnts on ep.Id equals eo.EmsPort.Id
 474:                              where emsOntIdList.Contains(eo.Id)
 475:                              select ep).AsNoTracking().ToList();
 476:                  }
 477:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.EmsPort>();
 478:              }
 479:   
 480:              return list.Distinct().ToList();
 481:          }
 482:   
 483:          ////////////////////////////////////////////////////////////////////////////
 484:   
 485:          /// <summary>
 486:          /// 
 487:          /// </summary>
 488:          public static List<Ia.Ngn.Cl.Model.Ui.Huawei.EmsOnt> EmsOntList(List<string> emsOntIdList)
 489:          {
 490:              List<Ia.Ngn.Cl.Model.Ui.Huawei.EmsOnt> list;
 491:   
 492:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 493:              {
 494:                  if (emsOntIdList.Count > 0)
 495:                  {
 496:                      list = (from eo in db.EmsOnts
 497:                              where emsOntIdList.Contains(eo.Id)
 498:                              select new Ia.Ngn.Cl.Model.Ui.Huawei.EmsOnt()
 499:                              {
 500:                                  Id = eo.Id,
 501:                                  ResultCode = eo.ResultCode,
 502:                                  StateId = eo.StateId,
 503:                                  Access = eo.Access,
 504:                                  ALIAS = eo.ALIAS,
 505:                                  AUTH = eo.AUTH,
 506:                                  CAPABPROF = eo.CAPABPROF,
 507:                                  Created = eo.Created,
 508:                                  DEV = eo.DEV,
 509:                                  DID = eo.DID,
 510:                                  EQUIPMENTID = eo.EQUIPMENTID,
 511:                                  FN = eo.FN,
 512:                                  GATE = eo.GATE,
 513:                                  IP = eo.IP,
 514:                                  MAINSOFTVERSION = eo.MAINSOFTVERSION,
 515:                                  NAME = eo.NAME,
 516:                                  ONTID = eo.ONTID,
 517:                                  PN = eo.PN,
 518:                                  ROUTEIP = eo.ROUTEIP,
 519:                                  SERIALNUM = eo.SERIALNUM,
 520:                                  SN = eo.SN,
 521:                                  VAPROF = eo.VAPROF,
 522:                                  Updated = eo.Updated,
 523:                                  VENDORID = eo.VENDORID,
 524:                                  VLAN = eo.VLAN
 525:                              }).AsNoTracking().ToList();
 526:                  }
 527:                  else list = new List<Ia.Ngn.Cl.Model.Ui.Huawei.EmsOnt>();
 528:              }
 529:   
 530:              return list.Distinct().ToList();
 531:          }
 532:   
 533:          ////////////////////////////////////////////////////////////////////////////
 534:   
 535:          /// <summary>
 536:          /// 
 537:          /// </summary>
 538:          public static List<Ia.Ngn.Cl.Model.Huawei.EmsOntSipInfo> EmsOntSipInfoListFromEmsOntIdList(List<string> emsOntIdList)
 539:          {
 540:              List<Ia.Ngn.Cl.Model.Huawei.EmsOntSipInfo> list;
 541:   
 542:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 543:              {
 544:                  if (emsOntIdList.Count > 0)
 545:                  {
 546:                      list = (from eosi in db.EmsOntSipInfoes
 547:                              where emsOntIdList.Contains(eosi.EmsOnt.Id)
 548:                              select eosi).Include(o => o.EmsOnt).AsNoTracking().ToList();
 549:                  }
 550:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.EmsOntSipInfo>();
 551:              }
 552:   
 553:              return list.Distinct().ToList();
 554:          }
 555:   
 556:          ////////////////////////////////////////////////////////////////////////////
 557:   
 558:          /// <summary>
 559:          /// 
 560:          /// </summary>
 561:          public static List<Ia.Ngn.Cl.Model.Huawei.EmsVoipPstnUser> EmsVoipPstnUserList(List<string> emsVoipPstnUserIdList)
 562:          {
 563:              List<Ia.Ngn.Cl.Model.Huawei.EmsVoipPstnUser> list;
 564:   
 565:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 566:              {
 567:                  if (emsVoipPstnUserIdList.Count > 0)
 568:                  {
 569:                      list = (from evpu in db.EmsVoipPstnUsers
 570:                              where emsVoipPstnUserIdList.Contains(evpu.Id)
 571:                              select evpu).Include(o => o.EmsOnt).Include(o => o.EmsOnt.Access).AsNoTracking().ToList();
 572:                  }
 573:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.EmsVoipPstnUser>();
 574:              }
 575:   
 576:              return list.Distinct().ToList();
 577:          }
 578:   
 579:          ////////////////////////////////////////////////////////////////////////////
 580:   
 581:          /// <summary>
 582:          /// 
 583:          /// </summary>
 584:          public static List<string> EmsVoipPstnUserIdListFromEmsOntIdList(List<string> emsOntIdList)
 585:          {
 586:              List<string> list;
 587:   
 588:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 589:              {
 590:                  if (emsOntIdList.Count > 0)
 591:                  {
 592:                      list = (from evpu in db.EmsVoipPstnUsers
 593:                              where evpu.EmsOnt != null && emsOntIdList.Contains(evpu.EmsOnt.Id)
 594:                              select evpu.Id).AsNoTracking().ToList();
 595:                  }
 596:                  else list = new List<string>();
 597:              }
 598:   
 599:              return list.Distinct().ToList();
 600:          }
 601:   
 602:          ////////////////////////////////////////////////////////////////////////////
 603:   
 604:          /// <summary>
 605:          /// 
 606:          /// </summary>
 607:          public static List<string> EmsVoipPstnUserIdListFromServiceList(List<string> serviceList)
 608:          {
 609:              List<string> serviceWithCountryCodeList, impuAidList;
 610:              List<string> list;
 611:   
 612:              // for MDUs numbers will look like 96524805054
 613:              // for MSAN numbers will look like +96524805054
 614:   
 615:              if (serviceList.Count > 0)
 616:              {
 617:                  serviceWithCountryCodeList = new List<string>();
 618:                  impuAidList = new List<string>();
 619:   
 620:                  foreach (string service in serviceList)
 621:                  {
 622:                      serviceWithCountryCodeList.Add(Ia.Ngn.Cl.Model.Business.NumberFormatConverter.ServiceWithCountryCode(service));
 623:                      impuAidList.Add(Ia.Ngn.Cl.Model.Business.NumberFormatConverter.ImpuAid(service));
 624:                  }
 625:   
 626:                  using (var db = new Ia.Ngn.Cl.Model.Ngn())
 627:                  {
 628:                      list = (from evpu in db.EmsVoipPstnUsers
 629:                              where serviceWithCountryCodeList.Contains(evpu.DN) || impuAidList.Contains(evpu.DN)
 630:                              select evpu.Id).AsNoTracking().ToList();
 631:                  }
 632:              }
 633:              else list = new List<string>();
 634:   
 635:              return list.Distinct().ToList();
 636:          }
 637:   
 638:          ////////////////////////////////////////////////////////////////////////////
 639:   
 640:          /// <summary>
 641:          /// 
 642:          /// </summary>
 643:          public static List<Ia.Ngn.Cl.Model.Huawei.EmsVoipPstnUser> EmsVoipPstnUserListFromEmsOntIdList(List<string> emsOntIdList)
 644:          {
 645:              List<Ia.Ngn.Cl.Model.Huawei.EmsVoipPstnUser> list;
 646:   
 647:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 648:              {
 649:                  if (emsOntIdList.Count > 0)
 650:                  {
 651:                      list = (from evpu in db.EmsVoipPstnUsers
 652:                              where evpu.EmsOnt != null && emsOntIdList.Contains(evpu.EmsOnt.Id)
 653:                              select evpu).Include(o => o.EmsOnt).AsNoTracking().ToList();
 654:                  }
 655:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.EmsVoipPstnUser>();
 656:              }
 657:   
 658:              return list.Distinct().ToList();
 659:          }
 660:   
 661:          ////////////////////////////////////////////////////////////////////////////
 662:   
 663:          /// <summary>
 664:          /// 
 665:          /// </summary>
 666:          public static List<Ia.Ngn.Cl.Model.Huawei.EmsVag> VagListFromEmsOntIdList(List<string> emsOntIdList)
 667:          {
 668:              List<Ia.Ngn.Cl.Model.Huawei.EmsVag> list;
 669:   
 670:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 671:              {
 672:                  if (emsOntIdList.Count > 0)
 673:                  {
 674:                      list = (from v in db.EmsVags
 675:                              where emsOntIdList.Contains(v.EmsOnt.Id)
 676:                              select v).Include(o => o.EmsOnt).AsNoTracking().ToList();
 677:                  }
 678:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.EmsVag>();
 679:              }
 680:   
 681:              return list.Distinct().ToList();
 682:          }
 683:   
 684:          ////////////////////////////////////////////////////////////////////////////
 685:   
 686:          /// <summary>
 687:          /// 
 688:          /// </summary>
 689:          public static List<Ia.Ngn.Cl.Model.Huawei.EmsVoipPstnUser> EmsVoipPstnUserListFromEmsOntIdListAndServiceList(List<string> emsOntIdList, List<string> serviceList)
 690:          {
 691:              string serviceWithCountryCode;
 692:              List<string> emsVoipPstnUserDnList;
 693:              List<Ia.Ngn.Cl.Model.Huawei.EmsVoipPstnUser> list;
 694:   
 695:              if (emsOntIdList.Count > 0 && serviceList.Count > 0)
 696:              {
 697:                  emsVoipPstnUserDnList = new List<string>();
 698:   
 699:                  foreach (var service in serviceList)
 700:                  {
 701:                      serviceWithCountryCode = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.ServiceWithCountryCode(service);
 702:                      emsVoipPstnUserDnList.Add(serviceWithCountryCode);
 703:                  }
 704:   
 705:                  using (var db = new Ia.Ngn.Cl.Model.Ngn())
 706:                  {
 707:                      list = (from evpu in db.EmsVoipPstnUsers
 708:                              where evpu.EmsOnt != null && emsOntIdList.Contains(evpu.EmsOnt.Id) && emsVoipPstnUserDnList.Contains(evpu.DN)
 709:                              select evpu).Include(o => o.EmsOnt).AsNoTracking().ToList();
 710:                  }
 711:              }
 712:              else list = new List<Ia.Ngn.Cl.Model.Huawei.EmsVoipPstnUser>();
 713:   
 714:              return list.Distinct().ToList();
 715:          }
 716:   
 717:          ////////////////////////////////////////////////////////////////////////////
 718:   
 719:          /// <summary>
 720:          /// 
 721:          /// </summary>
 722:          public static List<Ia.Ngn.Cl.Model.Huawei.EmsOntSipInfo> EmsOntSipInfoListFromEmsOntIdListAndService(List<string> emsOntIdList, List<string> sipUserNameList)
 723:          {
 724:              List<Ia.Ngn.Cl.Model.Huawei.EmsOntSipInfo> list;
 725:   
 726:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 727:              {
 728:                  if (emsOntIdList.Count > 0 && sipUserNameList.Count > 0)
 729:                  {
 730:                      list = (from eosi in db.EmsOntSipInfoes
 731:                              where emsOntIdList.Contains(eosi.EmsOnt.Id) && sipUserNameList.Contains(eosi.SIPUSERNAME)
 732:                              select eosi).Include(o => o.EmsOnt).Include(o => o.EmsOnt.Access).AsNoTracking().ToList();
 733:                  }
 734:                  else list = new List<Ia.Ngn.Cl.Model.Huawei.EmsOntSipInfo>();
 735:              }
 736:   
 737:              return list.Distinct().ToList();
 738:          }
 739:   
 740:          ////////////////////////////////////////////////////////////////////////////
 741:   
 742:          /// <summary>
 743:          /// 
 744:          /// </summary>
 745:          public static List<Ia.Ngn.Cl.Model.ServiceRequestOnt> ServiceRequestOntList(List<string> serviceRequestOntIdList)
 746:          {
 747:              List<Ia.Ngn.Cl.Model.ServiceRequestOnt> list;
 748:   
 749:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 750:              {
 751:                  if (serviceRequestOntIdList.Count > 0)
 752:                  {
 753:                      list = (from sro in db.ServiceRequestOnts
 754:                              where serviceRequestOntIdList.Contains(sro.Id)
 755:                              select sro).AsNoTracking().ToList();
 756:                  }
 757:                  else list = new List<Ia.Ngn.Cl.Model.ServiceRequestOnt>();
 758:              }
 759:   
 760:              return list.Distinct().ToList();
 761:          }
 762:   
 763:          ////////////////////////////////////////////////////////////////////////////
 764:   
 765:          /// <summary>
 766:          /// 
 767:          /// </summary>
 768:          public static List<Ia.Ngn.Cl.Model.ServiceRequestOntDetail> ServiceRequestOntDetailList(List<string> serviceRequestOntIdList)
 769:          {
 770:              List<Ia.Ngn.Cl.Model.ServiceRequestOntDetail> list;
 771:   
 772:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 773:              {
 774:                  if (serviceRequestOntIdList.Count > 0)
 775:                  {
 776:                      list = (from srod in db.ServiceRequestOntDetails
 777:                              where serviceRequestOntIdList.Contains(srod.ServiceRequestOnt.Id)
 778:                              select srod).AsNoTracking().ToList();
 779:                  }
 780:                  else list = new List<Ia.Ngn.Cl.Model.ServiceRequestOntDetail>();
 781:              }
 782:   
 783:              return list.Distinct().ToList();
 784:          }
 785:   
 786:          ////////////////////////////////////////////////////////////////////////////
 787:   
 788:          /// <summary>
 789:          /// 
 790:          /// </summary>
 791:          public static List<Ia.Ngn.Cl.Model.ServiceRequestOntDetail> ServiceRequestOntDetailFromServieListList(List<string> serviceList)
 792:          {
 793:              List<Ia.Ngn.Cl.Model.ServiceRequestOntDetail> list;
 794:   
 795:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 796:              {
 797:                  if (serviceList.Count > 0)
 798:                  {
 799:                      list = (from srod in db.ServiceRequestOntDetails
 800:                              where serviceList.Contains(srod.Service)
 801:                              select srod).AsNoTracking().ToList();
 802:                  }
 803:                  else list = new List<Ia.Ngn.Cl.Model.ServiceRequestOntDetail>();
 804:              }
 805:   
 806:              return list.Distinct().ToList();
 807:          }
 808:   
 809:          ////////////////////////////////////////////////////////////////////////////
 810:   
 811:          /// <summary>
 812:          /// 
 813:          /// </summary>
 814:          public static List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> NddOntList(List<string> nddOntIdList)
 815:          {
 816:              List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont> list;
 817:   
 818:              if (nddOntIdList.Count > 0)
 819:              {
 820:                  list = (from o in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList
 821:                          where nddOntIdList.Contains(o.Id)
 822:                          select o).ToList();
 823:              }
 824:              else list = new List<Ia.Ngn.Cl.Model.Business.NetworkDesignDocument.Ont>();
 825:   
 826:              return list.Distinct().ToList();
 827:          }
 828:   
 829:          ////////////////////////////////////////////////////////////////////////////
 830:   
 831:          /// <summary>
 832:          /// 
 833:          /// </summary>
 834:          public static List<Ia.Ngn.Cl.Model.Access> AccessList(List<string> accessIdList)
 835:          {
 836:              List<Ia.Ngn.Cl.Model.Access> list;
 837:   
 838:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 839:              {
 840:                  if (accessIdList.Count > 0)
 841:                  {
 842:                      list = (from a in db.Accesses
 843:                              where accessIdList.Contains(a.Id)
 844:                              select a).AsNoTracking().ToList();
 845:                  }
 846:                  else list = new List<Ia.Ngn.Cl.Model.Access>();
 847:              }
 848:   
 849:              return list.Distinct().ToList();
 850:          }
 851:   
 852:          ////////////////////////////////////////////////////////////////////////////
 853:   
 854:          /// <summary>
 855:          /// 
 856:          /// </summary>
 857:          public static List<Ia.Ngn.Cl.Model.Access> AccessListFromAddress(int kuwaitOfnAreaId, string block, int street, int premisesOld, int premisesNew)
 858:          {
 859:              string streetString, premisesOldString, premisesNewString;
 860:              List<Ia.Ngn.Cl.Model.Access> list;
 861:   
 862:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 863:              {
 864:                  streetString = street.ToString();
 865:                  premisesOldString = premisesOld.ToString();
 866:                  premisesNewString = premisesNew.ToString();
 867:   
 868:                  list = (from a in db.Accesses
 869:                          where
 870:                          a.AreaId == kuwaitOfnAreaId
 871:                          &&
 872:                          (
 873:                          a.Block == block && a.Street == streetString && a.PremisesOld == premisesOldString && a.PremisesNew == premisesNewString
 874:                          || a.Block == block && a.Street == streetString && a.PremisesOld == premisesOldString && premisesNew == 0
 875:                          || a.Block == block && a.Street == streetString && a.PremisesNew == premisesNewString && premisesOld == 0
 876:                          || a.Block == block && a.PremisesOld == premisesOldString && a.PremisesNew == premisesNewString && street == 0
 877:                          || a.Block == block && a.PremisesOld == premisesOldString && street == 0 && premisesNew == 0
 878:                          || a.Block == block && a.PremisesNew == premisesNewString && street == 0 && premisesOld == 0
 879:                          || a.Block == block && a.Street == streetString && premisesOld == 0 && premisesNew == 0
 880:                          || a.Block == block && street == 0 && premisesOld == 0 && premisesNew == 0
 881:                          || block == string.Empty && street == 0 && premisesOld == 0 && premisesNew == 0
 882:                          )
 883:                          select a).AsNoTracking().ToList();
 884:              }
 885:   
 886:              return list.Distinct().ToList();
 887:          }
 888:   
 889:          ////////////////////////////////////////////////////////////////////////////
 890:   
 891:          /// <summary>
 892:          /// 
 893:          /// </summary>
 894:          public static List<Ia.Ngn.Cl.Model.Access> AccessListFromAreaAndBlock(int kuwaitOfnAreaId, string block)
 895:          {
 896:              List<Ia.Ngn.Cl.Model.Access> list;
 897:   
 898:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 899:              {
 900:                  list = (from a in db.Accesses
 901:                          where a.AreaId == kuwaitOfnAreaId && a.Block == block
 902:                          select a).AsNoTracking().ToList();
 903:              }
 904:   
 905:              return list.Distinct().ToList();
 906:          }
 907:   
 908:          ////////////////////////////////////////////////////////////////////////////
 909:   
 910:          /// <summary>
 911:          /// 
 912:          /// </summary>
 913:          public static List<string> AccessIdListFromPaci(int paci)
 914:          {
 915:              List<string> list;
 916:   
 917:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 918:              {
 919:                  if (paci > 0)
 920:                  {
 921:                      list = (from a in db.Accesses
 922:                              where a.Paci == paci.ToString()
 923:                              select a.Id).AsNoTracking().ToList();
 924:                  }
 925:                  else list = new List<string>();
 926:              }
 927:   
 928:              return list.ToList();
 929:          }
 930:   
 931:          ////////////////////////////////////////////////////////////////////////////
 932:   
 933:          /// <summary>
 934:          /// 
 935:          /// </summary>
 936:          public static List<Ia.Ngn.Cl.Model.Ont> OntList(List<string> ontIdList)
 937:          {
 938:              List<Ia.Ngn.Cl.Model.Ont> list;
 939:   
 940:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 941:              {
 942:                  if (ontIdList.Count > 0)
 943:                  {
 944:                      list = (from o in db.Onts
 945:                              where ontIdList.Contains(o.Id)
 946:                              select o).AsNoTracking().ToList();
 947:                  }
 948:                  else list = new List<Ia.Ngn.Cl.Model.Ont>();
 949:              }
 950:   
 951:              return list.Distinct().ToList();
 952:          }
 953:   
 954:          ////////////////////////////////////////////////////////////////////////////
 955:   
 956:          /// <summary>
 957:          /// 
 958:          /// </summary>
 959:          public static List<Ia.Ngn.Cl.Model.OntOntPots> OntOntPotsListFromOntOntPotsIdList(List<string> ontOntPotsIdList)
 960:          {
 961:              List<Ia.Ngn.Cl.Model.OntOntPots> list;
 962:   
 963:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 964:              {
 965:                  if (ontOntPotsIdList.Count > 0)
 966:                  {
 967:                      list = (from oop in db.OntOntPots
 968:                              where ontOntPotsIdList.Contains(oop.Id)
 969:                              select oop).AsNoTracking().ToList();
 970:                  }
 971:                  else list = new List<Ia.Ngn.Cl.Model.OntOntPots>();
 972:              }
 973:   
 974:              return list.Distinct().ToList();
 975:          }
 976:   
 977:          ////////////////////////////////////////////////////////////////////////////
 978:   
 979:          /// <summary>
 980:          /// 
 981:          /// </summary>
 982:          public static List<Ia.Ngn.Cl.Model.Event> EventList(List<long> eventIdList)
 983:          {
 984:              List<Ia.Ngn.Cl.Model.Event> list;
 985:   
 986:              using (var db = new Ia.Ngn.Cl.Model.Ngn())
 987:              {
 988:                  if (eventIdList.Count > 0)
 989:                  {
 990:                      list = (from e in db.Events
 991:                              where eventIdList.Contains(e.Id)
 992:                              select e).AsNoTracking().ToList();
 993:                  }
 994:                  else list = new List<Ia.Ngn.Cl.Model.Event>();
 995:              }
 996:   
 997:              return list.Distinct().ToList();
 998:          }
 999:   
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Ui.Nokia.SubParty> SubPartyList(List<string> subPartyIdList)
        {
            List<Ia.Ngn.Cl.Model.Ui.Nokia.SubParty> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (subPartyIdList.Count > 0)
                {
                    list = (from sp in db.SubParties
                            where subPartyIdList.Contains(sp.Id)
                            select new Ia.Ngn.Cl.Model.Ui.Nokia.SubParty()
                            {
                                Id = sp.Id,
                                PartyId = sp.PartyId,
                                PrimaryPUIDCPEProfileNumber = sp.PrimaryPUIDCPEProfileNumber,
                                DisplayName = sp.DisplayName,
                                Category = sp.Category,
                                AssocOtasRealm = sp.AssocOtasRealm,
                                ServiceSuspension = sp.ServiceSuspension,
                                Created = sp.Created,
                                Updated = sp.Updated
                            }).AsNoTracking().ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.Ui.Nokia.SubParty>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Report> ReportList(List<int> reportIdList)
        {
            List<Ia.Ngn.Cl.Model.Report> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (reportIdList.Count > 0)
                {
                    list = (from r in db.Reports
                            where reportIdList.Contains(r.Id)
                            select r).Include(u => u.ReportHistories).AsNoTracking().ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.Report>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Ui.Huawei.HuSbr> HuSbrList(List<string> huSbrImpuList)
        {
            List<Ia.Ngn.Cl.Model.Ui.Huawei.HuSbr> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (huSbrImpuList.Count > 0)
                {
                    list = (from h in db.HuSbrs
                            where huSbrImpuList.Contains(h.IMPU)
                            select new Ia.Ngn.Cl.Model.Ui.Huawei.HuSbr()
                            {
                                COP = h.COP,
                                CSC = h.CSC,
                                Id = h.Id,
                                IMPU = h.IMPU,
                                ITT = h.ITT,
                                LP = h.LP,
                                NS3PTY = h.NS3PTY,
                                NSABRC = h.NSABRC,
                                NSCBA = h.NSCBA,
                                NSCFU = h.NSCFU,
                                NSCLIP = h.NSCLIP,
                                NSCW = h.NSCW,
                                NSFAX = h.NSFAX,
                                NSHOLD = h.NSHOLD,
                                NSNPTY = h.NSNPTY,
                                NSWAKE_UP = h.NSWAKE_UP,
                                Created = h.Created,
                                Updated = h.Updated
                            }).AsNoTracking().ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.Ui.Huawei.HuSbr>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Huawei.Owsbr> OwsbrList(List<string> owsbrImpuList)
        {
            List<Ia.Ngn.Cl.Model.Huawei.Owsbr> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (owsbrImpuList.Count > 0)
                {
                    list = (from o in db.Owsbrs
                            where owsbrImpuList.Contains(o.IMPU)
                            select o).AsNoTracking().ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.Huawei.Owsbr>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Huawei.Seruattr> SeruattrListFromServiceIdList(List<string> serviceIdList)
        {
            List<Ia.Ngn.Cl.Model.Huawei.Seruattr> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceIdList.Count > 0)
                {
                    list = (from s in db.Seruattrs
                            where serviceIdList.Contains(s.Id)
                            select s).AsNoTracking().ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.Huawei.Seruattr>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Huawei.Seruattr> SeruattrList(List<string> serviceList)
        {
            List<Ia.Ngn.Cl.Model.Huawei.Seruattr> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceList.Count > 0)
                {
                    list = (from s in db.Seruattrs
                            where serviceList.Contains(s.USRNUM)
                            select s).AsNoTracking().ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.Huawei.Seruattr>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Ericsson.AxeSubscriber> AxeSubscriberListFromServiceIdList(List<string> serviceIdList)
        {
            List<Ia.Ngn.Cl.Model.Ericsson.AxeSubscriber> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceIdList.Count > 0)
                {
                    list = (from s in db.AxeSubscribers
                            where serviceIdList.Contains(s.Id)
                            select s).AsNoTracking().ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.Ericsson.AxeSubscriber>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Ericsson.AxeSubscriber> AxeSubscriberList(List<int> numberList)
        {
            List<Ia.Ngn.Cl.Model.Ericsson.AxeSubscriber> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (numberList.Count > 0)
                {
                    list = (from s in db.AxeSubscribers
                            where numberList.Contains(s.SNB)
                            select s).AsNoTracking().ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.Ericsson.AxeSubscriber>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Siemens.EwsdSubscriber> EwsdSubscriberListFromServiceIdList(List<string> serviceIdList)
        {
            List<Ia.Ngn.Cl.Model.Siemens.EwsdSubscriber> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceIdList.Count > 0)
                {
                    list = (from s in db.EwsdSubscribers
                            where serviceIdList.Contains(s.Id)
                            select s).AsNoTracking().ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.Siemens.EwsdSubscriber>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Siemens.EwsdSubscriber> EwsdSubscriberList(List<int> numberList)
        {
            List<Ia.Ngn.Cl.Model.Siemens.EwsdSubscriber> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (numberList.Count > 0)
                {
                    // this procedure was not used but might be slow. try to read using id
                    //var id = Ia.Ngn.Cl.Model.Business.Siemens.Subscriber.SubscriberId(23616858);
                    //var subscriber = (from es in db.EwsdSubscribers where es.Id == id select es.DN).SingleOrDefault();
 
                    list = (from s in db.EwsdSubscribers
                            where numberList.Contains(s.DN)
                            select s).AsNoTracking().ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.Siemens.EwsdSubscriber>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.OntServiceVoip> OntServiceVoipList(List<string> ontServiceVoipIdList)
        {
            List<Ia.Ngn.Cl.Model.OntServiceVoip> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (ontServiceVoipIdList.Count > 0)
                {
                    list = (from ov in db.OntServiceVoips
                            where ontServiceVoipIdList.Contains(ov.Id)
                            select ov).AsNoTracking().ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.OntServiceVoip>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Ui.Service2> ServiceList(List<string> serviceIdList)
        {
            List<Ia.Ngn.Cl.Model.Service2> list0;
            List<Ia.Ngn.Cl.Model.Ui.Service2> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceIdList.Count > 0)
                {
                    list0 = (from s in db.Service2 where serviceIdList.Contains(s.Id) select s).Include(u => u.Access).AsNoTracking().ToList();
 
                    list = (from s in list0
                            select new Ia.Ngn.Cl.Model.Ui.Service2()
                            {
                                Id = s.Id,
                                AbbriviatedCalling = s.AbbriviatedCalling,
                                AlarmCall = s.AlarmCall,
                                CallBarring = s.CallBarring,
                                CallerId = s.CallerId,
                                CallForwarding = s.CallForwarding,
                                CallWaiting = s.CallWaiting,
                                ConferenceCall = s.ConferenceCall,
                                Created = s.Created,
                                InternationalCalling = s.InternationalCalling,
                                InternationalCallingUserControlled = s.InternationalCallingUserControlled,
                                Port = s.Port,
                                Pin = s.Pin,
                                Service = s.Service,
                                ServiceType = s.ServiceType,
                                ServiceSuspension = s.ServiceSuspension,
                                ServiceTypeName = s.ServiceType.ToString(),
                                Updated = s.Updated,
                                AccessId = (s.Access != null) ? s.Access.Id : string.Empty
                            }).ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.Ui.Service2>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<Ia.Ngn.Cl.Model.Ui.Nokia.Subscriber> SubscriberList(List<string> subscriberIdList)
        {
            List<Ia.Ngn.Cl.Model.Ui.Nokia.Subscriber> list;
 
            // below: db.Subscribers contains XML fields which can not be evaluated in a Union() function.
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (subscriberIdList.Count > 0)
                {
                    list = (from s in db.Subscribers
                            where subscriberIdList.Contains(s.Id)
                            select s).AsEnumerable().Select(s => new Ia.Ngn.Cl.Model.Ui.Nokia.Subscriber()
                            {
                                Id = s.Id,
                                AlternateOtasRealm = s.AlternateOtasRealm,
                                PartyId = s.PartyId,
                                AbbriviatedCalling = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.OneDigitSpeedDialIsAssigned(s._OneDigitSpeedDial),
                                AlarmCall = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.ReminderCallIsAssigned(s._ReminderCall),
                                CallerId = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.CallingLineIdIsAssigned(s._CallingLineId),
                                CallForwarding = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.CallForwardingIsAssigned(s._CallForwardingVari),
                                CallWaiting = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.CallWaitingIsAssigned(s._CallWaiting, false),
                                ConferenceCall = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.ConferenceCallIsAssigned(s._ConferenceCalling),
                                InternationalCalling = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.InternationalCallingIsAssigned(s._CallBarring),
                                InternationalCallingUserControlled = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.InternationalCallingUserControlledIsAssigned(s._OutgoingCallBarring),
                                //ServiceSuspention = Ia.Ngn.Cl.Model.Business.Nokia.Subscriber.ServiceSuspentionIsAssigned(s._ServiceSuspention),
                                Created = s.Created,
                                Updated = s.Updated,
                            }).ToList();
                }
                else list = new List<Ia.Ngn.Cl.Model.Ui.Nokia.Subscriber>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AccessIdList(int oltId, int ponNumber, int ontInternalNumber)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                list = (from a in db.Accesses
                        where a.Olt == oltId && a.Pon == ponNumber && a.Ont == ontInternalNumber
                        select a.Id).AsNoTracking().ToList();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AccessIdList(int oltId, int ponNumber)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                list = (from a in db.Accesses
                        where a.Olt == oltId && a.Pon == ponNumber
                        select a.Id).AsNoTracking().ToList();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> EmsDevIdListFromEmsBoardIdList(List<string> emsBoardIdList)
        {
            List<int> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (emsBoardIdList.Count > 0)
                {
                    list = (from ed in db.EmsDevs
                            join eb in db.EmsBoards on ed.Id equals eb.EmsDev.Id
                            where emsBoardIdList.Contains(eb.Id)
                            select ed.Id).ToList();
                }
                else list = new List<int>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> EmsDevIdListFromAccessIdList(List<string> accessIdList)
        {
            List<int> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (accessIdList.Count > 0)
                {
                    list = (from ed in db.EmsDevs
                            where accessIdList.Contains(ed.Access.Id)
                            select ed.Id).ToList();
                }
                else list = new List<int>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> EmsDevIdListFromEmsVoipPstnUserIdList(List<string> emsVoipPstnUserIdList)
        {
            List<int> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (emsVoipPstnUserIdList.Count > 0)
                {
                    list = (from ed in db.EmsDevs
                            join evpu in db.EmsVoipPstnUsers on ed.DID equals evpu.DID
                            where emsVoipPstnUserIdList.Contains(evpu.Id)
                            select ed.Id).ToList();
                }
                else list = new List<int>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> EmsBoardIdListFromEmsPortIdList(List<string> emsPortIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (emsPortIdList.Count > 0)
                {
                    list = (from eb in db.EmsBoards
                            join ep in db.EmsPorts on eb.Id equals ep.EmsBoard.Id
                            where emsPortIdList.Contains(ep.Id)
                            select eb.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> EmsBoardIdListFromAccessIdList(List<string> accessIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (accessIdList.Count > 0)
                {
                    list = (from eb in db.EmsBoards
                            join ed in db.EmsDevs on eb.EmsDev.Id equals ed.Id
                            where accessIdList.Contains(ed.Access.Id)
                            select eb.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> EmsPortIdListFromEmsOntIdList(List<string> emsOntIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (emsOntIdList.Count > 0)
                {
                    list = (from ep in db.EmsPorts
                            join eo in db.EmsOnts on ep.Id equals eo.EmsPort.Id
                            where emsOntIdList.Contains(eo.Id)
                            select ep.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> EmsPortIdListFromEmsVoipPstnUserIdList(List<string> emsVoipPstnUserIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (emsVoipPstnUserIdList.Count > 0)
                {
                    // select * from EmsPorts where did  = 7340512 and fn = 0 and sn = 1 and pn = 0
                    var list0 = (from evpu in db.EmsVoipPstnUsers
                                 where emsVoipPstnUserIdList.Contains(evpu.Id)
                                 select evpu).AsNoTracking().ToList();
 
                    list = new List<string>();
 
                    foreach (var evpu in list0)
                    {
                        var l = (from ep in db.EmsPorts
                                 where ep.DID == evpu.DID && ep.FN == evpu.FN && ep.SN == evpu.SN && ep.PN == evpu.PN
                                 select ep.Id).AsNoTracking().SingleOrDefault();
 
                        if (l != null) list.Add(l);
                    }
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> EmsOntIdListFromNddOntIdList(List<string> nddOntIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (nddOntIdList.Count > 0)
                {
                    list = (from eo in db.EmsOnts
                            where nddOntIdList.Contains(eo.Id)
                            select eo.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> EmsOntIpListFromNddOntIdList(List<string> nddOntIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (nddOntIdList.Count > 0)
                {
                    list = (from eo in db.EmsOnts
                            where nddOntIdList.Contains(eo.Id)
                            select eo.IP).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> SbrImpuListFromImpuSipDomainList(List<string> impuSipDomainList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (impuSipDomainList.Count > 0)
                {
                    list = (from s in db.HuSbrs
                            where impuSipDomainList.Contains(s.IMPU)
                            select s.IMPU).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> OwSbrImpuListFromImpuSipDomainList(List<string> impuSipDomainList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (impuSipDomainList.Count > 0)
                {
                    list = (from o in db.Owsbrs
                            where impuSipDomainList.Contains(o.IMPU)
                            select o.IMPU).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> ServiceRequestServiceIdListFromAccessIdList(List<string> accessIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (accessIdList.Count > 0)
                {
                    list = (from srs in db.ServiceRequestServices
                            where accessIdList.Contains(srs.Access.Id)
                            select srs.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> ServiceRequestServiceIdListFromServiceIdList(List<string> serviceIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceIdList.Count > 0)
                {
                    list = (from srs in db.ServiceRequestServices
                            where serviceIdList.Contains(srs.Id)
                            select srs.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> ServiceRequestServiceIdListFromServiceList(List<string> serviceList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceList.Count > 0)
                {
                    list = (from srs in db.ServiceRequestServices
                            where serviceList.Contains(srs.Service)
                            select srs.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> Service2IdListFromServiceIdList(List<string> serviceIdList)
        {
            List<string> list;
 
            if (serviceIdList.Count > 0)
            {
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    list = (from s in db.Service2
                            where serviceIdList.Contains(s.Id)
                            select s.Id).AsNoTracking().ToList();
                }
            }
            else list = new List<string>();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> ServiceIdListFromServiceList(List<string> serviceList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceList.Count > 0)
                {
                    list = (from s in db.Service2
                            where serviceList.Contains(s.Service)
                            select s.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> ReportIdListFromServiceList(List<string> serviceList)
        {
            List<int> list;
 
            //reportIdList = (from r in db.Reports where r.Service == accessName && r.ServiceType == 2 select r.Id).Distinct().ToList();
            // <type id="2" name="Ont Name" arabicName=""/>
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceList.Count > 0)
                {
                    list = (from r in db.Reports
                            where serviceList.Contains(r.Service)
                            select r.Id).ToList();
                }
                else list = new List<int>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> ReportIdListFromAccessIdList(List<string> accessIdList)
        {
            string accessName;
            List<string> accessNameList;
            List<int> list;
 
            //reportIdList = (from r in db.Reports where r.Service == accessName && r.ServiceType == 2 select r.Id).Distinct().ToList();
            // <type id="2" name="Ont Name" arabicName=""/>
 
            if (accessIdList.Count > 0)
            {
                var ontAccessIdToOntAccessNameDictionary = Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntAccessIdToOntAccessNameDictionary;
 
                accessNameList = new List<string>();
 
                foreach (var id in accessIdList)
                {
                    if (ontAccessIdToOntAccessNameDictionary.ContainsKey(id))
                    {
                        accessName = ontAccessIdToOntAccessNameDictionary[id];
 
                        accessNameList.Add(accessName);
                    }
                }
 
                list = ReportIdListFromServiceList(accessNameList); // Its OK
            }
            else list = new List<int>();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> ServiceIdListFromAccessIdList(List<string> accessIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (accessIdList.Count > 0)
                {
                    list = (from s in db.Service2
                            where s.Access != null && accessIdList.Contains(s.Access.Id)
                            select s.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AccessIdListFromServiceIdList(List<string> serviceIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceIdList.Count > 0)
                {
                    list = (from s in db.Service2
                            where serviceIdList.Contains(s.Id) && s.Access != null
                            select s.Access.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AccessIdListFromServiceList(List<string> serviceList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceList.Count > 0)
                {
                    list = (from s in db.Service2
                            where serviceList.Contains(s.Service) && s.Access != null /*&& where s.ServiceType == Ia.Ngn.Cl.Model.Business.Service.ServiceType.NgnService*/
                            select s.Access.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AccessIdListFromServiceRequestServiceIdList(List<string> serviceRequestServiceIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceRequestServiceIdList.Count > 0)
                {
                    list = (from srs in db.ServiceRequestServices
                            where serviceRequestServiceIdList.Contains(srs.Id) && srs.Access != null
                            select srs.Access.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> ServiceRequestOntIdListFromAccessIdList(List<string> accessIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (accessIdList.Count > 0)
                {
                    list = (from sro in db.ServiceRequestOnts
                            where accessIdList.Contains(sro.Access.Id)
                            select sro.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> ServiceRequestIdListFromServiceList(List<string> serviceList)
        {
            List<int> list, numberList;
 
            if (serviceList.Count > 0)
            {
                numberList = serviceList.Select(int.Parse).ToList();
 
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    list = (from sr in db.ServiceRequests
                            where numberList.Contains(sr.Number)
                            select sr.Id).ToList();
                }
            }
            else list = new List<int>();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> ServiceRequestIdListFromServiceAndRelatedChangedAndChangedToServiceList(List<string> serviceList)
        {
            List<int> list;//, numberList, numberAndChangedAndChangedToList;
 
            if (serviceList.Count > 0)
            {
                var list0 = Ia.Ngn.Cl.Model.Data.ServiceRequest.ServiceListAndRelatedChangedAndChangedToServiceListByServiceList(serviceList);
                serviceList = serviceList.Union(list0).Distinct().ToList();
 
                list = Ia.Ngn.Cl.Model.Data.Maintenance.Find.ServiceRequestIdListFromServiceList(serviceList);
            }
            else list = new List<int>();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> ServiceRequestIdListFromServiceRequestServiceIdList(List<string> serviceRequestServiceIdList)
        {
            List<int> list;
 
            if (serviceRequestServiceIdList.Count > 0)
            {
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    list = (from sr in db.ServiceRequests
                            where serviceRequestServiceIdList.Contains(sr.ServiceRequestService.Id)
                            select sr.Id).ToList();
                }
            }
            else list = new List<int>();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> ServiceRequestAdministrativeIssueIdListFromServiceIdList(List<string> serviceIdList)
        {
            List<string> list;
 
            if (serviceIdList.Count > 0)
            {
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    list = (from srai in db.ServiceRequestAdministrativeIssues
                            where serviceIdList.Contains(srai.Id)
                            select srai.Id).AsNoTracking().ToList();
                }
            }
            else list = new List<string>();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> ServiceRequestHistoryIdListFromServiceAndRelatedChangedAndChangedToServiceList(List<string> serviceList)
        {
            List<int> numberList;
            List<string> list;
 
            if (serviceList.Count > 0)
            {
                var list0 = Ia.Ngn.Cl.Model.Data.ServiceRequest.ServiceListAndRelatedChangedAndChangedToServiceListByServiceList(serviceList);
                serviceList = serviceList.Union(list0).Distinct().ToList();
 
                numberList = new List<int>();
 
                foreach (string s in serviceList)
                {
                    if (int.TryParse(s, out int i)) numberList.Add(i);
                }
 
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    list = (from srh in db.ServiceRequestHistories
                            where numberList.Contains(srh.Number)
                            select srh.Id).AsNoTracking().ToList();
                }
            }
            else list = new List<string>();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> ServiceRequestTypeIdListFromServiceRequestIdList(List<int> serviceRequestIdList)
        {
            List<int> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (serviceRequestIdList.Count > 0)
                {
                    list = (from srt in db.ServiceRequestTypes
                            where serviceRequestIdList.Contains(srt.ServiceRequest.Id)
                            select srt.Id).ToList();
                }
                else list = new List<int>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> NddOntIdList(int oltId, int ponNumber, int ontInternalNumber)
        {
            List<string> list;
 
            list = (from o in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList
                    where o.Pon.PonGroup.Olt.Id == oltId && o.Pon.Number == ponNumber && o.Number == ontInternalNumber
                    select o.Id).ToList();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> NddOntIdList(int oltId, int ponNumber)
        {
            List<string> list;
 
            list = (from o in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList
                    where o.Pon.PonGroup.Olt.Id == oltId && o.Pon.Number == ponNumber
                    select o.Id).ToList();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> NddOntIdListFromAccessIdList(List<string> accessIdList)
        {
            List<string> list;
 
            if (accessIdList.Count > 0)
            {
                // this is not slow for general returns
                list = (from o in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList
                        where accessIdList.Contains(o.Access.Id)
                        select o.Id).ToList();
            }
            else list = new List<string>();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> NddOntIdListFromIpList(List<string> ipList)
        {
            List<string> list;
 
            if (ipList.Count > 0)
            {
                // this is not slow for general returns
                list = (from o in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList
                        where ipList.Contains(o.Ip)
                        select o.Id).ToList();
            }
            else list = new List<string>();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////   
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> NddOntIdListFromEmsOntSipInfoListAndEmsVoipPstnUserListByServiceList(List<string> serviceList)
        {
            string sipUserName, serviceWithCountryCode;
            List<string> list, emsOntSipInfoEmsOntIdList, emsVoipPstnUserEmsOntIdList;
            List<string> emsOntSipInfoSipUserNameList, emsVoipPstnUserDnList;
 
            if (serviceList.Count > 0)
            {
                emsOntSipInfoSipUserNameList = new List<string>();
                emsVoipPstnUserDnList = new List<string>();
 
                foreach (var service in serviceList)
                {
                    sipUserName = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.SipUserName(service);
                    emsOntSipInfoSipUserNameList.Add(sipUserName);
 
                    serviceWithCountryCode = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.ServiceWithCountryCode(service);
                    emsVoipPstnUserDnList.Add(serviceWithCountryCode);
                }
 
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    emsOntSipInfoEmsOntIdList = (from eosi in db.EmsOntSipInfoes
                                                 join eo in db.EmsOnts on eosi.EmsOnt.Id equals eo.Id
                                                 where emsOntSipInfoSipUserNameList.Contains(eosi.SIPUSERNAME)
                                                 select eo.Id).AsNoTracking().ToList();
 
                    emsOntSipInfoEmsOntIdList = emsOntSipInfoEmsOntIdList.Distinct().ToList();
 
                    emsVoipPstnUserEmsOntIdList = (from evpu in db.EmsVoipPstnUsers
                                                   join eo in db.EmsOnts on evpu.EmsOnt.Id equals eo.Id
                                                   where evpu.EmsOnt != null && emsVoipPstnUserDnList.Contains(evpu.DN)
                                                   select eo.Id).AsNoTracking().ToList();
 
                    emsVoipPstnUserEmsOntIdList = emsVoipPstnUserEmsOntIdList.Distinct().ToList();
 
                    list = emsOntSipInfoEmsOntIdList.Concat(emsVoipPstnUserEmsOntIdList).ToList();
                    list = list.Distinct().ToList();
                }
            }
            else list = new List<string>();
 
            return list.ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> OntServiceVoipIpList(List<string> ontServiceVoipIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (ontServiceVoipIdList.Count > 0)
                {
                    list = (from osv in db.OntServiceVoips
                            where ontServiceVoipIdList.Contains(osv.Id)
                            select osv.Ip).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> NddPonIpList(int oltId, int ponNumber)
        {
            var list = (from o in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList
                        where o.Pon.PonGroup.Olt.Id == oltId && o.Pon.Number == ponNumber
                        select o.Ip);//.ToList();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> OntIdListFromNddOntIdList(List<string> nddOntIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (nddOntIdList.Count > 0)
                {
                    list = (from o in db.Onts
                            where nddOntIdList.Contains(o.Id)
                            select o.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> OntOntPotsIdListFromOntIdList(List<string> ontIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (ontIdList.Count > 0)
                {
                    list = (from oop in db.OntOntPots
                            where ontIdList.Contains(oop.Ont.Id)
                            select oop.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> OntServiceVoipsIdListFromOntIdList(List<string> ontIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (ontIdList.Count > 0)
                {
                    list = (from ov in db.OntServiceVoips
                            where ontIdList.Contains(ov.Ont.Id)
                            select ov.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AccessIdListFromOntSerial(string serial)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (!string.IsNullOrEmpty(serial))
                {
                    list = (from o in db.Onts
                            where o.Serial == serial
                            select o.Access.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AccessIdListFromEmsOntSerial(string serial)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (!string.IsNullOrEmpty(serial))
                {
                    list = (from eo in db.EmsOnts
                            where eo.SERIALNUM == serial
                            select eo.Access.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AccessIdListFromEmsOntIp(string ip)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (!string.IsNullOrEmpty(ip))
                {
                    list = (from eo in db.EmsOnts
                            where eo.IP == ip
                            select eo.Access.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> OntServiceVoipsIdListFromIpList(List<string> ipList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (ipList.Count > 0)
                {
                    list = (from ov in db.OntServiceVoips
                            where ipList.Contains(ov.Ip)
                            select ov.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<long> EventIdListFromOntIdList(List<string> ontIdList)
        {
            List<long> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (ontIdList.Count > 0)
                {
                    list = (from e in db.Events
                            where ontIdList.Contains(e.Ont.Id) && e.Ont != null
                            select e.Id).ToList();
                }
                else list = new List<long>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<long> EventIdListFromNddOntIdList(List<string> nddOntIdList, int take)
        {
            List<long> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (nddOntIdList.Count > 0)
                {
                    //foreach (var v in nddOntList)
                    //{
                    //eventSystemList.Add(v.Pon.PonGroup.Olt.AmsName);
                    //eventAidOntList.Add("ONT-1-1-" + v.Card + "-" + v.Port + "-" + v.Number);
                    //eventAidOntVoipList.Add("ONTVOIP-1-1-" + v.Card + "-" + v.Port + "-1");
 
                    //foreach (var w in ontOntPotsList) eventAidOntPotsList.Add("ONTPOTS-1-1-" + v.Card + "-" + v.Port + "-" + w.Card + "-" + w.Port);
                    //}
 
                    //eventSystemList = eventSystemList.Distinct().ToList();
                    //eventAidOntList = eventAidOntList.Distinct().ToList();
                    //eventAidOntVoipList = eventAidOntVoipList.Distinct().ToList();
 
                    /*
                    eventList = (from e in db.Events where eventSystemList.Contains(e.System) where eventAidOntList.Contains(e.Aid) select e)
                                .Union(from e in db.Events where eventSystemList.Contains(e.System) where eventAidOntList.Contains(e.Aid) where eventAidOntVoipList.Contains(e.Aid) select e)
                                .Union(from e in db.Events where eventSystemList.Contains(e.System) where eventAidOntList.Contains(e.Aid) where eventAidOntPotsList.Contains(e.Aid) select e)
                                .ToList();
                                */
 
 
                    list = (from e in db.Events
                            where e.Ont != null && nddOntIdList.Contains(e.Ont.Id)
                            orderby e.Created descending
                            select e.Id).Take(take).ToList();
                }
                else list = new List<long>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> AgcfGatewayRecordIdListFromIpList(List<string> ipList)
        {
            List<int> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                // try Ia.Ngn.Cl.Model.Data.Nokia.AgcfGatewayRecord.IdToIp1Dictionary;
 
                if (ipList.Count > 0)
                {
                    list = (from gr in db.AgcfGatewayRecords
                            where ipList.Contains(gr.IP1)
                            select gr.Id).ToList();
                }
                else list = new List<int>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> AgcfGatewayRecordIdListFromNddOntIdList(List<string> nddOntIdlist)
        {
            List<int> list;
            List<string> nddIpList;
 
            if (nddOntIdlist.Count > 0)
            {
                nddIpList = (from o in Ia.Ngn.Cl.Model.Data.NetworkDesignDocument.OntList
                             where nddOntIdlist.Contains(o.Id)
                             select o.Ip).ToList();
 
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    list = (from gr in db.AgcfGatewayRecords
                            where nddIpList.Contains(gr.IP1)
                            select gr.Id).ToList();
                }
            }
            else list = new List<int>();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> AgcfGatewayRecordIdListFromAgcfEndpointIdList(List<string> agcfEndpointIdList)
        {
            List<int> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (agcfEndpointIdList.Count > 0)
                {
                    list = (from ep in db.AgcfEndpoints
                            where agcfEndpointIdList.Contains(ep.Id)
                            select ep.AgcfGatewayRecord.Id).ToList();
                }
                else list = new List<int>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AgcfGatewayRecordIpListFromIdList(List<int> agcfGatewayRecordIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (agcfGatewayRecordIdList.Count > 0)
                {
                    list = (from gr in db.AgcfGatewayRecords
                            where agcfGatewayRecordIdList.Contains(gr.Id)
                            select gr.IP1).ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> AgcfGatewayRecordIdListFromGatewayIdList(List<int> gatewayIdList)
        {
            List<int> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (gatewayIdList.Count > 0)
                {
                    list = (from gr in db.AgcfGatewayRecords
                            where gatewayIdList.Contains(gr.GwId)
                            select gr.Id).ToList();
                }
                else list = new List<int>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<int> GatewayIdFromAgcfGatewayRecordIdListList(List<int> agcfGatewayRecordIdList)
        {
            List<int> list;
 
            if (agcfGatewayRecordIdList.Count > 0)
            {
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    list = (from gr in db.AgcfGatewayRecords
                            where agcfGatewayRecordIdList.Contains(gr.Id)
                            select gr.GwId).ToList();
                }
            }
            else list = new List<int>();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AgcfEndpointIdListFromAgcfGatewayRecordIdList(List<int> agcfGatewayRecordIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (agcfGatewayRecordIdList.Count > 0)
                {
                    list = (from e in db.AgcfEndpoints
                            where agcfGatewayRecordIdList.Contains(e.AgcfGatewayRecord.Id) && e.AgcfGatewayRecord != null
                            select e.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> MgwIdListFromAsbrIdList(List<string> asbrIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (asbrIdList.Count > 0)
                {
                    /* this is just dumb!
                    list = (from m in db.Mgws
                            join a in db.Asbrs on m.Id equals a.Mgw.Id
                            where asbrIdList.Contains(a.Id)
                            select m.Id).ToList();
                    */
 
                    list = (from a in db.Asbrs
                            where asbrIdList.Contains(a.Id) && a.Mgw != null
                            select a.Mgw.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> MgwIdListFromIpList(List<string> ipList)
        {
            List<string> list, idList;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (ipList.Count > 0)
                {
                    // below is very slow
                    //list = (from m in db.Mgws where ipList.Contains(m.RA1) select m.Id).AsNoTracking().ToList();
 
                    // I will use the fact the Id have the IP in the middle
                    // see mgwId = Ia.Ngn.Cl.Model.Business.Huawei.Mgw.MgwId(response.NetworkElement, eid);
 
                    idList = new List<string>();
 
                    foreach (var ip in ipList)
                    {
                        idList.Add(Ia.Ngn.Cl.Model.Business.Huawei.SoftX.TecNetworkElement.Domain + ":" + ip + ":" + Ia.Ngn.Cl.Model.Business.Huawei.SoftX.RemotePort);
                        idList.Add(Ia.Ngn.Cl.Model.Business.Huawei.SoftX.SkbNetworkElement.Domain + ":" + ip + ":" + Ia.Ngn.Cl.Model.Business.Huawei.SoftX.RemotePort);
                    }
 
                    list = (from m in db.Mgws
                            where idList.Contains(m.Id)
                            select m.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> MgwIpListFromIdList(List<string> mgwIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (mgwIdList.Count > 0)
                {
                    list = (from m in db.Mgws
                            where mgwIdList.Contains(m.Id)
                            select m.RA1).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AsbrIdListFromImpuSipDomainList(List<string> impuSipDomainList)
        {
            string id;
            List<string> list, asbrIdInTecAndSkbNetworkElementList;
 
            if (impuSipDomainList.Count > 0)
            {
                asbrIdInTecAndSkbNetworkElementList = new List<string>(impuSipDomainList.Count * 2);
 
                foreach (var isd in impuSipDomainList)
                {
                    id = Ia.Ngn.Cl.Model.Business.Huawei.Asbr.AsbrId(Ia.Ngn.Cl.Model.Business.Huawei.SoftX.TecNetworkElement.Domain, isd);
                    asbrIdInTecAndSkbNetworkElementList.Add(id);
 
                    id = Ia.Ngn.Cl.Model.Business.Huawei.Asbr.AsbrId(Ia.Ngn.Cl.Model.Business.Huawei.SoftX.SkbNetworkElement.Domain, isd);
                    asbrIdInTecAndSkbNetworkElementList.Add(id);
                }
 
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    list = (from a in db.Asbrs
                            where asbrIdInTecAndSkbNetworkElementList.Contains(a.Id)
                            select a.Id).AsNoTracking().ToList();
                }
            }
            else list = new List<string>();
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AgcfEndpointIdListFromSubPartyIdList(List<string> subPartyIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (subPartyIdList.Count > 0)
                {
                    list = (from sp in db.SubParties
                            where subPartyIdList.Contains(sp.Id)
                            select sp.AgcfEndpoint.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AgcfEndpointIdListFromPrividUserList(List<string> prividUserList)
        {
            List<string> list0, list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (prividUserList.Count > 0)
                {
                    list0 = new List<string>();
 
                    foreach (var prividUser in prividUserList)
                    {
                        list0.Add(Ia.Ngn.Cl.Model.Nokia.AgcfEndpoint.AgcfEndpointId(prividUser));
                    }
 
                    list = (from ep in db.AgcfEndpoints
                                //where prividUserList.Contains(ep.PrividUser)
                            where list0.Contains(ep.Id)
                            select ep.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> AgcfEndpointIdListFromGatewayIdList(List<int> gatewayIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (gatewayIdList.Count > 0)
                {
                    list = (from ep in db.AgcfEndpoints
                            where gatewayIdList.Contains(ep.GwId)
                            select ep.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> SubPartyIdListFromAgcfEndpointIdList(List<string> agcfEndpointIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (agcfEndpointIdList.Count > 0)
                {
                    list = (from sp in db.SubParties
                            where agcfEndpointIdList.Contains(sp.AgcfEndpoint.Id) && sp.AgcfEndpoint != null
                            select sp.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> SubPartyIdListFromPartyIdList(List<string> partyIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (partyIdList.Count > 0)
                {
                    list = (from sp in db.SubParties
                            where partyIdList.Contains(sp.PartyId)
                            select sp.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> SubscriberIdListFromSubPartyIdList(List<string> subPartyIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (subPartyIdList.Count > 0)
                {
                    list = (from s in db.Subscribers
                            where subPartyIdList.Contains(s.SubParty.Id)
                            select s.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> SubscriberIdListFromPartyIdList(List<string> partyIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (partyIdList.Count > 0)
                {
                    // note that Id is PartyId. Maybe I could use it subscriber.Id = Ia.Ngn.Cl.Model.Nokia.Subscriber.SubscriberId(partyId);
                    //list = (from s in db.Subscribers where partyIdList.Contains(s.PartyId) select s.Id).AsNoTracking().ToList();
                    list = (from s in db.Subscribers where partyIdList.Contains(s.Id) select s.Id).AsNoTracking().ToList();
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static List<string> ServiceListFromGatewayIdList(List<int> gatewayIdList)
        {
            List<string> list;
 
            using (var db = new Ia.Ngn.Cl.Model.Ngn())
            {
                if (gatewayIdList.Count > 0)
                {
                    list = new List<string>();
 
                    var list0 = (from s in db.Subscribers
                                 join sp in db.SubParties on s.SubParty.Id equals sp.Id
                                 join ep in db.AgcfEndpoints on sp.AgcfEndpoint.Id equals ep.Id
                                 join gr in db.AgcfGatewayRecords on ep.AgcfGatewayRecord.Id equals gr.Id
                                 where gatewayIdList.Contains(gr.GwId)
                                 select s.PartyId).AsNoTracking().ToList();
 
                    foreach (var partyId in list0)
                    {
                        list.Add(Ia.Ngn.Cl.Model.Business.NumberFormatConverter.Service(partyId));
                    }
                }
                else list = new List<string>();
            }
 
            return list.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////   
 
        /// <summary>
        /// 
        /// </summary>
        public static void SynchronizeNumberFormatLists(ref List<string> partyIdList, ref List<string> prividUserList, ref List<string> serviceList, ref List<int> numberList, ref List<long> serviceLongList, ref List<string> impuSipDomainList, ref List<string> sipUserNameList, ref List<string> serviceWithCountryCodeList, ref List<string> serviceIdList)
        {
            int number;
            long numberWithCountryCode;
            string service, impuSipDomain, sipUserName, serviceWithCountryCode, partyId, prividUser;
 
            foreach (var pi in partyIdList)
            {
                service = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.Service(pi);
 
                if (!string.IsNullOrEmpty(service))
                {
                    number = int.Parse(service);
                    numberWithCountryCode = long.Parse(Ia.Ngn.Cl.Model.Business.Service.CountryCode.ToString() + number);
                    impuSipDomain = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.ImpuSipDomain(service);
                    sipUserName = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.SipUserName(service);
                    serviceWithCountryCode = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.ServiceWithCountryCode(service);
                    partyId = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.PartyId(service);
                    prividUser = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.PrividUser(service);
 
                    serviceList.Add(service);
                    numberList.Add(number);
                    serviceLongList.Add(numberWithCountryCode);
                    impuSipDomainList.Add(impuSipDomain);
                    sipUserNameList.Add(sipUserName);
                    serviceWithCountryCodeList.Add(serviceWithCountryCode);
                    //partyIdList.Add(partyId);
                    prividUserList.Add(prividUser);
                }
            }
 
            foreach (var s in serviceList)
            {
                service = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.Service(s);
 
                if (!string.IsNullOrEmpty(service))
                {
                    number = int.Parse(service);
                    numberWithCountryCode = long.Parse(Ia.Ngn.Cl.Model.Business.Service.CountryCode.ToString() + number);
                    impuSipDomain = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.ImpuSipDomain(service);
                    sipUserName = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.SipUserName(service);
                    serviceWithCountryCode = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.ServiceWithCountryCode(service);
                    partyId = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.PartyId(service);
                    prividUser = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.PrividUser(service);
 
                    //serviceList.Add(service);
                    numberList.Add(number);
                    serviceLongList.Add(numberWithCountryCode);
                    impuSipDomainList.Add(impuSipDomain);
                    sipUserNameList.Add(sipUserName);
                    serviceWithCountryCodeList.Add(serviceWithCountryCode);
                    partyIdList.Add(partyId);
                    prividUserList.Add(prividUser);
                }
            }
 
            serviceList = serviceList.Distinct().ToList();
            numberList = numberList.Distinct().ToList();
            serviceLongList = serviceLongList.Distinct().ToList();
            impuSipDomainList = impuSipDomainList.Distinct().ToList();
            sipUserNameList = sipUserNameList.Distinct().ToList();
            serviceWithCountryCodeList = serviceWithCountryCodeList.Distinct().ToList();
            partyIdList = partyIdList.Distinct().ToList();
            prividUserList = prividUserList.Distinct().ToList();
 
            serviceIdList = Ia.Ngn.Cl.Model.Business.Service.ServiceListToServiceIdListForAllServiceTypes(serviceList);
        }
 
        ////////////////////////////////////////////////////////////////////////////   
 
        /// <summary>
        /// 
        /// </summary>
        public static void UpdateServiceListFromServiceRequestServiceIdOrService2IdList(List<string> serviceRequestServiceIdListOrService2IdList, ref List<string> serviceList)
        {
            string service;
 
            foreach (var si in serviceRequestServiceIdListOrService2IdList)
            {
                service = Ia.Ngn.Cl.Model.Business.ServiceRequestService.ServiceIdToService(si);
 
                if (!string.IsNullOrEmpty(service)) serviceList.Add(service);
            }
 
            serviceList = serviceList.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////   
 
        /// <summary>
        /// 
        /// </summary>
        public static void CollectServiceListFromEmsOntSipInfoListAndEmsVoipPstnUserListByEmsOntIdList(List<string> emsOntIdList, ref List<string> serviceList)
        {
            string service;
            List<string> emsOntSipInfoSipUserNameList, emsVoipPstnUserDnList;
 
            if (emsOntIdList.Count > 0)
            {
                using (var db = new Ia.Ngn.Cl.Model.Ngn())
                {
                    emsOntSipInfoSipUserNameList = (from eosi in db.EmsOntSipInfoes
                                                    where emsOntIdList.Contains(eosi.EmsOnt.Id)
                                                    select eosi.SIPUSERNAME).AsNoTracking().ToList();
 
                    emsOntSipInfoSipUserNameList = emsOntSipInfoSipUserNameList.Distinct().ToList();
 
                    emsVoipPstnUserDnList = (from evpu in db.EmsVoipPstnUsers
                                             where evpu.EmsOnt != null && emsOntIdList.Contains(evpu.EmsOnt.Id)
                                             select evpu.DN).AsNoTracking().ToList();
 
                    emsVoipPstnUserDnList = emsVoipPstnUserDnList.Distinct().ToList();
                }
 
                foreach (var eosisun in emsOntSipInfoSipUserNameList)
                {
                    service = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.Service(eosisun);
 
                    if (!string.IsNullOrEmpty(service)) serviceList.Add(service);
                }
 
                foreach (var evpud in emsVoipPstnUserDnList)
                {
                    service = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.Service(evpud);
 
                    if (!string.IsNullOrEmpty(service)) serviceList.Add(service);
                }
            }
            else
            {
 
            }
 
            serviceList = serviceList.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////   
 
        /// <summary>
        /// 
        /// </summary>
        public static void CollectServiceListFromAgcfEndpointList(List<Ia.Ngn.Cl.Model.Ui.Nokia.AgcfEndpoint> agcfEndpointList, ref List<string> serviceList)
        {
            string service;
 
            foreach (var ep in agcfEndpointList)
            {
                service = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.Service(ep.PrividUser);
 
                if (!string.IsNullOrEmpty(service)) serviceList.Add(service);
            }
 
            serviceList = serviceList.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////   
 
        /// <summary>
        /// 
        /// </summary>
        public static void CollectServiceListFromSubscriberList(List<Ia.Ngn.Cl.Model.Ui.Nokia.Subscriber> subscriberList, ref List<string> serviceList)
        {
            string service;
 
            foreach (var s in subscriberList)
            {
                service = Ia.Ngn.Cl.Model.Business.NumberFormatConverter.Service(s.PartyId);
 
                if (!string.IsNullOrEmpty(service)) serviceList.Add(service);
            }
 
            serviceList = serviceList.Distinct().ToList();
        }
 
        ////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////   
    }
 
    ////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////   
}