/// <summary>
/// Creates and returns a new object for the GET_EVENTS_EQUIPMENT table.
/// </summary>
/// <param name="eventsAuto"></param>
/// <param name="equipmentAuto"></param>
/// <param name="smu"></param>
/// <param name="ltd"></param>
/// <returns></returns>
public GET_EVENTS_EQUIPMENT createEquipmentEvent(long eventsAuto, long equipmentAuto, int smu, int ltd)
{
GET_EVENTS_EQUIPMENT equipmentEvent = new GET_EVENTS_EQUIPMENT();
equipmentEvent.equipment_auto = equipmentAuto;
equipmentEvent.events_auto = eventsAuto;
equipmentEvent.smu = smu;
equipmentEvent.ltd = ltd;
return(equipmentEvent);
}
/// <summary>
/// Find and return the previous equipment event given the equipment Id
/// and an event date.
/// </summary>
/// <param name="_gContext"></param>
/// <param name="equipmentAuto"></param>
/// <param name="eventDate"></param>
/// <returns></returns>
public GET_EVENTS_EQUIPMENT findPreviousEquipmentEvent(GETContext _gContext, long equipmentAuto, DateTime eventDate)
{
GET_EVENTS_EQUIPMENT result = new GET_EVENTS_EQUIPMENT();
DateTime eventDate2 = new DateTime(eventDate.Year, eventDate.Month, eventDate.Day, 23, 59, 59);
result = (from ee in _gContext.GET_EVENTS_EQUIPMENT
join ge in _gContext.GET_EVENTS
on ee.events_auto equals ge.events_auto
where ee.equipment_auto == equipmentAuto &&
ge.event_date <= eventDate2 &&
ge.recordStatus == 0
orderby ge.event_date descending, ge.events_auto descending
select ee).FirstOrDefault();
return(result);
}
protected bool UpdateGETByAction(IEquipmentActionRecord actionRecord, ref string OperationResult)
{
bool result = false;
var getEventsByUC = _gContext.GET_EVENTS.Where(m => m.UCActionHistoryId == actionRecord.Id);
if (getEventsByUC.Count() > 0) //Means update
{
var getEventTobeUpdated = getEventsByUC.First();
//All the logic for the lifes to be updated based on getEventTobeUpdated
}
else
{ //Insert
GET_EVENTS GetEvents = new GET_EVENTS
{
user_auto = actionRecord.ActionUser.Id,
action_auto = (int)GETActionType.UndercarriageAction,
event_date = actionRecord.ActionDate,
comment = actionRecord.Comment,
cost = actionRecord.Cost,
recorded_date = actionRecord.ActionDate
};
GET_EVENTS_EQUIPMENT GetEventsEquipment = new GET_EVENTS_EQUIPMENT
{
equipment_auto = actionRecord.EquipmentId,
smu = actionRecord.ReadSmuNumber,
ltd = 0, // Check this.
events_auto = 0 // Check this.
};
//GET_EVENTS_IMPLEMENT GetEventsImplement = new GET_EVENTS_IMPLEMENT
//{
//};
//GET_EVENTS_COMPONENT GetEventsComponent = new GET_EVENTS_COMPONENT
//{
//};
}
return(result);
}
public ActionStatus Start()
{
bool SMUValidationPassed = false;
if (Status == ActionStatus.Close)
{
int iEquipmentIdAuto = longNullableToint(Params.EquipmentId);
// Check that the Action validation passes before starting.
if (ActionSMUValidation(iEquipmentIdAuto, Params.MeterReading, Params.EventDate))
{
string log = "";
_actionRecord = UpdateEquipmentByAction(_actionRecord, ref log);
ActionLog += log;
Message = base.Message;
if (_actionRecord != null && _actionRecord.Id != 0)
{
_actionRecord.TypeOfAction = ActionType.GETAction;
}
SMUValidationPassed = true;
}
else
{
Status = ActionStatus.Invalid;
Message = "SMU validation failed!";
}
if (SMUValidationPassed)
{
int changesSaved = 0;
try
{
// Create a record for the Equipment setup event.
GET_EVENTS getEvents = new GET_EVENTS
{
user_auto = Params.UserAuto,
action_auto = (int)Params.ActionType,
recorded_date = Params.RecordedDate,
event_date = Params.EventDate,
comment = Params.Comment,
cost = Params.Cost
};
_gContext.GET_EVENTS.Add(getEvents);
changesSaved = _gContext.SaveChanges();
if (changesSaved > 0)
{
// Create a new equipment event record.
GET_EVENTS_EQUIPMENT getEventsEquipment = new GET_EVENTS_EQUIPMENT
{
events_auto = getEvents.events_auto,
equipment_auto = Params.EquipmentId,
smu = Params.MeterReading,
ltd = Params.EquipmentLTD
};
_gContext.GET_EVENTS_EQUIPMENT.Add(getEventsEquipment);
changesSaved = _gContext.SaveChanges();
// Link up the GET Event record with the UC Action Taken History record.
if (changesSaved > 0)
{
int GETEventsId = (int)getEvents.events_auto;
int ActionTakenHistoryId = _actionRecord.Id;
var eqEntity = _context.EQUIPMENTs.Find(Params.EquipmentId);
var UCHistoryRecord = _context.ACTION_TAKEN_HISTORY.Find(ActionTakenHistoryId);
if (UCHistoryRecord != null)
{
UCHistoryRecord.GETActionHistoryId = GETEventsId;
UCHistoryRecord.recordStatus = (int)RecordStatus.Available;
_context.Entry(UCHistoryRecord).State = EntityState.Modified;
}
if (eqEntity != null)
{
eqEntity.ActionTakenHistoryId = _actionRecord.Id;
_context.Entry(eqEntity).State = EntityState.Modified;
}
getEvents.UCActionHistoryId = ActionTakenHistoryId;
_context.SaveChanges();
_gContext.SaveChanges();
Status = ActionStatus.Started;
}
}
}
catch (Exception ex1)
{
}
}
else
{
Status = ActionStatus.Failed;
}
}
Available();
return(Status);
}
public ActionStatus Start()
{
bool SMUValidationPassed = false;
if (Status == ActionStatus.Close)
{
int iEquipmentIdAuto = longNullableToint(Params.EquipmentId);
// Check that the Action validation passes before updating UC.
if (ActionSMUValidation(iEquipmentIdAuto, Params.MeterReading, Params.EventDate))
{
string log = "";
_actionRecord = UpdateEquipmentByAction(_actionRecord, ref log);
ActionLog += log;
Message = base.Message;
if (_actionRecord != null && _actionRecord.Id != 0)
{
_actionRecord.TypeOfAction = ActionType.GETAction;
}
SMUValidationPassed = true;
}
else
{
Status = ActionStatus.Invalid;
Message = "SMU validation failed!";
}
if (SMUValidationPassed)
{
// Create an event record.
int actionAuto = (int)GETActionType.Attach_Implement_to_Equipment;
var attachImplementEvent = eventManagement.createGETEvent(Params.UserId,
actionAuto, Params.EventDate, Params.Comment, Params.Cost, Params.RecordedDate);
_gContext.GET_EVENTS.Add(attachImplementEvent);
int _changesSaved = _gContext.SaveChanges();
//Create Events for equipment, implement and components.
if (_changesSaved > 0)
{
GET_EVENTS previousEvent = new GET_EVENTS();
GET_EVENTS_EQUIPMENT previousEquipmentEvent = new GET_EVENTS_EQUIPMENT();
// Perform a cascading update for equipment, implement and components.
long SMUUpdateEventID = eventManagement.cascadeUpdateWithNewSMU(_gContext, Params.EquipmentId,
Params.MeterReading, Params.UserId, Params.EventDate, Params.Comment, Params.Cost);
// Error occurred.
if (SMUUpdateEventID < 0)
{
Status = IndicateFailedActionStatus(attachImplementEvent);
return(Status);
}
else
{
// Find the most recent (valid) smu and ltd for the equipment.
previousEquipmentEvent = eventManagement.findPreviousEquipmentEvent(_gContext, Params.EquipmentId, Params.EventDate);
if (previousEquipmentEvent == null)
{
Status = IndicateFailedActionStatus(attachImplementEvent);
Message = "ERROR: No previous events found for this equipment.";
return(Status);
}
// No change to meter reading
if (SMUUpdateEventID == 0)
{
previousEvent = _gContext.GET_EVENTS.Find(previousEquipmentEvent.events_auto);
}
// SMU is changed
else
{
previousEvent = _gContext.GET_EVENTS.Find(SMUUpdateEventID);
previousEquipmentEvent = _gContext.GET_EVENTS_EQUIPMENT
.Where(e => e.events_auto == SMUUpdateEventID)
.FirstOrDefault();
}
}
int SMU_difference = Params.MeterReading - previousEquipmentEvent.smu;
// Only perform an update for positive SMU changes.
if (SMU_difference >= 0)
{
// Create an equipment event.
var equipmentEvent = eventManagement.createEquipmentEvent(attachImplementEvent.events_auto,
Params.EquipmentId, Params.MeterReading, (previousEquipmentEvent.ltd + SMU_difference));
_gContext.GET_EVENTS_EQUIPMENT.Add(equipmentEvent);
int _changesSavedEquipmentEvent = _gContext.SaveChanges();
// Find the most recent (valid) ltd for the implement.
var previousImplementEvent = eventManagement.findPreviousImplementEvent(_gContext, Params.ImplementId, Params.EventDate);
if (previousImplementEvent == null)
{
// Mark the SMU Update event as invalid.
if (SMUUpdateEventID > 0)
{
previousEvent.recordStatus = 1;
_gContext.SaveChanges();
}
Status = IndicateFailedActionStatus(attachImplementEvent);
Message = "ERROR: No previous events found for this implement.";
return(Status);
}
// Create an implement event.
var implementEvent = eventManagement.createImplementEvent((int)Params.ImplementId,
previousImplementEvent.ltd + SMU_difference, attachImplementEvent.events_auto);
_gContext.GET_EVENTS_IMPLEMENT.Add(implementEvent);
int _changesSavedImplementEvent = _gContext.SaveChanges();
if (_changesSavedImplementEvent > 0)
{
// Create an inventory event.
int statusAuto = (int)GETInterfaces.Enum.InventoryStatus.On_Equipment;
var inventoryEvent = eventManagement.createInventoryEvent(implementEvent.implement_events_auto,
Params.JobsiteId, statusAuto, null);
_gContext.GET_EVENTS_INVENTORY.Add(inventoryEvent);
int _changesSavedInventoryEvent = _gContext.SaveChanges();
// Create component events.
bool componentEventsCreated = eventManagement.updateComponentsForGET(_gContext,
Params.ImplementId, SMU_difference, attachImplementEvent.events_auto, Params.EventDate);
if (!componentEventsCreated)
{
// Mark the SMU Update event as invalid.
if (SMUUpdateEventID > 0)
{
previousEvent.recordStatus = 1;
_gContext.SaveChanges();
}
Status = IndicateFailedActionStatus(attachImplementEvent);
Message = "ERROR: Unable to process this change for components.";
return(Status);
}
}
// Now update the implement and inventory records.
if ((_changesSavedEquipmentEvent > 0) && (_changesSavedImplementEvent > 0))
{
// Attach to equipment
var implementRecord = _gContext.GET.Find(Params.ImplementId);
implementRecord.equipmentid_auto = Params.EquipmentId;
implementRecord.on_equipment = true;
int _changesSavedImplement = _gContext.SaveChanges();
// Remove the entry from inventory since it's now on an equipment.
if (_changesSavedImplement > 0)
{
var inventoryRecord = _gContext.GET_INVENTORY
.Where(g => g.get_auto == Params.ImplementId)
.FirstOrDefault();
_gContext.GET_INVENTORY.Remove(inventoryRecord);
int _changesSavedInventory = _gContext.SaveChanges();
if (_changesSavedInventory > 0)
{
// Link up the GET Event record with the UC Action Taken History record.
int GETEventsId = (int)attachImplementEvent.events_auto;
int ActionTakenHistoryId = _actionRecord.Id;
var UCHistoryRecord = _context.ACTION_TAKEN_HISTORY.Find(ActionTakenHistoryId);
if (UCHistoryRecord != null)
{
UCHistoryRecord.GETActionHistoryId = GETEventsId;
}
attachImplementEvent.UCActionHistoryId = ActionTakenHistoryId;
_context.SaveChanges();
_gContext.SaveChanges();
Status = ActionStatus.Started;
}
}
}
}
}
else
{
Status = ActionStatus.Failed;
}
}
}
return(Status);
}
