Example #1
0
        public void SetEVehicleAdminStatus(eVehicle_Id eVehicleId,
                                           IEnumerable <Timestamped <eVehicleAdminStatusType> > StatusList,
                                           ChangeMethods ChangeMethod = ChangeMethods.Replace)
        {
            eVehicle _eVehicle = null;

            if (TryGetEVehicleById(eVehicleId, out _eVehicle))
            {
                _eVehicle.SetAdminStatus(StatusList, ChangeMethod);
            }

            //if (SendUpstream)
            //{
            //
            //    RoamingNetwork.
            //        SendeVehicleAdminStatusDiff(new eVehicleAdminStatusDiff(DateTime.UtcNow,
            //                                               ChargingStationOperatorId:    Id,
            //                                               ChargingStationOperatorName:  Name,
            //                                               NewStatus:         new List<KeyValuePair<eVehicle_Id, eVehicleAdminStatusType>>(),
            //                                               ChangedStatus:     new List<KeyValuePair<eVehicle_Id, eVehicleAdminStatusType>>() {
            //                                                                          new KeyValuePair<eVehicle_Id, eVehicleAdminStatusType>(eVehicleId, NewStatus.Value)
            //                                                                      },
            //                                               RemovedIds:        new List<eVehicle_Id>()));
            //
            //}
        }
Example #2
0
        /// <summary>
        /// Compares two e-vehicles for equality.
        /// </summary>
        /// <param name="eVehicle">A e-vehicle to compare with.</param>
        /// <returns>True if both match; False otherwise.</returns>
        public Boolean Equals(eVehicle eVehicle)
        {
            if ((Object)eVehicle == null)
            {
                return(false);
            }

            return(Id.Equals(eVehicle.Id));
        }
Example #3
0
        /// <summary>
        /// Compares two instances of this object.
        /// </summary>
        /// <param name="eVehicle">A e-vehicle object to compare with.</param>
        public Int32 CompareTo(eVehicle eVehicle)
        {
            if ((Object)eVehicle == null)
            {
                throw new ArgumentNullException("The given e-vehicle must not be null!");
            }

            return(Id.CompareTo(eVehicle.Id));
        }
Example #4
0
        public void SetEVehicleAdminStatus(eVehicle_Id eVehicleId,
                                           eVehicleAdminStatusType NewStatus,
                                           DateTime Timestamp)
        {
            eVehicle _eVehicle = null;

            if (TryGetEVehicleById(eVehicleId, out _eVehicle))
            {
                _eVehicle.SetAdminStatus(NewStatus, Timestamp);
            }
        }
Example #5
0
        public void SeteVehicleAdminStatus(eVehicle_Id eVehicleId,
                                           Timestamped <eVehicleAdminStatusType> NewStatus,
                                           Boolean SendUpstream = false)
        {
            eVehicle _eVehicle = null;

            if (TryGetEVehicleById(eVehicleId, out _eVehicle))
            {
                _eVehicle.SetAdminStatus(NewStatus);
            }
        }
Example #6
0
        /// <summary>
        /// Update the current electric vehicle geo location.
        /// </summary>
        /// <param name="Timestamp">The timestamp when this change was detected.</param>
        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
        /// <param name="eVehicle">The updated eVehicle.</param>
        /// <param name="OldGeoCoordinate">The old aggreagted charging station status.</param>
        /// <param name="NewGeoCoordinate">The new aggreagted charging station status.</param>
        internal async Task UpdateEVehicleGeoLocation(DateTime Timestamp,
                                                      EventTracking_Id EventTrackingId,
                                                      eVehicle eVehicle,
                                                      Timestamped <GeoCoordinate> OldGeoCoordinate,
                                                      Timestamped <GeoCoordinate> NewGeoCoordinate)
        {
            var OnEVehicleGeoLocationChangedLocal = OnEVehicleGeoLocationChanged;

            if (OnEVehicleGeoLocationChangedLocal != null)
            {
                await OnEVehicleGeoLocationChangedLocal(Timestamp,
                                                        EventTrackingId,
                                                        eVehicle,
                                                        OldGeoCoordinate,
                                                        NewGeoCoordinate);
            }
        }
Example #7
0
        /// <summary>
        /// Update the current eVehicle status.
        /// </summary>
        /// <param name="Timestamp">The timestamp when this change was detected.</param>
        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
        /// <param name="eVehicle">The updated eVehicle.</param>
        /// <param name="OldStatus">The old aggreagted charging station status.</param>
        /// <param name="NewStatus">The new aggreagted charging station status.</param>
        internal async Task UpdateEVehicleStatus(DateTime Timestamp,
                                                 EventTracking_Id EventTrackingId,
                                                 eVehicle eVehicle,
                                                 Timestamped <eVehicleStatusType> OldStatus,
                                                 Timestamped <eVehicleStatusType> NewStatus)
        {
            var OnEVehicleStatusChangedLocal = OnEVehicleStatusChanged;

            if (OnEVehicleStatusChangedLocal != null)
            {
                await OnEVehicleStatusChangedLocal(Timestamp,
                                                   EventTrackingId,
                                                   eVehicle,
                                                   OldStatus,
                                                   NewStatus);
            }
        }
Example #8
0
        public Boolean TryRemoveEVehicle(eVehicle_Id eVehicleId, out eVehicle eVehicle)
        {
            if (TryGetEVehicleById(eVehicleId, out eVehicle))
            {
                if (eVehicleRemoval.SendVoting(DateTime.UtcNow, this, eVehicle))
                {
                    if (_eVehicles.TryRemove(eVehicleId, out eVehicle))
                    {
                        eVehicleRemoval.SendNotification(DateTime.UtcNow, this, eVehicle);

                        return(true);
                    }
                }

                return(false);
            }

            return(true);
        }
Example #9
0
        public eVehicle RemoveEVehicle(eVehicle_Id eVehicleId)
        {
            eVehicle _eVehicle = null;

            if (TryGetEVehicleById(eVehicleId, out _eVehicle))
            {
                if (eVehicleRemoval.SendVoting(DateTime.UtcNow, this, _eVehicle))
                {
                    if (_eVehicles.TryRemove(eVehicleId, out _eVehicle))
                    {
                        eVehicleRemoval.SendNotification(DateTime.UtcNow, this, _eVehicle);

                        return(_eVehicle);
                    }
                }
            }

            return(null);
        }
Example #10
0
        /// <summary>
        /// Update the data of an eVehicle.
        /// </summary>
        /// <param name="Timestamp">The timestamp when this change was detected.</param>
        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
        /// <param name="eVehicle">The changed eVehicle.</param>
        /// <param name="PropertyName">The name of the changed property.</param>
        /// <param name="OldValue">The old value of the changed property.</param>
        /// <param name="NewValue">The new value of the changed property.</param>
        internal async Task UpdateEVehicleData(DateTime Timestamp,
                                               EventTracking_Id EventTrackingId,
                                               eVehicle eVehicle,
                                               String PropertyName,
                                               Object OldValue,
                                               Object NewValue)
        {
            var OnEVehicleDataChangedLocal = OnEVehicleDataChanged;

            if (OnEVehicleDataChangedLocal != null)
            {
                await OnEVehicleDataChangedLocal(Timestamp,
                                                 EventTrackingId,
                                                 eVehicle,
                                                 PropertyName,
                                                 OldValue,
                                                 NewValue);
            }
        }
Example #11
0
        public Boolean TryGetEVehicleById(eVehicle_Id eVehicleId, out eVehicle eVehicle)

        => _eVehicles.TryGet(eVehicleId, out eVehicle);
Example #12
0
        /// <summary>
        /// Check if the given eVehicle is already present within the Charging Station Operator.
        /// </summary>
        /// <param name="eVehicle">A eVehicle.</param>
        public Boolean ContainseVehicle(eVehicle eVehicle)

        => _eVehicles.Contains(eVehicle);
Example #13
0
        /// <summary>
        /// Create and register a new eVehicle having the given
        /// unique eVehicle identification.
        /// </summary>
        /// <param name="eVehicleId">The unique identification of the new eVehicle.</param>
        /// <param name="Configurator">An optional delegate to configure the new eVehicle before its successful creation.</param>
        /// <param name="OnSuccess">An optional delegate to configure the new eVehicle after its successful creation.</param>
        /// <param name="OnError">An optional delegate to be called whenever the creation of the eVehicle failed.</param>
        public eVehicle CreateNewEVehicle(eVehicle_Id eVehicleId         = null,
                                          Action <eVehicle> Configurator = null,
                                          RemoteEVehicleCreatorDelegate RemoteeVehicleCreator = null,
                                          eVehicleAdminStatusType AdminStatus            = eVehicleAdminStatusType.Operational,
                                          eVehicleStatusType Status                      = eVehicleStatusType.Available,
                                          Action <eVehicle> OnSuccess                    = null,
                                          Action <eMobilityStation, eVehicle_Id> OnError = null)

        {
            #region Initial checks

            if (eVehicleId == null)
            {
                eVehicleId = eVehicle_Id.Random(Provider.Id);
            }

            // Do not throw an exception when an OnError delegate was given!
            if (_eVehicles.Any(pool => pool.Id == eVehicleId))
            {
                if (OnError == null)
                {
                    throw new eVehicleAlreadyExistsInStation(this, eVehicleId);
                }
                else
                {
                    OnError?.Invoke(this, eVehicleId);
                }
            }

            #endregion

            var _eVehicle = new eVehicle(eVehicleId,
                                         Provider,
                                         Configurator,
                                         RemoteeVehicleCreator,
                                         AdminStatus,
                                         Status);


            if (eVehicleAddition.SendVoting(DateTime.UtcNow, this, _eVehicle))
            {
                if (_eVehicles.TryAdd(_eVehicle))
                {
                    _eVehicle.OnDataChanged        += UpdateEVehicleData;
                    _eVehicle.OnStatusChanged      += UpdateEVehicleStatus;
                    _eVehicle.OnAdminStatusChanged += UpdateEVehicleAdminStatus;

                    //_eVehicle.OnNewReservation                     += SendNewReservation;
                    //_eVehicle.OnCancelReservationResponse               += SendOnCancelReservationResponse;
                    //_eVehicle.OnNewChargingSession                 += SendNewChargingSession;
                    //_eVehicle.OnNewChargeDetailRecord              += SendNewChargeDetailRecord;


                    OnSuccess?.Invoke(_eVehicle);
                    eVehicleAddition.SendNotification(DateTime.UtcNow, this, _eVehicle);

                    return(_eVehicle);
                }
            }

            return(null);
        }
Example #14
0
        /// <summary>
        /// Take a snapshot of the current e-mobility station admin status.
        /// </summary>
        /// <param name="eVehicle">An e-mobility station.</param>

        public static eVehicleStatus Snapshot(eVehicle eVehicle)

        => new eVehicleStatus(eVehicle.Id,
                              eVehicle.Status.Value,
                              eVehicle.Status.Timestamp);