public async Task <IActionResult> PutAirplaneModel(int id, AirplaneModel airplaneModel)
{
if (id != airplaneModel.AirplaneId)
{
return(BadRequest());
}
_context.Entry(airplaneModel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AirplaneModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <AirplaneModel> > PostAirplaneModel(AirplaneModel airplaneModel)
{
_context.Airplanes.Add(airplaneModel);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAirplaneModel", new { id = airplaneModel.AirplaneId }, airplaneModel));
}
public void AssertAirplaneSaved()
{
AirplaneStorage storage = new AirplaneStorage(PATH_TEST);
// Create Airplane Model
ArrayList waypoints = new ArrayList();
waypoints.Add(new Vector3(0.0f, 0.0f, 1000.0f));
waypoints.Add(new Vector3(100.0f, 100.0f, 1000.0f));
AirplaneModel airplaneModel = new AirplaneModel(1, "test", Utilities.parseToString(waypoints));
// Save the model in file
storage.Save(airplaneModel);
// Load the airplane
ArrayList result = storage.Load();
// Assert that the number of airplanes model is 1
Debug.Log(result.Count);
// Assert AirplaneModel attributes with the first AirplaneModel in file
AirplaneModel resultModel = (AirplaneModel)result [0];
Assert.That(resultModel.id == airplaneModel.id);
Assert.That(resultModel.name == airplaneModel.name);
Assert.That(resultModel.waypoints == airplaneModel.waypoints);
}
private Resultado DadosValidos(AirplaneModel aeroplano)
{
var resultado = new Resultado();
if (aeroplano == null)
{
resultado.Inconsistencias.Add(
"Preencha os dados do aeroplano");
}
else
{
if (String.IsNullOrWhiteSpace(aeroplano.Modelo))
{
resultado.Inconsistencias.Add(
"Preencha o Nome do Modelo");
}
if (aeroplano.QuantidadePassageiros <= 0)
{
resultado.Inconsistencias.Add(
"A quantidade de passageiros deve ser maior do que zero");
}
}
return(resultado);
}
public void EditAirplane(AirplaneModel airplane)
{
var entity = _airplaneMapper.MapToEntity(airplane);
_uof.Airplanes.Update(entity);
_uof.Complete();
}
public Resultado Atualizar(AirplaneModel dados)
{
Resultado resultado = DadosValidos(dados);
resultado.Acao = "Atualização de Aeroplano";
if (resultado.Inconsistencias.Count == 0)
{
AirplaneModel aeroplano = _context.Airplanes.Where(
p => p.AirplaneId == dados.AirplaneId).FirstOrDefault();
if (aeroplano == null)
{
resultado.Inconsistencias.Add(
"Aeroplano não encontrado");
}
else
{
aeroplano.Modelo = dados.Modelo;
aeroplano.QuantidadePassageiros = dados.QuantidadePassageiros;
aeroplano.DtCriacao = dados.DtCriacao;
_context.SaveChanges();
}
}
return(resultado);
}
public void insertAirplane(string name, string waypoints)
{
AirplaneModel data = new AirplaneModel(-1, name, waypoints);
((AirplaneStorage)airplaneStorage).Insert(data);
airplanes = Load();
}
public void AssertAirplaneInserted()
{
AirplaneStorage storage = new AirplaneStorage(PATH_TEST);
// Create Airplane Model
ArrayList waypoints = new ArrayList();
waypoints.Add(new Vector3(0.0f, 0.0f, 1000.0f));
waypoints.Add(new Vector3(100.0f, 100.0f, 1000.0f));
AirplaneModel airplaneModel = new AirplaneModel(1, "test", Utilities.parseToString(waypoints));
// Save the model in file
storage.Save(airplaneModel);
// Update Airplane Model
string name = "updatedTest";
waypoints [0] = new Vector3(50.0f, 50.0f, 1000.0f);
airplaneModel = new AirplaneModel(1, name, Utilities.parseToString(waypoints));
// Update it in File
storage.Insert(airplaneModel);
// Load the airplane
ArrayList result = storage.Load();
// Assert AirplaneModel attributes with the first AirplaneModel in file
AirplaneModel resultModel = (AirplaneModel)result [0];
Assert.That(resultModel.id == airplaneModel.id);
Assert.That(resultModel.name == airplaneModel.name);
Assert.That(resultModel.waypoints == airplaneModel.waypoints);
}
public void updateAirplane(int id, string name, string waypoints)
{
AirplaneModel data = new AirplaneModel(id, name, waypoints);
((AirplaneStorage)airplaneStorage).Insert(data);
airplanes = Load();
}
public OnBoardCamera(string name, AirplaneModel airplane)
: base(name)
{
this.airplane = airplane;
this.Near = 0.1f;
this.FieldOfView = (float)Math.PI / 4;
}
private void addChildItemToolStripMenuItem_Click(object sender, EventArgs e)
{
if (TreeViewHierarchy.SelectedNode != null)
{
ControlSurface surface = TreeViewHierarchy.SelectedNode.Tag as ControlSurface;
AirplaneModel airplane = TreeViewHierarchy.Nodes[0].Tag as AirplaneModel;
if (surface != null)
{
RCSim.DataClasses.AircraftParameters.ControlSurface surfaceDef = new RCSim.DataClasses.AircraftParameters.ControlSurface();
if (surface.SurfaceDefinition.ChildControlSurfaces == null)
{
surface.SurfaceDefinition.ChildControlSurfaces = new List <RCSim.DataClasses.AircraftParameters.ControlSurface>();
}
surface.SurfaceDefinition.ChildControlSurfaces.Add(surfaceDef);
ControlSurface newSurface = new ControlSurface(surfaceDef, surface.AirplaneControl);
surface.AddChild(newSurface);
}
else if (airplane != null)
{
RCSim.DataClasses.AircraftParameters.ControlSurface surfaceDef = new RCSim.DataClasses.AircraftParameters.ControlSurface();
ModelControl.AirplaneModel.AirplaneControl.AircraftParameters.ControlSurfaces.Add(surfaceDef);
ControlSurface newSurface = new ControlSurface(surfaceDef, airplane.AirplaneControl);
airplane.AddChild(newSurface);
}
BuildTreeView(airplane);
}
}
public void AddAirplane(AirplaneModel airplane)
{
var entity = _airplaneMapper.MapToEntity(airplane);
_uof.Airplanes.Add(entity);
_uof.Complete();
}
public ModelControl(string filename, bool create)
{
reflection = new Reflection();
heightmap = new Heightmap(1000);
heightmap.MinHeight = -5f;
heightmap.MaxHeight = 5f;
useAileronForRudder = Convert.ToBoolean(Bonsai.Utils.Settings.GetValue("UseAileronChannel"));
AircraftParameters parameters = new AircraftParameters();
if (create)
{
parameters.CreateDefault(filename);
}
else
{
parameters.File = filename;
}
if (parameters.Version == 2)
{
iFlightModel = new FlightModelWind2();
}
else
{
iFlightModel = new FlightModelWind();
}
iFlightModel.AircraftParameters = parameters;
iFlightModel.Heightmap = heightmap;
iFlightModel.Paused = true;
iFlightModel.Initialize();
airplaneModel = new AirplaneModel(iFlightModel);
airplaneModel.Position = new Vector3(0, 0, 0);
}
public AirplanViewModel(AirplaneModel m)
{
this.model = m;
model.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e)
{
NotifyPropertyChanged("vm_" + e.PropertyName);
};
}
public static void Initialize(AirplaneContext context)
{
context.Database.EnsureCreated();
if (context.Airplane.Any())
{
return;
}
var airplane1 = new AirplaneModel
{
Id = new Guid(),
Model = "Airbus A380",
PassengersNumber = 50,
CreatedOn = DateTime.Now
};
var airplane2 = new AirplaneModel
{
Id = new Guid(),
Model = "Boeing 707",
PassengersNumber = 60,
CreatedOn = DateTime.Now
};
var airplane3 = new AirplaneModel
{
Id = new Guid(),
Model = "Airbus A320",
PassengersNumber = 40,
CreatedOn = DateTime.Now
};
var airplane4 = new AirplaneModel
{
Id = new Guid(),
Model = "Boeing 727",
PassengersNumber = 50,
CreatedOn = DateTime.Now
};
var airplane5 = new AirplaneModel
{
Id = new Guid(),
Model = "Boeing 767",
PassengersNumber = 80,
CreatedOn = DateTime.Now
};
var airplanes = new List <AirplaneModel> {
airplane1, airplane2, airplane3, airplane4, airplane5
};
context.Airplane.AddRange(airplanes);
context.SaveChanges();
}
public override IFlight GenerateFlight(DateTime departureTime, AirplaneModel model)
{
return(new Flight()
{
FlightId = String.Format("{0}-{1}", FlightPrefix, nextFlightId++),
Model = model,
DepartureTime = departureTime,
Status = FlightStatus.New
});
}
public ResponseResult <AirplaneModel> Add(AirplaneModel entity)
{
var validation = new AirplaneCreateValidation().Validate(entity);
if (!validation.IsValid)
{
return(new ResponseResult <AirplaneModel>(validation));
}
_airplaneRepository.Add(entity);
return(new ResponseResult <AirplaneModel>(entity));
}
public static Airplane Generate(string modelName, string flightID)
{
rand = new Random();
List <AirplaneModel> models = AirplaneModel.Models as List <AirplaneModel>;
AirplaneModel modelNeeded = models.Find(m => m.Model == modelName);
Airplane airplane = new Airplane(modelNeeded, aiplaneID);
aiplaneID++;
airplane.FlightID = flightID;
return(FillAirplane(airplane));
}
private bool ValidarAirPlane(AirplaneModel airplaneModel)
{
if (airplaneModel.IsValid())
{
return(true);
}
NotifyErrorValidation(airplaneModel.ValidationResult);
return(false);
}
public Airplane(AirplaneModel model, int id)
{
this.model = model;
this.airplaneID = "Plane-" + id;
MotionPermitted = false;
FoodList = new Dictionary <Food, int>()
{
{ Food.Child, 0 },
{ Food.Standard, 0 },
{ Food.Vegan, 0 }
};
}
protected void BuildTreeView(AirplaneModel airplaneModel)
{
TreeViewHierarchy.Nodes.Clear();
if (airplaneModel != null)
{
TreeNode rootNode = new TreeNode(GetNodeName(airplaneModel.AirplaneControl.AircraftParameters.FixedMesh));
rootNode.Tag = airplaneModel;
TreeViewHierarchy.Nodes.Add(rootNode);
AddChildren(airplaneModel, rootNode);
}
TreeViewHierarchy.ExpandAll();
}
public void Adicionar(AirplaneModel airplaneModel)
{
var airplane = new AirplaneModel(airplaneModel.Modelo, airplaneModel.QtdPassageiros);
if (!ValidarAirPlane(airplane))
{
return;
}
_airplaneRepo.Add(airplane);
Commit();
}
public IActionResult Post([FromBody] AirplaneModel item)
{
try
{
service.Post <AirplaneModelValidator>(item);
return(new ObjectResult(item.Id));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public AirplaneModel MapToModel(Airplane entity)
{
var model = new AirplaneModel
{
Id = entity.Id,
Company = entity.Company,
Model = entity.Model,
DefaultPrice = entity.DefaultPrice,
Seats = entity.Seats
};
return(model);
}
public Airplane MapToEntity(AirplaneModel model)
{
var entity = new Airplane
{
Id = model.Id,
Company = model.Company,
Model = model.Model,
DefaultPrice = model.DefaultPrice,
Seats = model.Seats
};
return(entity);
}
private long CreateAirplane(AirplaneModel airplaneModel)
{
if (airplaneModel?.Id == GuestId)
{
return(this.airplaneRepository.AddGuestAirplane(airplaneModel));
}
if (this.airplaneRepository.TryGetAirplane(airplaneModel, out long airplaneId))
{
return(airplaneId);
}
throw new KeyNotFoundException("Airplane not found");
}
public long AddGuestAirplane(AirplaneModel airplaneModel)
{
using var dbContext = new LocalDatabaseContext();
Airplane airplane = new Airplane
{
GuestAirplaneImmatriculation = airplaneModel.Immatriculation,
GuestAirplaneType = airplaneModel.Type,
};
dbContext.Airplanes.Add(airplane);
dbContext.SaveChanges();
return(airplane.Id);
}
public ActionResult <AirplaneModel> Get(int codigoAviao)
{
AirplaneModel airplane = null;
var response = _airplaneComponent.Obter(codigoAviao);
if (response != null)
{
airplane = CommonHelper.Instance.BuildResultComponent <AirplaneModel>(response);
return(airplane);
}
else
{
return(NotFound());
}
}
public void Editar(AirplaneModel airplaneModel)
{
if (!ValidarAirPlane(airplaneModel))
{
return;
}
var atual = _airplaneRepo.GetById(airplaneModel.Id);
airplaneModel.DataCriacao = atual.DataCriacao; //Todo: Alterar essa forma de fazer
_airplaneRepo.Update(airplaneModel);
Commit();
}
private void surfacePropertiesControl_FileChanged(object sender, EventArgs e)
{
if (TreeViewHierarchy.SelectedNode != null)
{
ControlSurface surface = TreeViewHierarchy.SelectedNode.Tag as ControlSurface;
AirplaneModel airplane = TreeViewHierarchy.Nodes[0].Tag as AirplaneModel;
if (surface != null)
{
TreeViewHierarchy.SelectedNode.Text = GetNodeName(surface.MeshFileName);
}
else if (airplane != null)
{
TreeViewHierarchy.SelectedNode.Text = GetNodeName(airplane.MeshFileName);
}
}
}
