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