Exemple #1
0
        public async Task <AddResult> AddAsync(Flight flight)
        {
            FlightEntity flightDal = _mapper.Map <FlightEntity>(flight);

            AirportEntity toAirport = await _airportRepository.GetByIdAsync(flightDal.ToAirportId);

            AirportEntity fromAirport = await _airportRepository.GetByIdAsync(flightDal.FromAirportId);

            if (toAirport == null || fromAirport == null)
            {
                return(new AddResult(ResultTypes.NotFound, null));
            }

            AirplaneEntity airplane = await _airplaneRepository.GetByIdAsync(flightDal.AirplaneId);

            if (airplane == null)
            {
                return(new AddResult(ResultTypes.NotFound, null));
            }

            if (flight.ArrivalTime <= flight.DepartureTime)
            {
                return(new AddResult(ResultTypes.InvalidData, null));
            }

            int addedFlightId = await _flightRepository.AddAsync(flightDal);

            return(new AddResult(ResultTypes.Ok, addedFlightId));
        }
Exemple #2
0
        public async Task <bool> CheckDuplicateAsync(AirportEntity item)
        {
            AirportEntity duplicate =
                _airportsData.FirstOrDefault(x => x.Name == item.Name && x.CityId == item.CityId);

            return(duplicate != null);
        }
        public async Task <AddAirportResult> Handle(AddAirportCommand request, CancellationToken cancellationToken)
        {
            var country = await _unitOfWork.Countries.GetByIdAsync(request.CountryId, cancellationToken);

            var airportType = await _unitOfWork.AirportTypes.GetByIdAsync(request.TypeId, cancellationToken);

            var size = await _unitOfWork.AirportSizes.GetByIdAsync(request.SizeId, cancellationToken);

            var status = await _unitOfWork.AirportStatuses.GetByIdAsync(request.StatusId, cancellationToken);

            var airport = new AirportEntity
            {
                Id      = Guid.NewGuid(),
                Iata    = request.Iata,
                Name    = request.Name,
                Country = country,
                Type    = airportType,
                Size    = size,
                Status  = status,
                Lon     = request.Lon,
                Lat     = request.Lat
            };

            await _unitOfWork.Airports.CreateAsync(airport, cancellationToken);

            await _unitOfWork.SaveChanges(cancellationToken);

            return(new AddAirportResult(airport.Id));
        }
        public bool AddNewAirport(AirportEntity ae)
        {
            int result;

            string sql = "INSERT INTO airport([code], [name], [city], [state], [country], [utc_time],[deleted], [openning]) ";

            sql += "VALUES(@code, @name, @city, @state, @country, @utc_time,@deleted, @openning)";

            ParameterPair[] p = new ParameterPair[8];

            p[0] = new ParameterPair("@code", ae.Code);
            p[1] = new ParameterPair("@name", ae.Name);
            p[2] = new ParameterPair("@city", ae.City);
            p[3] = new ParameterPair("@state", ae.State);
            p[4] = new ParameterPair("@country", ae.Country);
            p[5] = new ParameterPair("@utc_time", ae.UtcTime);
            p[6] = new ParameterPair("@deleted", ae.Deleted.ToString());
            p[7] = new ParameterPair("@openning", ae.Openning.ToString());

            result = _dbconnection.ExecuteNonQuery(sql, p);

            if (result > 0)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Exemple #5
0
        public async Task <ResultTypes> UpdateAsync(Flight newFlight)
        {
            FlightEntity flightDal = _mapper.Map <FlightEntity>(newFlight);

            AirportEntity toAirport = await _airportRepository.GetByIdAsync(flightDal.ToAirportId);

            AirportEntity fromAirport = await _airportRepository.GetByIdAsync(flightDal.FromAirportId);

            if (toAirport == null || fromAirport == null)
            {
                return(ResultTypes.NotFound);
            }

            AirplaneEntity airplane = await _airplaneRepository.GetByIdAsync(flightDal.AirplaneId);

            if (airplane == null)
            {
                return(ResultTypes.NotFound);
            }

            if (newFlight.ArrivalTime <= newFlight.DepartureTime)
            {
                return(ResultTypes.InvalidData);
            }

            await _flightRepository.UpdateAsync(flightDal);

            return(ResultTypes.Ok);
        }
        public AirportEntity InsertAirportEntity(AirportEntity airport)
        {
            AirportEntity pass = context.Airports.Add(airport);

            context.SaveChanges();
            return(pass);
        }
        public void UpdateAirport(Guid airportId, AirportFormUpdate airportFormUpdate)
        {
            AirportEntity entity = _context.Airports.SingleOrDefault(a => a.Id == airportId);

            _mapper.Map(airportFormUpdate, entity);

            _context.SaveChanges();
        }
Exemple #8
0
        public AirportDto toDto(AirportEntity airport)
        {
            AirportDto airportDto = new AirportDto();

            airportDto.AirportId = airport.AirportId;
            airportDto.City      = airport.City;
            return(airportDto);
        }
Exemple #9
0
        public AirportEntity toEntity(AirportDto airportDto)
        {
            AirportEntity airport = new AirportEntity();

            airport.AirportId = airportDto.AirportId;
            airport.City      = airportDto.City;
            return(airport);
        }
Exemple #10
0
        public async Task UpdateAsync(AirportEntity airport)
        {
            using SqlConnection db = new SqlConnection(_dalSettings.ConnectionString);

            await db.ExecuteAsync(
                "UpdateAirport",
                new { id = airport.Id, name = airport.Name, cityId = airport.CityId },
                commandType : CommandType.StoredProcedure);
        }
Exemple #11
0
        public async Task <bool> CheckDuplicateAsync(AirportEntity airport)
        {
            using SqlConnection db = new SqlConnection(_dalSettings.ConnectionString);

            return(await db.ExecuteScalarAsync <bool>(
                       "CheckAirportDuplicate",
                       new { name = airport.Name, cityId = airport.CityId },
                       commandType : CommandType.StoredProcedure));
        }
Exemple #12
0
        public async Task <int> AddAsync(AirportEntity airport)
        {
            using SqlConnection db = new SqlConnection(_dalSettings.ConnectionString);

            return(await db.QuerySingleOrDefaultAsync <int>(
                       "AddAirport",
                       new { name = airport.Name, cityId = airport.CityId },
                       commandType : CommandType.StoredProcedure));
        }
        public void DeleteAirportEntity(int id)
        {
            AirportEntity pass = new AirportEntity()
            {
                AirportId = id
            };

            context.Airports.Attach(pass);
            context.Airports.Remove(pass);
            context.SaveChanges();
        }
Exemple #14
0
        public AirportEntity GetAirportEntityByID(int Id)
        {
            AirportEntity airport = null;

            using (var context = new TUIAssessmentDALContext(_options))
            {
                airport = context.Airports.Single(a => a.Id == Id);
            }

            return(airport);
        }
        public Airport GetAirportById(Guid id)
        {
            AirportEntity entity = _context.Airports.SingleOrDefault(a => a.Id == id);

            if (entity == null)
            {
                return(null);
            }

            return(_mapper.Map <Airport>(entity));
        }
        public void DeleteAirport(Guid airportId)
        {
            AirportEntity entity = _context.Airports.SingleOrDefault(a => a.Id == airportId);

            if (entity == null)
            {
                return;
            }

            _context.Remove(entity);
            _context.SaveChanges();
        }
 private async Task <bool> Update(AirportEntity airport)
 {
     try
     {
         _context.Update(airport);
         return(await _context.SaveChangesAsync() > 0);
     }
     catch (Exception e)
     {
         Console.WriteLine(e);
         return(false);
     }
 }
        private void btnAdd_Click(object sender, EventArgs e)
        {
            if (btnAdd.Text.Equals("Add"))
            {
                btnAdd.Text = "Save";
                LockControls(false);

                ClearBindingControls();

                ClearControls();
            }
            else if (btnAdd.Text.Equals("Save"))
            {
                AirportEntity ae = new AirportEntity();
                ae.Code     = txtCode.Text;
                ae.Name     = txtName.Text;
                ae.City     = txtCity.Text;
                ae.State    = txtState.Text;
                ae.Country  = txtCountry.Text;
                ae.UtcTime  = txtUTCTime.Text;
                ae.Openning = chkClosed.Checked;
                ae.Deleted  = false;

                AirportDAL ado = new AirportDAL();

                if (!ado.AddNewAirport(ae))
                {
                    MessageBox.Show("Can not insert new Airport. Please check again.", "Error", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
                }
                else
                {
                    DataRow newRow = dsAirport.Tables["Airport"].NewRow();
                    newRow["code"]     = ae.Code;
                    newRow["name"]     = ae.Name;
                    newRow["city"]     = ae.City;
                    newRow["state"]    = ae.State;
                    newRow["country"]  = ae.Country;
                    newRow["utc_time"] = ae.UtcTime;
                    newRow["openning"] = ae.Openning;
                    newRow["deleted"]  = ae.Deleted;

                    dsAirport.Tables["Airport"].Rows.Add(newRow);

                    BindingControls();
                    ClearControls();
                    LockControls(true);
                    // LoadAirportList(lsbCountry.GetItemText(lsbCountry.SelectedItem));
                }
            }
        }
        public async Task <bool> Add(AirportEntity airport)
        {
            try
            {
                await _context.Airports.AddAsync(airport);

                return(await _context.SaveChangesAsync() > 0);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                return(false);
            }
        }
        public Airport CreateAirport(AirportFormCreate airportFormCreate)
        {
            AirportEntity entity = _mapper.Map <AirportEntity>(airportFormCreate);

            entity.Id = Guid.NewGuid();

            _context.Airports.Add(entity);
            var created = _context.SaveChanges();

            if (created < 1)
            {
                throw new InvalidOperationException("Could not create new airport.");
            }

            return(_mapper.Map <Airport>(entity));
        }
        public List <AirportEntity> GetAirportList()
        {
            List <AirportEntity> list = new List <AirportEntity>();

            string sql = "SELECT [code], [name], [city], [state], [country], [utc_time],[deleted], [openning] ";

            sql += " FROM airport ";

            SqlDataReader dr = _dbconnection.ExecuteReader(sql);
            AirportEntity ae;

            while (dr.Read())
            {
                ae = new AirportEntity(dr["code"].ToString(), dr["name"].ToString(), dr["city"].ToString(),
                                       dr["state"].ToString(), dr["country"].ToString(),
                                       dr["utc_time"].ToString(), bool.Parse(dr["deleted"].ToString()),
                                       bool.Parse(dr["openning"].ToString()));

                list.Add(ae);
            }

            return(list);
        }
        public AirportEntity GetAirportByCode(string code)
        {
            string sql = "SELECT [code], [name], [city], [state], [country], [utc_time],[deleted], [openning] ";

            sql += " FROM airport WHERE [code]=@CODE";

            SqlDataReader dr = _dbconnection.ExecuteReader(sql, new ParameterPair[] { new ParameterPair("@CODE", code) });
            AirportEntity ae;

            if (dr.Read())
            {
                ae = new AirportEntity(dr["code"].ToString(), dr["name"].ToString(), dr["city"].ToString(),
                                       dr["state"].ToString(), dr["country"].ToString(),
                                       dr["utc_time"].ToString(), bool.Parse(dr["deleted"].ToString()),
                                       bool.Parse(dr["openning"].ToString()));

                return(ae);
            }
            else
            {
                return(null);
            }
        }
Exemple #23
0
 public static Airport ToModel(this AirportEntity model) => Mapper.Map <Airport>(model);
Exemple #24
0
 public async Task <int> AddAsync(AirportEntity item)
 {
     return(0);
 }
Exemple #25
0
 public async Task UpdateAsync(AirportEntity item)
 {
     // implementation
 }
Exemple #26
0
        public AirportDto AddAirport(AirportDto airportDto)
        {
            AirportEntity airportEntity = AirportRepository.InsertAirportEntity(AirportMapper.toEntity(airportDto));

            return(AirportMapper.toDto(airportEntity));
        }
 public void UpdateAirportEntity(AirportEntity airport)
 {
     throw new NotImplementedException();
 }
Exemple #28
0
 public async Task Update(AirportEntity entity)
 {
     using IDbConnection db = _configuration.GetConnection();
     await db.ExecuteAsync("UpdateAirport", entity, commandType : CommandType.StoredProcedure);
 }