private void AddSmc(SmcDto smc)
{
var topicAddress = AddDeviceToTopicList(smc.Serial, CommandDeviceType.Smc);
var topic = MakeTopicObject(topicAddress);
_commandsMqttClient.Subscribe(topic);
}
public SmcTicketThread(SmcDto smcDto, ClientSettings clientSettings,
BrokerSettings brokerSettings, IMqttClientConfiguration mqttClientConfiguration,
IMqttClientMethods mqttClientMethods, Topic topic,
CommandRules commandRules, IEventService eventService, IForwarderSenderService forwarderSenderService)
{
Smc = smcDto;
_eventService = eventService;
_forwarderSenderService = forwarderSenderService;
Tickets = new ConcurrentPriorityQueue <TicketThreadObject>();
_executingCommandSemaphore = new SemaphoreSlim(1, 1);
_waitingCommandMessageSemaphore = new SemaphoreSlim(1, 1);
_answerSemaphore = new SemaphoreSlim(1, 1);
var localClientSettings = new ClientSettings
{
ClientId = clientSettings.ClientId, ClientName = clientSettings.ClientName
};
localClientSettings.ClientId = localClientSettings.ClientId.Replace("serial", smcDto.Serial);
localClientSettings.ClientName = localClientSettings.ClientName.Replace("serial", smcDto.Serial);
localClientSettings.DebugMode = clientSettings.DebugMode;
localClientSettings.AutoReconnectDelayInSeconds = clientSettings.AutoReconnectDelayInSeconds;
var localTopic = new Topic {
Address = topic.Address, QoS = topic.QoS
};
localTopic.Address = localTopic.Address
.Replace("{smc-or-meter}", CommandDeviceType.Smc.ToString().ToLower())
.Replace("{serial}", smcDto.Serial);
_mqttClient = new IoGMqttClient(localClientSettings, brokerSettings, mqttClientConfiguration,
mqttClientMethods);
_mqttClient.Subscribe(localTopic);
_mqttClient.MessageReceivedHandler += ReceivedUpdate;
_commandRules = commandRules;
}
public ForwarderMessage MakeSmcDeletionPackageForForwarder(SmcDto smcDto)
{
var forwarderMessage = new ForwarderMessage
{
MessageContent = "", //todo
Uri = _middlewares.EletraSmc.BaseUrl + _middlewares.EletraSmc.Smc.SubRoute + "?serial=" + smcDto.Serial
};
return(forwarderMessage);
}
public ForwarderMessage MakeSmcCreationPackageForForwarder(SmcDto smcDto)
{
var forwarderMessage = new ForwarderMessage
{
MessageContent = JsonConvert.SerializeObject(
new EletraSmcModels.SmcWithMeter {
SmcDto = _mapper.Map <SmcDto, EletraSmcModels.SmcDto>(smcDto)
}),
Uri = _middlewares.EletraSmc.BaseUrl + _middlewares.EletraSmc.Smc.SubRoute
};
return(forwarderMessage);
}
public SmcDto Update(SmcDto smcDto)
{
var smc = _mapper.Map <SmcDto, Smc>(smcDto);
var savedSmc = GetExistingSmc(smcDto.Serial);
var smcModel = _smcModelService.GetExistingSmcModel(smcDto.SmcModel.Name);
smc.SmcModel = smcModel;
savedSmc.UpdateFields(smc);
return(_mapper
.Map <Smc, SmcDto>(
_smcRepository.Update(savedSmc)
));
}
public IActionResult GetBySerial([FromRoute] string serial)
{
SmcDto savedSmcDto = _smcService.GetBySerial(serial);
if (savedSmcDto == null)
{
return(new NotFoundResult());
}
else
{
return(new OkObjectResult(savedSmcDto));
}
}
private Smc CreateSmc(SmcDto smc, KeysDto keysDto)
{
smc.KeysDto = keysDto;
smc.SmcModel = _smcModelService.GetByName(smc.SmcModel.Name);
var status = _smcForwarderService.ForwardCreation(smc);
if (!status.IsSuccessStatusCode)
{
throw new BadRequestException(JsonConvert
.DeserializeObject <ErrorMessageDto>(status.Content.ReadAsStringAsync().Result).ErrorMessage);
}
_smcService.Save(smc);
return(_smcService.GetExistingSmc(smc.Serial));
}
public IActionResult Save(SmcDto smcDto)
{
SmcDto savedSmcDto = _smcService.Save(smcDto);
_eventService.ASmcWasSavedEvent(this, new IoGServicedEventArgs <SmcDto>(savedSmcDto));
return(new CreatedResult(
_servicesUtils
.CreateUri(
Request,
Url.RouteUrl(
"GetBySerialSmcRoute",
new { serial = savedSmcDto.Serial })),
savedSmcDto));
}
public HttpResponseMessage ForwardDeletion(SmcDto smcDto)
{
try
{
var middlewareService =
_middlewareProviderService.GetSmcMiddlewareServiceByManufacturerName(smcDto.SmcModel.Manufacturer.Name);
var convertedMessage = middlewareService.MakeSmcDeletionPackageForForwarder(smcDto);
return(_forwarderSenderService.SendDelete(convertedMessage));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public HttpResponseMessage ForwardCreation(SmcDto t)
{
try
{
var middlewareService =
_middlewareProviderService.GetSmcMiddlewareServiceByManufacturerName(t.SmcModel.Manufacturer.Name);
var convertedMessage = middlewareService.MakeSmcCreationPackageForForwarder(t);
return(_forwarderSenderService.SendPost(convertedMessage).Result);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public SmcDto Save(SmcDto smcDto)
{
var savedSmc = _smcRepository.GetBySerial(smcDto.Serial);
var smc = _mapper.Map <SmcDto, Smc>(smcDto);
smc.SmcModel = _smcModelService.GetExistingSmcModel(smc.SmcModel.Name);
if (savedSmc == null)
{
return(_mapper.Map <Smc, SmcDto>(_smcRepository.Save(smc)));
}
if (savedSmc.Active)
{
throw new ExistentEntityException("O smc de serial " + savedSmc.Serial + " já existe");
}
savedSmc.UpdateFields(smc);
savedSmc.Active = true;
return(_mapper.Map <Smc, SmcDto>(_smcRepository.Update(savedSmc)));
}
public async Task UpdateForAll(SmcDto smcDto)
{
await Clients.All.SendAsync("UpdateForAll", smcDto);
}
public SmcCommandManager(SmcDto smcDto)
{
_commandThreads = new List <CommandThread>();
SmcDto = smcDto;
}
public ForwarderMessage MakeSmcDeletionPackageForForwarder(SmcDto smcDto)
{
throw new NotImplementedException();
}
public IActionResult Update(SmcDto smcDto)
{
SmcDto updatedSmcDto = _smcService.Update(smcDto);
return(new OkObjectResult(updatedSmcDto));
}
