private async Task <bool> PrvidePowerBank(HolderModel holderModel, PowerbankModel powerbank)
        {
            var request = WebRequest.Create(_baseUrl);

            request.Method = "POST";
            using (Stream requestStream = request.GetRequestStream())
            {
                var holderRequest = new HolderRequest()
                {
                    Position      = powerbank.Position.ToString(),
                    EquipmentSn   = holderModel.Code,
                    DeviceType    = "8",
                    DeviceVersion = "1",
                    SessionId     = "94868768687778",
                    PackageType   = "171"
                };
                var holderRequestString = JsonConvert.SerializeObject(holderRequest);
                var holderRequestBuf    = Encoding.UTF8.GetBytes(holderRequestString);
                requestStream.Write(holderRequestBuf);
            }

            var response = await request.GetResponseAsync();

            string responceString = "";

            using (Stream dataStream = response.GetResponseStream())
            {
                StreamReader reader = new StreamReader(dataStream);
                responceString = await reader.ReadToEndAsync();
            }
            return(true);
        }
        public async Task UpdatePowerbanksInfo(IEnumerable <EquipmentNotifyPowerbank> powerbanksNotifies)
        {
            foreach (var powerbanksNotify in powerbanksNotifies)
            {
                var powerbankToUpdate = await _appRepository.Powerbanks.Include(x => x.Holder).FirstOrDefaultAsync(x => x.Code == powerbanksNotify.PowerBankSn);

                if (powerbankToUpdate == null)
                {
                    var holder = await _appRepository.Holders.FirstOrDefaultAsync(x => x.Code == powerbanksNotify.EquipmentSn);

                    if (holder == null)
                    {
                        continue;
                    }

                    var powerbankToAdd = new PowerbankModel
                    {
                        Code        = powerbanksNotify.PowerBankSn,
                        Position    = int.Parse(powerbanksNotify.Position),
                        Electricity = int.Parse(powerbanksNotify.Electricity),
                        Holder      = holder
                    };

                    await _appRepository.Powerbanks.AddAsync(powerbankToAdd);

                    await _appRepository.SaveChangesAsync();

                    continue;
                }

                powerbankToUpdate.Position = int.Parse(powerbanksNotify.Position);
                _appRepository.Entry(powerbankToUpdate).Property(x => x.Position).IsModified = true;

                powerbankToUpdate.Electricity = int.Parse(powerbanksNotify.Electricity);
                _appRepository.Entry(powerbankToUpdate).Property(x => x.Electricity).IsModified = true;

                var currentHolder = powerbankToUpdate.Holder;
                var newHolder     = await _appRepository.Holders.FirstOrDefaultAsync(x => x.Code == powerbanksNotify.EquipmentSn);

                if (currentHolder == null || newHolder == null)
                {
                    continue;
                }

                if (currentHolder.Code != newHolder.Code)
                {
                    powerbankToUpdate.Holder = newHolder;
                }
            }

            await _appRepository.SaveChangesAsync();
        }
        public async Task <bool> ProvidePowerBank(int idCostumer, int holderId, RentModel rentModel, string cardBindingId)
        {
            var costumer = await _appRepository.Costumers.Include(x => x.Sessions).FirstOrDefaultAsync(x => x.Id == idCostumer);

            var holder = await _appRepository.Holders.Include(x => x.Powerbanks).ThenInclude(x => x.Sessions).FirstOrDefaultAsync(x => x.Id == holderId);

            if (costumer == null || holder == null)
            {
                return(false);
            }

            PowerbankModel powerBankToProvide = null;

            var lastPowerbankSession = costumer.Sessions.OrderBy(x => x.Start).LastOrDefault();

            if (lastPowerbankSession == null)
            {
                var powerBank = holder.Powerbanks.Where(x => x.Sessions.Where(y => y.IsActive).Count() == 0 && x.Electricity > 75).OrderBy(x => x.Position).FirstOrDefault();
                if (powerBank == null)
                {
                    return(false);
                }

                powerBankToProvide = powerBank;
            }
            else
            {
                var powerBanks = holder.Powerbanks.Where(x => x.Sessions.Where(y => y.IsActive).Count() == 0 && x.Electricity > 75).OrderBy(x => x.Position);
                if (powerBanks.Count() == 1)
                {
                    powerBankToProvide = powerBanks.FirstOrDefault();
                }
                else
                {
                    powerBankToProvide = powerBanks.Where(x => x.Id != lastPowerbankSession.Powerbank.Id).FirstOrDefault();
                }
            }

            //if (powerBankToProvide == null)
            //{
            //    var powerBank = holder.Powerbanks.Where(x => x.Sessions.Where(y => y.IsActive).Count() == 0 && x.Electricity > 75).OrderBy(x => x.Position).FirstOrDefault();
            //    if (powerBank == null) return false;

            //    powerBankToProvide = powerBank;
            //}

            if (!await PrvidePowerBank(holder, powerBankToProvide))
            {
                return(false);
            }

            var card = await _appRepository.CardBidnings.FirstOrDefaultAsync(x => x.BindingId == cardBindingId);

            card.IsLocked = true;
            _appRepository.Entry(card).Property(x => x.IsLocked).IsModified = true;

            var session = new PowerbankSessionModel
            {
                Costumer  = costumer,
                Start     = DateTime.Now,
                Powerbank = powerBankToProvide,
                CardId    = cardBindingId,
                RentModel = rentModel
            };

            await _appRepository.PowerbankSessions.AddAsync(session);

            await _appRepository.SaveChangesAsync();

            return(true);
        }