Exemple #1
0
        // POST api/<controller>
        public async Task <ActionResult <AssetEstimatedPayloadPerCycleSettingsResponse> > Save(AssetSettingsRequest request)
        {
            request = await base.ReadRequestContentAsync(request);

            AssetSettingsRequestBase serviceRequest = new AssetSettingsRequestBase();

            if (request != null)
            {
                serviceRequest = new AssetSettingsRequestBase
                {
                    StartDate    = DateTime.Parse(DateTime.UtcNow.ToShortDateString()),
                    TargetValues = new Dictionary <AssetTargetType, double?> {
                        { AssetTargetType.PayloadPerCycleInTonnes, request.TargetValue }
                    },
                    CustomerUid = base.GetCustomerContext(Request),
                    UserUid     = base.GetUserContext(Request),
                    AssetUIds   = request.AssetUIds
                };
            }

            this._loggingService.Debug("Updating Asset Settings Estimated Payload Per Cycle for the given request : " + JsonConvert.SerializeObject(request), MethodInfo.GetCurrentMethod().Name);

            this._loggingService.Debug("Request : " + JsonConvert.SerializeObject(request), MethodInfo.GetCurrentMethod().Name);

            var result = await this._assetSettingsService.Save(serviceRequest);

            this._loggingService.Debug("Updating Asset Settings Estimated Payload per cycle response : " + JsonConvert.SerializeObject(result), MethodInfo.GetCurrentMethod().Name);

            return(base.SendResponse(HttpStatusCode.OK, new AssetEstimatedPayloadPerCycleSettingsResponse(result.AssetSettingsLists, result.Errors.OfType <AssetErrorInfo>().ToList <AssetErrorInfo>())));
        }
Exemple #2
0
        protected virtual void CheckForInvalidRecords(AssetSettingsRequestBase request, List <IErrorInfo> errorInfos)
        {
            var invalidRecords = errorInfos.Where(x => x.IsInvalid);

            if (errorInfos.Where(x => x.IsInvalid).Any())
            {
                this._loggingService.Info("Ignoring request since following records are invalid : " + JsonConvert.SerializeObject(invalidRecords), MethodInfo.GetCurrentMethod().Name);
                throw new DomainException {
                          Errors = errorInfos
                };
            }

            if (request.AssetUIds == null || !request.AssetUIds.Any())
            {
                throw new DomainException
                      {
                          Errors = errorInfos.Any() ? errorInfos : new List <IErrorInfo>
                          {
                              new ErrorInfo
                              {
                                  ErrorCode = (int)ErrorCodes.AssetUIDListNull,
                                  Message   = UtilHelpers.GetEnumDescription(ErrorCodes.AssetUIDListNull)
                              }
                          }
                      };
            }
        }
Exemple #3
0
        public virtual async Task <IList <AssetSettingsResponse> > Fetch(AssetSettingsRequestBase request, IList <IErrorInfo> errorInfos)
        {
            List <AssetSettingsResponse> convertedResponse = new List <AssetSettingsResponse>();

            try
            {
                //Fetch from DB
                var results = await this.FetchAssetConfig(request, "<=");

                if (results.Any())
                {
                    convertedResponse.AddRange(this._mapper.Map <IEnumerable <AssetSettingsResponse> >(results));
                }
            }
            catch (DomainException domainException)
            {
                this._loggingService.Error("An Error occurred during validation", MethodInfo.GetCurrentMethod().Name, domainException);
                throw domainException;
            }
            catch (Exception ex)
            {
                this._loggingService.Error("An Exception has occurred", MethodInfo.GetCurrentMethod().Name, ex);
                throw ex;
            }
            return(convertedResponse);
        }
Exemple #4
0
        public virtual async Task <IList <AssetSettingsResponse> > Save(AssetSettingsRequestBase request, IList <IErrorInfo> errorInfos)
        {
            List <AssetSettingsResponse> convertedResponse = new List <AssetSettingsResponse>();

            try
            {
                //Fetch from DB
                var assetsSettingsResponse = await this.FetchAssetConfig(request, "<=");

                var assetsSettingsList = assetsSettingsResponse.ToList();

                var configTypeIds = this._assetConfigTypeRepository.FetchByConfigTypeNames(
                    new AssetConfigTypeDto
                {
                    ConfigTypeNames = request.TargetValues.Select(x => x.Key.ToString())
                }).Result;

                var configTypeDictionary = configTypeIds.ToDictionary(x => x.AssetTargetType, x => x.AssetConfigTypeID);

                this._loggingService.Debug("Started parallel execution for insertion / updation", MethodInfo.GetCurrentMethod().Name);

                var updatedAssetSettingsList = this.BuildAssetConfig(assetsSettingsList, request, configTypeDictionary);

                this.PersistAndPublish(updatedAssetSettingsList, request);

                this._loggingService.Debug("Ended parallel execution for insertion / updation", MethodInfo.GetCurrentMethod().Name);


                //Fetch from DB for the updated values
                var results = await this.FetchAssetConfig(request, "=");

                if (results.Any())
                {
                    convertedResponse.AddRange(this._mapper.Map <List <AssetSettingsResponse> >(results).ToArray());
                }
            }
            catch (DomainException domainException)
            {
                this._loggingService.Error("An Error occurred during validation", MethodInfo.GetCurrentMethod().Name, domainException);
                throw domainException;
            }
            catch (Exception ex)
            {
                this._loggingService.Error("An Exception has occurred", MethodInfo.GetCurrentMethod().Name, ex);
                throw ex;
            }
            return(convertedResponse);
        }
Exemple #5
0
        private bool PersistAndPublish(IEnumerable <AssetSettingsDto> assetSettings, AssetSettingsRequestBase request)
        {
            bool          result  = true;
            List <Action> actions = new List <Action>();

            if (assetSettings.Any())
            {
                actions.Add(() => _transactions.Upsert(assetSettings));
                actions.Add(() => this._assetSettingsPublisher.PublishAssetSettings(assetSettings));
                actions.Add(() => this._assetSettingsPublisher.PublishUserAssetSettings(request));                 //history record

                result = _transactions.Execute(actions);
            }

            return(result);
        }
Exemple #6
0
        public void BuildRepositoryStub(int count, AssetSettingsRequestBase request, List <AssetTargetType> assetTargetTypes)
        {
            AssetConfigDtoLists = new List <AssetSettingsDto>();

            for (int i = 0; i < count; i++)
            {
                var guid = Guid.NewGuid();
                this.AssetUIDs.Add(guid.ToString());
                AssetConfigDtoLists.Add(new AssetSettingsDto
                {
                    StartDate   = DateTime.Now,
                    EndDate     = DateTime.Now,
                    InsertUTC   = DateTime.UtcNow,
                    UpdateUTC   = DateTime.UtcNow,
                    TargetValue = i,
                    TargetType  = assetTargetTypes[i % assetTargetTypes.Count].ToString()
                });
            }
        }
Exemple #7
0
        // POST api/<controller>
        public async Task <ActionResult <AssetMileageSettingsResponse> > Fetch(List <String> assetUIDs = null)
        {
            assetUIDs = await base.ReadRequestContentAsync(assetUIDs);

            var request = new AssetSettingsRequestBase
            {
                StartDate    = DateTime.Parse(DateTime.UtcNow.ToShortDateString()),
                TargetValues = new Dictionary <AssetTargetType, double?> {
                    { AssetTargetType.OdometerinKmsPerWeek, 0 }
                },
                CustomerUid = base.GetCustomerContext(Request),
                UserUid     = base.GetUserContext(Request),
                AssetUIds   = assetUIDs
            };

            this._loggingService.Info("Fetching Asset Settings Mileage for the given request : " + JsonConvert.SerializeObject(request), MethodInfo.GetCurrentMethod().Name);
            var result = await this._assetSettingsService.Fetch(request);

            this._loggingService.Debug("Fetching Asset Settings Mileage response : " + JsonConvert.SerializeObject(result), MethodInfo.GetCurrentMethod().Name);

            return(SendResponse(HttpStatusCode.OK, new AssetMileageSettingsResponse(result.AssetSettingsLists, result.Errors.OfType <AssetErrorInfo>().ToList <AssetErrorInfo>())));
        }
Exemple #8
0
 public void PublishUserAssetSettings(AssetSettingsRequestBase request)
 {
     try
     {
         var payloadMessages = new List <KafkaMessage>();
         _loggingService.Debug("Started Publishing User Asset Settings", "AssetSettingsPublisher.PublishUserAssetSettings");
         foreach (var assetUId in request.AssetUIds)
         {
             foreach (var targetValue in request.TargetValues)
             {
                 var userAssetTargetEvent = new UserAssetTargetEvent
                 {
                     AssetUID   = Guid.Parse(assetUId),
                     TargetType = targetValue.Key,
                     StartDate  = Convert.ToDateTime(request.StartDate),
                     Timestamp  = new TimestampDetail {
                         EventUtc = DateTime.UtcNow
                     },
                     UserUID     = request.UserUid,
                     CustomerUID = request.CustomerUid,
                     TargetValue = targetValue.Value
                 };
                 var payloadMessage = new KafkaMessage {
                     Key = userAssetTargetEvent.AssetUID.ToString(), Message = userAssetTargetEvent, Topic = _userAssetSettingsTopic
                 };
                 payloadMessages.Add(payloadMessage);                         // check we need to publish with hypens or not
                 _loggingService.Debug(string.Format("USer Asset Settings Published to Kafka :- {0} ", JsonConvert.SerializeObject(payloadMessage)), "AssetSettingsPublisher.PublishUserAssetSettings");
             }
         }
         _transactions.Publish(payloadMessages);
         _loggingService.Debug("Ended Publishing User Asset Settings", "AssetSettingsPublisher.PublishUserAssetSettings");
     }
     catch (Exception ex)
     {
         this._loggingService.Error("An Exception has occurred ", MethodInfo.GetCurrentMethod().Name, ex);
     }
 }
Exemple #9
0
        protected virtual async Task <IEnumerable <AssetSettingsDto> > FetchAssetConfig(AssetSettingsRequestBase request, string startDateComparer)
        {
            this._loggingService.Debug("Started fetching AssetConfig details from database", MethodInfo.GetCurrentMethod().Name);
            var assetsSettingsResponse = await this._assetSettingsRepository.FetchAssetConfig(request.AssetUIds, new AssetSettingsDto
            {
                StartDate      = request.StartDate,
                TargetValues   = this.AssignAssetTargetValues(request.TargetValues, new AssetSettingsDto()),
                FilterCriteria = new List <KeyValuePair <string, Tuple <string, object> > >
                {
                    new KeyValuePair <string, Tuple <string, object> >(startDateComparer, new Tuple <string, object>("AC.StartDate", request.StartDate.ToDateTimeStringWithYearMonthDayFormat())),
                    new KeyValuePair <string, Tuple <string, object> >("is", new Tuple <string, object>("AC.EndDate", null))
                }
            });

            this._loggingService.Debug("Ended fetching AssetConfig details from database", MethodInfo.GetCurrentMethod().Name);
            return(assetsSettingsResponse);
        }
Exemple #10
0
        private IEnumerable <AssetSettingsDto> BuildAssetConfig(List <AssetSettingsDto> assetSettingsList, AssetSettingsRequestBase request, Dictionary <AssetTargetType, int> configTypeDictionary)
        {
            DateTime currentDateTime = DateTime.UtcNow;

            List <AssetSettingsDto> resultAssetSettings = new List <AssetSettingsDto>();

            //Build Asset UIDs to be created
            var assetUidsToBeCreated = request.AssetUIds.Except(assetSettingsList.Distinct().Select(x => x.AssetUID.ToString())).ToList();

            this._loggingService.Info("Following AssetUIDs are not having opened AssetConfig records  : " + string.Join(",", assetUidsToBeCreated), MethodInfo.GetCurrentMethod().Name);

            if (assetUidsToBeCreated.Count > 0)
            {
                foreach (var requestTargetType in request.TargetValues)
                {
                    resultAssetSettings.AddRange(assetUidsToBeCreated.Select(x => new AssetSettingsDto
                    {
                        AssetConfigUID    = Guid.NewGuid(),
                        AssetUID          = Guid.Parse(x),
                        StartDate         = request.StartDate,
                        TargetType        = requestTargetType.Key.ToString(),
                        TargetValue       = requestTargetType.Value ?? 0,
                        AssetConfigTypeID = configTypeDictionary[requestTargetType.Key],
                        InsertUTC         = currentDateTime,
                        UpdateUTC         = currentDateTime,
                        StatusInd         = true
                    }));
                }
            }

            foreach (var assetConfig in assetSettingsList)
            {
                AssetTargetType targetType = (AssetTargetType)Enum.Parse(typeof(AssetTargetType), assetConfig.TargetType);
                assetConfig.AssetConfigTypeID = configTypeDictionary[targetType];

                assetConfig.UpdateUTC = currentDateTime;
                //Unsetting the current config
                if (!request.TargetValues[targetType].HasValue)
                {
                    _loggingService.Info("Assigning EndDate as Target values are null for the Asset : " + assetConfig.AssetUID, "AssetSettingsServiceBase.BuildAssetConfig");
                    if (Convert.ToDateTime(assetConfig.StartDate) == request.StartDate)
                    {
                        assetConfig.EndDate = request.StartDate;
                    }
                    else
                    {
                        assetConfig.EndDate = request.StartDate.AddDays(-1);
                    }
                    _loggingService.Info("Assigned EndDate : " + assetConfig.EndDate + " for the Asset : " + assetConfig.AssetUID, "AssetSettingsServiceBase.BuildAssetConfig");
                }
                //Check if StartDate < request.StartDate ie., Old Records
                else if (Convert.ToDateTime(assetConfig.StartDate) < request.StartDate)
                {
                    _loggingService.Info("Assigning EndDate as user is updating on next day for the Asset : " + assetConfig.AssetUID, "AssetSettingsServiceBase.BuildAssetConfig");
                    assetConfig.EndDate = request.StartDate.AddDays(-1);
                    this._loggingService.Info("Assigned EndDate : " + assetConfig.EndDate + " for the Asset : " + assetConfig.AssetUID, "AssetSettingsServiceBase.BuildAssetConfig");

                    resultAssetSettings.Add(new AssetSettingsDto
                    {
                        AssetConfigUID    = Guid.NewGuid(),
                        AssetUID          = assetConfig.AssetUID,
                        TargetType        = assetConfig.TargetType,
                        TargetValue       = Convert.ToDouble(request.TargetValues[targetType]),
                        InsertUTC         = currentDateTime,
                        StartDate         = request.StartDate,
                        AssetConfigTypeID = configTypeDictionary[targetType],
                        UpdateUTC         = currentDateTime,
                        StatusInd         = true
                    });
                    this._loggingService.Info("Created new AssetConfig with StartDate : " + assetConfig.StartDate + " for the Asset : " + assetConfig.AssetUID, "AssetSettingsServiceBase.BuildAssetConfig");
                }
                else
                {
                    //Assign Target value to the given target value ie., for updation
                    assetConfig.TargetValue = Convert.ToDouble(request.TargetValues[targetType]);
                    this._loggingService.Info("Assigned TargetValue : " + assetConfig.TargetValue + " for the Asset : " + assetConfig.AssetUID, "AssetSettingsServiceBase.BuildAssetConfig");
                }
            }
            resultAssetSettings.AddRange(assetSettingsList);
            return(resultAssetSettings);
        }