public IActionResult Type(string id, [FromQuery] bool?includeRetire, AircraftModel model)
{
id = id?.ToUpper();
string typeName;
typeName = _context.Type.AsNoTracking().FirstOrDefault(p => p.TypeCode == id)?.TypeName;
model.Title = typeName ?? "all";
model.TableId = id ?? "all";
model.api = "/api/type/" + id;
//全機退役かどうか確認
int operatingCount = _context.AircraftView.AsNoTracking().Where(p => p.TypeCode == id && p.OperationCode != OperationCode.RETIRE_UNREGISTERED).Count();
if (operatingCount == 0 && !includeRetire.HasValue)
{
//全機退役済みなら強制的に退役済みを表示
model.IncludeRetire = true;
model.IsAllRetire = true;
}
else
{
model.IncludeRetire = includeRetire.HasValue ? includeRetire.Value : false;
}
model.IsAdmin = CookieUtil.IsAdmin(HttpContext);
return(View("~/Views/Aircraft/index.cshtml", model));
}
public async Task TestCreateAircraft()
{
// Arrange
string testId = "1100";
Flight flight = GetTestFlights().FirstOrDefault(p => p.Id == testId);
Aircraft aircraft = GetTestAircrafts().FirstOrDefault(p => p.Id == testId);
FlightModel flightmodel = GetTestFlightsModels().FirstOrDefault(p => p.Id == testId);
AircraftModel aircraftmodel = GetTestAircraftsModels().FirstOrDefault(p => p.Id == testId);
var mockRepoAircraft = new Mock <IAircraftRepository>();
var mockRepoFlight = new Mock <IFlightRepository>();
mockRepoFlight.Setup(c => c.Add(flight));
mockRepoAircraft.Setup(c => c.Add(aircraft));
var controller = new AircraftController(mockRepoAircraft.Object);
// Act
var result = controller.Post(aircraftmodel);
// Assert
var actionResult = Assert.IsType <OkResult>(result);
var model = Assert.IsType <OkResult>(actionResult);
}
public PartialViewResult saveEditedAircraft([FromBody] AircraftModel Model)
{
Model.AircraftModelID = AircraftModelModel.AircraftModelID;
var test = AircraftModelModel.AircrafModels.Single(r => r.AircraftModelID == AircraftModelModel.AircraftModelID);
int index = AircraftModelModel.AircrafModels.IndexOf(test);
AircraftModelModel.AircrafModels[index] = Model;
AircraftModelModel.AircraftModelID = Model.AircraftModelID;
AircraftModelModel.Name = Model.ModelName;
AircraftModelModel.Manufacturer = Model.Manufacturer;
AircraftModelModel.EngineType = Model.EngineType;
AircraftModelModel.Description = Model.Description;
AircraftModelModel.AdditionalData = Model.AdditionalData;
AircraftModelModel.ImagePath = Model.ImagePath;
AircraftModelModel.Category = Model.Category;
try
{
string aircraftData = JsonConvert.SerializeObject(Model);
this.PutAsync("http://localhost:8961/api/Aircraftmodel/", aircraftData);
// AircraftModelModel.MaintenanceOrders.Add(Model);
// maintenanceViewModel.MaintenanceOrders[index] = Model;
}
catch (AggregateException e)
{
}
return(PartialView("_AircraftModel", AircraftModelModel));
}
public static AccessoryDescriptionDTO Convert(this AircraftModel aircraftModel)
{
return(new AccessoryDescriptionDTO
{
ItemId = aircraftModel.ItemId,
IsDeleted = aircraftModel.IsDeleted,
Updated = aircraftModel.Updated,
CorrectorId = aircraftModel.CorrectorId,
Model = aircraftModel.Name,
PartNumber = aircraftModel.PartNumber,
AltPartNumber = aircraftModel.AltPartNumber,
AtaChapterId = aircraftModel.ATAChapter?.ItemId,
GoodStandart = aircraftModel.Standart?.Convert(),
Description = aircraftModel.Description,
StandartId = aircraftModel.Standart?.ItemId,
Manufacturer = aircraftModel.Manufacturer,
CostNew = aircraftModel.CostNew,
CostOverhaul = aircraftModel.CostOverhaul,
CostServiceable = aircraftModel.CostServiceable,
Measure = aircraftModel.Measure?.ItemId,
Remarks = aircraftModel.Remarks,
ModelingObjectTypeId = aircraftModel.ModelingObjectType?.ItemId ?? -1,
ModelingObjectSubTypeId = aircraftModel.ManufactureReg?.ItemId,
SubModel = aircraftModel.Series,
FullName = aircraftModel.FullName,
ShortName = aircraftModel.ShortName,
Designer = aircraftModel.Designer,
Code = aircraftModel.Code,
ComponentClass = (short?)aircraftModel.GoodsClass?.ItemId,
IsDangerous = aircraftModel.IsDangerous,
SupplierRelations = aircraftModel.SupplierRelations?.Select(i => i.Convert()) as ICollection <KitSuppliersRelationDTO>,
});
}
/// <summary>
/// Конструктор создает объект типа директивы
/// </summary>
/// <param name="categoryType"></param>
/// <param name="categoryName"></param>
/// <param name="aircraftModel"></param>
public TemplateLLPLifeLimitCategory(String categoryType, String categoryName, AircraftModel aircraftModel)
: this()
{
CategoryType = categoryType;
CategoryName = categoryName;
AircraftModel = aircraftModel;
}
public PartialViewResult SaveNewAircraft([FromBody] AircraftModel Model)
{
int finalIndex = (AircraftModelModel.AircrafModels.Count) - 1;
if (finalIndex < 0)
{
Model.AircraftModelID = 1;
}
else
{
Model.AircraftModelID = AircraftModelModel.AircrafModels[finalIndex].AircraftModelID + 1;
}
try
{
string aircraftData = JsonConvert.SerializeObject(Model);
this.PostAsync("http://localhost:8961/api/Aircraftmodel/", aircraftData);
AircraftModelModel.AircrafModels.Add(Model);
}
catch (AggregateException e)
{
}
return(PartialView("_AircraftModel", AircraftModelModel));
}
public void Should_Compute_Flight_Detail()
{
var departureAirport = new AirportModel
{
Name = "CDG",
Latitude = 49.009719,
Longitude = 2.547667,
};
var arrivalAirport = new AirportModel
{
Name = "Jönköpings Flygplats",
Latitude = 57.750359,
Longitude = 14.070648,
};
var aircraft = new AircraftModel
{
ConsumptionPerKm = 50,
TakeOffEffort = 100,
};
var detail = FlightDetailManager.GetFlightDetail(departureAirport, arrivalAirport, aircraft);
Assert.Equal(1234.03, Math.Round(detail.DistanceInKm, 2));
Assert.Equal(61801.68, Math.Round(detail.FuelNeeded, 2));
}
public List <ReportItem> GenerateReportAircraftInEurope()
{
List <Aircraft> lektuvai = _aircraftRepository.Retrieve();
List <ReportItem> ataskaita = new List <ReportItem>();
foreach (var vienasLektuvas in lektuvai)
{
Company lektuvoKompanija = _companyRepository.Retrieve(vienasLektuvas.CompanyId);
Country lektuvoSalis = _countryRepository.Retrieve(lektuvoKompanija.CountryId);
AircraftModel lektuvoModelis = _aircraftModelRepository.Retrieve(vienasLektuvas.ModelId);
if (lektuvoSalis.Continent == "Europe")
{
ReportItem eilute = new ReportItem();
eilute.AircraftTailNumber = vienasLektuvas.TailNumber;
eilute.ModelNumber = lektuvoModelis.Number;
eilute.ModelDescription = lektuvoModelis.Description;
eilute.OwnerCompanyName = lektuvoKompanija.Name;
eilute.CompanyCountryCode = lektuvoSalis.Code;
eilute.CompanyCountryName = lektuvoSalis.Name;
eilute.BelongsToEU = lektuvoSalis.BelongsToEU;
ataskaita.Add(eilute);
}
}
return(ataskaita);
}
public List <ReportItem> GenerateReportAircraftInEurope()
{
List <ReportItem> ataskaita = new List <ReportItem>();
var lektuvuSarasas = _aircraftRepository.Retrieve();
if (lektuvuSarasas.Count() > 0)
{
foreach (var lektuvas in lektuvuSarasas)
{
Company lektuvuKompanija = _companyRepository.Retrieve(lektuvas.CompanyId);
Country lektuvoSalis = _countryRepository.Retrieve(lektuvuKompanija.CountryId);
AircraftModel modelis = _aircraftModelRepository.Retrieve(lektuvas.ModelId);
if (lektuvoSalis.Continent == "Europe")
{
ReportItem reportItem = new ReportItem();
reportItem.AircraftTailNumber = lektuvas.TailNumber;
reportItem.ModelNumber = modelis.Number;
reportItem.ModelDescription = modelis.Description;
reportItem.OwnerCompanyName = lektuvuKompanija.Name;
reportItem.CompanyCountryCode = lektuvoSalis.Code;
reportItem.CompanyCountryName = lektuvoSalis.Name;
reportItem.BelongsToEU = lektuvoSalis.BelongsToEU;
ataskaita.Add(reportItem);
}
}
return(ataskaita);
}
else
{
return(null);
}
}
public static void SeedAircraftModels(FlightTrackContext context)
{
var crafts = new AircraftModel[]
{
new AircraftModel
{
Id = Guid.NewGuid(),
Name = "PA44-180"
},
new AircraftModel
{
Id = Guid.NewGuid(),
Name = "PA28R-201"
},
new AircraftModel
{
Id = Guid.NewGuid(),
Name = "PA28-161"
}
};
foreach (AircraftModel m in crafts)
{
context.AircraftModels.Add(m);
}
context.SaveChanges();
}
/// <summary>
/// Конструктор создает объект типа директивы
/// </summary>
/// <param name="itemId"></param>
/// <param name="categoryName"></param>
/// <param name="aircraftModel"></param>
/// <param name="threshold"></param>
public TemplateDefferedCategory(Int32 itemId, String categoryName, AircraftModel aircraftModel, DirectiveThreshold threshold)
{
IsDeleted = false;
ItemId = itemId;
CategoryName = categoryName;
AircraftModel = aircraftModel;
Threshold = threshold;
}
public async Task <AircraftModel> CreateAircraftAsync(AircraftModel model)
{
var modelEntity = Mapper.Map <Aircraft>(model);
var newAircraft = await _repository.AddAsync(modelEntity);
return(Mapper.Map <AircraftModel>(newAircraft));
}
/// <summary>
/// Конструктор создает объект типа директивы
/// </summary>
/// <param name="itemId"></param>
/// <param name="chartName"></param>
/// <param name="aircraftModel"></param>
/// <param name="fileId"></param>
public TemplateDamageChart(Int32 itemId, String chartName, AircraftModel aircraftModel, int fileId)
{
IsDeleted = false;
ItemId = itemId;
ChartName = chartName;
AircraftModel = aircraftModel;
FileId = fileId;
}
public ActionResult Details(Guid id)
{
var aircraftReadModel = DocumentSession.Load <AircraftReadModel>(id);
var model = new AircraftModel(aircraftReadModel);
return(View("Details", model));
}
private static LookupItem GetAircraftLookup(AircraftModel aircraft)
{
LookupItem myItem = new LookupItem();
myItem.Value = aircraft.AircraftModelId;
myItem.Label = aircraft.AircraftModelName;
return(myItem);
}
/// <summary>
/// Создает связь с определенной моделью
/// </summary>
public FlightNumberAircraftModelRelation(AircraftModel aircraftModel) : this()
{
if (aircraftModel == null)
{
throw new ArgumentNullException("aircraftModel", "must be not null");
}
AircraftModel = aircraftModel;
}
public IHttpActionResult Post(AircraftModel aircraftmodel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
aircraftModelLogic.Insert(aircraftmodel);
return(CreatedAtRoute("DefaultApi", new { id = aircraftmodel.AircraftModelID }, aircraftmodel));
}
public async Task <ActionResult> CreateAircraft([FromBody] AircraftModel airCraftViewModel)
{
var result = await mediator.Send(new CreateAircraftCommand()
{
aircraftViewModel = airCraftViewModel
});
return(Ok(result));
}
public async Task <IHttpActionResult> Create(AircraftModel aircraft)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
AircraftModelRepo.Insert(aircraft);
return(CreatedAtRoute("DefaultApi", new { id = aircraft.AircraftModelID }, aircraft));
}
public IActionResult Index(AircraftModel model)
{
model.Title = "all";
model.TableId = "all";
model.api = "/api/airlinegroup/";
model.IsAdmin = CookieUtil.IsAdmin(HttpContext);
return(View("~/Views/Aircraft/index.cshtml", model));
}
// GET: api/AircraftModel/5
public async Task <IHttpActionResult> AircraftModelByID(AircraftModel AircraftModelID)
{
var item = aircraftmodel.Find(AircraftModelID);
if (item == null)
{
return(NotFound());
}
return(Ok(item));
}
public ActionResult Post([FromBody] AircraftModel model)
{
var aircraft = new Aircraft
{
Name = model.Name,
NumberOfSeats = model.NumberOfSeats
};
aircraftRepository.Add(aircraft);
return(Ok());
}
/// <summary>
/// Конструктор создает объект с параметрами по умолчанию
/// </summary>
public TemplateDamageChart()
{
IsDeleted = false;
ItemId = -1;
ChartName = "";
AircraftModel = new AircraftModel {
ItemId = -1
};
FileId = -1;
AttachedFile = null;
}
/// <summary>
/// Конструктор создает объект с параметрами по умолчанию
/// </summary>
public TemplateLLPLifeLimitCategory()
{
SmartCoreObjectType = SmartCoreType.Unknown;
IsDeleted = false;
ItemId = -1;
CategoryName = "";
AircraftModel = new AircraftModel {
ItemId = -1
};
}
public async Task <IHttpActionResult> EngineTypeDelete(AircraftModel aircraft)
{
if (aircraft == null)
{
return(NotFound());
}
AircraftModelRepo.DeleteOne(aircraft);
// EngineRepo.DeleteOne(enginetype);
return(Ok(aircraft));
}
public async Task <IHttpActionResult> EditAircraft(AircraftModel model)
{
try
{
var result = await _aircraftManager.EditAircraftAsync(model);
return(Ok(result));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public AircraftModel Post(AircraftPostOptions options)
{
var model = new AircraftModel
{
Number = options.Number,
ConsumptionPerKm = options.ConsumptionPerKm,
TakeOffEffort = options.TakeOffEffort,
};
Context.Aircrafts.Add(model);
return(model);
}
public IHttpActionResult Put([FromBody] AircraftModel aircraft)
{
if (aircraft.Equals(0))
{
return(BadRequest());
}
else if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
aircraftModelLogic.UpdateOne(aircraft);
return(StatusCode(HttpStatusCode.NoContent));
}
/// <summary>
/// Конструктор создает объект с параметрами по умолчанию
/// </summary>
public TemplateDefferedCategory()
{
IsDeleted = false;
ItemId = -1;
CategoryName = "";
AircraftModel = new AircraftModel {
ItemId = -1
};
Threshold = new DirectiveThreshold {
FirstPerformanceConditionType = ThresholdConditionType.WhicheverFirst,
FirstPerformanceSinceEffectiveDate = Lifelength.Null, PerformSinceNew = true, PerformSinceEffectiveDate = true
};
}
public AircraftModel GetAircraftModel(int id)
{
AircraftModel aircraftModel = store.GetModel(id);
if (aircraftModel == null)
{
commandLine.Write($"Model with id {id} was not found.");
return(null);
}
else
{
return(aircraftModel);
}
}
