public static void UpdateEntity(this Data.Aircraft entity, AircraftViewModel model)
{
if (model == null || entity == null)
{
return;
}
entity.Id = model.Id;
entity.ProducerName = model.ProducerName;
entity.ProducerNameEn = model.ProducerNameEn;
entity.ProducerCountryCode = model.ProducerCountryCode;
entity.ProducerCountryName = model.ProducerCountryName;
entity.AirCategoryCode = model.AirCategoryCode;
entity.AirCategoryName = model.AirCategoryName;
entity.Icao = model.Icao;
entity.MsnserialNumber = model.MsnserialNumber;
entity.ModelName = model.ModelName;
entity.ModelNameEn = model.ModelNameEn;
entity.AircraftDebt = new List <AircraftDebt>();
if (model.Debts != null && model.Debts.Any())
{
entity.AircraftDebt = model.Debts
.Select(x => x.ToEntity()).ToList();
}
entity.AircraftRegistration = new List <AircraftRegistration>();
if (model.Registrations != null && model.Registrations.Any())
{
entity.AircraftRegistration = model.Registrations
.Select(x => x.ToEntity()).ToList();
}
return;
}
public static AircraftViewModel ToViewModel(this Aircraft entity)
{
if (entity == null)
{
return(null);
}
AircraftViewModel model = new AircraftViewModel
{
Id = entity.Id,
ProducerName = entity.ProducerName,
ProducerNameEn = entity.ProducerNameEn,
ProducerCountryCode = entity.ProducerCountryCode,
ProducerCountryName = entity.ProducerCountryName,
AirCategoryCode = entity.AirCategoryCode,
AirCategoryName = entity.AirCategoryName,
Icao = entity.Icao,
MsnserialNumber = entity.MsnserialNumber,
ModelName = entity.ModelName,
ModelNameEn = entity.ModelNameEn,
Debts = entity.AircraftDebt
.Select(x => x.ToViewModel()).ToList(),
Registrations = entity.AircraftRegistration
.Select(x => x.ToViewModel()).ToList(),
};
return(model);
}
public ActionResult LoadDetails(int id)
{
var model = new AircraftViewModel();
model = _actypeService.GetAll().Where(x => x.ID == id).FirstOrDefault();
return(Json(model, JsonRequestBehavior.AllowGet));
}
public AircraftViewModel Create(AircraftViewModel aircraft)
{
try
{
var _existingAircraft = _repository.Find(wh => wh.Codigo == aircraft.Codigo);
if (_existingAircraft != null && !_existingAircraft.IsDeleted)
{
throw new ApiException("Já existe um registro com esse código", HttpStatusCode.Conflict);
}
if (_existingAircraft != null && _existingAircraft.IsDeleted)
{
Update(_existingAircraft.Id.ToString(), aircraft);
return(_mapper.Map <AircraftViewModel>(_existingAircraft));
}
else
{
var _airplane = _repository.Create(_mapper.Map <Aircraft>(aircraft));
return(_mapper.Map <AircraftViewModel>(_airplane));
}
}
catch (Exception)
{
throw;
}
}
public void Update(string id, AircraftViewModel airplaneToUpdate)
{
try
{
if (!Guid.TryParse(id, out Guid _parsedId))
{
throw new ApiException("O Id especificado é inválido", HttpStatusCode.BadRequest);
}
var _existingAircraft = _repository.Find(wh => wh.Id == _parsedId);
if (_existingAircraft == null)
{
throw new ApiException("Avião não encontrado", HttpStatusCode.NotFound);
}
//necessário para mapear
airplaneToUpdate.Id = id;
airplaneToUpdate.CreatedDate = DateTime.Now;
_existingAircraft.IsDeleted = false;
_repository.Update(_mapper.Map(airplaneToUpdate, _existingAircraft));
}
catch (Exception)
{
throw;
}
}
public static AircraftViewModel ToViewModel(this RegiX.Client.ResponseModels.Aircraft model)
{
if (model == null)
{
return(null);
}
AircraftViewModel viewModel = new AircraftViewModel
{
Id = -1,
ProducerName = model.Producer?.Name,
ProducerNameEn = model.Producer?.NameEn,
ProducerCountryCode = model.Producer?.CountryCode,
ProducerCountryName = model.Producer?.CountryName,
AirCategoryCode = model.AirCategory?.Code,
AirCategoryName = model.AirCategory?.Name,
Icao = model.ICAO,
MsnserialNumber = model.MSNSerialNumber,
ModelName = model.BGModelName,
ModelNameEn = model.ENModelName,
};
viewModel.Registrations = CreateAircraftRegistrationViewModels(model);
viewModel.Debts = CreateAircraftDebtViewNodels(model);
return(viewModel);
}
public ActionResult Update(AircraftViewModel model)
{
//update data
string msg = _actypeService.Update(model);
return(Json(new { Message = msg }, JsonRequestBehavior.AllowGet));
}
public async Task <Data.Aircraft> AddOrUpdateAircraftAsync(AircraftViewModel model)
{
if (model == null)
{
throw new NullReferenceException("AircraftViewModel is null");
}
Data.Aircraft entity = null;
var existing = await _context.Aircraft
.Include(x => x.AircraftDebt)
.Include(x => x.AircraftRegistration)
.Include(x => x.AircraftRegistration).ThenInclude(x => x.AircraftRegistrationOwnerPerson)
.Include(x => x.AircraftRegistration).ThenInclude(x => x.AircraftRegistrationOwnerEntity)
.Include(x => x.AircraftRegistration).ThenInclude(x => x.AircraftRegistrationOperatorPerson)
.Include(x => x.AircraftRegistration).ThenInclude(x => x.AircraftRegistrationOperatorEntity)
.Where(x => x.MsnserialNumber.ToLower() == model.MsnserialNumber.ToLower() &&
x.AircraftExtension != null &&
x.AircraftExtension.Deactivated == false)
.ToListAsync();
if (!existing.Any())
{
entity = model.ToEntity();
entity.Id = 0;
entity.AircraftExtension.AircraftId = entity.Id;
await _context.Aircraft.AddAsync(entity);
}
else
{
foreach (Data.Aircraft item in existing)
{
item.AircraftExtension.Deactivated = true;
_context.AircraftDebt.RemoveRange(item.AircraftDebt);
foreach (Data.AircraftRegistration reg in item.AircraftRegistration)
{
_context.AircraftRegistrationOperatorPerson.RemoveRange(reg.AircraftRegistrationOperatorPerson);
_context.AircraftRegistrationOperatorEntity.RemoveRange(reg.AircraftRegistrationOperatorEntity);
_context.AircraftRegistrationOwnerPerson.RemoveRange(reg.AircraftRegistrationOwnerPerson);
_context.AircraftRegistrationOwnerEntity.RemoveRange(reg.AircraftRegistrationOwnerEntity);
}
_context.AircraftRegistration.RemoveRange(item.AircraftRegistration);
}
existing[0].UpdateEntity(model);
existing[0].AircraftExtension.Deactivated = false;
existing[0].AircraftExtension.UpdatedAt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc);
existing[0].AircraftExtension.RequestId = model.ExtensionRequestId;
_context.Aircraft.Update(existing[0]);
entity = existing[0];
}
await _context.SaveChangesAsync();
return(entity);
}
public string Update(AircraftViewModel model)
{
string msg = string.Empty;
try
{
AircraftType aircraft = _context.AsQueryable <AircraftType>().Where(x => x.ID == model.ID).FirstOrDefault();
bool isExists = false;
#region Check if new name changed
if (aircraft.Name.Trim().ToUpper() != model.Name.Trim().ToUpper())
{
int ctr = _context.AsQueryable <AircraftType>().Where(x => x.Name.Trim() == model.Name.Trim()).Count();
if (ctr > 0)
{
isExists = true;
}
}
#endregion
if (isExists)
{
msg = "Aircraft name already exists.";
}
else
{
if (!string.IsNullOrEmpty(model.Name))
{
aircraft.Name = model.Name;
}
if (!string.IsNullOrEmpty(model.Description))
{
aircraft.Description = model.Description;
}
aircraft.DateModified = DateTime.Now;
if (aircraft != null)
{
_context.Update <AircraftType>(aircraft);
_context.SaveChanges();
}
msg = "Aircraft updated.";
}
}
catch (Exception ex)
{
LogsViewModel error = new LogsViewModel()
{
ActionType = ActionType.Error.ToString(),
Description = ex.Message + "\n" + ex.StackTrace,
ModifiedBy = "Aircraft Service Error : Update()",
DateModified = DateTime.Now.ToString("MM/dd/yyyy HH:mm")
};
new LogsService().Create(error);
msg = "Unexpected error encountered. Please contact your system administrator.";
//log error
}
return(msg);
}
public virtual ActionResult CreateAircraft(AircraftViewModel aircraftViewModel)
{
this.Validate(aircraftViewModel, string.Empty);
if (!ModelState.IsValid)
{
return(View(Views.CreateAircraft, aircraftViewModel));
}
flightProgramsRepository.AddNewAircraftMds(aircraftViewModel.Name);
return(RedirectToAction(MVC.FlightPrograms.Manage()));
}
public IActionResult Index()
{
var list = _aircraftrepository.Aircrafts;
var vm = new AircraftViewModel()
{
Aircrafts = list
};
return(View(vm));
}
public IActionResult Edit(AircraftViewModel aircraft)
{
if (!ModelState.IsValid)
{
return(View(aircraft));
}
_service.UpdateAircraft(aircraft);
return(RedirectToAction("List", new { parentId = aircraft.UnitId }));
}
public IActionResult Post(AircraftViewModel airplane)
{
try
{
var _result = _service.Create(airplane);
return(Created(string.Empty, _result));
}
catch (Exception ex)
{
throw;
}
}
public IActionResult Put(string id, [FromBody] AircraftViewModel airplane)
{
try
{
_service.Update(id, airplane);
return(Ok());
}
catch (Exception)
{
throw;
}
}
public virtual ActionResult EditAircraft(Guid id, AircraftViewModel aircraftViewModel)
{
var aircraft = Repository.Get <AircraftMDS>(id);
this.Validate(aircraftViewModel, string.Empty);
if (!ModelState.IsValid)
{
var viewModel = Mapper.Map <AircraftMDS, AircraftViewModel>(aircraft);
return(View(Views.EditAircraft, viewModel));
}
Mapper.Map <AircraftViewModel, AircraftMDS>(aircraftViewModel, aircraft);
return(RedirectToAction(MVC.FlightPrograms.Manage()));
}
public IActionResult List(int?selectId)
{
_logger.LogDebug(string.Concat("List aircraft", selectId.HasValue ? $" (, {selectId} is selected" : string.Empty));
var viewModel = new AircraftViewModel {
ExistingAircraft = _aircraftRepository.GetAllAircraft()
};
if (selectId.HasValue)
{
var editedAircraft = _aircraftRepository.GetAircraftById(selectId.Value);
viewModel.SelectedAircraft = editedAircraft;
}
return(View("Aircraft", viewModel));
}
public IActionResult Submit(AircraftViewModel parameter)
{
_logger.LogDebug("Submiting aircraft");
if (_aircraftRepository.GetAircraftById(parameter.SelectedAircraft.Id) != null)
{
_logger.LogDebug("Aircraft Id already exist");
_aircraftRepository.UpdateAircraft(parameter.SelectedAircraft);
}
else
{
_aircraftRepository.CreateAircraft(parameter.SelectedAircraft);
}
return(new RedirectToActionResult("List", "Aircraft", null));
}
public static Aircraft ToEntity(this AircraftViewModel model)
{
if (model == null)
{
return(null);
}
Aircraft entity = new Aircraft
{
Id = model.Id,
ProducerName = model.ProducerName,
ProducerNameEn = model.ProducerNameEn,
ProducerCountryCode = model.ProducerCountryCode,
ProducerCountryName = model.ProducerCountryName,
AirCategoryCode = model.AirCategoryCode,
AirCategoryName = model.AirCategoryName,
Icao = model.Icao,
MsnserialNumber = model.MsnserialNumber,
ModelName = model.ModelName,
ModelNameEn = model.ModelNameEn,
};
if (model.Debts != null && model.Debts.Any())
{
entity.AircraftDebt = model.Debts
.Select(x => x.ToEntity()).ToList();
}
if (model.Registrations != null && model.Registrations.Any())
{
entity.AircraftRegistration = model.Registrations
.Select(x => x.ToEntity()).ToList();
}
entity.AircraftExtension = new AircraftExtension
{
AircraftId = entity.Id,
UpdatedAt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc),
RequestId = model.ExtensionRequestId,
Deactivated = false
};
return(entity);
}
public string Create(AircraftViewModel model)
{
string msg = string.Empty;
try
{
var ctr = _context.AsQueryable <AircraftType>().Where(x => x.Name == model.Name).Count();
if (ctr > 0)
{
msg = "Aircraft already exists.";
}
else
{
AircraftType aircraft = new AircraftType()
{
Name = model.Name,
Description = model.Description,
DateCreated = DateTime.Now,
DateModified = DateTime.Now
};
_context.Add <AircraftType>(aircraft);
_context.SaveChanges();
msg = "Aircraft added.";
}
}
catch (Exception ex)
{
LogsViewModel error = new LogsViewModel()
{
ActionType = ActionType.Error.ToString(),
Description = ex.Message + "\n" + ex.StackTrace,
ModifiedBy = "Aircraft Service Error : Create()",
DateModified = DateTime.Now.ToString("MM/dd/yyyy HH:mm")
};
new LogsService().Create(error);
msg = "Unexpected error encountered. Please contact your system administrator.";
}
return(msg);
}
public IActionResult Delete(AircraftViewModel aircraft)
{
_service.DeleteAircraft(aircraft.Id);
return(RedirectToAction("List", new { parentId = aircraft.UnitId }));
}
public ActionResult Index()
{
AircraftViewModel model = new AircraftViewModel();
return(View(model));
}
public AircraftView()
{
AircraftViewModel = new AircraftViewModel();
this.InitializeComponent();
}
private List <object> GetPropertyViewModelsFromResponse(Shared.Enums.PropertyType propertyType, PropertySearchResultModel result, PropertySearchRequestModel searchModel)
{
if (result == null || result.ResponseObject == null)
{
return(null);
}
List <object> entities = null;
switch (propertyType)
{
case Shared.Enums.PropertyType.AIRCRAFT:
AircraftsResponse aircraftsResponse = result.ResponseObject as AircraftsResponse;
if (aircraftsResponse == null)
{
throw new Exception("Could not convert response to AircraftsResponse");
}
if (aircraftsResponse.Aircraft != null && aircraftsResponse.Aircraft.Length > 0)
{
//List<AircraftViewModel> aircrafts = SaveAircrafts(aircraftsResponse, result.RequestId, searchModel);
List <AircraftViewModel> aircrafts = new List <AircraftViewModel>();
for (int i = 0; i < aircraftsResponse.Aircraft.Length; i++)
{
AircraftViewModel airViewModel = aircraftsResponse.Aircraft[i].ToViewModel();
airViewModel.ExtensionRequestId = result.RequestId;
if (regixCertificateSettings.SaveEntityWithSearchedIdentifier && searchModel.IdentifierTypeCode == "MSN")
{
airViewModel.MsnserialNumber = searchModel.Identifier;
}
aircrafts.Add(airViewModel);
}
entities = (aircrafts).Cast <object>().ToList();
}
break;
case Shared.Enums.PropertyType.VEHICLE:
if (regixCertificateSettings.UseVehicleV3)
{
GetMotorVehicleRegistrationInfoV3Response vehiclesResponse = result.ResponseObject as GetMotorVehicleRegistrationInfoV3Response;
if (vehiclesResponse == null)
{
throw new Exception("Could not convert response to GetMotorVehicleRegistrationInfoV3Response");
}
if (vehiclesResponse.Response != null &&
vehiclesResponse.Response.Results.Length > 0 &&
vehiclesResponse.Response.Results[0].VehicleData != null)
{
List <VehicleViewModel> vehicles = new List <VehicleViewModel>();
VehicleViewModel vehicleViewModel = vehiclesResponse.Response.Results[0].ToViewModel();
vehicleViewModel.ExtensionRequestId = result.RequestId;
if (regixCertificateSettings.SaveEntityWithSearchedIdentifier)
{
vehicleViewModel.RegistrationNumber = searchModel.Identifier;
}
vehicles.Add(vehicleViewModel);
entities = (vehicles).Cast <object>().ToList();
}
}
else
{
MotorVehicleRegistrationResponse vehiclesResponse = result.ResponseObject as MotorVehicleRegistrationResponse;
if (vehiclesResponse == null)
{
throw new Exception("Could not convert response to MotorVehicleRegistrationResponse");
}
if (vehiclesResponse.Vehicles != null && vehiclesResponse.Vehicles.Length > 0)
{
//List<Data.Vehicle> vehicles = await SaveVehicles(vehiclesResponse, result.RequestId, searchModel, useSearchIdentifier);
List <VehicleViewModel> vehicles = new List <VehicleViewModel>();
foreach (RegiX.Client.ResponseModels.Vehicle vehicle in vehiclesResponse.Vehicles)
{
VehicleViewModel vehicleViewModel = vehicle.ToViewModel();
vehicleViewModel.ExtensionRequestId = result.RequestId;
if (regixCertificateSettings.SaveEntityWithSearchedIdentifier)
{
vehicleViewModel.RegistrationNumber = searchModel.Identifier;
}
vehicles.Add(vehicleViewModel);
}
entities = (vehicles).Cast <object>().ToList();
}
}
break;
case Shared.Enums.PropertyType.VESSEL:
RegistrationInfoByOwnerResponse vesselResponse = result.ResponseObject as RegistrationInfoByOwnerResponse;
if (vesselResponse == null)
{
throw new Exception("Could not convert response to RegistrationInfoByOwnerResponse");
}
if (vesselResponse.VesselInfo != null)
{
VesselViewModel vesselViewModel = vesselResponse.VesselInfo.ToViewModel();
vesselViewModel.ExtensionRequestId = result.RequestId;
vesselViewModel = SetVesselStatusInModel(vesselViewModel);
entities = new List <object>();
entities.Add(vesselViewModel);
}
break;
case Shared.Enums.PropertyType.AGRIFORMACHINERY:
AgriculturalMachineryCollectionModel machines = result.ResponseObject as AgriculturalMachineryCollectionModel;
entities = (machines.Machines).Cast <object>().ToList();
break;
default:
break;
}
return(entities);
}
public AircraftView()
{
DataContext = new AircraftViewModel();
InitializeComponent();
}
public AircraftView()
{
this.InitializeComponent();
ViewModel = new AircraftViewModel();
this.DataContext = new Aircraft();
}
