public Entity.SearchResult <List <Entity.DeviceTypeDetail> > List(Entity.SearchRequest request)
{
Entity.SearchResult <List <Entity.DeviceTypeDetail> > result = new Entity.SearchResult <List <Entity.DeviceTypeDetail> >();
try
{
logger.InfoLog(Constants.ACTION_ENTRY, "DeviceTypeRepository.List");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(SolutionConfiguration.CurrentUserId, request.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyGuid", SolutionConfiguration.CompanyId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("search", request.SearchText, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("pagesize", request.PageSize, DbType.Int32, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("pagenumber", request.PageNumber, DbType.Int32, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("orderby", request.OrderBy, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("count", DbType.Int32, ParameterDirection.Output, 16));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[DeviceType_List]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Items = DataUtils.DataReaderToList <Entity.DeviceTypeDetail>(dbDataReader, null);
result.Count = int.Parse(parameters.Where(p => p.ParameterName.Equals("count")).FirstOrDefault().Value.ToString());
}
logger.InfoLog(Constants.ACTION_EXIT, "DeviceTypeRepository.List");
}
catch (Exception ex)
{
logger.ErrorLog(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public Entity.BaseResponse <int> ValidateKit(string kitCode)
{
Entity.BaseResponse <int> result = new Entity.BaseResponse <int>();
try
{
logger.Information(Constants.ACTION_ENTRY, "ValidateKit.Get");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <System.Data.Common.DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CompanyId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("kitCode", kitCode, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("culture", component.helper.SolutionConfiguration.Culture, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
sqlDataAccess.ExecuteScalar(sqlDataAccess.CreateCommand("[Validate_KitCode]", CommandType.StoredProcedure, null), parameters.ToArray());
int outPut = int.Parse(parameters.Where(p => p.ParameterName.Equals("output")).FirstOrDefault().Value.ToString());
if (outPut > 0)
{
result.IsSuccess = true;
}
else
{
result.IsSuccess = false;
}
result.Message = parameters.Where(p => p.ParameterName.Equals("fieldname")).FirstOrDefault().Value.ToString();
}
logger.Information(Constants.ACTION_EXIT, "ValidateKit.Get");
}
catch (Exception ex)
{
logger.Error(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public Entity.BaseResponse <List <Entity.EntityDashboardOverviewResponse> > GetStatistics(Guid entityId, DateTime currentDate, string timeZone)
{
Entity.BaseResponse <List <Entity.EntityDashboardOverviewResponse> > result = new Entity.BaseResponse <List <Entity.EntityDashboardOverviewResponse> >();
try
{
logger.InfoLog(Constants.ACTION_ENTRY, "EntityRepository.Get");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
DateTime dateValue;
if (DateTime.TryParse(currentDate.ToString(), out dateValue))
{
dateValue = dateValue.AddMinutes(-double.Parse(timeZone));
}
List <DbParameter> parameters = sqlDataAccess.CreateParams(SolutionConfiguration.CurrentUserId, SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("guid", entityId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("currentDate", dateValue, DbType.DateTime, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("syncDate", DateTime.UtcNow, DbType.DateTime, ParameterDirection.Output));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[EntityStatistics_Get]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Data = DataUtils.DataReaderToList <Entity.EntityDashboardOverviewResponse>(dbDataReader, null);
if (parameters.Where(p => p.ParameterName.Equals("syncDate")).FirstOrDefault() != null)
{
result.LastSyncDate = Convert.ToString(parameters.Where(p => p.ParameterName.Equals("syncDate")).FirstOrDefault().Value);
}
}
logger.InfoLog(Constants.ACTION_EXIT, "EntityRepository.Get");
}
catch (Exception ex)
{
logger.ErrorLog(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public Entity.DeviceDetail Get(Guid deviceId)
{
List <Entity.DeviceDetail> listResult = new List <Entity.DeviceDetail>();
var result = new Entity.DeviceDetail();
try
{
logger.InfoLog(Constants.ACTION_ENTRY, "DeviceRepository.Get");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <System.Data.Common.DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CompanyId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyGuid", component.helper.SolutionConfiguration.CompanyId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("guid", deviceId, DbType.Guid, ParameterDirection.Input));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[Device_Get]", CommandType.StoredProcedure, null), parameters.ToArray());
listResult = DataUtils.DataReaderToList <Entity.DeviceDetail>(dbDataReader, null);
if (listResult.Count > 0)
{
result = listResult[0];
}
}
logger.InfoLog(Constants.ACTION_EXIT, "DeviceRepository.Get");
}
catch (Exception ex)
{
logger.ErrorLog(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public ActionStatus UpdateDetails(Model.Company request)
{
ActionStatus result = new ActionStatus(true);
try
{
logger.InfoLog(Constants.ACTION_ENTRY, "CompanyRepository.Manage");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyGuid", request.Guid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("name", request.Name, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("contactNo", request.ContactNo, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("address", request.Address, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("countryGuid", request.CountryGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("stateGuid", request.StateGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("city", request.City, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("postalCode", request.PostalCode, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("timezoneGuid", request.TimezoneGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("culture", component.helper.SolutionConfiguration.Culture, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
int intResult = sqlDataAccess.ExecuteNonQuery(sqlDataAccess.CreateCommand("[Company_UpdateDetail]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Data = int.Parse(parameters.Where(p => p.ParameterName.Equals("newid")).FirstOrDefault().Value.ToString());
}
logger.InfoLog(Constants.ACTION_EXIT, "CompanyRepository.Manage");
}
catch (Exception ex)
{
logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(result);
}
public Entity.SearchResult <List <Entity.UserResponse> > List(Entity.SearchRequest request)
{
Entity.SearchResult <List <Entity.UserResponse> > result = new Entity.SearchResult <List <Entity.UserResponse> >();
try
{
_logger.InfoLog(LogHandler.Constants.ACTION_ENTRY, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <System.Data.Common.DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, request.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyguid", request.CompanyId, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("search", request.SearchText, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("pagesize", request.PageSize, DbType.Int32, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("pagenumber", request.PageNumber, DbType.Int32, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("orderby", request.OrderBy, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("count", DbType.Int32, ParameterDirection.Output, 16));
var commandDef = sqlDataAccess.CreateCommand("[AdminUser_List]", CommandType.StoredProcedure, null);
System.Data.Common.DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(commandDef, parameters.ToArray());
result.Items = DataUtils.DataReaderToList <Entity.UserResponse>(dbDataReader, null);
result.Count = int.Parse(parameters.Where(p => p.ParameterName.Equals("count"))?.FirstOrDefault().Value.ToString());
}
_logger.InfoLog(LogHandler.Constants.ACTION_EXIT, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
catch (Exception ex)
{
_logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(result);
}
public ActionStatus Manage(Model.Role request)
{
ActionStatus result = new ActionStatus(true);
try
{
logger.Information(Constants.ACTION_ENTRY, "RoleRepository.Manage");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyGuid", request.CompanyGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("name", request.Name, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("description", request.Description, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("isAdminRole", request.IsAdminRole, DbType.Boolean, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("newid", request.Guid, DbType.Guid, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("culture", component.helper.SolutionConfiguration.Culture, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
int intResult = sqlDataAccess.ExecuteNonQuery(sqlDataAccess.CreateCommand("[Role_AddUpdate]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Data = parameters.Where(p => p.ParameterName.Equals("newid")).FirstOrDefault().Value.ToString();
}
logger.Information(Constants.ACTION_EXIT, "RoleRepository.Manage");
}
catch (Exception ex)
{
logger.Error(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public Entity.BaseResponse <List <Response.OperationHours> > GetOperationHours(Request.ChartRequest request)
{
Entity.BaseResponse <List <Response.OperationHours> > result = new Entity.BaseResponse <List <Response.OperationHours> >();
try
{
_logger.InfoLog(Constants.ACTION_ENTRY, "Chart_OperationHours.Get");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyguid", component.helper.SolutionConfiguration.CompanyId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("guid", request.BuildingId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("frequency", request.Frequency, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("syncDate", DateTime.UtcNow, DbType.DateTime, ParameterDirection.Output));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[Chart_OperationHours]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Data = DataUtils.DataReaderToList <Response.OperationHours>(dbDataReader, null);
if (parameters.Where(p => p.ParameterName.Equals("syncDate")).FirstOrDefault() != null)
{
result.LastSyncDate = Convert.ToString(parameters.Where(p => p.ParameterName.Equals("syncDate")).FirstOrDefault().Value);
}
}
_logger.InfoLog(Constants.ACTION_EXIT, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
catch (Exception ex)
{
_logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(result);
}
public List <Response.WaterUsageResponse> GetWaterUsage(Request.ChartRequest request)
{
List <Response.WaterUsageResponse> result = new List <Response.WaterUsageResponse>();
try
{
_logger.InfoLog(LogHandler.Constants.ACTION_ENTRY, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyguid", component.helper.SolutionConfiguration.CompanyId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("entityguid", request.GreenHouseGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("guid", request.HardwareKitGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[Chart_WaterConsumption]", CommandType.StoredProcedure, null), parameters.ToArray());
result = DataUtils.DataReaderToList <Response.WaterUsageResponse>(dbDataReader, null);
}
_logger.InfoLog(LogHandler.Constants.ACTION_EXIT, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
catch (Exception ex)
{
_logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(result);
}
public ActionStatus DeleteMediaFiles(Guid deviceId, Guid?fileId)
{
ActionStatus result = new ActionStatus(true);
try
{
logger.InfoLog(Constants.ACTION_ENTRY, "DeviceRepository.DeleteMediaFiles");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("guid", fileId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("deviceGuid", deviceId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("status", true, DbType.Boolean, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("culture", component.helper.SolutionConfiguration.Culture, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
sqlDataAccess.ExecuteNonQuery(sqlDataAccess.CreateCommand("[DeviceFiles_UpdateStatus]", CommandType.StoredProcedure, null), parameters.ToArray());
int outPut = int.Parse(parameters.Where(p => p.ParameterName.Equals("output")).FirstOrDefault().Value.ToString());
if (outPut > 0)
{
result.Success = true;
}
else
{
result.Success = false;
}
result.Message = parameters.Where(p => p.ParameterName.Equals("fieldname")).FirstOrDefault().Value.ToString();
}
logger.InfoLog(Constants.ACTION_EXIT, "DeviceRepository.DeleteMediaFiles");
}
catch (Exception ex)
{
logger.ErrorLog(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public List <T> ExecuteStoredProcedure <T>(string spName, Dictionary <string, string> parameters) where T : new()
{
var result = new List <T>();
try
{
//_logger.InfoLog(LogHandler.Constants.ACTION_ENTRY, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <System.Data.Common.DbParameter> dbparameters = new List <System.Data.Common.DbParameter>();
if (parameters != null && parameters.Any())
{
foreach (var param in parameters)
{
dbparameters.Add(sqlDataAccess.CreateParameter(param.Key, param.Value, DbType.String, ParameterDirection.Input));
}
}
System.Data.Common.DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(
sqlDataAccess.CreateCommand(spName, System.Data.CommandType.StoredProcedure, null), dbparameters.ToArray());
result = DataUtils.DataReaderToList <T>(dbDataReader, null);
}
// _logger.InfoLog(LogHandler.Constants.ACTION_EXIT, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
catch (Exception ex)
{
// _logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(result);
}
public Entity.BaseResponse <List <Entity.AttributeItem> > DeviceAttributeLookup(Guid deviceId)
{
Entity.BaseResponse <List <Entity.AttributeItem> > result = new Entity.BaseResponse <List <Entity.AttributeItem> >();
try
{
_logger.InfoLog(Constants.ACTION_ENTRY, "Device_LatestAttributeValue_Get.Get");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("guid", deviceId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("syncDate", DateTime.UtcNow, DbType.DateTime, ParameterDirection.Output));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[Device_LatestAttributeValue_Get]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Data = DataUtils.DataReaderToList <Entity.AttributeItem>(dbDataReader, null);
if (parameters.Where(p => p.ParameterName.Equals("syncDate")).FirstOrDefault() != null)
{
result.LastSyncDate = Convert.ToString(parameters.Where(p => p.ParameterName.Equals("syncDate")).FirstOrDefault().Value);
}
}
_logger.InfoLog(Constants.ACTION_EXIT, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
catch (Exception ex)
{
_logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(result);
}
public Entity.BaseResponse <List <Entity.LocationStaticsResponse> > GetLocationStatics(Guid locationId)
{
Entity.BaseResponse <List <Entity.LocationStaticsResponse> > result = new Entity.BaseResponse <List <Entity.LocationStaticsResponse> >();
try
{
logger.Information(Constants.ACTION_ENTRY, "LocationRepository.GetLocationStatics");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("guid", locationId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("syncDate", DateTime.UtcNow, DbType.DateTime, ParameterDirection.Output));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[LocationStatistics_Get]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Data = DataUtils.DataReaderToList <Entity.LocationStaticsResponse>(dbDataReader, null);
if (parameters.Where(p => p.ParameterName.Equals("syncDate")).FirstOrDefault() != null)
{
result.LastSyncDate = Convert.ToString(parameters.Where(p => p.ParameterName.Equals("syncDate")).FirstOrDefault().Value);
}
}
logger.Information(Constants.ACTION_EXIT, "LocationRepository.GetLocationStatics");
}
catch (Exception ex)
{
logger.Error(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public Entity.BaseResponse <List <Response.DevicePeakHoursResponse> > GetPeakHoursByElevator(Request.ElevatorsPeakRequest request)
{
Entity.BaseResponse <List <Response.DevicePeakHoursResponse> > responseResult = new Entity.BaseResponse <List <Response.DevicePeakHoursResponse> >();
List <Response.DevicePeakHoursResponse> tripList = new List <Response.DevicePeakHoursResponse>();
try
{
string ids = String.Join(",", request.ElevatorList);
_logger.InfoLog(Constants.ACTION_ENTRY, "Chart_PeakHoursByElevator.Get");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <Response.OperationHours> result = new List <Response.OperationHours>();
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyguid", component.helper.SolutionConfiguration.CompanyId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("elevators", ids, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("frequency", request.Frequency, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("syncDate", DateTime.UtcNow, DbType.DateTime, ParameterDirection.Output));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[Chart_PeakHoursByElevator]", CommandType.StoredProcedure, null), parameters.ToArray());
result = DataUtils.DataReaderToList <Response.OperationHours>(dbDataReader, null);
if (parameters.Where(p => p.ParameterName.Equals("syncDate")).FirstOrDefault() != null)
{
responseResult.LastSyncDate = Convert.ToString(parameters.Where(p => p.ParameterName.Equals("syncDate")).FirstOrDefault().Value);
}
var resultGrp = from data in result
group data by data.Name
into egroup
select egroup;
foreach (var group in resultGrp)
{
List <Response.PeakLookup> lookupItems = new List <Response.PeakLookup>();
foreach (var items in group)
{
lookupItems.Add(new Response.PeakLookup {
Name = items.ElevatorName, Value = items.Value
});
}
tripList.Add(new Response.DevicePeakHoursResponse {
Time = group.Key, Value = lookupItems
});
}
responseResult.Data = tripList;
}
_logger.InfoLog(Constants.ACTION_EXIT, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
catch (Exception ex)
{
_logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(responseResult);
}
public ActionStatus Manage(Model.Entity request)
{
ActionStatus result = new ActionStatus(true);
try
{
logger.Information(Constants.ACTION_ENTRY, "EntityRepository.Manage");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyGuid", request.CompanyGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("guid", request.Guid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("parentEntityGuid", request.ParentEntityGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("name", request.Name, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("type", request.Type, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("description", request.Description, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("latitude", request.Latitude, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("longitude ", request.Longitude, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("address", request.Address, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("address2", request.Address2, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("city", request.City, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("stateGuid", request.StateGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("countryGuid", request.CountryGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("zipCode", request.Zipcode, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("image", request.Image, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("newid", request.Guid, DbType.Guid, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("culture", component.helper.SolutionConfiguration.Culture, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
int intResult = sqlDataAccess.ExecuteNonQuery(sqlDataAccess.CreateCommand("[Entity_AddUpdate]", CommandType.StoredProcedure, null), parameters.ToArray());
int outPut = int.Parse(parameters.Where(p => p.ParameterName.Equals("output")).FirstOrDefault().Value.ToString());
if (outPut > 0)
{
string guidResult = parameters.Where(p => p.ParameterName.Equals("newid")).FirstOrDefault().Value.ToString();
if (!string.IsNullOrEmpty(guidResult))
{
result.Data = _uow.DbContext.Entity.Where(u => u.Guid.Equals(Guid.Parse(guidResult))).FirstOrDefault();
}
}
else
{
result.Message = parameters.Where(p => p.ParameterName.Equals("fieldname")).FirstOrDefault().Value.ToString();
}
}
logger.Information(Constants.ACTION_EXIT, "EntityRepository.Manage");
}
catch (Exception ex)
{
logger.Error(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public Entity.SearchResult <List <Entity.EntityDetail> > List(Entity.SearchRequest request)
{
Entity.SearchResult <List <Entity.EntityDetail> > result = new Entity.SearchResult <List <Entity.EntityDetail> >();
try
{
logger.Information(Constants.ACTION_ENTRY, "EntityRepository.List");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, request.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyguid", component.helper.SolutionConfiguration.CompanyId, DbType.Guid, ParameterDirection.Input));
//if (!request.EntityId.Equals(Guid.Empty) && !request.EntityId.Equals(SolutionConfiguration.EntityGuid))
//{
// parameters.Add(sqlDataAccess.CreateParameter("parentEntityGuid", request.EntityId, DbType.Guid, ParameterDirection.Input));
//}
parameters.Add(sqlDataAccess.CreateParameter("search", request.SearchText, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("pagesize", request.PageSize, DbType.Int32, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("pagenumber", request.PageNumber, DbType.Int32, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("orderby", request.OrderBy, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("count", DbType.Int32, ParameterDirection.Output, 16));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[Entity_List]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Items = DataUtils.DataReaderToList <Entity.EntityDetail>(dbDataReader, null);
result.Count = int.Parse(parameters.Where(p => p.ParameterName.Equals("count")).FirstOrDefault().Value.ToString());
if (result.Count > 0)
{
foreach (var item in result.Items)
{
if (!string.IsNullOrEmpty(item.Attributes))
{
item.AttributeList = DeserlizeXML(item.Attributes);
}
item.Attributes = "";
}
}
}
logger.Information(Constants.ACTION_EXIT, "EntityRepository.List");
}
catch (Exception ex)
{
logger.Error(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public Entity.SearchResult <List <Entity.DeviceMaintenanceDetail> > List(Entity.SearchRequest request)
{
Entity.SearchResult <List <Entity.DeviceMaintenanceDetail> > result = new Entity.SearchResult <List <Entity.DeviceMaintenanceDetail> >();
try
{
logger.InfoLog(Constants.ACTION_ENTRY, "DeviceMaintenanceRepository.Get");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, request.Version);
DateTime dateValue;
if (DateTime.TryParse(request.CurrentDate.ToString(), out dateValue))
{
dateValue = dateValue.AddMinutes(-double.Parse(request.TimeZone));
}
if (!request.EntityId.Equals(Guid.Empty))
{
parameters.Add(sqlDataAccess.CreateParameter("entityGuid", request.EntityId, DbType.Guid, ParameterDirection.Input));
}
if (!string.IsNullOrEmpty(request.Guid))
{
parameters.Add(sqlDataAccess.CreateParameter("deviceguid", new Guid(request.Guid), DbType.Guid, ParameterDirection.Input));
}
parameters.Add(sqlDataAccess.CreateParameter("companyguid", component.helper.SolutionConfiguration.CompanyId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("search", request.SearchText, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("pagesize", request.PageSize, DbType.Int32, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("pagenumber", request.PageNumber, DbType.Int32, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("orderby", request.OrderBy, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("currentDate", dateValue, DbType.DateTime, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("count", DbType.Int32, ParameterDirection.Output, 16));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[DeviceMaintenance_List]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Items = DataUtils.DataReaderToList <Entity.DeviceMaintenanceDetail>(dbDataReader, null);
result.Count = int.Parse(parameters.Where(p => p.ParameterName.Equals("count")).FirstOrDefault().Value.ToString());
}
logger.InfoLog(Constants.ACTION_EXIT, "DeviceMaintenanceRepository.Get");
}
catch (Exception ex)
{
logger.ErrorLog(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public ActionStatus Manage(Model.GreenHouse request)
{
ActionStatus result = new ActionStatus(true);
try
{
_logger.InfoLog(LogHandler.Constants.ACTION_ENTRY, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyGuid", request.CompanyGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("guid", request.Guid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("name", request.Name, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("description", request.Description, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("address", request.Address, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("address2", request.Address2, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("city", request.City, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("stateGuid", request.StateGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("countryGuid", request.CountryGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("zipCode", request.Zipcode, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("latitude", request.Latitude, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("longitude", request.Longitude, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("image", request.Image, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("newid", request.Guid, DbType.Guid, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("culture", component.helper.SolutionConfiguration.Culture, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
int intResult = sqlDataAccess.ExecuteNonQuery(sqlDataAccess.CreateCommand("[GreenHouse_AddUpdate]", CommandType.StoredProcedure, null), parameters.ToArray());
string guidResult = parameters.Where(p => p.ParameterName.Equals("newid")).FirstOrDefault().Value.ToString();
if (!string.IsNullOrEmpty(guidResult))
{
result.Data = _uow.DbContext.GreenHouse.Where(u => u.Guid.Equals(Guid.Parse(guidResult))).FirstOrDefault();
}
}
_logger.InfoLog(LogHandler.Constants.ACTION_EXIT, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
catch (Exception ex)
{
_logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(result);
}
public Entity.ActionStatus Manage(Model.Device request)
{
ActionStatus result = new ActionStatus(true);
try
{
_logger.InfoLog(LogHandler.Constants.ACTION_ENTRY, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("guid", request.Guid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("companyGuid", request.CompanyGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("greenHouseGuid", request.GreenHouseGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("templateGuid", request.TemplateGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("parentDeviceGuid", request.ParentDeviceGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("type", request.Type, DbType.Byte, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("uniqueId", request.UniqueId, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("name", request.Name, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("note", request.Note, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("tag", request.Tag, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("image", request.Image, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("isProvisioned", request.IsProvisioned, DbType.Boolean, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("newid", request.Guid, DbType.Guid, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("culture", component.helper.SolutionConfiguration.Culture, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
int intResult = sqlDataAccess.ExecuteNonQuery(sqlDataAccess.CreateCommand("[Device_AddUpdate]", CommandType.StoredProcedure, null), parameters.ToArray());
string guidResult = parameters.Where(p => p.ParameterName.Equals("newid")).FirstOrDefault().Value.ToString();
if (!string.IsNullOrEmpty(guidResult))
{
result.Data = _uow.DbContext.Device.Where(u => u.Guid.Equals(Guid.Parse(guidResult))).FirstOrDefault();
}
// result.Data = int.Parse(parameters.Where(p => p.ParameterName.Equals("newid")).FirstOrDefault().Value.ToString());
}
_logger.InfoLog(LogHandler.Constants.ACTION_EXIT, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
catch (Exception ex)
{
_logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(result);
}
public Entity.ActionStatus TelemetrySummary_HourWise()
{
Entity.ActionStatus actionStatus = new Entity.ActionStatus(true);
try
{
_logger.InfoLog(LogHandler.Constants.ACTION_ENTRY, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = new List <DbParameter>();
sqlDataAccess.ExecuteNonQuery(sqlDataAccess.CreateCommand("[TelemetrySummary_HourWise_Add]", CommandType.StoredProcedure, null), parameters.ToArray());
}
_logger.InfoLog(LogHandler.Constants.ACTION_EXIT, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
catch (Exception ex)
{
_logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
actionStatus.Success = false;
actionStatus.Message = ex.Message;
}
return(actionStatus);
}
public Entity.BaseResponse <List <Entity.DashboardOverviewByEntityResponse> > GetStatisticsByEntity(DateTime currentDate, string timeZone)
{
Entity.BaseResponse <List <Entity.DashboardOverviewByEntityResponse> > result = new Entity.BaseResponse <List <Entity.DashboardOverviewByEntityResponse> >();
try
{
_logger.InfoLog(Constants.ACTION_ENTRY, "GetStatisticsByEntity.Get");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
DateTime dateValue;
if (DateTime.TryParse(currentDate.ToString(), out dateValue))
{
dateValue = dateValue.AddMinutes(-double.Parse(timeZone));
}
List <DbParameter> parameters = sqlDataAccess.CreateParams(SolutionConfiguration.CurrentUserId, SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyguid", component.helper.SolutionConfiguration.CompanyId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("currentDate", dateValue, DbType.DateTime, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("search", "", DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("pagesize", -1, DbType.Int32, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("pagenumber", -1, DbType.Int32, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("orderby", "", DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("count", DbType.Int32, ParameterDirection.Output, 16));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[Entity_List]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Data = DataUtils.DataReaderToList <Entity.DashboardOverviewByEntityResponse>(dbDataReader, null);
//if (parameters.Where(p => p.ParameterName.Equals("syncDate")).FirstOrDefault() != null)
//{
// result.LastSyncDate = Convert.ToString(parameters.Where(p => p.ParameterName.Equals("syncDate")).FirstOrDefault().Value);
//}
}
_logger.InfoLog(Constants.ACTION_EXIT, "GetStatisticsByEntity.Get");
}
catch (Exception ex)
{
_logger.ErrorLog(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public Entity.ActionStatus UploadFiles(string xmlString, string deviceId)
{
var response = new ActionStatus();
int outPut = 0;
try
{
logger.InfoLog(Constants.ACTION_ENTRY, "DeviceRepository.UploadFiles");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("deviceGuid", Guid.Parse(deviceId)));
parameters.Add(sqlDataAccess.CreateParameter("files", xmlString, DbType.Xml, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("culture", component.helper.SolutionConfiguration.Culture, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
int intResult = sqlDataAccess.ExecuteNonQuery(sqlDataAccess.CreateCommand("[DeviceFiles_Add]", CommandType.StoredProcedure, null), parameters.ToArray());
outPut = int.Parse(parameters.Where(p => p.ParameterName.Equals("output")).FirstOrDefault().Value.ToString());
}
if (outPut == 1)
{
response.Message = "Files Uploaded Successfully!!";
response.Data = null;
response.Success = true;
}
else
{
response.Message = "Unable to Upload Files";
response.Data = null;
response.Success = false;
}
logger.InfoLog(Constants.ACTION_EXIT, "DeviceRepository.UploadFiles");
}
catch (Exception ex)
{
logger.ErrorLog(Constants.ACTION_EXCEPTION, ex);
}
return(response);
}
public Entity.SearchResult <List <Entity.AdminRule> > List(Entity.SearchRequest request)
{
var isAdmin = false;
Entity.SearchResult <List <Entity.AdminRule> > result = new Entity.SearchResult <List <Entity.AdminRule> >();
try
{
logger.InfoLog(Constants.ACTION_ENTRY, "AdminRuleRepository.Get");
var checkForAdmin = _companyRepository.FindBy(x => x.Guid.Equals(component.helper.SolutionConfiguration.CompanyId)).FirstOrDefault();
if (checkForAdmin == null)
{
isAdmin = true;
}
else
{
isAdmin = false;
}
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(SolutionConfiguration.CurrentUserId, request.Version);
parameters.Add(sqlDataAccess.CreateParameter("search", request.SearchText, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("isAdmin", isAdmin, DbType.Boolean, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("count", DbType.Int32, ParameterDirection.Output, 16));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[AdminRule_List]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Items = DataUtils.DataReaderToList <Entity.AdminRule>(dbDataReader, null);
result.Count = int.Parse(parameters.Where(p => p.ParameterName.Equals("count")).FirstOrDefault().Value.ToString());
}
logger.InfoLog(Constants.ACTION_EXIT, "AdminRuleRepository.Get");
}
catch (Exception ex)
{
logger.ErrorLog(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public ActionStatus Manage(Entity.AddCompanyRequest request)
{
ActionStatus result = new ActionStatus(true);
try
{
_logger.InfoLog(LogHandler.Constants.ACTION_ENTRY, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("name", request.Name, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("cpid", request.CpId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("address", request.Address, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("countryGuid", request.CountryGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("stateGuid", request.StateGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("city", request.City, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("postalCode", request.PostalCode, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("timezoneGuid", request.TimezoneGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("contactNo", request.ContactNo, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("firstName", request.FirstName, DbType.String, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("lastName", request.LastName, DbType.String, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("userId", request.UserID, DbType.Guid, ParameterDirection.Output));//Email
parameters.Add(sqlDataAccess.CreateParameter("companyGuid", request.CompanyGuid, DbType.Guid, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("userGuid", request.AdminUserGuid, DbType.Guid, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("greenhouseGuid", request.GreenHouseGuid, DbType.Guid, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("roleGuid", request.RoleGuid, DbType.Guid, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("culture", component.helper.SolutionConfiguration.Culture, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
int intResult = sqlDataAccess.ExecuteNonQuery(sqlDataAccess.CreateCommand("[Company_AddUpdate]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Data = int.Parse(parameters.Where(p => p.ParameterName.Equals("output")).FirstOrDefault().Value.ToString());
}
_logger.InfoLog(LogHandler.Constants.ACTION_EXIT, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
catch (Exception ex)
{
_logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(result);
}
public Entity.ActionStatus Manage(Model.Device request)
{
ActionStatus result = new ActionStatus(true);
try
{
logger.InfoLog(Constants.ACTION_ENTRY, "DeviceRepository.Manage");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("guid", request.Guid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("companyGuid", request.CompanyGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("entityGuid", request.EntityGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("templateGuid", request.TemplateGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("parentDeviceGuid", request.ParentDeviceGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("typeGuid", request.TypeGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("uniqueId", request.UniqueId, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("name", request.Name, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("note", request.Note, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("tag", request.Tag, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("description", request.Description, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("specification", request.Specification, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("image", request.Image, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("isProvisioned", request.IsProvisioned, DbType.Boolean, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("newid", request.Guid, DbType.Guid, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("culture", component.helper.SolutionConfiguration.Culture, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
int intResult = sqlDataAccess.ExecuteNonQuery(sqlDataAccess.CreateCommand("[Device_AddUpdate]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Data = Guid.Parse(parameters.Where(p => p.ParameterName.Equals("newid")).FirstOrDefault().Value.ToString());
}
logger.InfoLog(Constants.ACTION_EXIT, "DeviceRepository.Manage");
}
catch (Exception ex)
{
logger.ErrorLog(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public List <Response.EntityWiseDeviceResponse> GetEntityWiseDevices(Guid?locationId, Guid?deviceId)
{
List <Response.EntityWiseDeviceResponse> result = new List <Response.EntityWiseDeviceResponse>();
try
{
logger.InfoLog(Constants.ACTION_ENTRY, "GetLocationDevices.Get");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <System.Data.Common.DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CompanyId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("companyGuid", component.helper.SolutionConfiguration.CompanyId, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("locationGuid", locationId, DbType.Guid, ParameterDirection.Input));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[Device_Lookup]", CommandType.StoredProcedure, null), parameters.ToArray());
result = DataUtils.DataReaderToList <Response.EntityWiseDeviceResponse>(dbDataReader, null);
}
logger.InfoLog(Constants.ACTION_EXIT, "GetLocationDevices.Get");
}
catch (Exception ex)
{
logger.ErrorLog(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public Entity.BaseResponse <List <Entity.ZoneLookup> > ZoneLookup(Guid facilityId)
{
Entity.BaseResponse <List <Entity.ZoneLookup> > result = new Entity.BaseResponse <List <Entity.ZoneLookup> >();
try
{
_logger.InfoLog(Constants.ACTION_ENTRY, "ZoneLookup.Get");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("parentEntityGuid", facilityId, DbType.Guid, ParameterDirection.Input));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[Zone_Lookup]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Data = DataUtils.DataReaderToList <Entity.ZoneLookup>(dbDataReader, null);
result.IsSuccess = true;
result.Message = "Data Loaded Successfully !!";
}
_logger.InfoLog(Constants.ACTION_EXIT, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
catch (Exception ex)
{
_logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(result);
}
public List <Entity.DashboardOverviewResponse> GetStatistics()
{
List <Entity.DashboardOverviewResponse> result = new List <Entity.DashboardOverviewResponse>();
try
{
_logger.Information(Constants.ACTION_ENTRY, "GeneratorRepository.Get");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(SolutionConfiguration.CurrentUserId, SolutionConfiguration.Version);
parameters.Add(sqlDataAccess.CreateParameter("guid", SolutionConfiguration.CompanyId, DbType.Guid, ParameterDirection.Input));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[CompanyStatistics_Get]", CommandType.StoredProcedure, null), parameters.ToArray());
// DataUtils.DataReaderToObject(dbDataReader, result);
result = DataUtils.DataReaderToList <Entity.DashboardOverviewResponse>(dbDataReader, null);
}
_logger.Information(Constants.ACTION_EXIT, "GeneratorRepository.Get");
}
catch (Exception ex)
{
_logger.Error(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}
public List <Response.DeviceTypeUsageResponse> GetDeviceUsage(Request.ChartRequest request)
{
List <Response.DeviceTypeUsageResponse> result = new List <Response.DeviceTypeUsageResponse>();
try
{
_logger.InfoLog(Constants.ACTION_ENTRY, "Chart_Utilization.Get");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(component.helper.SolutionConfiguration.CurrentUserId, component.helper.SolutionConfiguration.Version);
if (request.DeviceGuid != null && request.DeviceGuid != Guid.Empty)
{
parameters.Add(sqlDataAccess.CreateParameter("guid", request.DeviceGuid, DbType.Guid, ParameterDirection.Input));
}
if (request.EntityGuid != null && request.EntityGuid != Guid.Empty)
{
parameters.Add(sqlDataAccess.CreateParameter("entityGuid", request.EntityGuid, DbType.Guid, ParameterDirection.Input));
}
parameters.Add(sqlDataAccess.CreateParameter("frequency", request.Frequency, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("syncDate", DateTime.UtcNow, DbType.DateTime, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", component.helper.SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
DbDataReader dbDataReader = sqlDataAccess.ExecuteReader(sqlDataAccess.CreateCommand("[Chart_Utilization]", CommandType.StoredProcedure, null), parameters.ToArray());
result = DataUtils.DataReaderToList <Response.DeviceTypeUsageResponse>(dbDataReader, null);
}
_logger.InfoLog(Constants.ACTION_EXIT, null, "", "", this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
catch (Exception ex)
{
_logger.ErrorLog(ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(result);
}
public ActionStatus Manage(Model.DeviceType request)
{
ActionStatus result = new ActionStatus(true);
try
{
logger.InfoLog(Constants.ACTION_ENTRY, "DeviceTypeRepository.Manage");
using (var sqlDataAccess = new SqlDataAccess(ConnectionString))
{
List <DbParameter> parameters = sqlDataAccess.CreateParams(SolutionConfiguration.CurrentUserId, SolutionConfiguration.Version);
if (request.Guid != null && request.Guid != Guid.Empty)
{
parameters.Add(sqlDataAccess.CreateParameter("guid", request.Guid, DbType.Guid, ParameterDirection.Input));
}
parameters.Add(sqlDataAccess.CreateParameter("companyGuid", request.CompanyGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("name", request.Name, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("description", request.Description, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("make", request.Make, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("model", request.Model, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("manufacturer", request.Manufacturer, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("entityGuid", request.EntityGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("templateGuid", request.TemplateGuid, DbType.Guid, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("newid", request.Guid, DbType.Guid, ParameterDirection.Output));
parameters.Add(sqlDataAccess.CreateParameter("culture", SolutionConfiguration.Culture, DbType.String, ParameterDirection.Input));
parameters.Add(sqlDataAccess.CreateParameter("enableDebugInfo", SolutionConfiguration.EnableDebugInfo, DbType.String, ParameterDirection.Input));
int intResult = sqlDataAccess.ExecuteNonQuery(sqlDataAccess.CreateCommand("[DeviceType_AddUpdate]", CommandType.StoredProcedure, null), parameters.ToArray());
result.Data = parameters.Where(p => p.ParameterName.Equals("newid")).FirstOrDefault().Value.ToString();
}
logger.InfoLog(Constants.ACTION_EXIT, "DeviceTypeRepository.Manage");
}
catch (Exception ex)
{
logger.ErrorLog(Constants.ACTION_EXCEPTION, ex);
}
return(result);
}