public void Should_generate_connector_ids_sequencially()
{
using (var context = new ApplicationDbContext(ContextOptions))
{
ChargeStation chargeStation = ChargeStations[1];
Connector connector;
Assert.IsTrue(chargeStation.Connectors.TryGetValue(new Connector(1), out connector));
Assert.AreEqual(1, connector.Id);
Connector connector2 = new Connector(5f);
Connector connector3 = new Connector(5f);
Connector connector4 = new Connector(5f);
Connector connector5 = new Connector(5f);
chargeStation.AppendConnector(connector2);
chargeStation.AppendConnector(connector3);
chargeStation.AppendConnector(connector4);
chargeStation.AppendConnector(connector5);
Assert.AreEqual(2, connector2.Id);
Assert.AreEqual(3, connector3.Id);
Assert.AreEqual(4, connector4.Id);
Assert.AreEqual(5, connector5.Id);
Assert.DoesNotThrow(() => context.SaveChanges());
}
}
private Group GetGroup1()
{
var result = new Group
{
Id = 7,
Name = "Tesla XX Groups 2025",
CapacityInAmps = 56
};
var chargeStation = new ChargeStation {
Name = "LA Based Tesla 01", Id = 1
};
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 3, LineNo = 1, ChargeStationId = 1, Id = 1
});
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 5, LineNo = 2, ChargeStationId = 1, Id = 2
});
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 2, LineNo = 3, ChargeStationId = 1, Id = 3
});
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 2, LineNo = 4, ChargeStationId = 1, Id = 4
});
result.ChargeStations.Add(chargeStation);
chargeStation = new ChargeStation {
Name = "Tokyo Nissan 18", Id = 2
};
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 9, LineNo = 1, ChargeStationId = 2, Id = 5
});
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 5, LineNo = 2, ChargeStationId = 2, Id = 6
});
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 16, LineNo = 3, ChargeStationId = 2, Id = 7
});
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 1, LineNo = 4, ChargeStationId = 2, Id = 8
});
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 1, LineNo = 5, ChargeStationId = 2, Id = 9
});
result.ChargeStations.Add(chargeStation);
chargeStation = new ChargeStation {
Name = "Frankfurt Audi 3", Id = 3
};
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 3, LineNo = 1, ChargeStationId = 3, Id = 10
});
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 7, LineNo = 2, ChargeStationId = 3, Id = 11
});
result.ChargeStations.Add(chargeStation);
return(result);
}
public async Task <ActionResult <ConnectorResource> > GetConnector(Guid groupId, Guid chargeStationId, int id)
{
Group group = await _context.Group.FirstOrDefaultAsync(g => g.Id == groupId);
if (group == null)
{
return(NotFound("Group not found"));
}
ChargeStation chargeStation = await _context.ChargeStation.FirstOrDefaultAsync(c => c.Id == chargeStationId);
if (chargeStation == null)
{
return(NotFound("Charge Station not found"));
}
Connector connector = await _context.Connector.FirstOrDefaultAsync(c => c.Id == id && c.ChargeStationId == chargeStationId);
if (connector == null)
{
return(NotFound("Connector not found"));
}
return(_mapper.Map <ConnectorResource>(connector));
}
public void Algo_should_return_multiple_double_options_with_min_current()
{
//Arrange
decimal capacity = 10;
var chargeGroup = new ChargeGroup(Guid.Empty, "", capacity, null);
var chargeStation = new ChargeStation(Guid.NewGuid(), "", chargeGroup);
chargeGroup.AddChargeStation(chargeStation);
var expectedConnectorId_1 = 9;
var expectedConnectorId_2 = 8;
var expectedConnectorId_3 = 5;
chargeStation.AddConnector(0.4m, expectedConnectorId_1);
chargeStation.AddConnector(0.5m, expectedConnectorId_2);
chargeStation.AddConnector(0.9m, expectedConnectorId_3);
chargeStation.AddConnector(2);
chargeStation.AddConnector(3);
var needToFree = 0.9m;
//Act
var result = new Algo().FindOptions(chargeGroup, needToFree);
//Assert
result.Count.ShouldBe(2);
//0.4 + 0.5
result.Find(l => l.Exists(c => c.ConnectorId == expectedConnectorId_1)).Count.ShouldBe(2);
result.Find(l => l.Exists(c => c.ConnectorId == expectedConnectorId_1))
.Find(c => c.ConnectorId == expectedConnectorId_1).Amps.ShouldBe(0.4m);
result.Find(l => l.Exists(c => c.ConnectorId == expectedConnectorId_1))
.Find(c => c.ConnectorId == expectedConnectorId_2).Amps.ShouldBe(0.5m);
//0.9
result.Find(l => l.Exists(c => c.ConnectorId == expectedConnectorId_3)).Count.ShouldBe(1);
result.Find(l => l.Exists(c => c.ConnectorId == expectedConnectorId_3)).FirstOrDefault().Amps.ShouldBe(0.9m);
}
public void Algo_should_return_multiple_single_options_with_min_current()
{
//Arrange
decimal capacity = 10;
var chargeGroup = new ChargeGroup(Guid.Empty, "", capacity, null);
var chargeStation = new ChargeStation(Guid.NewGuid(), "", chargeGroup);
chargeGroup.AddChargeStation(chargeStation);
var expectedConnectorId = 9;
chargeStation.AddConnector(1, expectedConnectorId);
chargeStation.AddConnector(1);
chargeStation.AddConnector(2);
chargeStation.AddConnector(2);
chargeStation.AddConnector(3);
var needToFree = 0.9m;
//Act
var result = new Algo().FindOptions(chargeGroup, needToFree);
//Assert
result.Count.ShouldBe(2);
result[0].Count.ShouldBe(1);
result[1].Count.ShouldBe(1);
result.Find(c => c[0].ConnectorId == expectedConnectorId)[0].Amps.ShouldBe(1);
result.Find(c => c[0].ConnectorId != expectedConnectorId)[0].Amps.ShouldBe(1);
}
private Group GetGroup4()
{
var result = new Group
{
Id = 7,
Name = "Tesla XX Groups 2025",
CapacityInAmps = 9
};
var chargeStation = new ChargeStation {
Name = "LA Based Tesla 01", Id = 1
};
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 5, LineNo = 2, ChargeStationId = 1, Id = 2
});
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 2, LineNo = 3, ChargeStationId = 1, Id = 3
});
chargeStation.Connectors.Add(new Connector {
MaxCurrentInAmps = 2, LineNo = 4, ChargeStationId = 1, Id = 4
});
result.ChargeStations.Add(chargeStation);
return(result);
}
public void ValidateCreate(ChargeStation chargeStation, ICollection <Connector> connectors)
{
if (chargeStation.GroupId <= 0)
{
throw new UnexpectedValueException(nameof(chargeStation.GroupId));
}
_CommonValidator.ValidateChargeStationConnectorsCount(connectors.Count);
//Get group
var group = _UnitOfWork.GroupRepository.GetById(chargeStation.GroupId);
if (group == null)
{
throw new DependentNotFoundException(nameof(ChargeStation.GroupId), chargeStation.GroupId);
}
//Get sum of MaxCurrent of given connectors
var connectorsMaxCurrentSum = connectors.Sum(c => c.MaxCurrent);
//Get sum of MaxCurrentSum of all connectors of current group
var groupConnectorsMaxCurrentSum =
(from c in _UnitOfWork.ConnectorRepository.Queryable
join cs in _UnitOfWork.ChargeStationRepository.Queryable.Where(e => e.GroupId == chargeStation.GroupId)
on c.ChargeStationId equals cs.Id
select c.MaxCurrent).Sum();
_CommonValidator.ValidateCapacityExceedance(group.Capacity, groupConnectorsMaxCurrentSum + connectorsMaxCurrentSum);
}
public async Task <bool> Execute(UpdateChargeStationInputModel chargeStationInput, string groupId)
{
var group = await _groupRepository.GetGroupById(groupId);
if (group == null)
{
HandlerMessage = "Can't add this station because the IdGroup doenst exist";
return(false);
}
var hasChargeStation = _groupRepository.GetChargeStationById(chargeStationInput.Id);
if (hasChargeStation != null)
{
HandlerMessage = "The charge station already exist.";
return(false);
}
var chargeStation = new ChargeStation(chargeStationInput.Name);
AddConnectors(chargeStationInput, chargeStation);
group.ChargeStations.Add(chargeStation);
await _groupRepository.Update(group.Id, group);
HandlerMessage = "the Connector has created";
return(true);
}
public void CreateChargeStation(ChargeStation chargeStation)
{
var query = @$ "INSERT INTO gf_smartcharging.`charge-stations`
(Name, GroupId)
VALUES
(@Name, @GroupId);
SELECT LAST_INSERT_ID()";
// On real applications the DB password would be stored somewhere else (KMS, SecretManager or similar services)
var connectionString = _configuration["DatabaseConnection:ConnectionString"];
using (var connection = new MySqlConnection(connectionString))
{
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
using (var command = new MySqlCommand(query, connection))
{
command.Parameters.AddWithValue("@Name", chargeStation.Name);
command.Parameters.AddWithValue("@GroupId", chargeStation.GroupId);
chargeStation.Id = Convert.ToInt64(command.ExecuteScalar());
}
}
}
public async Task UpdateConnectors_should_update_chargestation_connectors()
{
var stations = new ChargeStationRepository(_fixture.DbContext);
var capacity = 10m;
var name = "TestChargeStation";
var chargeStationId = Guid.NewGuid();
var chargeGroup = new ChargeGroup(Guid.Empty, "", capacity, null);
var chargeStation = new ChargeStation(chargeStationId, name, chargeGroup);
chargeGroup.AddChargeStation(chargeStation);
//add
await stations.AddAsync(chargeStation).ConfigureAwait(false);
//get
var stationFromDb = await stations.GetAsync(chargeStationId).ConfigureAwait(false);
stationFromDb.Id.ShouldBe(chargeStationId);
stationFromDb.Connectors.Count().ShouldBe(0);
chargeStation.AddConnector(3.0m);
await stations.UpdateConnectorsAsync(chargeStation).ConfigureAwait(false);
stationFromDb = await stations.GetAsync(chargeStationId).ConfigureAwait(false);
stationFromDb.Id.ShouldBe(chargeStationId);
stationFromDb.Connectors.Count().ShouldBe(1);
stationFromDb.Connectors.FirstOrDefault().MaxCurrentAmps.ShouldBe(3.0m);
}
protected override async Task <IResponseContainerWithValue <ChargeStationDto> > GetResultAsync(CreateChargeStationRequest request)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
var result = new ResponseContainerWithValue <ChargeStationDto>();
var group = await groupRepository.GetAsync(request.GroupId);
if (group is null)
{
result.AddErrorMessage($"Group with ID={request.GroupId} is not found.");
Log.Error(result.Messages);
return(result);
}
var chargeStationResponseContainer = ChargeStation.Create(group, request.Name);
if (!chargeStationResponseContainer.IsSuccess)
{
result.JoinWith(chargeStationResponseContainer);
Log.Error(result.Messages);
return(result);
}
var chargeStation = await chargeStationRepository.CreateAsync(chargeStationResponseContainer.Value);
result = new ResponseContainerWithValue <ChargeStationDto> {
Value = ChargeStationDto.From(chargeStation)
};
return(result);
}
private ChargeStationAdditionResponseModel GetSuccesfulResult(ChargeStation chargeStation)
{
return(new ChargeStationAdditionResponseModel
{
ChargeStationId = chargeStation.Id
});
}
public void Algo_should_return_connector_with_min_current()
{
//Arrange
decimal capacity = 10;
var chargeGroup = new ChargeGroup(Guid.Empty, "", capacity, null);
var chargeStation = new ChargeStation(Guid.NewGuid(), "", chargeGroup);
chargeGroup.AddChargeStation(chargeStation);
var expectedConnectorId = 9;
chargeStation.AddConnector(1, expectedConnectorId);
chargeStation.AddConnector(1.5m);
chargeStation.AddConnector(2);
chargeStation.AddConnector(2);
chargeStation.AddConnector(3);
var needToFree = 1.0m;
//Act
var result = new Algo().FindOptions(chargeGroup, needToFree);
//Assert
result.Count.ShouldBe(1);
result.FirstOrDefault().Count.ShouldBe(1);
result.FirstOrDefault().FirstOrDefault().ConnectorId.ShouldBe(expectedConnectorId);
result.FirstOrDefault().FirstOrDefault().Amps.ShouldBe(1);
result.FirstOrDefault().FirstOrDefault().StationId.ShouldBe(chargeStation.Id);
}
public async Task <bool> Execute(CreateGroupStationInputModel groupStationInput)
{
var group = new GroupStation(groupStationInput.Name, groupStationInput.CapacityAmps);
Parallel.ForEach(groupStationInput.ChargeStations, chargeStation =>
{
var newChargStation = new ChargeStation(chargeStation.Name);
var newConnectorList = CreateConnectors(chargeStation, newChargStation);
newChargStation.Connectors.AddRange(newConnectorList);
group.AddChargeStation(newChargStation);
});
if (group.IsCapacityOfGroup() > group.CapacityAmps)
{
var numberOfExcessConnector = group.IsCapacityOfGroup() - group.CapacityAmps;
HandlerMessage = $"The capactiy of Connector was excessed. You may remove {numberOfExcessConnector} of Connectors";
return(false);
}
await _groupRepository.Add(group);
HandlerMessage = "Group has been added";
return(true);
}
public void GetMinimalAmountOfConnectorsForMaxCurrentInAmps_WithScenario1_ReturnsCorrectResult()
{
int groupCapacity = 50;
var sut = new Group(name: "test group", groupCapacity);
var chargeStation = new ChargeStation
{
Connectors = new List <Connector>
{
new Connector
{
MaxCurrentInAmps = 50
}
}
};
sut.ChargeStations.Add(chargeStation);
int capacityToBeAdded = 50;
int numberOfOptimalOptions = 1;
int numberOfConnectorsToBeRemoved = 1;
var result = sut.GetMinimalAmountOfConnectorsForMaxCurrentInAmps(capacityToBeAdded);
Assert.Equal(numberOfOptimalOptions, result.Count());
Assert.Equal(numberOfConnectorsToBeRemoved, result.Single().NumberOfConnectors);
Assert.Equal(capacityToBeAdded, result.Single().MaxCurrentInAmps);
}
public async Task AsyncExtended_should_return_station_with_linked_properties()
{
var stations = new ChargeStationRepository(_fixture.DbContext);
var groups = new ChargeGroupRepository(_fixture.DbContext);
var capacity = 10m;
var name = "TestChargeStation";
var stationId = Guid.NewGuid();
var groupId = Guid.NewGuid();
var chargeGroup = new ChargeGroup(groupId, "", capacity, null);
var chargeStation = new ChargeStation(stationId, name, chargeGroup);
chargeGroup.AddChargeStation(chargeStation);
//add
await groups.AddAsync(chargeGroup).ConfigureAwait(false);
await stations.AddAsync(chargeStation).ConfigureAwait(false);
var groupromDb = await groups.GetAsyncExtended(groupId).ConfigureAwait(false);
groupromDb.Id.ShouldBe(groupId);
groupromDb.ChargeStations.ShouldNotBeNull();
groupromDb.ChargeStations.First(s => s.Id == stationId).ShouldNotBeNull();
groupromDb.ChargeStations.First(s => s.Id == stationId).ParentChargeGroup.Id.ShouldBe(groupId);
}
public ChargeStation GetChargeStationById(long chargeStationId)
{
var query = $@"SELECT * FROM gf_smartcharging.`charge-stations`
WHERE Id = @Id;";
var chargeStation = new ChargeStation();
// On real applications the DB password would be stored somewhere else (KMS, SecretManager or similar services)
var connectionString = _configuration["DatabaseConnection:ConnectionString"];
using (var connection = new MySqlConnection(connectionString))
{
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
using (var command = new MySqlCommand(query, connection))
{
command.Parameters.AddWithValue("@Id", chargeStationId);
var reader = command.ExecuteReader();
if (reader.Read())
{
chargeStation.Id = Convert.ToInt64(reader["Id"]);
chargeStation.Name = (string)reader["Name"];
chargeStation.GroupId = Convert.ToInt64(reader["GroupId"]);
}
}
}
return(chargeStation);
}
public void UpdateCapacityInAmps_WithSufficientCapacity_PerformsTheUpdate()
{
int expectedCapacityInAmps = 150;
var sut = new Group(name: "test group", capacityInAmps: 100);
var chargeStation = new ChargeStation
{
Connectors = new List <Connector>
{
new Connector
{
MaxCurrentInAmps = 50
},
new Connector
{
MaxCurrentInAmps = 50
}
}
};
sut.AddChargeStation(chargeStation);
sut.UpdateCapacityInAmps(expectedCapacityInAmps);
Assert.Equal(expectedCapacityInAmps, sut.CapacityInAmps);
}
public List <ChargeStation> GetAllChargeStations()
{
var query = $@"SELECT * FROM gf_smartcharging.`charge-stations`;";
var chargeStationList = new List <ChargeStation>();
// On real applications the DB password would be stored somewhere else (KMS, SecretManager or similar services)
var connectionString = _configuration["DatabaseConnection:ConnectionString"];
using (var connection = new MySqlConnection(connectionString))
{
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
using (var command = new MySqlCommand(query, connection))
{
var reader = command.ExecuteReader();
while (reader.Read())
{
var chargeStation = new ChargeStation();
chargeStation.Id = Convert.ToInt64(reader["Id"]);
chargeStation.Name = (string)reader["Name"];
chargeStation.GroupId = Convert.ToInt64(reader["GroupId"]);
chargeStationList.Add(chargeStation);
}
}
}
return(chargeStationList);
}
public static ChargeStationDocument AsDocument(this ChargeStation entity)
=> new ChargeStationDocument
{
Id = entity.Id.ToString(),
Name = entity.Name,
ChargeGroupId = entity.ParentChargeGroup.Id.ToString(),
Connectors = entity.Connectors.Select(c => c.AsDocument())
};
public async Task UpdateConnectorsAsync(ChargeStation chargeStation)
{
await _chargeStationDocuments.FindOneAndUpdateAsync(
Builders <ChargeStationDocument> .Filter.Where(s => s.Id == chargeStation.Id.ToString()),
Builders <ChargeStationDocument> .Update
.Set(s => s.Connectors, chargeStation.Connectors.Select(c => c.AsDocument()))
).ConfigureAwait(false);
}
private void VerifyParentGroupId(ChargeStation chargeStation)
{
var existentGroup = _groupRepository.GetGroupById(chargeStation.GroupId);
if (existentGroup == null || existentGroup.Id == 0)
{
throw new RestException("Parent Group not found");
}
}
private void Start()
{
if (Instance != null)
{
throw new Exception("There should only be one instace of ChargeStation.");
}
Instance = this;
}
private async Task AddChargeStation(Group group, ChargeStation chargeStation)
{
group.AddChargeStation(chargeStation);
_dbContext.ChargeStation.Add(chargeStation);
_dbContext.Group.Update(group);
await _dbContext.SaveChangesAsync();
}
public void ChargeStationId_should_be_newGuid_by_default()
{
//Arrange
//Act
var chargestation = new ChargeStation(Guid.Empty, "", null);
//Assert
chargestation.Id.ShouldNotBe(Guid.Empty);
}
public void AddChargeStation_WithoutAConnector_RejectsAddition()
{
var sut = new Group(name: "test group", capacityInAmps: 130);
var chargeStation = new ChargeStation
{
Connectors = new List <Connector>()
};
Assert.Throws <SpecificationException>(() => sut.AddChargeStation(chargeStation));
}
protected static async Task <ChargeStation> AddChargeStationAsync(long groupId)
{
var chargeStation = new ChargeStation
{
Name = "S1",
GroupId = groupId
};
await AddAsync(chargeStation);
return(chargeStation);
}
private void VerifyChargeStationFields(ChargeStation chargeStation)
{
if (string.IsNullOrEmpty(chargeStation.Name))
{
throw new RestException("Name is required for creating a charge station");
}
if (chargeStation.GroupId < 0)
{
throw new RestException("Name is required for creating a charge station");
}
}
private ChargeStation CreateChargeStation(AddChargeStationCommand addChargeStationCommand)
{
var chargeStation = new ChargeStation
{
Name = addChargeStationCommand.Name,
Connectors = addChargeStationCommand.Connectors.Select(x => new Connector {
MaxCurrentInAmps = x.MaxCurrentInAmps
}).ToList()
};
return(chargeStation);
}
private Connector AddToChargeStation(ChargeStation chargeStation, AddConnectorCommand request)
{
var connector = new Connector
{
MaxCurrentInAmps = request.MaxCurrentInAmps
};
chargeStation.AddConnector(connector);
_dbContext.Connector.Add(connector);
return(connector);
}
