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.Ftn.Cl.Model.Nokia

   10: {

   11:     ////////////////////////////////////////////////////////////////////////////

   12:  

   13:     /// <summary publish="true">

   14:     /// Subscriber Entity Framework class for Fixed Telecommunications Network (FTN) 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:@&=!,|-_.!~*()%]* Before CTS R5.0: [+0-9a-zA-Z:@&=!,-_.!~*'()%]* LCP-CTS R6.1 From CTS R6.1: [+0-9a-zA-Z:@&=,|-_.!~*'()%#?/$][]* 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); }

 1000:             set { _AINOHDTrigger = value.ToString(); }

 1001:         }

 1002:  

 1003:         /// <summary>

 1004:         /// AINTATTrigger

 1005:         /// </summary>

 1006:         [Column(TypeName = "xml")]

 1007:         public string _AINTATTrigger { get; set; }

 1008:  

 1009:         [NotMapped]

 1010:         public XElement AINTATTrigger

 1011:         {

 1012:             get { return XElement.Parse(_AINTATTrigger); }

 1013:             set { _AINTATTrigger = value.ToString(); }

 1014:         }

 1015:  

 1016:         /// <summary>

 1017:         /// GLSAccess

 1018:         /// </summary>

 1019:         [Column(TypeName = "xml")]

 1020:         public string _GLSAccess { get; set; }

 1021:  

 1022:         [NotMapped]

 1023:         public XElement GLSAccess

 1024:         {

 1025:             get { return XElement.Parse(_GLSAccess); }

 1026:             set { _GLSAccess = value.ToString(); }

 1027:         }

 1028:  

 1029:         /// <summary>

 1030:         /// SharedNumber

 1031:         /// </summary>

 1032:         [Column(TypeName = "xml")]

 1033:         public string _SharedNumber { get; set; }

 1034:  

 1035:         [NotMapped]

 1036:         public XElement SharedNumber

 1037:         {

 1038:             get { return XElement.Parse(_SharedNumber); }

 1039:             set { _SharedNumber = value.ToString(); }

 1040:         }

 1041:  

 1042:         /// <summary>

 1043:         /// CallDeflection

 1044:         /// </summary>

 1045:         [Column(TypeName = "xml")]

 1046:         public string _CallDeflection { get; set; }

 1047:  

 1048:         [NotMapped]

 1049:         public XElement CallDeflection

 1050:         {

 1051:             get { return XElement.Parse(_CallDeflection); }

 1052:             set { _CallDeflection = value.ToString(); }

 1053:         }

 1054:  

 1055:         /// <summary>

 1056:         /// AutoAttendant

 1057:         /// </summary>

 1058:         [Column(TypeName = "xml")]

 1059:         public string _AutoAttendant { get; set; }

 1060:  

 1061:         [NotMapped]

 1062:         public XElement AutoAttendant

 1063:         {

 1064:             get { return XElement.Parse(_AutoAttendant); }

 1065:             set { _AutoAttendant = value.ToString(); }

 1066:         }

 1067:  

 1068:         /// <summary>

 1069:         /// AdjunctTerminating

 1070:         /// </summary>

 1071:         [Column(TypeName = "xml")]

 1072:         public string _AdjunctTerminating { get; set; }

 1073:  

 1074:         [NotMapped]

 1075:         public XElement AdjunctTerminating

 1076:         {

 1077:             get { return XElement.Parse(_AdjunctTerminating); }

 1078:             set { _AdjunctTerminating = value.ToString(); }

 1079:         }

 1080:  

 1081:         /// <summary>

 1082:         /// OutgoingCallBarring

 1083:         /// </summary>

 1084:         [Column(TypeName = "xml")]

 1085:         public string _OutgoingCallBarring { get; set; }

 1086:  

 1087:         [NotMapped]

 1088:         public XElement OutgoingCallBarring

 1089:         {

 1090:             get { return XElement.Parse(_OutgoingCallBarring); }

 1091:             set { _OutgoingCallBarring = value.ToString(); }

 1092:         }

 1093:  

 1094:         /// <summary>

 1095:         /// RDigitParms

 1096:         /// </summary>

 1097:         [Column(TypeName = "xml")]

 1098:         public string _RDigitParms { get; set; }

 1099:  

 1100:         [NotMapped]

 1101:         public XElement RDigitParms

 1102:         {

 1103:             get { return XElement.Parse(_RDigitParms); }

 1104:             set { _RDigitParms = value.ToString(); }

 1105:         }

 1106:  

 1107:         /// <summary>

 1108:         /// TransitRouting

 1109:         /// </summary>

 1110:         [Column(TypeName = "xml")]

 1111:         public string _TransitRouting { get; set; }

 1112:  

 1113:         [NotMapped]

 1114:         public XElement TransitRouting

 1115:         {

 1116:             get { return XElement.Parse(_TransitRouting); }

 1117:             set { _TransitRouting = value.ToString(); }

 1118:         }

 1119:  

 1120:         /// <summary>

 1121:         /// LocationNumber

 1122:         /// </summary>

 1123:         [Column(TypeName = "xml")]

 1124:         public string _LocationNumber { get; set; }

 1125:  

 1126:         [NotMapped]

 1127:         public XElement LocationNumber

 1128:         {

 1129:             get { return XElement.Parse(_LocationNumber); }

 1130:             set { _LocationNumber = value.ToString(); }

 1131:         }

 1132:  

 1133:         /// <summary>

 1134:         /// FemtoBSR

 1135:         /// </summary>

 1136:         [Column(TypeName = "xml")]

 1137:         public string _FemtoBSR { get; set; }

 1138:  

 1139:         [NotMapped]

 1140:         public XElement FemtoBSR

 1141:         {

 1142:             get { return XElement.Parse(_FemtoBSR); }

 1143:             set { _FemtoBSR = value.ToString(); }

 1144:         }

 1145:  

 1146:         /// <summary>

 1147:         /// GeneralReset

 1148:         /// </summary>

 1149:         [Column(TypeName = "xml")]

 1150:         public string _GeneralReset { get; set; }

 1151:  

 1152:         [NotMapped]

 1153:         public XElement GeneralReset

 1154:         {

 1155:             get { return XElement.Parse(_GeneralReset); }

 1156:             set { _GeneralReset = value.ToString(); }

 1157:         }

 1158:  

 1159:         /// <summary>

 1160:         /// Metering

 1161:         /// </summary>

 1162:         [Column(TypeName = "xml")]

 1163:         public string _Metering { get; set; }

 1164:  

 1165:         [NotMapped]

 1166:         public XElement Metering

 1167:         {

 1168:             get { return XElement.Parse(_Metering); }

 1169:             set { _Metering = value.ToString(); }

 1170:         }

 1171:  

 1172:         /// <summary>

 1173:         /// PinService

 1174:         /// </summary>

 1175:         [Column(TypeName = "xml")]

 1176:         public string _PinService { get; set; }

 1177:  

 1178:         [NotMapped]

 1179:         public XElement PinService

 1180:         {

 1181:             get { return XElement.Parse(_PinService); }

 1182:             set { _PinService = value.ToString(); }

 1183:         }

 1184:  

 1185:         /// <summary>

 1186:         /// WholeSale

 1187:         /// </summary>

 1188:         [Column(TypeName = "xml")]

 1189:         public string _WholeSale { get; set; }

 1190:  

 1191:         [NotMapped]

 1192:         public XElement WholeSale

 1193:         {

 1194:             get { return XElement.Parse(_WholeSale); }

 1195:             set { _WholeSale = value.ToString(); }

 1196:         }

 1197:  

 1198:         /// <summary>

 1199:         /// SpareService

 1200:         /// </summary>

 1201:         [Column(TypeName = "xml")]

 1202:         public string _SpareService { get; set; }

 1203:  

 1204:         [NotMapped]

 1205:         public XElement SpareService

 1206:         {

 1207:             get { return XElement.Parse(_SpareService); }

 1208:             set { _SpareService = value.ToString(); }

 1209:         }

 1210:  

 1211:         /// <summary>

 1212:         /// UseHoldAnnouncement

 1213:         /// </summary>

 1214:         [Column(TypeName = "xml")]

 1215:         public string _UseHoldAnnouncement { get; set; }

 1216:  

 1217:         [NotMapped]

 1218:         public XElement UseHoldAnnouncement

 1219:         {

 1220:             get { return XElement.Parse(_UseHoldAnnouncement); }

 1221:             set { _UseHoldAnnouncement = value.ToString(); }

 1222:         }

 1223:  

 1224:         /// <summary>

 1225:         /// VPNDialingAndDisplay

 1226:         /// </summary>

 1227:         [Column(TypeName = "xml")]

 1228:         public string _VPNDialingAndDisplay { get; set; }

 1229:  

 1230:         [NotMapped]

 1231:         public XElement VPNDialingAndDisplay

 1232:         {

 1233:             get { return XElement.Parse(_VPNDialingAndDisplay); }

 1234:             set { _VPNDialingAndDisplay = value.ToString(); }

 1235:         }

 1236:  

 1237:         /// <summary>

 1238:         /// PriorityModeCalling

 1239:         /// </summary>

 1240:         [Column(TypeName = "xml")]

 1241:         public string _PriorityModeCalling { get; set; }

 1242:  

 1243:         [NotMapped]

 1244:         public XElement PriorityModeCalling

 1245:         {

 1246:             get { return XElement.Parse(_PriorityModeCalling); }

 1247:             set { _PriorityModeCalling = value.ToString(); }

 1248:         }

 1249:  

 1250:         /// <summary>

 1251:         /// OneNumber

 1252:         /// </summary>

 1253:         [Column(TypeName = "xml")]

 1254:         public string _OneNumber { get; set; }

 1255:  

 1256:         [NotMapped]

 1257:         public XElement OneNumber

 1258:         {

 1259:             get { return XElement.Parse(_OneNumber); }

 1260:             set { _OneNumber = value.ToString(); }

 1261:         }

 1262:  

 1263:         /// <summary>

 1264:         /// AdvancedConference

 1265:         /// </summary>

 1266:         [Column(TypeName = "xml")]

 1267:         public string _AdvancedConference { get; set; }

 1268:  

 1269:         [NotMapped]

 1270:         public XElement AdvancedConference

 1271:         {

 1272:             get { return XElement.Parse(_AdvancedConference); }

 1273:             set { _AdvancedConference = value.ToString(); }

 1274:         }

 1275:  

 1276:         /// <summary>

 1277:         /// 

 1278:         /// </summary>

 1279:         [Column(TypeName = "xml")]

 1280:         public string _AnswConfirm { get; set; }

 1281:  

 1282:         [NotMapped]

 1283:         public XElement AnswConfirm

 1284:         {

 1285:             get { return XElement.Parse(_AnswConfirm); }

 1286:             set { _AnswConfirm = value.ToString(); }

 1287:         }

 1288:  

 1289:         /// <summary>

 1290:         /// OnlineCharging

 1291:         /// </summary>

 1292:         [Column(TypeName = "xml")]

 1293:         public string _OnlineCharging { get; set; }

 1294:  

 1295:         [NotMapped]

 1296:         public XElement OnlineCharging

 1297:         {

 1298:             get { return XElement.Parse(_OnlineCharging); }

 1299:             set { _OnlineCharging = value.ToString(); }

 1300:         }

 1301:  

 1302:         /// <summary>

 1303:         /// VideoCallRouting

 1304:         /// </summary>

 1305:         [Column(TypeName = "xml")]

 1306:         public string _VideoCallRouting { get; set; }

 1307:  

 1308:         [NotMapped]

 1309:         public XElement VideoCallRouting

 1310:         {

 1311:             get { return XElement.Parse(_VideoCallRouting); }

 1312:             set { _VideoCallRouting = value.ToString(); }

 1313:         }

 1314:  

 1315:         /// <summary>

 1316:         /// LisInVMRescue

 1317:         /// </summary>

 1318:         [Column(TypeName = "xml")]

 1319:         public string _LisInVMRescue { get; set; }

 1320:  

 1321:         [NotMapped]

 1322:         public XElement LisInVMRescue

 1323:         {

 1324:             get { return XElement.Parse(_LisInVMRescue); }

 1325:             set { _LisInVMRescue = value.ToString(); }

 1326:         }

 1327:  

 1328:         /// <summary>

 1329:         /// EndpointValidation

 1330:         /// </summary>

 1331:         [Column(TypeName = "xml")]

 1332:         public string _EndpointValidation { get; set; }

 1333:  

 1334:         [NotMapped]

 1335:         public XElement EndpointValidation

 1336:         {

 1337:             get { return XElement.Parse(_EndpointValidation); }

 1338:             set { _EndpointValidation = value.ToString(); }

 1339:         }

 1340:  

 1341:         /// <summary>

 1342:         /// ParlayRest

 1343:         /// </summary>

 1344:         [Column(TypeName = "xml")]

 1345:         public string _ParlayRest { get; set; }

 1346:  

 1347:         [NotMapped]

 1348:         public XElement ParlayRest

 1349:         {

 1350:             get { return XElement.Parse(_ParlayRest); }

 1351:             set { _ParlayRest = value.ToString(); }

 1352:         }

 1353:  

 1354:         /// <summary>

 1355:         /// AltRtToPBX

 1356:         /// </summary>

 1357:         [Column(TypeName = "xml")]

 1358:         public string _AltRtToPBX { get; set; }

 1359:  

 1360:         [NotMapped]

 1361:         public XElement AltRtToPBX

 1362:         {

 1363:             get { return XElement.Parse(_AltRtToPBX); }

 1364:             set { _AltRtToPBX = value.ToString(); }

 1365:         }

 1366:  

 1367:         /// <summary>

 1368:         /// WAMAccess

 1369:         /// </summary>

 1370:         [Column(TypeName = "xml")]

 1371:         public string _WAMAccess { get; set; }

 1372:  

 1373:         [NotMapped]

 1374:         public XElement WAMAccess

 1375:         {

 1376:             get { return XElement.Parse(_WAMAccess); }

 1377:             set { _WAMAccess = value.ToString(); }

 1378:         }

 1379:  

 1380:         /// <summary>

 1381:         /// ISDN

 1382:         /// </summary>

 1383:         [Column(TypeName = "xml")]

 1384:         public string _ISDN { get; set; }

 1385:  

 1386:         [NotMapped]

 1387:         public XElement ISDN

 1388:         {

 1389:             get { return XElement.Parse(_ISDN); }

 1390:             set { _ISDN = value.ToString(); }

 1391:         }

 1392:  

 1393:         /// <summary>

 1394:         /// LocaleParms

 1395:         /// </summary>

 1396:         [Column(TypeName = "xml")]

 1397:         public string _LocaleParms { get; set; }

 1398:  

 1399:         [NotMapped]

 1400:         public XElement LocaleParms

 1401:         {

 1402:             get { return XElement.Parse(_LocaleParms); }

 1403:             set { _LocaleParms = value.ToString(); }

 1404:         }

 1405:  

 1406:         /// <summary>

 1407:         /// VASI

 1408:         /// </summary>

 1409:         [Column(TypeName = "xml")]

 1410:         public string _VASI { get; set; }

 1411:  

 1412:         [NotMapped]

 1413:         public XElement VASI

 1414:         {

 1415:             get { return XElement.Parse(_VASI); }

 1416:             set { _VASI = value.ToString(); }

 1417:         }

 1418:  

 1419:         /// <summary>

 1420:         /// LocBasedRedirect

 1421:         /// </summary>

 1422:         [Column(TypeName = "xml")]

 1423:         public string _LocBasedRedirect { get; set; }

 1424:  

 1425:         [NotMapped]

 1426:         public XElement LocBasedRedirect

 1427:         {

 1428:             get { return XElement.Parse(_LocBasedRedirect); }

 1429:             set { _LocBasedRedirect = value.ToString(); }

 1430:         }

 1431:  

 1432:         /// <summary>

 1433:         /// CallLimitGroup

 1434:         /// </summary>

 1435:         [Column(TypeName = "xml")]

 1436:         public string _CallLimitGroup { get; set; }

 1437:  

 1438:         [NotMapped]

 1439:         public XElement CallLimitGroup

 1440:         {

 1441:             get { return XElement.Parse(_CallLimitGroup); }

 1442:             set { _CallLimitGroup = value.ToString(); }

 1443:         }

 1444:  

 1445:         /// <summary>

 1446:         /// AlternateCharging

 1447:         /// </summary>

 1448:         [Column(TypeName = "xml")]

 1449:         public string _AlternateCharging { get; set; }

 1450:  

 1451:         [NotMapped]

 1452:         public XElement AlternateCharging

 1453:         {

 1454:             get { return XElement.Parse(_AlternateCharging); }

 1455:             set { _AlternateCharging = value.ToString(); }

 1456:         }

 1457:  

 1458:         /// <summary>

 1459:         /// CallForwardNotReach

 1460:         /// </summary>

 1461:         [Column(TypeName = "xml")]

 1462:         public string _CallForwardNotReach { get; set; }

 1463:  

 1464:         [NotMapped]

 1465:         public XElement CallForwardNotReach

 1466:         {

 1467:             get { return XElement.Parse(_CallForwardNotReach); }

 1468:             set { _CallForwardNotReach = value.ToString(); }

 1469:         }

 1470:  

 1471:         /// <summary>

 1472:         /// MultiDevicesPUID

 1473:         /// </summary>

 1474:         [Column(TypeName = "xml")]

 1475:         public string _MultiDevicesPUID { get; set; }

 1476:  

 1477:         [NotMapped]

 1478:         public XElement MultiDevicesPUID

 1479:         {

 1480:             get { return XElement.Parse(_MultiDevicesPUID); }

 1481:             set { _MultiDevicesPUID = value.ToString(); }

 1482:         }

 1483:  

 1484:         /// <summary>

 1485:         /// ManagedCallRec

 1486:         /// </summary>

 1487:         [Column(TypeName = "xml")]

 1488:         public string _ManagedCallRec { get; set; }

 1489:  

 1490:         [NotMapped]

 1491:         public XElement ManagedCallRec

 1492:         {

 1493:             get { return XElement.Parse(_ManagedCallRec); }

 1494:             set { _ManagedCallRec = value.ToString(); }

 1495:         }

 1496:  

 1497:         /// <summary>

 1498:         /// GeoRedundancyData

 1499:         /// </summary>

 1500:         [Column(TypeName = "xml")]

 1501:         public string _GeoRedundancyData { get; set; }

 1502:  

 1503:         [NotMapped]

 1504:         public XElement GeoRedundancyData

 1505:         {

 1506:             get { return XElement.Parse(_GeoRedundancyData); }

 1507:             set { _GeoRedundancyData = value.ToString(); }

 1508:         }

 1509:  

 1510:         /// <summary/>

 1511:         [ForeignKey("SubParty_Id")]

 1512:         public virtual SubParty SubParty { get; set; }

 1513:  

 1514:         /// <summary/>

 1515:         public DateTime Created { get; set; }

 1516:  

 1517:         /// <summary/>

 1518:         public DateTime Updated { get; set; }

 1519:  

 1520:         /// <summary/>

 1521:         public string UserId { get; set; }

 1522:  

 1523:         ////////////////////////////////////////////////////////////////////////////

 1524:  

 1525:         /// <summary>

 1526:         /// 

 1527:         /// </summary>

 1528:         public static string SubscriberId(string partyId)

 1529:         {

 1530:             return partyId;

 1531:         }

 1532:  

 1533:         ////////////////////////////////////////////////////////////////////////////

 1534:  

 1535:         /// <summary>

 1536:         /// 

 1537:         /// </summary>

 1538:         public bool Equal(Subscriber b)

 1539:         {

 1540:             // below: this will not check the Id, Created, Updated fields

 1541:             bool areEqual;

 1542:  

 1543:             //if (this.BatteryBackupAvailable != b.BatteryBackupAvailable) areEqual = false;

 1544:             //else areEqual = true;

 1545:  

 1546:             areEqual = false;

 1547:  

 1548:             return areEqual;

 1549:         }

 1550:  

 1551:         ////////////////////////////////////////////////////////////////////////////

 1552:  

 1553:         /// <summary>

 1554:         /// 

 1555:         /// </summary>

 1556:         public bool Update(Subscriber updatedNgfsSubscriber)

 1557:         {

 1558:             // below: this will not update Id, Created

 1559:             bool updated;

 1560:  

 1561:             updated = false;

 1562:  

 1563:             if (this.PartyId != updatedNgfsSubscriber.PartyId) { this.PartyId = updatedNgfsSubscriber.PartyId; updated = true; }

 1564:  

 1565:             if (this.AlternateOtasRealm != updatedNgfsSubscriber.AlternateOtasRealm) { this.AlternateOtasRealm = updatedNgfsSubscriber.AlternateOtasRealm; updated = true; }

 1566:  

 1567:             if (this._AnonymousCallRej != updatedNgfsSubscriber._AnonymousCallRej) { this._AnonymousCallRej = updatedNgfsSubscriber._AnonymousCallRej; updated = true; }

 1568:             if (this._SelectiveCallRejct != updatedNgfsSubscriber._SelectiveCallRejct) { this._SelectiveCallRejct = updatedNgfsSubscriber._SelectiveCallRejct; updated = true; }

 1569:             if (this._SelectiveCallAcpt != updatedNgfsSubscriber._SelectiveCallAcpt) { this._SelectiveCallAcpt = updatedNgfsSubscriber._SelectiveCallAcpt; updated = true; }

 1570:             if (this._AutomaticCallBack != updatedNgfsSubscriber._AutomaticCallBack) { this._AutomaticCallBack = updatedNgfsSubscriber._AutomaticCallBack; updated = true; }

 1571:             if (this._AutomaticRecall != updatedNgfsSubscriber._AutomaticRecall) { this._AutomaticRecall = updatedNgfsSubscriber._AutomaticRecall; updated = true; }

 1572:             if (this._CallingLineId != updatedNgfsSubscriber._CallingLineId) { this._CallingLineId = updatedNgfsSubscriber._CallingLineId; updated = true; }

 1573:             if (this._RemoteAccessServer != updatedNgfsSubscriber._RemoteAccessServer) { this._RemoteAccessServer = updatedNgfsSubscriber._RemoteAccessServer; updated = true; }

 1574:             if (this._CallBarring != updatedNgfsSubscriber._CallBarring) { this._CallBarring = updatedNgfsSubscriber._CallBarring; updated = true; }

 1575:             if (this._CallBlocking != updatedNgfsSubscriber._CallBlocking) { this._CallBlocking = updatedNgfsSubscriber._CallBlocking; updated = true; }

 1576:             if (this._CallTransfer != updatedNgfsSubscriber._CallTransfer) { this._CallTransfer = updatedNgfsSubscriber._CallTransfer; updated = true; }

 1577:             if (this._CallWaiting != updatedNgfsSubscriber._CallWaiting) { this._CallWaiting = updatedNgfsSubscriber._CallWaiting; updated = true; }

 1578:             if (this._CallForwardingVari != updatedNgfsSubscriber._CallForwardingVari) { this._CallForwardingVari = updatedNgfsSubscriber._CallForwardingVari; updated = true; }

 1579:             if (this._CallForwardingBusy != updatedNgfsSubscriber._CallForwardingBusy) { this._CallForwardingBusy = updatedNgfsSubscriber._CallForwardingBusy; updated = true; }

 1580:             if (this._CallForwardingNoAns != updatedNgfsSubscriber._CallForwardingNoAns) { this._CallForwardingNoAns = updatedNgfsSubscriber._CallForwardingNoAns; updated = true; }

 1581:             if (this._SelectiveCallFwd != updatedNgfsSubscriber._SelectiveCallFwd) { this._SelectiveCallFwd = updatedNgfsSubscriber._SelectiveCallFwd; updated = true; }

 1582:             if (this._CallForwardingUnreg != updatedNgfsSubscriber._CallForwardingUnreg) { this._CallForwardingUnreg = updatedNgfsSubscriber._CallForwardingUnreg; updated = true; }

 1583:             if (this._CustomerOrigTrace != updatedNgfsSubscriber._CustomerOrigTrace) { this._CustomerOrigTrace = updatedNgfsSubscriber._CustomerOrigTrace; updated = true; }

 1584:             if (this._NuisanceCallTrace != updatedNgfsSubscriber._NuisanceCallTrace) { this._NuisanceCallTrace = updatedNgfsSubscriber._NuisanceCallTrace; updated = true; }

 1585:             if (this._DoNotDisturb != updatedNgfsSubscriber._DoNotDisturb) { this._DoNotDisturb = updatedNgfsSubscriber._DoNotDisturb; updated = true; }

 1586:             if (this._MsgWaitingInd != updatedNgfsSubscriber._MsgWaitingInd) { this._MsgWaitingInd = updatedNgfsSubscriber._MsgWaitingInd; updated = true; }

 1587:             if (this._SimultaneousRinging != updatedNgfsSubscriber._SimultaneousRinging) { this._SimultaneousRinging = updatedNgfsSubscriber._SimultaneousRinging; updated = true; }

 1588:             if (this._WebPortal != updatedNgfsSubscriber._WebPortal) { this._WebPortal = updatedNgfsSubscriber._WebPortal; updated = true; }

 1589:             if (this._ConferenceCalling != updatedNgfsSubscriber._ConferenceCalling) { this._ConferenceCalling = updatedNgfsSubscriber._ConferenceCalling; updated = true; }

 1590:             if (this._FlashOrigServices != updatedNgfsSubscriber._FlashOrigServices) { this._FlashOrigServices = updatedNgfsSubscriber._FlashOrigServices; updated = true; }

 1591:             if (this._CarrierSelection != updatedNgfsSubscriber._CarrierSelection) { this._CarrierSelection = updatedNgfsSubscriber._CarrierSelection; updated = true; }

 1592:             if (this._RingbackWhenFree != updatedNgfsSubscriber._RingbackWhenFree) { this._RingbackWhenFree = updatedNgfsSubscriber._RingbackWhenFree; updated = true; }

 1593:             if (this._MultipleRingPattern != updatedNgfsSubscriber._MultipleRingPattern) { this._MultipleRingPattern = updatedNgfsSubscriber._MultipleRingPattern; updated = true; }

 1594:             if (this._CallForwardingLocal != updatedNgfsSubscriber._CallForwardingLocal) { this._CallForwardingLocal = updatedNgfsSubscriber._CallForwardingLocal; updated = true; }

 1595:             if (this._RemoteAccessServices != updatedNgfsSubscriber._RemoteAccessServices) { this._RemoteAccessServices = updatedNgfsSubscriber._RemoteAccessServices; updated = true; }

 1596:             if (this._VoiceMail != updatedNgfsSubscriber._VoiceMail) { this._VoiceMail = updatedNgfsSubscriber._VoiceMail; updated = true; }

 1597:             if (this._InterceptReferral != updatedNgfsSubscriber._InterceptReferral) { this._InterceptReferral = updatedNgfsSubscriber._InterceptReferral; updated = true; }

 1598:             if (this._DialingPlan != updatedNgfsSubscriber._DialingPlan) { this._DialingPlan = updatedNgfsSubscriber._DialingPlan; updated = true; }

 1599:             if (this._HSSPrivateId != updatedNgfsSubscriber._HSSPrivateId) { this._HSSPrivateId = updatedNgfsSubscriber._HSSPrivateId; updated = true; }

 1600:             if (this._HSSPublicIdCustom != updatedNgfsSubscriber._HSSPublicIdCustom) { this._HSSPublicIdCustom = updatedNgfsSubscriber._HSSPublicIdCustom; updated = true; }

 1601:             if (this._AcctCodes != updatedNgfsSubscriber._AcctCodes) { this._AcctCodes = updatedNgfsSubscriber._AcctCodes; updated = true; }

 1602:             if (this._SeqRinging != updatedNgfsSubscriber._SeqRinging) { this._SeqRinging = updatedNgfsSubscriber._SeqRinging; updated = true; }

 1603:             if (this._AuthCodeService != updatedNgfsSubscriber._AuthCodeService) { this._AuthCodeService = updatedNgfsSubscriber._AuthCodeService; updated = true; }

 1604:             if (this._MLHGNoHuntMember != updatedNgfsSubscriber._MLHGNoHuntMember) { this._MLHGNoHuntMember = updatedNgfsSubscriber._MLHGNoHuntMember; updated = true; }

 1605:             if (this._MultilineHuntGroup != updatedNgfsSubscriber._MultilineHuntGroup) { this._MultilineHuntGroup = updatedNgfsSubscriber._MultilineHuntGroup; updated = true; }

 1606:             if (this._CallPickupOrig != updatedNgfsSubscriber._CallPickupOrig) { this._CallPickupOrig = updatedNgfsSubscriber._CallPickupOrig; updated = true; }

 1607:             if (this._CallPickupTerm != updatedNgfsSubscriber._CallPickupTerm) { this._CallPickupTerm = updatedNgfsSubscriber._CallPickupTerm; updated = true; }

 1608:             if (this._Attendant != updatedNgfsSubscriber._Attendant) { this._Attendant = updatedNgfsSubscriber._Attendant; updated = true; }

 1609:             if (this._AttendantServer != updatedNgfsSubscriber._AttendantServer) { this._AttendantServer = updatedNgfsSubscriber._AttendantServer; updated = true; }

 1610:             if (this._CallPark != updatedNgfsSubscriber._CallPark) { this._CallPark = updatedNgfsSubscriber._CallPark; updated = true; }

 1611:             if (this._DirectedGroup != updatedNgfsSubscriber._DirectedGroup) { this._DirectedGroup = updatedNgfsSubscriber._DirectedGroup; updated = true; }

 1612:             if (this._RemoteUser != updatedNgfsSubscriber._RemoteUser) { this._RemoteUser = updatedNgfsSubscriber._RemoteUser; updated = true; }

 1613:             if (this._TransferToUsersVM != updatedNgfsSubscriber._TransferToUsersVM) { this._TransferToUsersVM = updatedNgfsSubscriber._TransferToUsersVM; updated = true; }

 1614:             if (this._FlexCallingLineId != updatedNgfsSubscriber._FlexCallingLineId) { this._FlexCallingLineId = updatedNgfsSubscriber._FlexCallingLineId; updated = true; }

 1615:             if (this._ExtensionDevice != updatedNgfsSubscriber._ExtensionDevice) { this._ExtensionDevice = updatedNgfsSubscriber._ExtensionDevice; updated = true; }

 1616:             if (this._PSIServer != updatedNgfsSubscriber._PSIServer) { this._PSIServer = updatedNgfsSubscriber._PSIServer; updated = true; }

 1617:             if (this._ClosedUserGroup != updatedNgfsSubscriber._ClosedUserGroup) { this._ClosedUserGroup = updatedNgfsSubscriber._ClosedUserGroup; updated = true; }

 1618:             if (this._OneDigitSpeedDial != updatedNgfsSubscriber._OneDigitSpeedDial) { this._OneDigitSpeedDial = updatedNgfsSubscriber._OneDigitSpeedDial; updated = true; }

 1619:             if (this._TwoDigitSpeedDial != updatedNgfsSubscriber._TwoDigitSpeedDial) { this._TwoDigitSpeedDial = updatedNgfsSubscriber._TwoDigitSpeedDial; updated = true; }

 1620:             if (this._ExtensionServer != updatedNgfsSubscriber._ExtensionServer) { this._ExtensionServer = updatedNgfsSubscriber._ExtensionServer; updated = true; }

 1621:             if (this._SelectiveAlert != updatedNgfsSubscriber._SelectiveAlert) { this._SelectiveAlert = updatedNgfsSubscriber._SelectiveAlert; updated = true; }

 1622:             if (this._ShortCodeTranslate != updatedNgfsSubscriber._ShortCodeTranslate) { this._ShortCodeTranslate = updatedNgfsSubscriber._ShortCodeTranslate; updated = true; }

 1623:             if (this._ReminderCall != updatedNgfsSubscriber._ReminderCall) { this._ReminderCall = updatedNgfsSubscriber._ReminderCall; updated = true; }

 1624:             if (this._SetTZPath != updatedNgfsSubscriber._SetTZPath) { this._SetTZPath = updatedNgfsSubscriber._SetTZPath; updated = true; }

 1625:             if (this._InhibitIncomingFwd != updatedNgfsSubscriber._InhibitIncomingFwd) { this._InhibitIncomingFwd = updatedNgfsSubscriber._InhibitIncomingFwd; updated = true; }

 1626:             if (this._BearerBasedCallFwd != updatedNgfsSubscriber._BearerBasedCallFwd) { this._BearerBasedCallFwd = updatedNgfsSubscriber._BearerBasedCallFwd; updated = true; }

 1627:             if (this._TimeOriginatedRC != updatedNgfsSubscriber._TimeOriginatedRC) { this._TimeOriginatedRC = updatedNgfsSubscriber._TimeOriginatedRC; updated = true; }

 1628:             if (this._MobileDMS != updatedNgfsSubscriber._MobileDMS) { this._MobileDMS = updatedNgfsSubscriber._MobileDMS; updated = true; }

 1629:             if (this._MLPP != updatedNgfsSubscriber._MLPP) { this._MLPP = updatedNgfsSubscriber._MLPP; updated = true; }

 1630:             if (this._MusicOnHold != updatedNgfsSubscriber._MusicOnHold) { this._MusicOnHold = updatedNgfsSubscriber._MusicOnHold; updated = true; }

 1631:             if (this._MiRingback != updatedNgfsSubscriber._MiRingback) { this._MiRingback = updatedNgfsSubscriber._MiRingback; updated = true; }

 1632:             if (this._SelNomadicBlocking != updatedNgfsSubscriber._SelNomadicBlocking) { this._SelNomadicBlocking = updatedNgfsSubscriber._SelNomadicBlocking; updated = true; }

 1633:             if (this._AutoDial != updatedNgfsSubscriber._AutoDial) { this._AutoDial = updatedNgfsSubscriber._AutoDial; updated = true; }

 1634:             if (this._CallForwardingDefault != updatedNgfsSubscriber._CallForwardingDefault) { this._CallForwardingDefault = updatedNgfsSubscriber._CallForwardingDefault; updated = true; }

 1635:             if (this._CCBS != updatedNgfsSubscriber._CCBS) { this._CCBS = updatedNgfsSubscriber._CCBS; updated = true; }

 1636:             if (this._BlockCCBS != updatedNgfsSubscriber._BlockCCBS) { this._BlockCCBS = updatedNgfsSubscriber._BlockCCBS; updated = true; }

 1637:             if (this._AINFeatcodeTrigger != updatedNgfsSubscriber._AINFeatcodeTrigger) { this._AINFeatcodeTrigger = updatedNgfsSubscriber._AINFeatcodeTrigger; updated = true; }

 1638:             if (this._AINPDPcodeTrigger != updatedNgfsSubscriber._AINPDPcodeTrigger) { this._AINPDPcodeTrigger = updatedNgfsSubscriber._AINPDPcodeTrigger; updated = true; }

 1639:             if (this._AINOHDTrigger != updatedNgfsSubscriber._AINOHDTrigger) { this._AINOHDTrigger = updatedNgfsSubscriber._AINOHDTrigger; updated = true; }

 1640:             if (this._AINTATTrigger != updatedNgfsSubscriber._AINTATTrigger) { this._AINTATTrigger = updatedNgfsSubscriber._AINTATTrigger; updated = true; }

 1641:             if (this._GLSAccess != updatedNgfsSubscriber._GLSAccess) { this._GLSAccess = updatedNgfsSubscriber._GLSAccess; updated = true; }

 1642:             if (this._SharedNumber != updatedNgfsSubscriber._SharedNumber) { this._SharedNumber = updatedNgfsSubscriber._SharedNumber; updated = true; }

 1643:             if (this._CallDeflection != updatedNgfsSubscriber._CallDeflection) { this._CallDeflection = updatedNgfsSubscriber._CallDeflection; updated = true; }

 1644:             if (this._AutoAttendant != updatedNgfsSubscriber._AutoAttendant) { this._AutoAttendant = updatedNgfsSubscriber._AutoAttendant; updated = true; }

 1645:             if (this._AdjunctTerminating != updatedNgfsSubscriber._AdjunctTerminating) { this._AdjunctTerminating = updatedNgfsSubscriber._AdjunctTerminating; updated = true; }

 1646:             if (this._OutgoingCallBarring != updatedNgfsSubscriber._OutgoingCallBarring) { this._OutgoingCallBarring = updatedNgfsSubscriber._OutgoingCallBarring; updated = true; }

 1647:             if (this._RDigitParms != updatedNgfsSubscriber._RDigitParms) { this._RDigitParms = updatedNgfsSubscriber._RDigitParms; updated = true; }

 1648:             if (this._TransitRouting != updatedNgfsSubscriber._TransitRouting) { this._TransitRouting = updatedNgfsSubscriber._TransitRouting; updated = true; }

 1649:             if (this._LocationNumber != updatedNgfsSubscriber._LocationNumber) { this._LocationNumber = updatedNgfsSubscriber._LocationNumber; updated = true; }

 1650:             if (this._FemtoBSR != updatedNgfsSubscriber._FemtoBSR) { this._FemtoBSR = updatedNgfsSubscriber._FemtoBSR; updated = true; }

 1651:             if (this._GeneralReset != updatedNgfsSubscriber._GeneralReset) { this._GeneralReset = updatedNgfsSubscriber._GeneralReset; updated = true; }

 1652:             if (this._Metering != updatedNgfsSubscriber._Metering) { this._Metering = updatedNgfsSubscriber._Metering; updated = true; }

 1653:             if (this._PinService != updatedNgfsSubscriber._PinService) { this._PinService = updatedNgfsSubscriber._PinService; updated = true; }

 1654:             if (this._WholeSale != updatedNgfsSubscriber._WholeSale) { this._WholeSale = updatedNgfsSubscriber._WholeSale; updated = true; }

 1655:             if (this._SpareService != updatedNgfsSubscriber._SpareService) { this._SpareService = updatedNgfsSubscriber._SpareService; updated = true; }

 1656:             if (this._UseHoldAnnouncement != updatedNgfsSubscriber._UseHoldAnnouncement) { this._UseHoldAnnouncement = updatedNgfsSubscriber._UseHoldAnnouncement; updated = true; }

 1657:             if (this._VPNDialingAndDisplay != updatedNgfsSubscriber._VPNDialingAndDisplay) { this._VPNDialingAndDisplay = updatedNgfsSubscriber._VPNDialingAndDisplay; updated = true; }

 1658:             if (this._PriorityModeCalling != updatedNgfsSubscriber._PriorityModeCalling) { this._PriorityModeCalling = updatedNgfsSubscriber._PriorityModeCalling; updated = true; }

 1659:             if (this._OneNumber != updatedNgfsSubscriber._OneNumber) { this._OneNumber = updatedNgfsSubscriber._OneNumber; updated = true; }

 1660:             if (this._AdvancedConference != updatedNgfsSubscriber._AdvancedConference) { this._AdvancedConference = updatedNgfsSubscriber._AdvancedConference; updated = true; }

 1661:             if (this._AnswConfirm != updatedNgfsSubscriber._AnswConfirm) { this._AnswConfirm = updatedNgfsSubscriber._AnswConfirm; updated = true; }

 1662:             if (this._OnlineCharging != updatedNgfsSubscriber._OnlineCharging) { this._OnlineCharging = updatedNgfsSubscriber._OnlineCharging; updated = true; }

 1663:             if (this._VideoCallRouting != updatedNgfsSubscriber._VideoCallRouting) { this._VideoCallRouting = updatedNgfsSubscriber._VideoCallRouting; updated = true; }

 1664:             if (this._LisInVMRescue != updatedNgfsSubscriber._LisInVMRescue) { this._LisInVMRescue = updatedNgfsSubscriber._LisInVMRescue; updated = true; }

 1665:             if (this._EndpointValidation != updatedNgfsSubscriber._EndpointValidation) { this._EndpointValidation = updatedNgfsSubscriber._EndpointValidation; updated = true; }

 1666:             if (this._ParlayRest != updatedNgfsSubscriber._ParlayRest) { this._ParlayRest = updatedNgfsSubscriber._ParlayRest; updated = true; }

 1667:             if (this._AltRtToPBX != updatedNgfsSubscriber._AltRtToPBX) { this._AltRtToPBX = updatedNgfsSubscriber._AltRtToPBX; updated = true; }

 1668:             if (this._WAMAccess != updatedNgfsSubscriber._WAMAccess) { this._WAMAccess = updatedNgfsSubscriber._WAMAccess; updated = true; }

 1669:             if (this._ISDN != updatedNgfsSubscriber._ISDN) { this._ISDN = updatedNgfsSubscriber._ISDN; updated = true; }

 1670:             if (this._LocaleParms != updatedNgfsSubscriber._LocaleParms) { this._LocaleParms = updatedNgfsSubscriber._LocaleParms; updated = true; }

 1671:             if (this._VASI != updatedNgfsSubscriber._VASI) { this._VASI = updatedNgfsSubscriber._VASI; updated = true; }

 1672:             if (this._LocBasedRedirect != updatedNgfsSubscriber._LocBasedRedirect) { this._LocBasedRedirect = updatedNgfsSubscriber._LocBasedRedirect; updated = true; }

 1673:             if (this._CallLimitGroup != updatedNgfsSubscriber._CallLimitGroup) { this._CallLimitGroup = updatedNgfsSubscriber._CallLimitGroup; updated = true; }

 1674:             if (this._AlternateCharging != updatedNgfsSubscriber._AlternateCharging) { this._AlternateCharging = updatedNgfsSubscriber._AlternateCharging; updated = true; }

 1675:             if (this._CallForwardNotReach != updatedNgfsSubscriber._CallForwardNotReach) { this._CallForwardNotReach = updatedNgfsSubscriber._CallForwardNotReach; updated = true; }

 1676:             if (this._MultiDevicesPUID != updatedNgfsSubscriber._MultiDevicesPUID) { this._MultiDevicesPUID = updatedNgfsSubscriber._MultiDevicesPUID; updated = true; }

 1677:             if (this._ManagedCallRec != updatedNgfsSubscriber._ManagedCallRec) { this._ManagedCallRec = updatedNgfsSubscriber._ManagedCallRec; updated = true; }

 1678:             if (this._GeoRedundancyData != updatedNgfsSubscriber._GeoRedundancyData) { this._GeoRedundancyData = updatedNgfsSubscriber._GeoRedundancyData; updated = true; }

 1679:  

 1680:             if (this.SubParty != updatedNgfsSubscriber.SubParty) { this.SubParty = updatedNgfsSubscriber.SubParty; updated = true; }

 1681:  

 1682:             if (this.UserId != updatedNgfsSubscriber.UserId) { this.UserId = updatedNgfsSubscriber.UserId; updated = true; }

 1683:  

 1684:             if (updated) this.Updated = DateTime.UtcNow.AddHours(3);

 1685:  

 1686:             return updated;

 1687:         }

 1688:  

 1689:         ////////////////////////////////////////////////////////////////////////////

 1690:         ////////////////////////////////////////////////////////////////////////////

 1691:     }

 1692:  

 1693:     ////////////////////////////////////////////////////////////////////////////

 1694:     ////////////////////////////////////////////////////////////////////////////

 1695: }