public JsonResult UnSubscribeFrom(int sensorId, string deviceId)
{
if (sensorId <= 0 || !Validator.Present(deviceId))
{
return(Json(new ApiError("Invalid request parameters.")));
}
try
{
using (SensorContext db = new SensorContext())
{
Sensor sensor = db.Sensors.Single(s => s.ID == sensorId);
if (!sensor.GetNotificationIds().Any(dID => dID == deviceId))
{
return(Json(new ApiError("Device isn't subscribed to sensor.")));
}
sensor.GetNotificationIds().Remove(deviceId);
db.SaveChanges();
return(Json(new { succeeded = true }));
}
}
catch (Exception e)
{
return(Json(new ApiError("An error occured.")));
}
}
public static void GerarDadosIniciais(int idSensor)
{
using (var dbSensor = new SensorContext()) {
DateTime mesAtual = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
DateTime fimMesAnterior = mesAtual.AddDays(-1);
for (int i = 1; i <= fimMesAnterior.Day; i++)
{
for (int j = 0; j < 24; j++)
{
for (int k = 0; k < 60; k += 30)
{
DateTime dataMedicao = new DateTime(fimMesAnterior.Year, fimMesAnterior.Month, i, j, k, 0);
foreach (Sensor sensor in dbSensor.Records.Where(p => p.ID == idSensor || idSensor == 0))
{
double medicaoSensor = GetRandomNumber(sensor.MedicaoMinima, sensor.MedicaoMaximaAlerta + 10);
IncluirLogSensor(sensor.ID, medicaoSensor, dataMedicao);
}
}
}
}
}
}
public void LoadSensorDataFromModel(InkModel inkModel, SensorData sensorData)
{
// Load sensor data if missing
if (mSensorDataMap.TryAdd(sensorData.Id, sensorData))
{
InputContext inputContext = inkModel.InputConfiguration.InputContexts.Find((ic) => ic.Id == sensorData.InputContextID);
// Load input context if missing
if (mInputContexts.TryAdd(inputContext.Id, inputContext))
{
Wacom.Ink.Serialization.Model.Environment environment = inkModel.InputConfiguration.Environments.Find((env) => env.Id == inputContext.EnvironmentId);
mEnvironments.TryAdd(environment.Id, environment);
SensorContext sensorContext = inkModel.InputConfiguration.SensorContexts.Find((sc) => sc.Id == inputContext.SensorContextId);
// Load sensor context if missing
if (mSensorContexts.TryAdd(sensorContext.Id, sensorContext))
{
// Iterate and load sensor channels contexts if missing
for (int j = 0; j < sensorContext.SensorChannelContexts.Count; j++)
{
SensorChannelsContext sensorChannelsContext = sensorContext.SensorChannelContexts[j];
// Load input device if missing
mInputDevices.TryAdd(sensorChannelsContext.InputDevice.Id, sensorChannelsContext.InputDevice);
// Load ink input provider if missing
mInkInputProvidersMap.TryAdd(sensorChannelsContext.InkInputProvider.Id, sensorChannelsContext.InkInputProvider);
}
}
}
}
}
public static Sensor AlterarSensor(int id, SensorRequest sensorRequest)
{
try {
Sensor sensor = new Sensor();
using (var dbSensor = new SensorContext()) {
sensor = (
from s in dbSensor.Records
where s.ID == id
select s).FirstOrDefault();
if (sensor != null)
{
sensor.IDTipoSensor = sensorRequest.IDTipoSensor;
sensor.IDBarragem = sensorRequest.IDBarragem;
sensor.Name = sensorRequest.Name;
sensor.MedicaoMinima = sensorRequest.MedicaoMinima;
sensor.MedicaoMaximaSeguranca = sensorRequest.MedicaoMaximaSeguranca;
sensor.MedicaoMaximaAlerta = sensorRequest.MedicaoMaximaAlerta;
dbSensor.Records.Update(sensor);
dbSensor.SaveChanges();
}
return(sensor);
}
}
catch (Exception e) {
throw (e);
}
}
private SensorContext CreateAndAddSensorContext(InkInputProvider inkInputProvider, InputDevice inputDevice)
{
// Create the sensor channel groups using the input provider and device
SensorChannelsContext defaultSensorChannelsContext = CreateChannelsGroup(inkInputProvider, inputDevice);
SensorChannelsContext specialChannelsContext = new SensorChannelsContext(
inkInputProvider,
inputDevice,
new List <SensorChannel> {
mTimestampSensorChannel
}, //, mSpecialPressureSensorChannel },
latency: 2,
samplingRateHint: 2);
// Create the sensor context using the sensor channels contexts
SensorContext sensorContext = new SensorContext();
sensorContext.AddSensorChannelsContext(defaultSensorChannelsContext);
//sensorContext.AddSensorChannelsContext(specialChannelsContext);
Identifier sensorContextId = sensorContext.Id;
bool res = InkDocument.InputConfiguration.SensorContexts.Any((context) => context.Id == sensorContextId);
if (!res)
{
InkDocument.InputConfiguration.SensorContexts.Add(sensorContext);
}
return(sensorContext);
}
public static Sensor ExcluirSensor(int id)
{
try {
Sensor sensor = new Sensor();
using (var dbSensor = new SensorContext()) {
sensor = (
from s in dbSensor.Records
where s.ID == id
select s).FirstOrDefault();
if (sensor != null)
{
dbSensor.Records.Remove(sensor);
dbSensor.SaveChanges();
}
}
return(sensor);
}
catch (Exception e) {
throw (e);
}
}
public JsonResult Notify(int sensorId, Dictionary <string, string> data)
{
if (sensorId <= 0 || data == null)
{
return(Json(new ApiError("Invalid request parameters.")));
}
try
{
using (SensorContext db = new SensorContext())
{
Sensor sensor = db.Sensors.Single(s => s.ID == sensorId);
FcmMessage msg = new FcmMessage(data, sensor.GetNotificationIds().ToArray());
var response = FirebaseClient.instance.Notify(msg);
if (response.IsSuccessStatusCode)
{
return(Json(new { succeeded = true }));
}
else
{
return(Json(new ApiError("Message wasn't sent.")));
}
}
}
catch (Exception e)
{
return(Json(new ApiError("An error occured.")));
}
}
public JsonResult addSensor(int id)
{
if (id <= 0)
{
return(Json(new ApiError("Invalid request parameters.")));
}
try
{
using (SensorContext db = new SensorContext())
{
// check if id already exists
if (db.Sensors.Any(sensor => sensor.ID == id))
{
return(Json(new ApiError("Sensor already exists")));
}
db.Sensors.Add(new Sensor(id));
db.SaveChanges();
return(Json(new { succeeded = true }));
}
}
catch (Exception e)
{
return(Json(new ApiError("An error occured.")));
}
}
public GetDeviceByIdOperation(SensorContext context,
IDeviceQueries deviceQueries,
IHttpContextAccessor httpContextAccessor,
INoAuthorization <string> noAuthorization)
: base(context, httpContextAccessor, noAuthorization)
{
_deviceQueries = deviceQueries;
}
public GetDevicesOperation(SensorContext context,
IHttpContextAccessor httpContextAccessor,
IDeviceQueries deviceQueries,
IAdministratorAuthorization noAuthorization)
: base(context, httpContextAccessor, noAuthorization)
{
_deviceQueries = deviceQueries;
}
private void PopulateSensorData(SensorData sensorData, SensorContext sensorContext, List <PointerData> pointerDataList)
{
SensorChannelsContext channels = sensorContext.DefaultSensorChannelsContext;
sensorData.AddData(channels.GetChannel(InkSensorType.X), pointerDataList.Select((pd) => pd.X).ToList());
sensorData.AddData(channels.GetChannel(InkSensorType.Y), pointerDataList.Select((pd) => pd.Y).ToList());
sensorData.AddTimestampData(channels.GetChannel(InkSensorType.Timestamp), pointerDataList.Select((pd) => pd.Timestamp).ToList());
}
public GetDevicesByUserOperation(SensorContext context,
IHttpContextAccessor httpContextAccessor,
IDeviceQueries deviceQueries,
INoAuthorization <UserIdDto> authorization)
: base(context, httpContextAccessor, authorization)
{
_deviceQueries = deviceQueries;
}
public GetUsersOperation(SensorContext context,
IHttpContextAccessor httpContextAccessor,
IUserQueries userQueries,
IAdministratorAuthorization noAuthorization)
: base(context, httpContextAccessor, noAuthorization)
{
_userQueries = userQueries;
}
public GetUserByIdOperation(SensorContext context,
IHttpContextAccessor httpContextAccessor,
IUserQueries userQueries,
INoAuthorization <UserIdDto> authorization)
: base(context, httpContextAccessor, authorization)
{
_userQueries = userQueries;
}
public DeleteUserOperation(SensorContext context,
IUserQueries userQueries,
IHttpContextAccessor httpContextAccessor,
IAdministratorAuthorization <UserIdDto> authorization)
: base(context, httpContextAccessor, authorization)
{
_userQueries = userQueries;
}
public UpdateUserOperation(SensorContext context,
IUserQueries userQueries,
IHttpContextAccessor httpContextAccessor,
INoAuthorization <UserDto> authorization)
: base(context, httpContextAccessor, authorization)
{
_userQueries = userQueries;
}
public RefreshTokenOperation(SensorContext context,
IAccountService accountService,
IHttpContextAccessor httpContextAccessor,
INoAuthorization <RefreshTokenDto> authorization)
: base(context, httpContextAccessor, authorization)
{
_accountService = accountService;
}
public GenerateTokenOperation(SensorContext context,
IAccountService accountService,
IHttpContextAccessor httpContextAccessor,
INoAuthorization <LoginDto> noAuthorization)
: base(context, httpContextAccessor, noAuthorization)
{
_accountService = accountService;
}
public SendSensorDataOperation(SensorContext context,
IDeviceQueries deviceQueries,
IHttpContextAccessor httpContextAccessor,
INoAuthorization <UpdateDeviceDataDto> noAuthorization)
: base(context, httpContextAccessor, noAuthorization)
{
_deviceQueries = deviceQueries;
}
protected OperationBase(SensorContext context,
IHttpContextAccessor httpContextAccessor,
IAuthorization <T> authorization)
{
_httpContextAccessor = httpContextAccessor;
_authorization = authorization;
Context = context;
}
public static List <Sensor> RecuperarSensorBarragem(int idBarragem)
{
try {
using (var dbSensor = new SensorContext()) {
return(dbSensor.Records.Where(p => p.IDBarragem == idBarragem).ToList());
}
}
catch (Exception e) {
throw (e);
}
}
public static Sensor RecuperarSensor(int idSensor)
{
try {
using (var dbSensor = new SensorContext()) {
return(dbSensor.Records.Where(p => p.ID == idSensor).FirstOrDefault());
}
}
catch (Exception e) {
throw (e);
}
}
public static List <Sensor> RecuperarSensor()
{
try {
using (var dbSensor = new SensorContext()) {
return(dbSensor.Records.ToList());
}
}
catch (Exception e) {
throw (e);
}
}
public bool setContext(SensorContext context)
{
ctx = context;
if (ctx.ToString() == context.ToString())
{
return(true);
}
else
{
return(false);
}
}
private void AddSensorDataToModel(SensorData sensorData)
{
// Add sensor data if missing
if (!InkDocument.SensorData.ContainsId(sensorData.Id))
{
InkDocument.SensorData.Add(sensorData);
InputContext inputContext = mInputContexts[sensorData.InputContextID];
// Add input context if missing
if (!InkDocument.InputConfiguration.InputContexts.Contains(inputContext))
{
InkDocument.InputConfiguration.InputContexts.Add(inputContext);
Wacom.Ink.Serialization.Model.Environment environment = mEnvironments[inputContext.EnvironmentId];
// Add environment if missing
if (!InkDocument.InputConfiguration.Environments.Contains(environment))
{
InkDocument.InputConfiguration.Environments.Add(environment);
}
SensorContext sensorContext = mSensorContexts[inputContext.SensorContextId];
// Add sensor context if missing
if (!InkDocument.InputConfiguration.SensorContexts.Contains(sensorContext))
{
InkDocument.InputConfiguration.SensorContexts.Add(sensorContext);
// Iterate and add sensor channels contexts if missing
for (int i = 0; i < sensorContext.SensorChannelContexts.Count; i++)
{
SensorChannelsContext sensorChannelsContext = sensorContext.SensorChannelContexts[i];
// Add input device if missing
if (!InkDocument.InputConfiguration.Devices.Contains(sensorChannelsContext.InputDevice))
{
InkDocument.InputConfiguration.Devices.Add(sensorChannelsContext.InputDevice);
}
// Add ink input provider if missing
if (!InkDocument.InputConfiguration.InkInputProviders.Contains(sensorChannelsContext.InkInputProvider))
{
InkDocument.InputConfiguration.InkInputProviders.Add(sensorChannelsContext.InkInputProvider);
}
}
}
}
}
}
public SensorController(SensorContext context)
{
_context = context;
_service = new SensorService();
/*
* if (_context.SensorItems.Count() == 0)
* {
* _context.SensorItems.Add(new SensorItem {Timestamp = 1539112021301,
* Tag = "brasil.sudeste.sensor01",
* Valor = "1"});
* _context.SaveChanges();
* }
*/
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
try
{
var index = int.Parse(_SerializationService.Deserialize(e.Parameter?.ToString()).ToString());
MyPivot.SelectedIndex = index;
using (var db = new SensorContext())
{
Sensors.ItemsSource = db.Sensors.ToList();
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
public App()
{
InitializeComponent();
SplashFactory = (e) => new Views.Splash(e);
#region App settings
var _settings = SettingsService.Instance;
RequestedTheme = _settings.AppTheme;
CacheMaxDuration = _settings.CacheMaxDuration;
ShowShellBackButton = _settings.UseShellBackButton;
#endregion
using (var db = new SensorContext())
{
db.Database.Migrate();
}
}
public Identifier AddSensorData(PointerDeviceType deviceType, List <PointerData> pointerDataList)
{
Identifier inputContextId = mDeviceTypeMap[deviceType];
InputContext inputContext = mInputContexts[inputContextId];
SensorContext sensorContext = mSensorContexts[inputContext.SensorContextId];
// Create sensor data using the input context
SensorData sensorData = new SensorData(
Identifier.FromNewGuid(),
inputContext.Id,
InkState.Plane);
PopulateSensorData(sensorData, sensorContext, pointerDataList);
mSensorDataMap.TryAdd(sensorData.Id, sensorData);
return(sensorData.Id);
}
public static Sensor IncluirSensor(SensorRequest sensorRequest)
{
try {
using (var dbSensor = new SensorContext()) {
Sensor sensor = new Sensor(sensorRequest.IDTipoSensor, sensorRequest.IDBarragem, sensorRequest.Name, sensorRequest.MedicaoMinima, sensorRequest.MedicaoMaximaSeguranca, sensorRequest.MedicaoMaximaAlerta);
dbSensor.Records.Add(sensor);
dbSensor.SaveChanges();
LogSensorLogical.GerarDadosIniciais(sensor.ID);
return(sensor);
}
}
catch (Exception e) {
throw (e);
}
}
