public Sensor GetByID(int id)
{
using (var entityConntext = new GeoViewerEntities())
{
return entityConntext.Sensors.SingleOrDefault(ent => ent.SensorID == id);
}
}
public Project GetByID(int id)
{
using (var entityConntext = new GeoViewerEntities())
{
return entityConntext.Projects.SingleOrDefault(ent => ent.ProjectID == id);
}
}
public Group GetGroupByID(int id)
{
using (var entityConntext = new GeoViewerEntities())
{
return entityConntext.Groups.SingleOrDefault(ent => ent.GroupID == id);
}
}
public bool IsUserInRole(string username, string role)
{
using (var entityConntext = new GeoViewerEntities())
{
return entityConntext.Accounts.Any(ent => ent.Username == username && ent.Roles.Any(r => r.RoleName == role));
}
}
/// <summary>
/// Check the sensor corressponding to picture view object has running alarm?
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public bool CheckAlarmRunning(Models.Object obj)
{
using (var entityContext = new GeoViewerEntities())
{
if (obj.Type == OBJECT_TYPE_IMAGE) return false;
if (obj.Type != OBJECT_TYPE_GROUP_INDICATOR)
{
// Parameters contain id of sensor which will be displayed
int sensorID = obj.Parameters.ToInt32TryParse();
var sensor = entityContext.Sensors.SingleOrDefault(ent => ent.SensorID == sensorID);
if (sensor == null) return false;
return sensor.AlarmEnabled && sensor.AlarmFlag;
}
// Get picture view corressponding to this object (type OBJECT_TYPE_GROUP_INDICATOR)
int pictureID = obj.Parameters.ToInt32TryParse();
var pictureView = entityContext.PictureViews.SingleOrDefault(ent => ent.PictureViewID == pictureID);
if (pictureView != null)
{
foreach (var viewObject in pictureView.Objects)
{
// Fix circle recursive
if (viewObject.ObjectID == obj.ObjectID) return false;
if (CheckAlarmRunning(viewObject))
{
return true;
}
}
}
return false;
}
}
public bool Insert(Logger obj)
{
bool result = false;
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_DATA_MANAGE);
Validate(obj);
obj.ProjectID = AppContext.Current.OpenProject.ProjectID;
obj.CreatedDate = obj.LastEditedDate = DateTime.Now;
obj.CreatedUser = obj.LastEditedUser = AppContext.Current.LogedInUser.Username;
entityConntext.Loggers.AddObject(obj);
result = entityConntext.SaveChanges() > 0;
}
// Auto Add Sensor
if (result)
{
DataReaderBLL.Current.ReadHeader(obj.LoggerID);
}
//foreach (var sensor in obj.Sensors)
//{
// obj.CreatedDate = obj.LastEditedDate = DateTime.Now;
// obj.CreatedUser = obj.LastEditedUser = AppContext.Current.LogedInUser.Username;
//}
return result;
}
public MainForm()
{
// Check connection to database
GeoViewerEntities context = null;
try
{
context = new GeoViewerEntities();
var list = context.Accounts.Count();
}
catch (Exception)
{
if (context != null) context.Dispose();
if (new SetupDatabase().ShowDialog() != DialogResult.OK)
{
Environment.Exit(0);
}
}
// Check licence
if (!LicenceBLL.ValidateKey())
{
if (new AddLicenceForm().ShowDialog() != DialogResult.OK)
{
Environment.Exit(0);
}
}
connectedToDatabase = true;
MainApplicationForm = this;
InitializeComponent();
// Check connection to database
// Run background process
ReaderThreadManager.Current.InitThreads();
ReaderThreadManager.Current.StartThreads();
}
/// <summary>
/// LogedIn user changes his password
/// </summary>
/// <param name="oldPassword"></param>
/// <param name="newPassword"></param>
/// <returns></returns>
public bool ChangePassword(string oldPassword, string newPassword)
{
using (var entityConntext = new GeoViewerEntities())
{
if (AppContext.Current.LogedInUser.Password != oldPassword.GetMd5Hash())
throw new Exception(Properties.Resources.Error_OldPasswordNotMatch);
AppContext.Current.LogedInUser.Password = newPassword.GetMd5Hash();
entityConntext.AttachUpdatedObject(AppContext.Current.LogedInUser);
return entityConntext.SaveChanges() > 0;
}
}
//public bool DeleteGroup(Group obj)
//{
// using (var entityConntext = new GeoViewerEntities())
// {
// SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_VIEWS_MANAGE);
// entityConntext.Groups.DeleteObject(obj);
// return entityConntext.SaveChanges() > 0;
// }
//}
public bool DeleteGroup(int id)
{
using (var entityConntext = new GeoViewerEntities())
{
var obj = entityConntext.Groups.SingleOrDefault(ent => ent.GroupID == id);
if (obj != null)
{
entityConntext.Groups.DeleteObject(obj);
return entityConntext.SaveChanges() > 0;
}
return false;
}
}
public bool InsertGroup(Group obj)
{
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_VIEWS_MANAGE);
ValidateGroup(obj);
obj.ProjectID = AppContext.Current.OpenProject.ProjectID;
obj.CreatedDate = obj.LastEditedDate = DateTime.Now;
obj.CreatedUser = obj.LastEditedUser = AppContext.Current.LogedInUser.Username;
entityConntext.Groups.AddObject(obj);
return entityConntext.SaveChanges() > 0;
}
}
/// <summary>
/// Admin change password of an user
/// </summary>
/// <param name="user"></param>
/// <param name="newPassword"></param>
/// <returns></returns>
public bool ChangePassword(Account user, string newPassword)
{
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(new string[]
{
SecurityBLL.ROLE_ACCOUNT_EDIT,
SecurityBLL.ROLE_ACCOUNT_MANAGE
});
user.Password = newPassword.GetMd5Hash();
entityConntext.AttachUpdatedObject(user);
return entityConntext.SaveChanges() > 0;
}
}
//public bool Delete(Logger obj)
//{
// SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_DATA_MANAGE);
// entityConntext.Loggers.DeleteObject(obj);
// DataReaderBLL.Current.RemoveThread(obj);
// bool result = entityConntext.SaveChanges() > 0;
// return result;
//}
public bool Delete(int id)
{
using (var entityConntext = new GeoViewerEntities())
{
var obj = entityConntext.Loggers.SingleOrDefault(ent => ent.LoggerID == id);
if (obj != null)
{
ReaderThreadManager.Current.RemoveThread(obj);
entityConntext.Loggers.DeleteObject(obj);
return entityConntext.SaveChanges() > 0;
}
return false;
}
}
public DataTable BindToDataTable(List<Sensor> sensors, bool rawValue = true, DateTime? startDate = null, DateTime? endDate = null)
{
// fix datetime
if (startDate != null)
{
startDate = new DateTime(startDate.Value.Year, startDate.Value.Month, startDate.Value.Day, 0, 0, 0);
}
if (endDate != null)
{
endDate = new DateTime(endDate.Value.Year, endDate.Value.Month, endDate.Value.Day, 23, 59, 59);
}
using (var entityContext = new GeoViewerEntities())
{
DataTable table = new DataTable();
if (sensors == null) return table;
var col = table.Columns.Add("MeaTime", typeof(DateTime));
table.PrimaryKey = new DataColumn[] { col };
foreach (var sensor in sensors)
{
table.Columns.Add(GetColumnName(sensor), typeof(string));
}
foreach (var sensor in sensors)
{
foreach (var value in entityContext.SensorValues.Where(ent => ent.SensorID == sensor.SensorID &&
(startDate == null || ent.MeaTime >= startDate) &&
(endDate == null || ent.MeaTime <= endDate)
).ToList())
{
var row = table.Rows.Find(value.MeaTime);
if (row == null)
{
row = table.NewRow();
row["MeaTime"] = value.MeaTime;
row[GetColumnName(sensor)] = rawValue ? value.RawValue : value.CalcValue;
table.Rows.Add(row);
}
else
{
row[GetColumnName(sensor)] = rawValue ? value.RawValue : value.CalcValue;
}
}
}
return table;
}
}
/// <summary>
/// Back up to file
/// </summary>
/// <param name="folderPath">folder will contain backup file</param>
/// <returns></returns>
public string BackupToFile(string folderPath)
{
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_DATA_MANAGE);
// Make backup folder name
string backupFolder = folderPath + @"\GeoViewer_" + DateTime.Now.ToString("ddMMyyyy-hhmm") + "_" +
GeneralUtils.GenerateRandomString(4);
// Create temp folder
Directory.CreateDirectory(backupFolder);
// Copy files data
foreach (var obj in entityConntext.Loggers)
{
// Copy data files
FileInfo file = new FileInfo(obj.DataPath);
if (file.Exists)
{
File.Copy(obj.DataPath, backupFolder + @"\" + obj.LoggerID + file.Extension, true);
}
else
{
CopyFolder(obj.DataPath, backupFolder + @"\" + obj.LoggerID);
}
}
// Back up database
entityConntext.ExecuteStoreCommand(
"backup database " + databaseName + " to disk = '" + backupFolder + @"\database.bak'",
null);
// Copy Pictures folder
CopyFolder("Pictures", backupFolder + @"\Pictures");
// Zip to file
ZipFile zip = new ZipFile();
zip.AddDirectory(backupFolder);
zip.Save(backupFolder + ".zip");
// Delete file after zipped
DeleteFolder(backupFolder);
return backupFolder + ".zip";
}
}
//public bool Delete(Project obj)
//{
// SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_DATA_MANAGE);
// // Delete all groups in this project
// foreach (var group in obj.Groups.ToList())
// {
// entityConntext.Groups.DeleteObject(group);
// }
// entityConntext.Projects.DeleteObject(obj);
// bool result = entityConntext.SaveChanges() > 0;
// if (result && AppContext.Current.OpenProject.ProjectID == obj.ProjectID)
// {
// CloseProject();
// }
// return result;
//}
public bool Delete(int id)
{
using (var entityConntext = new GeoViewerEntities())
{
var obj = entityConntext.Projects.SingleOrDefault(ent => ent.ProjectID == id);
if (obj != null)
{
// Delete all groups in this project
foreach (var group in obj.Groups.ToList())
{
entityConntext.Groups.DeleteObject(group);
}
entityConntext.Projects.DeleteObject(obj);
bool result = entityConntext.SaveChanges() > 0;
if (result && AppContext.Current.OpenProject.ProjectID == obj.ProjectID)
{
CloseProject();
}
return result;
}
return false;
}
}
public AppContext()
{
_entityContext = new GeoViewerEntities();
}
public bool Insert(AlarmLog obj)
{
using (var entityConntext = new GeoViewerEntities())
{
Validate(obj);
if (AppContext.Current.OpenProject != null) obj.ProjectID = AppContext.Current.OpenProject.ProjectID;
obj.IsEnded = false;
entityConntext.AlarmLogs.AddObject(obj);
return entityConntext.SaveChanges() > 0;
}
}
public DateTime? GetLastTime()
{
using (var entityConntext = new GeoViewerEntities())
{
var last = entityConntext.AlarmLogs.OrderByDescending(ent => ent.StartAlarmDatetime).FirstOrDefault();
if (last != null)
return last.StartAlarmDatetime;
return null;
}
}
public AlarmLog GetByID(long id)
{
using (var entityConntext = new GeoViewerEntities())
{
return entityConntext.AlarmLogs.SingleOrDefault(ent => ent.AlarmLogID == id);
}
}
/// <summary>
/// Get list of alarm logs by conditions, pass parameters null for select all (no condition)
/// </summary>
/// <param name="sensor">only select alarm logs for this sensor</param>
/// <param name="startDate">select alarm logs from start date</param>
/// <param name="endDate">select alarm logs to end date</param>
/// <param name="isEnded">select alarm logs which marked IsEnded = true or fasle</param>
/// <param name="start">started record</param>
/// <param name="limit">number of record will return</param>
/// <returns></returns>
public List<AlarmLog> GetByConditions(Sensor sensor = null, DateTime? startDate = null, DateTime? endDate = null, bool? isEnded = null, int start = -1, int limit = -1)
{
using (var entityConntext = new GeoViewerEntities())
{
int? sensorID = sensor == null ? null : (int?)sensor.SensorID;
var result = entityConntext.AlarmLogs.Where(ent =>
(sensorID == null || ent.SensorID == sensorID) &&
(startDate == null || ent.StartAlarmDatetime >= startDate) &&
(endDate == null || ent.StartAlarmDatetime <= endDate) &&
(isEnded == null || ent.IsEnded == isEnded)
).OrderByDescending(ent => ent.StartAlarmDatetime).ThenByDescending(ent => ent.AlarmLogID);
if (start >= 0 && limit > 0)
{
return result.Skip(start).Take(limit).ToList();
}
return result.ToList();
}
}
public bool Delete(long[] ids)
{
using (var entityConntext = new GeoViewerEntities())
{
//SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_ALARM_MANAGE);
foreach (var id in ids)
{
var obj = entityConntext.AlarmLogs.SingleOrDefault(ent => ent.AlarmLogID == id);
if (obj != null)
entityConntext.AlarmLogs.DeleteObject(obj);
}
return entityConntext.SaveChanges() > 0;
}
}
/// <summary>
/// Restore from file
/// </summary>
/// <param name="filePath">Backup file to restore</param>
public void RestoreFromFile(string filePath)
{
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_DATA_MANAGE);
// Check the file exist
FileInfo fileInfo = new FileInfo(filePath);
if (!fileInfo.Exists) throw new Exception(Resources.Error_BackupFileNotExist);
// First extract the backup zip file
string folder = fileInfo.FullName.Substring(0, fileInfo.FullName.LastIndexOf("."));
if (Directory.Exists(folder)) DeleteFolder(folder);
ZipFile zip = ZipFile.Read(filePath);
zip.ExtractAll(folder);
Console.WriteLine("Extract temp file to folder " + folder);
// Restore the database
string databasePath = folder + @"\database.bak";
if (!File.Exists(databasePath)) throw new Exception(Resources.Error_DatabaseNotExist);
entityConntext.ExecuteStoreCommand("use master restore database " + databaseName + " from disk = '" +
databasePath + "'");
Console.WriteLine("Restore database ok!");
// Refresh data
//AppContext.Current.RefreshEntityContext();
AccountBLL.Current.Logout();
AppContext.Current.OpenProject = null;
// Overwrite data files
foreach (var obj in entityConntext.Loggers)
{
if (!obj.DataPath.Contains("."))
{
// Copy folder
if (Directory.Exists(folder + @"\" + obj.LoggerID))
CopyFolder(folder + @"\" + obj.LoggerID, obj.DataPath);
Console.WriteLine("Copy folder to " + obj.DataPath);
}
else
{
// Copy file
string sourceFile = folder + @"\" + obj.LoggerID +
obj.DataPath.Substring(obj.DataPath.LastIndexOf("."));
if (File.Exists(sourceFile))
{
File.Copy(sourceFile, obj.DataPath, true);
Console.WriteLine("Copy file to " + obj.DataPath);
}
}
}
// Overwrite picture
CopyFolder(folder + @"\Pictures", "Pictures");
// Delete temp file and folder
DeleteFolder(folder);
Console.WriteLine("Delete folder " + folder);
}
}
/// <summary>
/// Read data from file with option onlyNewData and calculateValue
/// </summary>
/// <param name="logger"></param>
/// <param name="dataPath"></param>
/// <param name="onlyNewData"></param>
/// <param name="calculateValue"></param>
/// <param name="refreshEntityContext"></param>
public void ReadData(Logger logger, string dataPath, bool onlyNewData, bool calculateValue, ReaderProccess readerProccess)
{
try
{
Console.WriteLine("Thread[" + Thread.CurrentThread.ManagedThreadId + "]: Start read data file " + dataPath);
ReaderProccess fileReaderProccess;
if (readerProccess.FileReaderProccesses == null)
{
fileReaderProccess = readerProccess;
}
else
{
fileReaderProccess = new ReaderProccess();
fileReaderProccess.TotalRecord = FileUtils.CountTotalLines(dataPath);
readerProccess.FileReaderProccesses.Add(fileReaderProccess);
}
fileReaderProccess.CurrentFile = dataPath;
bool readFolder = !logger.DataPath.Equals(dataPath);
var file = new FileInfo(dataPath);
// Only read if file is modified
if (onlyNewData)
{
if (readFolder)
{
if (logger.LastModifyDatetime >= file.LastWriteTime && logger.Meta.Contains(file.Name)) return;
}
else
{
if (logger.LastModifyDatetime >= file.LastWriteTime || logger.FileSize == file.Length) return;
}
}
var streamReader = new StreamReader(dataPath, Encoding.UTF8);
var spiliter = new[] { logger.Delimiter };
// read meta line
string lineData = streamReader.ReadLine();
fileReaderProccess.ReadRecord++;
if (String.IsNullOrEmpty(lineData))
{
Console.WriteLine("File Empty!");
return;
}
// check type of data file
int type = 0;
string[] firstlineCells = lineData.Split(spiliter, StringSplitOptions.None);
if (firstlineCells[0].ToInt32TryParse() > 0 && firstlineCells[1].ToInt32TryParse() > 0)
{
type = 1;
}
if (type == 0)
{
// Ignore 4 first lines
for (int i = 0; i < 4; i++)
{
lineData = streamReader.ReadLine();
fileReaderProccess.ReadRecord++;
}
}
// Begin to read data
var entityConntext = new GeoViewerEntities();
var sensors = entityConntext.Sensors.Where(ent => ent.LoggerID == logger.LoggerID).OrderBy(ent => ent.ColumnIndex).ToList();
int line = 0;
do
{
if (!string.IsNullOrEmpty(lineData.Trim()))
{
string[] cells = lineData.Split(spiliter, StringSplitOptions.None);
var meaTime = type == 0
? Convert.ToDateTime(CleanValue(cells[0]))
: new DateTime(cells[1].ToInt32TryParse(), 1, 1).AddDays(
cells[2].ToInt32TryParse()).AddMinutes(
(int)(cells[3].ToInt32TryParse() * 60 / 100));
// Only read new record (by time)
if (!(onlyNewData && !readFolder && meaTime >= logger.FirstLogDatetime &&
meaTime <= logger.LastLogDatetime))
{
var valuesNeedCalc = new List<SensorValue>();
foreach (var sensor in sensors)
{
if (cells.Length > sensor.ColumnIndex)
{
// Check Value exist
//var sensorValue = sensor.SensorValues.SingleOrDefault(ent => ent.MeaTime == meaTime);
var sensorValue = entityConntext.SensorValues.SingleOrDefault(ent => ent.SensorID == sensor.SensorID && ent.MeaTime == meaTime);
if (sensorValue == null)
{
sensorValue = new SensorValue();
sensorValue.SensorID = sensor.SensorID;
sensorValue.MeaTime = meaTime;
sensor.SensorValues.Add(sensorValue);
}
sensorValue.RawValue = CleanValue(cells[sensor.ColumnIndex]).ToDecimalTryParse();
valuesNeedCalc.Add(sensorValue);
}
}
// Calc Value & Alarm Logger
if (calculateValue)
{
foreach (var sensorValue in valuesNeedCalc)
{
CalculationBLL.Current.Calculating(sensorValue, true);
}
}
}
line++;
if (line % 50 == 0)
{
entityConntext.SaveChanges();
entityConntext = new GeoViewerEntities();
sensors = entityConntext.Sensors.Where(ent => ent.LoggerID == logger.LoggerID).OrderBy(ent => ent.ColumnIndex).ToList();
Console.WriteLine("Thread[" + Thread.CurrentThread.ManagedThreadId + "]: Read success " + line + " lines in " + dataPath);
}
}
// go to nextline
lineData = streamReader.ReadLine();
fileReaderProccess.ReadRecord++;
} while ((lineData != null));
streamReader.Close();
if (fileReaderProccess.ReadRecord > 0)
{
fileReaderProccess.ReadRecord--;
}
if (line > 0 && line % 50 != 0)
{
entityConntext.SaveChanges();
Console.WriteLine("Thread[" + Thread.CurrentThread.ManagedThreadId + "]: Read success " + line + " lines in " + dataPath);
}
Console.WriteLine("Thread[" + Thread.CurrentThread.ManagedThreadId + "]: End read data from " + dataPath);
if (readerProccess.FileReaderProccesses != null)
{
readerProccess.ReadRecord += fileReaderProccess.ReadRecord;
}
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
}
public bool InsertObject(Models.Object obj)
{
bool result = false;
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_VIEWS_MANAGE);
ValidateObject(obj);
obj.CreatedDate = obj.LastEditedDate = DateTime.Now;
obj.CreatedUser = obj.LastEditedUser = AppContext.Current.LogedInUser.Username;
entityConntext.Objects.AddObject(obj);
result = entityConntext.SaveChanges() > 0;
}
if (obj.Type == OBJECT_TYPE_IMAGE && obj.ObjectID > 0)
{
string imagePath = PictureViewBLL.Current.CopyImageFile(obj.Parameters, obj.ObjectID);
obj.Parameters = imagePath;
UpdateObject(obj);
}
return result;
}
/// <summary>
/// Find all loggers which set AutomaticReadData = true and ReadData for it (only new data,calculate value)
/// </summary>
public void ReadData()
{
using (var entityConntext = new GeoViewerEntities())
{
foreach (var logger in entityConntext.Loggers.Where(ent => ent.AutomaticReadData).ToList())
{
int totalRecords;
int readRecords;
string currentFile;
ReadData(logger.LoggerID, true, true, new ReaderProccess());
}
}
}
/// <summary>
/// Read header, automatic add sensors' information to database
/// </summary>
/// <param name="logger"></param>
public void ReadHeader(int loggerID)
{
using (var entityConntext = new GeoViewerEntities())
{
Logger logger = entityConntext.Loggers.SingleOrDefault(ent => ent.LoggerID == loggerID);
if (logger == null) return;
bool readFolder = !File.Exists(logger.DataPath);
StreamReader streamReader;
if (readFolder)
{
DirectoryInfo directoryInfo = new DirectoryInfo(logger.DataPath);
if (!directoryInfo.Exists) throw new Exception(Properties.Resources.Error_Data_FileNotFound);
var files = directoryInfo.GetFiles();
if (files.Length == 0) throw new Exception(Properties.Resources.Error_Data_FileNotFound);
streamReader = new StreamReader(files[0].FullName, Encoding.UTF8);
}
else
{
streamReader = new StreamReader(logger.DataPath, Encoding.UTF8);
}
var spiliter = new string[] { logger.Delimiter };
// read meta line
string firstline = streamReader.ReadLine();
// check type of data file
int type = 0;
string[] cells = firstline.Split(spiliter, StringSplitOptions.None);
if (cells[0].ToInt32TryParse() > 0 && cells[1].ToInt32TryParse() > 0)
{
type = 1;
}
if (type == 0)
{
logger.Meta = firstline;
// read header line
string header = streamReader.ReadLine();
// read after header line
string afterHeader = streamReader.ReadLine();
// read Units line
string units = streamReader.ReadLine();
string[] sensorNames = header.Split(spiliter, StringSplitOptions.RemoveEmptyEntries);
string[] sensorUnits = units.Split(spiliter, StringSplitOptions.RemoveEmptyEntries);
// Two colums for Timestamp and record number
for (int i = 2; i < sensorNames.Length; i++)
{
var sensor = new Sensor();
// Set project ID
sensor.ProjectID = logger.ProjectID;
sensor.Logger = logger;
sensor.ColumnIndex = i;
sensor.Name = CleanValue(sensorNames[i]);
sensor.Unit = sensorUnits.Length >= i ? CleanValue(sensorUnits[i]) : "";
sensor.CreatedDate = sensor.LastEditedDate = DateTime.Now;
sensor.CreatedUser = sensor.LastEditedUser = AppContext.Current.LogedInUser.Username;
logger.Sensors.Add(sensor);
}
logger.TotalSensor = sensorNames.Length - 2;
}
else if (type == 1)
{
logger.Meta = "DS Index: " + cells[0] + "; IP Address: " + cells[4] + "#";
logger.TotalSensor = cells.Length - 5;
for (int i = 5; i < cells.Length; i++)
{
var sensor = new Sensor();
sensor.Logger = logger;
// Set project ID
sensor.ProjectID = logger.ProjectID;
sensor.ColumnIndex = i;
sensor.Name = "Column " + (i);
sensor.Unit = "Unit " + (i);
sensor.CreatedDate = sensor.LastEditedDate = DateTime.Now;
sensor.CreatedUser = sensor.LastEditedUser = AppContext.Current.LogedInUser.Username;
logger.Sensors.Add(sensor);
}
}
streamReader.Close();
entityConntext.SaveChanges();
//AppContext.Current.RefreshEntityContext();
}
}
public Group GetGroupByID(int id, GeoViewerEntities entitiesContext)
{
return entitiesContext.Groups.SingleOrDefault(ent => ent.GroupID == id);
}
//public bool DeleteObject(Models.Object obj)
//{
// SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_VIEWS_MANAGE);
// entityConntext.Objects.DeleteObject(obj);
// int result = entityConntext.SaveChanges();
// if (result > 0 && obj.Type == OBJECT_TYPE_IMAGE)
// {
// // Delete image file
// if (File.Exists(obj.Parameters))
// {
// File.Delete(obj.Parameters);
// }
// }
// return result > 0;
//}
public bool DeleteObject(int id)
{
using (var entityConntext = new GeoViewerEntities())
{
bool result = false;
var obj = entityConntext.Objects.SingleOrDefault(ent => ent.ObjectID == id);
if (obj != null)
{
entityConntext.Objects.DeleteObject(obj);
result = entityConntext.SaveChanges() > 0;
}
if (result && obj.Type == OBJECT_TYPE_IMAGE)
{
// Delete image file
if (File.Exists(obj.Parameters))
{
File.Delete(obj.Parameters);
}
}
return result;
}
}
public bool UpdateGroup(Group obj)
{
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(new string[]
{
SecurityBLL.ROLE_VIEWS_EDIT,
SecurityBLL.ROLE_VIEWS_MANAGE
});
ValidateGroup(obj);
obj.LastEditedDate = DateTime.Now;
obj.LastEditedUser = AppContext.Current.LogedInUser.Username;
entityConntext.AttachUpdatedObject(obj);
return entityConntext.SaveChanges() > 0;
}
}
/// <summary>
/// Get list of sensors which displayed in this picture view
/// </summary>
/// <param name="pictureView"></param>
/// <returns></returns>
public List<Sensor> GetSensorsInPictureView(PictureView pictureView)
{
using (var entityContext = new GeoViewerEntities())
{
var sensors = new List<Sensor>();
foreach (var obj in entityContext.Objects.Where(ent => ent.PictureViewID == pictureView.PictureViewID && ent.Type != OBJECT_TYPE_GROUP_INDICATOR && ent.Type != OBJECT_TYPE_IMAGE))
{
var sensor = SensorBLL.Current.GetByID(obj.Parameters.ToInt32TryParse());
if (sensor != null && !sensors.Contains(sensor)) sensors.Add(sensor);
}
return sensors;
}
}
