public void TestCreateMaintenanceWorkOrderValidInput()
{
//Arrange
MaintenanceWorkOrder newMaintenanceWorkOrder = new MaintenanceWorkOrder()
{
MaintenanceTypeID = "Plumbing", DateRequested = DateTime.Now, DateCompleted = DateTime.Now.AddDays(1), RequestingEmployeeID = 100000, WorkingEmployeeID = 100001, Description = "Created In Unit Test: TestCreateMaintenanceWorkOrderValidInput()", Comments = "Test Comment", MaintenanceStatusID = "Open", ResortPropertyID = 1, Complete = true
};
//Act
_maintenanceWorkOrderManager.AddMaintenanceWorkOrder(newMaintenanceWorkOrder);
//Assert
//Updates the list of MaintenanceWorkOrder
_maintenanceWorkOrders = _maintenanceWorkOrderManager.RetrieveAllMaintenanceWorkOrders();
//Checks to see if the new MaintenanceWorkOrder is in the updated list of MaintenanceWorkOrders
Assert.IsNotNull(_maintenanceWorkOrders.Find(x => x.MaintenanceTypeID == newMaintenanceWorkOrder.MaintenanceTypeID &&
x.MaintenanceStatusID == newMaintenanceWorkOrder.MaintenanceStatusID &&
x.DateRequested.Day == newMaintenanceWorkOrder.DateRequested.Day &&
x.RequestingEmployeeID == newMaintenanceWorkOrder.RequestingEmployeeID &&
x.WorkingEmployeeID == newMaintenanceWorkOrder.WorkingEmployeeID &&
x.Description == newMaintenanceWorkOrder.Description &&
x.Comments == newMaintenanceWorkOrder.Comments &&
x.ResortPropertyID == newMaintenanceWorkOrder.ResortPropertyID));
}
/// <summary>
/// Author: Dalton Cleveland
/// Created : 3/07/2019
/// This will update an existing work order or throw a new ArgumentException
/// </summary>
public void UpdateMaintenanceWorkOrder(MaintenanceWorkOrder oldMaintenanceWorkOrder, MaintenanceWorkOrder newMaintenanceWorkOrder)
{
bool updated = false;
foreach (var wo in _maintenanceWorkOrders)
{
if (wo.MaintenanceWorkOrderID == oldMaintenanceWorkOrder.MaintenanceWorkOrderID)
{
wo.MaintenanceTypeID = newMaintenanceWorkOrder.MaintenanceTypeID;
wo.MaintenanceStatusID = newMaintenanceWorkOrder.MaintenanceStatusID;
wo.DateRequested = newMaintenanceWorkOrder.DateRequested;
wo.DateCompleted = newMaintenanceWorkOrder.DateCompleted;
wo.RequestingEmployeeID = newMaintenanceWorkOrder.RequestingEmployeeID;
wo.WorkingEmployeeID = newMaintenanceWorkOrder.WorkingEmployeeID;
wo.Description = newMaintenanceWorkOrder.Description;
wo.Comments = newMaintenanceWorkOrder.Comments;
wo.ResortPropertyID = newMaintenanceWorkOrder.ResortPropertyID;
wo.Complete = newMaintenanceWorkOrder.Complete;
updated = true;
break;
}
}
if (!updated)
{
throw new ArgumentException("No Work Order was found to update");
}
}
/// <summary>
/// Author: Dalton Cleveland
/// Created : 2/21/2019
/// This Constructor requires a MaintenanceWorkOrder and an instance of the IRMaintenanceWorkOrderManager
/// </summary>
public DeactivateMaintenanceWorkOrder(MaintenanceWorkOrder maintenanceWorkOrder, IMaintenanceWorkOrderManager maintenanceWorkOrderManager)
{
InitializeComponent();
_maintenanceWorkOrderManager = maintenanceWorkOrderManager;
_maintenanceWorkOrder = maintenanceWorkOrder;
txtTitleContent.Text = "Are you sure you want to delete this Maintenance Work Order?";
txtBodyContent.Text = "Deleting this Item will remove it from our system. If you are unsure whether you should delete this please click cancel and ask your superior";
}
/// <summary>
/// Author: Dalton Cleveland
/// Created : 2/21/2019
/// This constructor is used for Creating a MaintenanceWorkOrder
/// Initializes connections to our MaintenanceWorkOrderManager
/// </summary>
public CreateMaintenanceWorkOrder(IMaintenanceWorkOrderManager maintenanceWorkOrderManager)
{
InitializeComponent();
_maintenanceTypeManager = new MaintenanceTypeManagerMSSQL();
_maintenanceStatusTypeManager = new MaintenanceStatusTypeManagerMSSQL();
_maintenanceWorkOrderManager = maintenanceWorkOrderManager;
try
{
_maintenanceTypes = _maintenanceTypeManager.RetrieveAllMaintenanceTypes();
}
catch (Exception ex)
{
SetError(ex.Message);
}
List <string> list1 = new List <string>();
if (_maintenanceTypes != null)
{
foreach (var item in _maintenanceTypes)
{
list1.Add(item.MaintenanceTypeID);
}
}
cboMaintenanceTypeID.ItemsSource = list1;
try
{
_maintenanceStatusTypes = _maintenanceStatusTypeManager.RetrieveAllMaintenanceStatusTypes();
}
catch (Exception ex)
{
SetError(ex.Message);
}
List <string> list2 = new List <string>();
if (_maintenanceStatusTypes != null)
{
foreach (var item in _maintenanceStatusTypes)
{
list2.Add(item.MaintenanceStatusID);
}
}
cboStatus.ItemsSource = list2;
chkComplete.IsEnabled = false;
chkComplete.IsChecked = true;
dpDateCompleted.IsEnabled = false;
dpDateCompleted.Equals(null);
dpDateRequested.IsEnabled = false;
dpDateRequested.Equals(DateTime.Now);
cboStatus.SelectedItem = "Open";
cboStatus.IsEnabled = false;
txtComments.IsEnabled = false;
txtComments.Equals(null);
_existingMaintenanceWorkOrder = null;
}
public ActionResult Create(MaintenanceWorkOrder workOrder)
{
workOrder.CreatedDateTime = DateTime.Now;
workOrder.LastStatusDateTime = DateTime.Now;
workOrder.MaintenanceStatusId = 0;
_context.MaintenanceWorkOrders.Add(workOrder);
_context.SaveChanges();
return(RedirectToAction("Index", "Maintenance"));
}
public void TestUpdateMaintenanceWorkOrderInValidResortPropertyID()
{
//Arrange
MaintenanceWorkOrder newMaintenanceWorkOrder = new MaintenanceWorkOrder();
setMaintenanceWorkOrders(_maintenanceWorkOrders[0], newMaintenanceWorkOrder);
newMaintenanceWorkOrder.ResortPropertyID = -1;
//Act
_maintenanceWorkOrderManager.EditMaintenanceWorkOrder(_maintenanceWorkOrders[0], newMaintenanceWorkOrder);
}
public void TestUpdateMaintenanceWorkOrderInValidWorkingEmployeeID()
{
//Arrange
MaintenanceWorkOrder newMaintenanceWorkOrder = new MaintenanceWorkOrder();
setMaintenanceWorkOrders(_maintenanceWorkOrders[0], newMaintenanceWorkOrder);
newMaintenanceWorkOrder.WorkingEmployeeID = -1;
//Act
_maintenanceWorkOrderManager.EditMaintenanceWorkOrder(_maintenanceWorkOrders[0], newMaintenanceWorkOrder);
}
/// <summary>
/// Author: Dalton Cleveland
/// Created : 3/07/2019
/// This will search for a work order with a matching work order ID from our mock data
/// </summary>
public MaintenanceWorkOrder RetrieveMaintenanceWorkOrder(int MaintenanceWorkOrderID)
{
MaintenanceWorkOrder w = new MaintenanceWorkOrder();
w = _maintenanceWorkOrders.Find(x => x.MaintenanceWorkOrderID == MaintenanceWorkOrderID);
if (w == null)
{
throw new ArgumentException("MaintenanceWorkOrderID did not match any MaintenanceWorkOrders in our System");
}
return(w);
}
public void TestRetrieveMaintenanceWorkOrderInValidInput()
{
//Arrange
MaintenanceWorkOrder newMaintenanceWorkOrder = new MaintenanceWorkOrder();
int invalidMaintenanceWorkOrderID = -1;
//Act
newMaintenanceWorkOrder = _maintenanceWorkOrderManager.RetrieveMaintenanceWorkOrder(invalidMaintenanceWorkOrderID);
//Assert
//Assert.AreEqual(newMaintenanceWorkOrder.MaintenanceWorkOrderID, 0);
}
public void TestUpdateMaintenanceWorkOrderInValidDescription()
{
//Arrange
MaintenanceWorkOrder newMaintenanceWorkOrder = new MaintenanceWorkOrder();
setMaintenanceWorkOrders(_maintenanceWorkOrders[0], newMaintenanceWorkOrder);
string newDescription = "This test is updating the description in TestUpdateMaintenanceWorkOrderValidDescription()" + createLongString(1001);
newMaintenanceWorkOrder.Description = newDescription;
//Act
_maintenanceWorkOrderManager.EditMaintenanceWorkOrder(_maintenanceWorkOrders[0], newMaintenanceWorkOrder);
}
public void TestCreateMaintenanceWorkOrderInValidInputMaintenanceResortID()
{
//Arrange
MaintenanceWorkOrder newMaintenanceWorkOrder = new MaintenanceWorkOrder()
{
MaintenanceTypeID = "Plumbing", DateRequested = DateTime.Now, DateCompleted = DateTime.Now.AddDays(1), RequestingEmployeeID = 100000, WorkingEmployeeID = 100000, Description = "Created In Unit Test: TestCreateMaintenanceWorkOrderInValidInputMaintenanceResortID()", Comments = "Test Comment", MaintenanceStatusID = "Open", ResortPropertyID = -1, Complete = true
};
//Act
//Since Status is invalid, this should throw an Exception
_maintenanceWorkOrderManager.AddMaintenanceWorkOrder(newMaintenanceWorkOrder);
}
private void setMaintenanceWorkOrders(MaintenanceWorkOrder oldMaintenanceWorkOrder, MaintenanceWorkOrder newMaintenanceWorkOrder)
{
newMaintenanceWorkOrder.MaintenanceWorkOrderID = oldMaintenanceWorkOrder.MaintenanceWorkOrderID;
newMaintenanceWorkOrder.MaintenanceTypeID = oldMaintenanceWorkOrder.MaintenanceTypeID;
newMaintenanceWorkOrder.MaintenanceStatusID = oldMaintenanceWorkOrder.MaintenanceStatusID;
newMaintenanceWorkOrder.DateRequested = oldMaintenanceWorkOrder.DateRequested;
newMaintenanceWorkOrder.DateCompleted = oldMaintenanceWorkOrder.DateCompleted;
newMaintenanceWorkOrder.RequestingEmployeeID = oldMaintenanceWorkOrder.RequestingEmployeeID;
newMaintenanceWorkOrder.WorkingEmployeeID = oldMaintenanceWorkOrder.WorkingEmployeeID;
newMaintenanceWorkOrder.Description = oldMaintenanceWorkOrder.Description;
newMaintenanceWorkOrder.Comments = oldMaintenanceWorkOrder.Comments;
newMaintenanceWorkOrder.ResortPropertyID = oldMaintenanceWorkOrder.ResortPropertyID;
newMaintenanceWorkOrder.Complete = oldMaintenanceWorkOrder.Complete;
}
/// <summary>
/// Author: Dalton Cleveland
/// Created : 2/21/2019
/// Update Work Order will attempt to update the Work Order from our MSSQL database
/// </summary>
public void UpdateMaintenanceWorkOrder(MaintenanceWorkOrder oldMaintenanceWorkOrder, MaintenanceWorkOrder newMaintenanceWorkOrder)
{
// get a connection
var conn = DBConnection.GetDbConnection();
// command text
string cmdText1 = @"sp_update_work_order";
// command objects
var cmd1 = new SqlCommand(cmdText1, conn);
// set the command type
cmd1.CommandType = CommandType.StoredProcedure;
// parameters
cmd1.Parameters.AddWithValue("@MaintenanceWorkOrderID", oldMaintenanceWorkOrder.MaintenanceWorkOrderID);
cmd1.Parameters.AddWithValue("@oldDateRequested", oldMaintenanceWorkOrder.DateRequested);
cmd1.Parameters.AddWithValue("@oldMaintenanceTypeID", oldMaintenanceWorkOrder.MaintenanceTypeID);
cmd1.Parameters.AddWithValue("@oldRequestingEmployeeID", oldMaintenanceWorkOrder.RequestingEmployeeID);
cmd1.Parameters.AddWithValue("@oldWorkingEmployeeID", oldMaintenanceWorkOrder.WorkingEmployeeID);
cmd1.Parameters.AddWithValue("@oldDescription", oldMaintenanceWorkOrder.Description);
cmd1.Parameters.AddWithValue("@oldMaintenanceStatusID", oldMaintenanceWorkOrder.MaintenanceStatusID);
cmd1.Parameters.AddWithValue("@oldResortPropertyID", oldMaintenanceWorkOrder.ResortPropertyID);
cmd1.Parameters.AddWithValue("@oldComplete", oldMaintenanceWorkOrder.Complete);
cmd1.Parameters.AddWithValue("@newMaintenanceTypeID", newMaintenanceWorkOrder.MaintenanceTypeID);
cmd1.Parameters.AddWithValue("@newRequestingEmployeeID", newMaintenanceWorkOrder.RequestingEmployeeID);
cmd1.Parameters.AddWithValue("@newWorkingEmployeeID", newMaintenanceWorkOrder.WorkingEmployeeID);
cmd1.Parameters.AddWithValue("@newDescription", newMaintenanceWorkOrder.Description);
cmd1.Parameters.AddWithValue("@newComments", newMaintenanceWorkOrder.Comments);
cmd1.Parameters.AddWithValue("@newMaintenanceStatusID", newMaintenanceWorkOrder.MaintenanceStatusID);
cmd1.Parameters.AddWithValue("@newResortPropertyID", newMaintenanceWorkOrder.ResortPropertyID);
cmd1.Parameters.AddWithValue("@newComplete", newMaintenanceWorkOrder.Complete);
try
{
// open the connection
conn.Open();
// execute the command
cmd1.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
}
public void TestUpdateMaintenanceWorkOrderValidDescription()
{
//Arrange
MaintenanceWorkOrder newMaintenanceWorkOrder = new MaintenanceWorkOrder();
setMaintenanceWorkOrders(_maintenanceWorkOrders[0], newMaintenanceWorkOrder);
string newDescription = "This test is updating the description in TestUpdateMaintenanceWorkOrderValidDescription()";
newMaintenanceWorkOrder.Description = newDescription;
//Act
_maintenanceWorkOrderManager.EditMaintenanceWorkOrder(_maintenanceWorkOrders[0], newMaintenanceWorkOrder);
//Assert
_maintenanceWorkOrders = _maintenanceWorkOrderManager.RetrieveAllMaintenanceWorkOrders();
Assert.AreEqual(_maintenanceWorkOrderManager.RetrieveMaintenanceWorkOrder(_maintenanceWorkOrders[0].MaintenanceWorkOrderID).Description, newDescription);
}
/// <summary author="Dalton Cleveland" created="2019/02/21">
/// Returns a MaintenanceWorkOrder from a MaintenanceWorkOrderAccessor or throws an error if there was a problem
/// </summary>
public MaintenanceWorkOrder RetrieveMaintenanceWorkOrder(int MaintenanceWorkOrderID)
{
MaintenanceWorkOrder maintenanceWorkOrder = new MaintenanceWorkOrder();
try
{
maintenanceWorkOrder = _maintenanceWorkOrderAccessor.RetrieveMaintenanceWorkOrder(MaintenanceWorkOrderID);
}
catch (Exception ex)
{
ExceptionLogManager.getInstance().LogException(ex);
throw new ArgumentException("MaintenanceWorkOrderID did not match any MaintenanceWorkOrders in our System");
}
return(maintenanceWorkOrder);
}
/// <summary author="Dalton Cleveland" created="2019/02/21">
/// Sends Existing MaintenanceWorkOrder data along with the new MaintenanceWorkOrder data to MaintenanceWorkOrder Accessor. Returns an error if update fails
/// </summary>
public void EditMaintenanceWorkOrder(MaintenanceWorkOrder oldMaintenanceWorkOrder, MaintenanceWorkOrder newMaintenanceWorkOrder)
{
try
{
if (!newMaintenanceWorkOrder.IsValid())
{
throw new ArgumentException("Data for this new MaintenanceWorkOrder is not valid");
}
_maintenanceWorkOrderAccessor.UpdateMaintenanceWorkOrder(oldMaintenanceWorkOrder, newMaintenanceWorkOrder);
}
catch (Exception ex)
{
ExceptionLogManager.getInstance().LogException(ex);
throw ex;
}
}
/// <summary>
/// Author: Dalton Cleveland
/// Created : 2/21/2019
/// This constructor is used for Reading and Updating a MaintenanceWorkOrder
/// </summary>
public CreateMaintenanceWorkOrder(MaintenanceWorkOrder existingMaintenanceWorkOrder, IMaintenanceWorkOrderManager maintenanceWorkOrderManager)
{
InitializeComponent();
_maintenanceWorkOrderManager = maintenanceWorkOrderManager;
_maintenanceTypeManager = new MaintenanceTypeManagerMSSQL();
_maintenanceStatusTypeManager = new MaintenanceStatusTypeManagerMSSQL();
try
{
_maintenanceTypes = _maintenanceTypeManager.RetrieveAllMaintenanceTypes();
}
catch (Exception ex)
{
SetError(ex.Message);
}
List <string> list1 = new List <string>();
foreach (var item in _maintenanceTypes)
{
list1.Add(item.MaintenanceTypeID);
}
cboMaintenanceTypeID.ItemsSource = list1;
try
{
_maintenanceStatusTypes = _maintenanceStatusTypeManager.RetrieveAllMaintenanceStatusTypes();
}
catch (Exception ex)
{
SetError(ex.Message);
}
List <string> list2 = new List <string>();
foreach (var item in _maintenanceStatusTypes)
{
list2.Add(item.MaintenanceStatusID);
}
cboStatus.ItemsSource = list2;
dpDateCompleted.IsEnabled = false;
dpDateCompleted.Equals(null);
dpDateRequested.IsEnabled = false;
dpDateRequested.Equals(DateTime.Now);
_existingMaintenanceWorkOrder = existingMaintenanceWorkOrder;
populateFormReadOnly();
}
/// <summary author="Dalton Cleveland" created="2019/02/21">
/// Passes along a MaintenanceWorkOrder object to our MaintenanceWorkOrderAccessorMSSQL to be stored in our database
public void AddMaintenanceWorkOrder(MaintenanceWorkOrder newMaintenanceWorkOrder)
{
try
{
//Double Check the MaintenanceWorkOrder is Valid
if (!newMaintenanceWorkOrder.IsValid())
{
throw new ArgumentException("Data for this MaintenanceWorkOrder is not valid");
}
_maintenanceWorkOrderAccessor.CreateMaintenanceWorkOrder(newMaintenanceWorkOrder);
}
catch (Exception ex)
{
ExceptionLogManager.getInstance().LogException(ex);
throw ex;
}
}
/// <summary>
/// Author: Dalton Cleveland
/// Created : 2/21/2019
/// The function which runs when the view MaintenanceWorkOrder button is clicked.
/// It will launch the CreateMaintenanceWorkOrder window in view mode with the option of updating
/// </summary>
private void btnViewMaintenanceWorkOrder_Click(object sender, RoutedEventArgs e)
{
if (dgMaintenanceWorkOrders.SelectedIndex != -1)
{
MaintenanceWorkOrder selectedMaintenanceWorkOrder = new MaintenanceWorkOrder();
try
{
selectedMaintenanceWorkOrder = _maintenanceWorkOrderManager.RetrieveMaintenanceWorkOrder(((MaintenanceWorkOrder)dgMaintenanceWorkOrders.SelectedItem).MaintenanceWorkOrderID);
var readUpdateMaintenanceWorkOrder = new CreateMaintenanceWorkOrder(selectedMaintenanceWorkOrder, _maintenanceWorkOrderManager);
readUpdateMaintenanceWorkOrder.ShowDialog();
refreshAllMaintenanceWorkOrders();
populateMaintenanceWorkOrders();
}
catch (Exception ex)
{
MessageBox.Show("Unable to find that Maintenance Work Order\n" + ex.Message);
}
}
}
private void selectMaintenanceTicket()
{
MaintenanceWorkOrder ticket = (MaintenanceWorkOrder)dgBuildingMaintenance.SelectedItem;
var detailForm = new CreateMaintenanceWorkOrder(ticket, maintenanceManager);
var formUpdated = detailForm.ShowDialog();
if (formUpdated == true)
{
try
{
setUpMaintainanceTab();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
public void TestRetrieveMaintenanceWorkOrderValidInput()
{
//Arrange
MaintenanceWorkOrder newMaintenanceWorkOrder = new MaintenanceWorkOrder();
//Act
newMaintenanceWorkOrder = _maintenanceWorkOrderManager.RetrieveMaintenanceWorkOrder(_maintenanceWorkOrders[0].MaintenanceWorkOrderID);
//Assert
Assert.AreEqual(newMaintenanceWorkOrder.MaintenanceWorkOrderID, _maintenanceWorkOrders[0].MaintenanceWorkOrderID);
Assert.AreEqual(newMaintenanceWorkOrder.MaintenanceTypeID, _maintenanceWorkOrders[0].MaintenanceTypeID);
Assert.AreEqual(newMaintenanceWorkOrder.MaintenanceStatusID, _maintenanceWorkOrders[0].MaintenanceStatusID);
Assert.AreEqual(newMaintenanceWorkOrder.DateRequested.Day, _maintenanceWorkOrders[0].DateRequested.Day);
Assert.AreEqual(newMaintenanceWorkOrder.RequestingEmployeeID, _maintenanceWorkOrders[0].RequestingEmployeeID);
Assert.AreEqual(newMaintenanceWorkOrder.WorkingEmployeeID, _maintenanceWorkOrders[0].WorkingEmployeeID);
Assert.AreEqual(newMaintenanceWorkOrder.Description, _maintenanceWorkOrders[0].Description);
Assert.AreEqual(newMaintenanceWorkOrder.Comments, _maintenanceWorkOrders[0].Comments);
Assert.AreEqual(newMaintenanceWorkOrder.ResortPropertyID, _maintenanceWorkOrders[0].ResortPropertyID);
}
/// <summary>
/// Author: Dalton Cleveland
/// Created : 02/14/2019
/// Creates a Work Order for the MaintenanceWorkOrder Table in our Microsoft SQL Server
/// </summary>
public void CreateMaintenanceWorkOrder(MaintenanceWorkOrder newMaintenanceWorkOrder)
{
// get a connection
var conn = DBConnection.GetDbConnection();
// command text
string cmdText1 = @"sp_create_work_order";
// command objects
var cmd1 = new SqlCommand(cmdText1, conn);
// set the command type
cmd1.CommandType = CommandType.StoredProcedure;
// parameters
//We do not have a MaintenanceWorkOrderID since we have not created the Work Order in our database yet
cmd1.Parameters.AddWithValue("@MaintenanceTypeID", newMaintenanceWorkOrder.MaintenanceTypeID);
cmd1.Parameters.AddWithValue("@DateRequested", DateTime.Now);
cmd1.Parameters.AddWithValue("@RequestingEmployeeID", newMaintenanceWorkOrder.RequestingEmployeeID);
cmd1.Parameters.AddWithValue("@WorkingEmployeeID", newMaintenanceWorkOrder.WorkingEmployeeID);
cmd1.Parameters.AddWithValue("@Description", newMaintenanceWorkOrder.Description);
cmd1.Parameters.AddWithValue("@MaintenanceStatusID", newMaintenanceWorkOrder.MaintenanceStatusID);
cmd1.Parameters.AddWithValue("@ResortPropertyID", newMaintenanceWorkOrder.ResortPropertyID);
try
{
// open the connection
conn.Open();
// execute the command
cmd1.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
}
/// <summary>
/// Author: Dalton Cleveland
/// Created : 2/21/2019
/// Retrieve All Work Orders will attempt to select and return every single Work Order from our MSSQL database in the form of a List
/// </summary>
public MaintenanceWorkOrder RetrieveMaintenanceWorkOrder(int MaintenanceWorkOrderID)
{
MaintenanceWorkOrder maintenanceWorkOrder = new MaintenanceWorkOrder();
// get a connection
var conn = DBConnection.GetDbConnection();
// command text
string cmdText = @"sp_select_work_order_by_id";
// command objects
var cmd1 = new SqlCommand(cmdText, conn);
// set the command type
cmd1.CommandType = CommandType.StoredProcedure;
// parameters
//We do not have a WorkOrderID since we have not created the WorkOrder in our database yet
cmd1.Parameters.AddWithValue("@MaintenanceWorkOrderID", MaintenanceWorkOrderID);
try
{
conn.Open();
SqlDataReader reader = cmd1.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
maintenanceWorkOrder.MaintenanceWorkOrderID = reader.GetInt32(0);
maintenanceWorkOrder.MaintenanceTypeID = reader.GetString(1);
maintenanceWorkOrder.DateRequested = reader.GetDateTime(2);
if (reader.IsDBNull(3))
{
maintenanceWorkOrder.DateCompleted = null;
}
else
{
maintenanceWorkOrder.DateCompleted = reader.GetDateTime(3);
}
maintenanceWorkOrder.RequestingEmployeeID = reader.GetInt32(4);
maintenanceWorkOrder.WorkingEmployeeID = reader.GetInt32(5);
maintenanceWorkOrder.Description = reader.GetString(6);
if (reader.IsDBNull(7))
{
maintenanceWorkOrder.Comments = null;
}
else
{
maintenanceWorkOrder.Comments = reader.GetString(7);
}
maintenanceWorkOrder.MaintenanceStatusID = reader.GetString(8);
maintenanceWorkOrder.ResortPropertyID = reader.GetInt32(9);
maintenanceWorkOrder.Complete = reader.GetBoolean(10);
break;
}
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return(maintenanceWorkOrder);
}
/// <summary>
/// Author: Dalton Cleveland
/// Created : 3/07/2019
/// This will create a work order using the data provided in the newWorkOrder
/// </summary>
public void CreateMaintenanceWorkOrder(MaintenanceWorkOrder newMaintenanceWorkOrder)
{
_maintenanceWorkOrders.Add(newMaintenanceWorkOrder);
}
public ActionResult MakeRequest(PartsRequestViewModel formData)
{
//get information from form here:
string value;
int keyNumber;
string[] keySplit;
bool refresh = false;
List <RequestLineStruct> requestLines = new List <RequestLineStruct>();
RequestLineStruct requestLine = new RequestLineStruct()
{
Number = 0, Note = "", PartId = 0
};
foreach (var key in Request.Form.AllKeys)
{
value = Request.Form.Get(key);
if (key == "refresh")
{
refresh = true;
System.Diagnostics.Debug.WriteLine("Refresh");
}
else if (key == "place")
{
System.Diagnostics.Debug.WriteLine("Place");
}
else if ((key.StartsWith("RequestLine.") && (value != "0")) ||
(key.StartsWith("Note.") && (requestLine.Note == null)) ||
(key.StartsWith("Part.") && (value != "0")) ||
(key.StartsWith("PartId.")))
{
keySplit = key.Split('.');
keyNumber = Int32.Parse(keySplit[1]);
if (keySplit[0] == "RequestLine") // Take advantage of always having the order of requestLine, Note and PartId in same order...
{
if (value != "0")
{
requestLine.Number = Int32.Parse(value);
requestLine.PartId = null;
requestLine.Note = null;
}
else
{
requestLine.Number = 0;
requestLine.PartId = 0;
requestLine.Note = "";
}
}
else if (keySplit[0] == "Note" && requestLine.Note == null)
{
requestLine.Note = value ?? "";
}
else if (keySplit[0] == "PartId" && requestLine.PartId == null)
{
requestLine.PartId = Int32.Parse(value);
requestLines.Add(requestLine);
}
else if (keySplit[0] == "Part" && value != "0")
{
requestLine.PartId = keyNumber;
requestLine.Number = Int32.Parse(value);
requestLine.Note = "";
requestLines.Add(requestLine);
}
}
}
List <int> partIdList = new List <int>();
List <int> numberList = new List <int>();
List <string> noteList = new List <string>();
List <StockRoomRequestLine> requestLineList = new List <StockRoomRequestLine>();
StockRoomRequestLine requestLineLine;
var manufacturerPart = _context.ManufacturerParts.ToList();
object stockRoomRequest = null;
if (formData != null && formData.PartRequestNumber != null)
{
stockRoomRequest = _context.StockRoomRequests.Single(r => r.Id == (int)formData.PartRequestNumber);
}
for (int i = 0; i < requestLines.Count; i++)
{
requestLine = requestLines[i];
requestLineLine = new StockRoomRequestLine();
requestLineLine.ManufacturerPart = manufacturerPart.Single(p => p.Id == requestLine.PartId);
requestLineLine.ManufacturerPartId = requestLineLine.ManufacturerPart.Id;
requestLineLine.Description = requestLine.Note;
requestLineLine.Number = requestLine.Number;
requestLineLine.Id = i;
if (stockRoomRequest != null)
{
requestLineLine.StockRoomRequest = (StockRoomRequest)stockRoomRequest;
requestLineLine.StockRoomRequestId = requestLineLine.StockRoomRequest.Id;
}
requestLineList.Add(requestLineLine);
}
if (refresh)
{
JobPlanViewModel buildModel = new JobPlanViewModel()
{
WorkOrderNumber = formData.WorkOrderNumber,
JobPlanId = formData.JobPlanNumber,
};
var viewModel = BuildPartsViewModel(buildModel);
viewModel.RequestLines = requestLineList;
if (formData.PartRequestNumber != null)
{
viewModel.PartRequestNumber = formData.PartRequestNumber;
}
return(View("PartsRequest", viewModel));
}
else
{
if (formData != null && formData.PartRequestNumber != null) // save changed record
{
int requestId = (int)formData.PartRequestNumber;
var stockRoomRequestLines = _context.StockroomRequestLines;
var requestRecords = stockRoomRequestLines.Where(r => r.StockRoomRequestId == requestId).ToList();
StockRoomRequestLine record;
foreach (var line in requestLineList) // Change or add first
{
record = requestRecords.SingleOrDefault(r => r.ManufacturerPartId == line.ManufacturerPartId);
if (record != null)
{
record.Description = line.Description;
record.Number = line.Number;
}
else
{
stockRoomRequestLines.Add(line);
}
}
_context.SaveChanges();
bool done = false;
while (!done)
{
requestRecords = stockRoomRequestLines.Where(r => r.StockRoomRequestId == requestId).ToList();
bool doDelete;
foreach (var line in requestRecords) // Delete ones no longer needed
{
doDelete = true;
done = true;
foreach (var request in requestLineList)
{
if (request.ManufacturerPartId == line.ManufacturerPartId)
{
doDelete = false;
break;
}
}
if (doDelete)
{
var itemToRemove = _context.StockroomRequestLines.SingleOrDefault(x => x.Id == line.Id);
if (itemToRemove != null)
{
_context.StockroomRequestLines.Remove(itemToRemove);
_context.SaveChanges();
}
System.Diagnostics.Debug.WriteLine("Delete Record");
done = false;
break;
}
}
}
}
else // new record
{
// create a request first and get the id for it.
int workOrderNumber;
MaintenanceWorkOrder workOrder = null;
Worker worker = null;
var workers = _context.Workers.ToList();
StockRoomRequest newStockRoomRequest = new StockRoomRequest()
{
StockRoomRequestStatus = _context.StockRoomRequestStatuses.Single(i => i.Id == 0),
Requested = DateTime.Now,
Required = DateTime.Now.AddDays(14),
Approval = false
};
newStockRoomRequest.StockRoomRequestStatusId = newStockRoomRequest.Id;
if (formData != null && formData.WorkOrderNumber != null)
{
workOrderNumber = (int)formData.WorkOrderNumber;
workOrder = _context.MaintenanceWorkOrders.Single(id => id.Id == workOrderNumber);
if (workOrder.LeadWorkerId != null)
{
worker = workers.Single(i => i.Id == workOrder.LeadWorker.Id);
newStockRoomRequest.Worker = worker;
newStockRoomRequest.WorkerId = worker.Id;
}
newStockRoomRequest.MaintenanceWorkOrder = workOrder;
newStockRoomRequest.MaintenanceWorkOrderId = workOrder.Id;
}
else
{
// Will be replaced when logins are possible
Random rand = new Random();
Worker rndWorker = workers.ElementAt(rand.Next(_context.Workers.Count()));
newStockRoomRequest.Worker = rndWorker;
newStockRoomRequest.WorkerId = newStockRoomRequest.Worker.Id;
}
_context.StockRoomRequests.Add(newStockRoomRequest);
_context.SaveChanges();
int requestId = newStockRoomRequest.Id; // Id of new request
StockRoomRequest tempStockRoomRequest = _context.StockRoomRequests.Single(i => i.Id == requestId);
foreach (var line in requestLineList)
{
line.StockRoomRequest = tempStockRoomRequest;
line.StockRoomRequestId = tempStockRoomRequest.Id;
_context.StockroomRequestLines.Add(line);
}
_context.SaveChanges();
}
}
return(RedirectToAction("Index", "Maintenance"));
}
/// <summary>
/// Author: Dalton Cleveland
/// Created : 1/31/2019
/// The function which runs when Save is clicked
/// </summary>
private void btnSave_Click(object sender, RoutedEventArgs e)
{
if (((string)btnSave.Content) == "Submit")
{
if (!ValidateInput())
{
return;
}
MaintenanceWorkOrder newMaintenanceWorkOrder = new MaintenanceWorkOrder();
newMaintenanceWorkOrder.MaintenanceTypeID = (cboMaintenanceTypeID.SelectedItem.ToString());
newMaintenanceWorkOrder.DateRequested = DateTime.Now;
newMaintenanceWorkOrder.RequestingEmployeeID = int.Parse(txtRequestingEmployeeID.Text);
newMaintenanceWorkOrder.WorkingEmployeeID = int.Parse(txtWorkingEmployeeID.Text);
newMaintenanceWorkOrder.ResortPropertyID = int.Parse(txtResortPropertyID.Text);
newMaintenanceWorkOrder.MaintenanceStatusID = cboStatus.SelectedItem.ToString();
newMaintenanceWorkOrder.Comments = txtComments.Text;
newMaintenanceWorkOrder.Description = txtDescription.Text;
try
{
if (_existingMaintenanceWorkOrder == null)
{
_maintenanceWorkOrderManager.AddMaintenanceWorkOrder(newMaintenanceWorkOrder);
SetError("");
MessageBox.Show("Maintenance Work Order Created Successfully: " +
"\nMaintenanceTypeID: " + newMaintenanceWorkOrder.MaintenanceTypeID +
"\nRequestingEmployeeID: " + newMaintenanceWorkOrder.RequestingEmployeeID +
"\nWorkingEmployeeID: " + newMaintenanceWorkOrder.WorkingEmployeeID +
"\nResortPropertyID: " + newMaintenanceWorkOrder.ResortPropertyID +
"\nMaintenanceStatus: " + newMaintenanceWorkOrder.MaintenanceStatusID +
"\nDescription: " + newMaintenanceWorkOrder.Description);
}
else
{
newMaintenanceWorkOrder.Complete = (bool)chkComplete.IsChecked;
_maintenanceWorkOrderManager.EditMaintenanceWorkOrder(_existingMaintenanceWorkOrder, newMaintenanceWorkOrder);
newMaintenanceWorkOrder.DateCompleted = DateTime.Now;
SetError("");
MessageBox.Show("Maintenance Work Order Updated Successfully: " +
"\nOld MaintenanceTypeID: " + _existingMaintenanceWorkOrder.MaintenanceTypeID +
"\nOld DateRequested: " + _existingMaintenanceWorkOrder.DateRequested +
"\nOld RequestingEmployeeID: " + _existingMaintenanceWorkOrder.RequestingEmployeeID +
"\nOld WorkingEmployeeID: " + _existingMaintenanceWorkOrder.WorkingEmployeeID +
"\nOld ResortPropertyID: " + _existingMaintenanceWorkOrder.ResortPropertyID +
"\nOldMaintenanceStatusID: " + _existingMaintenanceWorkOrder.MaintenanceStatusID +
"\nOld Description: " + _existingMaintenanceWorkOrder.Description +
"\n" +
"\nNew MaintenanceTypeID: " + newMaintenanceWorkOrder.MaintenanceTypeID +
"\nNew DateCompleted: " + newMaintenanceWorkOrder.DateCompleted +
"\nNew RequestingEmployeeID: " + newMaintenanceWorkOrder.RequestingEmployeeID +
"\nNew WorkingEmployeeID: " + newMaintenanceWorkOrder.WorkingEmployeeID +
"\nNew ResortPropertyID: " + newMaintenanceWorkOrder.ResortPropertyID +
"\nNew MaintenanceStatusID: " + newMaintenanceWorkOrder.MaintenanceStatusID +
"\nNew Comments: " + newMaintenanceWorkOrder.Comments +
"\nNew Description: " + newMaintenanceWorkOrder.Description);
}
}
catch (Exception ex)
{
SetError(ex.Message);
}
Close();
}
else if (((string)btnSave.Content) == "Update")
{
setEditable();
}
else
{
MessageBox.Show(btnSave.Content.GetType() + " " + btnSave.Content);
}
}
/// <summary>
/// Author: Dalton Cleveland
/// Created : 2/21/2019
/// Retrieve All Work Orders will attempt to select and return every single Work Order from our MSSQL database in the form of a List
/// </summary>
public List <MaintenanceWorkOrder> RetrieveAllMaintenanceWorkOrders()
{
List <MaintenanceWorkOrder> maintenanceWorkOrders = new List <MaintenanceWorkOrder>();
// get a connection
var conn = DBConnection.GetDbConnection();
// command text
string cmdText = @"sp_select_all_work_orders";
// command objects
var cmd = new SqlCommand(cmdText, conn);
// set the command type
cmd.CommandType = CommandType.StoredProcedure;
try
{
conn.Open();
SqlDataReader reader = cmd.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
MaintenanceWorkOrder maintenanceWorkOrder = new MaintenanceWorkOrder();
maintenanceWorkOrder.MaintenanceWorkOrderID = reader.GetInt32(0);
maintenanceWorkOrder.MaintenanceTypeID = reader.GetString(1);
maintenanceWorkOrder.DateRequested = reader.GetDateTime(2);
if (reader.IsDBNull(3))
{
maintenanceWorkOrder.DateCompleted = null;
}
else
{
maintenanceWorkOrder.DateCompleted = reader.GetDateTime(3);
}
maintenanceWorkOrder.RequestingEmployeeID = reader.GetInt32(4);
maintenanceWorkOrder.WorkingEmployeeID = reader.GetInt32(5);
maintenanceWorkOrder.Description = reader.GetString(6);
if (reader.IsDBNull(7))
{
maintenanceWorkOrder.Comments = null;
}
else
{
maintenanceWorkOrder.Comments = reader.GetString(7);
}
maintenanceWorkOrder.MaintenanceStatusID = reader.GetString(8);
maintenanceWorkOrder.ResortPropertyID = reader.GetInt32(9);
maintenanceWorkOrder.Complete = reader.GetBoolean(10);
maintenanceWorkOrders.Add(maintenanceWorkOrder);
}
}
}
catch (Exception)
{
throw;
}
finally
{
conn.Close();
}
return(maintenanceWorkOrders);
}
