public DAL.Communicator ConvertToData(DOM.Communicator domainModel)
{
{
if (domainModel is DOM.SerialCommunicator)
{
return ConvertToData((DOM.SerialCommunicator)domainModel);
}
else if (domainModel is DOM.FileCommunicator)
{
return ConvertToData((DOM.FileCommunicator)domainModel);
}
else if (domainModel is DOM.DatabaseCommunicator)
{
return ConvertToData((DOM.DatabaseCommunicator)domainModel);
}
return null;
}
}
/// <summary>
/// Adds a new Device to the MongoDB database.
/// </summary>
/// <param name="device"></param>
public void AddNewDevice(DOM.Device device)
{
_controller.AddNewDevice(_mapper.Map(device, new MON.Device()));
}
/// <summary>
/// Updates the Value object on the database.
/// </summary>
/// <param name="value"></param>
public void UpdateValue(DOM.Value value)
{
var dbValue = _db.Values.FirstOrDefault(v => v.Id == value.Id);
if (dbValue == null) return;
_mapper.Map(value, dbValue);
_db.Entry(dbValue).State = EntityState.Modified;
_db.SaveChanges();
}
/// <summary>
/// Updates the database copy of the parametised domain model.
/// </summary>
/// <param name="device"></param>
public DOM.Device UpdateDevice(DOM.Device device)
{
var dbCurrent = _db.Devices.FirstOrDefault(dev => dev.Id == device.Id);
_mapper.Map(device, dbCurrent);
_db.Entry(dbCurrent).State=EntityState.Modified;
_db.SaveChanges();
return _mapper.Map(dbCurrent, new DOM.Device());
}
/// <summary>
/// Updates the Alarm object on the database.
/// </summary>
/// <param name="alarm"></param>
/// <returns></returns>
public DOM.Alarm UpdateAlarm(DOM.Alarm alarm)
{
var dbCurrent = _db.Alarms.FirstOrDefault(alm => alm.Id == alarm.Id);
_mapper.Map(alarm, dbCurrent);
_db.Entry(dbCurrent).State = EntityState.Modified;
_db.SaveChanges();
return _mapper.Map(dbCurrent, new DOM.Alarm());
}
/// <summary>
/// Set the App Data for future use.
/// </summary>
/// <param name="ai"></param>
public void SetApplicationInformation(DOM.AppData ai)
{
var dbValue = _db.AppData.First();
if (dbValue == null)
{
_db.AppData.Add(_mapper.Map(ai, new DAL.AppData()));
}
else
{
dbValue = _mapper.Map(ai, new DAL.AppData());
}
_db.SaveChanges();
}
/// <summary>
/// Removes the Rule from the database.
/// </summary>
/// <param name="rule"></param>
public void DeleteRule(DOM.Rule rule)
{
var dbValue = _db.Rules.FirstOrDefault(r => r.Id == rule.Id);
if (dbValue == null) return;
_db.Rules.Remove(dbValue);
_db.SaveChanges();
}
/// <summary>
/// Removes the action from the database.
/// </summary>
/// <param name="action">Action to remove.</param>
public void DeleteAction(DOM.Action action)
{
var dbValue = RetrieveAction(action.Id);
if (dbValue == null) return;
_db.Actions.Remove(_mapper.Map(action, new DAL.Action()));
_db.SaveChanges();
}
public DAL.CommunicatorType ConvertToData(DOM.CommunicatorType domainModel)
{
throw new NotImplementedException();
}
public DAL.DatabaseType ConvertToData(DOM.DatabaseType dataModel)
{
throw new NotImplementedException();
}
public DAL.RuleType ConvertToData(DOM.RuleType domainModel)
{
throw new NotImplementedException();
}
public DAL.Value ConvertToData(DOM.Value domainModel)
{
throw new NotImplementedException();
}
public DAL.SerialCommunicator ConvertToData(DOM.SerialCommunicator domainModel)
{
throw new NotImplementedException();
}
/// <summary>
/// Adds a new value to the MongoDB database.
/// </summary>
/// <param name="value"></param>
public void AddNewValue(DOM.Value value)
{
_controller.AddNewValue(_mapper.Map(value, new MON.Value()));
}
/// <summary>
/// Creates a new instance of a Rule object. The returned
/// object includes all created Identity information.
/// </summary>
/// <param name="rule"></param>
/// <returns></returns>
public DOM.Rule CreateRule(DOM.Rule rule)
{
//Map to DAL object.
var dbVal = _mapper.Map(rule, new DAL.Rule());
//The Device does not need individual mapping for Rules.
try
{
//Save to Database.
_db.Rules.Add(dbVal);
//Save the changes made to the database.
_db.SaveChanges();
//Return the updated Domain object.
return _mapper.Map(dbVal, new DOM.Rule());
}
catch (Exception e)
{
//Report fault back up the chain.
DebugOutput.Print("Rule insertion to database failed. ", e.Message);
}
//Return null on failure.
return null;
}
/// <summary>
/// Creates a new Value object on the database. The returned
/// object includes all created Identity information.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public DOM.Value CreateValue(DOM.Value value)
{
var dbVal = _mapper.Map(value, new DAL.Value());
dbVal.DeviceId = value.Device.Id;
try
{
_db.Values.Add(dbVal);
_db.SaveChanges();
DebugOutput.Print($"Communicator #{dbVal.DeviceId}'s new value, '{dbVal.StringValue}', was captured!");
return _mapper.Map(dbVal, new DOM.Value());
}
catch (Exception)
{
var msg = $"Communicator #{value.Device.Id}'s new value, '{value.StringValue}', could not be captured!";
DebugOutput.Print("Could not store the new value!", msg);
}
//Return null on fail.
return null;
}
public DAL.AppData ConvertToData(DOM.AppData domainModel)
{
throw new NotImplementedException();
}
/// <summary>
/// Updates the database to remove the device from the system.
/// </summary>
/// <param name="device"></param>
public void DeleteDevice(DOM.Device device)
{
var dbValue = RetrieveDevice(device.Id);
if (dbValue == null) return;
_db.Devices.Remove(_mapper.Map(dbValue, new DAL.Device()));
_db.SaveChanges();
}
/// <summary>
/// Creates a new Action object within the database.
/// </summary>
/// <param name="action"></param>
public DOM.Action CreateAction(DOM.Action action)
{
var dbVal = (_mapper.Map(action, new DAL.Action()));
_db.Actions.Add(dbVal);
_db.SaveChanges();
return _mapper.Map(dbVal, new DOM.Action());
}
/// <summary>
/// Removes the single Value from the database, if it exists.
/// </summary>
/// <param name="value"></param>
public void DeleteValue(DOM.Value value)
{
var dbValue = _db.Values.FirstOrDefault(v => v.Id == value.Id);
if (dbValue == null) return;
_db.Values.Remove(dbValue);
_db.SaveChanges();
}
/// <summary>
/// Creates a new Alarm object on the database. The returned
/// object includes all created Identity information.
/// </summary>
/// <param name="alarm"></param>
/// <returns></returns>
public DOM.Alarm CreateAlarm(DOM.Alarm alarm)
{
//Convert the main Alarm object.
var dbVal = _mapper.Map(alarm, new DAL.Alarm());
//Create a new Globally Unique Identifier.
//dbVal.Id = Guid.NewGuid();
//Add the Alarm object to the Entity Context and Save changes to the Online Store.
_db.Alarms.Add(dbVal);
_db.SaveChanges();
//Return the new Alarm.
return _mapper.Map(dbVal, new DOM.Alarm());
}
/// <summary>
/// Updates the database Action entity based on the changes made in
/// the parammetised Domain model.
/// </summary>
/// <param name="action">Domain model to update.</param>
public DOM.Action UpdateAction(DOM.Action action)
{
var dbAction = _db.Actions.FirstOrDefault(act => act.Id == action.Id);
if (dbAction == null) return null;
var newAction = _mapper.Map(action, new DAL.Action());
_mapper.Map(newAction, dbAction);
dbAction.OutputValue = newAction.OutputValue;
_db.SaveChanges();
return _mapper.Map(dbAction, new DOM.Action());
}
/// <summary>
/// Creates a new Communicator object on the database. Automatically
/// handles each of the subsidary Communicator types internally.
/// </summary>
/// <param name="communicator">The domain model to push up to the database.</param>
/// <returns>The new ID number</returns>
public int? CreateCommunicator(DOM.Communicator communicator)
{
DAL.Communicator dbVal;
switch (communicator.Type)
{
case DOM.CommunicatorType.FlatFile:
dbVal = _mapper.Map(communicator, new DAL.FileCommunicator());
break;
case DOM.CommunicatorType.Serial:
dbVal= _mapper.Map(communicator, new DAL.SerialCommunicator());
break;
case DOM.CommunicatorType.Database:
dbVal = _mapper.Map(communicator, new DAL.DatabaseCommunicator());
break;
default:
throw new ArgumentOutOfRangeException();
}
var dalDevice = _mapper.Map(communicator.Device, dbVal.Device);
dbVal.Device = dalDevice;
try
{
_db.Entry(dbVal.Device).State = EntityState.Unchanged;
_db.Communicators.Add(dbVal);
_db.SaveChanges();
return _db.Communicators.Find(dbVal.Id).Id;
}
catch (Exception e)
{
DebugOutput.Print("System was unable to detatch the Device from the new Communicator! ", e.Message);
}
return null;
}
/// <summary>
/// Updates the Communicator as housed on the database.
/// </summary>
/// <param name="communicator"></param>
public void UpdateCommunicator(DOM.Communicator communicator)
{
var dbValue = _db.Communicators.FirstOrDefault(comm => comm.Id == communicator.Id);
if (dbValue == null) return;
_mapper.Map(communicator, dbValue);
//Tell EF that the object has been updated.
_db.Entry(dbValue).State = EntityState.Modified;
//Ensure that EF is aware this child object has not changed (and thus does not need changing/creating).
_db.Entry(dbValue.Device).State = EntityState.Unchanged;
_db.SaveChanges();
}
/// <summary>
/// Creates a new Device object within the database.
/// </summary>
/// <param name="device"></param>
public DOM.Device CreateDevice(DOM.Device device)
{
var dbVal = _mapper.Map(device, new DAL.Device());
_db.Devices.Add(dbVal);
_db.SaveChanges();
//Update MongoDB accordingly
var mongorepo = new MongoRepository();
mongorepo.AddNewDevice(device);
//MongoDB Updated!
return _mapper.Map(dbVal, new DOM.Device());
}
/// <summary>
/// Updates the Rule object on the database, the returned
/// object includes all created Identity information.
/// </summary>
/// <param name="rule"></param>
/// <returns></returns>
public DOM.Rule UpdateRule(DOM.Rule rule)
{
var dbVal = _db.Rules.FirstOrDefault(r => r.Id == rule.Id);
if (dbVal == null) return null;
_mapper.Map(rule, dbVal);
_db.Entry(dbVal).State = EntityState.Modified;
_db.SaveChanges();
//Return the updated Domain object.
return _mapper.Map(dbVal, new DOM.Rule());
}
/// <summary>
/// Decides on behalf of the user whether to create a new Device
/// entity or whether to update an entity that exists in its place.
/// </summary>
/// <param name="device"></param>
public DOM.Device CreateOrUpdateDevice(DOM.Device device)
{
var dbValue = RetrieveDevice(device.Id);
if (dbValue == null)
{
return CreateDevice(device);
}
else
{
return UpdateDevice(device);
}
}
/// <summary>
/// Converts a single DOM Communicator to DAL.
/// </summary>
/// <param name="communicator">DOM Communicator.</param>
/// <returns>DAL Communicator.</returns>
private DAL.Communicator ConvertDOMCommunicatorToDAL(DOM.Communicator communicator)
{
switch (communicator.Type)
{
case DOM.CommunicatorType.Database:
return (_mapper.Map(communicator, new DAL.DatabaseCommunicator()));
case DOM.CommunicatorType.Serial:
return (_mapper.Map(communicator, new DAL.SerialCommunicator()));
case DOM.CommunicatorType.FlatFile:
return (_mapper.Map(communicator, new DAL.FileCommunicator()));
default:
DebugOutput.Print("Unable to convert/understand Communicator...", communicator.Id.ToString());
return null;
}
}
/// <summary>
/// Updates and existing Device within the MongoDB datbase.
/// </summary>
/// <param name="device"></param>
public void UpdateDevice(DOM.Device device)
{
_controller.UpdateDevice(_mapper.Map(device, new MON.Device()));
}