Esempio n. 1
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (OwnerAddress.Length != 0)
            {
                hash ^= OwnerAddress.GetHashCode();
            }
            if (ExchangeId != 0L)
            {
                hash ^= ExchangeId.GetHashCode();
            }
            if (TokenId.Length != 0)
            {
                hash ^= TokenId.GetHashCode();
            }
            if (Quant != 0L)
            {
                hash ^= Quant.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
Esempio n. 2
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (OwnerAddress.Length != 0)
            {
                hash ^= OwnerAddress.GetHashCode();
            }
            if (FrozenBalance != 0L)
            {
                hash ^= FrozenBalance.GetHashCode();
            }
            if (FrozenDuration != 0L)
            {
                hash ^= FrozenDuration.GetHashCode();
            }
            if (Resource != global::Tron.Net.Protocol.ResourceCode.Bandwidth)
            {
                hash ^= Resource.GetHashCode();
            }
            if (ReceiverAddress.Length != 0)
            {
                hash ^= ReceiverAddress.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
Esempio n. 3
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (OwnerAddress.Length != 0)
            {
                hash ^= OwnerAddress.GetHashCode();
            }
            if (FirstTokenId.Length != 0)
            {
                hash ^= FirstTokenId.GetHashCode();
            }
            if (FirstTokenBalance != 0L)
            {
                hash ^= FirstTokenBalance.GetHashCode();
            }
            if (SecondTokenId.Length != 0)
            {
                hash ^= SecondTokenId.GetHashCode();
            }
            if (SecondTokenBalance != 0L)
            {
                hash ^= SecondTokenBalance.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
Esempio n. 4
0
        public PropertyOwner AddOwner(
            string userName,
            string firstName,
            string lastName,
            string contactEmail,
            string contactTelephone1,
            string contactTelephone2,
            bool onlineAccess,
            string userAvartaImgUrl,
            bool?isActive,
            int?roleId,
            string notes,
            OwnerAddress address)
        {
            var owner = new PropertyOwner(userName, firstName, lastName, contactEmail,
                                          contactTelephone1, contactTelephone2, false, userAvartaImgUrl, true, 2, "",
                                          address, DateTime.Now, DateTime.Now);

            var ownerProperty = new OwnerProperty(this, owner);


            owner.OwnerProperty.Add(ownerProperty);

            return(owner);
        }
Esempio n. 5
0
        private async Task HandleAsync(UpdateOwnerEvent @event)
        {
            var owner = _context.RentalPropertyOwner.Include(o => o.OwnerAddress).FirstOrDefault(o => o.OriginalId == @event.PropertyOwnerId);

            if (owner != null)
            {
                var oAddress = new OwnerAddress(@event.StreetNumber, @event.City, @event.StateProv, @event.ZipPostCode, @event.Country);

                var updated = owner.Update(owner, @event.FirstName, @event.LastName, @event.ContactEmail, @event.ContactTelephone1, @event.ContactTelephone2, oAddress);

                _context.RentalPropertyOwner.Update(updated);

                try
                {
                    await _context.SaveChangesAsync();

                    Log.Information("Message  {MessageType} with Id {MessageId} has been handled successfully", @event.MessageType, @event.MessageId);
                }
                catch (Exception ex)
                {
                    //throw;
                    Log.Error(ex, "Error while handling {MessageType} message with id {MessageId}.", @event.MessageType, @event.MessageId);
                }
            }
            else
            {
                Log.Information("The owner with Id: {OwnerId} does not exist.", @event.PropertyOwnerId);
            }


            //throw new NotImplementedException();
        }
Esempio n. 6
0
        private async Task HandleAsync(AddOwnerEvent @event)
        {
            var rentalProperty = _context.RentalProperty.Include(a => a.Address).FirstOrDefault(p => p.OriginalId == @event.PropertyId);

            if (rentalProperty != null)
            {
                var address = new OwnerAddress(@event.StreetNumber, @event.City, @event.StateProv, @event.Country, @event.ZipPostCode);

                var owner = new RentalPropertyOwner(@event.OriginalId, @event.FirstName, @event.LastName, @event.ContactEmail,
                                                    @event.ContactTelephone1, @event.ContactTelephone2, rentalProperty.Id, address, DateTime.Now, DateTime.Now);

                _context.Add(owner);

                try
                {
                    await _context.SaveChangesAsync();

                    Log.Information("Owner {Owner} has been added to property {Property} successfully", @event.FirstName + " " + @event.LastName, rentalProperty.PropertyName);
                }
                catch (Exception ex)
                {
                    Log.Error(ex, "Error while addinng owner {Owner} to {Property}.", @event.FirstName + " " + @event.LastName, rentalProperty.PropertyName);
                    throw ex;
                }
            }
            else
            {
                Log.Information("The rental property with Id: {PrpertyId} does not exist.", @event.PropertyId);
            }



            //throw new NotImplementedException();
        }
Esempio n. 7
0
        public async Task CreateOwner(CreateOwnerModel owner)
        {
            var address = new OwnerAddress
            {
                HouseNumber = owner.HouseNumber,
                StreetName  = owner.StreetName,
                City        = owner.City,
                County      = owner.County,
                PostCode    = owner.PostCode
            };

            var addressEntity = await _addressRepo
                                .GetAddress(owner.HouseNumber, owner.StreetName, owner.City, owner.County, owner.PostCode)
                                .SingleOrDefaultAsync();

            if (addressEntity == null)
            {
                addressEntity = Mapper.Map <ExampleOwnerAddress>(address);
                await _addressRepo.Add(addressEntity);
            }

            var entity = Mapper.Map <ExampleOwner>(owner);

            entity.Address = addressEntity;
            await _ownerRepo.Add(entity);
        }
        public async Task <Result> Handle(UpdateBusinessLegalCommand request, CancellationToken token)
        {
            var legalAddress = new LegalAddress(request.Address.Line1,
                                                request.Address.Line2,
                                                request.Address.Zipcode,
                                                request.Address.City,
                                                request.Address.Country);

            var ownerAddress = new OwnerAddress(request.Owner.Address.Line1,
                                                request.Owner.Address.Line2,
                                                request.Owner.Address.Zipcode,
                                                request.Owner.Address.City,
                                                request.Owner.Address.Country
                                                );

            var legal = await _context.Set <BusinessLegal>().SingleAsync(e => e.Id == request.LegalId, token);

            legal.SetKind(request.Kind);
            legal.SetValidation(request.Validation);
            legal.SetName(request.Name);
            legal.SetEmail(request.Email);
            legal.SetAddress(legalAddress);
            legal.SetSiret(request.Siret);
            legal.SetVatIdentifier(request.VatIdentifier);

            legal.Owner.SetFirstname(request.Owner.FirstName);
            legal.Owner.SetLastname(request.Owner.LastName);
            legal.Owner.SetEmail(request.Owner.Email);
            legal.Owner.SetBirthDate(request.Owner.BirthDate);
            legal.Owner.SetNationality(request.Owner.Nationality);
            legal.Owner.SetCountryOfResidence(request.Owner.CountryOfResidence);
            legal.Owner.SetAddress(ownerAddress);

            await _context.SaveChangesAsync(token);

            if (string.IsNullOrWhiteSpace(legal.User.Identifier))
            {
                var userResult = await _mediatr.Process(
                    new CheckBusinessLegalConfigurationCommand(request.RequestUser) { UserId = legal.UserId }, token);

                if (!userResult.Succeeded)
                {
                    return(Failure(userResult));
                }
            }
            else
            {
                var result = await _pspService.UpdateBusinessAsync(legal, token);

                if (!result.Succeeded)
                {
                    return(Failure(result));
                }
            }

            return(Success());
        }
Esempio n. 9
0
        private async Task HandleAsync(AddOwnerEvent @event)
        {
            var rentalProperty = _context.RentalProperty.FirstOrDefault(p => p.OriginalId == @event.PropertyId);

            if (rentalProperty != null)
            {
                var address = new OwnerAddress(@event.StreetNumber, @event.City, @event.StateProv, @event.Country, @event.ZipPostCode);

                var owner = new RentalPropertyOwner(@event.OriginalId, @event.FirstName, @event.LastName, @event.ContactEmail,
                                                    @event.ContactTelephone1, @event.ContactTelephone2, address, rentalProperty.Id, DateTime.Now, DateTime.Now);

                _context.Add(owner);

                try
                {
                    await _context.SaveChangesAsync();

                    Log.Information("Owner {Owner} has been added to property {Property} successfully", @event.FirstName + " " + @event.LastName, rentalProperty.PropertyName);

                    // Send message so that lease service can consume to queue app_approved


                    // need to make sure the rental property exists in Lease service then send message if it does.
                    //************************************************
                    // It may not need this because as ApproveApplicaiton Event will send property including owner so that it should be created in Lease service already
                    //************************************************

                    /*
                     * AddOwnerEvent e = new AddOwnerEvent(new Guid(), @event.PropertyId, @event.UserName, @event.FirstName, @event.LastName,
                     *                                  @event.ContactEmail, @event.ContactTelephone1, @event.ContactTelephone2, @event.OnlineAccessEnbaled,
                     *                                  @event.UserAvartaImgUrl, @event.IsActive, @event.RoleId, @event.Notes, @event.StreetNumber,
                     *                                  @event.City, @event.StateProv, @event.ZipPostCode, @event.Country);
                     *
                     *
                     * try
                     * {
                     *  await _messagePublisher.PublishMessageAsync(e.MessageType, e, "asset_created"); // publishing the message
                     *  Log.Information("Message  {MessageType} with Id {MessageId} has been published successfully", e.MessageType, e.MessageId);
                     * }
                     * catch (Exception ex)
                     * {
                     *  Log.Error(ex, "Error while publishing {MessageType} message with id {MessageId}.", e.MessageType, e.MessageId);
                     * }
                     *
                     */
                }
                catch (Exception ex)
                {
                    Log.Error(ex, "Error while addinng owner {Owner} to {Property}.", @event.FirstName + " " + @event.LastName, rentalProperty.PropertyName);
                    throw ex;
                }
            }



            //throw new NotImplementedException();
        }
Esempio n. 10
0
        public PropertyOwner UpdateOwner(PropertyOwner owner, string firstName, string lastName, string email,
                                         string telephone1, string telephone2, string avatarUrl, bool isActive,
                                         string notes, string streetNumber, string city, string stateProv, string country, string postZipCode)
        {
            OwnerAddress updatedAddress = new OwnerAddress(
                streetNumber, city, stateProv, country, postZipCode
                );

            owner.Update(firstName, lastName, email, telephone1, telephone2, avatarUrl, isActive, notes, updatedAddress);

            return(owner);
        }
Esempio n. 11
0
 public RentalPropertyOwner(string firstName, string lastName, string contactEmail,
                            string contactTelephone, string contactOther, OwnerAddress ownerAddress, DateTime create, DateTime updated)
 {
     FirstName        = firstName;
     LastName         = lastName;
     ContactEmail     = contactEmail;
     ContactTelephone = contactTelephone;
     ContactOther     = contactOther;
     OwnerAddress     = ownerAddress;
     Created          = create;
     Modified         = updated;
 }
Esempio n. 12
0
        private async Task DisplayContract(string contractaddress)
        {
            DataRow dr = dt.NewRow();

            if (!isDecommision(contractaddress))
            {
                var    url          = "http://127.0.0.1:7545";
                string eth_address1 = "0x594559a12AF7CC1085f65c53f4252535Bad12203";

                var privateKey1     = "db9820f8b4585f5f022b03e062431636dc965aff525b195cee787c1fe55fd02b";
                var account         = new Account(privateKey1);
                var web3            = new Web3(account, url);
                var iot4            = new OwnerAddress();
                var balanceHandler4 = web3.Eth.GetContractQueryHandler <OwnerAddress>();
                var balance4        = await balanceHandler4.QueryAsync <String>(contractaddress, iot4);

                var iot            = new ProductName();
                var balanceHandler = web3.Eth.GetContractQueryHandler <ProductName>();
                var balance        = await balanceHandler.QueryAsync <String>(contractaddress, iot);


                var iot2            = new Description();
                var balanceHandler2 = web3.Eth.GetContractQueryHandler <Description>();
                var balance2        = await balanceHandler2.QueryAsync <String>(contractaddress, iot2);

                var iot3            = new SerialNumber();
                var balanceHandler3 = web3.Eth.GetContractQueryHandler <SerialNumber>();
                var balance3        = await balanceHandler3.QueryAsync <String>(contractaddress, iot3);

                string[] s = File.ReadAllLines(@"C:\Users\C.z\source\repos\BlockChain Project\BlockChain Project\DecommisionContract.txt");
                int      a = 0;
                foreach (string s1 in s)
                {
                    if (s1 == contractaddress)
                    {
                        a = 1;
                    }
                }
                if (a != 1)
                {
                    dr[0] = contractaddress;
                    dr[1] = balance4;
                    dr[2] = balance;
                    dr[3] = balance2;
                    dr[4] = balance3;
                    dr[5] = balance3;
                }
            }
            dt.Rows.Add(dr);
            dataGridView1.DataSource = dt;
        }
Esempio n. 13
0
 public RentalPropertyOwner(int originalId, string firstName, string lastName, string contactEmail,
                            string contactTelephone, string contactOther, OwnerAddress ownerAddress, int rentalPropertyId, DateTime create, DateTime updated)
 {
     OriginalId       = originalId;
     FirstName        = firstName;
     LastName         = lastName;
     ContactEmail     = contactEmail;
     ContactTelephone = contactTelephone;
     ContactOther     = contactOther;
     OwnerAddress     = ownerAddress;
     RentalPropertyId = rentalPropertyId;
     Created          = create;
     Modified         = updated;
 }
Esempio n. 14
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (OwnerAddress.Length != 0)
            {
                hash ^= OwnerAddress.GetHashCode();
            }
            hash ^= Parameters.GetHashCode();
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
Esempio n. 15
0
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();

            sb.Append("o=");
            sb.Append($"{Username} ");
            sb.Append($"{SessionId} ");
            sb.Append($"{SessionVersion} ");
            sb.Append($"{NetworkType} ");
            sb.Append($"{AddressType} ");
            sb.Append($"{OwnerAddress.ToString()}");
            sb.AppendLine();

            return(sb.ToString());
        }
Esempio n. 16
0
        //*********************************
        // Entity Behavors
        //*********************************


        public void Update(/*PropertyOwner owner,*/ string firstName, string lastName, string email,
                           string telephone1, string telephone2, string avatarUrl, bool isActive,
                           string notes, OwnerAddress address)
        {
            FirstName         = firstName;
            LastName          = lastName;
            ContactEmail      = email;
            ContactTelephone1 = telephone1;
            ContactTelephone2 = telephone2;
            UserAvartaImgUrl  = avatarUrl;
            IsActive          = isActive;
            Notes             = notes;
            Address           = address;
            Modified          = DateTime.Now;

            //return owner;
        }
Esempio n. 17
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (OwnerAddress.Length != 0)
            {
                hash ^= OwnerAddress.GetHashCode();
            }
            if (Brokerage != 0)
            {
                hash ^= Brokerage.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
Esempio n. 18
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (OwnerAddress.Length != 0)
            {
                hash ^= OwnerAddress.GetHashCode();
            }
            if (StorageBytes != 0L)
            {
                hash ^= StorageBytes.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
Esempio n. 19
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (OwnerAddress.Length != 0)
            {
                hash ^= OwnerAddress.GetHashCode();
            }
            if (UpdateUrl.Length != 0)
            {
                hash ^= UpdateUrl.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
        public static OwnerAddress GetAddressById(int AddressId)
        {
            OwnerAddress ownerAddress = new OwnerAddress();

            var Data = OwnerService.GetOwnerAddressById(AddressId);

            if (Data != null)
            {
                ownerAddress.Id       = Data.Id;
                ownerAddress.Street1  = Data.Street1;
                ownerAddress.Street2  = Data.Street2;
                ownerAddress.City     = Data.City;
                ownerAddress.PostCode = Data.PostCode;
                ownerAddress.StateId  = Data.StateId;
            }

            return(ownerAddress);
        }
Esempio n. 21
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (OwnerAddress.Length != 0)
            {
                hash ^= OwnerAddress.GetHashCode();
            }
            if (ProposalId != 0L)
            {
                hash ^= ProposalId.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
Esempio n. 22
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (OwnerAddress.Length != 0)
            {
                hash ^= OwnerAddress.GetHashCode();
            }
            hash ^= votes_.GetHashCode();
            if (Support != false)
            {
                hash ^= Support.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
Esempio n. 23
0
        public PropertyOwner(
            string userName,
            string firstName,
            string lastName,
            string contactEmail,
            string contactTelephone1,
            string contactTelephone2,
            bool onlineAccess,
            string userAvartaImgUrl,
            bool isActive,
            int roleId,
            string notes,
            //string streetNumber,
            //string city,
            //string stateProv,
            //string zipPostCode,
            //string country,
            OwnerAddress address,
            DateTime createdOn,
            DateTime updatedOn
            //ICollection<OwnerProperty> ownerProperty
            )
        {
            UserName          = userName;
            FirstName         = firstName;
            LastName          = lastName;
            ContactEmail      = contactEmail;
            ContactTelephone1 = contactTelephone1;
            ContactTelephone2 = contactTelephone2;
            OnlineAccess      = onlineAccess;
            UserAvartaImgUrl  = userAvartaImgUrl;
            IsActive          = isActive;
            RoleId            = roleId;
            Notes             = notes;

            Address  = address;
            Created  = createdOn;
            Modified = updatedOn;
            //OwnerProperty = ownerProperty;
        }
Esempio n. 24
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (OwnerAddress.Length != 0)
            {
                hash ^= OwnerAddress.GetHashCode();
            }
            if (AccountAddress.Length != 0)
            {
                hash ^= AccountAddress.GetHashCode();
            }
            if (Type != global::Tron.Net.Protocol.AccountType.Normal)
            {
                hash ^= Type.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
Esempio n. 25
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (OwnerAddress.Length != 0)
            {
                hash ^= OwnerAddress.GetHashCode();
            }
            if (ToAddress.Length != 0)
            {
                hash ^= ToAddress.GetHashCode();
            }
            if (Amount != 0L)
            {
                hash ^= Amount.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
Esempio n. 26
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (OwnerAddress.Length != 0)
            {
                hash ^= OwnerAddress.GetHashCode();
            }
            if (owner_ != null)
            {
                hash ^= Owner.GetHashCode();
            }
            if (witness_ != null)
            {
                hash ^= Witness.GetHashCode();
            }
            hash ^= actives_.GetHashCode();
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
Esempio n. 27
0
        public async Task <CreatePropertyCommandResult> Handle(CreatePropertyCommand request, CancellationToken cancellationToken)
        {
            #region Create property aggregate root

            var createdProperty = new CreatePropertyCommandResult();

            var address = new PropertyAddress(request.PropertySuiteNumber,
                                              request.PropertyNumber, request.PropertyStreet,
                                              request.PropertyCity, request.PropertyStateProvince, request.PropertyZipPostCode,
                                              request.PropertyCountry);

            var feature = new PropertyFeature(request.NumberOfBathrooms,
                                              request.NumberOfBathrooms, request.NumberOfLayers,
                                              request.NumberOfParking, request.BasementAvailable,
                                              request.TotalLivingArea, request.IsShared, request.FeatureNotes);


            var facility = new PropertyFacility(request.Stove, request.Refrigerator, request.Dishwasher,
                                                request.AirConditioner, request.Laundry, request.BlindsCurtain, request.Furniture,
                                                request.Tvinternet, request.CommonFacility, request.SecuritySystem, request.UtilityIncluded,
                                                request.FireAlarmSystem, request.FacilityNotes, request.Others);



            var property = new Property(request.PropertyName, request.PropertyDesc, request.Type, request.PropertyManagerUserName,
                                        request.PropertyBuildYear, true, request.IsShared, request.Status,
                                        request.BasementAvailable, DateTime.Now, DateTime.Now, address, facility, feature);


            await _context.AddAsync(property);

            #endregion


            PropertyOwner owner = null;

            if (request.PropertyOwnerId == 0)
            {
                object ownerAddress = null;

                if (!request.IsSameAddress)
                {
                    ownerAddress = new OwnerAddress(request.OwnerStreetNumber, request.OwnerCity, request.OwnerStateProv,
                                                    request.OwnerCountry, request.OwnerZipPostCode);
                }
                else
                {
                    ownerAddress = new OwnerAddress(request.PropertySuiteNumber + " " + request.PropertyNumber + " " + request.PropertyStreet, request.PropertyCity, request.PropertyStateProvince,
                                                    request.PropertyCountry, request.PropertyZipPostCode);
                }

                owner = property.AddOwner("NotSet", request.FirstName, request.LastName, request.ContactEmail,
                                          request.ContactTelephone1, request.ContactTelephone2, request.OnlineAccessEnbaled, request.UserAvartaImgUrl,
                                          request.IsActive, request.RoleId, request.Notes, (OwnerAddress)ownerAddress);


                await _context.AddAsync(owner);
            }
            else
            {
                owner = _context.PropertyOwner.FirstOrDefault(o => o.Id == request.PropertyOwnerId);

                var ownerProperty = property.AddExsitingOwner(owner);

                owner.OwnerProperty.Add(ownerProperty);
            }

            try
            {
                await _context.SaveChangesAsync(); // comment out for testing message sending ONLY

                int PropertyId = property.Id;

                int NewOwnerId = owner.Id;

                request.PropertyId  = property.Id;
                request.CreatedDate = property.Created;
                request.UpdateDate  = property.Modified;

                //Populate return resultEnum.GetName(typeof())
                //
                createdProperty.Id                    = PropertyId;
                createdProperty.PropertyName          = request.PropertyName;
                createdProperty.Type                  = request.Type.ToString();
                createdProperty.Status                = request.Status.ToString();
                createdProperty.PropertyLogoImgUrl    = request.PropertyLogoImgUrl;
                createdProperty.IsShared              = request.IsShared;
                createdProperty.IsActive              = request.IsActive;
                createdProperty.IsBasementSuite       = request.IsBasementSuite;
                createdProperty.CreatedDate           = DateTime.Now.ToString("MMMM dd, yyyy");
                createdProperty.UpdateDate            = DateTime.Now.ToString("MMMM dd, yyyy");
                createdProperty.PropertySuiteNumber   = request.PropertySuiteNumber;
                createdProperty.PropertyStreet        = request.PropertyStreet;
                createdProperty.PropertyCity          = request.PropertyCity;
                createdProperty.PropertyStateProvince = request.PropertyStateProvince;
                createdProperty.PropertyZipPostCode   = request.PropertyZipPostCode;
                createdProperty.PropertyCountry       = request.PropertyCountry;


                Log.Information("Property with id {PropertyName} has been successfully created.", property.PropertyName);



                // Publish Domain Event (MediatR pattern)

                AssetCore.Events.PropertyCreatedEvent domainEvent = new AssetCore.Events.PropertyCreatedEvent(property);

                await _mediator.Publish(domainEvent);



                // Publish Integration Event (RabbitMQ)

                var streetNum = request.PropertySuiteNumber + " " + request.PropertyNumber + " " + request.PropertyStreet;

                //var streetNum = address.PropertySuiteNumber + " " + address.PropertyNumber + " " + address.PropertyStreet;
                // Send message to MQ
                //
                PropertyCreatedEvent e = new PropertyCreatedEvent(Guid.NewGuid(), request.PropertyId, request.PropertyName, request.PropertyManagerUserName,
                                                                  request.PropertyBuildYear, request.Type.ToString(), request.BasementAvailable, request.IsShared, request.NumberOfBedrooms,
                                                                  request.NumberOfBathrooms, request.NumberOfLayers, request.NumberOfParking, request.TotalLivingArea,
                                                                  streetNum, request.PropertyCity, request.PropertyStateProvince, request.PropertyCountry,
                                                                  request.PropertyZipPostCode, NewOwnerId, request.FirstName, request.LastName, request.ContactEmail, request.ContactTelephone1, request.ContactTelephone2,
                                                                  request.OwnerStreetNumber, request.OwnerCity, request.OwnerStateProv, request.OwnerZipPostCode, request.OwnerCountry);

                try
                {
                    await _messagePublisher.PublishMessageAsync(e.MessageType, e, "asset_created"); // publishing the message

                    Log.Information("Message  {MessageType} with Id {MessageId} has been published successfully", e.MessageType, e.MessageId);
                }
                catch (Exception ex)
                {
                    Log.Error(ex, "Error while publishing {MessageType} message with id {MessageId}.", e.MessageType, e.MessageId);
                }


                // Log message for reconciliation purpose         ******** This part can be replaced by Serilog ***************
                //
                var msgDetails = new MessageDetails();

                msgDetails.PrincicipalId     = e.PropertyId;
                msgDetails.PrincipalType     = "Property";
                msgDetails.PrincipalNameDesc = e.PropertyName;
                msgDetails.OperationType     = "Create";

                var details = msgDetails.ToBsonDocument();

                var msg = new Message(e.MessageId, "Asset Management", details, "asset_created", "asset_created.*", "Publish", DateTime.Now);

                await _loggingService.LogMessage(msg);
            }
            catch (Exception ex)
            {
                //throw ex;
                Log.Error(ex, "Error while creating property, {PropertyName} has not been created.", request.PropertyName);
            }

            return(createdProperty);
            //return new CreatePropertyCommandResult() { };
        }
Esempio n. 28
0
        private async Task HandleAsync(RentalAppApprovedEvent @event)
        {
            var newTenant = new NewTenant(@event.UserName, @event.FirstName, @event.LastName, @event.ContactEmail,
                                          @event.ContactTelephone1, @event.ContactTelephone2, @event.ContactOthers, DateTime.Now, DateTime.Now);

            _context.Add(newTenant);

            //try
            //{
            //    await _context.SaveChangesAsync();
            //}
            //catch (Exception ex)
            //{
            //    throw ex;
            //}



            var rentalproperty = _context.RentalProperty.Include(a => a.Address).FirstOrDefault(a => a.OriginalId == @event.PropertyId); // Get related rental property

            //Note above: @event.ProeprtyId comes from the event and is the Id for rental property (in Marketing), it should be named OriginalId in RentalProperty in Lease service

            if (rentalproperty == null)
            {
                var address = new Address(@event.StreetNum, @event.City, @event.StateProvince, @event.Country, @event.ZipPostCode);

                var owners = new List <RentalPropertyOwner>();

                foreach (var owner in @event.PropertyOwners)
                {
                    var ownerAddress = new OwnerAddress(owner.OwnerStreetNum, owner.OwnerCity, owner.OwnerStateProvinc, owner.OwnerZipPostCode, owner.OwnerCountry);
                    var pOwner       = new RentalPropertyOwner(owner.PropertyOwnerId, owner.FirstName, owner.LastName, owner.ContactEmail, owner.ContactTelephone, owner.ContactOther, owner.RentalPropertyId, ownerAddress, DateTime.Now, DateTime.Now);
                    owners.Add(pOwner);
                }

//(IList<RentalPropertyOwner>)@event.PropertyOwners


                var newRentalProperty = new RentalProperty(@event.PropertyId, DateTime.Now, DateTime.Now, @event.ListingId, /*0,*/ @event.PropertyName, @event.Type, @event.PropertyBuildYear,
                                                           @event.IsShared, "Pending", @event.IsBasementSuite, @event.NumberOfBedrooms, @event.NumberOfBathrooms, @event.NumberOfLayers,
                                                           @event.NumberOfParking, @event.TotalLivingArea, @event.Notes, @event.PropertyManagerUserName, address, owners);

                _context.RentalProperty.Add(newRentalProperty);

                //try
                //{
                //    await _context.SaveChangesAsync();

                //    Log.Information("Message  {MessageType} with Id {MessageId} has been handled successfully", @event.MessageType, @event.MessageId);
                //}
                //catch (Exception ex)
                //{
                //    //throw ex;
                //    Log.Error(ex, "Error while handling {MessageType} message with id {MessageId}.", @event.MessageType, @event.MessageId);
                //}
            }

            try
            {
                await _context.SaveChangesAsync();

                Log.Information("Message  {MessageType} with Id {MessageId} has been handled successfully", @event.MessageType, @event.MessageId);
            }
            catch (Exception ex)
            {
                //throw ex;
                Log.Error(ex, "Error while handling {MessageType} message with id {MessageId}.", @event.MessageType, @event.MessageId);
            }


            //throw new NotImplementedException();
        }
Esempio n. 29
0
        private async Task HandleAsync(PropertyCreatedEvent @event)
        {
            //var p = _context.RentalProperty.FirstOrDefault(r => r.Id == 2); // Test code

            var ownerAddress = new OwnerAddress(@event.OwnerStreetNum, @event.OwnerCity, @event.OwnerStateProvince, @event.OwnerCountry, @event.OwnerZipPostCode);

            var owner = new RentalPropertyOwner(@event.OwnerId, @event.OwnerFirstName, @event.OwnerLastName, @event.OwnerContactEmail, @event.OwnerContactTel, @event.OwnerContactOther, ownerAddress, DateTime.Now, DateTime.Now);

            var owners = new List <RentalPropertyOwner>();

            owners.Add(owner);

            await _context.AddAsync(owner);

            var address = new Address(
                @event.StreetNum, @event.City, @event.StateProvince, @event.Country, @event.ZipPostCode);

            int geoId = 0;

            geoId = getGeoId(@event.City);

            var property = new RentalProperty(
                @event.PropertyId, @event.PropertyName, @event.Type, @event.PropertyManagerUserName, @event.PropertyBuildYear,
                @event.IsShared, @event.IsBasementSuite, @event.NumberOfBedrooms, @event.NumberOfBathrooms,
                @event.NumberOfLayers, @event.NumberOfParking, @event.TotalLivingArea, "", DateTime.Now,
                DateTime.Now, address, geoId, owners);


            await _context.AddAsync(property);

            try
            {
                await _context.SaveChangesAsync();

                Log.Information("Message  {MessageType} with Id {MessageId} has been handled successfully", @event.MessageType, @event.MessageId);
            }
            catch (Exception ex)
            {
                //throw ex;
                //string messageId = messageObject.Property("MessageId") != null ? messageObject.Property("MessageId").Value<string>() : "[unknown]";
                Log.Error(ex, "Error while handling {MessageType} message with id {MessageId}.", @event.MessageType, @event.MessageId);
            }

            //throw new NotImplementedException();

            //Log.Information("Message  {MessageType} with Id {MessageId} has been handled successfully", @event.MessageType, @event.MessageId);

            //var msgDetails = new MessageDetails();

            //msgDetails.PrincicipalId = @event.PropertyId;
            //msgDetails.PrincipalType = "Property";
            //msgDetails.PrincipalNameDesc = @event.PropertyName;
            //msgDetails.OperationType = "Create";

            //var details = msgDetails.ToBsonDocument();

            //var msg = new Message(@event.MessageId, "Asset Management", details, "asset_created", "asset_created.*", "Subscription", DateTime.Now);

            //var messageLoggingService = new MessageLoggingService();

            //await messageLoggingService.LogMessage(msg);
        }
Esempio n. 30
0
        public async Task <AddOwnerToExistingPropertyCommandResult> Handle(AddOwnerToExistingPropertyCommand request, CancellationToken cancellationToken)
        {
            var property = _context.Property.FirstOrDefault(p => p.Id == request.PropertyId);

            PropertyOwner owner = null;

            var addedOwner = new AddOwnerToExistingPropertyCommandResult();

            // Check if the email already exist if adding new owner instead of existing owner
            //

            //var user = _context.PropertyOwner.FirstOrDefault(e => e.ContactEmail == request.ContactEmail);

            //if (user != null)
            //{
            //    return new AddOwnerToExistingPropertyCommandResult() { Notes = "The email already exists!"};
            //}

            // populate the addedOnwer
            addedOwner.UserAvartaImgUrl    = request.UserAvartaImgUrl;
            addedOwner.FirstName           = request.FirstName;
            addedOwner.LastName            = request.LastName;
            addedOwner.UserName            = request.UserName;
            addedOwner.ContactEmail        = request.ContactEmail;
            addedOwner.ContactTelephone1   = request.ContactTelephone1;
            addedOwner.ContactTelephone2   = request.ContactTelephone2;
            addedOwner.OnlineAccessEnbaled = request.OnlineAccessEnbaled;
            addedOwner.IsActive            = request.IsActive;
            addedOwner.RoleId       = request.RoleId;
            addedOwner.Notes        = request.Notes;
            addedOwner.StreetNumber = request.StreetNumber;
            addedOwner.City         = request.City;
            addedOwner.StateProv    = request.StateProv;
            addedOwner.ZipPostCode  = request.ZipPostCode;
            addedOwner.Country      = request.Country;
            addedOwner.Created      = DateTime.Now.ToString("MMMM dd, yyyy");
            addedOwner.Updated      = DateTime.Now.ToString("MMMM dd, yyyy");


            if (request.PropertyOwnerId == 0)
            {
                // Check if the email already exist if adding new owner instead of existing owner
                //

                var user = _context.PropertyOwner.FirstOrDefault(e => e.ContactEmail == request.ContactEmail);

                if (user != null)
                {
                    return(new AddOwnerToExistingPropertyCommandResult()
                    {
                        Notes = "The email already exists!"
                    });
                }

                var ownerAddress = new OwnerAddress(request.StreetNumber, request.City, request.StateProv, request.Country, request.ZipPostCode);

                owner = property.AddNewOwnerToProperty(request.PropertyId, request.UserName, request.FirstName, request.LastName, request.ContactEmail,
                                                       request.ContactTelephone1, request.ContactTelephone2, false, request.UserAvartaImgUrl, request.IsActive, 2, request.Notes, ownerAddress);

                _context.Add(owner);
            }
            else
            {
                owner = _context.PropertyOwner.Include(a => a.Address).FirstOrDefault(o => o.Id == request.PropertyOwnerId);

                var ownerProperty = property.AddExistingOwnerToProperty(owner, request.PropertyId);

                _context.Add(ownerProperty);
            }


            try
            {
                await _context.SaveChangesAsync();

                addedOwner.Id = owner.Id;


                // logging
                Log.Information("The new owner {OwnerName} has been added to the property {PorpertyName} successfully", request.FirstName + " " + request.LastName, property.PropertyName);

                // Send messages if necessary
                // Publish message to MQ for other service to consume

                AddOwnerEvent e = new AddOwnerEvent(new Guid(), owner.Id, request.PropertyId, owner.UserName, owner.FirstName, owner.LastName,
                                                    owner.ContactEmail, owner.ContactTelephone1, owner.ContactTelephone2, owner.OnlineAccess,
                                                    owner.UserAvartaImgUrl, owner.IsActive, owner.RoleId, owner.Notes, owner.Address.StreetNumber,
                                                    owner.Address.City, owner.Address.StateProvince, owner.Address.ZipPostCode, owner.Address.Country);


                try
                {
                    await _messagePublisher.PublishMessageAsync(e.MessageType, e, "asset_created"); // publishing the message

                    Log.Information("Message  {MessageType} with Id {MessageId} has been published successfully", e.MessageType, e.MessageId);
                }
                catch (Exception ex)
                {
                    Log.Error(ex, "Error while publishing {MessageType} message with id {MessageId}.", e.MessageType, e.MessageId);
                }
            }
            catch (Exception ex)
            {
                //throw ex;
                Log.Error(ex, "Error occured while adding the new owner {OwnerName} to the property {PropertyName}.", request.FirstName + " " + request.LastName, property.PropertyName);
            }

            return(addedOwner);
        }