)>}]
شركة التطبيقات المتكاملة لتصميم وبرمجة البرمجيات الخاصة ش.ش.و.
Integrated Applications Programming Company
Home » Code Library » Find (Ia.Ftn.Cl.Models.Data.Maintenance)

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 Fixed Telecommunications 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.Ftn.Cl.Models.Data.Maintenance
    8: {
    9:     ////////////////////////////////////////////////////////////////////////////
   10:  
   11:     /// <summary publish="true">
   12:     /// Find subscriber and network information support class for the Fixed Telecommunications 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:     /// </remarks> 
   18:     public class Find
   19:     {
   20:         ////////////////////////////////////////////////////////////////////////////
   21:  
   22:         /// <summary>
   23:         ///
   24:         /// </summary>
   25:         public Find() { }
   26:  
   27:         ////////////////////////////////////////////////////////////////////////////
   28:  
   29:         /// <summary>
   30:         /// 
   31:         /// </summary>
   32:         public static List<Ia.Ftn.Cl.Models.Ui.ServiceRequestService> ServiceRequestServiceList(List<string> serviceRequestServiceIdList)
   33:         {
   34:             List<Ia.Ftn.Cl.Models.ServiceRequestService> inList;
   35:             List<Ia.Ftn.Cl.Models.Ui.ServiceRequestService> list;
   36:  
   37:             using (var db = new Ia.Ftn.Cl.Db())
   38:             {
   39:                 if (serviceRequestServiceIdList.Count > 0)
   40:                 {
   41:                     inList = (from srs in db.ServiceRequestServices where serviceRequestServiceIdList.Contains(srs.Id) select srs).Include(u => u.Access).AsNoTracking().ToList();
   42:  
   43:                     list = (from srs in inList
   44:                             select new Ia.Ftn.Cl.Models.Ui.ServiceRequestService()
   45:                             {
   46:                                 Id = srs.Id,
   47:                                 AbbriviatedCalling = srs.AbbriviatedCalling,
   48:                                 Access = srs.Access,
   49:                                 AlarmCall = srs.AlarmCall,
   50:                                 CallBarring = srs.CallBarring,
   51:                                 CallerId = srs.CallerId,
   52:                                 CallForwarding = srs.CallForwarding,
   53:                                 CallWaiting = srs.CallWaiting,
   54:                                 ConferenceCall = srs.ConferenceCall,
   55:                                 Created = srs.Created,
   56:                                 InternationalCalling = srs.InternationalCalling,
   57:                                 InternationalCallingUserControlled = srs.InternationalCallingUserControlled,
   58:                                 LastRequestDateTime = srs.LastRequestDateTime,
   59:                                 Provisioned = srs.Provisioned,
   60:                                 Service = srs.Service,
   61:                                 Serial = srs.Serial,
   62:                                 ServiceType = srs.ServiceType,
   63:                                 //ServiceSuspension = srs.ServiceSuspension,
   64:                                 Type = srs.Type,
   65:                                 Updated = srs.Updated
   66:                             }).ToList();
   67:                 }
   68:                 else list = new List<Ia.Ftn.Cl.Models.Ui.ServiceRequestService>();
   69:  
   70:                 return list.Distinct().ToList();
   71:             }
   72:         }
   73:  
   74:         ////////////////////////////////////////////////////////////////////////////
   75:  
   76:         /// <summary>
   77:         /// 
   78:         /// </summary>
   79:         public static List<Ia.Ftn.Cl.Models.ServiceRequest> ServiceRequestList(List<int> serviceRequestIdList)
   80:         {
   81:             List<Ia.Ftn.Cl.Models.ServiceRequest> list;
   82:  
   83:             using (var db = new Ia.Ftn.Cl.Db())
   84:             {
   85:                 if (serviceRequestIdList.Count > 0)
   86:                 {
   87:                     list = (from sr in db.ServiceRequests
   88:                             where serviceRequestIdList.Contains(sr.Id)
   89:                             select sr).AsNoTracking().ToList();
   90:                 }
   91:                 else list = new List<Ia.Ftn.Cl.Models.ServiceRequest>();
   92:             }
   93:  
   94:             return list.Distinct().ToList();
   95:         }
   96:  
   97:         ////////////////////////////////////////////////////////////////////////////
   98:  
   99:         /// <summary>
  100:         /// 
  101:         /// </summary>
  102:         public static List<Ia.Ftn.Cl.Models.ServiceRequestAdministrativeIssue> ServiceRequestAdministrativeIssueList(List<string> serviceRequestAdministrativeIssueIdList)
  103:         {
  104:             List<Ia.Ftn.Cl.Models.ServiceRequestAdministrativeIssue> list;
  105:  
  106:             using (var db = new Ia.Ftn.Cl.Db())
  107:             {
  108:                 if (serviceRequestAdministrativeIssueIdList.Count > 0)
  109:                 {
  110:                     list = (from srai in db.ServiceRequestAdministrativeIssues
  111:                             where serviceRequestAdministrativeIssueIdList.Contains(srai.Id)
  112:                             select srai).AsNoTracking().ToList();
  113:                 }
  114:                 else list = new List<Ia.Ftn.Cl.Models.ServiceRequestAdministrativeIssue>();
  115:             }
  116:  
  117:             return list.Distinct().ToList();
  118:         }
  119:  
  120:         ////////////////////////////////////////////////////////////////////////////
  121:  
  122:         /// <summary>
  123:         /// 
  124:         /// </summary>
  125:         public static List<Ia.Ftn.Cl.Models.ServiceRequestHistory> ServiceRequestHistoryList(List<string> serviceRequestHistoryIdList)
  126:         {
  127:             List<Ia.Ftn.Cl.Models.ServiceRequestHistory> list;
  128:  
  129:             using (var db = new Ia.Ftn.Cl.Db())
  130:             {
  131:                 if (serviceRequestHistoryIdList.Count > 0)
  132:                 {
  133:                     list = (from srh in db.ServiceRequestHistories
  134:                             where serviceRequestHistoryIdList.Contains(srh.Id)
  135:                             select srh).AsNoTracking().ToList();
  136:                 }
  137:                 else list = new List<Ia.Ftn.Cl.Models.ServiceRequestHistory>();
  138:             }
  139:  
  140:             return list.Distinct().ToList();
  141:         }
  142:  
  143:         ////////////////////////////////////////////////////////////////////////////
  144:  
  145:         /// <summary>
  146:         /// 
  147:         /// </summary>
  148:         public static List<Ia.Ftn.Cl.Models.ServiceRequest> ServiceRequestListForCustomerId(int customerId, int maxNumberOfResults)
  149:         {
  150:             List<Ia.Ftn.Cl.Models.ServiceRequest> list;
  151:  
  152:             using (var db = new Ia.Ftn.Cl.Db())
  153:             {
  154:                 list = (from sr in db.ServiceRequests
  155:                         where sr.CustomerId == customerId
  156:                         select sr).AsNoTracking().Take(maxNumberOfResults).ToList();
  157:             }
  158:  
  159:             return list.Distinct().ToList();
  160:         }
  161:  
  162:         ////////////////////////////////////////////////////////////////////////////
  163:  
  164:         /// <summary>
  165:         /// 
  166:         /// </summary>
  167:         public static List<Ia.Ftn.Cl.Models.ServiceRequest> ServiceRequestListForCustomerName(string customerName, int maxNumberOfResults)
  168:         {
  169:             List<Ia.Ftn.Cl.Models.ServiceRequest> list;
  170:  
  171:             using (var db = new Ia.Ftn.Cl.Db())
  172:             {
  173:                 if (!string.IsNullOrEmpty(customerName))
  174:                 {
  175:                     list = (from sr in db.ServiceRequests
  176:                             where sr.CustomerName == customerName || sr.CustomerName.Contains(customerName)
  177:                             select sr).Take(maxNumberOfResults).AsNoTracking().ToList();
  178:                 }
  179:                 else list = new List<Ia.Ftn.Cl.Models.ServiceRequest>();
  180:             }
  181:  
  182:             return list.Distinct().ToList();
  183:         }
  184:  
  185:         ////////////////////////////////////////////////////////////////////////////
  186:  
  187:         /// <summary>
  188:         /// 
  189:         /// </summary>
  190:         public static List<Ia.Ftn.Cl.Models.ServiceRequestType> ServiceRequestTypeList(List<int> serviceRequestTypeIdList)
  191:         {
  192:             List<Ia.Ftn.Cl.Models.ServiceRequestType> list;
  193:  
  194:             using (var db = new Ia.Ftn.Cl.Db())
  195:             {
  196:                 if (serviceRequestTypeIdList.Count > 0)
  197:                 {
  198:                     list = (from srt in db.ServiceRequestTypes
  199:                             where serviceRequestTypeIdList.Contains(srt.Id)
  200:                             select srt).AsNoTracking().ToList();
  201:                 }
  202:                 else list = new List<Ia.Ftn.Cl.Models.ServiceRequestType>();
  203:             }
  204:  
  205:             return list.Distinct().ToList();
  206:         }
  207:  
  208:         ////////////////////////////////////////////////////////////////////////////
  209:  
  210:         /// <summary>
  211:         /// 
  212:         /// </summary>
  213:         public static List<Ia.Ftn.Cl.Models.Ui.Nokia.AgcfGatewayRecord> AgcfGatewayRecordList(List<int> agcfGatewayRecordIdList)
  214:         {
  215:             List<Ia.Ftn.Cl.Models.Ui.Nokia.AgcfGatewayRecord> list;
  216:  
  217:             using (var db = new Ia.Ftn.Cl.Db())
  218:             {
  219:                 if (agcfGatewayRecordIdList.Count > 0)
  220:                 {
  221:                     list = (from gr in db.AgcfGatewayRecords
  222:                             where agcfGatewayRecordIdList.Contains(gr.Id)
  223:                             select new Ia.Ftn.Cl.Models.Ui.Nokia.AgcfGatewayRecord()
  224:                             {
  225:                                 Id = gr.Id,
  226:                                 GwId = gr.GwId,
  227:                                 GwUserId = gr.GwUserId,
  228:                                 GwDomain = gr.GwDomain,
  229:                                 GwName = gr.GwName,
  230:                                 IP1 = gr.IP1,
  231:                                 IP2 = gr.IP2,
  232:                                 MateExternalIPAddr = gr.MateExternalIPAddr,
  233:                                 IsPrimary = gr.IsPrimary,
  234:                                 Created = gr.Created,
  235:                                 Updated = gr.Updated
  236:                             }).AsNoTracking().ToList();
  237:                 }
  238:                 else list = new List<Ia.Ftn.Cl.Models.Ui.Nokia.AgcfGatewayRecord>();
  239:             }
  240:  
  241:             return list.Distinct().ToList();
  242:         }
  243:  
  244:         ////////////////////////////////////////////////////////////////////////////
  245:  
  246:         /// <summary>
  247:         /// 
  248:         /// </summary>
  249:         public static List<Ia.Ftn.Cl.Models.Ui.Nokia.AgcfEndpoint> AgcfEndpointList(List<string> agcfEndpointIdList)
  250:         {
  251:             List<Ia.Ftn.Cl.Models.Ui.Nokia.AgcfEndpoint> list;
  252:  
  253:             using (var db = new Ia.Ftn.Cl.Db())
  254:             {
  255:                 if (agcfEndpointIdList.Count > 0)
  256:                 {
  257:                     list = (from e in db.AgcfEndpoints
  258:                             where agcfEndpointIdList.Contains(e.Id)
  259:                             select new Ia.Ftn.Cl.Models.Ui.Nokia.AgcfEndpoint()
  260:                             {
  261:                                 Id = e.Id,
  262:                                 PrividUser = e.PrividUser,
  263:                                 GwId = e.GwId,
  264:                                 Dn = e.Dn,
  265:                                 FlatTermID = e.FlatTermID,
  266:                                 CallHoldLc = e.CallHoldLc,
  267:                                 CallWaitingLc = e.CallWaitingLc,
  268:                                 CallToggleLc = e.CallToggleLc,
  269:                                 ThreeWayCallLc = e.ThreeWayCallLc,
  270:                                 McidLc = e.McidLc,
  271:                                 Password = e.Password,
  272:                                 CallTransferLc = e.CallTransferLc,
  273:                                 Created = e.Created,
  274:                                 Updated = e.Updated
  275:                             }).AsNoTracking().ToList();
  276:                 }
  277:                 else list = new List<Ia.Ftn.Cl.Models.Ui.Nokia.AgcfEndpoint>();
  278:             }
  279:  
  280:             return list.Distinct().ToList();
  281:         }
  282:  
  283:         ////////////////////////////////////////////////////////////////////////////
  284:  
  285:         /// <summary>
  286:         /// 
  287:         /// </summary>
  288:         public static List<Ia.Ftn.Cl.Models.Huawei.Mgw> MgwList(List<string> mgwIdList)
  289:         {
  290:             List<Ia.Ftn.Cl.Models.Huawei.Mgw> list;
  291:  
  292:             using (var db = new Ia.Ftn.Cl.Db())
  293:             {
  294:                 if (mgwIdList.Count > 0)
  295:                 {
  296:                     list = (from m in db.Mgws
  297:                             where mgwIdList.Contains(m.Id)
  298:                             select m).AsNoTracking().ToList();
  299:                 }
  300:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.Mgw>();
  301:             }
  302:  
  303:             return list.Distinct().ToList();
  304:         }
  305:  
  306:         ////////////////////////////////////////////////////////////////////////////
  307:  
  308:         /// <summary>
  309:         /// 
  310:         /// </summary>
  311:         public static List<Ia.Ftn.Cl.Models.Huawei.Asbr> AsbrList(List<string> asbrIdList)
  312:         {
  313:             List<Ia.Ftn.Cl.Models.Huawei.Asbr> list;
  314:  
  315:             using (var db = new Ia.Ftn.Cl.Db())
  316:             {
  317:                 if (asbrIdList.Count > 0)
  318:                 {
  319:                     list = (from a in db.Asbrs
  320:                             where asbrIdList.Contains(a.Id)
  321:                             select a).AsNoTracking().ToList();
  322:                 }
  323:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.Asbr>();
  324:             }
  325:  
  326:             return list.Distinct().ToList();
  327:         }
  328:  
  329:         ////////////////////////////////////////////////////////////////////////////
  330:  
  331:         /// <summary>
  332:         /// 
  333:         /// </summary>
  334:         public static List<Ia.Ftn.Cl.Models.Huawei.EmsDev> EmsDevList(List<int> emsDevIdList)
  335:         {
  336:             List<Ia.Ftn.Cl.Models.Huawei.EmsDev> list;
  337:  
  338:             using (var db = new Ia.Ftn.Cl.Db())
  339:             {
  340:                 if (emsDevIdList.Count > 0)
  341:                 {
  342:                     list = (from ed in db.EmsDevs
  343:                             where emsDevIdList.Contains(ed.Id)
  344:                             select ed).AsNoTracking().ToList();
  345:                 }
  346:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.EmsDev>();
  347:             }
  348:  
  349:             return list.Distinct().ToList();
  350:         }
  351:  
  352:         ////////////////////////////////////////////////////////////////////////////
  353:  
  354:         /// <summary>
  355:         /// 
  356:         /// </summary>
  357:         public static List<Ia.Ftn.Cl.Models.Huawei.EmsDev> EmsDevListFromEmsOntIdList(List<string> emsOntIdList)
  358:         {
  359:             List<Ia.Ftn.Cl.Models.Huawei.EmsDev> list;
  360:  
  361:             using (var db = new Ia.Ftn.Cl.Db())
  362:             {
  363:                 if (emsOntIdList.Count > 0)
  364:                 {
  365:                     list = (from ed in db.EmsDevs
  366:                             join eb in db.EmsBoards on ed.Id equals eb.EmsDev.Id
  367:                             join ep in db.EmsPorts on eb.Id equals ep.EmsBoard.Id
  368:                             join eo in db.EmsOnts on ep.Id equals eo.EmsPort.Id
  369:                             where emsOntIdList.Contains(eo.Id)
  370:                             select ed).AsNoTracking().ToList();
  371:                 }
  372:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.EmsDev>();
  373:             }
  374:  
  375:             return list.Distinct().ToList();
  376:         }
  377:  
  378:         ////////////////////////////////////////////////////////////////////////////
  379:  
  380:         /// <summary>
  381:         /// 
  382:         /// </summary>
  383:         public static List<Ia.Ftn.Cl.Models.Huawei.EmsBoard> EmsBoardList(List<string> emsBoardIdList)
  384:         {
  385:             List<Ia.Ftn.Cl.Models.Huawei.EmsBoard> list;
  386:  
  387:             using (var db = new Ia.Ftn.Cl.Db())
  388:             {
  389:                 if (emsBoardIdList.Count > 0)
  390:                 {
  391:                     list = (from eb in db.EmsBoards
  392:                             where emsBoardIdList.Contains(eb.Id)
  393:                             select eb).AsNoTracking().ToList();
  394:                 }
  395:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.EmsBoard>();
  396:             }
  397:  
  398:             return list.Distinct().ToList();
  399:         }
  400:  
  401:         ////////////////////////////////////////////////////////////////////////////
  402:  
  403:         /// <summary>
  404:         /// 
  405:         /// </summary>
  406:         public static List<Ia.Ftn.Cl.Models.Huawei.EmsBoard> EmsBoardListFromEmsOntIdList(List<string> emsOntIdList)
  407:         {
  408:             List<Ia.Ftn.Cl.Models.Huawei.EmsBoard> list;
  409:  
  410:             using (var db = new Ia.Ftn.Cl.Db())
  411:             {
  412:                 if (emsOntIdList.Count > 0)
  413:                 {
  414:                     list = (from eb in db.EmsBoards
  415:                             join ep in db.EmsPorts on eb.Id equals ep.EmsBoard.Id
  416:                             join eo in db.EmsOnts on ep.Id equals eo.EmsPort.Id
  417:                             where emsOntIdList.Contains(eo.Id)
  418:                             select eb).AsNoTracking().ToList();
  419:                 }
  420:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.EmsBoard>();
  421:             }
  422:  
  423:             return list.Distinct().ToList();
  424:         }
  425:  
  426:         ////////////////////////////////////////////////////////////////////////////
  427:  
  428:         /// <summary>
  429:         /// 
  430:         /// </summary>
  431:         public static List<Ia.Ftn.Cl.Models.Huawei.EmsPort> EmsPortList(List<string> emsPortIdList)
  432:         {
  433:             List<Ia.Ftn.Cl.Models.Huawei.EmsPort> list;
  434:  
  435:             using (var db = new Ia.Ftn.Cl.Db())
  436:             {
  437:                 if (emsPortIdList.Count > 0)
  438:                 {
  439:                     list = (from ep in db.EmsPorts
  440:                             where emsPortIdList.Contains(ep.Id)
  441:                             select ep).AsNoTracking().ToList();
  442:                 }
  443:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.EmsPort>();
  444:             }
  445:  
  446:             return list.Distinct().ToList();
  447:         }
  448:  
  449:         ////////////////////////////////////////////////////////////////////////////
  450:  
  451:         /// <summary>
  452:         /// 
  453:         /// </summary>
  454:         public static List<Ia.Ftn.Cl.Models.Huawei.EmsPort> EmsPortListFromEmsOntIdList(List<string> emsOntIdList)
  455:         {
  456:             List<Ia.Ftn.Cl.Models.Huawei.EmsPort> list;
  457:  
  458:             using (var db = new Ia.Ftn.Cl.Db())
  459:             {
  460:                 if (emsOntIdList.Count > 0)
  461:                 {
  462:                     list = (from ep in db.EmsPorts
  463:                             join eo in db.EmsOnts on ep.Id equals eo.EmsPort.Id
  464:                             where emsOntIdList.Contains(eo.Id)
  465:                             select ep).AsNoTracking().ToList();
  466:                 }
  467:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.EmsPort>();
  468:             }
  469:  
  470:             return list.Distinct().ToList();
  471:         }
  472:  
  473:         ////////////////////////////////////////////////////////////////////////////
  474:  
  475:         /// <summary>
  476:         /// 
  477:         /// </summary>
  478:         public static List<Ia.Ftn.Cl.Models.Ui.Huawei.EmsOnt> EmsOntList(List<string> emsOntIdList)
  479:         {
  480:             List<Ia.Ftn.Cl.Models.Ui.Huawei.EmsOnt> list;
  481:  
  482:             using (var db = new Ia.Ftn.Cl.Db())
  483:             {
  484:                 if (emsOntIdList.Count > 0)
  485:                 {
  486:                     list = (from eo in db.EmsOnts
  487:                             where emsOntIdList.Contains(eo.Id)
  488:                             select new Ia.Ftn.Cl.Models.Ui.Huawei.EmsOnt()
  489:                             {
  490:                                 Id = eo.Id,
  491:                                 ResultCode = eo.ResultCode,
  492:                                 StateId = eo.StateId,
  493:                                 Access = eo.Access,
  494:                                 ALIAS = eo.ALIAS,
  495:                                 AUTH = eo.AUTH,
  496:                                 CAPABPROF = eo.CAPABPROF,
  497:                                 Created = eo.Created,
  498:                                 DEV = eo.DEV,
  499:                                 DID = eo.DID,
  500:                                 EQUIPMENTID = eo.EQUIPMENTID,
  501:                                 FN = eo.FN,
  502:                                 GATE = eo.GATE,
  503:                                 IP = eo.IP,
  504:                                 MAINSOFTVERSION = eo.MAINSOFTVERSION,
  505:                                 NAME = eo.NAME,
  506:                                 ONTID = eo.ONTID,
  507:                                 PN = eo.PN,
  508:                                 ROUTEIP = eo.ROUTEIP,
  509:                                 SERIALNUM = eo.SERIALNUM,
  510:                                 SN = eo.SN,
  511:                                 VAPROF = eo.VAPROF,
  512:                                 Updated = eo.Updated,
  513:                                 VENDORID = eo.VENDORID,
  514:                                 VLAN = eo.VLAN
  515:                             }).AsNoTracking().ToList();
  516:                 }
  517:                 else list = new List<Ia.Ftn.Cl.Models.Ui.Huawei.EmsOnt>();
  518:             }
  519:  
  520:             return list.Distinct().ToList();
  521:         }
  522:  
  523:         ////////////////////////////////////////////////////////////////////////////
  524:  
  525:         /// <summary>
  526:         /// 
  527:         /// </summary>
  528:         public static List<Ia.Ftn.Cl.Models.Huawei.EmsOntSipInfo> EmsOntSipInfoListFromEmsOntIdList(List<string> emsOntIdList)
  529:         {
  530:             List<Ia.Ftn.Cl.Models.Huawei.EmsOntSipInfo> list;
  531:  
  532:             using (var db = new Ia.Ftn.Cl.Db())
  533:             {
  534:                 if (emsOntIdList.Count > 0)
  535:                 {
  536:                     list = (from eosi in db.EmsOntSipInfoes
  537:                             where emsOntIdList.Contains(eosi.EmsOnt.Id)
  538:                             select eosi).Include(o => o.EmsOnt).AsNoTracking().ToList();
  539:                 }
  540:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.EmsOntSipInfo>();
  541:             }
  542:  
  543:             return list.Distinct().ToList();
  544:         }
  545:  
  546:         ////////////////////////////////////////////////////////////////////////////
  547:  
  548:         /// <summary>
  549:         /// 
  550:         /// </summary>
  551:         public static List<Ia.Ftn.Cl.Models.Huawei.EmsVoipPstnUser> EmsVoipPstnUserList(List<string> emsVoipPstnUserIdList)
  552:         {
  553:             List<Ia.Ftn.Cl.Models.Huawei.EmsVoipPstnUser> list;
  554:  
  555:             using (var db = new Ia.Ftn.Cl.Db())
  556:             {
  557:                 if (emsVoipPstnUserIdList.Count > 0)
  558:                 {
  559:                     list = (from evpu in db.EmsVoipPstnUsers
  560:                             where emsVoipPstnUserIdList.Contains(evpu.Id)
  561:                             select evpu).Include(o => o.EmsOnt).Include(o => o.EmsOnt.Access).AsNoTracking().ToList();
  562:                 }
  563:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.EmsVoipPstnUser>();
  564:             }
  565:  
  566:             return list.Distinct().ToList();
  567:         }
  568:  
  569:         ////////////////////////////////////////////////////////////////////////////
  570:  
  571:         /// <summary>
  572:         /// 
  573:         /// </summary>
  574:         public static List<string> EmsVoipPstnUserIdListFromEmsOntIdList(List<string> emsOntIdList)
  575:         {
  576:             List<string> list;
  577:  
  578:             using (var db = new Ia.Ftn.Cl.Db())
  579:             {
  580:                 if (emsOntIdList.Count > 0)
  581:                 {
  582:                     list = (from evpu in db.EmsVoipPstnUsers
  583:                             where evpu.EmsOnt != null && emsOntIdList.Contains(evpu.EmsOnt.Id)
  584:                             select evpu.Id).AsNoTracking().ToList();
  585:                 }
  586:                 else list = new List<string>();
  587:             }
  588:  
  589:             return list.Distinct().ToList();
  590:         }
  591:  
  592:         ////////////////////////////////////////////////////////////////////////////
  593:  
  594:         /// <summary>
  595:         /// 
  596:         /// </summary>
  597:         public static List<string> EmsVoipPstnUserIdListFromServiceList(List<string> serviceList)
  598:         {
  599:             List<string> serviceWithCountryCodeList, impuAidList;
  600:             List<string> list;
  601:  
  602:             // for MDUs numbers will look like 96524805054
  603:             // for MSAN numbers will look like +96524805054
  604:  
  605:             if (serviceList.Count > 0)
  606:             {
  607:                 serviceWithCountryCodeList = new List<string>();
  608:                 impuAidList = new List<string>();
  609:  
  610:                 foreach (string service in serviceList)
  611:                 {
  612:                     serviceWithCountryCodeList.Add(Ia.Ftn.Cl.Models.Business.NumberFormatConverter.ServiceWithCountryCode(service));
  613:                     impuAidList.Add(Ia.Ftn.Cl.Models.Business.NumberFormatConverter.ImpuAid(service));
  614:                 }
  615:  
  616:                 using (var db = new Ia.Ftn.Cl.Db())
  617:                 {
  618:                     list = (from evpu in db.EmsVoipPstnUsers
  619:                             where serviceWithCountryCodeList.Contains(evpu.DN) || impuAidList.Contains(evpu.DN)
  620:                             select evpu.Id).AsNoTracking().ToList();
  621:                 }
  622:             }
  623:             else list = new List<string>();
  624:  
  625:             return list.Distinct().ToList();
  626:         }
  627:  
  628:         ////////////////////////////////////////////////////////////////////////////
  629:  
  630:         /// <summary>
  631:         /// 
  632:         /// </summary>
  633:         public static List<Ia.Ftn.Cl.Models.Huawei.EmsVoipPstnUser> EmsVoipPstnUserListFromEmsOntIdList(List<string> emsOntIdList)
  634:         {
  635:             List<Ia.Ftn.Cl.Models.Huawei.EmsVoipPstnUser> list;
  636:  
  637:             using (var db = new Ia.Ftn.Cl.Db())
  638:             {
  639:                 if (emsOntIdList.Count > 0)
  640:                 {
  641:                     list = (from evpu in db.EmsVoipPstnUsers
  642:                             where evpu.EmsOnt != null && emsOntIdList.Contains(evpu.EmsOnt.Id)
  643:                             select evpu).Include(o => o.EmsOnt).AsNoTracking().ToList();
  644:                 }
  645:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.EmsVoipPstnUser>();
  646:             }
  647:  
  648:             return list.Distinct().ToList();
  649:         }
  650:  
  651:         ////////////////////////////////////////////////////////////////////////////
  652:  
  653:         /// <summary>
  654:         /// 
  655:         /// </summary>
  656:         public static List<Ia.Ftn.Cl.Models.Huawei.EmsVag> VagListFromEmsOntIdList(List<string> emsOntIdList)
  657:         {
  658:             List<Ia.Ftn.Cl.Models.Huawei.EmsVag> list;
  659:  
  660:             using (var db = new Ia.Ftn.Cl.Db())
  661:             {
  662:                 if (emsOntIdList.Count > 0)
  663:                 {
  664:                     list = (from v in db.EmsVags
  665:                             where emsOntIdList.Contains(v.EmsOnt.Id)
  666:                             select v).Include(o => o.EmsOnt).AsNoTracking().ToList();
  667:                 }
  668:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.EmsVag>();
  669:             }
  670:  
  671:             return list.Distinct().ToList();
  672:         }
  673:  
  674:         ////////////////////////////////////////////////////////////////////////////
  675:  
  676:         /// <summary>
  677:         /// 
  678:         /// </summary>
  679:         public static List<Ia.Ftn.Cl.Models.Huawei.EmsVoipPstnUser> EmsVoipPstnUserListFromEmsOntIdListAndServiceList(List<string> emsOntIdList, List<string> serviceList)
  680:         {
  681:             string serviceWithCountryCode;
  682:             List<string> emsVoipPstnUserDnList;
  683:             List<Ia.Ftn.Cl.Models.Huawei.EmsVoipPstnUser> list;
  684:  
  685:             if (emsOntIdList.Count > 0 && serviceList.Count > 0)
  686:             {
  687:                 emsVoipPstnUserDnList = new List<string>();
  688:  
  689:                 foreach (var service in serviceList)
  690:                 {
  691:                     serviceWithCountryCode = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.ServiceWithCountryCode(service);
  692:                     emsVoipPstnUserDnList.Add(serviceWithCountryCode);
  693:                 }
  694:  
  695:                 using (var db = new Ia.Ftn.Cl.Db())
  696:                 {
  697:                     list = (from evpu in db.EmsVoipPstnUsers
  698:                             where evpu.EmsOnt != null && emsOntIdList.Contains(evpu.EmsOnt.Id) && emsVoipPstnUserDnList.Contains(evpu.DN)
  699:                             select evpu).Include(o => o.EmsOnt).AsNoTracking().ToList();
  700:                 }
  701:             }
  702:             else list = new List<Ia.Ftn.Cl.Models.Huawei.EmsVoipPstnUser>();
  703:  
  704:             return list.Distinct().ToList();
  705:         }
  706:  
  707:         ////////////////////////////////////////////////////////////////////////////
  708:  
  709:         /// <summary>
  710:         /// 
  711:         /// </summary>
  712:         public static List<Ia.Ftn.Cl.Models.Huawei.EmsOntSipInfo> EmsOntSipInfoListFromEmsOntIdListAndService(List<string> emsOntIdList, List<string> sipUserNameList)
  713:         {
  714:             List<Ia.Ftn.Cl.Models.Huawei.EmsOntSipInfo> list;
  715:  
  716:             using (var db = new Ia.Ftn.Cl.Db())
  717:             {
  718:                 if (emsOntIdList.Count > 0 && sipUserNameList.Count > 0)
  719:                 {
  720:                     list = (from eosi in db.EmsOntSipInfoes
  721:                             where emsOntIdList.Contains(eosi.EmsOnt.Id) && sipUserNameList.Contains(eosi.SIPUSERNAME)
  722:                             select eosi).Include(o => o.EmsOnt).Include(o => o.EmsOnt.Access).AsNoTracking().ToList();
  723:                 }
  724:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.EmsOntSipInfo>();
  725:             }
  726:  
  727:             return list.Distinct().ToList();
  728:         }
  729:  
  730:         ////////////////////////////////////////////////////////////////////////////
  731:  
  732:         /// <summary>
  733:         /// 
  734:         /// </summary>
  735:         public static List<Ia.Ftn.Cl.Models.ServiceRequestOnt> ServiceRequestOntList(List<string> serviceRequestOntIdList)
  736:         {
  737:             List<Ia.Ftn.Cl.Models.ServiceRequestOnt> list;
  738:  
  739:             using (var db = new Ia.Ftn.Cl.Db())
  740:             {
  741:                 if (serviceRequestOntIdList.Count > 0)
  742:                 {
  743:                     list = (from sro in db.ServiceRequestOnts
  744:                             where serviceRequestOntIdList.Contains(sro.Id)
  745:                             select sro).AsNoTracking().ToList();
  746:                 }
  747:                 else list = new List<Ia.Ftn.Cl.Models.ServiceRequestOnt>();
  748:             }
  749:  
  750:             return list.Distinct().ToList();
  751:         }
  752:  
  753:         ////////////////////////////////////////////////////////////////////////////
  754:  
  755:         /// <summary>
  756:         /// 
  757:         /// </summary>
  758:         public static List<Ia.Ftn.Cl.Models.ServiceRequestOntDetail> ServiceRequestOntDetailList(List<string> serviceRequestOntIdList)
  759:         {
  760:             List<Ia.Ftn.Cl.Models.ServiceRequestOntDetail> list;
  761:  
  762:             using (var db = new Ia.Ftn.Cl.Db())
  763:             {
  764:                 if (serviceRequestOntIdList.Count > 0)
  765:                 {
  766:                     list = (from srod in db.ServiceRequestOntDetails
  767:                             where serviceRequestOntIdList.Contains(srod.ServiceRequestOnt.Id)
  768:                             select srod).AsNoTracking().ToList();
  769:                 }
  770:                 else list = new List<Ia.Ftn.Cl.Models.ServiceRequestOntDetail>();
  771:             }
  772:  
  773:             return list.Distinct().ToList();
  774:         }
  775:  
  776:         ////////////////////////////////////////////////////////////////////////////
  777:  
  778:         /// <summary>
  779:         /// 
  780:         /// </summary>
  781:         public static List<Ia.Ftn.Cl.Models.ServiceRequestOntDetail> ServiceRequestOntDetailFromServieListList(List<string> serviceList)
  782:         {
  783:             List<Ia.Ftn.Cl.Models.ServiceRequestOntDetail> list;
  784:  
  785:             using (var db = new Ia.Ftn.Cl.Db())
  786:             {
  787:                 if (serviceList.Count > 0)
  788:                 {
  789:                     list = (from srod in db.ServiceRequestOntDetails
  790:                             where serviceList.Contains(srod.Service)
  791:                             select srod).AsNoTracking().ToList();
  792:                 }
  793:                 else list = new List<Ia.Ftn.Cl.Models.ServiceRequestOntDetail>();
  794:             }
  795:  
  796:             return list.Distinct().ToList();
  797:         }
  798:  
  799:         ////////////////////////////////////////////////////////////////////////////
  800:  
  801:         /// <summary>
  802:         /// 
  803:         /// </summary>
  804:         public static List<Ia.Ftn.Cl.Models.Business.NetworkDesignDocument.Ont> NddOntList(List<string> nddOntIdList)
  805:         {
  806:             List<Ia.Ftn.Cl.Models.Business.NetworkDesignDocument.Ont> list;
  807:  
  808:             if (nddOntIdList.Count > 0)
  809:             {
  810:                 list = (from o in Ia.Ftn.Cl.Models.Data.NetworkDesignDocument.OntList
  811:                         where nddOntIdList.Contains(o.Id)
  812:                         select o).ToList();
  813:             }
  814:             else list = new List<Ia.Ftn.Cl.Models.Business.NetworkDesignDocument.Ont>();
  815:  
  816:             return list.Distinct().ToList();
  817:         }
  818:  
  819:         ////////////////////////////////////////////////////////////////////////////
  820:  
  821:         /// <summary>
  822:         /// 
  823:         /// </summary>
  824:         public static List<Ia.Ftn.Cl.Models.Access> AccessList(List<string> accessIdList)
  825:         {
  826:             List<Ia.Ftn.Cl.Models.Access> list;
  827:  
  828:             using (var db = new Ia.Ftn.Cl.Db())
  829:             {
  830:                 if (accessIdList.Count > 0)
  831:                 {
  832:                     list = (from a in db.Accesses
  833:                             where accessIdList.Contains(a.Id)
  834:                             select a).AsNoTracking().ToList();
  835:                 }
  836:                 else list = new List<Ia.Ftn.Cl.Models.Access>();
  837:             }
  838:  
  839:             return list.Distinct().ToList();
  840:         }
  841:  
  842:         ////////////////////////////////////////////////////////////////////////////
  843:  
  844:         /// <summary>
  845:         /// 
  846:         /// </summary>
  847:         public static List<Ia.Ftn.Cl.Models.Access> AccessListFromAddress(int kuwaitFtnAreaId, string block, int street, int premisesOld, int premisesNew)
  848:         {
  849:             string streetString, premisesOldString, premisesNewString;
  850:             List<Ia.Ftn.Cl.Models.Access> list;
  851:  
  852:             using (var db = new Ia.Ftn.Cl.Db())
  853:             {
  854:                 streetString = street.ToString();
  855:                 premisesOldString = premisesOld.ToString();
  856:                 premisesNewString = premisesNew.ToString();
  857:  
  858:                 list = (from a in db.Accesses
  859:                         where
  860:                         a.AreaId == kuwaitFtnAreaId
  861:                         &&
  862:                         (
  863:                         a.Block == block && a.Street == streetString && a.PremisesOld == premisesOldString && a.PremisesNew == premisesNewString
  864:                         || a.Block == block && a.Street == streetString && a.PremisesOld == premisesOldString && premisesNew == 0
  865:                         || a.Block == block && a.Street == streetString && a.PremisesNew == premisesNewString && premisesOld == 0
  866:                         || a.Block == block && a.PremisesOld == premisesOldString && a.PremisesNew == premisesNewString && street == 0
  867:                         || a.Block == block && a.PremisesOld == premisesOldString && street == 0 && premisesNew == 0
  868:                         || a.Block == block && a.PremisesNew == premisesNewString && street == 0 && premisesOld == 0
  869:                         || a.Block == block && a.Street == streetString && premisesOld == 0 && premisesNew == 0
  870:                         || a.Block == block && street == 0 && premisesOld == 0 && premisesNew == 0
  871:                         || block == string.Empty && street == 0 && premisesOld == 0 && premisesNew == 0
  872:                         )
  873:                         select a).AsNoTracking().ToList();
  874:             }
  875:  
  876:             return list.Distinct().ToList();
  877:         }
  878:  
  879:         ////////////////////////////////////////////////////////////////////////////
  880:  
  881:         /// <summary>
  882:         /// 
  883:         /// </summary>
  884:         public static List<Ia.Ftn.Cl.Models.Access> AccessListFromAreaAndBlock(int kuwaitFtnAreaId, string block)
  885:         {
  886:             List<Ia.Ftn.Cl.Models.Access> list;
  887:  
  888:             using (var db = new Ia.Ftn.Cl.Db())
  889:             {
  890:                 list = (from a in db.Accesses
  891:                         where a.AreaId == kuwaitFtnAreaId && a.Block == block
  892:                         select a).AsNoTracking().ToList();
  893:             }
  894:  
  895:             return list.Distinct().ToList();
  896:         }
  897:  
  898:         ////////////////////////////////////////////////////////////////////////////
  899:  
  900:         /// <summary>
  901:         /// 
  902:         /// </summary>
  903:         public static List<string> AccessIdListFromPaci(int paci)
  904:         {
  905:             List<string> list;
  906:  
  907:             using (var db = new Ia.Ftn.Cl.Db())
  908:             {
  909:                 if (paci > 0)
  910:                 {
  911:                     list = (from a in db.Accesses
  912:                             where a.Paci == paci.ToString()
  913:                             select a.Id).AsNoTracking().ToList();
  914:                 }
  915:                 else list = new List<string>();
  916:             }
  917:  
  918:             return list.ToList();
  919:         }
  920:  
  921:         ////////////////////////////////////////////////////////////////////////////
  922:  
  923:         /// <summary>
  924:         /// 
  925:         /// </summary>
  926:         public static List<Ia.Ftn.Cl.Models.Ont> OntList(List<string> ontIdList)
  927:         {
  928:             List<Ia.Ftn.Cl.Models.Ont> list;
  929:  
  930:             using (var db = new Ia.Ftn.Cl.Db())
  931:             {
  932:                 if (ontIdList.Count > 0)
  933:                 {
  934:                     list = (from o in db.Onts
  935:                             where ontIdList.Contains(o.Id)
  936:                             select o).AsNoTracking().ToList();
  937:                 }
  938:                 else list = new List<Ia.Ftn.Cl.Models.Ont>();
  939:             }
  940:  
  941:             return list.Distinct().ToList();
  942:         }
  943:  
  944:         ////////////////////////////////////////////////////////////////////////////
  945:  
  946:         /// <summary>
  947:         /// 
  948:         /// </summary>
  949:         public static List<Ia.Ftn.Cl.Models.OntOntPots> OntOntPotsListFromOntOntPotsIdList(List<string> ontOntPotsIdList)
  950:         {
  951:             List<Ia.Ftn.Cl.Models.OntOntPots> list;
  952:  
  953:             using (var db = new Ia.Ftn.Cl.Db())
  954:             {
  955:                 if (ontOntPotsIdList.Count > 0)
  956:                 {
  957:                     list = (from oop in db.OntOntPots
  958:                             where ontOntPotsIdList.Contains(oop.Id)
  959:                             select oop).AsNoTracking().ToList();
  960:                 }
  961:                 else list = new List<Ia.Ftn.Cl.Models.OntOntPots>();
  962:             }
  963:  
  964:             return list.Distinct().ToList();
  965:         }
  966:  
  967:         ////////////////////////////////////////////////////////////////////////////
  968:  
  969:         /// <summary>
  970:         /// 
  971:         /// </summary>
  972:         public static List<Ia.Ftn.Cl.Models.Event> EventList(List<long> eventIdList)
  973:         {
  974:             List<Ia.Ftn.Cl.Models.Event> list;
  975:  
  976:             using (var db = new Ia.Ftn.Cl.Db())
  977:             {
  978:                 if (eventIdList.Count > 0)
  979:                 {
  980:                     list = (from e in db.Events
  981:                             where eventIdList.Contains(e.Id)
  982:                             select e).AsNoTracking().ToList();
  983:                 }
  984:                 else list = new List<Ia.Ftn.Cl.Models.Event>();
  985:             }
  986:  
  987:             return list.Distinct().ToList();
  988:         }
  989:  
  990:         ////////////////////////////////////////////////////////////////////////////
  991:  
  992:         /// <summary>
  993:         /// 
  994:         /// </summary>
  995:         public static List<Ia.Ftn.Cl.Models.Ui.Nokia.SubParty> SubPartyList(List<string> subPartyIdList)
  996:         {
  997:             List<Ia.Ftn.Cl.Models.Ui.Nokia.SubParty> list;
  998:  
  999:             using (var db = new Ia.Ftn.Cl.Db())
 1000:             {
 1001:                 if (subPartyIdList.Count > 0)
 1002:                 {
 1003:                     list = (from sp in db.SubParties
 1004:                             where subPartyIdList.Contains(sp.Id)
 1005:                             select new Ia.Ftn.Cl.Models.Ui.Nokia.SubParty()
 1006:                             {
 1007:                                 Id = sp.Id,
 1008:                                 PartyId = sp.PartyId,
 1009:                                 PrimaryPUIDCPEProfileNumber = sp.PrimaryPUIDCPEProfileNumber,
 1010:                                 DisplayName = sp.DisplayName,
 1011:                                 Category = sp.Category,
 1012:                                 AssocOtasRealm = sp.AssocOtasRealm,
 1013:                                 ServiceSuspension = sp.ServiceSuspension,
 1014:                                 Created = sp.Created,
 1015:                                 Updated = sp.Updated
 1016:                             }).AsNoTracking().ToList();
 1017:                 }
 1018:                 else list = new List<Ia.Ftn.Cl.Models.Ui.Nokia.SubParty>();
 1019:             }
 1020:  
 1021:             return list.Distinct().ToList();
 1022:         }
 1023:  
 1024:         ////////////////////////////////////////////////////////////////////////////
 1025:  
 1026:         /// <summary>
 1027:         /// 
 1028:         /// </summary>
 1029:         public static List<Ia.Ftn.Cl.Models.Report> ReportList(List<int> reportIdList)
 1030:         {
 1031:             List<Ia.Ftn.Cl.Models.Report> list;
 1032:  
 1033:             using (var db = new Ia.Ftn.Cl.Db())
 1034:             {
 1035:                 if (reportIdList.Count > 0)
 1036:                 {
 1037:                     list = (from r in db.Reports
 1038:                             where reportIdList.Contains(r.Id)
 1039:                             select r).Include(u => u.StaffIdentityUser).Include(u => u.ReportHistories).ThenInclude(u => u.StaffIdentityUser).AsNoTracking().ToList();
 1040:                 }
 1041:                 else list = new List<Ia.Ftn.Cl.Models.Report>();
 1042:             }
 1043:  
 1044:             return list.Distinct().ToList();
 1045:         }
 1046:  
 1047:         ////////////////////////////////////////////////////////////////////////////
 1048:  
 1049:         /// <summary>
 1050:         /// 
 1051:         /// </summary>
 1052:         public static List<Ia.Ftn.Cl.Models.Ui.Huawei.Sbr> SbrList(List<string> sbrImpuList)
 1053:         {
 1054:             List<Ia.Ftn.Cl.Models.Ui.Huawei.Sbr> list;
 1055:  
 1056:             using (var db = new Ia.Ftn.Cl.Db())
 1057:             {
 1058:                 if (sbrImpuList.Count > 0)
 1059:                 {
 1060:                     list = (from h in db.Sbrs
 1061:                             where sbrImpuList.Contains(h.IMPU)
 1062:                             select new Ia.Ftn.Cl.Models.Ui.Huawei.Sbr()
 1063:                             {
 1064:                                 COP = h.COP,
 1065:                                 CSC = h.CSC,
 1066:                                 Id = h.Id,
 1067:                                 IMPU = h.IMPU,
 1068:                                 ITT = h.ITT,
 1069:                                 LP = h.LP,
 1070:                                 NS3PTY = h.NS3PTY,
 1071:                                 NSABRC = h.NSABRC,
 1072:                                 NSCBA = h.NSCBA,
 1073:                                 NSCFU = h.NSCFU,
 1074:                                 NSCLIP = h.NSCLIP,
 1075:                                 NSCW = h.NSCW,
 1076:                                 NSFAX = h.NSFAX,
 1077:                                 NSHOLD = h.NSHOLD,
 1078:                                 NSNPTY = h.NSNPTY,
 1079:                                 NSWAKE_UP = h.NSWAKE_UP,
 1080:                                 Created = h.Created,
 1081:                                 Updated = h.Updated
 1082:                             }).AsNoTracking().ToList();
 1083:                 }
 1084:                 else list = new List<Ia.Ftn.Cl.Models.Ui.Huawei.Sbr>();
 1085:             }
 1086:  
 1087:             return list.Distinct().ToList();
 1088:         }
 1089:  
 1090:         ////////////////////////////////////////////////////////////////////////////
 1091:  
 1092:         /// <summary>
 1093:         /// 
 1094:         /// </summary>
 1095:         public static List<Ia.Ftn.Cl.Models.Huawei.Owsbr> OwsbrList(List<string> owsbrImpuList)
 1096:         {
 1097:             List<Ia.Ftn.Cl.Models.Huawei.Owsbr> list;
 1098:  
 1099:             using (var db = new Ia.Ftn.Cl.Db())
 1100:             {
 1101:                 if (owsbrImpuList.Count > 0)
 1102:                 {
 1103:                     list = (from o in db.Owsbrs
 1104:                             where owsbrImpuList.Contains(o.IMPU)
 1105:                             select o).AsNoTracking().ToList();
 1106:                 }
 1107:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.Owsbr>();
 1108:             }
 1109:  
 1110:             return list.Distinct().ToList();
 1111:         }
 1112:  
 1113:         ////////////////////////////////////////////////////////////////////////////
 1114:  
 1115:         /// <summary>
 1116:         /// 
 1117:         /// </summary>
 1118:         public static List<Ia.Ftn.Cl.Models.Huawei.Seruattr> SeruattrListFromServiceIdList(List<string> serviceIdList)
 1119:         {
 1120:             List<Ia.Ftn.Cl.Models.Huawei.Seruattr> list;
 1121:  
 1122:             using (var db = new Ia.Ftn.Cl.Db())
 1123:             {
 1124:                 if (serviceIdList.Count > 0)
 1125:                 {
 1126:                     list = (from s in db.Seruattrs
 1127:                             where serviceIdList.Contains(s.Id)
 1128:                             select s).AsNoTracking().ToList();
 1129:                 }
 1130:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.Seruattr>();
 1131:             }
 1132:  
 1133:             return list.Distinct().ToList();
 1134:         }
 1135:  
 1136:         ////////////////////////////////////////////////////////////////////////////
 1137:  
 1138:         /// <summary>
 1139:         /// 
 1140:         /// </summary>
 1141:         public static List<Ia.Ftn.Cl.Models.Huawei.Seruattr> SeruattrList(List<string> serviceList)
 1142:         {
 1143:             List<Ia.Ftn.Cl.Models.Huawei.Seruattr> list;
 1144:  
 1145:             using (var db = new Ia.Ftn.Cl.Db())
 1146:             {
 1147:                 if (serviceList.Count > 0)
 1148:                 {
 1149:                     list = (from s in db.Seruattrs
 1150:                             where serviceList.Contains(s.USRNUM)
 1151:                             select s).AsNoTracking().ToList();
 1152:                 }
 1153:                 else list = new List<Ia.Ftn.Cl.Models.Huawei.Seruattr>();
 1154:             }
 1155:  
 1156:             return list.Distinct().ToList();
 1157:         }
 1158:  
 1159:         ////////////////////////////////////////////////////////////////////////////
 1160:  
 1161:         /// <summary>
 1162:         /// 
 1163:         /// </summary>
 1164:         public static List<Ia.Ftn.Cl.Models.Ericsson.AxeSubscriber> AxeSubscriberListFromServiceIdList(List<string> serviceIdList)
 1165:         {
 1166:             List<Ia.Ftn.Cl.Models.Ericsson.AxeSubscriber> list;
 1167:  
 1168:             using (var db = new Ia.Ftn.Cl.Db())
 1169:             {
 1170:                 if (serviceIdList.Count > 0)
 1171:                 {
 1172:                     list = (from s in db.AxeSubscribers
 1173:                             where serviceIdList.Contains(s.Id)
 1174:                             select s).AsNoTracking().ToList();
 1175:                 }
 1176:                 else list = new List<Ia.Ftn.Cl.Models.Ericsson.AxeSubscriber>();
 1177:             }
 1178:  
 1179:             return list.Distinct().ToList();
 1180:         }
 1181:  
 1182:         ////////////////////////////////////////////////////////////////////////////
 1183:  
 1184:         /// <summary>
 1185:         /// 
 1186:         /// </summary>
 1187:         public static List<Ia.Ftn.Cl.Models.Ericsson.AxeSubscriber> AxeSubscriberList(List<int> numberList)
 1188:         {
 1189:             List<Ia.Ftn.Cl.Models.Ericsson.AxeSubscriber> list;
 1190:  
 1191:             using (var db = new Ia.Ftn.Cl.Db())
 1192:             {
 1193:                 if (numberList.Count > 0)
 1194:                 {
 1195:                     list = (from s in db.AxeSubscribers
 1196:                             where numberList.Contains(s.SNB)
 1197:                             select s).AsNoTracking().ToList();
 1198:                 }
 1199:                 else list = new List<Ia.Ftn.Cl.Models.Ericsson.AxeSubscriber>();
 1200:             }
 1201:  
 1202:             return list.Distinct().ToList();
 1203:         }
 1204:  
 1205:         ////////////////////////////////////////////////////////////////////////////
 1206:  
 1207:         /// <summary>
 1208:         /// 
 1209:         /// </summary>
 1210:         public static List<Ia.Ftn.Cl.Models.Siemens.EwsdSubscriber> EwsdSubscriberListFromServiceIdList(List<string> serviceIdList)
 1211:         {
 1212:             List<Ia.Ftn.Cl.Models.Siemens.EwsdSubscriber> list;
 1213:  
 1214:             using (var db = new Ia.Ftn.Cl.Db())
 1215:             {
 1216:                 if (serviceIdList.Count > 0)
 1217:                 {
 1218:                     list = (from s in db.EwsdSubscribers
 1219:                             where serviceIdList.Contains(s.Id)
 1220:                             select s).AsNoTracking().ToList();
 1221:                 }
 1222:                 else list = new List<Ia.Ftn.Cl.Models.Siemens.EwsdSubscriber>();
 1223:             }
 1224:  
 1225:             return list.Distinct().ToList();
 1226:         }
 1227:  
 1228:         ////////////////////////////////////////////////////////////////////////////
 1229:  
 1230:         /// <summary>
 1231:         /// 
 1232:         /// </summary>
 1233:         public static List<Ia.Ftn.Cl.Models.Siemens.EwsdSubscriber> EwsdSubscriberList(List<int> numberList)
 1234:         {
 1235:             List<Ia.Ftn.Cl.Models.Siemens.EwsdSubscriber> list;
 1236:  
 1237:             using (var db = new Ia.Ftn.Cl.Db())
 1238:             {
 1239:                 if (numberList.Count > 0)
 1240:                 {
 1241:                     // this procedure was not used but might be slow. try to read using id
 1242:                     //var id = Ia.Ftn.Cl.Model.Business.Siemens.Subscriber.SubscriberId(23616858);
 1243:                     //var subscriber = (from es in db.EwsdSubscribers where es.Id == id select es.DN).SingleOrDefault();
 1244:  
 1245:                     list = (from s in db.EwsdSubscribers
 1246:                             where numberList.Contains(s.DN)
 1247:                             select s).AsNoTracking().ToList();
 1248:                 }
 1249:                 else list = new List<Ia.Ftn.Cl.Models.Siemens.EwsdSubscriber>();
 1250:             }
 1251:  
 1252:             return list.Distinct().ToList();
 1253:         }
 1254:  
 1255:         ////////////////////////////////////////////////////////////////////////////
 1256:  
 1257:         /// <summary>
 1258:         /// 
 1259:         /// </summary>
 1260:         public static List<Ia.Ftn.Cl.Models.OntServiceVoip> OntServiceVoipList(List<string> ontServiceVoipIdList)
 1261:         {
 1262:             List<Ia.Ftn.Cl.Models.OntServiceVoip> list;
 1263:  
 1264:             using (var db = new Ia.Ftn.Cl.Db())
 1265:             {
 1266:                 if (ontServiceVoipIdList.Count > 0)
 1267:                 {
 1268:                     list = (from ov in db.OntServiceVoips
 1269:                             where ontServiceVoipIdList.Contains(ov.Id)
 1270:                             select ov).AsNoTracking().ToList();
 1271:                 }
 1272:                 else list = new List<Ia.Ftn.Cl.Models.OntServiceVoip>();
 1273:             }
 1274:  
 1275:             return list.Distinct().ToList();
 1276:         }
 1277:  
 1278:         ////////////////////////////////////////////////////////////////////////////
 1279:  
 1280:         /// <summary>
 1281:         /// 
 1282:         /// </summary>
 1283:         public static List<Ia.Ftn.Cl.Models.Ui.Service2> ServiceList(List<string> serviceIdList)
 1284:         {
 1285:             List<Ia.Ftn.Cl.Models.Service2> list0;
 1286:             List<Ia.Ftn.Cl.Models.Ui.Service2> list;
 1287:  
 1288:             using (var db = new Ia.Ftn.Cl.Db())
 1289:             {
 1290:                 if (serviceIdList.Count > 0)
 1291:                 {
 1292:                     list0 = (from s in db.Service2 where serviceIdList.Contains(s.Id) select s).Include(u => u.Access).AsNoTracking().ToList();
 1293:  
 1294:                     list = (from s in list0
 1295:                             select new Ia.Ftn.Cl.Models.Ui.Service2()
 1296:                             {
 1297:                                 Id = s.Id,
 1298:                                 AbbriviatedCalling = s.AbbriviatedCalling,
 1299:                                 AlarmCall = s.AlarmCall,
 1300:                                 CallBarring = s.CallBarring,
 1301:                                 CallerId = s.CallerId,
 1302:                                 CallForwarding = s.CallForwarding,
 1303:                                 CallWaiting = s.CallWaiting,
 1304:                                 ConferenceCall = s.ConferenceCall,
 1305:                                 Created = s.Created,
 1306:                                 InternationalCalling = s.InternationalCalling,
 1307:                                 InternationalCallingUserControlled = s.InternationalCallingUserControlled,
 1308:                                 Port = s.Port,
 1309:                                 Pin = s.Pin,
 1310:                                 Service = s.Service,
 1311:                                 ServiceType = s.ServiceType,
 1312:                                 ServiceSuspension = s.ServiceSuspension,
 1313:                                 ServiceTypeName = s.ServiceType.ToString(),
 1314:                                 Updated = s.Updated,
 1315:                                 AccessId = (s.Access != null) ? s.Access.Id : string.Empty
 1316:                             }).ToList();
 1317:                 }
 1318:                 else list = new List<Ia.Ftn.Cl.Models.Ui.Service2>();
 1319:             }
 1320:  
 1321:             return list.Distinct().ToList();
 1322:         }
 1323:  
 1324:         ////////////////////////////////////////////////////////////////////////////
 1325:  
 1326:         /// <summary>
 1327:         /// 
 1328:         /// </summary>
 1329:         public static List<Ia.Ftn.Cl.Models.Ui.Nokia.Subscriber> SubscriberList(List<string> subscriberIdList)
 1330:         {
 1331:             List<Ia.Ftn.Cl.Models.Ui.Nokia.Subscriber> list;
 1332:  
 1333:             // below: db.Subscribers contains XML fields which can not be evaluated in a Union() function.
 1334:  
 1335:             using (var db = new Ia.Ftn.Cl.Db())
 1336:             {
 1337:                 if (subscriberIdList.Count > 0)
 1338:                 {
 1339:                     list = (from s in db.Subscribers
 1340:                             where subscriberIdList.Contains(s.Id)
 1341:                             select s).AsEnumerable().Select(s => new Ia.Ftn.Cl.Models.Ui.Nokia.Subscriber()
 1342:                             {
 1343:                                 Id = s.Id,
 1344:                                 AlternateOtasRealm = s.AlternateOtasRealm,
 1345:                                 PartyId = s.PartyId,
 1346:                                 AbbriviatedCalling = Ia.Ftn.Cl.Models.Business.Nokia.Subscriber.OneDigitSpeedDialIsAssigned(s._OneDigitSpeedDial),
 1347:                                 AlarmCall = Ia.Ftn.Cl.Models.Business.Nokia.Subscriber.ReminderCallIsAssigned(s._ReminderCall),
 1348:                                 CallerId = Ia.Ftn.Cl.Models.Business.Nokia.Subscriber.CallingLineIdIsAssigned(s._CallingLineId),
 1349:                                 CallForwarding = Ia.Ftn.Cl.Models.Business.Nokia.Subscriber.CallForwardingIsAssigned(s._CallForwardingVari),
 1350:                                 CallWaiting = Ia.Ftn.Cl.Models.Business.Nokia.Subscriber.CallWaitingIsAssigned(s._CallWaiting, false),
 1351:                                 ConferenceCall = Ia.Ftn.Cl.Models.Business.Nokia.Subscriber.ConferenceCallIsAssigned(s._ConferenceCalling),
 1352:                                 InternationalCalling = Ia.Ftn.Cl.Models.Business.Nokia.Subscriber.InternationalCallingIsAssigned(s._CallBarring),
 1353:                                 InternationalCallingUserControlled = Ia.Ftn.Cl.Models.Business.Nokia.Subscriber.InternationalCallingUserControlledIsAssigned(s._OutgoingCallBarring),
 1354:                                 //ServiceSuspention = Ia.Ftn.Cl.Model.Business.Nokia.Subscriber.ServiceSuspentionIsAssigned(s._ServiceSuspention),
 1355:                                 Created = s.Created,
 1356:                                 Updated = s.Updated,
 1357:                             }).ToList();
 1358:                 }
 1359:                 else list = new List<Ia.Ftn.Cl.Models.Ui.Nokia.Subscriber>();
 1360:             }
 1361:  
 1362:             return list.Distinct().ToList();
 1363:         }
 1364:  
 1365:         ////////////////////////////////////////////////////////////////////////////
 1366:  
 1367:         /// <summary>
 1368:         /// 
 1369:         /// </summary>
 1370:         public static List<string> AccessIdList(int oltId, int ponNumber, int ontInternalNumber)
 1371:         {
 1372:             List<string> list;
 1373:  
 1374:             using (var db = new Ia.Ftn.Cl.Db())
 1375:             {
 1376:                 list = (from a in db.Accesses
 1377:                         where a.Olt == oltId && a.Pon == ponNumber && a.Ont == ontInternalNumber
 1378:                         select a.Id).AsNoTracking().ToList();
 1379:             }
 1380:  
 1381:             return list.Distinct().ToList();
 1382:         }
 1383:  
 1384:         ////////////////////////////////////////////////////////////////////////////
 1385:  
 1386:         /// <summary>
 1387:         /// 
 1388:         /// </summary>
 1389:         public static List<string> AccessIdList(int oltId, int ponNumber)
 1390:         {
 1391:             List<string> list;
 1392:  
 1393:             using (var db = new Ia.Ftn.Cl.Db())
 1394:             {
 1395:                 list = (from a in db.Accesses
 1396:                         where a.Olt == oltId && a.Pon == ponNumber
 1397:                         select a.Id).AsNoTracking().ToList();
 1398:             }
 1399:  
 1400:             return list.Distinct().ToList();
 1401:         }
 1402:  
 1403:         ////////////////////////////////////////////////////////////////////////////
 1404:  
 1405:         /// <summary>
 1406:         /// 
 1407:         /// </summary>
 1408:         public static List<int> EmsDevIdListFromEmsBoardIdList(List<string> emsBoardIdList)
 1409:         {
 1410:             List<int> list;
 1411:  
 1412:             using (var db = new Ia.Ftn.Cl.Db())
 1413:             {
 1414:                 if (emsBoardIdList.Count > 0)
 1415:                 {
 1416:                     list = (from ed in db.EmsDevs
 1417:                             join eb in db.EmsBoards on ed.Id equals eb.EmsDev.Id
 1418:                             where emsBoardIdList.Contains(eb.Id)
 1419:                             select ed.Id).ToList();
 1420:                 }
 1421:                 else list = new List<int>();
 1422:             }
 1423:  
 1424:             return list.Distinct().ToList();
 1425:         }
 1426:  
 1427:         ////////////////////////////////////////////////////////////////////////////
 1428:  
 1429:         /// <summary>
 1430:         /// 
 1431:         /// </summary>
 1432:         public static List<int> EmsDevIdListFromAccessIdList(List<string> accessIdList)
 1433:         {
 1434:             List<int> list;
 1435:  
 1436:             using (var db = new Ia.Ftn.Cl.Db())
 1437:             {
 1438:                 if (accessIdList.Count > 0)
 1439:                 {
 1440:                     list = (from ed in db.EmsDevs
 1441:                             where accessIdList.Contains(ed.Access.Id)
 1442:                             select ed.Id).ToList();
 1443:                 }
 1444:                 else list = new List<int>();
 1445:             }
 1446:  
 1447:             return list.Distinct().ToList();
 1448:         }
 1449:  
 1450:         ////////////////////////////////////////////////////////////////////////////
 1451:  
 1452:         /// <summary>
 1453:         /// 
 1454:         /// </summary>
 1455:         public static List<int> EmsDevIdListFromEmsVoipPstnUserIdList(List<string> emsVoipPstnUserIdList)
 1456:         {
 1457:             List<int> list;
 1458:  
 1459:             using (var db = new Ia.Ftn.Cl.Db())
 1460:             {
 1461:                 if (emsVoipPstnUserIdList.Count > 0)
 1462:                 {
 1463:                     list = (from ed in db.EmsDevs
 1464:                             join evpu in db.EmsVoipPstnUsers on ed.DID equals evpu.DID
 1465:                             where emsVoipPstnUserIdList.Contains(evpu.Id)
 1466:                             select ed.Id).ToList();
 1467:                 }
 1468:                 else list = new List<int>();
 1469:             }
 1470:  
 1471:             return list.Distinct().ToList();
 1472:         }
 1473:  
 1474:         ////////////////////////////////////////////////////////////////////////////
 1475:  
 1476:         /// <summary>
 1477:         /// 
 1478:         /// </summary>
 1479:         public static List<string> EmsBoardIdListFromEmsPortIdList(List<string> emsPortIdList)
 1480:         {
 1481:             List<string> list;
 1482:  
 1483:             using (var db = new Ia.Ftn.Cl.Db())
 1484:             {
 1485:                 if (emsPortIdList.Count > 0)
 1486:                 {
 1487:                     list = (from eb in db.EmsBoards
 1488:                             join ep in db.EmsPorts on eb.Id equals ep.EmsBoard.Id
 1489:                             where emsPortIdList.Contains(ep.Id)
 1490:                             select eb.Id).AsNoTracking().ToList();
 1491:                 }
 1492:                 else list = new List<string>();
 1493:             }
 1494:  
 1495:             return list.Distinct().ToList();
 1496:         }
 1497:  
 1498:         ////////////////////////////////////////////////////////////////////////////
 1499:  
 1500:         /// <summary>
 1501:         /// 
 1502:         /// </summary>
 1503:         public static List<string> EmsBoardIdListFromAccessIdList(List<string> accessIdList)
 1504:         {
 1505:             List<string> list;
 1506:  
 1507:             using (var db = new Ia.Ftn.Cl.Db())
 1508:             {
 1509:                 if (accessIdList.Count > 0)
 1510:                 {
 1511:                     list = (from eb in db.EmsBoards
 1512:                             join ed in db.EmsDevs on eb.EmsDev.Id equals ed.Id
 1513:                             where accessIdList.Contains(ed.Access.Id)
 1514:                             select eb.Id).AsNoTracking().ToList();
 1515:                 }
 1516:                 else list = new List<string>();
 1517:             }
 1518:  
 1519:             return list.Distinct().ToList();
 1520:         }
 1521:  
 1522:         ////////////////////////////////////////////////////////////////////////////
 1523:  
 1524:         /// <summary>
 1525:         /// 
 1526:         /// </summary>
 1527:         public static List<string> EmsPortIdListFromEmsOntIdList(List<string> emsOntIdList)
 1528:         {
 1529:             List<string> list;
 1530:  
 1531:             using (var db = new Ia.Ftn.Cl.Db())
 1532:             {
 1533:                 if (emsOntIdList.Count > 0)
 1534:                 {
 1535:                     list = (from ep in db.EmsPorts
 1536:                             join eo in db.EmsOnts on ep.Id equals eo.EmsPort.Id
 1537:                             where emsOntIdList.Contains(eo.Id)
 1538:                             select ep.Id).AsNoTracking().ToList();
 1539:                 }
 1540:                 else list = new List<string>();
 1541:             }
 1542:  
 1543:             return list.Distinct().ToList();
 1544:         }
 1545:  
 1546:         ////////////////////////////////////////////////////////////////////////////
 1547:  
 1548:         /// <summary>
 1549:         /// 
 1550:         /// </summary>
 1551:         public static List<string> EmsPortIdListFromEmsVoipPstnUserIdList(List<string> emsVoipPstnUserIdList)
 1552:         {
 1553:             List<string> list;
 1554:  
 1555:             using (var db = new Ia.Ftn.Cl.Db())
 1556:             {
 1557:                 if (emsVoipPstnUserIdList.Count > 0)
 1558:                 {
 1559:                     // select * from EmsPorts where did  = 7340512 and fn = 0 and sn = 1 and pn = 0
 1560:                     var list0 = (from evpu in db.EmsVoipPstnUsers
 1561:                                  where emsVoipPstnUserIdList.Contains(evpu.Id)
 1562:                                  select evpu).AsNoTracking().ToList();
 1563:  
 1564:                     list = new List<string>();
 1565:  
 1566:                     foreach (var evpu in list0)
 1567:                     {
 1568:                         var l = (from ep in db.EmsPorts
 1569:                                  where ep.DID == evpu.DID && ep.FN == evpu.FN && ep.SN == evpu.SN && ep.PN == evpu.PN
 1570:                                  select ep.Id).AsNoTracking().SingleOrDefault();
 1571:  
 1572:                         if (l != null) list.Add(l);
 1573:                     }
 1574:                 }
 1575:                 else list = new List<string>();
 1576:             }
 1577:  
 1578:             return list.Distinct().ToList();
 1579:         }
 1580:  
 1581:         ////////////////////////////////////////////////////////////////////////////
 1582:  
 1583:         /// <summary>
 1584:         /// 
 1585:         /// </summary>
 1586:         public static List<string> EmsOntIdListFromNddOntIdList(List<string> nddOntIdList)
 1587:         {
 1588:             List<string> list;
 1589:  
 1590:             using (var db = new Ia.Ftn.Cl.Db())
 1591:             {
 1592:                 if (nddOntIdList.Count > 0)
 1593:                 {
 1594:                     list = (from eo in db.EmsOnts
 1595:                             where nddOntIdList.Contains(eo.Id)
 1596:                             select eo.Id).AsNoTracking().ToList();
 1597:                 }
 1598:                 else list = new List<string>();
 1599:             }
 1600:  
 1601:             return list.Distinct().ToList();
 1602:         }
 1603:  
 1604:         ////////////////////////////////////////////////////////////////////////////
 1605:  
 1606:         /// <summary>
 1607:         /// 
 1608:         /// </summary>
 1609:         public static List<string> EmsOntIpListFromNddOntIdList(List<string> nddOntIdList)
 1610:         {
 1611:             List<string> list;
 1612:  
 1613:             using (var db = new Ia.Ftn.Cl.Db())
 1614:             {
 1615:                 if (nddOntIdList.Count > 0)
 1616:                 {
 1617:                     list = (from eo in db.EmsOnts
 1618:                             where nddOntIdList.Contains(eo.Id)
 1619:                             select eo.IP).AsNoTracking().ToList();
 1620:                 }
 1621:                 else list = new List<string>();
 1622:             }
 1623:  
 1624:             return list.Distinct().ToList();
 1625:         }
 1626:  
 1627:         ////////////////////////////////////////////////////////////////////////////
 1628:  
 1629:         /// <summary>
 1630:         /// 
 1631:         /// </summary>
 1632:         public static List<string> SbrImpuListFromImpuSipDomainList(List<string> impuSipDomainList)
 1633:         {
 1634:             List<string> list;
 1635:  
 1636:             using (var db = new Ia.Ftn.Cl.Db())
 1637:             {
 1638:                 if (impuSipDomainList.Count > 0)
 1639:                 {
 1640:                     list = (from s in db.Sbrs
 1641:                             where impuSipDomainList.Contains(s.IMPU)
 1642:                             select s.IMPU).AsNoTracking().ToList();
 1643:                 }
 1644:                 else list = new List<string>();
 1645:             }
 1646:  
 1647:             return list.Distinct().ToList();
 1648:         }
 1649:  
 1650:         ////////////////////////////////////////////////////////////////////////////
 1651:  
 1652:         /// <summary>
 1653:         /// 
 1654:         /// </summary>
 1655:         public static List<string> OwSbrImpuListFromImpuSipDomainList(List<string> impuSipDomainList)
 1656:         {
 1657:             List<string> list;
 1658:  
 1659:             using (var db = new Ia.Ftn.Cl.Db())
 1660:             {
 1661:                 if (impuSipDomainList.Count > 0)
 1662:                 {
 1663:                     list = (from o in db.Owsbrs
 1664:                             where impuSipDomainList.Contains(o.IMPU)
 1665:                             select o.IMPU).AsNoTracking().ToList();
 1666:                 }
 1667:                 else list = new List<string>();
 1668:             }
 1669:  
 1670:             return list.Distinct().ToList();
 1671:         }
 1672:  
 1673:         ////////////////////////////////////////////////////////////////////////////
 1674:  
 1675:         /// <summary>
 1676:         /// 
 1677:         /// </summary>
 1678:         public static List<string> ServiceRequestServiceIdListFromAccessIdList(List<string> accessIdList)
 1679:         {
 1680:             List<string> list;
 1681:  
 1682:             using (var db = new Ia.Ftn.Cl.Db())
 1683:             {
 1684:                 if (accessIdList.Count > 0)
 1685:                 {
 1686:                     list = (from srs in db.ServiceRequestServices
 1687:                             where accessIdList.Contains(srs.Access.Id)
 1688:                             select srs.Id).AsNoTracking().ToList();
 1689:                 }
 1690:                 else list = new List<string>();
 1691:             }
 1692:  
 1693:             return list.Distinct().ToList();
 1694:         }
 1695:  
 1696:         ////////////////////////////////////////////////////////////////////////////
 1697:  
 1698:         /// <summary>
 1699:         /// 
 1700:         /// </summary>
 1701:         public static List<string> ServiceRequestServiceIdListFromServiceIdList(List<string> serviceIdList)
 1702:         {
 1703:             List<string> list;
 1704:  
 1705:             using (var db = new Ia.Ftn.Cl.Db())
 1706:             {
 1707:                 if (serviceIdList.Count > 0)
 1708:                 {
 1709:                     list = (from srs in db.ServiceRequestServices
 1710:                             where serviceIdList.Contains(srs.Id)
 1711:                             select srs.Id).AsNoTracking().ToList();
 1712:                 }
 1713:                 else list = new List<string>();
 1714:             }
 1715:  
 1716:             return list.Distinct().ToList();
 1717:         }
 1718:  
 1719:         ////////////////////////////////////////////////////////////////////////////
 1720:  
 1721:         /// <summary>
 1722:         /// 
 1723:         /// </summary>
 1724:         public static List<string> ServiceRequestServiceIdListFromServiceList(List<string> serviceList)
 1725:         {
 1726:             List<string> list;
 1727:  
 1728:             using (var db = new Ia.Ftn.Cl.Db())
 1729:             {
 1730:                 if (serviceList.Count > 0)
 1731:                 {
 1732:                     list = (from srs in db.ServiceRequestServices
 1733:                             where serviceList.Contains(srs.Service)
 1734:                             select srs.Id).AsNoTracking().ToList();
 1735:                 }
 1736:                 else list = new List<string>();
 1737:             }
 1738:  
 1739:             return list.Distinct().ToList();
 1740:         }
 1741:  
 1742:         ////////////////////////////////////////////////////////////////////////////
 1743:  
 1744:         /// <summary>
 1745:         /// 
 1746:         /// </summary>
 1747:         public static List<string> Service2IdListFromServiceIdList(List<string> serviceIdList)
 1748:         {
 1749:             List<string> list;
 1750:  
 1751:             if (serviceIdList.Count > 0)
 1752:             {
 1753:                 using (var db = new Ia.Ftn.Cl.Db())
 1754:                 {
 1755:                     list = (from s in db.Service2
 1756:                             where serviceIdList.Contains(s.Id)
 1757:                             select s.Id).AsNoTracking().ToList();
 1758:                 }
 1759:             }
 1760:             else list = new List<string>();
 1761:  
 1762:             return list.Distinct().ToList();
 1763:         }
 1764:  
 1765:         ////////////////////////////////////////////////////////////////////////////
 1766:  
 1767:         /// <summary>
 1768:         /// 
 1769:         /// </summary>
 1770:         public static List<string> ServiceIdListFromServiceList(List<string> serviceList)
 1771:         {
 1772:             List<string> list;
 1773:  
 1774:             using (var db = new Ia.Ftn.Cl.Db())
 1775:             {
 1776:                 if (serviceList.Count > 0)
 1777:                 {
 1778:                     list = (from s in db.Service2
 1779:                             where serviceList.Contains(s.Service)
 1780:                             select s.Id).AsNoTracking().ToList();
 1781:                 }
 1782:                 else list = new List<string>();
 1783:             }
 1784:  
 1785:             return list.Distinct().ToList();
 1786:         }
 1787:  
 1788:         ////////////////////////////////////////////////////////////////////////////
 1789:  
 1790:         /// <summary>
 1791:         /// 
 1792:         /// </summary>
 1793:         public static List<int> ReportIdListFromServiceList(List<string> serviceList)
 1794:         {
 1795:             List<int> list;
 1796:  
 1797:             //reportIdList = (from r in db.Reports where r.Service == accessName && r.ServiceType == 2 select r.Id).Distinct().ToList();
 1798:             // <type id="2" name="Ont Name" arabicName=""/>
 1799:  
 1800:             using (var db = new Ia.Ftn.Cl.Db())
 1801:             {
 1802:                 if (serviceList.Count > 0)
 1803:                 {
 1804:                     list = (from r in db.Reports
 1805:                             where serviceList.Contains(r.Service)
 1806:                             select r.Id).ToList();
 1807:                 }
 1808:                 else list = new List<int>();
 1809:             }
 1810:  
 1811:             return list.Distinct().ToList();
 1812:         }
 1813:  
 1814:         ////////////////////////////////////////////////////////////////////////////
 1815:  
 1816:         /// <summary>
 1817:         /// 
 1818:         /// </summary>
 1819:         public static List<int> ReportIdListFromAccessIdList(List<string> accessIdList)
 1820:         {
 1821:             string accessName;
 1822:             List<string> accessNameList;
 1823:             List<int> list;
 1824:  
 1825:             //reportIdList = (from r in db.Reports where r.Service == accessName && r.ServiceType == 2 select r.Id).Distinct().ToList();
 1826:             // <type id="2" name="Ont Name" arabicName=""/>
 1827:  
 1828:             if (accessIdList.Count > 0)
 1829:             {
 1830:                 var ontAccessIdToOntAccessNameDictionary = Ia.Ftn.Cl.Models.Data.NetworkDesignDocument.OntAccessIdToOntAccessNameDictionary;
 1831:  
 1832:                 accessNameList = new List<string>();
 1833:  
 1834:                 foreach (var id in accessIdList)
 1835:                 {
 1836:                     if (ontAccessIdToOntAccessNameDictionary.ContainsKey(id))
 1837:                     {
 1838:                         accessName = ontAccessIdToOntAccessNameDictionary[id];
 1839:  
 1840:                         accessNameList.Add(accessName);
 1841:                     }
 1842:                 }
 1843:  
 1844:                 list = ReportIdListFromServiceList(accessNameList); // Its OK
 1845:             }
 1846:             else list = new List<int>();
 1847:  
 1848:             return list.Distinct().ToList();
 1849:         }
 1850:  
 1851:         ////////////////////////////////////////////////////////////////////////////
 1852:  
 1853:         /// <summary>
 1854:         /// 
 1855:         /// </summary>
 1856:         public static List<string> ServiceIdListFromAccessIdList(List<string> accessIdList)
 1857:         {
 1858:             List<string> list;
 1859:  
 1860:             using (var db = new Ia.Ftn.Cl.Db())
 1861:             {
 1862:                 if (accessIdList.Count > 0)
 1863:                 {
 1864:                     list = (from s in db.Service2
 1865:                             where s.Access != null && accessIdList.Contains(s.Access.Id)
 1866:                             select s.Id).AsNoTracking().ToList();
 1867:                 }
 1868:                 else list = new List<string>();
 1869:             }
 1870:  
 1871:             return list.Distinct().ToList();
 1872:         }
 1873:  
 1874:         ////////////////////////////////////////////////////////////////////////////
 1875:  
 1876:         /// <summary>
 1877:         /// 
 1878:         /// </summary>
 1879:         public static List<string> AccessIdListFromServiceIdList(List<string> serviceIdList)
 1880:         {
 1881:             List<string> list;
 1882:  
 1883:             using (var db = new Ia.Ftn.Cl.Db())
 1884:             {
 1885:                 if (serviceIdList.Count > 0)
 1886:                 {
 1887:                     list = (from s in db.Service2
 1888:                             where serviceIdList.Contains(s.Id) && s.Access != null
 1889:                             select s.Access.Id).AsNoTracking().ToList();
 1890:                 }
 1891:                 else list = new List<string>();
 1892:             }
 1893:  
 1894:             return list.Distinct().ToList();
 1895:         }
 1896:  
 1897:         ////////////////////////////////////////////////////////////////////////////
 1898:  
 1899:         /// <summary>
 1900:         /// 
 1901:         /// </summary>
 1902:         public static List<string> AccessIdListFromServiceList(List<string> serviceList)
 1903:         {
 1904:             List<string> list;
 1905:  
 1906:             using (var db = new Ia.Ftn.Cl.Db())
 1907:             {
 1908:                 if (serviceList.Count > 0)
 1909:                 {
 1910:                     list = (from s in db.Service2
 1911:                             where serviceList.Contains(s.Service) && s.Access != null /*&& where s.ServiceType == Ia.Ftn.Cl.Model.Business.Service.ServiceType.ImsService*/
 1912:                             select s.Access.Id).AsNoTracking().ToList();
 1913:                 }
 1914:                 else list = new List<string>();
 1915:             }
 1916:  
 1917:             return list.Distinct().ToList();
 1918:         }
 1919:  
 1920:         ////////////////////////////////////////////////////////////////////////////
 1921:  
 1922:         /// <summary>
 1923:         /// 
 1924:         /// </summary>
 1925:         public static List<string> AccessIdListFromServiceRequestServiceIdList(List<string> serviceRequestServiceIdList)
 1926:         {
 1927:             List<string> list;
 1928:  
 1929:             using (var db = new Ia.Ftn.Cl.Db())
 1930:             {
 1931:                 if (serviceRequestServiceIdList.Count > 0)
 1932:                 {
 1933:                     list = (from srs in db.ServiceRequestServices
 1934:                             where serviceRequestServiceIdList.Contains(srs.Id) && srs.Access != null
 1935:                             select srs.Access.Id).AsNoTracking().ToList();
 1936:                 }
 1937:                 else list = new List<string>();
 1938:             }
 1939:  
 1940:             return list.Distinct().ToList();
 1941:         }
 1942:  
 1943:         ////////////////////////////////////////////////////////////////////////////
 1944:  
 1945:         /// <summary>
 1946:         /// 
 1947:         /// </summary>
 1948:         public static List<string> ServiceRequestOntIdListFromAccessIdList(List<string> accessIdList)
 1949:         {
 1950:             List<string> list;
 1951:  
 1952:             using (var db = new Ia.Ftn.Cl.Db())
 1953:             {
 1954:                 if (accessIdList.Count > 0)
 1955:                 {
 1956:                     list = (from sro in db.ServiceRequestOnts
 1957:                             where accessIdList.Contains(sro.Access.Id)
 1958:                             select sro.Id).AsNoTracking().ToList();
 1959:                 }
 1960:                 else list = new List<string>();
 1961:             }
 1962:  
 1963:             return list.Distinct().ToList();
 1964:         }
 1965:  
 1966:         ////////////////////////////////////////////////////////////////////////////
 1967:  
 1968:         /// <summary>
 1969:         /// 
 1970:         /// </summary>
 1971:         public static List<int> ServiceRequestIdListFromServiceList(List<string> serviceList)
 1972:         {
 1973:             List<int> list, numberList;
 1974:  
 1975:             if (serviceList.Count > 0)
 1976:             {
 1977:                 numberList = serviceList.Select(int.Parse).ToList();
 1978:  
 1979:                 using (var db = new Ia.Ftn.Cl.Db())
 1980:                 {
 1981:                     list = (from sr in db.ServiceRequests
 1982:                             where numberList.Contains(sr.Number)
 1983:                             select sr.Id).ToList();
 1984:                 }
 1985:             }
 1986:             else list = new List<int>();
 1987:  
 1988:             return list.Distinct().ToList();
 1989:         }
 1990:  
 1991:         ////////////////////////////////////////////////////////////////////////////
 1992:  
 1993:         /// <summary>
 1994:         /// 
 1995:         /// </summary>
 1996:         public static List<int> ServiceRequestIdListFromServiceAndRelatedChangedAndChangedToServiceList(List<string> serviceList)
 1997:         {
 1998:             List<int> list;//, numberList, numberAndChangedAndChangedToList;
 1999:  
 2000:             if (serviceList.Count > 0)
 2001:             {
 2002:                 var list0 = Ia.Ftn.Cl.Models.Data.ServiceRequest.ServiceListAndRelatedChangedAndChangedToServiceListByServiceList(serviceList);
 2003:                 serviceList = serviceList.Union(list0).Distinct().ToList();
 2004:  
 2005:                 list = Ia.Ftn.Cl.Models.Data.Maintenance.Find.ServiceRequestIdListFromServiceList(serviceList);
 2006:             }
 2007:             else list = new List<int>();
 2008:  
 2009:             return list.Distinct().ToList();
 2010:         }
 2011:  
 2012:         ////////////////////////////////////////////////////////////////////////////
 2013:  
 2014:         /// <summary>
 2015:         /// 
 2016:         /// </summary>
 2017:         public static List<int> ServiceRequestIdListFromServiceRequestServiceIdList(List<string> serviceRequestServiceIdList)
 2018:         {
 2019:             List<int> list;
 2020:  
 2021:             if (serviceRequestServiceIdList.Count > 0)
 2022:             {
 2023:                 using (var db = new Ia.Ftn.Cl.Db())
 2024:                 {
 2025:                     list = (from sr in db.ServiceRequests
 2026:                             where serviceRequestServiceIdList.Contains(sr.ServiceRequestService.Id)
 2027:                             select sr.Id).ToList();
 2028:                 }
 2029:             }
 2030:             else list = new List<int>();
 2031:  
 2032:             return list.Distinct().ToList();
 2033:         }
 2034:  
 2035:         ////////////////////////////////////////////////////////////////////////////
 2036:  
 2037:         /// <summary>
 2038:         /// 
 2039:         /// </summary>
 2040:         public static List<string> ServiceRequestAdministrativeIssueIdListFromServiceIdList(List<string> serviceIdList)
 2041:         {
 2042:             List<string> list;
 2043:  
 2044:             if (serviceIdList.Count > 0)
 2045:             {
 2046:                 using (var db = new Ia.Ftn.Cl.Db())
 2047:                 {
 2048:                     list = (from srai in db.ServiceRequestAdministrativeIssues
 2049:                             where serviceIdList.Contains(srai.Id)
 2050:                             select srai.Id).AsNoTracking().ToList();
 2051:                 }
 2052:             }
 2053:             else list = new List<string>();
 2054:  
 2055:             return list.Distinct().ToList();
 2056:         }
 2057:  
 2058:         ////////////////////////////////////////////////////////////////////////////
 2059:  
 2060:         /// <summary>
 2061:         /// 
 2062:         /// </summary>
 2063:         public static List<string> ServiceRequestHistoryIdListFromServiceAndRelatedChangedAndChangedToServiceList(List<string> serviceList)
 2064:         {
 2065:             List<int> numberList;
 2066:             List<string> list;
 2067:  
 2068:             if (serviceList.Count > 0)
 2069:             {
 2070:                 var list0 = Ia.Ftn.Cl.Models.Data.ServiceRequest.ServiceListAndRelatedChangedAndChangedToServiceListByServiceList(serviceList);
 2071:                 serviceList = serviceList.Union(list0).Distinct().ToList();
 2072:  
 2073:                 numberList = new List<int>();
 2074:  
 2075:                 foreach (string s in serviceList)
 2076:                 {
 2077:                     if (int.TryParse(s, out int i)) numberList.Add(i);
 2078:                 }
 2079:  
 2080:                 using (var db = new Ia.Ftn.Cl.Db())
 2081:                 {
 2082:                     list = (from srh in db.ServiceRequestHistories
 2083:                             where numberList.Contains(srh.Number)
 2084:                             select srh.Id).AsNoTracking().ToList();
 2085:                 }
 2086:             }
 2087:             else list = new List<string>();
 2088:  
 2089:             return list.Distinct().ToList();
 2090:         }
 2091:  
 2092:         ////////////////////////////////////////////////////////////////////////////
 2093:  
 2094:         /// <summary>
 2095:         /// 
 2096:         /// </summary>
 2097:         public static List<int> ServiceRequestTypeIdListFromServiceRequestIdList(List<int> serviceRequestIdList)
 2098:         {
 2099:             List<int> list;
 2100:  
 2101:             using (var db = new Ia.Ftn.Cl.Db())
 2102:             {
 2103:                 if (serviceRequestIdList.Count > 0)
 2104:                 {
 2105:                     list = (from srt in db.ServiceRequestTypes
 2106:                             where serviceRequestIdList.Contains(srt.ServiceRequest.Id)
 2107:                             select srt.Id).ToList();
 2108:                 }
 2109:                 else list = new List<int>();
 2110:             }
 2111:  
 2112:             return list.Distinct().ToList();
 2113:         }
 2114:  
 2115:         ////////////////////////////////////////////////////////////////////////////
 2116:  
 2117:         /// <summary>
 2118:         /// 
 2119:         /// </summary>
 2120:         public static List<string> NddOntIdList(int oltId, int ponNumber, int ontInternalNumber)
 2121:         {
 2122:             List<string> list;
 2123:  
 2124:             list = (from o in Ia.Ftn.Cl.Models.Data.NetworkDesignDocument.OntList
 2125:                     where o.Pon.PonGroup.Olt.Id == oltId && o.Pon.Number == ponNumber && o.Number == ontInternalNumber
 2126:                     select o.Id).ToList();
 2127:  
 2128:             return list.Distinct().ToList();
 2129:         }
 2130:  
 2131:         ////////////////////////////////////////////////////////////////////////////
 2132:  
 2133:         /// <summary>
 2134:         /// 
 2135:         /// </summary>
 2136:         public static List<string> NddOntIdList(int oltId, int ponNumber)
 2137:         {
 2138:             List<string> list;
 2139:  
 2140:             list = (from o in Ia.Ftn.Cl.Models.Data.NetworkDesignDocument.OntList
 2141:                     where o.Pon.PonGroup.Olt.Id == oltId && o.Pon.Number == ponNumber
 2142:                     select o.Id).ToList();
 2143:  
 2144:             return list.Distinct().ToList();
 2145:         }
 2146:  
 2147:         ////////////////////////////////////////////////////////////////////////////
 2148:  
 2149:         /// <summary>
 2150:         /// 
 2151:         /// </summary>
 2152:         public static List<string> NddOntIdListFromAccessIdList(List<string> accessIdList)
 2153:         {
 2154:             List<string> list;
 2155:  
 2156:             if (accessIdList.Count > 0)
 2157:             {
 2158:                 // this is not slow for general returns
 2159:                 list = (from o in Ia.Ftn.Cl.Models.Data.NetworkDesignDocument.OntList
 2160:                         where accessIdList.Contains(o.Access.Id)
 2161:                         select o.Id).ToList();
 2162:             }
 2163:             else list = new List<string>();
 2164:  
 2165:             return list.Distinct().ToList();
 2166:         }
 2167:  
 2168:         ////////////////////////////////////////////////////////////////////////////
 2169:  
 2170:         /// <summary>
 2171:         /// 
 2172:         /// </summary>
 2173:         public static List<string> NddOntIdListFromIpList(List<string> ipList)
 2174:         {
 2175:             List<string> list;
 2176:  
 2177:             if (ipList.Count > 0)
 2178:             {
 2179:                 // this is not slow for general returns
 2180:                 list = (from o in Ia.Ftn.Cl.Models.Data.NetworkDesignDocument.OntList
 2181:                         where ipList.Contains(o.Ip)
 2182:                         select o.Id).ToList();
 2183:             }
 2184:             else list = new List<string>();
 2185:  
 2186:             return list.Distinct().ToList();
 2187:         }
 2188:  
 2189:         ////////////////////////////////////////////////////////////////////////////   
 2190:  
 2191:         /// <summary>
 2192:         /// 
 2193:         /// </summary>
 2194:         public static List<string> NddOntIdListFromEmsOntSipInfoListAndEmsVoipPstnUserListByServiceList(List<string> serviceList)
 2195:         {
 2196:             string sipUserName, serviceWithCountryCode;
 2197:             List<string> list, emsOntSipInfoEmsOntIdList, emsVoipPstnUserEmsOntIdList;
 2198:             List<string> emsOntSipInfoSipUserNameList, emsVoipPstnUserDnList;
 2199:  
 2200:             if (serviceList.Count > 0)
 2201:             {
 2202:                 emsOntSipInfoSipUserNameList = new List<string>();
 2203:                 emsVoipPstnUserDnList = new List<string>();
 2204:  
 2205:                 foreach (var service in serviceList)
 2206:                 {
 2207:                     sipUserName = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.SipUserName(service);
 2208:                     emsOntSipInfoSipUserNameList.Add(sipUserName);
 2209:  
 2210:                     serviceWithCountryCode = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.ServiceWithCountryCode(service);
 2211:                     emsVoipPstnUserDnList.Add(serviceWithCountryCode);
 2212:                 }
 2213:  
 2214:                 using (var db = new Ia.Ftn.Cl.Db())
 2215:                 {
 2216:                     emsOntSipInfoEmsOntIdList = (from eosi in db.EmsOntSipInfoes
 2217:                                                  join eo in db.EmsOnts on eosi.EmsOnt.Id equals eo.Id
 2218:                                                  where emsOntSipInfoSipUserNameList.Contains(eosi.SIPUSERNAME)
 2219:                                                  select eo.Id).AsNoTracking().ToList();
 2220:  
 2221:                     emsOntSipInfoEmsOntIdList = emsOntSipInfoEmsOntIdList.Distinct().ToList();
 2222:  
 2223:                     emsVoipPstnUserEmsOntIdList = (from evpu in db.EmsVoipPstnUsers
 2224:                                                    join eo in db.EmsOnts on evpu.EmsOnt.Id equals eo.Id
 2225:                                                    where evpu.EmsOnt != null && emsVoipPstnUserDnList.Contains(evpu.DN)
 2226:                                                    select eo.Id).AsNoTracking().ToList();
 2227:  
 2228:                     emsVoipPstnUserEmsOntIdList = emsVoipPstnUserEmsOntIdList.Distinct().ToList();
 2229:  
 2230:                     list = emsOntSipInfoEmsOntIdList.Concat(emsVoipPstnUserEmsOntIdList).ToList();
 2231:                     list = list.Distinct().ToList();
 2232:                 }
 2233:             }
 2234:             else list = new List<string>();
 2235:  
 2236:             return list.ToList();
 2237:         }
 2238:  
 2239:         ////////////////////////////////////////////////////////////////////////////
 2240:  
 2241:         /// <summary>
 2242:         /// 
 2243:         /// </summary>
 2244:         public static List<string> OntServiceVoipIpList(List<string> ontServiceVoipIdList)
 2245:         {
 2246:             List<string> list;
 2247:  
 2248:             using (var db = new Ia.Ftn.Cl.Db())
 2249:             {
 2250:                 if (ontServiceVoipIdList.Count > 0)
 2251:                 {
 2252:                     list = (from osv in db.OntServiceVoips
 2253:                             where ontServiceVoipIdList.Contains(osv.Id)
 2254:                             select osv.Ip).AsNoTracking().ToList();
 2255:                 }
 2256:                 else list = new List<string>();
 2257:             }
 2258:  
 2259:             return list.Distinct().ToList();
 2260:         }
 2261:  
 2262:         ////////////////////////////////////////////////////////////////////////////
 2263:  
 2264:         /// <summary>
 2265:         /// 
 2266:         /// </summary>
 2267:         public static List<string> NddPonIpList(int oltId, int ponNumber)
 2268:         {
 2269:             var list = (from o in Ia.Ftn.Cl.Models.Data.NetworkDesignDocument.OntList
 2270:                         where o.Pon.PonGroup.Olt.Id == oltId && o.Pon.Number == ponNumber
 2271:                         select o.Ip);//.ToList();
 2272:  
 2273:             return list.Distinct().ToList();
 2274:         }
 2275:  
 2276:         ////////////////////////////////////////////////////////////////////////////
 2277:  
 2278:         /// <summary>
 2279:         /// 
 2280:         /// </summary>
 2281:         public static List<string> OntIdListFromNddOntIdList(List<string> nddOntIdList)
 2282:         {
 2283:             List<string> list;
 2284:  
 2285:             using (var db = new Ia.Ftn.Cl.Db())
 2286:             {
 2287:                 if (nddOntIdList.Count > 0)
 2288:                 {
 2289:                     list = (from o in db.Onts
 2290:                             where nddOntIdList.Contains(o.Id)
 2291:                             select o.Id).AsNoTracking().ToList();
 2292:                 }
 2293:                 else list = new List<string>();
 2294:             }
 2295:  
 2296:             return list.Distinct().ToList();
 2297:         }
 2298:  
 2299:         ////////////////////////////////////////////////////////////////////////////
 2300:  
 2301:         /// <summary>
 2302:         /// 
 2303:         /// </summary>
 2304:         public static List<string> OntOntPotsIdListFromOntIdList(List<string> ontIdList)
 2305:         {
 2306:             List<string> list;
 2307:  
 2308:             using (var db = new Ia.Ftn.Cl.Db())
 2309:             {
 2310:                 if (ontIdList.Count > 0)
 2311:                 {
 2312:                     list = (from oop in db.OntOntPots
 2313:                             where ontIdList.Contains(oop.Ont.Id)
 2314:                             select oop.Id).AsNoTracking().ToList();
 2315:                 }
 2316:                 else list = new List<string>();
 2317:             }
 2318:  
 2319:             return list.Distinct().ToList();
 2320:         }
 2321:  
 2322:         ////////////////////////////////////////////////////////////////////////////
 2323:  
 2324:         /// <summary>
 2325:         /// 
 2326:         /// </summary>
 2327:         public static List<string> OntServiceVoipsIdListFromOntIdList(List<string> ontIdList)
 2328:         {
 2329:             List<string> list;
 2330:  
 2331:             using (var db = new Ia.Ftn.Cl.Db())
 2332:             {
 2333:                 if (ontIdList.Count > 0)
 2334:                 {
 2335:                     list = (from ov in db.OntServiceVoips
 2336:                             where ontIdList.Contains(ov.Ont.Id)
 2337:                             select ov.Id).AsNoTracking().ToList();
 2338:                 }
 2339:                 else list = new List<string>();
 2340:             }
 2341:  
 2342:             return list.Distinct().ToList();
 2343:         }
 2344:  
 2345:         ////////////////////////////////////////////////////////////////////////////
 2346:  
 2347:         /// <summary>
 2348:         /// 
 2349:         /// </summary>
 2350:         public static List<string> AccessIdListFromOntSerial(string serial)
 2351:         {
 2352:             List<string> list;
 2353:  
 2354:             using (var db = new Ia.Ftn.Cl.Db())
 2355:             {
 2356:                 if (!string.IsNullOrEmpty(serial))
 2357:                 {
 2358:                     list = (from o in db.Onts
 2359:                             where o.Serial == serial
 2360:                             select o.Access.Id).AsNoTracking().ToList();
 2361:                 }
 2362:                 else list = new List<string>();
 2363:             }
 2364:  
 2365:             return list.Distinct().ToList();
 2366:         }
 2367:  
 2368:         ////////////////////////////////////////////////////////////////////////////
 2369:  
 2370:         /// <summary>
 2371:         /// 
 2372:         /// </summary>
 2373:         public static List<string> AccessIdListFromEmsOntSerial(string serial)
 2374:         {
 2375:             List<string> list;
 2376:  
 2377:             using (var db = new Ia.Ftn.Cl.Db())
 2378:             {
 2379:                 if (!string.IsNullOrEmpty(serial))
 2380:                 {
 2381:                     list = (from eo in db.EmsOnts
 2382:                             where eo.SERIALNUM == serial
 2383:                             select eo.Access.Id).AsNoTracking().ToList();
 2384:                 }
 2385:                 else list = new List<string>();
 2386:             }
 2387:  
 2388:             return list.Distinct().ToList();
 2389:         }
 2390:  
 2391:         ////////////////////////////////////////////////////////////////////////////
 2392:  
 2393:         /// <summary>
 2394:         /// 
 2395:         /// </summary>
 2396:         public static List<string> AccessIdListFromEmsOntIp(string ip)
 2397:         {
 2398:             List<string> list;
 2399:  
 2400:             using (var db = new Ia.Ftn.Cl.Db())
 2401:             {
 2402:                 if (!string.IsNullOrEmpty(ip))
 2403:                 {
 2404:                     list = (from eo in db.EmsOnts
 2405:                             where eo.IP == ip
 2406:                             select eo.Access.Id).AsNoTracking().ToList();
 2407:                 }
 2408:                 else list = new List<string>();
 2409:             }
 2410:  
 2411:             return list.Distinct().ToList();
 2412:         }
 2413:  
 2414:         ////////////////////////////////////////////////////////////////////////////
 2415:  
 2416:         /// <summary>
 2417:         /// 
 2418:         /// </summary>
 2419:         public static List<string> OntServiceVoipsIdListFromIpList(List<string> ipList)
 2420:         {
 2421:             List<string> list;
 2422:  
 2423:             using (var db = new Ia.Ftn.Cl.Db())
 2424:             {
 2425:                 if (ipList.Count > 0)
 2426:                 {
 2427:                     list = (from ov in db.OntServiceVoips
 2428:                             where ipList.Contains(ov.Ip)
 2429:                             select ov.Id).AsNoTracking().ToList();
 2430:                 }
 2431:                 else list = new List<string>();
 2432:             }
 2433:  
 2434:             return list.Distinct().ToList();
 2435:         }
 2436:  
 2437:         ////////////////////////////////////////////////////////////////////////////
 2438:  
 2439:         /// <summary>
 2440:         /// 
 2441:         /// </summary>
 2442:         public static List<long> EventIdListFromOntIdList(List<string> ontIdList)
 2443:         {
 2444:             List<long> list;
 2445:  
 2446:             using (var db = new Ia.Ftn.Cl.Db())
 2447:             {
 2448:                 if (ontIdList.Count > 0)
 2449:                 {
 2450:                     list = (from e in db.Events
 2451:                             where ontIdList.Contains(e.Ont.Id) && e.Ont != null
 2452:                             select e.Id).ToList();
 2453:                 }
 2454:                 else list = new List<long>();
 2455:             }
 2456:  
 2457:             return list.Distinct().ToList();
 2458:         }
 2459:  
 2460:         ////////////////////////////////////////////////////////////////////////////
 2461:  
 2462:         /// <summary>
 2463:         /// 
 2464:         /// </summary>
 2465:         public static List<long> EventIdListFromNddOntIdList(List<string> nddOntIdList, int take)
 2466:         {
 2467:             List<long> list;
 2468:  
 2469:             using (var db = new Ia.Ftn.Cl.Db())
 2470:             {
 2471:                 if (nddOntIdList.Count > 0)
 2472:                 {
 2473:                     //foreach (var v in nddOntList)
 2474:                     //{
 2475:                     //eventSystemList.Add(v.Pon.PonGroup.Olt.AmsName);
 2476:                     //eventAidOntList.Add("ONT-1-1-" + v.Card + "-" + v.Port + "-" + v.Number);
 2477:                     //eventAidOntVoipList.Add("ONTVOIP-1-1-" + v.Card + "-" + v.Port + "-1");
 2478:  
 2479:                     //foreach (var w in ontOntPotsList) eventAidOntPotsList.Add("ONTPOTS-1-1-" + v.Card + "-" + v.Port + "-" + w.Card + "-" + w.Port);
 2480:                     //}
 2481:  
 2482:                     //eventSystemList = eventSystemList.Distinct().ToList();
 2483:                     //eventAidOntList = eventAidOntList.Distinct().ToList();
 2484:                     //eventAidOntVoipList = eventAidOntVoipList.Distinct().ToList();
 2485:  
 2486:                     /*
 2487:                     eventList = (from e in db.Events where eventSystemList.Contains(e.System) where eventAidOntList.Contains(e.Aid) select e)
 2488:                                 .Union(from e in db.Events where eventSystemList.Contains(e.System) where eventAidOntList.Contains(e.Aid) where eventAidOntVoipList.Contains(e.Aid) select e)
 2489:                                 .Union(from e in db.Events where eventSystemList.Contains(e.System) where eventAidOntList.Contains(e.Aid) where eventAidOntPotsList.Contains(e.Aid) select e)
 2490:                                 .ToList();
 2491:                                 */
 2492:  
 2493:  
 2494:                     list = (from e in db.Events
 2495:                             where e.Ont != null && nddOntIdList.Contains(e.Ont.Id)
 2496:                             orderby e.Created descending
 2497:                             select e.Id).Take(take).ToList();
 2498:                 }
 2499:                 else list = new List<long>();
 2500:             }
 2501:  
 2502:             return list.Distinct().ToList();
 2503:         }
 2504:  
 2505:         ////////////////////////////////////////////////////////////////////////////
 2506:  
 2507:         /// <summary>
 2508:         /// 
 2509:         /// </summary>
 2510:         public static List<int> AgcfGatewayRecordIdListFromIpList(List<string> ipList)
 2511:         {
 2512:             List<int> list;
 2513:  
 2514:             using (var db = new Ia.Ftn.Cl.Db())
 2515:             {
 2516:                 // try Ia.Ftn.Cl.Model.Data.Nokia.AgcfGatewayRecord.IdToIp1Dictionary;
 2517:  
 2518:                 if (ipList.Count > 0)
 2519:                 {
 2520:                     list = (from gr in db.AgcfGatewayRecords
 2521:                             where ipList.Contains(gr.IP1)
 2522:                             select gr.Id).ToList();
 2523:                 }
 2524:                 else list = new List<int>();
 2525:             }
 2526:  
 2527:             return list.Distinct().ToList();
 2528:         }
 2529:  
 2530:         ////////////////////////////////////////////////////////////////////////////
 2531:  
 2532:         /// <summary>
 2533:         /// 
 2534:         /// </summary>
 2535:         public static List<int> AgcfGatewayRecordIdListFromNddOntIdList(List<string> nddOntIdlist)
 2536:         {
 2537:             List<int> list;
 2538:             List<string> nddIpList;
 2539:  
 2540:             if (nddOntIdlist.Count > 0)
 2541:             {
 2542:                 nddIpList = (from o in Ia.Ftn.Cl.Models.Data.NetworkDesignDocument.OntList
 2543:                              where nddOntIdlist.Contains(o.Id)
 2544:                              select o.Ip).ToList();
 2545:  
 2546:                 using (var db = new Ia.Ftn.Cl.Db())
 2547:                 {
 2548:                     list = (from gr in db.AgcfGatewayRecords
 2549:                             where nddIpList.Contains(gr.IP1)
 2550:                             select gr.Id).ToList();
 2551:                 }
 2552:             }
 2553:             else list = new List<int>();
 2554:  
 2555:             return list.Distinct().ToList();
 2556:         }
 2557:  
 2558:         ////////////////////////////////////////////////////////////////////////////
 2559:  
 2560:         /// <summary>
 2561:         /// 
 2562:         /// </summary>
 2563:         public static List<int> AgcfGatewayRecordIdListFromAgcfEndpointIdList(List<string> agcfEndpointIdList)
 2564:         {
 2565:             List<int> list;
 2566:  
 2567:             using (var db = new Ia.Ftn.Cl.Db())
 2568:             {
 2569:                 if (agcfEndpointIdList.Count > 0)
 2570:                 {
 2571:                     list = (from ep in db.AgcfEndpoints
 2572:                             where agcfEndpointIdList.Contains(ep.Id)
 2573:                             select ep.AgcfGatewayRecord.Id).ToList();
 2574:                 }
 2575:                 else list = new List<int>();
 2576:             }
 2577:  
 2578:             return list.Distinct().ToList();
 2579:         }
 2580:  
 2581:         ////////////////////////////////////////////////////////////////////////////
 2582:  
 2583:         /// <summary>
 2584:         /// 
 2585:         /// </summary>
 2586:         public static List<string> AgcfGatewayRecordIpListFromIdList(List<int> agcfGatewayRecordIdList)
 2587:         {
 2588:             List<string> list;
 2589:  
 2590:             using (var db = new Ia.Ftn.Cl.Db())
 2591:             {
 2592:                 if (agcfGatewayRecordIdList.Count > 0)
 2593:                 {
 2594:                     list = (from gr in db.AgcfGatewayRecords
 2595:                             where agcfGatewayRecordIdList.Contains(gr.Id)
 2596:                             select gr.IP1).ToList();
 2597:                 }
 2598:                 else list = new List<string>();
 2599:             }
 2600:  
 2601:             return list.Distinct().ToList();
 2602:         }
 2603:  
 2604:         ////////////////////////////////////////////////////////////////////////////
 2605:  
 2606:         /// <summary>
 2607:         /// 
 2608:         /// </summary>
 2609:         public static List<int> AgcfGatewayRecordIdListFromGatewayIdList(List<int> gatewayIdList)
 2610:         {
 2611:             List<int> list;
 2612:  
 2613:             using (var db = new Ia.Ftn.Cl.Db())
 2614:             {
 2615:                 if (gatewayIdList.Count > 0)
 2616:                 {
 2617:                     list = (from gr in db.AgcfGatewayRecords
 2618:                             where gatewayIdList.Contains(gr.GwId)
 2619:                             select gr.Id).ToList();
 2620:                 }
 2621:                 else list = new List<int>();
 2622:             }
 2623:  
 2624:             return list.Distinct().ToList();
 2625:         }
 2626:  
 2627:         ////////////////////////////////////////////////////////////////////////////
 2628:  
 2629:         /// <summary>
 2630:         /// 
 2631:         /// </summary>
 2632:         public static List<int> GatewayIdFromAgcfGatewayRecordIdListList(List<int> agcfGatewayRecordIdList)
 2633:         {
 2634:             List<int> list;
 2635:  
 2636:             if (agcfGatewayRecordIdList.Count > 0)
 2637:             {
 2638:                 using (var db = new Ia.Ftn.Cl.Db())
 2639:                 {
 2640:                     list = (from gr in db.AgcfGatewayRecords
 2641:                             where agcfGatewayRecordIdList.Contains(gr.Id)
 2642:                             select gr.GwId).ToList();
 2643:                 }
 2644:             }
 2645:             else list = new List<int>();
 2646:  
 2647:             return list.Distinct().ToList();
 2648:         }
 2649:  
 2650:         ////////////////////////////////////////////////////////////////////////////
 2651:  
 2652:         /// <summary>
 2653:         /// 
 2654:         /// </summary>
 2655:         public static List<string> AgcfEndpointIdListFromAgcfGatewayRecordIdList(List<int> agcfGatewayRecordIdList)
 2656:         {
 2657:             List<string> list;
 2658:  
 2659:             using (var db = new Ia.Ftn.Cl.Db())
 2660:             {
 2661:                 if (agcfGatewayRecordIdList.Count > 0)
 2662:                 {
 2663:                     list = (from e in db.AgcfEndpoints
 2664:                             where agcfGatewayRecordIdList.Contains(e.AgcfGatewayRecord.Id) && e.AgcfGatewayRecord != null
 2665:                             select e.Id).AsNoTracking().ToList();
 2666:                 }
 2667:                 else list = new List<string>();
 2668:             }
 2669:  
 2670:             return list.Distinct().ToList();
 2671:         }
 2672:  
 2673:         ////////////////////////////////////////////////////////////////////////////
 2674:         ////////////////////////////////////////////////////////////////////////////
 2675:  
 2676:         /// <summary>
 2677:         /// 
 2678:         /// </summary>
 2679:         public static List<string> MgwIdListFromAsbrIdList(List<string> asbrIdList)
 2680:         {
 2681:             List<string> list;
 2682:  
 2683:             using (var db = new Ia.Ftn.Cl.Db())
 2684:             {
 2685:                 if (asbrIdList.Count > 0)
 2686:                 {
 2687:                     /* this is just dumb!
 2688:                     list = (from m in db.Mgws
 2689:                             join a in db.Asbrs on m.Id equals a.Mgw.Id
 2690:                             where asbrIdList.Contains(a.Id)
 2691:                             select m.Id).ToList();
 2692:                     */
 2693:  
 2694:                     list = (from a in db.Asbrs
 2695:                             where asbrIdList.Contains(a.Id) && a.Mgw != null
 2696:                             select a.Mgw.Id).AsNoTracking().ToList();
 2697:                 }
 2698:                 else list = new List<string>();
 2699:             }
 2700:  
 2701:             return list.Distinct().ToList();
 2702:         }
 2703:  
 2704:         ////////////////////////////////////////////////////////////////////////////
 2705:  
 2706:         /// <summary>
 2707:         /// 
 2708:         /// </summary>
 2709:         public static List<string> MgwIdListFromIpList(List<string> ipList)
 2710:         {
 2711:             List<string> list, idList;
 2712:  
 2713:             using (var db = new Ia.Ftn.Cl.Db())
 2714:             {
 2715:                 if (ipList.Count > 0)
 2716:                 {
 2717:                     // below is very slow
 2718:                     //list = (from m in db.Mgws where ipList.Contains(m.RA1) select m.Id).AsNoTracking().ToList();
 2719:  
 2720:                     // I will use the fact the Id have the IP in the middle
 2721:                     // see mgwId = Ia.Ftn.Cl.Model.Business.Huawei.Mgw.MgwId(response.NetworkElement, eid);
 2722:  
 2723:                     idList = new List<string>();
 2724:  
 2725:                     foreach (var ip in ipList)
 2726:                     {
 2727:                         idList.Add(Ia.Ftn.Cl.Models.Business.Huawei.SoftX.TecNetworkElement.Domain + ":" + ip + ":" + Ia.Ftn.Cl.Models.Business.Huawei.SoftX.RemotePort);
 2728:                         idList.Add(Ia.Ftn.Cl.Models.Business.Huawei.SoftX.SkbNetworkElement.Domain + ":" + ip + ":" + Ia.Ftn.Cl.Models.Business.Huawei.SoftX.RemotePort);
 2729:                     }
 2730:  
 2731:                     list = (from m in db.Mgws
 2732:                             where idList.Contains(m.Id)
 2733:                             select m.Id).AsNoTracking().ToList();
 2734:                 }
 2735:                 else list = new List<string>();
 2736:             }
 2737:  
 2738:             return list.Distinct().ToList();
 2739:         }
 2740:  
 2741:         ////////////////////////////////////////////////////////////////////////////
 2742:  
 2743:         /// <summary>
 2744:         /// 
 2745:         /// </summary>
 2746:         public static List<string> MgwIpListFromIdList(List<string> mgwIdList)
 2747:         {
 2748:             List<string> list;
 2749:  
 2750:             using (var db = new Ia.Ftn.Cl.Db())
 2751:             {
 2752:                 if (mgwIdList.Count > 0)
 2753:                 {
 2754:                     list = (from m in db.Mgws
 2755:                             where mgwIdList.Contains(m.Id)
 2756:                             select m.RA1).AsNoTracking().ToList();
 2757:                 }
 2758:                 else list = new List<string>();
 2759:             }
 2760:  
 2761:             return list.Distinct().ToList();
 2762:         }
 2763:  
 2764:         ////////////////////////////////////////////////////////////////////////////
 2765:  
 2766:         /// <summary>
 2767:         /// 
 2768:         /// </summary>
 2769:         public static List<string> AsbrIdListFromImpuSipDomainList(List<string> impuSipDomainList)
 2770:         {
 2771:             string id;
 2772:             List<string> list, asbrIdInTecAndSkbNetworkElementList;
 2773:  
 2774:             if (impuSipDomainList.Count > 0)
 2775:             {
 2776:                 asbrIdInTecAndSkbNetworkElementList = new List<string>(impuSipDomainList.Count * 2);
 2777:  
 2778:                 foreach (var isd in impuSipDomainList)
 2779:                 {
 2780:                     id = Ia.Ftn.Cl.Models.Business.Huawei.Asbr.AsbrId(Ia.Ftn.Cl.Models.Business.Huawei.SoftX.TecNetworkElement.Domain, isd);
 2781:                     asbrIdInTecAndSkbNetworkElementList.Add(id);
 2782:  
 2783:                     id = Ia.Ftn.Cl.Models.Business.Huawei.Asbr.AsbrId(Ia.Ftn.Cl.Models.Business.Huawei.SoftX.SkbNetworkElement.Domain, isd);
 2784:                     asbrIdInTecAndSkbNetworkElementList.Add(id);
 2785:                 }
 2786:  
 2787:                 using (var db = new Ia.Ftn.Cl.Db())
 2788:                 {
 2789:                     list = (from a in db.Asbrs
 2790:                             where asbrIdInTecAndSkbNetworkElementList.Contains(a.Id)
 2791:                             select a.Id).AsNoTracking().ToList();
 2792:                 }
 2793:             }
 2794:             else list = new List<string>();
 2795:  
 2796:             return list.Distinct().ToList();
 2797:         }
 2798:  
 2799:         ////////////////////////////////////////////////////////////////////////////
 2800:         ////////////////////////////////////////////////////////////////////////////
 2801:  
 2802:         /// <summary>
 2803:         /// 
 2804:         /// </summary>
 2805:         public static List<string> AgcfEndpointIdListFromSubPartyIdList(List<string> subPartyIdList)
 2806:         {
 2807:             List<string> list;
 2808:  
 2809:             using (var db = new Ia.Ftn.Cl.Db())
 2810:             {
 2811:                 if (subPartyIdList.Count > 0)
 2812:                 {
 2813:                     list = (from sp in db.SubParties
 2814:                             where subPartyIdList.Contains(sp.Id)
 2815:                             select sp.AgcfEndpoint.Id).AsNoTracking().ToList();
 2816:                 }
 2817:                 else list = new List<string>();
 2818:             }
 2819:  
 2820:             return list.Distinct().ToList();
 2821:         }
 2822:  
 2823:         ////////////////////////////////////////////////////////////////////////////
 2824:  
 2825:         /// <summary>
 2826:         /// 
 2827:         /// </summary>
 2828:         public static List<string> AgcfEndpointIdListFromPrividUserList(List<string> prividUserList)
 2829:         {
 2830:             List<string> list0, list;
 2831:  
 2832:             using (var db = new Ia.Ftn.Cl.Db())
 2833:             {
 2834:                 if (prividUserList.Count > 0)
 2835:                 {
 2836:                     list0 = new List<string>();
 2837:  
 2838:                     foreach (var prividUser in prividUserList)
 2839:                     {
 2840:                         list0.Add(Ia.Ftn.Cl.Models.Nokia.AgcfEndpoint.AgcfEndpointId(prividUser));
 2841:                     }
 2842:  
 2843:                     list = (from ep in db.AgcfEndpoints
 2844:                                 //where prividUserList.Contains(ep.PrividUser)
 2845:                             where list0.Contains(ep.Id)
 2846:                             select ep.Id).AsNoTracking().ToList();
 2847:                 }
 2848:                 else list = new List<string>();
 2849:             }
 2850:  
 2851:             return list.Distinct().ToList();
 2852:         }
 2853:  
 2854:         ////////////////////////////////////////////////////////////////////////////
 2855:  
 2856:         /// <summary>
 2857:         /// 
 2858:         /// </summary>
 2859:         public static List<string> AgcfEndpointIdListFromGatewayIdList(List<int> gatewayIdList)
 2860:         {
 2861:             List<string> list;
 2862:  
 2863:             using (var db = new Ia.Ftn.Cl.Db())
 2864:             {
 2865:                 if (gatewayIdList.Count > 0)
 2866:                 {
 2867:                     list = (from ep in db.AgcfEndpoints
 2868:                             where gatewayIdList.Contains(ep.GwId)
 2869:                             select ep.Id).AsNoTracking().ToList();
 2870:                 }
 2871:                 else list = new List<string>();
 2872:             }
 2873:  
 2874:             return list.Distinct().ToList();
 2875:         }
 2876:  
 2877:         ////////////////////////////////////////////////////////////////////////////
 2878:  
 2879:         /// <summary>
 2880:         /// 
 2881:         /// </summary>
 2882:         public static List<string> SubPartyIdListFromAgcfEndpointIdList(List<string> agcfEndpointIdList)
 2883:         {
 2884:             List<string> list;
 2885:  
 2886:             using (var db = new Ia.Ftn.Cl.Db())
 2887:             {
 2888:                 if (agcfEndpointIdList.Count > 0)
 2889:                 {
 2890:                     list = (from sp in db.SubParties
 2891:                             where agcfEndpointIdList.Contains(sp.AgcfEndpoint.Id) && sp.AgcfEndpoint != null
 2892:                             select sp.Id).AsNoTracking().ToList();
 2893:                 }
 2894:                 else list = new List<string>();
 2895:             }
 2896:  
 2897:             return list.Distinct().ToList();
 2898:         }
 2899:  
 2900:         ////////////////////////////////////////////////////////////////////////////
 2901:  
 2902:         /// <summary>
 2903:         /// 
 2904:         /// </summary>
 2905:         public static List<string> SubPartyIdListFromPartyIdList(List<string> partyIdList)
 2906:         {
 2907:             List<string> list;
 2908:  
 2909:             using (var db = new Ia.Ftn.Cl.Db())
 2910:             {
 2911:                 if (partyIdList.Count > 0)
 2912:                 {
 2913:                     list = (from sp in db.SubParties
 2914:                             where partyIdList.Contains(sp.PartyId)
 2915:                             select sp.Id).AsNoTracking().ToList();
 2916:                 }
 2917:                 else list = new List<string>();
 2918:             }
 2919:  
 2920:             return list.Distinct().ToList();
 2921:         }
 2922:  
 2923:         ////////////////////////////////////////////////////////////////////////////
 2924:  
 2925:         /// <summary>
 2926:         /// 
 2927:         /// </summary>
 2928:         public static List<string> SubscriberIdListFromSubPartyIdList(List<string> subPartyIdList)
 2929:         {
 2930:             List<string> list;
 2931:  
 2932:             using (var db = new Ia.Ftn.Cl.Db())
 2933:             {
 2934:                 if (subPartyIdList.Count > 0)
 2935:                 {
 2936:                     list = (from s in db.Subscribers
 2937:                             where subPartyIdList.Contains(s.SubParty.Id)
 2938:                             select s.Id).AsNoTracking().ToList();
 2939:                 }
 2940:                 else list = new List<string>();
 2941:             }
 2942:  
 2943:             return list.Distinct().ToList();
 2944:         }
 2945:  
 2946:         ////////////////////////////////////////////////////////////////////////////
 2947:  
 2948:         /// <summary>
 2949:         /// 
 2950:         /// </summary>
 2951:         public static List<string> SubscriberIdListFromPartyIdList(List<string> partyIdList)
 2952:         {
 2953:             List<string> list;
 2954:  
 2955:             using (var db = new Ia.Ftn.Cl.Db())
 2956:             {
 2957:                 if (partyIdList.Count > 0)
 2958:                 {
 2959:                     // note that Id is PartyId. Maybe I could use it subscriber.Id = Ia.Ftn.Cl.Model.Nokia.Subscriber.SubscriberId(partyId);
 2960:                     //list = (from s in db.Subscribers where partyIdList.Contains(s.PartyId) select s.Id).AsNoTracking().ToList();
 2961:                     list = (from s in db.Subscribers where partyIdList.Contains(s.Id) select s.Id).AsNoTracking().ToList();
 2962:                 }
 2963:                 else list = new List<string>();
 2964:             }
 2965:  
 2966:             return list.Distinct().ToList();
 2967:         }
 2968:  
 2969:         ////////////////////////////////////////////////////////////////////////////
 2970:  
 2971:         /// <summary>
 2972:         /// 
 2973:         /// </summary>
 2974:         public static List<string> ServiceListFromGatewayIdList(List<int> gatewayIdList)
 2975:         {
 2976:             List<string> list;
 2977:  
 2978:             using (var db = new Ia.Ftn.Cl.Db())
 2979:             {
 2980:                 if (gatewayIdList.Count > 0)
 2981:                 {
 2982:                     list = new List<string>();
 2983:  
 2984:                     var list0 = (from s in db.Subscribers
 2985:                                  join sp in db.SubParties on s.SubParty.Id equals sp.Id
 2986:                                  join ep in db.AgcfEndpoints on sp.AgcfEndpoint.Id equals ep.Id
 2987:                                  join gr in db.AgcfGatewayRecords on ep.AgcfGatewayRecord.Id equals gr.Id
 2988:                                  where gatewayIdList.Contains(gr.GwId)
 2989:                                  select s.PartyId).AsNoTracking().ToList();
 2990:  
 2991:                     foreach (var partyId in list0)
 2992:                     {
 2993:                         list.Add(Ia.Ftn.Cl.Models.Business.NumberFormatConverter.Service(partyId));
 2994:                     }
 2995:                 }
 2996:                 else list = new List<string>();
 2997:             }
 2998:  
 2999:             return list.Distinct().ToList();
 3000:         }
 3001:  
 3002:         ////////////////////////////////////////////////////////////////////////////
 3003:         ////////////////////////////////////////////////////////////////////////////   
 3004:  
 3005:         /// <summary>
 3006:         /// 
 3007:         /// </summary>
 3008:         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)
 3009:         {
 3010:             int number;
 3011:             long numberWithCountryCode;
 3012:             string service, impuSipDomain, sipUserName, serviceWithCountryCode, partyId, prividUser;
 3013:  
 3014:             foreach (var pi in partyIdList)
 3015:             {
 3016:                 service = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.Service(pi);
 3017:  
 3018:                 if (!string.IsNullOrEmpty(service))
 3019:                 {
 3020:                     number = int.Parse(service);
 3021:                     numberWithCountryCode = long.Parse(Ia.Ftn.Cl.Models.Business.Service.CountryCode.ToString() + number);
 3022:                     impuSipDomain = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.ImpuSipDomain(service);
 3023:                     sipUserName = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.SipUserName(service);
 3024:                     serviceWithCountryCode = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.ServiceWithCountryCode(service);
 3025:                     partyId = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.PartyId(service);
 3026:                     prividUser = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.PrividUser(service);
 3027:  
 3028:                     serviceList.Add(service);
 3029:                     numberList.Add(number);
 3030:                     serviceLongList.Add(numberWithCountryCode);
 3031:                     impuSipDomainList.Add(impuSipDomain);
 3032:                     sipUserNameList.Add(sipUserName);
 3033:                     serviceWithCountryCodeList.Add(serviceWithCountryCode);
 3034:                     //partyIdList.Add(partyId);
 3035:                     prividUserList.Add(prividUser);
 3036:                 }
 3037:             }
 3038:  
 3039:             foreach (var s in serviceList)
 3040:             {
 3041:                 service = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.Service(s);
 3042:  
 3043:                 if (!string.IsNullOrEmpty(service))
 3044:                 {
 3045:                     number = int.Parse(service);
 3046:                     numberWithCountryCode = long.Parse(Ia.Ftn.Cl.Models.Business.Service.CountryCode.ToString() + number);
 3047:                     impuSipDomain = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.ImpuSipDomain(service);
 3048:                     sipUserName = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.SipUserName(service);
 3049:                     serviceWithCountryCode = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.ServiceWithCountryCode(service);
 3050:                     partyId = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.PartyId(service);
 3051:                     prividUser = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.PrividUser(service);
 3052:  
 3053:                     //serviceList.Add(service);
 3054:                     numberList.Add(number);
 3055:                     serviceLongList.Add(numberWithCountryCode);
 3056:                     impuSipDomainList.Add(impuSipDomain);
 3057:                     sipUserNameList.Add(sipUserName);
 3058:                     serviceWithCountryCodeList.Add(serviceWithCountryCode);
 3059:                     partyIdList.Add(partyId);
 3060:                     prividUserList.Add(prividUser);
 3061:                 }
 3062:             }
 3063:  
 3064:             serviceList = serviceList.Distinct().ToList();
 3065:             numberList = numberList.Distinct().ToList();
 3066:             serviceLongList = serviceLongList.Distinct().ToList();
 3067:             impuSipDomainList = impuSipDomainList.Distinct().ToList();
 3068:             sipUserNameList = sipUserNameList.Distinct().ToList();
 3069:             serviceWithCountryCodeList = serviceWithCountryCodeList.Distinct().ToList();
 3070:             partyIdList = partyIdList.Distinct().ToList();
 3071:             prividUserList = prividUserList.Distinct().ToList();
 3072:  
 3073:             serviceIdList = Ia.Ftn.Cl.Models.Business.Service.ServiceListToServiceIdListForAllServiceTypes(serviceList);
 3074:         }
 3075:  
 3076:         ////////////////////////////////////////////////////////////////////////////   
 3077:  
 3078:         /// <summary>
 3079:         /// 
 3080:         /// </summary>
 3081:         public static void UpdateServiceListFromServiceRequestServiceIdOrService2IdList(List<string> serviceRequestServiceIdListOrService2IdList, ref List<string> serviceList)
 3082:         {
 3083:             string service;
 3084:  
 3085:             foreach (var si in serviceRequestServiceIdListOrService2IdList)
 3086:             {
 3087:                 service = Ia.Ftn.Cl.Models.Business.ServiceRequestService.ServiceIdToService(si);
 3088:  
 3089:                 if (!string.IsNullOrEmpty(service)) serviceList.Add(service);
 3090:             }
 3091:  
 3092:             serviceList = serviceList.Distinct().ToList();
 3093:         }
 3094:  
 3095:         ////////////////////////////////////////////////////////////////////////////   
 3096:  
 3097:         /// <summary>
 3098:         /// 
 3099:         /// </summary>
 3100:         public static void CollectServiceListFromEmsOntSipInfoListAndEmsVoipPstnUserListByEmsOntIdList(List<string> emsOntIdList, ref List<string> serviceList)
 3101:         {
 3102:             string service;
 3103:             List<string> emsOntSipInfoSipUserNameList, emsVoipPstnUserDnList;
 3104:  
 3105:             if (emsOntIdList.Count > 0)
 3106:             {
 3107:                 using (var db = new Ia.Ftn.Cl.Db())
 3108:                 {
 3109:                     emsOntSipInfoSipUserNameList = (from eosi in db.EmsOntSipInfoes
 3110:                                                     where emsOntIdList.Contains(eosi.EmsOnt.Id)
 3111:                                                     select eosi.SIPUSERNAME).AsNoTracking().ToList();
 3112:  
 3113:                     emsOntSipInfoSipUserNameList = emsOntSipInfoSipUserNameList.Distinct().ToList();
 3114:  
 3115:                     emsVoipPstnUserDnList = (from evpu in db.EmsVoipPstnUsers
 3116:                                              where evpu.EmsOnt != null && emsOntIdList.Contains(evpu.EmsOnt.Id)
 3117:                                              select evpu.DN).AsNoTracking().ToList();
 3118:  
 3119:                     emsVoipPstnUserDnList = emsVoipPstnUserDnList.Distinct().ToList();
 3120:                 }
 3121:  
 3122:                 foreach (var eosisun in emsOntSipInfoSipUserNameList)
 3123:                 {
 3124:                     service = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.Service(eosisun);
 3125:  
 3126:                     if (!string.IsNullOrEmpty(service)) serviceList.Add(service);
 3127:                 }
 3128:  
 3129:                 foreach (var evpud in emsVoipPstnUserDnList)
 3130:                 {
 3131:                     service = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.Service(evpud);
 3132:  
 3133:                     if (!string.IsNullOrEmpty(service)) serviceList.Add(service);
 3134:                 }
 3135:             }
 3136:             else
 3137:             {
 3138:  
 3139:             }
 3140:  
 3141:             serviceList = serviceList.Distinct().ToList();
 3142:         }
 3143:  
 3144:         ////////////////////////////////////////////////////////////////////////////   
 3145:  
 3146:         /// <summary>
 3147:         /// 
 3148:         /// </summary>
 3149:         public static void CollectServiceListFromAgcfEndpointList(List<Ia.Ftn.Cl.Models.Ui.Nokia.AgcfEndpoint> agcfEndpointList, ref List<string> serviceList)
 3150:         {
 3151:             string service;
 3152:  
 3153:             foreach (var ep in agcfEndpointList)
 3154:             {
 3155:                 service = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.Service(ep.PrividUser);
 3156:  
 3157:                 if (!string.IsNullOrEmpty(service)) serviceList.Add(service);
 3158:             }
 3159:  
 3160:             serviceList = serviceList.Distinct().ToList();
 3161:         }
 3162:  
 3163:         ////////////////////////////////////////////////////////////////////////////   
 3164:  
 3165:         /// <summary>
 3166:         /// 
 3167:         /// </summary>
 3168:         public static void CollectServiceListFromSubscriberList(List<Ia.Ftn.Cl.Models.Ui.Nokia.Subscriber> subscriberList, ref List<string> serviceList)
 3169:         {
 3170:             string service;
 3171:  
 3172:             foreach (var s in subscriberList)
 3173:             {
 3174:                 service = Ia.Ftn.Cl.Models.Business.NumberFormatConverter.Service(s.PartyId);
 3175:  
 3176:                 if (!string.IsNullOrEmpty(service)) serviceList.Add(service);
 3177:             }
 3178:  
 3179:             serviceList = serviceList.Distinct().ToList();
 3180:         }
 3181:  
 3182:         ////////////////////////////////////////////////////////////////////////////
 3183:         ////////////////////////////////////////////////////////////////////////////   
 3184:     }
 3185:  
 3186:     ////////////////////////////////////////////////////////////////////////////
 3187:     ////////////////////////////////////////////////////////////////////////////   
 3188: }