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;
}
/// <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 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 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 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;
}
}
/// <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();
}
}
/// <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);
}
}
/// <summary>
/// Read data for logger
/// </summary>
/// <param name="logger"></param>
/// <param name="onlyNewData"></param>
/// <param name="calculateValue"></param>
/// <param name="refreshEntityContext"></param>
public void ReadData(int loggerID, bool onlyNewData, bool calculateValue, ReaderProccess readerProccess)
{
using (var entityConntext = new GeoViewerEntities())
{
Logger logger = entityConntext.Loggers.SingleOrDefault(ent => ent.LoggerID == loggerID);
if (logger == null) return;
// For test only
Console.WriteLine("Thread[" + Thread.CurrentThread.ManagedThreadId + "]: Read data form logger " + logger.LoggerID);
// End for test
var fileInfo = new FileInfo(logger.DataPath);
if (!fileInfo.Exists)
{
readerProccess.TotalRecord = FileUtils.CountTotalFolderLines(logger.DataPath);
readerProccess.FileReaderProccesses = new List<ReaderProccess>();
readerProccess.CurrentFile = logger.DataPath;
var directoryInfo = new DirectoryInfo(logger.DataPath);
if (!directoryInfo.Exists) throw new Exception(Properties.Resources.Error_Data_FileNotFound);
string meta = "";
if (logger.Meta.LastIndexOf("#") > 0)
{
meta = logger.Meta.Substring(0, logger.Meta.LastIndexOf("#") + 1);
}
foreach (var file in directoryInfo.GetFiles())
{
ReadData(logger, file.FullName, onlyNewData, calculateValue, readerProccess);
meta += file.Name + ",";
}
logger.Meta = meta;
logger.FileSize = FileUtils.FolderSize(logger.DataPath);
}
else
{
readerProccess.TotalRecord = FileUtils.CountTotalLines(logger.DataPath);
readerProccess.CurrentFile = logger.DataPath;
ReadData(logger, logger.DataPath, onlyNewData, calculateValue, readerProccess);
logger.FileSize = fileInfo.Length;
}
// Update last time read logger
logger.LastModifyDatetime = DateTime.Now;
// Update total record
logger.TotalSensor = logger.Sensors.Count();
Sensor sensor = null;
if (logger.TotalSensor > 0)
{
sensor = logger.Sensors.First();
logger.TotalRecord = sensor.SensorValues.LongCount();
}
else
{
logger.TotalRecord = 0;
}
// Update first record meatime
if (logger.TotalRecord > 0)
{
logger.FirstLogDatetime = sensor.SensorValues.OrderBy(ent => ent.MeaTime).First().MeaTime;
logger.LastLogDatetime = sensor.SensorValues.OrderByDescending(ent => ent.MeaTime).First().MeaTime;
}
entityConntext.SaveChanges();
Console.WriteLine("Thread[" + Thread.CurrentThread.ManagedThreadId + "]: End Read data form logger " + logger.LoggerID + ". Total record " + logger.TotalRecord);
}
}
public bool Update(Logger obj)
{
bool result = false;
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(new[]
{
SecurityBLL.ROLE_DATA_EDIT,
SecurityBLL.ROLE_DATA_MANAGE
});
Validate(obj);
obj.LastEditedDate = DateTime.Now;
obj.LastEditedUser = AppContext.Current.LogedInUser.Username;
entityConntext.AttachUpdatedObject(obj);
result = entityConntext.SaveChanges() > 0;
}
if (result)
{
if (!obj.AutomaticReadData)
{
ReaderThreadManager.Current.RemoveThread(obj);
}
else
{
ReaderThreadManager.Current.SaveThread(obj);
}
}
return result;
}
public bool Update(Account account)
{
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(new string[]
{
SecurityBLL.ROLE_ACCOUNT_MANAGE,
SecurityBLL.ROLE_ACCOUNT_EDIT
});
Validate(account);
int count =
entityConntext.Accounts.Count(
ent => ent.Username != account.Username && ent.Email == account.Email);
if (count > 0)
{
throw new Exception(Resources.Error_Account_EmailIsUsed);
}
entityConntext.AttachUpdatedObject(account);
return entityConntext.SaveChanges() > 0;
}
}
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 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;
}
}
public bool Insert(Project obj)
{
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_DATA_MANAGE);
Validate(obj);
entityConntext.Projects.AddObject(obj);
return entityConntext.SaveChanges() > 0;
}
}
public bool Update(Project obj)
{
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(new string[]
{
SecurityBLL.ROLE_DATA_EDIT,
SecurityBLL.ROLE_DATA_MANAGE
});
Validate(obj);
entityConntext.AttachUpdatedObject(obj);
return entityConntext.SaveChanges() > 0;
}
}
public bool Delete(Account account)
{
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_ACCOUNT_MANAGE);
// Check RootAdmin
if (account.Username == "RootAdmin") throw new Exception(Resources.Error_CannotDeleteRootAdmin);
entityConntext.AttachUpdatedObject(account, EntityState.Deleted);
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 Insert(Account account)
{
using (var entityConntext = new GeoViewerEntities())
{
SecurityBLL.Current.CheckPermissionThrowException(SecurityBLL.ROLE_ACCOUNT_MANAGE);
Validate(account);
int count = entityConntext.Accounts.Count(ent => ent.Username == account.Username);
if (count > 0) throw new Exception(Properties.Resources.Error_Account_UsernameExist);
count = entityConntext.Accounts.Count(ent => ent.Email == account.Email);
if (count > 0) throw new Exception(Properties.Resources.Error_Account_EmailExist);
account.Password = account.Password.GetMd5Hash();
account.CreatedDate = DateTime.Now;
account.IsApproved = true;
account.IsLocked = false;
entityConntext.Accounts.AddObject(account);
return entityConntext.SaveChanges() > 0;
}
}
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;
}
private void markUnendedMenuItem_Click(object sender, EventArgs e)
{
try
{
using (var entityConntext = new GeoViewerEntities())
{
if (logGridView.SelectedRows.Count == 0)
{
MessageBox.Show(Resources.Warning_NoRecordSelected);
return;
}
long id = 0;
for (int i = 0; i < logGridView.SelectedRows.Count; i++)
{
id = logGridView.SelectedRows[i].Cells["AlarmLogID"].Value.ToInt64TryParse();
var obj = entityConntext.AlarmLogs.SingleOrDefault(ent => ent.AlarmLogID == id);
if (obj != null)
{
obj.IsEnded = false;
obj.EndAlarmDatetime = null;
}
}
if (entityConntext.SaveChanges() > 0)
{
ShowSuccessMessage(string.Format("Đánh dấu chưa kết thúc thành công cho {0} cảnh báo!",
logGridView.SelectedRows.Count));
ReloadGrid();
}
}
}
catch (Exception exception)
{
ShowErrorMessage(exception.Message);
}
}
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;
}
}
public bool SetRolesForUser(string userName, string[] roles)
{
using (var entityConntext = new GeoViewerEntities())
{
// Check RootAdmin
if (userName == "RootAdmin" && !roles.Contains(ROLE_ACCOUNT_MANAGE))
throw new Exception(Resources.Error_CannotRemoveAccountRoleOfRootAdmin);
var user = entityConntext.Accounts.FirstOrDefault(ent => ent.Username == userName);
if (user != null)
{
user.Roles.Clear();
foreach (var role in roles)
{
var r = entityConntext.Roles.SingleOrDefault(ent => ent.RoleName == role);
if (r != null)
{
user.Roles.Add(r);
}
}
return entityConntext.SaveChanges() > 0;
}
return false;
}
}
public void OpenProject(int id)
{
using (var entityConntext = new GeoViewerEntities())
{
var obj = entityConntext.Projects.SingleOrDefault(ent => ent.ProjectID == id);
if (obj != null)
{
AppContext.Current.OpenProject = obj;
foreach (var pro in entityConntext.Projects)
{
pro.IsDefault = false;
}
obj.IsDefault = true;
entityConntext.SaveChanges();
}
}
}
public void Login(string username, string password)
{
using (var entityConntext = new GeoViewerEntities())
{
string md5Pass = password.GetMd5Hash();
Account obj = entityConntext.Accounts.SingleOrDefault(ent => ent.Username == username);
if (obj == null) throw new Exception(Properties.Resources.Error_Account_AccountNotExist);
if (obj.Password != md5Pass) throw new Exception(Properties.Resources.Error_Account_PasswordNotMatch);
if (!obj.IsApproved) throw new Exception(Resources.Error_Account_UnApproved);
if (obj.IsLocked) throw new Exception(Resources.Error_Account_IsLocked);
_logedInUser = obj;
obj.LastLoginDate = DateTime.Now;
entityConntext.SaveChanges();
}
}
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;
}
}
private void markAsReadMenuItem_Click(object sender, EventArgs e)
{
try
{
using (var entityConntext = new GeoViewerEntities())
{
if (logGridView.SelectedRows.Count == 0)
{
MessageBox.Show(Resources.Warning_NoRecordSelected);
return;
}
long id = 0;
for (int i = 0; i < logGridView.SelectedRows.Count; i++)
{
id = logGridView.SelectedRows[i].Cells["AlarmLogID"].Value.ToInt64TryParse();
var obj = entityConntext.AlarmLogs.SingleOrDefault(ent => ent.AlarmLogID == id);
if (obj != null)
{
obj.LastEditedDate = DateTime.Now;
obj.LastEditedUser = AppContext.Current.LogedInUser.Username;
}
}
if (entityConntext.SaveChanges() > 0)
{
ShowSuccessMessage(string.Format("Đánh dấu đã đọc thành công cho {0} cảnh báo!",
logGridView.SelectedRows.Count));
ReloadGrid();
}
}
}
catch (Exception exception)
{
ShowErrorMessage(exception.Message);
}
}