/// <summary>
        /// Create an OICP PushAuthenticationDataRequest XML/SOAP request.
        /// </summary>
        /// <param name="ProviderAuthenticationData">The e-mobility provider authentication data.</param>
        /// <param name="ProviderId">An e-mobility provider identification.</param>
        /// <param name="OICPAction">An optional OICP action.</param>
        ///
        /// <param name="Timestamp">The optional timestamp of the request.</param>
        /// <param name="CancellationToken">An optional token to cancel this request.</param>
        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
        /// <param name="RequestTimeout">An optional timeout for this request.</param>
        public PushAuthenticationDataRequest(ProviderAuthenticationData ProviderAuthenticationData,
                                             ActionTypes OICPAction = ActionTypes.fullLoad,

                                             DateTime?Timestamp = null,
                                             CancellationToken?CancellationToken = null,
                                             EventTracking_Id EventTrackingId    = null,
                                             TimeSpan?RequestTimeout             = null)

            : base(Timestamp,
                   CancellationToken,
                   EventTrackingId,
                   RequestTimeout)

        {
            #region Initial checks

            if (ProviderAuthenticationData == null)
            {
                throw new ArgumentNullException(nameof(ProviderAuthenticationData), "The given enumeration of authorization identifications must not be null!");
            }

            #endregion

            this.ProviderAuthenticationData = ProviderAuthenticationData;
            this.ProviderId = ProviderId;
            this.OICPAction = OICPAction;
        }
 /// <summary>
 /// Return the HashCode of this object.
 /// </summary>
 /// <returns>The HashCode of this object.</returns>
 public override Int32 GetHashCode()
 {
     unchecked
     {
         return(ProviderAuthenticationData.GetHashCode() * 5 ^
                ProviderId.GetHashCode() * 3 ^
                OICPAction.GetHashCode());
     }
 }
        /// <summary>
        /// Try to parse the given XML representation of an OICP push authentication data request.
        /// </summary>
        /// <param name="PushAuthenticationDataRequestXML">The XML to parse.</param>
        /// <param name="PushAuthenticationDataRequest">The parsed push authentication data request.</param>
        /// <param name="CustomPushAuthenticationDataRequestParser">A delegate to parse custom PushAuthenticationData requests.</param>
        /// <param name="CustomProviderAuthenticationDataParser">A delegate to parse custom ProviderAuthenticationData XML elements.</param>
        /// <param name="CustomIdentificationParser">A delegate to parse custom Identification XML elements.</param>
        /// <param name="CustomRFIDIdentificationParser">A delegate to parse custom RFID identification XML elements.</param>
        /// <param name="OnException">An optional delegate called whenever an exception occured.</param>
        ///
        /// <param name="Timestamp">The optional timestamp of the request.</param>
        /// <param name="CancellationToken">An optional token to cancel this request.</param>
        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
        /// <param name="RequestTimeout">An optional timeout for this request.</param>
        public static Boolean TryParse(XElement PushAuthenticationDataRequestXML,
                                       out PushAuthenticationDataRequest PushAuthenticationDataRequest,
                                       CustomXMLParserDelegate <PushAuthenticationDataRequest> CustomPushAuthenticationDataRequestParser = null,
                                       CustomXMLParserDelegate <ProviderAuthenticationData> CustomProviderAuthenticationDataParser       = null,
                                       CustomXMLParserDelegate <Identification> CustomIdentificationParser         = null,
                                       CustomXMLParserDelegate <RFIDIdentification> CustomRFIDIdentificationParser = null,
                                       OnExceptionDelegate OnException = null,

                                       DateTime?Timestamp = null,
                                       CancellationToken?CancellationToken = null,
                                       EventTracking_Id EventTrackingId    = null,
                                       TimeSpan?RequestTimeout             = null)

        {
            try
            {
                if (PushAuthenticationDataRequestXML.Name != OICPNS.AuthenticationData + "eRoamingPushAuthenticationData")
                {
                    PushAuthenticationDataRequest = null;
                    return(false);
                }

                PushAuthenticationDataRequest = new PushAuthenticationDataRequest(

                    PushAuthenticationDataRequestXML.MapElement(OICPNS.AuthenticationData + "ProviderAuthenticationData",
                                                                (xml, e) => ProviderAuthenticationData.Parse(xml,
                                                                                                             CustomProviderAuthenticationDataParser,
                                                                                                             CustomIdentificationParser,
                                                                                                             CustomRFIDIdentificationParser,
                                                                                                             e),
                                                                OnException),

                    PushAuthenticationDataRequestXML.MapValueOrFail(OICPNS.AuthenticationData + "ActionType",
                                                                    ActionTypesExtentions.Parse),

                    Timestamp,
                    CancellationToken,
                    EventTrackingId,
                    RequestTimeout);


                if (CustomPushAuthenticationDataRequestParser != null)
                {
                    PushAuthenticationDataRequest = CustomPushAuthenticationDataRequestParser(PushAuthenticationDataRequestXML,
                                                                                              PushAuthenticationDataRequest);
                }

                return(true);
            }
            catch (Exception e)
            {
                OnException?.Invoke(DateTime.UtcNow, PushAuthenticationDataRequestXML, e);

                PushAuthenticationDataRequest = null;
                return(false);
            }
        }
        /// <summary>
        /// Compares two push authentication data requests for equality.
        /// </summary>
        /// <param name="PushAuthenticationDataRequest">A push authentication data request to compare with.</param>
        /// <returns>True if both match; False otherwise.</returns>
        public override Boolean Equals(PushAuthenticationDataRequest PushAuthenticationDataRequest)
        {
            if ((Object)PushAuthenticationDataRequest == null)
            {
                return(false);
            }

            return(ProviderAuthenticationData.Equals(PushAuthenticationDataRequest.ProviderAuthenticationData) &&
                   ProviderId.Equals(PushAuthenticationDataRequest.ProviderId) &&
                   OICPAction.Equals(PushAuthenticationDataRequest.OICPAction));
        }
        /// <summary>
        /// Return a XML representation of this object.
        /// </summary>
        /// <param name="CustomPushAuthenticationDataRequestSerializer">A delegate to customize the serialization of PushAuthenticationDataRequest requests.</param>
        public XElement ToXML(CustomXMLSerializerDelegate <PushAuthenticationDataRequest> CustomPushAuthenticationDataRequestSerializer = null)
        {
            var XML = new XElement(OICPNS.AuthenticationData + "eRoamingPushAuthenticationData",

                                   new XElement(OICPNS.AuthenticationData + "ActionType", OICPAction.AsString()),

                                   ProviderAuthenticationData.ToXML()


                                   );

            return(CustomPushAuthenticationDataRequestSerializer != null
                       ? CustomPushAuthenticationDataRequestSerializer(this, XML)
                       : XML);
        }
示例#6
0
        PushAuthenticationData(this IEMPClient IEMPClient,
                               ProviderAuthenticationData ProviderAuthenticationData,
                               ActionTypes Action = ActionTypes.fullLoad,

                               DateTime?Timestamp = null,
                               CancellationToken?CancellationToken = null,
                               EventTracking_Id EventTrackingId    = null,
                               TimeSpan?RequestTimeout             = null)


        => IEMPClient.PushAuthenticationData(new PushAuthenticationDataRequest(ProviderAuthenticationData,
                                                                               Action,

                                                                               Timestamp,
                                                                               CancellationToken,
                                                                               EventTrackingId,
                                                                               RequestTimeout ?? IEMPClient.RequestTimeout));
        /// <summary>
        /// Return a text-representation of this object.
        /// </summary>
        public override String ToString()

        => String.Concat("'", OICPAction, "' ",
                         " of ",
                         ProviderAuthenticationData.ToString());