public async Task GetBatteryByIdAsync_CallsBatteryRepositoryGetByIdAsync()
{
var service = new BatteryService(_batteryRepositoryMock.Object, _batteryTypeRepositoryMock.Object, _batteryChargeRepositoryMock.Object, _loggerMock.Object);
var result = await service.GetBatteryByIdAsync(1, 1);
_batteryRepositoryMock.Verify(x => x.GetByIdAsync(It.IsAny <int>()));
}
// Populate the page with entity data
private void PopulatePage()
{
int batteryId = 0;
try
{
// Get object from BatteryApi
batteryId = Int32.Parse(Security.GetQueryString());
BatteryDto battery = BatteryService.GetBattery(batteryId);
BatteryReferenceTb.Text = battery.Battery_Ref;
CycleIndexTb.Text = battery.Cycle_Index.ToString();
ChargeCapacityTb.Text = battery.Charge_Capacity.ToString();
DischargeCapacityTb.Text = battery.Discharge_Capacity.ToString();
ChargeEnergyTb.Text = battery.Charge_Energy.ToString();
DischargeEnergyTb.Text = battery.Discharge_Energy.ToString();
dvdtTb.Text = battery.dvdt.ToString();
InternalResistanceTb.Text = battery.Internal_Resistance.ToString();
}
catch
{
// ERROR - User contained invalid data
Response.Redirect("BatteryDetail?Id{" + batteryId + "}&message=DatabaseError");
}
}
public async Task EnterNullBatteryType_ThrowsArgumentNullException()
{
BatteryType batteryType = null;
var service = new BatteryService(_batteryRepositoryMock.Object, _batteryTypeRepositoryMock.Object, _batteryChargeRepositoryMock.Object, _loggerMock.Object);
await Assert.ThrowsAsync <ArgumentNullException>(() => service.EnterNewBatteryTypeAsync(1, batteryType));
}
// Populate the page with entity data
private void PopulatePage()
{
int batchId = 0;
try
{
// Get object from BatchApi
batchId = Int32.Parse(Security.GetQueryString());
BatchDto batch = BatchService.GetBatch(batchId);
BatchReferenceTb.Text = batch.Batch_Ref;
}
catch
{
// ERROR - User contained invalid data
Response.Redirect("BatchDetail?Id{" + batchId + "}&message=DatabaseError");
}
List <BatteryDto> batteries = BatteryService.GetBatteries(batchId);
if (batteries.Count > 0)
{
// If there are batteries in this batch; display the gridview
BatteryGridView.DataSource = batteries;
BatteryGridView.DataBind();
}
else
{
// Otherwise hide the gridview and display an alternative message
hiddenDiv.Visible = true;
SubtitleDiv.Visible = false;
DownloadDiv.Visible = false;
}
}
// Update Battery in the database
protected void UpdateBtn_Click(object sender, EventArgs e)
{
// Create Battery Object
int batteryId = Int32.Parse(Security.GetQueryString());
BatteryDto battery = BatteryService.GetBattery(batteryId);
battery.Battery_Ref = BatteryReferenceTb.Text;
battery.Cycle_Index = Int32.Parse(CycleIndexTb.Text);
battery.Charge_Capacity = Double.Parse(ChargeCapacityTb.Text);
battery.Discharge_Capacity = Double.Parse(DischargeCapacityTb.Text);
battery.Charge_Energy = Double.Parse(ChargeEnergyTb.Text);
battery.Discharge_Energy = Double.Parse(DischargeEnergyTb.Text);
battery.dvdt = Double.Parse(dvdtTb.Text);
battery.Internal_Resistance = Double.Parse(InternalResistanceTb.Text);
battery.BatchId = Int32.Parse(BatteryService.GetBatchId().ToString());
battery.Lifetime = null;
// update in database
if (BatteryService.UpdateBattery(battery))
{
Response.Redirect("Default.aspx?message=BatteryUpdateSuccess");
}
else
{
Response.Redirect("BatteryDetail.aspx?id=" + batteryId + "&message=UpdateError");
}
}
public void StopServices()
{
this.BatteryService.ValueChangeCompleted -= BatteryService_ValueChangeCompleted;
this.BatteryLevel = DEFAULT_BATTERYVALUE;
BatteryService.Stop();
LinkLossService.Stop();
ImmediateAlertService.Stop();
}
public async Task DeleteBatteryTypeAsyncWithBadId_ThrowsBatteryTypeNotFound()
{
var batteryTypeId = 8;
_batteryTypeRepositoryMock.Setup(x => x.GetById(It.IsAny <int>())).Returns <BatteryType>(null);
var service = new BatteryService(_batteryRepositoryMock.Object, _batteryTypeRepositoryMock.Object, _batteryChargeRepositoryMock.Object, _loggerMock.Object);
await Assert.ThrowsAsync <BatteryNotFoundException>(() => service.DeleteBatteryAsync(1, batteryTypeId));
}
public async Task EnterNewBatteryType_CallsBatteryTypeRepositoryAdd()
{
var batteryType = new BatteryType {
Type = "Graphene", Cells = 4, CapacityMah = 2200, WeightInGrams = 500, AccountId = 1
};
var service = new BatteryService(_batteryRepositoryMock.Object, _batteryTypeRepositoryMock.Object, _batteryChargeRepositoryMock.Object, _loggerMock.Object);
await service.EnterNewBatteryTypeAsync(1, batteryType);
_batteryTypeRepositoryMock.Verify(x => x.AddAsync(batteryType));
}
public async Task UpdateBatteryTypeAsync_CallsBatteryTypeRepositoryUpdateAsync()
{
var batteryType = new BatteryType {
AccountId = 1, Type = "Graphene", Cells = 4, CapacityMah = 2200, WeightInGrams = 500
};
_batteryTypeRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <BatteryType>())).Returns(Task.FromResult(batteryType));
var service = new BatteryService(_batteryRepositoryMock.Object, _batteryTypeRepositoryMock.Object, _batteryChargeRepositoryMock.Object, _loggerMock.Object);
var result = await service.UpdateBatteryTypeAsync(1, batteryType);
_batteryTypeRepositoryMock.Verify(x => x.UpdateAsync(batteryType));
}
// Soft-delete Battery in the database
protected void DeleteBtn_Click(object sender, EventArgs e)
{
int batteryId = Int32.Parse(Security.GetQueryString());
// Soft delete battery in Database
if (BatteryService.DeleteBattery(batteryId))
{
Response.Redirect("Default.aspx?message=BatteryDeleteSuccess");
}
else
{
Response.Redirect("BatteryDetail.aspx?id=" + batteryId + "&message=DeleteError");
}
}
public async Task DeleteBatteryTypeAsync_CallsRepositoryDeleteAsync()
{
var batteryTypeId = 1;
var batteryType = new BatteryType {
Id = batteryTypeId, AccountId = 1, Type = "Graphene", Cells = 4, CapacityMah = 2200, WeightInGrams = 500
};
_batteryTypeRepositoryMock.Setup(x => x.GetById(It.IsAny <int>())).Returns(batteryType);
var service = new BatteryService(_batteryRepositoryMock.Object, _batteryTypeRepositoryMock.Object, _batteryChargeRepositoryMock.Object, _loggerMock.Object);
await service.DeleteBatteryTypeAsync(1, batteryTypeId);
_batteryTypeRepositoryMock.Verify(x => x.DeleteAsync(batteryType));
}
public async void StartServicesOnDevice(DeviceInformationItem chosenBLEDevice)
{
var linkLossServiceOnDevice = chosenBLEDevice.Device.GetGattService(GattServiceUuids.LinkLoss);
var batteryServiceOnDevice = chosenBLEDevice.Device.GetGattService(GattServiceUuids.Battery);
var ImmediateAlertServiceOnDevice = chosenBLEDevice.Device.GetGattService(GattServiceUuids.ImmediateAlert);
await BatteryService.Start(batteryServiceOnDevice);
await LinkLossService.Start(linkLossServiceOnDevice);
LinkLossService.WriteAlertLevelCharacteristicAsync(AlertLevelEnum.HighAlert);
await ImmediateAlertService.Start(ImmediateAlertServiceOnDevice);
BatteryService.ValueChangeCompleted += BatteryService_ValueChangeCompleted;
}
Dictionary <string, string> GetData()
{
var batteryService = new BatteryService();
var data = new Dictionary <string, string>();
data.Add(nameof(batteryService.IsCharging), batteryService.IsCharging.ToString());
data.Add(nameof(batteryService.BatteryLevel), batteryService.BatteryLevel.ToString());
data.Add("BatteryState", batteryService.BatteryState);
data.Add("PowerType", batteryService.PowerType);
foreach (var item in batteryService.AddInfo)
{
data.Add(item.Title, item.Value);
}
return(data);
}
public async Task GetBatteriesAsync_CallsListAllAsyncInRepository()
{
var batteryList = new List <Battery> {
new Battery {
Id = 1, AccountId = 1, IsActive = true, Notes = "Test battery", PurchaseDate = DateTime.Now.AddMonths(-1)
}
};
_batteryRepositoryMock.Setup(x => x.GetAllAsync()).Returns(Task.FromResult(batteryList));
var service = new BatteryService(_batteryRepositoryMock.Object, _batteryTypeRepositoryMock.Object, _batteryChargeRepositoryMock.Object, _loggerMock.Object);
var result = await service.ListBatteriesAsync(1);
Assert.NotEmpty(result);
_batteryRepositoryMock.Verify(x => x.GetAllAsync());
}
public async Task UpdateBatteryAsync_CallsBatteryRepositoryUpdateAsync()
{
var battery = new Battery {
Id = 7, AccountId = 1, BatteryType = new BatteryType {
Id = 2, Type = "NanoTech", Cells = 3
}, IsActive = true, PurchaseDate = DateTime.Now, Notes = "Notes for the test"
};
_batteryRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <Battery>())).Returns(Task.FromResult(battery));
var service = new BatteryService(_batteryRepositoryMock.Object, _batteryTypeRepositoryMock.Object, _batteryChargeRepositoryMock.Object, _loggerMock.Object);
var result = await service.UpdateBatteryAsync(1, battery);
_batteryRepositoryMock.Verify(x => x.UpdateAsync(It.IsAny <Battery>()));
Assert.IsType <Battery>(result);
}
public async Task DeleteBatteryAsync_CallsRepositoryDeleteAsync()
{
var batteryId = 3;
var battery = new Battery {
Id = batteryId, AccountId = 1, BatteryType = new BatteryType {
Id = 1, Type = "NanoTech", Cells = 3
}, IsActive = true, PurchaseDate = DateTime.Now, Notes = "Notes for the test"
};
_batteryRepositoryMock.Setup(x => x.GetById(It.IsAny <int>())).Returns(battery);
var service = new BatteryService(_batteryRepositoryMock.Object, _batteryTypeRepositoryMock.Object, _batteryChargeRepositoryMock.Object, _loggerMock.Object);
await service.DeleteBatteryAsync(1, batteryId);
_batteryRepositoryMock.Verify(x => x.DeleteAsync(battery));
}
public void EnterChargeDataWithNullBattery_ThrowsBatteryNotFoundException()
{
var battery = new Battery {
Id = 0, AccountId = 1
};
var charge = new BatteryCharge {
Battery = battery, ChargedOn = DateTime.Now, Type = ChargeType.Standard, Mah = 1000
};
_batteryRepositoryMock.Setup(x => x.GetById(It.IsAny <int>())).Returns(() => null);
var service = new BatteryService(
_batteryRepositoryMock.Object,
_batteryTypeRepositoryMock.Object,
_batteryChargeRepositoryMock.Object,
_loggerMock.Object
);
Assert.ThrowsAsync <BatteryNotFoundException>(() => service.EnterChargeDataAsync(1, battery, charge.ChargedOn, charge.Type, charge.Mah));
}
// Predict the remaining lifetime for a Battery in the gridview
protected void PredictLB_Command(object sender, CommandEventArgs e)
{
int batchId = Int32.Parse(Security.GetQueryString());
// Get batteryId
int batteryId = 0;
try
{
batteryId = Int32.Parse(e.CommandArgument.ToString());
}
catch
{
Response.Redirect("BatchDetail.aspx?id=" + batchId + "&message=IdError");
}
// Get prediction
double prediction = 0;
try
{
prediction = Double.Parse(PredictService.Single(batteryId).ToString());
}
catch
{
Response.Redirect("BatchDetail.aspx?id=" + batchId + "&message=PredictionError");
}
// Update battery in database
BatteryDto battery = BatteryService.GetBattery(batteryId);
battery.Lifetime = prediction;
if (BatteryService.UpdateBattery(battery))
{
Response.Redirect("BatchDetail.aspx?id=" + batchId + "&message=PredictionSuccess");
}
else
{
Response.Redirect("BatchDetail.aspx?id=" + batchId + "&message=UpdateError");
}
}
// Redirect to the home page or initialise page before it is presented to the User
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
// Redirect User if they do not have permission to view this page
Security.RedirectIfNoQueryString();
int?batchId = BatteryService.GetBatchId();
int?userId = BatchService.GetUserId(batchId);
Security.RedirectIfUserIdMismatch(userId);
Security.RedirectIfIsGuest();
// Populate the page with entity data
PopulatePage();
// Display Success/Error message on page if appropriate
DisplayMessage();
}
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
_deferral = taskInstance.GetDeferral();
var client = DigitServiceBuilder.Get();
try
{
var opts = new DigitBLEOptions();
if (opts.IsConfigured)
{
var bleClient = new DigitBLEClient(opts);
var batteryService = new BatteryService(bleClient, client);
await batteryService.TimeTriggeredMeasurement();
}
}
catch (Exception e)
{
await client.LogAsync($"Unhandled background exception: {e.Message}", 3);
}
_deferral.Complete();
}
// Create Battery in the database
protected void CreateBtn_Click(object sender, EventArgs e)
{
BatteryDto battery = null;
int batchId = 0;
try
{
batchId = Int32.Parse(Security.GetQueryString());
// Create Battery Object
battery = new BatteryDto
{
Battery_Ref = BatteryReferenceTb.Text,
Cycle_Index = Int32.Parse(CycleIndexTb.Text),
Charge_Capacity = Double.Parse(ChargeCapacityTb.Text),
Discharge_Capacity = Double.Parse(DischargeCapacityTb.Text),
Charge_Energy = Double.Parse(ChargeEnergyTb.Text),
Discharge_Energy = Double.Parse(DischargeEnergyTb.Text),
dvdt = Double.Parse(dvdtTb.Text),
Internal_Resistance = Double.Parse(InternalResistanceTb.Text),
BatchId = batchId,
Lifetime = null
};
}
catch
{
Response.Redirect("CreateBattery?id=" + batchId + "&message=Error");
}
// Add to database
if (BatteryService.CreateBattery(battery))
{
Response.Redirect("Default?message=BatteryCreateSuccess");
}
else
{
Response.Redirect("CreateBattery?id" + batchId + "&message=Error");
}
}
public void EnterChargeDataWithExistingBattery_ReturnsBattery()
{
var battery = new Battery {
Id = 1, IsActive = true, Notes = "Test battery", PurchaseDate = DateTime.Now.AddMonths(-1), AccountId = 1
};
var charge = new BatteryCharge {
Battery = battery, ChargedOn = DateTime.Now, Type = ChargeType.Standard, Mah = 1000
};
_batteryRepositoryMock.Setup(x => x.GetById(It.IsAny <int>())).Returns(() => battery);
_batteryChargeRepositoryMock.Setup(x => x.Add(It.IsAny <BatteryCharge>())).Returns(charge);
var service = new BatteryService(
_batteryRepositoryMock.Object,
_batteryTypeRepositoryMock.Object,
_batteryChargeRepositoryMock.Object,
_loggerMock.Object
);
var result = service.EnterChargeDataAsync(1, battery, charge.ChargedOn, charge.Type, charge.Mah);
Assert.NotNull(result);
}
Dictionary <string, string> GetData()
{
var batteryService = new BatteryService();
var data = new Dictionary <string, string>();
data.Add(nameof(batteryService.IsCharging), batteryService.IsCharging.ToString());
data.Add(nameof(batteryService.BatteryLevel), batteryService.BatteryLevel.ToString());
data.Add("BatteryState", batteryService.BatteryState);
data.Add("PowerType", batteryService.PowerType);
try
{
foreach (var item in batteryService.AddInfo)
{
data.Add(item.Title, item.Value);
}
}
catch (NotImplementedException ex)
{
Debug.WriteLine($"Exception: {ex.Message}");
}
return(data);
}
public BatteryControllerForm()
{
InitializeComponent();
batteryService = BatteryService.Instance;
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
_deferral = taskInstance.GetDeferral();
var client = DigitServiceBuilder.Get();
try
{
RawNotification notification = (RawNotification)taskInstance.TriggerDetails;
await client.LogAsync($"Received push {notification.Content}");
var opts = new DigitBLEOptions();
var content = JsonConvert.DeserializeObject <PushPayload>(notification.Content);
switch (content.Action)
{
case PushActions.MeasureBattery:
if (opts.IsConfigured)
{
var bleClient = new DigitBLEClient(opts);
var batteryService = new BatteryService(bleClient, client);
await batteryService.AddBatteryMeasurement();
}
else
{
await client.LogAsync($"Push error: no device configured.", 3);
}
break;
case PushActions.SendTime:
if (opts.IsConfigured)
{
var bleClient = new DigitBLEClient(opts);
try
{
await bleClient.SetTime(DateTime.Now);
}
catch (DigitBLEExpcetion e)
{
await client.LogAsync($"Could not send time: {e.Message}", 3);
}
}
else
{
await client.LogAsync($"Push error: no device configured.", 3);
}
break;
case PushActions.SendLocation:
var locationService = new LocationService(client);
await locationService.SendCurrentLocation();
break;
default: break;
}
}
catch (Exception e)
{
await client.LogAsync($"Unhandled background exception: {e.Message}", 3);
}
_deferral.Complete();
}
private async void RetrieveBatteryService(GattDeviceService gattDeviceService)
{
await BatteryService.Start(gattDeviceService);
BatteryService.ValueChangeCompleted += BatteryService_ValueChangeCompleted;
}
public BatteryServiceTests()
{
this.batteryService = new BatteryService();
this.helper = new TestsHelper();
}
public BatteryViewerForm()
{
batteryService = BatteryService.Instance;
InitializeComponent();
}
public MainFormPi()
{
batteryService = BatteryService.Instance;
InitializeComponent();
}
