private DataResponseActiveAlarmsActiveAlarm MakeGetWorkOrderActiveAlarmsResponse(
DataRequestActiveAlarmsActiveAlarm activeAlarmRequest)
{
//make a response from the request
var activeAlarmResponse = new DataResponseActiveAlarmsActiveAlarm
{
cid = activeAlarmRequest.cid,
mid = activeAlarmRequest.mid,
aid = activeAlarmRequest.aid,
EventUID = activeAlarmRequest.EventUID,
EventCode = activeAlarmRequest.EventCode,
EventSource = activeAlarmRequest.EventSource,
TimeOfOccurrance = activeAlarmRequest.TimeOfOccurrance,
TimeOfOccurranceSpecified = true,
TimeOfNotification = activeAlarmRequest.TimeOfNotification,
TimeOfNotificationSpecified = true,
SLADue = activeAlarmRequest.SLADue,
Notes = activeAlarmRequest.Notes
};
//then get the WorkOrderId
activeAlarmResponse.WorkOrderId = GetWorkOrderId(activeAlarmResponse);
//now create the work order event for this alarm
return(activeAlarmResponse);
}
/// <summary>
/// Gets a work order ID for this asset. IF one does not exist, it will create it instead.
/// </summary>
/// <param name="activeAlarmResponse"></param>
/// <returns></returns>
private string GetWorkOrderId(DataResponseActiveAlarmsActiveAlarm activeAlarmResponse)
{
const int defaultValue = -1;
//first, parse the ids
int customeId = int.TryParse(activeAlarmResponse.cid, out customeId) ? customeId : defaultValue;
int meterId = int.TryParse(activeAlarmResponse.mid, out meterId) ? meterId : defaultValue;
int areaId = int.TryParse(activeAlarmResponse.aid, out areaId) ? areaId : defaultValue;
int eventSource = int.TryParse(activeAlarmResponse.EventSource, out eventSource)
? eventSource
: defaultValue;
int eventCode = int.TryParse(activeAlarmResponse.EventCode, out eventCode) ? eventCode : defaultValue;
long eventUID = long.TryParse(activeAlarmResponse.EventUID, out eventUID) ? eventUID : defaultValue;
long workOrderId = defaultValue;
//check ot make sure all the ids were parsed correctly
if (customeId > defaultValue && meterId > defaultValue && areaId > defaultValue &&
eventCode > defaultValue && eventSource > defaultValue && eventUID > defaultValue)
{
var currentCustomer = new PemsCity(customeId.ToString());
//go get the customer so we can get the correct connection string
using (
var maintenanceEntities = new MaintenanceEntities(currentCustomer.MaintenanceConnectionStringName))
{
//first we have to go to PEMS db to get the asset
//return nothing if the asset doesnt exist.
var assetFactory = (new AssetFactory(currentCustomer.PemsConnectionStringName));
var asset = assetFactory.GetAsset(customeId, areaId, meterId);
//fail state - work order or work orde3r event will not be created
if (asset == null)
{
return(string.Empty);
}
//now create the work order/ or get the exisitng one
var fmWorkOrder = CreateWorkOrder(activeAlarmResponse, areaId, currentCustomer, customeId, asset,
meterId, maintenanceEntities);
workOrderId = fmWorkOrder.WorkOrderId;
//now that we have our work order id (exisitng or new), we haev to create the event for this work order.
//first, we have to get the vlaues we need ot create an event (tier, etc)
//get event code
CreateWorkOrderEvent(activeAlarmResponse, currentCustomer, customeId, eventSource, eventCode,
eventUID, workOrderId, maintenanceEntities);
//every time a event is created, resolved , etc, we have to update the sladue and highest severity, so lets do that now
var mobileWorkOrderFactory =
(new TechnicianWorkOrderFactory(currentCustomer.MaintenanceConnectionStringName,
currentCustomer.PemsConnectionStringName));
mobileWorkOrderFactory.UpdateEventAggregateInfo(workOrderId);
return(workOrderId.ToString());
}
}
return(string.Empty);
}
public Data GetWorkOrders(Data wsRequest)
{
try
{
//get the request
var request = wsRequest.Request;
if (request == null)
{
return(GenerateError("Invalid Request Object", "400"));
}
//get the active alarms for the request
var requestActiveAlarms = request.ActiveAlarms;
if (requestActiveAlarms == null)
{
return(GenerateError("Invalid Active Alarms Object for the request", "400"));
}
//build a list of response alarms from the request alarms
var responseActiveAlarms = new DataResponseActiveAlarms[wsRequest.Request.ActiveAlarms.Count()];
for (int activeAlarmsIndex = 0; activeAlarmsIndex < requestActiveAlarms.Count(); activeAlarmsIndex++)
{
var responseActiveAlarm =
new DataResponseActiveAlarmsActiveAlarm[
requestActiveAlarms[activeAlarmsIndex].ActiveAlarm.Count()];
for (int activeAlarmIndex = 0;
activeAlarmIndex < requestActiveAlarms[activeAlarmsIndex].ActiveAlarm.Count();
activeAlarmIndex++)
{
var activeAlarmRequest = requestActiveAlarms[activeAlarmsIndex].ActiveAlarm[activeAlarmIndex];
var activeAlarmResponse = MakeGetWorkOrderActiveAlarmsResponse(activeAlarmRequest);
//now we have to create the work order event for this alarm
//then add it to our colleciton
responseActiveAlarm[activeAlarmIndex] = activeAlarmResponse;
}
var activeAlarmsResponse = new DataResponseActiveAlarms();
activeAlarmsResponse.ActiveAlarm = responseActiveAlarm;
responseActiveAlarms[activeAlarmsIndex] = activeAlarmsResponse;
}
var response = new Data {
Response = new DataResponse {
ActiveAlarms = responseActiveAlarms
}
};
return(response);
}
catch (Exception ex)
{
return(GenerateError(ex.Message, "500"));
}
}
/// <summary>
/// Creates a work order in the system
/// </summary>
/// <param name="activeAlarmResponse"></param>
/// <param name="areaId"></param>
/// <param name="currentCustomer"></param>
/// <param name="customeId"></param>
/// <param name="asset"></param>
/// <param name="meterId"></param>
/// <param name="maintenanceEntities"></param>
/// <returns></returns>
private static FMWorkOrder CreateWorkOrder(DataResponseActiveAlarmsActiveAlarm activeAlarmResponse, int areaId,
PemsCity currentCustomer, int customeId, Meter asset, int meterId,
MaintenanceEntities maintenanceEntities)
{
//we have to check to see if htey asset already has a work order. if it does, use that work order. This includes any open, incomplete or rejected work orders.
//we add it to any open work order, even if it is assigned ot another technician (in practice this will almost never happen)
var existingWorkOrder =
maintenanceEntities.FMWorkOrders.FirstOrDefault(
x =>
x.MeterId == meterId && x.CustomerId == customeId && x.AreaId == areaId &&
(x.WorkOrderStatusId == (int)WorkOrderStatus.Open ||
x.WorkOrderStatusId == (int)WorkOrderStatus.Incomplete ||
x.WorkOrderStatusId == (int)WorkOrderStatus.Rejected));
if (existingWorkOrder != null)
{
return(existingWorkOrder);
}
//we need to crate a new work order
//create the work order now. commented out properties we ignore upon creation.
var fmWorkOrder = new FMWorkOrder
{
AreaId = areaId,
CreateDateTime = currentCustomer.LocalTime,
CustomerId = customeId, //cid
HighestSeverity = 0,
Location = asset.Location,
Mechanism = asset.MeterType,
MeterGroup = asset.MeterGroup ?? 1,
MeterId = meterId,
Notes = string.Empty,
SLADue = activeAlarmResponse.SLADue, //this gets reset anyways, jsut set it to
WorkOrderStatusId = (int)WorkOrderStatus.Open,
AssignmentState = (int)AssignmentState.Unassigned,
ZoneId =
asset.MeterMaps.FirstOrDefault() != null?asset.MeterMaps.FirstOrDefault().ZoneId : (int?)null
};
maintenanceEntities.FMWorkOrders.Add(fmWorkOrder);
maintenanceEntities.SaveChanges();
//every time a event is created, resolved , etc, we have to update the sladue and highest severity, so lets do that now
var mobileWorkOrderFactory =
(new TechnicianWorkOrderFactory(currentCustomer.MaintenanceConnectionStringName,
currentCustomer.PemsConnectionStringName));
mobileWorkOrderFactory.UpdateEventAggregateInfo(fmWorkOrder.WorkOrderId);
return(fmWorkOrder);
}
/// <summary>
/// Creates a work order event if we need to.
/// </summary>
/// <param name="activeAlarmResponse"></param>
/// <param name="currentCustomer"></param>
/// <param name="customeId"></param>
/// <param name="eventSource"></param>
/// <param name="eventCode"></param>
/// <param name="eventUID"></param>
/// <param name="workOrderId"></param>
/// <param name="maintenanceEntities"></param>
private void CreateWorkOrderEvent(DataResponseActiveAlarmsActiveAlarm activeAlarmResponse,
PemsCity currentCustomer,
int customeId, int eventSource, int eventCode, long eventUID, long workOrderId,
MaintenanceEntities maintenanceEntities)
{
//check to see if we need to crate the event first. the PK for it is workorderid, eventid, eventcode
var existingWorkOrderEvent =
maintenanceEntities.FMWorkOrderEvents.FirstOrDefault(
x =>
x.WorkOrderId == workOrderId && x.EventId == eventUID && x.EventCode == eventCode &&
x.Status == (int)WorkOrderEventStatus.Open);
if (existingWorkOrderEvent != null)
{
return;
}
//if we got here, we have to creat the event.
using (var pemsEntities = new PEMEntities(currentCustomer.PemsConnectionStringName))
{
var ec =
pemsEntities.EventCodes.FirstOrDefault(
x => x.CustomerID == customeId && x.EventSource == eventSource && x.EventCode1 == eventCode);
if (ec != null)
{
//we found the event code, continue. .
var fmWorkOrderEvent = new FMWorkOrderEvent();
fmWorkOrderEvent.AlarmTier = ec.AlarmTier; // alarm tier of the event code
fmWorkOrderEvent.Automated = true;
fmWorkOrderEvent.EventCode = eventCode;
fmWorkOrderEvent.EventDateTime = activeAlarmResponse.TimeOfOccurrance;
fmWorkOrderEvent.EventDesc = ec.EventDescVerbose;
fmWorkOrderEvent.EventId = eventUID;
fmWorkOrderEvent.Notes = activeAlarmResponse.Notes;
fmWorkOrderEvent.SLADue = activeAlarmResponse.SLADue;
fmWorkOrderEvent.Status = (int)WorkOrderEventStatus.Open;
fmWorkOrderEvent.Vandalism = false;
fmWorkOrderEvent.WorkOrderId = workOrderId;
maintenanceEntities.FMWorkOrderEvents.Add(fmWorkOrderEvent);
maintenanceEntities.SaveChanges();
}
}
}
