public JsonResult Post([FromBody] VesselViewModel vm)
{
try
{
if (ModelState.IsValid)
{
var newVessel = vm.ToEntity();
_logger.LogInformation("Attempting to save a new Vessel");
_repository.Add(newVessel);
_unitOfWork.Commit();
Response.StatusCode = (int)HttpStatusCode.Created;
return(Json(VesselViewModel.FromEntity(newVessel)));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save Vessel", ex);
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json("Failed to save Vessel"));
}
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json(new { Message = "Failed", ModelState = ModelState }));
}
public void CreateVessel(VesselViewModel vessel)
{
var vesselInsert = Mapper.Map <VesselViewModel, Vessel_M>(vessel);
_vesselRepository.Add(vesselInsert);
SaveVessel();
}
public JsonResult GetVesselList()
{
return(ExecuteFunctionRun(() =>
{
System.Data.DataTable table = this.Connection.GetVesselConfigTable();
List <VesselViewModel> list = new List <VesselViewModel>();
if (table != null)
{
foreach (DataRow row in table.Rows)
{
int port = int.Parse(row[OThinker.Clusterware.VesselConfig.PropertyName_Port] + string.Empty);
int loadWeight = int.Parse(row[OThinker.Clusterware.VesselConfig.PropertyName_LoadWeight] + string.Empty);
int masterOrder = int.Parse(row[OThinker.Clusterware.VesselConfig.PropertyName_MasterOrder] + string.Empty);
string currentState = (row[OThinker.Clusterware.VesselConfig.ColumnName_CurrentState] + string.Empty == "1") ? "运行状态" : "挂起状态";
VesselViewModel model = new VesselViewModel()
{
Code = row[OThinker.Clusterware.VesselConfig.PropertyName_Code] + string.Empty,
Address = row[OThinker.Clusterware.VesselConfig.PropertyName_Address] + string.Empty,
Port = port,
LoadWeight = loadWeight,
Order = masterOrder,
CurrentState = currentState
};
list.Add(model);
}
}
return Json(CreateLigerUIGridData(list.OrderBy(s => s.Order).ToArray()), JsonRequestBehavior.AllowGet);
}));
}
public ActionResult Edit(VesselViewModel viewModel)
{
var req = viewModel.MapTo <SaveVesselRequest>();
_vesselService.SaveVessel(req);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> AddVessel(VesselViewModel model)
{
if (ModelState.IsValid)
{
var path = string.Empty;
if (model.ImageFile != null)
{
path = await _imageHelper.UpLoadImageAsync(model.ImageFile);
}
var vesselimg = new Vessel
{
Vessel_Name = model.Vessel_Name,
ImageUrl = path,
Voys = new List <Voy>(),
VesselType = await _datacontext.VesselTypes.FindAsync(model.VesselTypeId),
};
_datacontext.Vessels.Add(vesselimg);
await _datacontext.SaveChangesAsync();
return(RedirectToAction($"Index"));
}
model.VesselTypes = _combosHelper.GetComboVesselType();
return(View(model));
}
public void UpdateVessel(VesselViewModel Vessel)
{
var vesselToRemove = _vesselRepository.GetById(Vessel.VesselC);
var updateVessel = Mapper.Map <VesselViewModel, Vessel_M>(Vessel);
_vesselRepository.Delete(vesselToRemove);
_vesselRepository.Add(updateVessel);
SaveVessel();
}
public IActionResult AddVessel()
{
var model = new VesselViewModel
{
VesselTypes = _combosHelper.GetComboVesselType(),
};
return(View(model));
}
/// <summary>
/// convert vessel view model to domain
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public Vessel ConvertToDomain(VesselViewModel model)
{
Vessel vessel = new Vessel();
vessel.VesselId = model.VesselId;
vessel.Name = model.VesselName;
vessel.IsActive = model.IsActive;
return(vessel);
}
/// <summary>
/// convert vessel to view model
/// </summary>
/// <param name="vessel"></param>
/// <returns></returns>
public VesselViewModel ConvertToView(Vessel vessel)
{
VesselViewModel model = new VesselViewModel();
model.VesselId = vessel.VesselId;
model.VesselName = (!string.IsNullOrEmpty(vessel.Name)) ? vessel.Name : "N/A";
model.IsActive = vessel.IsActive;
return(model);
}
public ActionResult Transaction(string id, VesselViewModel dataVW)
{
VesselModel data = dataVW.Vessel;
RequestResult <VesselModel> result = new RequestResult <VesselModel>()
{
Status = Status.Success, Data = data
};
VesselServices vesselServices = new VesselServices();
try
{
if (!ModelState.IsValid)
{
result = new RequestResult <VesselModel>()
{
Status = Status.Error, Message = localResource.ErrorOnSave
}
}
;
else
{
if (id == "add")
{
if (Request.Files.Count > 0)
{
var File = Request.Files[0];
data.Image.FileName = File.FileName;
data.Image.ContentType = File.ContentType;
data.Image.FileContent = File.InputStream;
}
data.UserModifiedId = SessionWeb.User.UserId;
result = vesselServices.InsUpdComplete(
dataVW.Vessel, dataVW.VesselSpecificInfo, dataVW.SpecificInfo, dataVW.VesselCost);
result.Data.Image.FileContent = null;
if (result.Status != Status.Success)
{
throw new Exception(string.Format("{0}: {1}", globalResources.SomethingWrong, result.Message));
}
return(Json(result));
}
}
}
catch (Exception ex)
{
Elmah.ErrorSignal.FromCurrentContext().Raise(ex);
Response.StatusCode = (int)HttpStatusCode.BadRequest;
Response.StatusDescription = ex.Message;
return(Json(ex.Message, JsonRequestBehavior.AllowGet));
}
return(Json(result));
}
public async Task <Vessel> ToVesselAsync(VesselViewModel model, string path, bool isNew)
{
return(new Vessel
{
Vessel_Name = model.Vessel_Name,
ImageUrl = path,
Voys = isNew ? new List <Voy>() : model.Voys,
Id = isNew ? 0 : model.Id,
VesselType = await _dataContext.VesselTypes.FindAsync(model.VesselTypeId),
});
}
public async Task <Data.Vessel> AddOrUpdateVesselAsync(VesselViewModel model)
{
if (model == null)
{
throw new NullReferenceException("VesselViewModel is null");
}
Data.Vessel entity = null;
var existing = new List <Data.Vessel>();
// няма търсене по уникален номер на кораб в Regix
//string identifier = model.RegistrationData != null ? model.RegistrationData.RegistrationNumber : "";
//var existing = await _context.Vessel
// .Include(x => x.VesselEngine)
// .Include(x => x.VesselOwner)
// .Include(x => x.VesselRegistrationData)
// .Include(x => x.VesselRegistrationData).ThenInclude(x => x.StatusNavigation)
// .Where(x => x.VesselRegistrationData.Any() &&
// x.VesselRegistrationData.Where(a => a.RegistrationNumber.ToLower() == identifier.ToLower()).Any() &&
// x.VesselExtension != null &&
// x.VesselExtension.Deactivated == false)
// .ToListAsync();
if (!existing.Any())
{
entity = model.ToEntity();
entity.Id = 0;
entity.VesselExtension.VesselId = entity.Id;
await _context.Vessel.AddAsync(entity);
}
else
{
foreach (Data.Vessel item in existing)
{
item.VesselExtension.Deactivated = true;
_context.VesselEngine.RemoveRange(item.VesselEngine);
_context.VesselOwner.RemoveRange(item.VesselOwner);
_context.VesselRegistrationData.RemoveRange(item.VesselRegistrationData);
}
existing[0].UpdateEntity(model);
existing[0].VesselExtension.Deactivated = false;
existing[0].VesselExtension.UpdatedAt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc);
existing[0].VesselExtension.RequestId = model.ExtensionRequestId;
_context.Vessel.Update(existing[0]);
entity = existing[0];
}
await _context.SaveChangesAsync();
return(entity);
}
public static Vessel ToEntity(this VesselViewModel model)
{
if (model == null)
{
return(null);
}
Vessel entity = new Vessel
{
Id = model.Id,
Bt = model.Bt,
Nt = model.Nt,
MaxLength = model.MaxLength,
LengthBetweenPerpendiculars = model.LengthBetweenPerpendiculars,
MaxWidth = model.MaxWidth,
Waterplane = model.Waterplane,
ShipboardHeight = model.ShipboardHeight,
Deadweight = model.Deadweight,
NumberOfEngines = model.NumberOfEngines,
EnginesFuel = model.EnginesFuel,
SumEnginePower = model.SumEnginePower,
BodyNumber = model.BodyNumber
};
if (model.Engines != null && model.Engines.Any())
{
entity.VesselEngine = model.Engines
.Select(x => x.ToEntity()).ToList();
}
if (model.Owners != null && model.Owners.Any())
{
entity.VesselOwner = model.Owners
.Select(x => x.ToEntity()).ToList();
}
if (model.RegistrationData != null)
{
entity.VesselRegistrationData = new List <VesselRegistrationData>();
entity.VesselRegistrationData.Add(model.RegistrationData.ToEntity());
}
entity.VesselExtension = new VesselExtension
{
VesselId = entity.Id,
UpdatedAt = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Utc),
RequestId = model.ExtensionRequestId,
Deactivated = false
};
return(entity);
}
private VesselViewModel SetVesselStatusInModel(VesselViewModel vessel)
{
VesselStatus status = _context.VesselStatus
.Where(x => x.Code == vessel.RegistrationData.Status)
.FirstOrDefault();
if (status != null)
{
vessel.RegistrationData.StatusName = status.Name;
vessel.RegistrationData.StatusNameEn = status.NameEn;
}
return(vessel);
}
public ActionResult Edit(int Id)
{
CountryServices countryServices = new CountryServices();
ProjectTypeServices projectTypeServices = new ProjectTypeServices();
ClasificationSocietyServices clasificationSocietyServices = new ClasificationSocietyServices();
PortServices portServices = new PortServices();
RegionServices regionServices = new RegionServices();
VesselTypeServices vesselTypeServices = new VesselTypeServices();
VesselServices vesselServices = new VesselServices();
VesselViewModel model = new VesselViewModel();
//Desencriptamos y validamos permisos y existencia
VesselModel vessel = vesselServices.GetFirst(new VesselModel()
{
VesselId = Id
});
if (vessel == null || vessel.Company.CompanyId != SessionWeb.User.CompanyId)
{
return(RedirectToAction("Unauthorized", "Redirect"));
}
model.Vessel = vessel;
model.VesselSpecificInfo = vesselServices.GetSpecificInfo(Id);
model.SpecificInfo = vesselServices.GetSpecificInfoExtra(Id);
model.VesselCost = vesselServices.GetCost(Id);
ViewBag.LstCountry = countryServices.GetSelect(globalResources.Select).Select(x => new SelectListItem {
Value = x.Value, Text = x.Text
});
ViewBag.LstProjectType = projectTypeServices.GetSelect(null).Select(x => new SelectListItem {
Value = x.Value, Text = x.Text
});
ViewBag.LstVesselType = vesselTypeServices.GetSelect(globalResources.Select).Select(x => new SelectListItem {
Value = x.Value, Text = x.Text
});
ViewBag.LstClasificationSociety = clasificationSocietyServices.GetSelect(globalResources.Select).Select(x => new SelectListItem {
Value = x.Value, Text = x.Text
});
ViewBag.LstPort = portServices.GetSelect(globalResources.Select).Select(x => new SelectListItem {
Value = x.Value, Text = x.Text
});
ViewBag.LstRegion = regionServices.GetSelect(globalResources.Select).Select(x => new SelectListItem {
Value = x.Value, Text = x.Text
});
return(View("Create", model));
}
//
// GET: /Vessel/Create
public ActionResult Create()
{
var viewModel = new VesselViewModel();
viewModel.Measurements = _measurementService.GetMeasurements(new GetMeasurementsRequest {
Take = -1,
SortingDictionary = new Dictionary <string, SortOrder> {
{ "Name", SortOrder.Ascending }
}
}).Measurements
.Select(x => new SelectListItem {
Value = x.Id.ToString(), Text = x.Name
}).ToList();
return(View(viewModel));
}
public ActionResult AddVessel(VesselViewModel viewModel)
{
if (ModelState.IsValid)
{
var req = viewModel.MapTo <SaveVesselRequest>();
var resp = _vesselService.SaveVessel(req);
return(Json(resp));
}
else
{
var errorList = (from item in ModelState
where item.Value.Errors.Any()
select item.Value.Errors[0].ErrorMessage).ToList();
return(Json(new { IsSuccess = false, Message = errorList }));
}
}
public static void UpdateEntity(this Data.Vessel entity, VesselViewModel model)
{
if (model == null || entity == null)
{
return;
}
entity.Id = model.Id;
entity.Bt = model.Bt;
entity.Nt = model.Nt;
entity.MaxLength = model.MaxLength;
entity.LengthBetweenPerpendiculars = model.LengthBetweenPerpendiculars;
entity.MaxWidth = model.MaxWidth;
entity.Waterplane = model.Waterplane;
entity.ShipboardHeight = model.ShipboardHeight;
entity.Deadweight = model.Deadweight;
entity.NumberOfEngines = model.NumberOfEngines;
entity.EnginesFuel = model.EnginesFuel;
entity.SumEnginePower = model.SumEnginePower;
entity.BodyNumber = model.BodyNumber;
entity.VesselEngine = new List <VesselEngine>();
if (model.Engines != null && model.Engines.Any())
{
entity.VesselEngine = model.Engines
.Select(x => x.ToEntity()).ToList();
}
entity.VesselOwner = new List <VesselOwner>();
if (model.Owners != null && model.Owners.Any())
{
entity.VesselOwner = model.Owners
.Select(x => x.ToEntity()).ToList();
}
entity.VesselRegistrationData = new List <VesselRegistrationData>();
if (model.RegistrationData != null)
{
entity.VesselRegistrationData.Add(model.RegistrationData.ToEntity());
}
return;
}
public override JsonResult Get(int id)
{
try
{
var Ve = _repository.GetSingle(id);
var VeVm = VesselViewModel.FromEntity(Ve);
if (VeVm == null)
{
return(Json(null));
}
return(Json(VeVm));
}
catch (Exception ex)
{
_logger.LogError($"Failed to get Vessel", ex);
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json("Failed to get Vessel"));
}
}
public JsonResult SaveVessel(VesselViewModel model)
{
return(ExecuteFunctionRun(() => {
ActionResult result = new ActionResult(true);
if (string.IsNullOrEmpty(model.Code))
{
result.Success = false;
result.Message = "服务编码不可为空!";
}
else if (string.IsNullOrEmpty(model.Address))
{
result.Success = false;
result.Message = "服务器IP不可为空!";
}
if (!result.Success)
{
return Json(result, JsonRequestBehavior.AllowGet);
}
// TODO:待判定是否重复
OThinker.Clusterware.VesselConfig config = new Clusterware.VesselConfig()
{
Address = model.Address,
Code = model.Code,
Description = model.Description,
LoadWeight = model.LoadWeight,
MasterOrder = model.Order,
ObjectUri = Configs.ProductInfo.EngineUri,
Port = model.Port
};
if (this.Connection.AddVesselConfig(config))
{
result.Success = true;
}
else
{
result.Message = "添加失败";
}
return Json(result, JsonRequestBehavior.AllowGet);
}));
}
public JsonResult GetInactiveVessels()
{
var model = new VesselViewModel();
var vessels = new List <VesselViewModel>();
var tempVessels = _vesselRepository.GetVessels().Where(x => !x.IsActive).ToList();
if (tempVessels != null && tempVessels.Count > 0)
{
foreach (var tempVessel in tempVessels)
{
VesselViewModel convertedModel = new VesselConverter().ConvertToView(tempVessel);
vessels.Add(convertedModel);
}
}
model.Vessels = vessels.OrderBy(x => x.VesselName).ToList();
return(Json(model, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> EditVessel(VesselViewModel model)
{
if (ModelState.IsValid)
{
var path = string.Empty;
if (model.ImageFile != null)
{
path = await _imageHelper.UpLoadImageAsync(model.ImageFile);
}
var vessel = await _converterHelper.ToVesselAsync(model, path, false);
_datacontext.Vessels.Update(vessel);
await _datacontext.SaveChangesAsync();
return(RedirectToAction($"Index"));
}
else
{
return(View(model));
}
}
public override JsonResult Get()
{
try
{
var Vessels = _repository.GetAll();
var VesselsVm = Vessels.Select(x => VesselViewModel.FromEntity(x));
if (VesselsVm == null)
{
return(Json(null));
}
return(Json(VesselsVm));
//return new string[] { "value1", "value2" };
}
catch (Exception ex)
{
_logger.LogError($"Failed to get Vessels", ex);
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json("Failed to get Vessels"));
}
}
public static VesselViewModel ToViewModel(this Vessel entity)
{
if (entity == null)
{
return(null);
}
VesselViewModel model = new VesselViewModel
{
Id = entity.Id,
Bt = entity.Bt,
Nt = entity.Nt,
MaxLength = entity.MaxLength,
LengthBetweenPerpendiculars = entity.LengthBetweenPerpendiculars,
MaxWidth = entity.MaxWidth,
Waterplane = entity.Waterplane,
ShipboardHeight = entity.ShipboardHeight,
Deadweight = entity.Deadweight,
NumberOfEngines = entity.NumberOfEngines,
EnginesFuel = entity.EnginesFuel,
SumEnginePower = entity.SumEnginePower,
BodyNumber = entity.BodyNumber,
ExtensionRequestId = entity.VesselExtension?.RequestId,
Engines = entity.VesselEngine
.Select(x => x.ToViewModel()).ToList(),
Owners = entity.VesselOwner
.Select(x => x.ToViewModel()).ToList(),
RegistrationData = entity.VesselRegistrationData
.Select(x => x.ToViewModel()).FirstOrDefault()
};
return(model);
}
public JsonResult EditVessel(VesselViewModel model)
{
var operationResult = new OperationResult();
Vessel vessel = new VesselConverter().ConvertToDomain(model);
operationResult = _vesselRepository.UpdateVessel(vessel);
if (operationResult.Success)
{
model.Success = true;
var vessels = new List <VesselViewModel>();
var tempVessels = _vesselRepository.GetVessels().Where(x => x.IsActive).ToList();
if (tempVessels != null && tempVessels.Count > 0)
{
foreach (var tempVessel in tempVessels)
{
VesselViewModel convertedModel = new VesselConverter().ConvertToView(tempVessel);
vessels.Add(convertedModel);
}
}
model.Vessels = vessels.OrderBy(x => x.VesselName).ToList();
}
else
{
model.Success = false;
model.Message = operationResult.Message;
}
return(Json(model, JsonRequestBehavior.AllowGet));
}
public void Put(VesselViewModel vessel)
{
_vesselService.UpdateVessel(vessel);
}
public void Post(VesselViewModel vessel)
{
_vesselService.CreateVessel(vessel);
}
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);
}
