public ActionResult AddReactor(ReactorPO form)
{
ActionResult response = null;
int rowsAffected;
try
{
_logger.LogMessage("Info", "Add Reactor Post request", MethodBase.GetCurrentMethod().ToString(),
"Request to add Reactor information received.");
if (ModelState.IsValid)
{
_logger.LogMessage("Info", "Model State check passed", MethodBase.GetCurrentMethod().ToString(),
"ReactorPO form model state is valid.");
//If thermal and electric power entered, calculate efficiency with BLO
if (form.ThermalPower != 0 && form.ElectricPower != 0)
{
_logger.LogMessage("Attempting to calculate efficiency.");
ReactorBO reactorBO = Mapping.Mapper.ReactorPOtoBO(form);
form.Efficiency = _reactorBLO.CalculateEfficiency(reactorBO);
}
else
{
_logger.LogMessage("Thermal Power or Electric Power not provided. Did not calculate efficiency.");
}
_logger.LogMessage("Attempting to map Reactor PO to DO.");
ReactorDO reactorDO = Mapping.Mapper.ReactorPOtoDO(form);
rowsAffected = _reactorDAO.AddNewReactor(reactorDO);
if (rowsAffected > 0)
{
_logger.LogMessage("Info", "New reactor information added", MethodBase.GetCurrentMethod().ToString(),
form.Name + " reactor was added to database.");
TempData["addNew"] = "Reactor added successfully.";
}
else
{
_logger.LogMessage("Warning", "Add Reactor attempt failed", MethodBase.GetCurrentMethod().ToString(),
"Attempt to add new reactor showed no database rows affected.");
TempData["addNew"] = "Failed to add new reactor to database.";
}
response = RedirectToAction("Index");
}
else
{
_logger.LogMessage("Warning", "Model State check failed", MethodBase.GetCurrentMethod().ToString(),
"ReactorPO form model state was not valid. Returning user to View.");
FillGenerationDropDown(form);
FillModeratorDropDown(form);
response = View(form);
}
}
catch (Exception ex)
{
_logger.LogMessage(ex, "Fatal");
}
finally { }
return(response);
}
public List <ReactorDO> ObtainAllReactors()
{
List <ReactorDO> reactorList = new List <ReactorDO>();
SqlConnection connectionToSql = null;
SqlCommand obtainReactors = null;
SqlDataAdapter adapter = null;
DataTable reactorsTable = new DataTable();
try
{
//Instantiate SQL connection with connection string
connectionToSql = new SqlConnection(_connectionString);
//Instantiate SQL command for stored procedure to run
obtainReactors = new SqlCommand("OBTAIN_REACTORS", connectionToSql);
obtainReactors.CommandType = CommandType.StoredProcedure;
//Open connection to SQL
connectionToSql.Open();
//Instantiate Data Adapter to fill table with records obtained from query
adapter = new SqlDataAdapter(obtainReactors);
adapter.Fill(reactorsTable);
//Map each row to a Data Object, and create list of DOs for the method to return
foreach (DataRow row in reactorsTable.Rows)
{
ReactorDO reactorDO = Mapping.Mapper.ReactorTableRowToDO(row);
reactorList.Add(reactorDO);
}
}
catch (Exception ex)
{
//Log exceptions with DAL logger
_logger.LogMessage(ex, "Fatal");
throw ex;
}
finally
{
//Close and dispose of connection, and dispose adapter
if (connectionToSql != null)
{
connectionToSql.Close();
connectionToSql.Dispose();
}
else
{
}
if (adapter != null)
{
adapter.Dispose();
}
else
{
}
}
return(reactorList);
}
public int AddNewReactor(ReactorDO reactorDO)
{
int rowsAffected = 0;
SqlConnection connectionToSql = null;
SqlCommand addReactor = null;
try
{
//Logging informational messages
_logger.LogMessage("Info", "Add New Reactor start", MethodBase.GetCurrentMethod().ToString(),
"Request to add new reactor to database received.");
_logger.LogMessage("Instantiating SQL connection from connection string.");
connectionToSql = new SqlConnection(_connectionString);
_logger.LogMessage("Instantiating SQL command for stored procedure.");
addReactor = new SqlCommand("ADD_NEW_REACTOR", connectionToSql);
addReactor.CommandType = CommandType.StoredProcedure;
//Method that adds parameter values to stored procedure
_logger.LogMessage("Adding parameters to stored procedure.");
AddParameterValues(addReactor, reactorDO);
_logger.LogMessage("Opening SQL connection.");
connectionToSql.Open();
//Execute non query stored procedure and obtain number of rows affected
rowsAffected = addReactor.ExecuteNonQuery();
//Check whether data was added successfully, and log accordingly
if (rowsAffected > 0)
{
_logger.LogMessage("Info", "Nonquery completed", MethodBase.GetCurrentMethod().ToString(),
"New reactor information was added to the database.");
}
else
{
_logger.LogMessage("Warning", "No rows affected in nonquery", MethodBase.GetCurrentMethod().ToString(),
"Reactor information was not added to the database.");
}
}
catch (Exception ex)
{
_logger.LogMessage(ex, "Fatal");
throw ex;
}
finally
{
if (connectionToSql != null)
{
connectionToSql.Close();
connectionToSql.Dispose();
}
}
//Allow method to check for success from MVC as well
return(rowsAffected);
}
public ReactorDO ObtainReactorByID(int id)
{
ReactorDO reactorDO = null;
SqlConnection connectionToSql = null;
SqlCommand obtainReactorInfo = null;
SqlDataAdapter adapter = null;
DataTable reactorInfo = new DataTable();
try
{
connectionToSql = new SqlConnection(_connectionString);
obtainReactorInfo = new SqlCommand("OBTAIN_REACTOR_BY_ID", connectionToSql);
obtainReactorInfo.CommandType = CommandType.StoredProcedure;
obtainReactorInfo.Parameters.AddWithValue("@ReactorID", id);
connectionToSql.Open();
adapter = new SqlDataAdapter(obtainReactorInfo);
adapter.Fill(reactorInfo);
if (reactorInfo.Rows.Count > 0)
{
DataRow row = reactorInfo.Rows[0];
reactorDO = Mapping.Mapper.ReactorTableRowToDO(row);
}
else
{
_logger.LogMessage("Warning",
"Queried ID not found",
MethodBase.GetCurrentMethod().ToString(),
"Did not create reactorDO. No rows found in reactorInfo table.");
}
}
catch (Exception ex)
{
_logger.LogMessage(ex, "Fatal");
throw ex;
}
finally
{
if (connectionToSql != null)
{
connectionToSql.Close();
connectionToSql.Dispose();
}
if (adapter != null)
{
adapter.Dispose();
}
}
return(reactorDO);
}
public void UpdateReactor(ReactorDO reactorDO)
{
int rowsAffected = 0;
SqlConnection connectionToSql = null;
SqlCommand updateReactor = null;
try
{
_logger.LogMessage("Info", "Update Reactor start", MethodBase.GetCurrentMethod().ToString(),
"Request to update reactor with ID #" + reactorDO.ReactorID + " received.");
_logger.LogMessage("Instantiating SQL connection from connection string.");
connectionToSql = new SqlConnection(_connectionString);
_logger.LogMessage("Instantiating SQL command for stored procedure.");
updateReactor = new SqlCommand("UPDATE_REACTOR", connectionToSql);
updateReactor.CommandType = CommandType.StoredProcedure;
//Add parameters, including ID
_logger.LogMessage("Adding parameters to stored procedure.");
updateReactor.Parameters.AddWithValue("@ReactorID", reactorDO.ReactorID);
AddParameterValues(updateReactor, reactorDO);
_logger.LogMessage("Opening SQL connection.");
connectionToSql.Open();
rowsAffected = updateReactor.ExecuteNonQuery();
//Check whether the row was affected, and log accordingly
if (rowsAffected > 0)
{
_logger.LogMessage("Info", "Nonquery completed", MethodBase.GetCurrentMethod().ToString(),
"Reactor information was updated.");
}
else
{
_logger.LogMessage("Warning", "No rows affected in nonquery", MethodBase.GetCurrentMethod().ToString(),
"Reactor information was not updated.");
}
}
catch (Exception ex)
{
_logger.LogMessage(ex, "Fatal");
throw ex;
}
finally
{
if (connectionToSql != null)
{
connectionToSql.Close();
connectionToSql.Dispose();
}
}
}
public void AddParameterValues(SqlCommand storedProcedure, ReactorDO reactorDO)
{
//Adding parameter values to stored procedure from DO
//Check if nullable fields are null to pass DBNull
storedProcedure.Parameters.AddWithValue("@Name", reactorDO.Name);
storedProcedure.Parameters.AddWithValue("@FullName", (object)reactorDO.FullName ?? DBNull.Value);
storedProcedure.Parameters.AddWithValue("@IsThermal", reactorDO.IsThermal);
storedProcedure.Parameters.AddWithValue("@ModeratorID", (reactorDO.ModeratorID != 0) ? (object)reactorDO.ModeratorID : DBNull.Value);
storedProcedure.Parameters.AddWithValue("@PrimaryCoolant", reactorDO.PrimaryCoolant);
storedProcedure.Parameters.AddWithValue("@Fuel", reactorDO.Fuel);
storedProcedure.Parameters.AddWithValue("@ThermalPower", (reactorDO.ThermalPower != 0) ? (object)reactorDO.ThermalPower : DBNull.Value);
storedProcedure.Parameters.AddWithValue("@ElectricPower", (reactorDO.ElectricPower != 0) ? (object)reactorDO.ElectricPower : DBNull.Value);
storedProcedure.Parameters.AddWithValue("@Efficiency", (reactorDO.Efficiency != 0) ? (object)reactorDO.Efficiency : DBNull.Value);
storedProcedure.Parameters.AddWithValue("@Year", reactorDO.Year);
storedProcedure.Parameters.AddWithValue("@Generation", (object)reactorDO.Generation ?? DBNull.Value);
storedProcedure.Parameters.AddWithValue("@CountryOfOrigin", (object)reactorDO.CountryOfOrigin ?? DBNull.Value);
storedProcedure.Parameters.AddWithValue("@NumberActive", (reactorDO.NumberActive != 0) ? (object)reactorDO.NumberActive : DBNull.Value);
storedProcedure.Parameters.AddWithValue("@Notes", (object)reactorDO.Notes ?? DBNull.Value);
}
public ActionResult UpdateReactor(int id)
{
ReactorPO form = new ReactorPO();
try
{
_logger.LogMessage("Info", "Update Reactor Get request", MethodBase.GetCurrentMethod().ToString(),
"Request for update form for reactor with ID#" + id + " received.");
ReactorDO reactorDO = _reactorDAO.ObtainReactorByID(id);
form = Mapping.Mapper.ReactorDOtoPO(reactorDO);
FillGenerationDropDown(form);
FillModeratorDropDown(form);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally { }
return(View(form));
}
public static ReactorPO ReactorDOtoPO(ReactorDO from)
{
ReactorPO to = new ReactorPO();
to.ReactorID = from.ReactorID;
to.Name = from.Name;
to.FullName = from.FullName;
to.IsThermal = from.IsThermal;
to.ModeratorID = from.ModeratorID;
to.PrimaryCoolant = from.PrimaryCoolant;
to.Fuel = from.Fuel;
to.ThermalPower = from.ThermalPower;
to.ElectricPower = from.ElectricPower;
to.Efficiency = from.Efficiency;
to.Year = from.Year;
to.Generation = from.Generation;
to.CountryOfOrigin = from.CountryOfOrigin;
to.NumberActive = from.NumberActive;
to.Notes = from.Notes;
return(to);
}
public static ReactorDO ReactorTableRowToDO(DataRow row)
{
ReactorDO reactorDO = new ReactorDO();
reactorDO.ReactorID = int.Parse(row["ReactorID"].ToString());
reactorDO.Name = row["Name"].ToString().Trim();
reactorDO.FullName = row["FullName"].ToString().Trim();
reactorDO.IsThermal = bool.Parse(row["IsThermal"].ToString());
reactorDO.ModeratorID = (int.TryParse(row["ModeratorID"].ToString(), out int moderatorID)) ? moderatorID : default(int);
reactorDO.PrimaryCoolant = row["PrimaryCoolant"].ToString().Trim();
reactorDO.Fuel = row["Fuel"].ToString().Trim();
reactorDO.ThermalPower = (float.TryParse(row["ThermalPower"].ToString(), out float thermalPower)) ? thermalPower : default(float);
reactorDO.ElectricPower = (float.TryParse(row["ElectricPower"].ToString(), out float electricPower)) ? electricPower : default(float);
reactorDO.Efficiency = (float.TryParse(row["Efficiency"].ToString(), out float efficiency)) ? efficiency : default(float);
reactorDO.Year = int.Parse(row["Year"].ToString());
reactorDO.Generation = row["Generation"].ToString().Trim();
reactorDO.CountryOfOrigin = row["CountryOfOrigin"].ToString().Trim();
reactorDO.NumberActive = (int.TryParse(row["NumberActive"].ToString(), out int active)) ? active : default(int);
reactorDO.Notes = row["Notes"].ToString().Trim();
return(reactorDO);
}
public ActionResult ReactorDetails(int id)
{
ActionResult response = null;
try
{
ReactorDO reactorDO = _reactorDAO.ObtainReactorByID(id);
if (reactorDO != null)
{
_logger.LogMessage("Info", "Reactor Details", MethodBase.GetCurrentMethod().ToString(),
"User request to view details of reactor with ID #" + id + " is valid.");
ReactorPO reactorPO = Mapping.Mapper.ReactorDOtoPO(reactorDO);
if (reactorPO.ModeratorID != 0)
{
reactorPO.ModeratorName = _reactorDAO.ObtainModeratorNameByID(reactorPO.ModeratorID);
}
else
{
}
if (Session["ID"] != null)
{
List <BookmarkDO> bookmarkDOList = _bookmarkDAO.ObtainBookmarksByUserID(int.Parse(Session["ID"].ToString()));
if (bookmarkDOList.Count > 0)
{
List <int> bookmarkReactorIDs = new List <int>();
foreach (BookmarkDO bookmarkDO in bookmarkDOList)
{
bookmarkReactorIDs.Add(bookmarkDO.ReactorID);
}
if (bookmarkReactorIDs.Contains(id))
{
ViewBag.isBookmarked = true;
}
else
{
ViewBag.isBookmarked = false;
}
}
else
{
ViewBag.isBookmarked = false;
}
}
else
{
}
response = View(reactorPO);
}
else
{
_logger.LogMessage("Warning", "Page not found", MethodBase.GetCurrentMethod().ToString(),
"User attempted to navigate to ReactorDetails on null ID " + id + ". " +
"Redirecting to Index.");
TempData["idNotFound"] = "The page you were looking for could not be found." +
"You have been returned to the reactor list.";
response = RedirectToAction("Index");
}
}
catch (Exception ex)
{
_logger.LogMessage(ex, "Fatal");
}
finally { }
return(response);
}
