コード例 #1
0
        public async Task Init()
        {
            IsLoaded = true;
            _userId  = int.Parse(JWTService.DecodeJWT());
            var user = await _authService.GetById(_userId);

            IsSupplier = JWTService.DecodeJWTRole() == Role.Supplier;
            IsClient   = !IsSupplier;
            InitProperties(user);
            IsLoaded = true;
        }
コード例 #2
0
        public async Task Init()
        {
            IsSupplier = JWTService.DecodeJWTRole() == Role.Supplier;
            IsClient   = !IsSupplier;

            var result = await this._authService.GetById(Id);

            InitProperties(result);
            var address = await _addressService.GetById <Address>((int)result.AddressId);

            InitAddress(address);
            var country = await _countryService.GetById <Country>((int)address.CountryId);

            InitCountry(country);
        }
コード例 #3
0
        public async Task Init()
        {
            var request = await _requestService.GetById <Request>(Id);

            if (request.Inactive == true)
            {
                InActiveRequest = true;
                ActiveRequest   = false;
                return;
            }
            InitRequest(request);
            var address = await _addressService.GetById <Address>(request.DeliveryAddress);

            var country = await _countryService.GetById <Country>((int)address.CountryId);

            var status = await _statusService.GetById <Model.Status>(request.StatusId);

            InitStatus(status);

            Address    = $"{country.Name}, {address.ZipCode}, {address.City}";
            IsSupplier = JWTService.DecodeJWTRole() == Role.Supplier;
            IsClient   = !IsSupplier;

            if (IsClient)
            {
                var searchRequest = new OfferSearchRequest
                {
                    RequestId     = Id,
                    OfferStatusId = (int)Models.OfferStatus.Active
                };
                var offerList = await _offerService.GetAll <List <Offer> >(searchRequest);

                if (offerList.Count == 0)
                {
                    HaveAcceptedOffer = await RequestHaveAcceptedOffer();

                    HaveFinishedOffer = await RequestHaveFinishedOffer();

                    HaveActiveOffers = await RequestHaveActiveOffer();

                    var finishedOffer = await RequestHaveFinishedOfferWithoutRating();

                    if (!HaveAcceptedOffer && !finishedOffer)
                    {
                        ShowEditButton = true;
                    }

                    if (HaveFinishedOffer)
                    {
                        var list = await _ratingTypeService.GetAll <List <Model.RatingType> >();

                        RatingTypeList.Clear();
                        foreach (var rt in list)
                        {
                            RatingTypeList.Add(rt);
                        }
                    }
                }
                else
                {
                    ShowList = true;
                }

                OfferList.Clear();
                foreach (var offer in offerList)
                {
                    var supplier = await _authService.GetById(offer.UserId);

                    var supplierAddress = await _addressService.GetById <Address>((int)supplier.AddressId);

                    var supplierCountry = await _countryService.GetById <Country>((int)supplierAddress.CountryId);

                    var user = await _authService.GetById(offer.UserId);

                    var newOffer = new RequestDetailsOffers
                    {
                        Company    = user.Company,
                        UserFromId = offer.UserId,
                        Address    = supplierCountry.Name + ", " + supplierAddress.City,
                        OfferId    = offer.OfferId
                    };

                    OfferList.Add(newOffer);
                }
                OffersHeight = OfferList.Count * 65;
            }
            else
            {
                await InitFieldsVisibility();
            }

            var recommendedRequests = await _requestService.RecommendRequest <List <Request> >(Id);

            RecommendedRequests.Clear();
            foreach (var recRequest in recommendedRequests)
            {
                var toAddress = await _addressService.GetById <Address>(recRequest.DeliveryAddress);

                var toCountry = await _countryService.GetById <Country>((int)toAddress.CountryId);

                var fromUser = await _authService.GetById(recRequest.ClientId);

                var fromAddress = await _addressService.GetById <Address>((int)fromUser.AddressId);

                var fromCountry = await _countryService.GetById <Country>((int)fromAddress.CountryId);

                var requestModel = new RequestModel
                {
                    FromCountry = fromCountry.Name,
                    Price       = recRequest.Price,
                    RequestId   = recRequest.RequestId,
                    ToCountry   = toCountry.Name,
                    FullName    = $"{fromUser.FirstName} {fromUser.LastName}"
                };

                RecommendedRequests.Add(requestModel);
            }

            if (RecommendedRequests.Count > 0)
            {
                RecommendShowList = true;
            }
            else
            {
                RecommendShowList = false;
            }
        }