ProtocolMapper.n

  [Record]
  public class ProtocolMapper : MapperBase
  {
    #region Protocols

    [NamedOverloads(src, purchaseProtocolZK
                       , purchaseProtocolOSZ
                       , purchaseProtocolPAAE
                       , purchaseProtocolPAAE94FZ
                       , purchaseProtocolPAEP
                       , purchaseProtocolPAOA
                       , purchaseProtocolRZ1AE
                       , purchaseProtocolRZ2AE
                       , purchaseProtocolRZAE
                       , purchaseProtocolRZOA
                       , purchaseProtocolRZOK
                       , purchaseProtocolVK
                       , purchaseProtocol            )]
    public Protocol(src: purchaseProtocol) : ProtocolType
    {           
      def data = typeOf match(src)
      {
        | purchaseProtocolZK        => src.body.item.purchaseProtocolZKData;
        | purchaseProtocolOSZ       => src.body.item.purchaseProtocolOSZData;   
        | purchaseProtocolPAAE      => src.body.item.purchaseProtocolPAAEData;
        | purchaseProtocolPAAE94FZ  => src.body.item.purchaseProtocolPAAE94FZData;
        | purchaseProtocolPAEP      => src.body.item.purchaseProtocolPAEPData;
        | purchaseProtocolPAOA      => src.body.item.purchaseProtocolPAOAData;
        | purchaseProtocolRZ1AE     => src.body.item.purchaseProtocolRZ1AEData;
        | purchaseProtocolRZ2AE     => src.body.item.purchaseProtocolRZ2AEData;
        | purchaseProtocolRZAE      => src.body.item.purchaseProtocolRZAEData;
        | purchaseProtocolRZOA      => src.body.item.purchaseProtocolRZOAData; 
        | purchaseProtocolRZOK      => src.body.item.purchaseProtocolRZOKData;
        | purchaseProtocolVK        => src.body.item.purchaseProtocolVKData;
        | purchaseProtocol          => src.body.item.purchaseProtocolData;   
      }
      entity <-
      {            
        Attachments = attachments(data.attachments);
        AbandonedLots = 
          from (data.missedContest == true, 
                lot in data.lotApplicationsList) 
          select entity <-
          {
            AbandonedReason <- 
            { 
              ReasonInfo = data.missedReason 
            }
            LotNumber = typeOf match(src)
            {
              | purchaseProtocolPAAE
              | purchaseProtocolPAAE94FZ
              | purchaseProtocolPAOA
              | purchaseProtocolVK
              | purchaseProtocol => lot.lot.ordinalNumber;
              | _                => lot.ordinalNumber;
            }
          }
        Commission = typeOf match(src)
        {
          | purchaseProtocolZK
          | purchaseProtocolPAAE
          | purchaseProtocolPAAE94FZ
          | purchaseProtocolPAEP
          | purchaseProtocol => null; 
          | _                => entity <- 
            {
              Name = data.commissionName;
              AdditionInfo = data.commissionResult;
            }
        }
        IdentityInfo <-
        {
          ProtocolIdentity = businessKey(data.purchaseInfo.purchaseNoticeNumber, data.registrationNumber); 
          TenderIdentity = data.purchaseInfo.purchaseNoticeNumber;
        }
        MainInfo <-
        {
          ProtocolDate = typeOf match(src)
          {
            | purchaseProtocolPAAE
            | purchaseProtocolPAEP     => null;
            | purchaseProtocolPAAE94FZ => date(data.auctionStartDate);
            | _                        => date(data.procedureDate);
          }
          def protocolType = typeOf match(src)
          {
            | purchaseProtocolOSZ
            | purchaseProtocolPAAE
            | purchaseProtocolPAEP
            | purchaseProtocolPAOA
            | purchaseProtocolRZ2AE
            | purchaseProtocolZK       => ProtocolTypeMainInfoProtocolType.ProtocolFinal;
            | purchaseProtocolVK       => ProtocolTypeMainInfoProtocolType.ProtocolOpening;
            | purchaseProtocolRZ1AE
            | purchaseProtocolRZAE
            | purchaseProtocolRZOA
            | purchaseProtocolRZOK     => ProtocolTypeMainInfoProtocolType.ProtocolAdmission;
            | purchaseProtocol         => ProtocolTypeMainInfoProtocolType.ProtocolPurchase;
            | purchaseProtocolPAAE94FZ => ProtocolTypeMainInfoProtocolType.ProtocolExecuting;
          }
          ProtocolType = nullable(protocolType);
          SignDate = typeOf match(src)
          {
            | purchaseProtocolPAAE     => date(data.procedureDate);
            | purchaseProtocolPAAE94FZ => date(data.auctionEndDate);
            | _                        => date(data.protocolSignDate);
          }
        }
        OptionalInfo <-
        {
          ProtocolKindInfo = src.GetType().Name;
          PlaceInfo = typeOf match(src)
          {
		        | purchaseProtocolPAAE
		        | purchaseProtocolPAAE94FZ
		        | purchaseProtocolPAEP
		        | purchaseProtocolRZ1AE
		        | purchaseProtocolRZ2AE => null;
		        | _ => data.procedurePlace;
          }
        }
        PublishInfo <-
        {
          Date = date(data.publicationDateTime ?? src.header.createDateTime);
          ModificationInfo = data.modificationDescription;
          Url = data.urlOOS;
          Version = int'(data.version);
        }
      }
    }
    
    public Protocol_purchaseProtocolCancellation(protocol : ProtocolType, cancel : protocolCancellation) : ProtocolType
    {
      def data = cancel.body.item.protocolCancellationData;
      protocol <<-
      {
        CancelInfo <-
        {
          CancelledDate = date(data.cancellationDate ?? cancel.header.createDateTime);
          CancelledReason <-
          {
              ReasonInfo = data.сancellationReason;
          }
        }
      }
    }
        
    #endregion
        
    #region Offer
    
    [NamedOverloads(src, purchaseProtocolZK
                       , purchaseProtocolOSZ
                       , purchaseProtocolPAAE
                       , purchaseProtocolPAAE94FZ
                       , purchaseProtocolPAEP
                       , purchaseProtocolPAOA
                       , purchaseProtocolRZ1AE
                       , purchaseProtocolRZ2AE
                       , purchaseProtocolRZAE
                       , purchaseProtocolRZOA
                       , purchaseProtocolRZOK
                       , purchaseProtocolVK
                       , purchaseProtocol            )]
    public Offers(src : purchaseProtocolRZAE) : array[OfferType]
    {
      def protocol = typeOf match(src)
      {
        | purchaseProtocolZK        => src.body.item.purchaseProtocolZKData;
        | purchaseProtocolOSZ       => src.body.item.purchaseProtocolOSZData;   
        | purchaseProtocolPAAE      => src.body.item.purchaseProtocolPAAEData;
        | purchaseProtocolPAAE94FZ  => src.body.item.purchaseProtocolPAAE94FZData;
        | purchaseProtocolPAEP      => src.body.item.purchaseProtocolPAEPData;
        | purchaseProtocolPAOA      => src.body.item.purchaseProtocolPAOAData;
        | purchaseProtocolRZ1AE     => src.body.item.purchaseProtocolRZ1AEData;
        | purchaseProtocolRZ2AE     => src.body.item.purchaseProtocolRZ2AEData;
        | purchaseProtocolRZAE      => src.body.item.purchaseProtocolRZAEData;
        | purchaseProtocolRZOA      => src.body.item.purchaseProtocolRZOAData; 
        | purchaseProtocolRZOK      => src.body.item.purchaseProtocolRZOKData;
        | purchaseProtocolVK        => src.body.item.purchaseProtocolVKData;
        | purchaseProtocol          => src.body.item.purchaseProtocolData;   
      }
      def getLot(lotApplications)
      {
        typeOf match(src)
        {
          | purchaseProtocolPAAE      
          | purchaseProtocolPAAE94FZ  
          | purchaseProtocolPAOA      
          | purchaseProtocol
          | purchaseProtocolVK => lotApplications.lot
          | _                  => lotApplications;
        }
      }
      
      from(lotApplications in protocol.lotApplicationsList,
           lot = getLot(lotApplications),
           { app in lotApplications?.application; number = 1; number++ })
      select entity <-
      {
        IdentityInfo <-
        {
          LotNumber = lot.ordinalNumber;
          OfferNumber = offerNum(app.applicationNumber, number);
          TenderIdentity = protocol.purchaseInfo.purchaseNoticeNumber;
        }
        MainInfo <-
        {
          def appCurrency : string = typeOf match(src)
          {
            | purchaseProtocolPAAE
            | purchaseProtocolPAAE94FZ
            | purchaseProtocolPAOA => 
              def item = lotApplications?.lotParameters?.ItemChoice;
              choice(item) when(item.currency(x)) x.code;
            | purchaseProtocolOSZ
            | purchaseProtocolRZAE
            | purchaseProtocolRZ1AE
            | purchaseProtocolRZ2AE
            | purchaseProtocolRZOA
            | purchaseProtocolRZOK => null;
            | _ => 
              def query = 
                from item in app.ItemsChoice
                select choice(item) when(item.currency(x)) x.code;
              query.FirstOrDefault(x => x != null);
          }
          def lotCurrency = typeOf match(src)
          {
            | purchaseProtocolZK       
            | purchaseProtocolPAEP     
            | purchaseProtocolRZ1AE    
            | purchaseProtocolRZ2AE    
            | purchaseProtocolRZAE     
            | purchaseProtocolRZOA     
            | purchaseProtocolVK       
            | purchaseProtocol =>
              def query = 
                from item in lot.ItemsChoice
                select choice(item) when(item.currency(x)) x.code;
              query.FirstOrDefault(x => x != null);
            | _ => null;
          }
          Currency = appCurrency ?? lotCurrency;
          IsRejected = typeOf match(src)
          {
            | purchaseProtocolRZAE
            | purchaseProtocolRZOA
            | purchaseProtocolRZ1AE
            | purchaseProtocolRZ2AE
            | purchaseProtocolRZOK
            | purchaseProtocol => isRejected(app.accepted);
            | _ => null;
          }
          def appPrice = typeOf match(src)
          {
            | purchaseProtocolPAAE
            | purchaseProtocolPAOA =>
              def item = app.Item1Choice;
              choice(item) when(item.lastPrice(x)) decimal'(x) 
            | purchaseProtocolPAAE94FZ
            | purchaseProtocolRZ2AE => 
              def item = app.ItemChoice;
              choice(item) when(item.lastPrice(x)) decimal'(x)
            | purchaseProtocolOSZ
            | purchaseProtocolRZAE
            | purchaseProtocolRZ1AE
            | purchaseProtocolRZOA
            | purchaseProtocolRZOK => null;
            | purchaseProtocolPAEP =>
              def query = 
                from item in app.ItemsChoice
                select choice(item) when(item.lastPrice(x)) decimal'(x);
              query.FirstOrDefault(x => x != null);
            | _ => 
              def query = 
                from item in app.ItemsChoice
                select choice(item) when(item.price(x)) decimal'(x);
              query.FirstOrDefault(x => x != null);
          }
          def lotPrice = typeOf match(src)
          {
            | purchaseProtocolPAEP
            | purchaseProtocolPAOA
            | purchaseProtocolRZ1AE
            | purchaseProtocolRZ2AE
            | purchaseProtocolRZAE
            | purchaseProtocolRZOA
            | purchaseProtocolVK
            | purchaseProtocol =>
              def query = 
                from item in lot.ItemsChoice
                select choice(item) when(item.initialSum(x)) decimal'(x);
              query.FirstOrDefault(x => x != null);
            | _ => null;
          }
          OfferedPrice = (appPrice : decimal?) ?? (lotPrice : decimal?);
          Rank = typeOf match(src)
          {
            | purchaseProtocolOSZ
            | purchaseProtocolPAAE
            | purchaseProtocolPAAE94FZ
            | purchaseProtocolPAOA 
            | purchaseProtocolRZ2AE => decimal'(app.applicationRate);
            | _ => null;
          }
          Result = typeOf match(src)
          {
            | purchaseProtocol
            | purchaseProtocolZK   => result(app.winnerIndication);
            | purchaseProtocolOSZ
            | purchaseProtocolPAAE
            | purchaseProtocolPAOA => result(app.applicationPlace);
            | _ => null;
          }
          SubmissionDate = typeOf match(src)
          {
            | purchaseProtocolPAAE
            | purchaseProtocolPAOA
            | purchaseProtocolOSZ
            | purchaseProtocolPAAE94FZ
            | purchaseProtocolPAEP
            | purchaseProtocolRZOK => null;
            | _ => date(app.applicationDate)
          }
        }
        OptionalInfo <-
        {
          RejectedReason = typeOf match(src)
          {
            | purchaseProtocolZK => entity when(app.rejectionReason != null) <-
              {
                ReasonInfo = app.rejectionReason;
              }
            | _ => null;
          }
        }    
        Participants = typeOf match(src)
        {
          | purchaseProtocolPAAE94FZ
          | purchaseProtocolRZ1AE => null;
          | _ => collection supplier(app);
        }
        PublishInfo <-
        {
          Date = date(protocol.publicationDateTime ?? src.header.createDateTime);
        }
      }
    }

        
    #endregion
        
    #region Helpers

    result([Null]src : winnerIndication3?) : OfferTypeMainInfoResult?
    {
      match(src.Value) 
      {
        | winnerIndication3.W => OfferTypeMainInfoResult.Winner
        | winnerIndication3.F => OfferTypeMainInfoResult.LikeWinner
        | winnerIndication3.S => OfferTypeMainInfoResult.Second
      }
    }
        
    result([Null] src : winnerIndication?) : OfferTypeMainInfoResult?
    {
      match(src.Value) 
      {
        | winnerIndication.F => OfferTypeMainInfoResult.Winner
        | winnerIndication.S => OfferTypeMainInfoResult.Second
        | winnerIndication.T => OfferTypeMainInfoResult.Bidder
        | winnerIndication.B => OfferTypeMainInfoResult.Bidder
        | winnerIndication.N => null;
      }
    }
          
    isRejected([Null]src : acceptedType?) : bool?
    {
      match(src.Value)
      {
        | acceptedType.F => true;
        | acceptedType.T => false;
      }
    }
    
    isRejected([Null]src : acceptedType2?) : bool?
    {
      match(src.Value)
      {
        | acceptedType2.F => true;
        | acceptedType2.T => false;
        | acceptedType2.N => null;
      }
    }
        
    [Overloads(src, protocolZKApplicationType
                  , protocolOSZApplicationType
                  , protocolPAOAApplicationType
                  , protocolPAEPApplicationType
                  , protocolRZOAApplicationType
                  , protocolRZOKApplicationType
                  , protocolVKApplicationType
                  , protocolApplicationType
                  , protocolRZ2AEApplicationType)]
    supplier(src : protocolRZ2AEApplicationType) : OfferTypeParticipant
    {
      def item = typeOf match(src)
      {
        | protocolRZ2AEApplicationType => src.Item1Choice;
        | _                            => src.ItemChoice;
      }
      choice(item)
      {
        when(item.supplierInfo(x)) entity <-
        {
          IdentityInfo <- { LocalIdentity = str(Guid.NewGuid()); }
          Role = OfferTypeParticipantRole.Supplier;
          Person <-
          {
            MainInfo <-
            {
              FullName = x.name;
              INN = x.inn;
              KPP = x.kpp;
              OGRN = x.ogrn;
            }
            OptionalInfo = entity when (x?.address != null) <- 
            {
                PhysicalAddress = x?.address
            }
          }
        }
        when(item.nonResidentInfo(x)) entity <-
        {
          IdentityInfo <- { LocalIdentity = str(Guid.NewGuid()); }
          Role = OfferTypeParticipantRole.Supplier;
          Person <-
          {
            MainInfo <-  { FullName = x.name; }
            OptionalInfo <- { PhysicalAddress = x.address; }
          }
        }
      }
    }
                
    #endregion
  }