public ActionResult Edit(PlantModel tblmc)
{
if ((Session["UserId"] == null) || (Session["UserId"].ToString() == String.Empty))
{
return(RedirectToAction("Login", "Login", null));
}
ViewBag.Logout = Session["Username"].ToString().ToUpper();
ViewBag.roleid = Session["RoleID"];
String Username = Session["Username"].ToString();
int UserID = Convert.ToInt32(Session["UserID"]);
string plantName = tblmc.Plant.PlantName.ToString();
int plantid = tblmc.Plant.PlantID;
using (i_facility_unimechEntities db = new i_facility_unimechEntities())
{
var doesThisPlantExist = db.tblplants.Where(m => m.IsDeleted == 0 && m.PlantName == plantName && m.PlantID != plantid).ToList();
if (doesThisPlantExist.Count == 0)
{
var Plant = db.tblplants.Find(tblmc.Plant.PlantID);
Plant.PlantName = tblmc.Plant.PlantName;
Plant.PlantDesc = tblmc.Plant.PlantDesc;
Plant.PlantDisplayName = tblmc.Plant.PlantDisplayName;
Plant.ModifiedBy = 1;
Plant.ModifiedOn = DateTime.Now;
db.Entry(Plant).State = EntityState.Modified;
db.SaveChanges();
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
Session["Error"] = "Plant Name" + " " + tblmc.Plant.PlantName + " " + "already Exists.";
return(View(tblmc));
}
}
}
public static string toJson(this PlantModel model)
{
return(JsonSerializer.Serialize(model));
}
public async Task <ActionResult <PlantModel> > PostPlantModel(PlantModel plantModel)
{
await _plantService.AddPlantAsync(plantModel);
return(CreatedAtAction(nameof(GetPlantModel), new { id = plantModel.Id }, plantModel));
}
private List <MesDataViewModel> GetVueModel(PlantModel plant, List <MachineInfoModel> allMachines, bool onlyActive)
{
var result = new List <MesDataViewModel>();
var dataAllMachines = _mesService.GetPlantData(plant);
if (onlyActive)
{
dataAllMachines = dataAllMachines.Where(m => m.Expired == false).ToList();
}
foreach (var dataMachine in dataAllMachines)
{
var mes = new MesDataViewModel();
var machine = allMachines.FirstOrDefault(w => w.Id == dataMachine.MachineId);
if (machine?.Type == null || machine.Model == null)
{
continue;
}
mes.info = new MachineInfoViewModel
{
id = machine.Id,
description = machine.Description == string.Empty ? null : machine.Description,
model = machine.Model.Name,
machineName = machine.MachineName,
icon = machine.Type.Image,
expired = dataMachine.Expired,
id_mtype = machine.Type?.Id ?? 0,
serial = machine.Serial
};
var data = dataAllMachines.FirstOrDefault(w => w.MachineId == machine.Id);
if (data == null)
{
result.Add(mes);
continue;
}
if (data.enActualState != null)
{
mes.state = new StateViewModel
{
code = data.enActualState.GetDescription(),
text = LocalizationService.GetResource(data.enActualState.ToString())
};
mes.error = data.ActualStateCode;
}
if (data.ActualJobPerc != null)
{
mes.job = new JobDataModel
{
code = data.ActualJobCode,
perc = (data.ActualJobPerc ?? 0).RoundToInt()
};
}
mes.@operator = data.ActualOperator;
if (data.StateEfficiency != null)
{
mes.efficiency = new EfficiencyVueModel();
mes.efficiency.kpi = CommonViewService.getKpiViewModel((decimal)(data.StateEfficiency ?? 0), machine.StateProductivityGreenThreshold, machine.StateProductivityYellowThreshold);
mes.efficiency.overfeed = CommonViewService.getKpiViewModel((decimal)(data.StateOverfeedAvg ?? 0), null, null);
}
if (data.PieceCompletedCount != null)
{
mes.productivity = new ProductivityVueModel();
mes.productivity.kpi = CommonViewService.getKpiViewModel(Common.GetRatioProductivity(data.PieceCompletedCount, data.PieceElapsedTime),
machine.PiecesProductivityGreenThreshold,
machine.PiecesProductivityYellowThreshold);
mes.productivity.piece = new PieceViewModel()
{
total = (data.PieceCompletedCount ?? 0) + (data.PieceRedoneCount ?? 0)
};
}
if (data.AlarmCount != null)
{
mes.errors = new ErrorViewModel();
mes.errors.quantity = data.AlarmCount;
}
result.Add(mes);
}
return(result);
}
public void UpdatePlant(PlantModel item)
{
item.LastUpdate = DateTime.Now;
_dao.Update(item);
}
public void AddPlant(PlantModel item)
{
_dao.Add(item);
}
public List <MachineMessagesDataViewModel> GetVueModel(PlantModel plant, List <MachineInfoModel> allMachines, PeriodModel period)
{
if (period.StartDate == DateTime.MinValue || period.EndDate == DateTime.MinValue)
{
period.EndDate = DateTime.UtcNow;
period.StartDate = DateTime.Now.AddDays(-30);
}
var result = new List <MachineMessagesDataViewModel>();
var dataAllMachines = _mesService.GetPlantData(plant);
foreach (var dataMachine in dataAllMachines)
{
var machine = allMachines.FirstOrDefault(w => w.Id == dataMachine.MachineId);
if (machine == null)
{
continue;
}
var machineInfo = new MachineInfoViewModel()
{
id = machine.Id,
description = machine.Description == string.Empty ? null : machine.Description,
model = machine.Model.Name,
machineName = machine.MachineName,
icon = machine.Type.Image,
serial = machine.Serial
};
var data = _messageService.GetMessageDetails(machine, period);
if (data.Count == 0)
{
continue;
}
var msgDet = data.Select(a => new MessageDetailViewModel()
{
code = a.Code,
parameters = a.Params,
timestamp = DateTime.SpecifyKind(a.Day ?? DateTime.MinValue, DateTimeKind.Utc),
utc = machine.UTC ?? 0,
type = ((enTypeAlarm)a.Type).GetDescription(),
//((enTypeAlarm)a.StateId).GetDescription(),
group = a.GroupName,
time = CommonViewService.getTimeViewModel(a.ElapsedTime),
description = a.Description
}).ToList();
foreach (var det in msgDet)
{
var msg = new MachineMessagesDataViewModel();
msg.message = det;
msg.machine = machineInfo;
result.Add(msg);
}
}
if (result.Count == 0)
{
result = null;
}
return(result);
}
/// <summary>
/// This method is the update method which
/// passes the plant to the update method for
/// the database and also resets the in-memory
/// list once the database is updated
/// </summary>
/// <param name="plant">plant to be added</param>
public static void updatePlant(PlantModel plant)
{
updateIntoDb(plant);
PlantService.plants = readData();
}
/// <summary>
/// Update specific plant from db
/// </summary>
/// <param name="plant">PlantModel</param>
/// <returns></returns>
internal Task UpdatePlant(PlantModel plant)
{
string procName = "Company.PlantUpdate";
return(_db.UpdateDataAsync(procName, plant));
}
public ActionResult SavePlant(PlantModel plantModel)
{
try
{
SubjectManager subjectManager = new SubjectManager();
InteractionManager interactionManager = new InteractionManager();
Plant plant = new Plant();
if (plantModel.Id > 0)
{
var x = subjectManager.Get(plantModel.Id).Self;
plant = x as Plant;
}
plant.Name = plantModel.Name;
plant.ScientificName = plantModel.ScientificName;
//Todo Select the type based on the scientific name
//plant.Rank = Utility.GetTaxonRank(plantModel.ScientificName);
plant.Rank = plantModel.TaxonRank;
#region after culture
foreach (var ac in plantModel.AfterCultures)
{
if (string.IsNullOrEmpty(ac.Name))
{
break;
}
Plant afterCultureTmp = null;
//add new culture to plant
if (ac.Id == 0)
{
afterCultureTmp = subjectManager.GetAllAsQueryable <Plant>().Where(p => p.Name.Equals(ac.Name)).FirstOrDefault();
if (afterCultureTmp != null)
{
plant.AfterCultures.Add(subjectManager.Get(afterCultureTmp.Id) as Plant);
}
}
}
//delete cultures
List <string> nameOfDeleteAfterCultures = new List <string>();
foreach (var ac in plant.AfterCultures)
{
if (!plantModel.AfterCultures.Any(a => a.Name.Equals(ac.Name)))
{
nameOfDeleteAfterCultures.Add(ac.Name);
}
}
foreach (var name in nameOfDeleteAfterCultures)
{
var tmp = plant.AfterCultures.Where(a => a.Name.Equals(name)).FirstOrDefault();
if (tmp != null)
{
plant.AfterCultures.Remove(tmp);
}
}
#endregion after culture
#region preculture
foreach (var pc in plantModel.PreCultures)
{
if (string.IsNullOrEmpty(pc.Name))
{
break;
}
Plant preCultureTmp = null;;
//add new culture to plant
if (pc.Id == 0)
{
preCultureTmp = subjectManager.GetAllAsQueryable <Plant>().Where(p => p.Name.Equals(pc.Name)).FirstOrDefault();
if (preCultureTmp != null)
{
plant.PreCultures.Add(subjectManager.Get(preCultureTmp.Id) as Plant);
}
}
}
//delete cultures
List <string> nameOfDeletePreCultures = new List <string>();
foreach (var ac in plant.PreCultures)
{
if (!plantModel.PreCultures.Any(a => a.Name.Equals(ac.Name)))
{
nameOfDeletePreCultures.Add(ac.Name);
}
}
foreach (var name in nameOfDeletePreCultures)
{
var tmp = plant.PreCultures.Where(a => a.Name.Equals(name)).FirstOrDefault();
if (tmp != null)
{
plant.PreCultures.Remove(tmp);
}
}
#endregion preculture
plant.Description = plantModel.Description;
plant.Height = plantModel.Height;
plant.LocationType = plantModel.LocationType;
if (!plantModel.ImagePath.Equals("/Images/Empty.png") && !plant.Medias.Where(m => m.ImagePath.Equals(plantModel.ImagePath)).Any())
{
plant.Medias.Add(new Media()
{
ImagePath = plantModel.ImagePath,
MIMEType = MimeMapping.GetMimeMapping(plantModel.ImagePath)
});
}
plant.NutrientClaim = plantModel.NutrientClaim;
plant.RootDepth = plantModel.RootDepth;
plant.SowingDepth = plantModel.SowingDepth;
plant.Width = plantModel.Width;
plant.TimePeriods = new List <TimePeriod>();
foreach (var lifeCylce in plantModel.LifeCycles)
{
lifeCylce.Reverse();
TimePeriod last = null;
foreach (var tpModel in lifeCylce)
{
TimePeriod tp = Utility.CreateTimePeriodFromModel(tpModel);
tp.AssignedTo = plant;
if (lifeCylce.Last().Equals(tpModel))
{
tp.Start = true;
}
if (last != null)
{
tp.Next = last;
}
plant.TimePeriods.Add(tp);
last = tp;
}
plant.TimePeriods.Reverse();
}
if (plantModel.Id == 0)
{
plant = subjectManager.CreatePlant(plant);
}
else
{
plant = subjectManager.UpdatePlant(plant);
}
//set parent
if (plantModel.Parent != null && plantModel.Parent.Id > 0)
{
var parent = subjectManager.GetAll <Node>().Where(n => n.Id.Equals(plantModel.Parent.Id)).FirstOrDefault();
plant.Parent = parent;
}
else // delete parent from plant
{
plant.Parent = null;
}
subjectManager.Update(plant);
return(Json(plant.Id, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(ex.Message, JsonRequestBehavior.AllowGet));
}
}
public ActionResult Edit(long id, string type)
{
SubjectManager sm = new SubjectManager();
Subject s = sm.Get(id);
//load by loading the page and store it in a session!!!!
switch (type)
{
case "Plant":
{
Plant plant = sm.GetAll <Plant>().Where(p => p.Id.Equals(id)).FirstOrDefault();
PlantModel Model = PlantModel.Convert(plant);
//load interactions
Model.Interactions = SubjectModel.ConverInteractionModels(sm.GetAllDependingInteractions(plant, true).ToList());
//load ParentList
ViewData["Parent.Id"] = getAllNodeNames(Model.TaxonRank);
return(View("PlantEdit", Model));
}
case "Animal":
{
Animal animal = sm.GetAll <Animal>().Where(a => a.Id.Equals(id)).FirstOrDefault();
AnimalModel Model = AnimalModel.Convert(animal);
Model.Interactions = SubjectModel.ConverInteractionModels(sm.GetAllDependingInteractions(animal, true).ToList());
//load ParentList
ViewData["Parent.Id"] = getAllNodeNames(Model.TaxonRank);
return(View("AnimalEdit", Model));
}
case "Taxon":
{
Taxon taxon = sm.GetAll <Taxon>().Where(a => a.Id.Equals(id)).FirstOrDefault();
NodeModel Model = NodeModel.Convert(taxon);
//load ParentList
ViewData["Parent.Id"] = getAllNodeNames(Model.TaxonRank);
return(View("TaxonEdit", Model));
}
case "Effect":
{
Effect effect = sm.GetAll <Effect>().Where(e => e.Id.Equals(id)).FirstOrDefault();
return(View("EffectDetails"));
}
case "Unknow":
{
SubjectModel Model = SubjectModel.Convert(s);
return(View("SubjectDetails", Model));
}
default: { break; }
}
return(RedirectToAction("Search", "Search"));
}
public ResponseModel Edit([FromBody] PlantModel plant)
{
var response = new ResponseModel {
IsError = false
};
var editablePlant = _repository.Plants.Include(p => p.Genus).Include(p => p.Family).Include(p => p.Conservation)
.Where(p => p.Id == plant.Id).FirstOrDefault();
if (string.IsNullOrEmpty(plant.LatinName))
{
response.IsError = true;
response.ErrorMessage = "Please add latin name.";
}
else if (editablePlant.LatinName != plant.LatinName)
{
editablePlant.LatinName = plant.LatinName;
}
if (string.IsNullOrEmpty(plant.Name))
{
response.IsError = true;
response.ErrorMessage = "Please add name.";
}
else if (editablePlant.Name != plant.Name)
{
editablePlant.Name = plant.Name;
}
if (editablePlant.Genus == null || editablePlant.Genus.Name != plant.Genus)
{
var selectedGenus = _repository.Genus.Where(g => g.Name == plant.Genus).FirstOrDefault();
if (selectedGenus == null)
{
response.IsError = true;
response.ErrorMessage = "Please select genus.";
}
else
{
editablePlant.Genus = selectedGenus;
}
}
if (editablePlant.Conservation == null || editablePlant.Conservation.Name != plant.Conservation)
{
var selectedConservation = _repository.Conservations.Where(g => g.Name == plant.Conservation).FirstOrDefault();
if (selectedConservation == null)
{
response.IsError = true;
response.ErrorMessage = "Please select conservation.";
}
else
{
editablePlant.Conservation = selectedConservation;
}
}
if (editablePlant.Family == null || editablePlant.Family.Name != plant.Family)
{
var selectedFamily = _repository.Familys.Where(g => g.Name == plant.Family).FirstOrDefault();
if (selectedFamily == null)
{
response.IsError = true;
response.ErrorMessage = "Please select family.";
}
else
{
editablePlant.Family = selectedFamily;
}
}
if (!response.IsError)
{
_repository.SaveChanges();
}
return(response);
}
private static int CountTimesPlantIsRated(IEnumerable <UserPlantRatingModel> userPlantRatingList,
PlantModel plant)
{
return(userPlantRatingList.Count(
u => u.PlantName.Equals(plant.Name) && u.Rating != UserPlantRating.NoRating));
}
private static double CountDislikeIndexesForPlant(IEnumerable <UserPlantRatingModel> userPlantRatingList,
IEnumerable <UserSimilarityIndexModel> userSimilarityIndexList, PlantModel plant)
{
var relevantUserPlantRatingList = userPlantRatingList
.Where(userPlantRating => userPlantRating.PlantName.Equals(plant.Name))
.Where(userPlantRating => userPlantRating.Rating == UserPlantRating.Dislike)
.ToList();
double dislikeIndexes = 0;
foreach (var userPlantRating in relevantUserPlantRatingList)
{
var correctUserSimilarityIndex = userSimilarityIndexList.FirstOrDefault(userSimilarityIndex =>
userSimilarityIndex.OtherUserId == userPlantRating.UserId);
if (correctUserSimilarityIndex == null)
{
continue;
}
dislikeIndexes += correctUserSimilarityIndex.SimilarityIndex;
}
return(dislikeIndexes);
}
public void TestDefaultConstructorShouldPass()
{
PlantModel plantTest = new PlantModel();
Assert.IsNotNull(plantTest);
}
public void Post([FromBody] PlantModel value)
{
_service.AddPlant(value);
}
