Beispiel #1
0
        private bool Update(AssetOwnerEvent assetOwner)
        {
            AssetOwnerInfo existingAssetOwner = _assetOwnerRepository.GetExistingAssetOwner(assetOwner.AssetUID.Value);

            var compareResult = CheckExistingAssetOwnerForUpdate(existingAssetOwner, assetOwner);

            if (!compareResult)
            {
                Guid?customerUid     = existingAssetOwner.CustomerUID == null ? (Guid?)null : new Guid(existingAssetOwner.CustomerUID);
                Guid?accountUid      = existingAssetOwner.AccountUID == null? (Guid?)null : new Guid(existingAssetOwner.AccountUID);
                Guid?dealerUid       = existingAssetOwner.DealerUID == null ? (Guid?)null : new Guid(existingAssetOwner.DealerUID);
                var  assetOwnerEvent = new AssetOwnerEvent
                {
                    AssetUID         = assetOwner.AssetUID,
                    AssetOwnerRecord = new ClientModel.AssetOwner
                    {
                        DealerUID           = assetOwner.AssetOwnerRecord.DealerUID == null ? dealerUid : (assetOwner.AssetOwnerRecord.DealerUID == Guid.Empty ? null : assetOwner.AssetOwnerRecord.DealerUID),
                        DealerName          = assetOwner.AssetOwnerRecord.DealerName == null ? existingAssetOwner.DealerName : (string.IsNullOrWhiteSpace(assetOwner.AssetOwnerRecord.DealerName) ? null : assetOwner.AssetOwnerRecord.DealerName),
                        CustomerName        = assetOwner.AssetOwnerRecord.CustomerName == null ? existingAssetOwner.CustomerName : (string.IsNullOrWhiteSpace(assetOwner.AssetOwnerRecord.CustomerName) ? null : assetOwner.AssetOwnerRecord.CustomerName),
                        AccountName         = assetOwner.AssetOwnerRecord.AccountName == null ? existingAssetOwner.AccountName : (string.IsNullOrWhiteSpace(assetOwner.AssetOwnerRecord.AccountName) ? null : assetOwner.AssetOwnerRecord.AccountName),
                        DealerAccountCode   = assetOwner.AssetOwnerRecord.DealerAccountCode == null ? existingAssetOwner.DealerAccountCode : (string.IsNullOrWhiteSpace(assetOwner.AssetOwnerRecord.DealerAccountCode) ? null : assetOwner.AssetOwnerRecord.DealerAccountCode),
                        NetworkCustomerCode = assetOwner.AssetOwnerRecord.NetworkCustomerCode == null ? existingAssetOwner.NetworkCustomerCode : (string.IsNullOrWhiteSpace(assetOwner.AssetOwnerRecord.NetworkCustomerCode) ? null : assetOwner.AssetOwnerRecord.NetworkCustomerCode),
                        NetworkDealerCode   = assetOwner.AssetOwnerRecord.NetworkDealerCode == null ? existingAssetOwner.NetworkDealerCode : (string.IsNullOrWhiteSpace(assetOwner.AssetOwnerRecord.NetworkDealerCode) ? null : assetOwner.AssetOwnerRecord.NetworkDealerCode),
                        CustomerUID         = assetOwner.AssetOwnerRecord.CustomerUID == null ? customerUid : (assetOwner.AssetOwnerRecord.CustomerUID == Guid.Empty ? null : assetOwner.AssetOwnerRecord.CustomerUID),
                        AccountUID          = assetOwner.AssetOwnerRecord.AccountUID == null ? accountUid : (assetOwner.AssetOwnerRecord.AccountUID == Guid.Empty ? null : assetOwner.AssetOwnerRecord.AccountUID)
                    },
                    Action      = Operation.Update,
                    ActionUTC   = DateTime.UtcNow,
                    ReceivedUTC = DateTime.UtcNow
                };
                return(_assetOwnerRepository.UpdateAssetOwnerEvent(assetOwnerEvent));
            }
            return(compareResult);
        }
Beispiel #2
0
        public void Create_Update_Delete_AssetOwnerEvent()
        {
            //Arrange for Create

            var assetOwnerEvent = new AssetOwnerEvent()
            {
                Action           = Operation.Create,
                ActionUTC        = DateTime.UtcNow,
                AssetUID         = new Guid(),
                AssetOwnerRecord = new VSS.MasterData.WebAPI.ClientModel.AssetOwner()
                {
                    AccountName         = "Sam",
                    AccountUID          = new Guid("a162eb79-0317-11e9-a988-029d68d36a0c"),
                    CustomerName        = "Cat",
                    CustomerUID         = new Guid("a162eb79-0317-11e9-a988-029d68d36a0d"),
                    DealerAccountCode   = "TD00",
                    DealerName          = "DemoDeler",
                    DealerUID           = new Guid("a162eb79-0317-11e9-a988-029d68d36a0e"),
                    NetworkCustomerCode = "SAP",
                    NetworkDealerCode   = "TeT",
                }
            };

            _transaction.Execute(Arg.Any <List <Action> >()).Returns(x =>
            {
                foreach (var action in x.Arg <List <Action> >())
                {
                    action();
                }
                return(true);
            });

            //Act
            Assert.True(_assetOwnerServices.CreateAssetOwnerEvent(assetOwnerEvent));

            //Arrange for Update
            assetOwnerEvent.Action = Operation.Update;

            //Act
            Assert.True(_assetOwnerServices.UpdateAssetOwnerEvent(assetOwnerEvent));

            //Arrange for Delete
            assetOwnerEvent.Action = Operation.Delete;

            //Act
            Assert.True(_assetOwnerServices.DeleteAssetOwnerEvent(assetOwnerEvent));
        }
Beispiel #3
0
        public ActionResult AssetOwner([FromBody] AssetOwnerEvent assetOwner)
        {
            try
            {
                bool   result;
                string validateMsg = validateAsetOwner(assetOwner);

                if (String.IsNullOrEmpty(validateMsg))
                {
                    assetOwner.ReceivedUTC = DateTime.UtcNow;
                    assetOwner.Action      = DetermineAction(assetOwner.AssetUID.Value, assetOwner.Action);
                    if (assetOwner.Action == Operation.Create)
                    {
                        if ((assetOwner.AssetOwnerRecord.DealerUID == null || assetOwner.AssetOwnerRecord.DealerUID == Guid.Empty) &&
                            (assetOwner.AssetOwnerRecord.CustomerUID == null || assetOwner.AssetOwnerRecord.CustomerUID == Guid.Empty) &&
                            (assetOwner.AssetOwnerRecord.AccountUID == null || assetOwner.AssetOwnerRecord.AccountUID == Guid.Empty))
                        {
                            _logger.LogInformation(string.Format("Atlest one guid should be mandatory", assetOwner));
                            return(BadRequest("Atlest one guid is mandatory"));
                        }
                    }
                    result = PerformAction(assetOwner, assetOwner.Action);
                    if (result)
                    {
                        _logger.LogInformation("AssetOwnerEvent for Asset:" + assetOwner.AssetUID + " Action: " + assetOwner.Action + " resulted in a success ");
                        return(Ok());
                    }
                }
                else
                {
                    return(BadRequest(validateMsg));
                }

                _logger.LogError($"Failed to process message for asset {assetOwner.AssetUID}");
                throw new Exception("Failed to process message");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.Message + ex.StackTrace);
                return(StatusCode((int)HttpStatusCode.InternalServerError));
            }
        }
Beispiel #4
0
        private DbModel.AssetOwner GetAssetOwnerDBModel(AssetOwnerEvent assetOwnerEvent)
        {
            DateTime utcNow = DateTime.UtcNow;

            return(new DbModel.AssetOwner
            {
                fk_AssetUID = assetOwnerEvent.AssetUID.Value,
                fk_CustomerUID = assetOwnerEvent.AssetOwnerRecord.CustomerUID,
                CustomerName = assetOwnerEvent.AssetOwnerRecord.CustomerName,
                fk_DealerCustomerUID = assetOwnerEvent.AssetOwnerRecord.DealerUID,
                DealerName = assetOwnerEvent.AssetOwnerRecord.DealerName,
                fk_AccountCustomerUID = assetOwnerEvent.AssetOwnerRecord.AccountUID,
                AccountName = assetOwnerEvent.AssetOwnerRecord.AccountName,
                NetworkCustomerCode = assetOwnerEvent.AssetOwnerRecord.NetworkCustomerCode,
                DealerAccountCode = assetOwnerEvent.AssetOwnerRecord.DealerAccountCode,
                NetworkDealerCode = assetOwnerEvent.AssetOwnerRecord.NetworkDealerCode,
                InsertUTC = utcNow,
                UpdateUTC = utcNow
            });
        }
Beispiel #5
0
        private bool PerformAction(AssetOwnerEvent assetOwner, Operation operation)
        {
            bool result = false;

            switch (operation)
            {
            case Operation.Create:
                result = _assetOwnerRepository.CreateAssetOwnerEvent(assetOwner);
                break;

            case Operation.Update:
                result = Update(assetOwner);
                break;

            case Operation.Delete:
                result = _assetOwnerRepository.DeleteAssetOwnerEvent(assetOwner);
                break;
            }
            return(result);
        }
Beispiel #6
0
        private string validateAsetOwner(AssetOwnerEvent assetOwner)
        {
            string errorMsg = string.Empty;

            if (!ValidateGUID(assetOwner.AssetUID.Value))
            {
                errorMsg = "AssetUID is mandatory";
            }

            else if (assetOwner.AssetOwnerRecord.DealerUID == null && assetOwner.AssetOwnerRecord.CustomerUID == null && assetOwner.AssetOwnerRecord.AccountUID == null)
            {
                _logger.LogInformation(string.Format("Atlest one guid should be mandatory", assetOwner));
                errorMsg = "Atlest one guid is mandatory";
            }
            else if (assetOwner.Action == Operation.Delete && !_assetOwnerRepository.CheckExistingAssetOwner(assetOwner.AssetUID.Value))
            {
                _logger.LogInformation($"Delete AssetOwnerDetail called for non-existing asset {assetOwner.AssetUID}");
                errorMsg = "No Such AssetOwnerDetail exist.";
            }
            return(errorMsg);
        }
Beispiel #7
0
        public virtual bool DeleteAssetOwnerEvent(AssetOwnerEvent assetOwnerEvent)
        {
            string guid  = assetOwnerEvent.AssetUID.Value.ToStringWithoutHyphens();
            string query = $"delete from md_asset_AssetOwner where {MySql.ColumnName.AssetOwner.ColumnName.ASSET_UID} = {guid.WrapWithUnhex()}";

            Guid?    customerUid = assetOwnerEvent.AssetOwnerRecord.CustomerUID == null || assetOwnerEvent.AssetOwnerRecord.CustomerUID == Guid.Empty ? (Guid?)null : assetOwnerEvent.AssetOwnerRecord.CustomerUID;
            Guid?    accountUid  = assetOwnerEvent.AssetOwnerRecord.AccountUID == null || assetOwnerEvent.AssetOwnerRecord.AccountUID == Guid.Empty ? (Guid?)null : assetOwnerEvent.AssetOwnerRecord.AccountUID;
            DateTime utcNow      = DateTime.UtcNow;
            var      message     = new KafkaMessage
            {
                Key     = assetOwnerEvent.AssetUID.ToString(),
                Message = new
                {
                    AssetUID         = assetOwnerEvent.AssetUID,
                    AssetOwnerRecord = new ClientModel.AssetOwner
                    {
                        CustomerName        = assetOwnerEvent.AssetOwnerRecord.CustomerName,
                        AccountName         = assetOwnerEvent.AssetOwnerRecord.AccountName,
                        DealerAccountCode   = assetOwnerEvent.AssetOwnerRecord.DealerAccountCode,
                        DealerUID           = assetOwnerEvent.AssetOwnerRecord.DealerUID,
                        DealerName          = assetOwnerEvent.AssetOwnerRecord.DealerName,
                        NetworkCustomerCode = assetOwnerEvent.AssetOwnerRecord.NetworkCustomerCode,
                        NetworkDealerCode   = assetOwnerEvent.AssetOwnerRecord.NetworkDealerCode,
                        CustomerUID         = customerUid,
                        AccountUID          = accountUid
                    },
                    Action      = "Delete",
                    ActionUTC   = utcNow,                   //ToDO: Ensure the Insert UTC values
                    ReceivedUTC = utcNow
                }
            };

            var actions = new List <Action>()
            {
                () => _transaction.Delete(query),
                () => assetOwnerTopicNames?.ForEach((topic) => { message.Topic = topic; _transaction.Publish(message); })
            };

            return(_transaction.Execute(actions));
        }
Beispiel #8
0
        public virtual bool UpdateAssetOwnerEvent(AssetOwnerEvent assetOwnerEvent)
        {
            var assetOwnerDBModel = GetAssetOwnerDBModel(assetOwnerEvent);

            var message = new KafkaMessage
            {
                Key     = assetOwnerEvent.AssetUID.ToString(),
                Message = new {
                    AssetUID         = assetOwnerEvent.AssetUID,
                    AssetOwnerRecord = new ClientModel.AssetOwner
                    {
                        CustomerName        = assetOwnerEvent.AssetOwnerRecord.CustomerName,
                        AccountName         = assetOwnerEvent.AssetOwnerRecord.AccountName,
                        DealerAccountCode   = assetOwnerEvent.AssetOwnerRecord.DealerAccountCode,
                        DealerUID           = assetOwnerEvent.AssetOwnerRecord.DealerUID,
                        DealerName          = assetOwnerEvent.AssetOwnerRecord.DealerName,
                        NetworkCustomerCode = assetOwnerEvent.AssetOwnerRecord.NetworkCustomerCode,
                        NetworkDealerCode   = assetOwnerEvent.AssetOwnerRecord.NetworkDealerCode,
                        CustomerUID         = assetOwnerEvent.AssetOwnerRecord.CustomerUID,
                        AccountUID          = assetOwnerEvent.AssetOwnerRecord.AccountUID
                    },
                    Action      = "Update",
                    ActionUTC   = assetOwnerDBModel.UpdateUTC,                   //ToDO: Ensure the Insert UTC values
                    ReceivedUTC = assetOwnerDBModel.UpdateUTC
                }
            };

            var actions = new List <Action>()
            {
                () => _transaction.Upsert(assetOwnerDBModel),
                () => assetOwnerTopicNames?.ForEach((topic) => { message.Topic = topic; _transaction.Publish(message); })
            };

            _logger.LogInformation($"Update Asset Owner: {JsonSerializer.Serialize(assetOwnerEvent)}");
            return(_transaction.Execute(actions));
        }
Beispiel #9
0
        public virtual bool CreateAssetOwnerEvent(AssetOwnerEvent assetOwnerEvent)
        {
            string networkCustomerCode = string.IsNullOrWhiteSpace(assetOwnerEvent.AssetOwnerRecord.NetworkCustomerCode) ? null : assetOwnerEvent.AssetOwnerRecord.NetworkCustomerCode;
            string dealerAccountCode   = string.IsNullOrWhiteSpace(assetOwnerEvent.AssetOwnerRecord.DealerAccountCode) ? null : assetOwnerEvent.AssetOwnerRecord.DealerAccountCode;
            string networkDealerCode   = string.IsNullOrWhiteSpace(assetOwnerEvent.AssetOwnerRecord.NetworkDealerCode)? null : assetOwnerEvent.AssetOwnerRecord.NetworkDealerCode;
            string accountName         = string.IsNullOrWhiteSpace(assetOwnerEvent.AssetOwnerRecord.AccountName)? null : assetOwnerEvent.AssetOwnerRecord.AccountName;
            string dealerName          = string.IsNullOrWhiteSpace(assetOwnerEvent.AssetOwnerRecord.DealerName)? null : assetOwnerEvent.AssetOwnerRecord.DealerName;
            string customerName        = string.IsNullOrWhiteSpace(assetOwnerEvent.AssetOwnerRecord.CustomerName)? null : assetOwnerEvent.AssetOwnerRecord.CustomerName;

            Guid?customerUid = assetOwnerEvent.AssetOwnerRecord.CustomerUID == null || assetOwnerEvent.AssetOwnerRecord.CustomerUID == Guid.Empty ? (Guid?)null : assetOwnerEvent.AssetOwnerRecord.CustomerUID;
            Guid?accountUid  = assetOwnerEvent.AssetOwnerRecord.AccountUID == null || assetOwnerEvent.AssetOwnerRecord.AccountUID == Guid.Empty ? (Guid?)null : assetOwnerEvent.AssetOwnerRecord.AccountUID;
            Guid?dealerUid   = assetOwnerEvent.AssetOwnerRecord.DealerUID == Guid.Empty ? (Guid?)null : assetOwnerEvent.AssetOwnerRecord.DealerUID;

            try
            {
                var assetOwnerPayload = new AssetOwnerEvent
                {
                    AssetUID         = assetOwnerEvent.AssetUID,
                    AssetOwnerRecord = new ClientModel.AssetOwner
                    {
                        NetworkCustomerCode = networkCustomerCode,
                        DealerAccountCode   = dealerAccountCode,
                        NetworkDealerCode   = networkDealerCode,
                        AccountName         = accountName,
                        DealerName          = dealerName,
                        DealerUID           = dealerUid,
                        CustomerName        = customerName,
                        CustomerUID         = customerUid,
                        AccountUID          = accountUid
                    },
                    Action      = Operation.Create,
                    ActionUTC   = DateTime.UtcNow,
                    ReceivedUTC = DateTime.UtcNow
                };

                var assetOwnerDBModel = GetAssetOwnerDBModel(assetOwnerPayload);

                var message = new KafkaMessage
                {
                    Key     = assetOwnerEvent.AssetUID.ToString(),
                    Message = new {
                        AssetUID         = assetOwnerEvent.AssetUID,
                        AssetOwnerRecord = new ClientModel.AssetOwner
                        {
                            NetworkCustomerCode = networkCustomerCode,
                            DealerAccountCode   = dealerAccountCode,
                            NetworkDealerCode   = networkDealerCode,
                            AccountName         = accountName,
                            DealerName          = dealerName,
                            DealerUID           = assetOwnerEvent.AssetOwnerRecord.DealerUID,
                            CustomerName        = customerName,
                            CustomerUID         = customerUid,
                            AccountUID          = accountUid
                        },
                        Action      = "Create",
                        ActionUTC   = assetOwnerDBModel.UpdateUTC,
                        ReceivedUTC = assetOwnerDBModel.UpdateUTC
                    }
                };

                var actions = new List <Action>()
                {
                    () => _transaction.Upsert(assetOwnerDBModel),
                    () => assetOwnerTopicNames?.ForEach((topic) => { message.Topic = topic; _transaction.Publish(message); })
                };
                _logger.LogInformation($"Create Asset Owner: {JsonSerializer.Serialize(assetOwnerPayload)}");

                return(_transaction.Execute(actions));
            }
            catch (MySqlException ex)
            {
                _logger.LogError("error while creating asset in db: ", ex);
                throw ex;
            }
            finally
            {
            }
        }
Beispiel #10
0
        private bool CheckExistingAssetOwnerForUpdate(AssetOwnerInfo existingAssetOwner, AssetOwnerEvent assetowner)
        {
            bool areEqual = false;

            string customerUid = assetowner.AssetOwnerRecord.CustomerUID == null ? null : (assetowner.AssetOwnerRecord.CustomerUID == Guid.Empty ? null : new Guid(assetowner.AssetOwnerRecord.CustomerUID.ToString()).ToString("N").ToUpper());
            string dealerUid   = assetowner.AssetOwnerRecord.DealerUID == null ? null : (assetowner.AssetOwnerRecord.DealerUID == Guid.Empty ? null : new Guid(assetowner.AssetOwnerRecord.DealerUID.ToString()).ToString("N").ToUpper());
            string accountUid  = assetowner.AssetOwnerRecord.AccountUID == null ? null : (assetowner.AssetOwnerRecord.AccountUID == Guid.Empty ? null : new Guid(assetowner.AssetOwnerRecord.AccountUID.ToString()).ToString("N").ToUpper());

            string networkCustomerCode = assetowner.AssetOwnerRecord.NetworkCustomerCode;
            string dealerAccountCode   = assetowner.AssetOwnerRecord.DealerAccountCode;
            string networkDealerCode   = assetowner.AssetOwnerRecord.NetworkDealerCode;
            string accountName         = assetowner.AssetOwnerRecord.AccountName;
            string customerName        = assetowner.AssetOwnerRecord.CustomerName;
            string dealerName          = assetowner.AssetOwnerRecord.DealerName;

            if (existingAssetOwner.DealerUID == dealerUid && existingAssetOwner.CustomerUID == customerUid && existingAssetOwner.NetworkCustomerCode == networkCustomerCode &&
                existingAssetOwner.AccountUID == accountUid && existingAssetOwner.DealerAccountCode == dealerAccountCode && existingAssetOwner.NetworkDealerCode == networkDealerCode &&
                existingAssetOwner.AccountName == accountName && existingAssetOwner.CustomerName == customerName && existingAssetOwner.DealerName == dealerName)
            {
                areEqual = true;
            }
            return(areEqual);
        }