public List <MeterModel> Meters(string groupCode)
{
var result = new List <MeterModel>();
using (var connection = new NpgsqlConnection(_connectionString)) {
var command = new NpgsqlCommand(
@"select m.cups, m.tipo_punto
from coordenadas_acometida g
join datos_geograficos_cups m on g.cups = m.cups
where g.clave_acometida = @GroupCode", connection);
command.Parameters.Add("GroupCode", NpgsqlDbType.Double).Value = double.Parse(groupCode);
connection.Open();
var reader = command.ExecuteReader();
while (reader.Read())
{
var model = new MeterModel {
Code = reader["cups"] as string, Type = reader["tipo_punto"] as string
};
result.Add(model);
}
reader.Close();
}
return(result);
}
public void CheckGetMetersForBuildingWithWrongBuildingId()
{
int wrongBuildingid = -1;
var meterModel = new MeterModel();
meterModel.GetMetersForBuilding(wrongBuildingid);
}
public void CheckGetFoundMeters_With_Correct_City()
{
var meterModel = new MeterModel();
meterModel.GetFoundMeters("Kolding");
Assert.AreNotEqual(0, meterModel.Meters.Count);
}
public void CheckGetRandomMeters_For_Return_Type()
{
var meterModel = new MeterModel();
meterModel.GetRandomMeters();
Assert.IsInstanceOfType(meterModel.Meters, typeof(List<Meter>));
}
public JsonResult GetMetersForBuilding(int buildingId)
{
var model = new MeterModel();
model.GetMetersForBuilding(buildingId);
return(Json(model.Meters, JsonRequestBehavior.AllowGet));
}
public ActionResult FindMetersByDetails()
{
var model = new MeterModel();
model.GetRandomMeters();
return(View(model));
}
public ActionResult ShowSomeMeters()
{
var model = new MeterModel();
model.GetRandomMeters();
return(View(model));
}
public JsonResult GetMetersForFlatPart(int flatPartId)
{
var model = new MeterModel();
model.GetMetersForFlatPart(flatPartId);
return(Json(model.Meters, JsonRequestBehavior.AllowGet));
}
public void CheckGetRandomMeters_For_Return_Instances()
{
var meterModel = new MeterModel();
meterModel.GetRandomMeters();
Assert.AreNotEqual(0,meterModel.Meters.Count);
}
public void CheckGetFoundMeters_With_Wrong_City()
{
var meterModel = new MeterModel();
meterModel.GetFoundMeters("New York");
Assert.AreEqual(0, meterModel.Meters.Count);
}
public void CheckGetMetersForBuildingWithCorrectBuildingId_nullTest()
{
int correctBuildingid = 50;
var meterModel = new MeterModel();
meterModel.GetMetersForBuilding(correctBuildingid);
Assert.IsNotNull(meterModel.Meters);
}
public void CheckGetMetersForBuildingWithCorrectBuildingId_typeTest()
{
int correctBuildingid = 100;
var meterModel = new MeterModel();
meterModel.GetMetersForBuilding(correctBuildingid);
Assert.IsInstanceOfType(meterModel.Meters, typeof(List<Meter>));
}
public ActionResult ShowFoundMeters(string searchString)
{
var model = new MeterModel();
model.GetFoundMeters(searchString);
ViewBag.SearchString = searchString;
return(View(model));
}
public ActionResult Electricity(MeterModel meterModel)
{
meterModel.MetersDifference = meterModel.CurrentMeters - meterModel.LastMeters;
if (meterModel.MetersDifference <= 100)
{
meterModel.SumToPay = (meterModel.MetersDifference * meterModel.RateLess100);
}
else
{
double summary1 = (100 * meterModel.RateLess100);
double summary2 = ((meterModel.MetersDifference - 100) * meterModel.RateMore100);
meterModel.SumToPay = summary1 + summary2;
}
return(View(meterModel));
}
public override Task <MeterModel> GetMeterInfo(MeterLookupModel request, ServerCallContext context)
{
MeterModel output = new MeterModel();
var meter = _context.Meters.Find(request.MeterId);
_logger.LogInformation("Sending Meter response");
if (meter != null)
{
output.MeterId = meter.MeterId;
output.MeterNumber = meter.MeterNumber;
}
return(Task.FromResult(output));
}
public ActionResult ShowRandomMeters()
{
using (var context = new TownUtilityBillSystemEntities())
{
var model = new MeterModel();
var metersDB = context.METER.ToList();
model.TotalCount = metersDB.Count;
CustomizedMethod.Shuffle(metersDB);
metersDB.RemoveRange(meterCountToDisplay, metersDB.Count - meterCountToDisplay);
CreateMeterModelFromMeterList(context, model, metersDB);
var view = View("~/Views/Meter/ShowRandomMeters.cshtml", model);
return(view);
}
}
public IHttpActionResult GetMeterMilesHoursValueList(MeterModel objMeterModel)
{
var ObjServiceResponseModel = new ServiceResponseModel <List <eFleetMeterModel> >();
try
{
if (objMeterModel != null && objMeterModel.ServiceAuthKey != null && objMeterModel.UserId > 0)
{
// var ObjPreventativeMaintenaceManager = new PreventativeMaintenaceManager();
var meterList = _IEfleetPM.GetAllMilesValue();
if (meterList.Count > 0)
{
ObjServiceResponseModel.Response = Convert.ToInt32(ServiceResponse.SuccessResponse, CultureInfo.CurrentCulture);
ObjServiceResponseModel.Message = CommonMessage.Successful();
ObjServiceResponseModel.Data = meterList;
}
else
{
ObjServiceResponseModel.Response = Convert.ToInt32(ServiceResponse.NoRecord, CultureInfo.CurrentCulture);
ObjServiceResponseModel.Message = CommonMessage.NoRecordMessage();
}
return(Ok(ObjServiceResponseModel));
}
else
{
ObjServiceResponseModel.Response = Convert.ToInt32(ServiceResponse.FailedResponse, CultureInfo.CurrentCulture);
ObjServiceResponseModel.Message = CommonMessage.InvalidUser();
return(Ok(ObjServiceResponseModel));
}
}
catch (Exception ex)
{
ObjServiceResponseModel.Message = ex.Message;
ObjServiceResponseModel.Response = Convert.ToInt32(ServiceResponse.ExeptionResponse, CultureInfo.CurrentCulture);
ObjServiceResponseModel.Data = null;
return(Ok(ObjServiceResponseModel));
}
}
public MeterModel Random()
{
var meterModel = new MeterModel
{
Meter01 = _r.Next(0, 100),
Meter02 = _r.Next(0, 100),
Meter03 = _r.Next(0, 100),
Meter04 = _r.Next(0, 100),
Meter05 = _r.Next(0, 100),
Meter06 = _r.Next(0, 100),
Meter07 = _r.Next(0, 100),
Meter08 = _r.Next(0, 100),
Meter09 = _r.Next(0, 100),
Meter10 = _r.Next(0, 100),
Meter11 = _r.Next(0, 100),
Meter12 = _r.Next(0, 100),
Meter13 = _r.Next(0, 100),
Meter14 = _r.Next(0, 100),
Meter15 = _r.Next(0, 100),
Meter16 = _r.Next(0, 100),
Meter17 = _r.Next(0, 100),
Meter18 = _r.Next(0, 100),
Meter19 = _r.Next(0, 100),
Meter20 = _r.Next(0, 100),
Meter21 = _r.Next(0, 100),
Meter22 = _r.Next(0, 100),
Meter23 = _r.Next(0, 100),
Meter24 = _r.Next(0, 100),
Meter25 = _r.Next(0, 100),
Meter26 = _r.Next(0, 100),
Meter27 = _r.Next(0, 100),
Meter28 = _r.Next(0, 100),
Meter29 = _r.Next(0, 100),
Meter30 = _r.Next(0, 100)
};
return(meterModel);
}
public ActionResult Edit(MeterModel model)
{
var meter = _meterRepository.GetById(model.Id);
if (ModelState.IsValid)
{
meter = model.ToEntity(meter);
//always set IsNew to false when saving
meter.IsNew = false;
_meterRepository.Update(meter);
//commit all changes
this._dbContext.SaveChanges();
//notification
SuccessNotification(_localizationService.GetResource("Record.Saved"));
return(new NullJsonResult());
}
else
{
return(Json(new { Errors = ModelState.SerializeErrors() }));
}
}
public ActionResult ShowFoundMeters(string searchString)
{
using (var context = new TownUtilityBillSystemEntities())
{
var model = new MeterModel();
var metersDB = (from m in context.METER
where
m.SERIAL_NUMBER.Contains(searchString) ||
m.METER_TYPE.NAME.Contains(searchString) ||
m.METER_TYPE.UTILITY.NAME.Contains(searchString) ||
m.ADDRESS.STREET.NAME.Contains(searchString) ||
m.ADDRESS.TOWN.NAME.Contains(searchString) ||
m.ADDRESS.FLAT_PART.NAME.Contains(searchString) ||
m.ADDRESS.INDEX.VALUE.ToString().Contains(searchString)
select m
).ToList();
CreateMeterModelFromMeterList(context, model, metersDB);
ViewBag.SearchString = searchString;
return(View(model));
}
}
public MeterModel Update(MeterModel meterModel)
{
_iogContext.Update(meterModel);
_iogContext.SaveChanges();
return(meterModel);
}
public MeterModel Save(MeterModel meterModel)
{
_iogContext.MeterModels.Add(meterModel);
_iogContext.SaveChanges();
return(meterModel);
}
/// <summary>
/// Task for starting the R2 and receiving meters over the COM Port.
/// </summary>
/// <returns></returns>
private async Task R2Listen()
{
//Gets any devices associated with the R2 port
var aqsFilter = SerialDevice.GetDeviceSelector(R2Device.PortName);
var devices = await DeviceInformation.FindAllAsync(aqsFilter);
if (devices.Any())
{
var deviceId = devices.First().Id;
//This redundancy ensures the device is supplies a valid datareader object
using (SerialDevice device = await SerialDevice.FromIdAsync(deviceId))
{
if (device != null)
{
var readCancellationTokenSource = new CancellationTokenSource();
//DataReader dataReaderObject = new DataReader(device.InputStream);
//Reading variables
R2PacketModel R2Model;
int lineCount = 0;
StringBuilder OutputBuilder = new StringBuilder();
bool packetStart = false, packetEnd = false;
string endpointId = "", reading = "", flag = "", rssi = "";
DateTime date = new DateTime();
TimeSpan time = new TimeSpan();
//GetLog tests
//R2I8 r = new R2I8();
//await r.ExecuteGetLog(device, "7072600", 11520);
//var resp = await R2.Listen(device, readCancellationTokenSource, R2PacketHeader.I8LogDetails, R2PacketHeader.I8LogStart, R2PacketHeader.I8LogCompleted, 30, 1);
Stream str = device.InputStream.AsStreamForRead(0);
IsR2Listening = true;
while (IsR2Initialized && IsR2Listening)
{
byte[] buffer = new byte[1];
string response = "";
while (!packetStart || !packetEnd)
{
int readCount = await str.ReadAsync(buffer, 0, 1, readCancellationTokenSource.Token);//.ConfigureAwait(false);
string temp = Encoding.UTF8.GetString(buffer);
//temp.AddRange(Regex.Split(resp, @"(?<=[$&])"));
//string temp = await R2.Listen(device, readCancellationTokenSource, dataReaderObject, 80, true);
response += temp;
if (temp == "+" || temp == "*")
{
packetStart = true;
}
else if (temp == "$" || temp == "&")
{
packetEnd = true;
}
if (!packetStart && packetEnd)
{
packetEnd = false;
}
}
//If a start and end char are found, begin parsing
if (packetStart && packetEnd)//foreach (string response in temp)
{
packetStart = false;
packetEnd = false;
R2Model = await R2ReadPacketResponseAsync.ParseR2PacketResponse(response);
if (R2Model.R2M2WPacketModel != null || R2Model.R2NRDPacketModel != null)
{
if (R2Model.R2M2WPacketModel != null)
{
//Set Database Variables
endpointId = R2Model.R2M2WPacketModel.EndpointId;
reading = R2Model.R2M2WPacketModel.Reading;
date = R2Model.R2M2WPacketModel.ReadTime.Date;
time = R2Model.R2M2WPacketModel.ReadTime.TimeOfDay;
flag = R2Model.R2M2WPacketModel.Flag;
rssi = R2Model.R2M2WPacketModel.RSSI;
}
if (R2Model.R2NRDPacketModel != null)
{
//Set Database Variables
endpointId = R2Model.R2NRDPacketModel.EndpointId;
reading = R2Model.R2NRDPacketModel.Reading;
date = R2Model.R2NRDPacketModel.ReadTime.Date;
time = R2Model.R2NRDPacketModel.ReadTime.TimeOfDay;
flag = R2Model.R2NRDPacketModel.Flag;
rssi = R2Model.R2NRDPacketModel.RSSI;
}
//Add to display list
if (lineCount > 21)
{
OutputBuilder.Remove(0, OutputBuilder.ToString().IndexOf('\n') + 1);
}
OutputBuilder.Append("ID: " + endpointId + "\n");
R2Packet = OutputBuilder.ToString();
lineCount++;
//Update Database
if (!(ReadIds.Contains(endpointId)))// && (Meters.Where(meter => meter.MeterInfo.MeterId == endpointId)).Any())
{
MeterModel receivedMeter = Meters.FirstOrDefault(meter => meter.MeterInfo.MeterId == endpointId);
if (receivedMeter != null)
{
int index = Meters.IndexOf(receivedMeter);
Meters[index].MeterInfo.Reading = reading;
Meters[index].ReadUpdated = true;
MeterSyncQueue.Enqueue(Meters[index].MeterInfo);
}
else
{
MeterSyncQueue.Enqueue(new JsonMeterModel()
{
MeterId = endpointId, Reading = reading
});
}
ReadIds.Add(endpointId);
ReadEndpoints++;
//await Task.Delay(10);
////(@ID, @Read, @Date, @Time, @Codes, @RSSI, @HiUse, @Voltage);";
//Database.UpdateReadCommand.Parameters.Add(new SqliteParameter("Id", endpointId));
//Database.UpdateReadCommand.Parameters.Add(new SqliteParameter("Read", reading));
//Database.UpdateReadCommand.Parameters.Add(new SqliteParameter("Date", date));
//Database.UpdateReadCommand.Parameters.Add(new SqliteParameter("Time", time));
//Database.UpdateReadCommand.Parameters.Add(new SqliteParameter("Codes", flag));
//Database.UpdateReadCommand.Parameters.Add(new SqliteParameter("RSSI", rssi));
////Database.UpdateReadCommand.Parameters.Add(new SqliteParameter("HiUse", hiUse));
////Database.UpdateReadCommand.Parameters.Add(new SqliteParameter("Voltage", voltage));
//Database.ExecuteCommand(Database.UpdateReadCommand);
//if (Database.DatabaseFile != null && _userFolder != null)
//{
// await Database.DatabaseFile.CopyAsync(_userFolder, _userFile.Name, NameCollisionOption.ReplaceExisting);
//}
}
}
}
}
//end thread
await PushReadsToCloud();
SyncStatus = "Syncronized";
}
}
}
}
public static Meter ToEntity(this MeterModel model)
{
return(model.MapTo <MeterModel, Meter>());
}
private static void CreateMeterModelFromMeterList(TownUtilityBillSystemEntities context, MeterModel model, List <METER> metersDB)
{
foreach (var m in metersDB)
{
var meterTypeDB = context.METER_TYPE.Where(mt => mt.ID == m.METER_TYPE_ID).FirstOrDefault();
var utilityDB = context.UTILITY.Where(u => u.ID == meterTypeDB.UTILITY_ID).FirstOrDefault();
var addressDB = context.ADDRESS.Where(a => a.ID == m.ADDRESS_ID).FirstOrDefault();
var indexDB = context.INDEX.Where(i => i.ID == addressDB.INDEX_ID).FirstOrDefault();
var townDB = context.TOWN.Where(t => t.ID == addressDB.TOWN_ID).FirstOrDefault();
var streetDB = context.STREET.Where(s => s.ID == addressDB.STREET_ID).FirstOrDefault();
var buildingDB = context.BUILDING.Where(b => b.ID == addressDB.BUILDING_ID).FirstOrDefault();
var flatPartDB = context.FLAT_PART.Where(fp => fp.ID == addressDB.FLAT_PART_ID).FirstOrDefault();
var utility = new Utility()
{
Id = utilityDB.ID, Name = utilityDB.NAME
};
var meterType = new MeterType()
{
Id = meterTypeDB.ID, Name = meterTypeDB.NAME, Utility = utility
};
var index = new Index()
{
Id = indexDB.ID, Value = indexDB.VALUE
};
var town = new Town()
{
Id = townDB.ID, Name = townDB.NAME
};
var street = new Street()
{
Id = streetDB.ID, Name = streetDB.NAME
};
var building = new Building()
{
Id = buildingDB.ID, Number = buildingDB.NUMBER
};
FlatPart flatPart = null;
if (flatPartDB != null)
{
if (!String.IsNullOrEmpty(flatPartDB.NAME) && !flatPartDB.NUMBER.HasValue)
{
flatPart = new FlatPart()
{
Id = flatPartDB.ID, Name = flatPartDB.NAME
}
}
;
else if (String.IsNullOrEmpty(flatPartDB.NAME) && flatPartDB.NUMBER.HasValue)
{
flatPart = new FlatPart()
{
Id = flatPartDB.ID, Number = (int)flatPartDB.NUMBER
}
}
;
else if (!String.IsNullOrEmpty(flatPartDB.NAME) && flatPartDB.NUMBER.HasValue)
{
flatPart = new FlatPart()
{
Id = flatPartDB.ID, Number = (int)flatPartDB.NUMBER, Name = flatPartDB.NAME
}
}
;
}
var address = new Address()
{
Id = addressDB.ID, Index = index, Town = town, Street = street, Building = building, FlatPart = flatPart
};
model.Meters.Add(new Meter()
{
Id = m.ID, SerialNumber = m.SERIAL_NUMBER, ReleaseDate = m.RELEASE_DATE, VarificationDate = m.VARIFICATION_DATE, MeterType = meterType, Address = address
});
}
}
public static Meter ToEntity(this MeterModel model, Meter destination)
{
return(model.MapTo(destination));
}
