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

Integrated Applications Programming Company

Skip Navigation LinksHome » Code Library » Subscriber

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

Subscriber Entity Framework class for Optical Fiber Network (OFN) entity model.

   1:  using System;
   2:  using System.ComponentModel.DataAnnotations;
   3:  using System.ComponentModel.DataAnnotations.Schema;
   4:  using System.Xml.Linq;
   5:  using System.Linq;
   6:  using System.Threading.Tasks;
   7:  using System.Threading;
   8:   
   9:  namespace Ia.Ngn.Cl.Model.Nokia
  10:  {
  11:      ////////////////////////////////////////////////////////////////////////////
  12:   
  13:      /// <summary publish="true">
  14:      /// Subscriber Entity Framework class for Optical Fiber Network (OFN) entity model.
  15:      /// </summary>
  16:      /// 
  17:      /// <remarks> 
  18:      /// Copyright � 2014-2021 Jasem Y. Al-Shamlan (info@ia.com.kw), Integrated Applications - Kuwait. All Rights Reserved.
  19:      ///
  20:      /// This library is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by
  21:      /// the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  22:      ///
  23:      /// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  24:      /// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  25:      /// 
  26:      /// You should have received a copy of the GNU General Public License along with this library. If not, see http://www.gnu.org/licenses.
  27:      /// 
  28:      /// Copyright notice: This notice may not be removed or altered from any source distribution.
  29:      /// </remarks> 
  30:      public class Subscriber
  31:      {
  32:          /// <summary>
  33:          /// 1360 COM WebAPI User Guide 255-400-419R3.X
  34:          /// ngfs-subscriber-v2 (rtrv,ent,ed,dlt)
  35:          /// The ngfs-subscriber is a composite of the following groups. Each group is further defined in the subsections
  36:          /// below. PartyID is a unique identifier for a subscriber. PublicID, or PUID, is the public telephone number for the
  37:          /// telephone device. All PUIDs are E.164 numbers, including the leading +.
  38:          /// </summary>
  39:          public Subscriber() { }
  40:   
  41:          /// <summary/>
  42:          [Key, DatabaseGenerated(DatabaseGeneratedOption.None)]
  43:          public string Id { get; set; }
  44:   
  45:          /// <summary>
  46:          /// PartyId (req for ent,req for ed). LCP Name for Party record. String (1-27) [+0-9a-zA-Z:@&amp;=!,|-_.!~*()%]* Before CTS R5.0: [+0-9a-zA-Z:@&amp;=!,-_.!~*'()%]* LCP-CTS R6.1 From CTS R6.1: [+0-9a-zA-Z:@&amp;=,|-_.!~*'()%#?/$][]* If the String Ends with '[AutoSelect]', '[AutoSelectSTAS]', or '[AutoSelectDTAS]' The Subscriber will be automatically distributed to the TASs. When [AutoSelect],[AutoSelectDTAS] or [AutoSelectSTAS] is used in ent- request, AssocOtasRealm should be empty. And the OTAS which has fewest subscriber will be chosen as AssocOtasRealm. For non-ICS subscriber request (do not include iHss private id info), [AutoSelect] can be used. For the subscriber request which include iHss Private Id info, [AutoSelectDTAS] and [AutoSelectSTAS] can be used. And the Realm in OTAS must match the "ApplicateionServer" defined in iHss Global IFC and this IFC must be used by iHss Service profile. Otherwise, error will be reported thant no service profile for this OTAS. String length does not include length of '[AutoSelect]', '[AutoSelectSTAS]', and '[AutoSelectDTAS]'. LCP-CTS R6.2.1 The new partyId. Used for changing partyId. Only used for ed command. Range same as PartyId.
  47:          /// </summary>
  48:          public string PartyId { get; set; }
  49:   
  50:          /// <summary>
  51:          /// AlternateOtasRealm (opt for ent/ed). Alternate TAS that supports this party. String (0-63) [0-9a-zA-Z\.\-]* If the string equals to '[AutoSelect]', the protection subscriber will be automatically distributed to the TASs.
  52:          /// </summary>
  53:          public string AlternateOtasRealm { get; set; }
  54:   
  55:          /// <summary>
  56:          /// AnonymousCallRej
  57:          /// </summary>
  58:          [Column(TypeName = "xml")]
  59:          public string _AnonymousCallRej { get; set; }
  60:          [NotMapped]
  61:          public XElement AnonymousCallRej
  62:          {
  63:              get { return XElement.Parse(_AnonymousCallRej); }
  64:              set { _AnonymousCallRej = value.ToString(); }
  65:          }
  66:   
  67:          /// <summary>
  68:          /// SelectiveCallRejct
  69:          /// </summary>
  70:          [Column(TypeName = "xml")]
  71:          public string _SelectiveCallRejct { get; set; }
  72:   
  73:          [NotMapped]
  74:          public XElement SelectiveCallRejct
  75:          {
  76:              get { return XElement.Parse(_SelectiveCallRejct); }
  77:              set { _SelectiveCallRejct = value.ToString(); }
  78:          }
  79:   
  80:          /// <summary>
  81:          /// SelectiveCallAcpt
  82:          /// </summary>
  83:          [Column(TypeName = "xml")]
  84:          public string _SelectiveCallAcpt { get; set; }
  85:   
  86:          [NotMapped]
  87:          public XElement SelectiveCallAcpt
  88:          {
  89:              get { return XElement.Parse(_SelectiveCallAcpt); }
  90:              set { _SelectiveCallAcpt = value.ToString(); }
  91:          }
  92:   
  93:          /// <summary>
  94:          /// AutomaticCallBack
  95:          /// </summary>
  96:          [Column(TypeName = "xml")]
  97:          public string _AutomaticCallBack { get; set; }
  98:   
  99:          [NotMapped]
 100:          public XElement AutomaticCallBack
 101:          {
 102:              get { return XElement.Parse(_AutomaticCallBack); }
 103:              set { _AutomaticCallBack = value.ToString(); }
 104:          }
 105:   
 106:          /// <summary>
 107:          /// AutomaticRecall
 108:          /// </summary>
 109:          [Column(TypeName = "xml")]
 110:          public string _AutomaticRecall { get; set; }
 111:   
 112:          [NotMapped]
 113:          public XElement AutomaticRecall
 114:          {
 115:              get { return XElement.Parse(_AutomaticRecall); }
 116:              set { _AutomaticRecall = value.ToString(); }
 117:          }
 118:   
 119:          /// <summary>
 120:          /// CallingLineId
 121:          /// </summary>
 122:          [Column(TypeName = "xml")]
 123:          public string _CallingLineId { get; set; }
 124:   
 125:          [NotMapped]
 126:          public XElement CallingLineId
 127:          {
 128:              get { return XElement.Parse(_CallingLineId); }
 129:              set { _CallingLineId = value.ToString(); }
 130:          }
 131:   
 132:          /// <summary>
 133:          /// RemoteAccessServer
 134:          /// </summary>
 135:          [Column(TypeName = "xml")]
 136:          public string _RemoteAccessServer { get; set; }
 137:   
 138:          [NotMapped]
 139:          public XElement RemoteAccessServer
 140:          {
 141:              get { return XElement.Parse(_RemoteAccessServer); }
 142:              set { _RemoteAccessServer = value.ToString(); }
 143:          }
 144:   
 145:          /// <summary>
 146:          /// CallBarring
 147:          /// </summary>
 148:          [Column(TypeName = "xml")]
 149:          public string _CallBarring { get; set; }
 150:   
 151:          [NotMapped]
 152:          public XElement CallBarring
 153:          {
 154:              get { return XElement.Parse(_CallBarring); }
 155:              set { _CallBarring = value.ToString(); }
 156:          }
 157:   
 158:          /// <summary>
 159:          /// CallBlocking
 160:          /// </summary>
 161:          [Column(TypeName = "xml")]
 162:          public string _CallBlocking { get; set; }
 163:   
 164:          [NotMapped]
 165:          public XElement CallBlocking
 166:          {
 167:              get { return XElement.Parse(_CallBlocking); }
 168:              set { _CallBlocking = value.ToString(); }
 169:          }
 170:   
 171:          /// <summary>
 172:          /// CallTransfer
 173:          /// </summary>
 174:          [Column(TypeName = "xml")]
 175:          public string _CallTransfer { get; set; }
 176:   
 177:          [NotMapped]
 178:          public XElement CallTransfer
 179:          {
 180:              get { return XElement.Parse(_CallTransfer); }
 181:              set { _CallTransfer = value.ToString(); }
 182:          }
 183:   
 184:          /// <summary>
 185:          /// CallWaiting
 186:          /// </summary>
 187:          [Column(TypeName = "xml")]
 188:          public string _CallWaiting { get; set; }
 189:   
 190:          [NotMapped]
 191:          public XElement CallWaiting
 192:          {
 193:              get { return XElement.Parse(_CallWaiting); }
 194:              set { _CallWaiting = value.ToString(); }
 195:          }
 196:   
 197:          /// <summary>
 198:          /// CallForwardingVari
 199:          /// </summary>
 200:          [Column(TypeName = "xml")]
 201:          public string _CallForwardingVari { get; set; }
 202:   
 203:          [NotMapped]
 204:          public XElement CallForwardingVari
 205:          {
 206:              get { return XElement.Parse(_CallForwardingVari); }
 207:              set { _CallForwardingVari = value.ToString(); }
 208:          }
 209:   
 210:          /// <summary>
 211:          /// CallForwardingBusy
 212:          /// </summary>
 213:          [Column(TypeName = "xml")]
 214:          public string _CallForwardingBusy { get; set; }
 215:   
 216:          [NotMapped]
 217:          public XElement CallForwardingBusy
 218:          {
 219:              get { return XElement.Parse(_CallForwardingBusy); }
 220:              set { _CallForwardingBusy = value.ToString(); }
 221:          }
 222:   
 223:          /// <summary>
 224:          /// CallForwardingNoAns
 225:          /// </summary>
 226:          [Column(TypeName = "xml")]
 227:          public string _CallForwardingNoAns { get; set; }
 228:   
 229:          [NotMapped]
 230:          public XElement CallForwardingNoAns
 231:          {
 232:              get { return XElement.Parse(_CallForwardingNoAns); }
 233:              set { _CallForwardingNoAns = value.ToString(); }
 234:          }
 235:   
 236:          /// <summary>
 237:          /// SelectiveCallFwd
 238:          /// </summary>
 239:          [Column(TypeName = "xml")]
 240:          public string _SelectiveCallFwd { get; set; }
 241:   
 242:          [NotMapped]
 243:          public XElement SelectiveCallFwd
 244:          {
 245:              get { return XElement.Parse(_SelectiveCallFwd); }
 246:              set { _SelectiveCallFwd = value.ToString(); }
 247:          }
 248:   
 249:          /// <summary>
 250:          /// CallForwardingUnreg
 251:          /// </summary>
 252:          [Column(TypeName = "xml")]
 253:          public string _CallForwardingUnreg { get; set; }
 254:   
 255:          [NotMapped]
 256:          public XElement CallForwardingUnreg
 257:          {
 258:              get { return XElement.Parse(_CallForwardingUnreg); }
 259:              set { _CallForwardingUnreg = value.ToString(); }
 260:          }
 261:   
 262:          /// <summary>
 263:          /// CustomerOrigTrace
 264:          /// </summary>
 265:          [Column(TypeName = "xml")]
 266:          public string _CustomerOrigTrace { get; set; }
 267:   
 268:          [NotMapped]
 269:          public XElement CustomerOrigTrace
 270:          {
 271:              get { return XElement.Parse(_CustomerOrigTrace); }
 272:              set { _CustomerOrigTrace = value.ToString(); }
 273:          }
 274:   
 275:          /// <summary>
 276:          /// NuisanceCallTrace
 277:          /// </summary>
 278:          [Column(TypeName = "xml")]
 279:          public string _NuisanceCallTrace { get; set; }
 280:   
 281:          [NotMapped]
 282:          public XElement NuisanceCallTrace
 283:          {
 284:              get { return XElement.Parse(_NuisanceCallTrace); }
 285:              set { _NuisanceCallTrace = value.ToString(); }
 286:          }
 287:   
 288:          /// <summary>
 289:          /// DoNotDisturb
 290:          /// </summary>
 291:          [Column(TypeName = "xml")]
 292:          public string _DoNotDisturb { get; set; }
 293:   
 294:          [NotMapped]
 295:          public XElement DoNotDisturb
 296:          {
 297:              get { return XElement.Parse(_DoNotDisturb); }
 298:              set { _DoNotDisturb = value.ToString(); }
 299:          }
 300:   
 301:          /// <summary>
 302:          /// MsgWaitingInd
 303:          /// </summary>
 304:          [Column(TypeName = "xml")]
 305:          public string _MsgWaitingInd { get; set; }
 306:   
 307:          [NotMapped]
 308:          public XElement MsgWaitingInd
 309:          {
 310:              get { return XElement.Parse(_MsgWaitingInd); }
 311:              set { _MsgWaitingInd = value.ToString(); }
 312:          }
 313:   
 314:          /// <summary>
 315:          /// SimultaneousRinging
 316:          /// </summary>
 317:          [Column(TypeName = "xml")]
 318:          public string _SimultaneousRinging { get; set; }
 319:   
 320:          [NotMapped]
 321:          public XElement SimultaneousRinging
 322:          {
 323:              get { return XElement.Parse(_SimultaneousRinging); }
 324:              set { _SimultaneousRinging = value.ToString(); }
 325:          }
 326:   
 327:          /// <summary>
 328:          /// WebPortal
 329:          /// </summary>
 330:          [Column(TypeName = "xml")]
 331:          public string _WebPortal { get; set; }
 332:   
 333:          [NotMapped]
 334:          public XElement WebPortal
 335:          {
 336:              get { return XElement.Parse(_WebPortal); }
 337:              set { _WebPortal = value.ToString(); }
 338:          }
 339:   
 340:          /// <summary>
 341:          /// ConferenceCalling
 342:          /// </summary>
 343:          [Column(TypeName = "xml")]
 344:          public string _ConferenceCalling { get; set; }
 345:   
 346:          [NotMapped]
 347:          public XElement ConferenceCalling
 348:          {
 349:              get { return XElement.Parse(_ConferenceCalling); }
 350:              set { _ConferenceCalling = value.ToString(); }
 351:          }
 352:   
 353:          /// <summary>
 354:          /// FlashOrigServices
 355:          /// </summary>
 356:          [Column(TypeName = "xml")]
 357:          public string _FlashOrigServices { get; set; }
 358:   
 359:          [NotMapped]
 360:          public XElement FlashOrigServices
 361:          {
 362:              get { return XElement.Parse(_FlashOrigServices); }
 363:              set { _FlashOrigServices = value.ToString(); }
 364:          }
 365:   
 366:          /// <summary>
 367:          /// CarrierSelection
 368:          /// </summary>
 369:          [Column(TypeName = "xml")]
 370:          public string _CarrierSelection { get; set; }
 371:   
 372:          [NotMapped]
 373:          public XElement CarrierSelection
 374:          {
 375:              get { return XElement.Parse(_CarrierSelection); }
 376:              set { _CarrierSelection = value.ToString(); }
 377:          }
 378:   
 379:          /// <summary>
 380:          /// RingbackWhenFree
 381:          /// </summary>
 382:          [Column(TypeName = "xml")]
 383:          public string _RingbackWhenFree { get; set; }
 384:   
 385:          [NotMapped]
 386:          public XElement RingbackWhenFree
 387:          {
 388:              get { return XElement.Parse(_RingbackWhenFree); }
 389:              set { _RingbackWhenFree = value.ToString(); }
 390:          }
 391:   
 392:          /// <summary>
 393:          /// MultipleRingPattern
 394:          /// </summary>
 395:          [Column(TypeName = "xml")]
 396:          public string _MultipleRingPattern { get; set; }
 397:   
 398:          [NotMapped]
 399:          public XElement MultipleRingPattern
 400:          {
 401:              get { return XElement.Parse(_MultipleRingPattern); }
 402:              set { _MultipleRingPattern = value.ToString(); }
 403:          }
 404:   
 405:          /// <summary>
 406:          /// CallForwardingLocal
 407:          /// </summary>
 408:          [Column(TypeName = "xml")]
 409:          public string _CallForwardingLocal { get; set; }
 410:   
 411:          [NotMapped]
 412:          public XElement CallForwardingLocal
 413:          {
 414:              get { return XElement.Parse(_CallForwardingLocal); }
 415:              set { _CallForwardingLocal = value.ToString(); }
 416:          }
 417:   
 418:          /// <summary>
 419:          /// RemoteAccessServices
 420:          /// </summary>
 421:          [Column(TypeName = "xml")]
 422:          public string _RemoteAccessServices { get; set; }
 423:   
 424:          [NotMapped]
 425:          public XElement RemoteAccessServices
 426:          {
 427:              get { return XElement.Parse(_RemoteAccessServices); }
 428:              set { _RemoteAccessServices = value.ToString(); }
 429:          }
 430:   
 431:          /// <summary>
 432:          /// VoiceMail
 433:          /// </summary>
 434:          [Column(TypeName = "xml")]
 435:          public string _VoiceMail { get; set; }
 436:   
 437:          [NotMapped]
 438:          public XElement VoiceMail
 439:          {
 440:              get { return XElement.Parse(_VoiceMail); }
 441:              set { _VoiceMail = value.ToString(); }
 442:          }
 443:   
 444:          /// <summary>
 445:          /// InterceptReferral
 446:          /// </summary>
 447:          [Column(TypeName = "xml")]
 448:          public string _InterceptReferral { get; set; }
 449:   
 450:          [NotMapped]
 451:          public XElement InterceptReferral
 452:          {
 453:              get { return XElement.Parse(_InterceptReferral); }
 454:              set { _InterceptReferral = value.ToString(); }
 455:          }
 456:   
 457:          /// <summary>
 458:          /// DialingPlan
 459:          /// </summary>
 460:          [Column(TypeName = "xml")]
 461:          public string _DialingPlan { get; set; }
 462:   
 463:          [NotMapped]
 464:          public XElement DialingPlan
 465:          {
 466:              get { return XElement.Parse(_DialingPlan); }
 467:              set { _DialingPlan = value.ToString(); }
 468:          }
 469:   
 470:          /// <summary>
 471:          /// HSSPrivateId
 472:          /// </summary>
 473:          [Column(TypeName = "xml")]
 474:          public string _HSSPrivateId { get; set; }
 475:   
 476:          [NotMapped]
 477:          public XElement HSSPrivateId
 478:          {
 479:              get { return XElement.Parse(_HSSPrivateId); }
 480:              set { _HSSPrivateId = value.ToString(); }
 481:          }
 482:   
 483:          /// <summary>
 484:          /// HSSPublicIdCustom
 485:          /// </summary>
 486:          [Column(TypeName = "xml")]
 487:          public string _HSSPublicIdCustom { get; set; }
 488:   
 489:          [NotMapped]
 490:          public XElement HSSPublicIdCustom
 491:          {
 492:              get { return XElement.Parse(_HSSPublicIdCustom); }
 493:              set { _HSSPublicIdCustom = value.ToString(); }
 494:          }
 495:   
 496:          /// <summary>
 497:          /// AcctCodes
 498:          /// </summary>
 499:          [Column(TypeName = "xml")]
 500:          public string _AcctCodes { get; set; }
 501:   
 502:          [NotMapped]
 503:          public XElement AcctCodes
 504:          {
 505:              get { return XElement.Parse(_AcctCodes); }
 506:              set { _AcctCodes = value.ToString(); }
 507:          }
 508:   
 509:          /// <summary>
 510:          /// SeqRinging
 511:          /// </summary>
 512:          [Column(TypeName = "xml")]
 513:          public string _SeqRinging { get; set; }
 514:   
 515:          [NotMapped]
 516:          public XElement SeqRinging
 517:          {
 518:              get { return XElement.Parse(_SeqRinging); }
 519:              set { _SeqRinging = value.ToString(); }
 520:          }
 521:   
 522:          /// <summary>
 523:          /// AuthCodeService
 524:          /// </summary>
 525:          [Column(TypeName = "xml")]
 526:          public string _AuthCodeService { get; set; }
 527:   
 528:          [NotMapped]
 529:          public XElement AuthCodeService
 530:          {
 531:              get { return XElement.Parse(_AuthCodeService); }
 532:              set { _AuthCodeService = value.ToString(); }
 533:          }
 534:   
 535:          /// <summary>
 536:          /// MLHGNoHuntMember
 537:          /// </summary>
 538:          [Column(TypeName = "xml")]
 539:          public string _MLHGNoHuntMember { get; set; }
 540:   
 541:          [NotMapped]
 542:          public XElement MLHGNoHuntMember
 543:          {
 544:              get { return XElement.Parse(_MLHGNoHuntMember); }
 545:              set { _MLHGNoHuntMember = value.ToString(); }
 546:          }
 547:   
 548:          /// <summary>
 549:          /// MultilineHuntGroup
 550:          /// </summary>
 551:          [Column(TypeName = "xml")]
 552:          public string _MultilineHuntGroup { get; set; }
 553:   
 554:          [NotMapped]
 555:          public XElement MultilineHuntGroup
 556:          {
 557:              get { return XElement.Parse(_MultilineHuntGroup); }
 558:              set { _MultilineHuntGroup = value.ToString(); }
 559:          }
 560:   
 561:          /// <summary>
 562:          /// CallPickupOrig
 563:          /// </summary>
 564:          [Column(TypeName = "xml")]
 565:          public string _CallPickupOrig { get; set; }
 566:   
 567:          [NotMapped]
 568:          public XElement CallPickupOrig
 569:          {
 570:              get { return XElement.Parse(_CallPickupOrig); }
 571:              set { _CallPickupOrig = value.ToString(); }
 572:          }
 573:   
 574:          /// <summary>
 575:          /// CallPickupTerm
 576:          /// </summary>
 577:          [Column(TypeName = "xml")]
 578:          public string _CallPickupTerm { get; set; }
 579:   
 580:          [NotMapped]
 581:          public XElement CallPickupTerm
 582:          {
 583:              get { return XElement.Parse(_CallPickupTerm); }
 584:              set { _CallPickupTerm = value.ToString(); }
 585:          }
 586:   
 587:          /// <summary>
 588:          /// Attendant
 589:          /// </summary>
 590:          [Column(TypeName = "xml")]
 591:          public string _Attendant { get; set; }
 592:   
 593:          [NotMapped]
 594:          public XElement Attendant
 595:          {
 596:              get { return XElement.Parse(_Attendant); }
 597:              set { _Attendant = value.ToString(); }
 598:          }
 599:   
 600:          /// <summary>
 601:          /// AttendantServer
 602:          /// </summary>
 603:          [Column(TypeName = "xml")]
 604:          public string _AttendantServer { get; set; }
 605:   
 606:          [NotMapped]
 607:          public XElement AttendantServer
 608:          {
 609:              get { return XElement.Parse(_AttendantServer); }
 610:              set { _AttendantServer = value.ToString(); }
 611:          }
 612:   
 613:          /// <summary>
 614:          /// CallPark
 615:          /// </summary>
 616:          [Column(TypeName = "xml")]
 617:          public string _CallPark { get; set; }
 618:   
 619:          [NotMapped]
 620:          public XElement CallPark
 621:          {
 622:              get { return XElement.Parse(_CallPark); }
 623:              set { _CallPark = value.ToString(); }
 624:          }
 625:   
 626:          /// <summary>
 627:          /// DirectedGroup
 628:          /// </summary>
 629:          [Column(TypeName = "xml")]
 630:          public string _DirectedGroup { get; set; }
 631:   
 632:          [NotMapped]
 633:          public XElement DirectedGroup
 634:          {
 635:              get { return XElement.Parse(_DirectedGroup); }
 636:              set { _DirectedGroup = value.ToString(); }
 637:          }
 638:   
 639:          /// <summary>
 640:          /// RemoteUser
 641:          /// </summary>
 642:          [Column(TypeName = "xml")]
 643:          public string _RemoteUser { get; set; }
 644:   
 645:          [NotMapped]
 646:          public XElement RemoteUser
 647:          {
 648:              get { return XElement.Parse(_RemoteUser); }
 649:              set { _RemoteUser = value.ToString(); }
 650:          }
 651:   
 652:          /// <summary>
 653:          /// TransferToUsersVM
 654:          /// </summary>
 655:          [Column(TypeName = "xml")]
 656:          public string _TransferToUsersVM { get; set; }
 657:   
 658:          [NotMapped]
 659:          public XElement TransferToUsersVM
 660:          {
 661:              get { return XElement.Parse(_TransferToUsersVM); }
 662:              set { _TransferToUsersVM = value.ToString(); }
 663:          }
 664:   
 665:          /// <summary>
 666:          /// FlexCallingLineId
 667:          /// </summary>
 668:          [Column(TypeName = "xml")]
 669:          public string _FlexCallingLineId { get; set; }
 670:   
 671:          [NotMapped]
 672:          public XElement FlexCallingLineId
 673:          {
 674:              get { return XElement.Parse(_FlexCallingLineId); }
 675:              set { _FlexCallingLineId = value.ToString(); }
 676:          }
 677:   
 678:          /// <summary>
 679:          /// ExtensionDevice
 680:          /// </summary>
 681:          [Column(TypeName = "xml")]
 682:          public string _ExtensionDevice { get; set; }
 683:   
 684:          [NotMapped]
 685:          public XElement ExtensionDevice
 686:          {
 687:              get { return XElement.Parse(_ExtensionDevice); }
 688:              set { _ExtensionDevice = value.ToString(); }
 689:          }
 690:   
 691:          /// <summary>
 692:          /// PSIServer
 693:          /// </summary>
 694:          [Column(TypeName = "xml")]
 695:          public string _PSIServer { get; set; }
 696:   
 697:          [NotMapped]
 698:          public XElement PSIServer
 699:          {
 700:              get { return XElement.Parse(_PSIServer); }
 701:              set { _PSIServer = value.ToString(); }
 702:          }
 703:   
 704:          /// <summary>
 705:          /// ClosedUserGroup
 706:          /// </summary>
 707:          [Column(TypeName = "xml")]
 708:          public string _ClosedUserGroup { get; set; }
 709:   
 710:          [NotMapped]
 711:          public XElement ClosedUserGroup
 712:          {
 713:              get { return XElement.Parse(_ClosedUserGroup); }
 714:              set { _ClosedUserGroup = value.ToString(); }
 715:          }
 716:   
 717:          /// <summary>
 718:          /// OneDigitSpeedDial
 719:          /// </summary>
 720:          [Column(TypeName = "xml")]
 721:          public string _OneDigitSpeedDial { get; set; }
 722:   
 723:          [NotMapped]
 724:          public XElement OneDigitSpeedDial
 725:          {
 726:              get { return XElement.Parse(_OneDigitSpeedDial); }
 727:              set { _OneDigitSpeedDial = value.ToString(); }
 728:          }
 729:   
 730:          /// <summary>
 731:          /// TwoDigitSpeedDial
 732:          /// </summary>
 733:          [Column(TypeName = "xml")]
 734:          public string _TwoDigitSpeedDial { get; set; }
 735:   
 736:          [NotMapped]
 737:          public XElement TwoDigitSpeedDial
 738:          {
 739:              get { return XElement.Parse(_TwoDigitSpeedDial); }
 740:              set { _TwoDigitSpeedDial = value.ToString(); }
 741:          }
 742:   
 743:          /// <summary>
 744:          /// ExtensionServer
 745:          /// </summary>
 746:          [Column(TypeName = "xml")]
 747:          public string _ExtensionServer { get; set; }
 748:   
 749:          [NotMapped]
 750:          public XElement ExtensionServer
 751:          {
 752:              get { return XElement.Parse(_ExtensionServer); }
 753:              set { _ExtensionServer = value.ToString(); }
 754:          }
 755:   
 756:          /// <summary>
 757:          /// SelectiveAlert
 758:          /// </summary>
 759:          [Column(TypeName = "xml")]
 760:          public string _SelectiveAlert { get; set; }
 761:   
 762:          [NotMapped]
 763:          public XElement SelectiveAlert
 764:          {
 765:              get { return XElement.Parse(_SelectiveAlert); }
 766:              set { _SelectiveAlert = value.ToString(); }
 767:          }
 768:   
 769:          /// <summary>
 770:          /// ShortCodeTranslate
 771:          /// </summary>
 772:          [Column(TypeName = "xml")]
 773:          public string _ShortCodeTranslate { get; set; }
 774:   
 775:          [NotMapped]
 776:          public XElement ShortCodeTranslate
 777:          {
 778:              get { return XElement.Parse(_ShortCodeTranslate); }
 779:              set { _ShortCodeTranslate = value.ToString(); }
 780:          }
 781:   
 782:          /// <summary>
 783:          /// ReminderCall
 784:          /// </summary>
 785:          [Column(TypeName = "xml")]
 786:          public string _ReminderCall { get; set; }
 787:   
 788:          [NotMapped]
 789:          public XElement ReminderCall
 790:          {
 791:              get { return XElement.Parse(_ReminderCall); }
 792:              set { _ReminderCall = value.ToString(); }
 793:          }
 794:   
 795:          /// <summary>
 796:          /// SetTZPath
 797:          /// </summary>
 798:          [Column(TypeName = "xml")]
 799:          public string _SetTZPath { get; set; }
 800:   
 801:          [NotMapped]
 802:          public XElement SetTZPath
 803:          {
 804:              get { return XElement.Parse(_SetTZPath); }
 805:              set { _SetTZPath = value.ToString(); }
 806:          }
 807:   
 808:          /// <summary>
 809:          /// InhibitIncomingFwd
 810:          /// </summary>
 811:          [Column(TypeName = "xml")]
 812:          public string _InhibitIncomingFwd { get; set; }
 813:   
 814:          [NotMapped]
 815:          public XElement InhibitIncomingFwd
 816:          {
 817:              get { return XElement.Parse(_InhibitIncomingFwd); }
 818:              set { _InhibitIncomingFwd = value.ToString(); }
 819:          }
 820:   
 821:          /// <summary>
 822:          /// BearerBasedCallFwd
 823:          /// </summary>
 824:          [Column(TypeName = "xml")]
 825:          public string _BearerBasedCallFwd { get; set; }
 826:   
 827:          [NotMapped]
 828:          public XElement BearerBasedCallFwd
 829:          {
 830:              get { return XElement.Parse(_BearerBasedCallFwd); }
 831:              set { _BearerBasedCallFwd = value.ToString(); }
 832:          }
 833:   
 834:          /// <summary>
 835:          /// TimeOriginatedRC
 836:          /// </summary>
 837:          [Column(TypeName = "xml")]
 838:          public string _TimeOriginatedRC { get; set; }
 839:   
 840:          [NotMapped]
 841:          public XElement TimeOriginatedRC
 842:          {
 843:              get { return XElement.Parse(_TimeOriginatedRC); }
 844:              set { _TimeOriginatedRC = value.ToString(); }
 845:          }
 846:   
 847:          /// <summary>
 848:          /// MobileDMS
 849:          /// </summary>
 850:          [Column(TypeName = "xml")]
 851:          public string _MobileDMS { get; set; }
 852:   
 853:          [NotMapped]
 854:          public XElement MobileDMS
 855:          {
 856:              get { return XElement.Parse(_MobileDMS); }
 857:              set { _MobileDMS = value.ToString(); }
 858:          }
 859:   
 860:          /// <summary>
 861:          /// MLPP
 862:          /// </summary>
 863:          [Column(TypeName = "xml")]
 864:          public string _MLPP { get; set; }
 865:   
 866:          [NotMapped]
 867:          public XElement MLPP
 868:          {
 869:              get { return XElement.Parse(_MLPP); }
 870:              set { _MLPP = value.ToString(); }
 871:          }
 872:   
 873:          /// <summary>
 874:          /// MusicOnHold
 875:          /// </summary>
 876:          [Column(TypeName = "xml")]
 877:          public string _MusicOnHold { get; set; }
 878:   
 879:          [NotMapped]
 880:          public XElement MusicOnHold
 881:          {
 882:              get { return XElement.Parse(_MusicOnHold); }
 883:              set { _MusicOnHold = value.ToString(); }
 884:          }
 885:   
 886:          /// <summary>
 887:          /// MiRingback
 888:          /// </summary>
 889:          [Column(TypeName = "xml")]
 890:          public string _MiRingback { get; set; }
 891:   
 892:          [NotMapped]
 893:          public XElement MiRingback
 894:          {
 895:              get { return XElement.Parse(_MiRingback); }
 896:              set { _MiRingback = value.ToString(); }
 897:          }
 898:   
 899:          /// <summary>
 900:          /// SelNomadicBlocking
 901:          /// </summary>
 902:          [Column(TypeName = "xml")]
 903:          public string _SelNomadicBlocking { get; set; }
 904:   
 905:          [NotMapped]
 906:          public XElement SelNomadicBlocking
 907:          {
 908:              get { return XElement.Parse(_SelNomadicBlocking); }
 909:              set { _SelNomadicBlocking = value.ToString(); }
 910:          }
 911:   
 912:          /// <summary>
 913:          /// AutoDial
 914:          /// </summary>
 915:          [Column(TypeName = "xml")]
 916:          public string _AutoDial { get; set; }
 917:   
 918:          [NotMapped]
 919:          public XElement AutoDial
 920:          {
 921:              get { return XElement.Parse(_AutoDial); }
 922:              set { _AutoDial = value.ToString(); }
 923:          }
 924:   
 925:          /// <summary>
 926:          /// CallForwardingDefault
 927:          /// </summary>
 928:          [Column(TypeName = "xml")]
 929:          public string _CallForwardingDefault { get; set; }
 930:   
 931:          [NotMapped]
 932:          public XElement CallForwardingDefault
 933:          {
 934:              get { return XElement.Parse(_CallForwardingDefault); }
 935:              set { _CallForwardingDefault = value.ToString(); }
 936:          }
 937:   
 938:          /// <summary>
 939:          /// CCBS
 940:          /// </summary>
 941:          [Column(TypeName = "xml")]
 942:          public string _CCBS { get; set; }
 943:   
 944:          [NotMapped]
 945:          public XElement CCBS
 946:          {
 947:              get { return XElement.Parse(_CCBS); }
 948:              set { _CCBS = value.ToString(); }
 949:          }
 950:   
 951:          /// <summary>
 952:          /// BlockCCBS
 953:          /// </summary>
 954:          [Column(TypeName = "xml")]
 955:          public string _BlockCCBS { get; set; }
 956:   
 957:          [NotMapped]
 958:          public XElement BlockCCBS
 959:          {
 960:              get { return XElement.Parse(_BlockCCBS); }
 961:              set { _BlockCCBS = value.ToString(); }
 962:          }
 963:   
 964:          /// <summary>
 965:          /// AINFeatcodeTrigger
 966:          /// </summary>
 967:          [Column(TypeName = "xml")]
 968:          public string _AINFeatcodeTrigger { get; set; }
 969:   
 970:          [NotMapped]
 971:          public XElement AINFeatcodeTrigger
 972:          {
 973:              get { return XElement.Parse(_AINFeatcodeTrigger); }
 974:              set { _AINFeatcodeTrigger = value.ToString(); }
 975:          }
 976:   
 977:          /// <summary>
 978:          /// AINPDPcodeTrigger
 979:          /// </summary>
 980:          [Column(TypeName = "xml")]
 981:          public string _AINPDPcodeTrigger { get; set; }
 982:   
 983:          [NotMapped]
 984:          public XElement AINPDPcodeTrigger
 985:          {
 986:              get { return XElement.Parse(_AINPDPcodeTrigger); }
 987:              set { _AINPDPcodeTrigger = value.ToString(); }
 988:          }
 989:   
 990:          /// <summary>
 991:          /// AINOHDTrigger
 992:          /// </summary>
 993:          [Column(TypeName = "xml")]
 994:          public string _AINOHDTrigger { get; set; }
 995:   
 996:          [NotMapped]
 997:          public XElement AINOHDTrigger
 998:          {
 999:              get { return XElement.Parse(_AINOHDTrigger); }
            set { _AINOHDTrigger = value.ToString(); }
        }
 
        /// <summary>
        /// AINTATTrigger
        /// </summary>
        [Column(TypeName = "xml")]
        public string _AINTATTrigger { get; set; }
 
        [NotMapped]
        public XElement AINTATTrigger
        {
            get { return XElement.Parse(_AINTATTrigger); }
            set { _AINTATTrigger = value.ToString(); }
        }
 
        /// <summary>
        /// GLSAccess
        /// </summary>
        [Column(TypeName = "xml")]
        public string _GLSAccess { get; set; }
 
        [NotMapped]
        public XElement GLSAccess
        {
            get { return XElement.Parse(_GLSAccess); }
            set { _GLSAccess = value.ToString(); }
        }
 
        /// <summary>
        /// SharedNumber
        /// </summary>
        [Column(TypeName = "xml")]
        public string _SharedNumber { get; set; }
 
        [NotMapped]
        public XElement SharedNumber
        {
            get { return XElement.Parse(_SharedNumber); }
            set { _SharedNumber = value.ToString(); }
        }
 
        /// <summary>
        /// CallDeflection
        /// </summary>
        [Column(TypeName = "xml")]
        public string _CallDeflection { get; set; }
 
        [NotMapped]
        public XElement CallDeflection
        {
            get { return XElement.Parse(_CallDeflection); }
            set { _CallDeflection = value.ToString(); }
        }
 
        /// <summary>
        /// AutoAttendant
        /// </summary>
        [Column(TypeName = "xml")]
        public string _AutoAttendant { get; set; }
 
        [NotMapped]
        public XElement AutoAttendant
        {
            get { return XElement.Parse(_AutoAttendant); }
            set { _AutoAttendant = value.ToString(); }
        }
 
        /// <summary>
        /// AdjunctTerminating
        /// </summary>
        [Column(TypeName = "xml")]
        public string _AdjunctTerminating { get; set; }
 
        [NotMapped]
        public XElement AdjunctTerminating
        {
            get { return XElement.Parse(_AdjunctTerminating); }
            set { _AdjunctTerminating = value.ToString(); }
        }
 
        /// <summary>
        /// OutgoingCallBarring
        /// </summary>
        [Column(TypeName = "xml")]
        public string _OutgoingCallBarring { get; set; }
 
        [NotMapped]
        public XElement OutgoingCallBarring
        {
            get { return XElement.Parse(_OutgoingCallBarring); }
            set { _OutgoingCallBarring = value.ToString(); }
        }
 
        /// <summary>
        /// RDigitParms
        /// </summary>
        [Column(TypeName = "xml")]
        public string _RDigitParms { get; set; }
 
        [NotMapped]
        public XElement RDigitParms
        {
            get { return XElement.Parse(_RDigitParms); }
            set { _RDigitParms = value.ToString(); }
        }
 
        /// <summary>
        /// TransitRouting
        /// </summary>
        [Column(TypeName = "xml")]
        public string _TransitRouting { get; set; }
 
        [NotMapped]
        public XElement TransitRouting
        {
            get { return XElement.Parse(_TransitRouting); }
            set { _TransitRouting = value.ToString(); }
        }
 
        /// <summary>
        /// LocationNumber
        /// </summary>
        [Column(TypeName = "xml")]
        public string _LocationNumber { get; set; }
 
        [NotMapped]
        public XElement LocationNumber
        {
            get { return XElement.Parse(_LocationNumber); }
            set { _LocationNumber = value.ToString(); }
        }
 
        /// <summary>
        /// FemtoBSR
        /// </summary>
        [Column(TypeName = "xml")]
        public string _FemtoBSR { get; set; }
 
        [NotMapped]
        public XElement FemtoBSR
        {
            get { return XElement.Parse(_FemtoBSR); }
            set { _FemtoBSR = value.ToString(); }
        }
 
        /// <summary>
        /// GeneralReset
        /// </summary>
        [Column(TypeName = "xml")]
        public string _GeneralReset { get; set; }
 
        [NotMapped]
        public XElement GeneralReset
        {
            get { return XElement.Parse(_GeneralReset); }
            set { _GeneralReset = value.ToString(); }
        }
 
        /// <summary>
        /// Metering
        /// </summary>
        [Column(TypeName = "xml")]
        public string _Metering { get; set; }
 
        [NotMapped]
        public XElement Metering
        {
            get { return XElement.Parse(_Metering); }
            set { _Metering = value.ToString(); }
        }
 
        /// <summary>
        /// PinService
        /// </summary>
        [Column(TypeName = "xml")]
        public string _PinService { get; set; }
 
        [NotMapped]
        public XElement PinService
        {
            get { return XElement.Parse(_PinService); }
            set { _PinService = value.ToString(); }
        }
 
        /// <summary>
        /// WholeSale
        /// </summary>
        [Column(TypeName = "xml")]
        public string _WholeSale { get; set; }
 
        [NotMapped]
        public XElement WholeSale
        {
            get { return XElement.Parse(_WholeSale); }
            set { _WholeSale = value.ToString(); }
        }
 
        /// <summary>
        /// SpareService
        /// </summary>
        [Column(TypeName = "xml")]
        public string _SpareService { get; set; }
 
        [NotMapped]
        public XElement SpareService
        {
            get { return XElement.Parse(_SpareService); }
            set { _SpareService = value.ToString(); }
        }
 
        /// <summary>
        /// UseHoldAnnouncement
        /// </summary>
        [Column(TypeName = "xml")]
        public string _UseHoldAnnouncement { get; set; }
 
        [NotMapped]
        public XElement UseHoldAnnouncement
        {
            get { return XElement.Parse(_UseHoldAnnouncement); }
            set { _UseHoldAnnouncement = value.ToString(); }
        }
 
        /// <summary>
        /// VPNDialingAndDisplay
        /// </summary>
        [Column(TypeName = "xml")]
        public string _VPNDialingAndDisplay { get; set; }
 
        [NotMapped]
        public XElement VPNDialingAndDisplay
        {
            get { return XElement.Parse(_VPNDialingAndDisplay); }
            set { _VPNDialingAndDisplay = value.ToString(); }
        }
 
        /// <summary>
        /// PriorityModeCalling
        /// </summary>
        [Column(TypeName = "xml")]
        public string _PriorityModeCalling { get; set; }
 
        [NotMapped]
        public XElement PriorityModeCalling
        {
            get { return XElement.Parse(_PriorityModeCalling); }
            set { _PriorityModeCalling = value.ToString(); }
        }
 
        /// <summary>
        /// OneNumber
        /// </summary>
        [Column(TypeName = "xml")]
        public string _OneNumber { get; set; }
 
        [NotMapped]
        public XElement OneNumber
        {
            get { return XElement.Parse(_OneNumber); }
            set { _OneNumber = value.ToString(); }
        }
 
        /// <summary>
        /// AdvancedConference
        /// </summary>
        [Column(TypeName = "xml")]
        public string _AdvancedConference { get; set; }
 
        [NotMapped]
        public XElement AdvancedConference
        {
            get { return XElement.Parse(_AdvancedConference); }
            set { _AdvancedConference = value.ToString(); }
        }
 
        /// <summary>
        /// 
        /// </summary>
        [Column(TypeName = "xml")]
        public string _AnswConfirm { get; set; }
 
        [NotMapped]
        public XElement AnswConfirm
        {
            get { return XElement.Parse(_AnswConfirm); }
            set { _AnswConfirm = value.ToString(); }
        }
 
        /// <summary>
        /// OnlineCharging
        /// </summary>
        [Column(TypeName = "xml")]
        public string _OnlineCharging { get; set; }
 
        [NotMapped]
        public XElement OnlineCharging
        {
            get { return XElement.Parse(_OnlineCharging); }
            set { _OnlineCharging = value.ToString(); }
        }
 
        /// <summary>
        /// VideoCallRouting
        /// </summary>
        [Column(TypeName = "xml")]
        public string _VideoCallRouting { get; set; }
 
        [NotMapped]
        public XElement VideoCallRouting
        {
            get { return XElement.Parse(_VideoCallRouting); }
            set { _VideoCallRouting = value.ToString(); }
        }
 
        /// <summary>
        /// LisInVMRescue
        /// </summary>
        [Column(TypeName = "xml")]
        public string _LisInVMRescue { get; set; }
 
        [NotMapped]
        public XElement LisInVMRescue
        {
            get { return XElement.Parse(_LisInVMRescue); }
            set { _LisInVMRescue = value.ToString(); }
        }
 
        /// <summary>
        /// EndpointValidation
        /// </summary>
        [Column(TypeName = "xml")]
        public string _EndpointValidation { get; set; }
 
        [NotMapped]
        public XElement EndpointValidation
        {
            get { return XElement.Parse(_EndpointValidation); }
            set { _EndpointValidation = value.ToString(); }
        }
 
        /// <summary>
        /// ParlayRest
        /// </summary>
        [Column(TypeName = "xml")]
        public string _ParlayRest { get; set; }
 
        [NotMapped]
        public XElement ParlayRest
        {
            get { return XElement.Parse(_ParlayRest); }
            set { _ParlayRest = value.ToString(); }
        }
 
        /// <summary>
        /// AltRtToPBX
        /// </summary>
        [Column(TypeName = "xml")]
        public string _AltRtToPBX { get; set; }
 
        [NotMapped]
        public XElement AltRtToPBX
        {
            get { return XElement.Parse(_AltRtToPBX); }
            set { _AltRtToPBX = value.ToString(); }
        }
 
        /// <summary>
        /// WAMAccess
        /// </summary>
        [Column(TypeName = "xml")]
        public string _WAMAccess { get; set; }
 
        [NotMapped]
        public XElement WAMAccess
        {
            get { return XElement.Parse(_WAMAccess); }
            set { _WAMAccess = value.ToString(); }
        }
 
        /// <summary>
        /// ISDN
        /// </summary>
        [Column(TypeName = "xml")]
        public string _ISDN { get; set; }
 
        [NotMapped]
        public XElement ISDN
        {
            get { return XElement.Parse(_ISDN); }
            set { _ISDN = value.ToString(); }
        }
 
        /// <summary>
        /// LocaleParms
        /// </summary>
        [Column(TypeName = "xml")]
        public string _LocaleParms { get; set; }
 
        [NotMapped]
        public XElement LocaleParms
        {
            get { return XElement.Parse(_LocaleParms); }
            set { _LocaleParms = value.ToString(); }
        }
 
        /// <summary>
        /// VASI
        /// </summary>
        [Column(TypeName = "xml")]
        public string _VASI { get; set; }
 
        [NotMapped]
        public XElement VASI
        {
            get { return XElement.Parse(_VASI); }
            set { _VASI = value.ToString(); }
        }
 
        /// <summary>
        /// LocBasedRedirect
        /// </summary>
        [Column(TypeName = "xml")]
        public string _LocBasedRedirect { get; set; }
 
        [NotMapped]
        public XElement LocBasedRedirect
        {
            get { return XElement.Parse(_LocBasedRedirect); }
            set { _LocBasedRedirect = value.ToString(); }
        }
 
        /// <summary>
        /// CallLimitGroup
        /// </summary>
        [Column(TypeName = "xml")]
        public string _CallLimitGroup { get; set; }
 
        [NotMapped]
        public XElement CallLimitGroup
        {
            get { return XElement.Parse(_CallLimitGroup); }
            set { _CallLimitGroup = value.ToString(); }
        }
 
        /// <summary>
        /// AlternateCharging
        /// </summary>
        [Column(TypeName = "xml")]
        public string _AlternateCharging { get; set; }
 
        [NotMapped]
        public XElement AlternateCharging
        {
            get { return XElement.Parse(_AlternateCharging); }
            set { _AlternateCharging = value.ToString(); }
        }
 
        /// <summary>
        /// CallForwardNotReach
        /// </summary>
        [Column(TypeName = "xml")]
        public string _CallForwardNotReach { get; set; }
 
        [NotMapped]
        public XElement CallForwardNotReach
        {
            get { return XElement.Parse(_CallForwardNotReach); }
            set { _CallForwardNotReach = value.ToString(); }
        }
 
        /// <summary>
        /// MultiDevicesPUID
        /// </summary>
        [Column(TypeName = "xml")]
        public string _MultiDevicesPUID { get; set; }
 
        [NotMapped]
        public XElement MultiDevicesPUID
        {
            get { return XElement.Parse(_MultiDevicesPUID); }
            set { _MultiDevicesPUID = value.ToString(); }
        }
 
        /// <summary>
        /// ManagedCallRec
        /// </summary>
        [Column(TypeName = "xml")]
        public string _ManagedCallRec { get; set; }
 
        [NotMapped]
        public XElement ManagedCallRec
        {
            get { return XElement.Parse(_ManagedCallRec); }
            set { _ManagedCallRec = value.ToString(); }
        }
 
        /// <summary>
        /// GeoRedundancyData
        /// </summary>
        [Column(TypeName = "xml")]
        public string _GeoRedundancyData { get; set; }
 
        [NotMapped]
        public XElement GeoRedundancyData
        {
            get { return XElement.Parse(_GeoRedundancyData); }
            set { _GeoRedundancyData = value.ToString(); }
        }
 
        /// <summary/>
        [ForeignKey("SubParty_Id")]
        public virtual SubParty SubParty { get; set; }
 
        /// <summary/>
        public DateTime Created { get; set; }
 
        /// <summary/>
        public DateTime Updated { get; set; }
 
        /// <summary/>
        public System.Guid UserId { get; set; }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public static string SubscriberId(string partyId)
        {
            return partyId;
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public bool Equal(Subscriber b)
        {
            // below: this will not check the Id, Created, Updated fields
            bool areEqual;
 
            //if (this.BatteryBackupAvailable != b.BatteryBackupAvailable) areEqual = false;
            //else areEqual = true;
 
            areEqual = false;
 
            return areEqual;
        }
 
        ////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// 
        /// </summary>
        public bool Update(Subscriber updatedNgfsSubscriber)
        {
            // below: this will not update Id, Created
            bool updated;
 
            updated = false;
 
            if (this.PartyId != updatedNgfsSubscriber.PartyId) { this.PartyId = updatedNgfsSubscriber.PartyId; updated = true; }
 
            if (this.AlternateOtasRealm != updatedNgfsSubscriber.AlternateOtasRealm) { this.AlternateOtasRealm = updatedNgfsSubscriber.AlternateOtasRealm; updated = true; }
 
            if (this._AnonymousCallRej != updatedNgfsSubscriber._AnonymousCallRej) { this._AnonymousCallRej = updatedNgfsSubscriber._AnonymousCallRej; updated = true; }
            if (this._SelectiveCallRejct != updatedNgfsSubscriber._SelectiveCallRejct) { this._SelectiveCallRejct = updatedNgfsSubscriber._SelectiveCallRejct; updated = true; }
            if (this._SelectiveCallAcpt != updatedNgfsSubscriber._SelectiveCallAcpt) { this._SelectiveCallAcpt = updatedNgfsSubscriber._SelectiveCallAcpt; updated = true; }
            if (this._AutomaticCallBack != updatedNgfsSubscriber._AutomaticCallBack) { this._AutomaticCallBack = updatedNgfsSubscriber._AutomaticCallBack; updated = true; }
            if (this._AutomaticRecall != updatedNgfsSubscriber._AutomaticRecall) { this._AutomaticRecall = updatedNgfsSubscriber._AutomaticRecall; updated = true; }
            if (this._CallingLineId != updatedNgfsSubscriber._CallingLineId) { this._CallingLineId = updatedNgfsSubscriber._CallingLineId; updated = true; }
            if (this._RemoteAccessServer != updatedNgfsSubscriber._RemoteAccessServer) { this._RemoteAccessServer = updatedNgfsSubscriber._RemoteAccessServer; updated = true; }
            if (this._CallBarring != updatedNgfsSubscriber._CallBarring) { this._CallBarring = updatedNgfsSubscriber._CallBarring; updated = true; }
            if (this._CallBlocking != updatedNgfsSubscriber._CallBlocking) { this._CallBlocking = updatedNgfsSubscriber._CallBlocking; updated = true; }
            if (this._CallTransfer != updatedNgfsSubscriber._CallTransfer) { this._CallTransfer = updatedNgfsSubscriber._CallTransfer; updated = true; }
            if (this._CallWaiting != updatedNgfsSubscriber._CallWaiting) { this._CallWaiting = updatedNgfsSubscriber._CallWaiting; updated = true; }
            if (this._CallForwardingVari != updatedNgfsSubscriber._CallForwardingVari) { this._CallForwardingVari = updatedNgfsSubscriber._CallForwardingVari; updated = true; }
            if (this._CallForwardingBusy != updatedNgfsSubscriber._CallForwardingBusy) { this._CallForwardingBusy = updatedNgfsSubscriber._CallForwardingBusy; updated = true; }
            if (this._CallForwardingNoAns != updatedNgfsSubscriber._CallForwardingNoAns) { this._CallForwardingNoAns = updatedNgfsSubscriber._CallForwardingNoAns; updated = true; }
            if (this._SelectiveCallFwd != updatedNgfsSubscriber._SelectiveCallFwd) { this._SelectiveCallFwd = updatedNgfsSubscriber._SelectiveCallFwd; updated = true; }
            if (this._CallForwardingUnreg != updatedNgfsSubscriber._CallForwardingUnreg) { this._CallForwardingUnreg = updatedNgfsSubscriber._CallForwardingUnreg; updated = true; }
            if (this._CustomerOrigTrace != updatedNgfsSubscriber._CustomerOrigTrace) { this._CustomerOrigTrace = updatedNgfsSubscriber._CustomerOrigTrace; updated = true; }
            if (this._NuisanceCallTrace != updatedNgfsSubscriber._NuisanceCallTrace) { this._NuisanceCallTrace = updatedNgfsSubscriber._NuisanceCallTrace; updated = true; }
            if (this._DoNotDisturb != updatedNgfsSubscriber._DoNotDisturb) { this._DoNotDisturb = updatedNgfsSubscriber._DoNotDisturb; updated = true; }
            if (this._MsgWaitingInd != updatedNgfsSubscriber._MsgWaitingInd) { this._MsgWaitingInd = updatedNgfsSubscriber._MsgWaitingInd; updated = true; }
            if (this._SimultaneousRinging != updatedNgfsSubscriber._SimultaneousRinging) { this._SimultaneousRinging = updatedNgfsSubscriber._SimultaneousRinging; updated = true; }
            if (this._WebPortal != updatedNgfsSubscriber._WebPortal) { this._WebPortal = updatedNgfsSubscriber._WebPortal; updated = true; }
            if (this._ConferenceCalling != updatedNgfsSubscriber._ConferenceCalling) { this._ConferenceCalling = updatedNgfsSubscriber._ConferenceCalling; updated = true; }
            if (this._FlashOrigServices != updatedNgfsSubscriber._FlashOrigServices) { this._FlashOrigServices = updatedNgfsSubscriber._FlashOrigServices; updated = true; }
            if (this._CarrierSelection != updatedNgfsSubscriber._CarrierSelection) { this._CarrierSelection = updatedNgfsSubscriber._CarrierSelection; updated = true; }
            if (this._RingbackWhenFree != updatedNgfsSubscriber._RingbackWhenFree) { this._RingbackWhenFree = updatedNgfsSubscriber._RingbackWhenFree; updated = true; }
            if (this._MultipleRingPattern != updatedNgfsSubscriber._MultipleRingPattern) { this._MultipleRingPattern = updatedNgfsSubscriber._MultipleRingPattern; updated = true; }
            if (this._CallForwardingLocal != updatedNgfsSubscriber._CallForwardingLocal) { this._CallForwardingLocal = updatedNgfsSubscriber._CallForwardingLocal; updated = true; }
            if (this._RemoteAccessServices != updatedNgfsSubscriber._RemoteAccessServices) { this._RemoteAccessServices = updatedNgfsSubscriber._RemoteAccessServices; updated = true; }
            if (this._VoiceMail != updatedNgfsSubscriber._VoiceMail) { this._VoiceMail = updatedNgfsSubscriber._VoiceMail; updated = true; }
            if (this._InterceptReferral != updatedNgfsSubscriber._InterceptReferral) { this._InterceptReferral = updatedNgfsSubscriber._InterceptReferral; updated = true; }
            if (this._DialingPlan != updatedNgfsSubscriber._DialingPlan) { this._DialingPlan = updatedNgfsSubscriber._DialingPlan; updated = true; }
            if (this._HSSPrivateId != updatedNgfsSubscriber._HSSPrivateId) { this._HSSPrivateId = updatedNgfsSubscriber._HSSPrivateId; updated = true; }
            if (this._HSSPublicIdCustom != updatedNgfsSubscriber._HSSPublicIdCustom) { this._HSSPublicIdCustom = updatedNgfsSubscriber._HSSPublicIdCustom; updated = true; }
            if (this._AcctCodes != updatedNgfsSubscriber._AcctCodes) { this._AcctCodes = updatedNgfsSubscriber._AcctCodes; updated = true; }
            if (this._SeqRinging != updatedNgfsSubscriber._SeqRinging) { this._SeqRinging = updatedNgfsSubscriber._SeqRinging; updated = true; }
            if (this._AuthCodeService != updatedNgfsSubscriber._AuthCodeService) { this._AuthCodeService = updatedNgfsSubscriber._AuthCodeService; updated = true; }
            if (this._MLHGNoHuntMember != updatedNgfsSubscriber._MLHGNoHuntMember) { this._MLHGNoHuntMember = updatedNgfsSubscriber._MLHGNoHuntMember; updated = true; }
            if (this._MultilineHuntGroup != updatedNgfsSubscriber._MultilineHuntGroup) { this._MultilineHuntGroup = updatedNgfsSubscriber._MultilineHuntGroup; updated = true; }
            if (this._CallPickupOrig != updatedNgfsSubscriber._CallPickupOrig) { this._CallPickupOrig = updatedNgfsSubscriber._CallPickupOrig; updated = true; }
            if (this._CallPickupTerm != updatedNgfsSubscriber._CallPickupTerm) { this._CallPickupTerm = updatedNgfsSubscriber._CallPickupTerm; updated = true; }
            if (this._Attendant != updatedNgfsSubscriber._Attendant) { this._Attendant = updatedNgfsSubscriber._Attendant; updated = true; }
            if (this._AttendantServer != updatedNgfsSubscriber._AttendantServer) { this._AttendantServer = updatedNgfsSubscriber._AttendantServer; updated = true; }
            if (this._CallPark != updatedNgfsSubscriber._CallPark) { this._CallPark = updatedNgfsSubscriber._CallPark; updated = true; }
            if (this._DirectedGroup != updatedNgfsSubscriber._DirectedGroup) { this._DirectedGroup = updatedNgfsSubscriber._DirectedGroup; updated = true; }
            if (this._RemoteUser != updatedNgfsSubscriber._RemoteUser) { this._RemoteUser = updatedNgfsSubscriber._RemoteUser; updated = true; }
            if (this._TransferToUsersVM != updatedNgfsSubscriber._TransferToUsersVM) { this._TransferToUsersVM = updatedNgfsSubscriber._TransferToUsersVM; updated = true; }
            if (this._FlexCallingLineId != updatedNgfsSubscriber._FlexCallingLineId) { this._FlexCallingLineId = updatedNgfsSubscriber._FlexCallingLineId; updated = true; }
            if (this._ExtensionDevice != updatedNgfsSubscriber._ExtensionDevice) { this._ExtensionDevice = updatedNgfsSubscriber._ExtensionDevice; updated = true; }
            if (this._PSIServer != updatedNgfsSubscriber._PSIServer) { this._PSIServer = updatedNgfsSubscriber._PSIServer; updated = true; }
            if (this._ClosedUserGroup != updatedNgfsSubscriber._ClosedUserGroup) { this._ClosedUserGroup = updatedNgfsSubscriber._ClosedUserGroup; updated = true; }
            if (this._OneDigitSpeedDial != updatedNgfsSubscriber._OneDigitSpeedDial) { this._OneDigitSpeedDial = updatedNgfsSubscriber._OneDigitSpeedDial; updated = true; }
            if (this._TwoDigitSpeedDial != updatedNgfsSubscriber._TwoDigitSpeedDial) { this._TwoDigitSpeedDial = updatedNgfsSubscriber._TwoDigitSpeedDial; updated = true; }
            if (this._ExtensionServer != updatedNgfsSubscriber._ExtensionServer) { this._ExtensionServer = updatedNgfsSubscriber._ExtensionServer; updated = true; }
            if (this._SelectiveAlert != updatedNgfsSubscriber._SelectiveAlert) { this._SelectiveAlert = updatedNgfsSubscriber._SelectiveAlert; updated = true; }
            if (this._ShortCodeTranslate != updatedNgfsSubscriber._ShortCodeTranslate) { this._ShortCodeTranslate = updatedNgfsSubscriber._ShortCodeTranslate; updated = true; }
            if (this._ReminderCall != updatedNgfsSubscriber._ReminderCall) { this._ReminderCall = updatedNgfsSubscriber._ReminderCall; updated = true; }
            if (this._SetTZPath != updatedNgfsSubscriber._SetTZPath) { this._SetTZPath = updatedNgfsSubscriber._SetTZPath; updated = true; }
            if (this._InhibitIncomingFwd != updatedNgfsSubscriber._InhibitIncomingFwd) { this._InhibitIncomingFwd = updatedNgfsSubscriber._InhibitIncomingFwd; updated = true; }
            if (this._BearerBasedCallFwd != updatedNgfsSubscriber._BearerBasedCallFwd) { this._BearerBasedCallFwd = updatedNgfsSubscriber._BearerBasedCallFwd; updated = true; }
            if (this._TimeOriginatedRC != updatedNgfsSubscriber._TimeOriginatedRC) { this._TimeOriginatedRC = updatedNgfsSubscriber._TimeOriginatedRC; updated = true; }
            if (this._MobileDMS != updatedNgfsSubscriber._MobileDMS) { this._MobileDMS = updatedNgfsSubscriber._MobileDMS; updated = true; }
            if (this._MLPP != updatedNgfsSubscriber._MLPP) { this._MLPP = updatedNgfsSubscriber._MLPP; updated = true; }
            if (this._MusicOnHold != updatedNgfsSubscriber._MusicOnHold) { this._MusicOnHold = updatedNgfsSubscriber._MusicOnHold; updated = true; }
            if (this._MiRingback != updatedNgfsSubscriber._MiRingback) { this._MiRingback = updatedNgfsSubscriber._MiRingback; updated = true; }
            if (this._SelNomadicBlocking != updatedNgfsSubscriber._SelNomadicBlocking) { this._SelNomadicBlocking = updatedNgfsSubscriber._SelNomadicBlocking; updated = true; }
            if (this._AutoDial != updatedNgfsSubscriber._AutoDial) { this._AutoDial = updatedNgfsSubscriber._AutoDial; updated = true; }
            if (this._CallForwardingDefault != updatedNgfsSubscriber._CallForwardingDefault) { this._CallForwardingDefault = updatedNgfsSubscriber._CallForwardingDefault; updated = true; }
            if (this._CCBS != updatedNgfsSubscriber._CCBS) { this._CCBS = updatedNgfsSubscriber._CCBS; updated = true; }
            if (this._BlockCCBS != updatedNgfsSubscriber._BlockCCBS) { this._BlockCCBS = updatedNgfsSubscriber._BlockCCBS; updated = true; }
            if (this._AINFeatcodeTrigger != updatedNgfsSubscriber._AINFeatcodeTrigger) { this._AINFeatcodeTrigger = updatedNgfsSubscriber._AINFeatcodeTrigger; updated = true; }
            if (this._AINPDPcodeTrigger != updatedNgfsSubscriber._AINPDPcodeTrigger) { this._AINPDPcodeTrigger = updatedNgfsSubscriber._AINPDPcodeTrigger; updated = true; }
            if (this._AINOHDTrigger != updatedNgfsSubscriber._AINOHDTrigger) { this._AINOHDTrigger = updatedNgfsSubscriber._AINOHDTrigger; updated = true; }
            if (this._AINTATTrigger != updatedNgfsSubscriber._AINTATTrigger) { this._AINTATTrigger = updatedNgfsSubscriber._AINTATTrigger; updated = true; }
            if (this._GLSAccess != updatedNgfsSubscriber._GLSAccess) { this._GLSAccess = updatedNgfsSubscriber._GLSAccess; updated = true; }
            if (this._SharedNumber != updatedNgfsSubscriber._SharedNumber) { this._SharedNumber = updatedNgfsSubscriber._SharedNumber; updated = true; }
            if (this._CallDeflection != updatedNgfsSubscriber._CallDeflection) { this._CallDeflection = updatedNgfsSubscriber._CallDeflection; updated = true; }
            if (this._AutoAttendant != updatedNgfsSubscriber._AutoAttendant) { this._AutoAttendant = updatedNgfsSubscriber._AutoAttendant; updated = true; }
            if (this._AdjunctTerminating != updatedNgfsSubscriber._AdjunctTerminating) { this._AdjunctTerminating = updatedNgfsSubscriber._AdjunctTerminating; updated = true; }
            if (this._OutgoingCallBarring != updatedNgfsSubscriber._OutgoingCallBarring) { this._OutgoingCallBarring = updatedNgfsSubscriber._OutgoingCallBarring; updated = true; }
            if (this._RDigitParms != updatedNgfsSubscriber._RDigitParms) { this._RDigitParms = updatedNgfsSubscriber._RDigitParms; updated = true; }
            if (this._TransitRouting != updatedNgfsSubscriber._TransitRouting) { this._TransitRouting = updatedNgfsSubscriber._TransitRouting; updated = true; }
            if (this._LocationNumber != updatedNgfsSubscriber._LocationNumber) { this._LocationNumber = updatedNgfsSubscriber._LocationNumber; updated = true; }
            if (this._FemtoBSR != updatedNgfsSubscriber._FemtoBSR) { this._FemtoBSR = updatedNgfsSubscriber._FemtoBSR; updated = true; }
            if (this._GeneralReset != updatedNgfsSubscriber._GeneralReset) { this._GeneralReset = updatedNgfsSubscriber._GeneralReset; updated = true; }
            if (this._Metering != updatedNgfsSubscriber._Metering) { this._Metering = updatedNgfsSubscriber._Metering; updated = true; }
            if (this._PinService != updatedNgfsSubscriber._PinService) { this._PinService = updatedNgfsSubscriber._PinService; updated = true; }
            if (this._WholeSale != updatedNgfsSubscriber._WholeSale) { this._WholeSale = updatedNgfsSubscriber._WholeSale; updated = true; }
            if (this._SpareService != updatedNgfsSubscriber._SpareService) { this._SpareService = updatedNgfsSubscriber._SpareService; updated = true; }
            if (this._UseHoldAnnouncement != updatedNgfsSubscriber._UseHoldAnnouncement) { this._UseHoldAnnouncement = updatedNgfsSubscriber._UseHoldAnnouncement; updated = true; }
            if (this._VPNDialingAndDisplay != updatedNgfsSubscriber._VPNDialingAndDisplay) { this._VPNDialingAndDisplay = updatedNgfsSubscriber._VPNDialingAndDisplay; updated = true; }
            if (this._PriorityModeCalling != updatedNgfsSubscriber._PriorityModeCalling) { this._PriorityModeCalling = updatedNgfsSubscriber._PriorityModeCalling; updated = true; }
            if (this._OneNumber != updatedNgfsSubscriber._OneNumber) { this._OneNumber = updatedNgfsSubscriber._OneNumber; updated = true; }
            if (this._AdvancedConference != updatedNgfsSubscriber._AdvancedConference) { this._AdvancedConference = updatedNgfsSubscriber._AdvancedConference; updated = true; }
            if (this._AnswConfirm != updatedNgfsSubscriber._AnswConfirm) { this._AnswConfirm = updatedNgfsSubscriber._AnswConfirm; updated = true; }
            if (this._OnlineCharging != updatedNgfsSubscriber._OnlineCharging) { this._OnlineCharging = updatedNgfsSubscriber._OnlineCharging; updated = true; }
            if (this._VideoCallRouting != updatedNgfsSubscriber._VideoCallRouting) { this._VideoCallRouting = updatedNgfsSubscriber._VideoCallRouting; updated = true; }
            if (this._LisInVMRescue != updatedNgfsSubscriber._LisInVMRescue) { this._LisInVMRescue = updatedNgfsSubscriber._LisInVMRescue; updated = true; }
            if (this._EndpointValidation != updatedNgfsSubscriber._EndpointValidation) { this._EndpointValidation = updatedNgfsSubscriber._EndpointValidation; updated = true; }
            if (this._ParlayRest != updatedNgfsSubscriber._ParlayRest) { this._ParlayRest = updatedNgfsSubscriber._ParlayRest; updated = true; }
            if (this._AltRtToPBX != updatedNgfsSubscriber._AltRtToPBX) { this._AltRtToPBX = updatedNgfsSubscriber._AltRtToPBX; updated = true; }
            if (this._WAMAccess != updatedNgfsSubscriber._WAMAccess) { this._WAMAccess = updatedNgfsSubscriber._WAMAccess; updated = true; }
            if (this._ISDN != updatedNgfsSubscriber._ISDN) { this._ISDN = updatedNgfsSubscriber._ISDN; updated = true; }
            if (this._LocaleParms != updatedNgfsSubscriber._LocaleParms) { this._LocaleParms = updatedNgfsSubscriber._LocaleParms; updated = true; }
            if (this._VASI != updatedNgfsSubscriber._VASI) { this._VASI = updatedNgfsSubscriber._VASI; updated = true; }
            if (this._LocBasedRedirect != updatedNgfsSubscriber._LocBasedRedirect) { this._LocBasedRedirect = updatedNgfsSubscriber._LocBasedRedirect; updated = true; }
            if (this._CallLimitGroup != updatedNgfsSubscriber._CallLimitGroup) { this._CallLimitGroup = updatedNgfsSubscriber._CallLimitGroup; updated = true; }
            if (this._AlternateCharging != updatedNgfsSubscriber._AlternateCharging) { this._AlternateCharging = updatedNgfsSubscriber._AlternateCharging; updated = true; }
            if (this._CallForwardNotReach != updatedNgfsSubscriber._CallForwardNotReach) { this._CallForwardNotReach = updatedNgfsSubscriber._CallForwardNotReach; updated = true; }
            if (this._MultiDevicesPUID != updatedNgfsSubscriber._MultiDevicesPUID) { this._MultiDevicesPUID = updatedNgfsSubscriber._MultiDevicesPUID; updated = true; }
            if (this._ManagedCallRec != updatedNgfsSubscriber._ManagedCallRec) { this._ManagedCallRec = updatedNgfsSubscriber._ManagedCallRec; updated = true; }
            if (this._GeoRedundancyData != updatedNgfsSubscriber._GeoRedundancyData) { this._GeoRedundancyData = updatedNgfsSubscriber._GeoRedundancyData; updated = true; }
 
            if (this.SubParty != updatedNgfsSubscriber.SubParty) { this.SubParty = updatedNgfsSubscriber.SubParty; updated = true; }
 
            if (this.UserId != updatedNgfsSubscriber.UserId) { this.UserId = updatedNgfsSubscriber.UserId; updated = true; }
 
            if (updated) this.Updated = DateTime.UtcNow.AddHours(3);
 
            return updated;
        }
 
        ////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////
    }
 
    ////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
}