518 lines
18 KiB
C#
518 lines
18 KiB
C#
using Foresight.Fleet.Services.Asset;
|
|
using Foresight.Fleet.Services.AssetHealth;
|
|
using IronIntel.Contractor.Machines;
|
|
using IronIntel.Contractor.Maintenance;
|
|
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Web;
|
|
|
|
namespace IronIntel.Contractor.Site.Maintenance
|
|
{
|
|
public class PreventativeMaintenanceBasePage : ContractorBasePage
|
|
{
|
|
protected void ProcessRequest(string methodName)
|
|
{
|
|
object result = null;
|
|
|
|
try
|
|
{
|
|
if (methodName != null)
|
|
{
|
|
switch (methodName.ToUpper())
|
|
{
|
|
case "GETPMSCHEDULE":
|
|
result = GetPmSchedule();
|
|
break;
|
|
case "DELETEPMSCHEDULE":
|
|
result = DeletePmScheule();
|
|
break;
|
|
case "SAVEPMSCHEDULE":
|
|
result = SavePmSchedule();
|
|
break;
|
|
case "ADDPMINTERVAL":
|
|
result = AddPmInterval();
|
|
break;
|
|
case "UPDATEPMINTERVAL":
|
|
result = UpdatePmInterval();
|
|
break;
|
|
case "DELETEPMINTERVAL":
|
|
result = DeletePmInterval();
|
|
break;
|
|
|
|
case "GETMACHINETYPES":
|
|
Machines.MachineManagement.RefreshMachineTypes();
|
|
result = MachineManagement.GetMachineTypes().OrderBy(m => m.Name).Select(t => new
|
|
{
|
|
ID = t.ID,
|
|
Name = t.Name
|
|
});
|
|
break;
|
|
case "GETMACHINELIST":
|
|
result = GetMachineList();
|
|
break;
|
|
case "GETSELECTEDMACHINES":
|
|
result = GetSelectedMachines();
|
|
break;
|
|
case "SAVEMACHINES":
|
|
result = SaveMachines();
|
|
break;
|
|
case "REMOVEPMASSETS":
|
|
result = RemovePMAssets();
|
|
break;
|
|
case "GETPMINTERVALBYSCHEDULEID":
|
|
result = GetPmIntervalByScheduleID();
|
|
break;
|
|
case "GETPMSCHEDULEBYID":
|
|
result = GetPMScheduleByID();
|
|
break;
|
|
case "GETMAINTENANCESCHEDULES":
|
|
result = GetMaintenanceSchedules();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result = ex.Message;
|
|
SystemParams.WriteLog("Error", "PreventativeMaintenanceBasePage.ProcessRequest", ex.Message, ex.ToString());
|
|
}
|
|
|
|
string json = JsonConvert.SerializeObject(result);
|
|
Response.Write(json);
|
|
Response.End();
|
|
}
|
|
|
|
private object GetPmIntervalByScheduleID()
|
|
{
|
|
try
|
|
{
|
|
var session = GetCurrentLoginSession();
|
|
if (session != null)
|
|
{
|
|
|
|
string scheduleid = Request.Form["ClientData"];
|
|
return MaintenanceManagement.GetPmInterval(session.SessionID, scheduleid);
|
|
}
|
|
else
|
|
return new PmIntervalItem[0];
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AddLog("ERROR", "PreventativeMaintenanceBasePage.GetPmIntervalByScheduleID", ex.Message, ex.ToString());
|
|
return ex.Message;
|
|
}
|
|
}
|
|
|
|
|
|
private object GetPmSchedule()
|
|
{
|
|
try
|
|
{
|
|
var session = GetCurrentLoginSession();
|
|
if (session != null)
|
|
{
|
|
string pmtype = Request.Form["ClientData"];
|
|
if (string.IsNullOrWhiteSpace(pmtype))
|
|
pmtype = "PM";
|
|
|
|
return MaintenanceManagement.GetPmSchedule(session.SessionID, pmtype, string.Empty, string.Empty);
|
|
}
|
|
else
|
|
return new PmScheduleInfo[0];
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AddLog("ERROR", "PreventativeMaintenanceBasePage.GetPmSchedule", ex.Message, ex.ToString());
|
|
return ex.Message;
|
|
}
|
|
}
|
|
|
|
private object GetMaintenanceSchedules()
|
|
{
|
|
try
|
|
{
|
|
var session = GetCurrentLoginSession();
|
|
if (session != null)
|
|
{
|
|
var clientdata = Request.Form["ClientData"];
|
|
string[] param = JsonConvert.DeserializeObject<string[]>(clientdata);
|
|
var pmtype = param[0];
|
|
var pmid = param[1];
|
|
var filter = HttpUtility.HtmlDecode(param[2]);
|
|
|
|
return MaintenanceManagement.GetPmSchedule(session.SessionID, pmtype, pmid, filter);
|
|
}
|
|
else
|
|
return new PmScheduleInfo[0];
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AddLog("ERROR", "PreventativeMaintenanceBasePage.GetPmSchedule", ex.Message, ex.ToString());
|
|
return ex.Message;
|
|
}
|
|
}
|
|
|
|
private object GetPMScheduleByID()
|
|
{
|
|
try
|
|
{
|
|
var session = GetCurrentLoginSession();
|
|
if (session != null)
|
|
{
|
|
string scheduleid = Request.Form["ClientData"];
|
|
|
|
return MaintenanceManagement.GetPMScheduleByID(session.SessionID, scheduleid);
|
|
}
|
|
else
|
|
return null;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AddLog("ERROR", "PreventativeMaintenanceBasePage.GetPMScheduleByID", ex.Message, ex.ToString());
|
|
return ex.Message;
|
|
}
|
|
}
|
|
|
|
private object DeletePmScheule()
|
|
{
|
|
try
|
|
{
|
|
var session = GetCurrentLoginSession();
|
|
if (session != null)
|
|
{
|
|
|
|
var iid = Request.Form["ClientData"];
|
|
CreateClient<PMClient>().DeletePMSchedule(SystemParams.CompanyID, iid, session.User.UID);
|
|
return string.Empty;
|
|
}
|
|
else
|
|
return "Failed";
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return "Failed to delete schedule: " + ex.Message;
|
|
}
|
|
}
|
|
|
|
private object SavePmSchedule()
|
|
{
|
|
try
|
|
{
|
|
var session = GetCurrentLoginSession();
|
|
if (session != null)
|
|
{
|
|
var s = HttpUtility.HtmlDecode(Request.Form["ClientData"]);
|
|
var item = JsonConvert.DeserializeObject<ScheduleSaveArgs>(s);
|
|
|
|
if (string.IsNullOrWhiteSpace(item.Name))
|
|
{
|
|
return "The schedule name cannot be empty or just whitespaces.";
|
|
}
|
|
|
|
PmScheduleInfo si;
|
|
if (item.Intervals == null)
|
|
{
|
|
item.Intervals = new PmIntervalItem[0];
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < item.Intervals.Length; i++)
|
|
{
|
|
if (string.IsNullOrEmpty(item.Intervals[i].PmIntervalID))
|
|
item.Intervals[i].PmIntervalID = Guid.NewGuid().ToString();
|
|
item.Intervals[i].ServiceName = item.Intervals[i].ServiceName.Trim();
|
|
}
|
|
}
|
|
si = new PmScheduleInfo
|
|
{
|
|
PmScheduleID = string.IsNullOrWhiteSpace(item.IID) ? Guid.NewGuid().ToString() : item.IID,
|
|
PmScheduleName = item.Name.Trim(),
|
|
PmScheduleType = item.Type,
|
|
PmScheduleUom = item.ScheduleUom,
|
|
Notes = item.Notes,
|
|
Intervals = item.Intervals
|
|
};
|
|
MaintenanceManagement.UpdatePmSchedule(session.SessionID, si, session.User.UID);
|
|
|
|
return si.PmScheduleID;
|
|
}
|
|
else
|
|
return "Failed";
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ex.Message;
|
|
}
|
|
}
|
|
|
|
private string AddPmInterval()
|
|
{
|
|
try
|
|
{
|
|
var session = GetCurrentLoginSession();
|
|
if (session != null)
|
|
{
|
|
var s = HttpUtility.HtmlDecode(Request.Form["ClientData"]);
|
|
PmScheduleInfo item;
|
|
item = JsonConvert.DeserializeObject<PmScheduleInfo>(s);
|
|
PmIntervalItem piclient = item.Intervals[0];
|
|
piclient.PmIntervalID = Guid.NewGuid().ToString();
|
|
piclient.ScheduleId = item.PmScheduleID;
|
|
|
|
if (string.IsNullOrWhiteSpace(piclient.ServiceName))
|
|
{
|
|
return "Service Name cannot be empty.";
|
|
}
|
|
else
|
|
{
|
|
piclient.ServiceName = piclient.ServiceName.Trim();
|
|
}
|
|
|
|
MaintenanceManagement.UpdatePmInterval(session.SessionID, piclient, session.User.UID);
|
|
|
|
return string.Empty;
|
|
}
|
|
else
|
|
return "Failed";
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ex.Message;
|
|
}
|
|
}
|
|
|
|
private object UpdatePmInterval()
|
|
{
|
|
try
|
|
{
|
|
var session = GetCurrentLoginSession();
|
|
if (session != null)
|
|
{
|
|
var s = HttpUtility.HtmlDecode(Request.Form["ClientData"]);
|
|
PmIntervalItem item = JsonConvert.DeserializeObject<PmIntervalItem>(s);
|
|
|
|
if (string.IsNullOrWhiteSpace(item.ServiceName))
|
|
{
|
|
return "Service Name cannot be empty.";
|
|
}
|
|
else
|
|
{
|
|
item.ServiceName = item.ServiceName.Trim();
|
|
}
|
|
|
|
MaintenanceManagement.UpdatePmInterval(session.SessionID, item, session.User.UID);
|
|
|
|
return string.Empty;
|
|
}
|
|
else
|
|
return "Failed";
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ex.Message;
|
|
}
|
|
}
|
|
|
|
private string DeletePmInterval()
|
|
{
|
|
try
|
|
{
|
|
var session = GetCurrentLoginSession();
|
|
if (session != null)
|
|
{
|
|
var iid = Request.Form["ClientData"];
|
|
CreateClient<PMClient>().DeletePMIntervals(SystemParams.CompanyID, new string[] { iid }, session.User.UID);
|
|
return string.Empty;
|
|
}
|
|
else
|
|
return "Failed";
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return "Failed to delete interval: " + ex.Message;
|
|
}
|
|
}
|
|
|
|
private MaintenanceMachineInfo[] GetMachineList()
|
|
{
|
|
var session = GetCurrentLoginSession();
|
|
var s = Request.Form["ClientData"];
|
|
var type = JsonConvert.DeserializeObject<MachineItem>(s);
|
|
|
|
var machines = MaintenanceManagement.GetMaintenanceMachines(session.SessionID, (int)type.MachineID, type.Name, session.User.UID)
|
|
//.Where(m => !selected.Any(t => t.MachineID == m.MachineID))
|
|
.OrderBy(m => m.VIN)
|
|
.ToArray();
|
|
|
|
return machines;
|
|
}
|
|
|
|
private PMAssetItem[] GetSelectedMachines()
|
|
{
|
|
try
|
|
{
|
|
var session = GetCurrentLoginSession();
|
|
if (session != null)
|
|
{
|
|
var iid = Request.Form["ClientData"];
|
|
List<PMAssetItem> result = new List<PMAssetItem>();
|
|
var assets = CreateClient<PMClient>().GetPMAssets(SystemParams.CompanyID, iid);
|
|
if (session.User.UserType < Foresight.Fleet.Services.User.UserTypes.Admin)
|
|
{
|
|
AssetBasicInfo[] allassets = CreateClient<AssetQueryClient>(SystemParams.CompanyID).GetAssetBasicInfoByUser(SystemParams.CompanyID, "", session.User.UID, 0);
|
|
var allassetids = allassets.Select(a => a.ID).ToList();
|
|
assets = assets.Where(a => allassetids.Contains(a.AssetId)).ToArray();
|
|
}
|
|
foreach (var asset in assets)
|
|
{
|
|
PMAssetItem a = new PMAssetItem();
|
|
Helper.CloneProperty(a, asset);
|
|
a.EngineHours = asset.CurrentEngineHours;
|
|
a.Odometer = asset.CurrentOdometer;
|
|
result.Add(a);
|
|
}
|
|
return result.ToArray();
|
|
}
|
|
else
|
|
return null;
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private string SaveMachines()
|
|
{
|
|
var u = GetCurrentUser();
|
|
if (u != null)
|
|
{
|
|
var s = Request.Form["ClientData"];
|
|
var p = JsonConvert.DeserializeObject<ScheduleAssetArgs>(s);
|
|
//MaintenanceManagement.UpdatePmMachines(ids.IID, ids.Assets);
|
|
List<PMAssetInfo> assets = new List<PMAssetInfo>();
|
|
if (p.Assets != null)
|
|
{
|
|
foreach (var a in p.Assets)
|
|
{
|
|
PMAssetInfo pmAsset = new PMAssetInfo();
|
|
pmAsset.AssetId = a.AssetId;
|
|
pmAsset.StartHours = a.StartHours;
|
|
pmAsset.StartOdometer = a.StartOdometer;
|
|
pmAsset.StartDate = a.StartDate;
|
|
pmAsset.StartIntervalValue = a.StartIntervalValue;
|
|
assets.Add(pmAsset);
|
|
}
|
|
}
|
|
CreateClient<PMClient>().UpdatePMScheduleAssets(SystemParams.CompanyID, p.IID, assets.ToArray(), u.IID);
|
|
}
|
|
|
|
return string.Empty;
|
|
}
|
|
|
|
private string RemovePMAssets()
|
|
{
|
|
var u = GetCurrentUser();
|
|
if (u != null)
|
|
{
|
|
var s = Request.Form["ClientData"];
|
|
var p = JsonConvert.DeserializeObject<RemovePMAssetsArgs>(s);
|
|
|
|
CreateClient<PMClient>().DeleteAssetsFromSchedule(SystemParams.CompanyID, p.ScheduleID, p.Assets, u.IID);
|
|
}
|
|
|
|
return string.Empty;
|
|
}
|
|
|
|
class RemovePMAssetsArgs
|
|
{
|
|
public string ScheduleID { get; set; }
|
|
public long[] Assets { get; set; }
|
|
}
|
|
|
|
class ScheduleAssetArgs
|
|
{
|
|
public string IID { get; set; }
|
|
public PMAssetItem[] Assets { get; set; }
|
|
}
|
|
|
|
|
|
class PMAssetItem
|
|
{
|
|
public string ModelName { get; set; }
|
|
public string Notes { get; set; }
|
|
private double? _StartOdometer;
|
|
public double? StartOdometer
|
|
{
|
|
get
|
|
{
|
|
return _StartOdometer;
|
|
}
|
|
set
|
|
{
|
|
if (value != null)
|
|
_StartOdometer = Math.Round(value.Value, 2);
|
|
else
|
|
_StartOdometer = value;
|
|
}
|
|
}
|
|
public double? StartHours { get; set; }
|
|
public DateTime? StartDate { get; set; }
|
|
public string TypeName { get; set; }
|
|
public int AlertsCount { get; set; }
|
|
public int UnMaintainedAlert { get; set; }
|
|
public string MakeName { get; set; }
|
|
public string Name { get; set; }
|
|
public string VIN { get; set; }
|
|
public long AssetId { get; set; }
|
|
public double? EngineHours { get; set; }
|
|
|
|
private double? _Odometer;
|
|
public double? Odometer
|
|
{
|
|
get
|
|
{
|
|
return _Odometer;
|
|
}
|
|
set
|
|
{
|
|
if (value != null)
|
|
_Odometer = Math.Round(value.Value, 2);
|
|
else
|
|
_Odometer = value;
|
|
}
|
|
}
|
|
public string PMScheduleId { get; set; }
|
|
public int? StartIntervalValue { get; set; }
|
|
public string StartDateString
|
|
{
|
|
get
|
|
{
|
|
if (StartDate == null)
|
|
return "";
|
|
else
|
|
return StartDate.Value.ToString("MM/dd/yyyy");
|
|
}
|
|
}
|
|
}
|
|
|
|
class ScheduleSaveArgs
|
|
{
|
|
public string IID { get; set; }
|
|
public string Name { get; set; }
|
|
public string ScheduleUom { get; set; }
|
|
public string Type { get; set; }
|
|
public string Notes { get; set; }
|
|
|
|
public PmIntervalItem[] Intervals { get; set; }
|
|
}
|
|
}
|
|
}
|