557 lines
25 KiB
C#
557 lines
25 KiB
C#
using Dapper;
|
|
using SolarPower.Helper;
|
|
using SolarPower.Models;
|
|
using SolarPower.Models.PowerStation;
|
|
using SolarPower.Repository.Interface;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace SolarPower.Repository.Implement
|
|
{
|
|
public class OverviewRepository : RepositoryBase<Overview>, IOverviewRepository
|
|
{
|
|
public OverviewRepository(IDatabaseHelper databaseHelper) : base(databaseHelper)
|
|
{
|
|
tableName = "power_station";
|
|
}
|
|
|
|
public async Task<List<int>> GetAllCityIdAsync()
|
|
{
|
|
List<int> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var sql = $"SELECT Id FROM city";
|
|
|
|
result = (await conn.QueryAsync<int>(sql)).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public async Task<Overview> GetOverviewByPowerStationIds(List<int> powerStationIds)
|
|
{
|
|
Overview result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var sql = @$"SELECT
|
|
SUM(ps.Today_kwh) AS Today_kwh,
|
|
SUM(ps.Total_kwh) AS Total_kwh,
|
|
AVG(ps.Today_irradiance) AS today_irradiance,
|
|
AVG(ps.avg_irradiance) AS avg_irradiance,
|
|
AVG(ps.today_PR) AS today_PR,
|
|
AVG(ps.avg_PR) AS avg_PR,
|
|
AVG(ps.today_kwhkwp) AS today_kwhkwp,
|
|
AVG(ps.avg_kwhkwp) AS avg_kwhkwp,
|
|
SUM(ps.today_monery) AS today_monery,
|
|
SUM(ps.total_monery) AS total_monery,
|
|
SUM(ps.today_carbon) AS today_carbon,
|
|
SUM(ps.total_carbon) AS total_carbon
|
|
FROM power_station ps
|
|
WHERE ps.Id IN @PowerStationIds
|
|
";
|
|
|
|
result = await conn.QueryFirstOrDefaultAsync<Overview>(sql, new { PowerStationIds = powerStationIds });
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
}
|
|
|
|
public async Task<List<CapacityDataTable>> GetCapacityDataTableByPowerStationIds(List<int> powerStationIds)
|
|
{
|
|
List<CapacityDataTable> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var sql = @$"SELECT
|
|
ps.CityId,
|
|
c.Name AS CityName,
|
|
COUNT(*) AS SubPowerStationCount,
|
|
SUM(ps.GeneratingCapacity) AS SubTotalCapacity
|
|
FROM power_station ps
|
|
LEFT JOIN city c ON ps.CityId = c.Id
|
|
WHERE ps.Id IN @PowerStationIds
|
|
GROUP BY ps.CityId
|
|
";
|
|
|
|
result = (await conn.QueryAsync<CapacityDataTable>(sql, new { PowerStationIds = powerStationIds })).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public async Task<List<PowerStation>> GetListPowerStationByPowerStationIds(List<int> powerStationIds)
|
|
{
|
|
List<PowerStation> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var sql = @$"SELECT * FROM power_station ps WHERE ps.Id IN @PowerStationIds
|
|
";
|
|
|
|
result = (await conn.QueryAsync<PowerStation>(sql, new { PowerStationIds = powerStationIds })).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public async Task<List<PowerStation>> GetSolarByCity(MyUser User, UseStatusCityGetPowerStation post)
|
|
{
|
|
|
|
using IDbConnection conn = _databaseHelper.GetConnection();
|
|
List<PowerStation> powerstation = new List<PowerStation>();
|
|
conn.Open();
|
|
var trans = conn.BeginTransaction();
|
|
try
|
|
{
|
|
var ids = "";
|
|
var KWH = "";
|
|
var PR = "";
|
|
if (post.KwhOrder == 0)
|
|
{
|
|
KWH = " ORDER BY Today_kwh DESC";
|
|
}
|
|
else
|
|
{
|
|
KWH = " ORDER BY Today_kwh";
|
|
}
|
|
|
|
if (post.PrOrder == 0)
|
|
{
|
|
PR = ",today_PR DESC";
|
|
}
|
|
else
|
|
{
|
|
PR = ",today_PR";
|
|
}
|
|
|
|
|
|
|
|
foreach (var id in post.Cityid)
|
|
{
|
|
ids = ids + id + ",";
|
|
}
|
|
if (ids.Length != 0)
|
|
{
|
|
ids = ids.Substring(0, ids.Length - 1);
|
|
}
|
|
if (User.Role.Layer == 0 || User.Role.Layer == 1)
|
|
{
|
|
var sql = "SELECT * FROM power_station WHERE CityId IN @IDs AND HealthStatus IN @Status" + KWH + PR;
|
|
powerstation = (await conn.QueryAsync<PowerStation>(sql, new { IDs = post.Cityid, Status = post.Status })).ToList();
|
|
trans.Commit();
|
|
}
|
|
else if (User.Role.Layer == 2)
|
|
{
|
|
var sql = "SELECT * FROM power_station WHERE CityId IN @IDs AND CompanyId=@CompanyId AND HealthStatus IN @Status" + KWH + PR;
|
|
powerstation = (await conn.QueryAsync<PowerStation>(sql, new { IDs = post.Cityid, CompanyId = User.CompanyId, Status = post.Status })).ToList();
|
|
trans.Commit();
|
|
}
|
|
else
|
|
{
|
|
var sql = "SELECT power_station.* FROM power_station LEFT JOIN power_station_operation_personnel ON power_station.Id = power_station_operation_personnel.PowerStationId WHERE CityId IN @IDs AND Userid = @UserId AND HealthStatus IN @Status" + KWH + PR;
|
|
powerstation = (await conn.QueryAsync<PowerStation>(sql, new { IDs = post.Cityid, UserId = User.Id, Status = post.Status })).ToList();
|
|
trans.Commit();
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
trans.Rollback();
|
|
throw exception;
|
|
}
|
|
finally
|
|
{
|
|
conn.Close();
|
|
}
|
|
return powerstation;
|
|
}
|
|
|
|
public async Task<List<PowerIrradiance>> GetListPowerIrradianceTodayByPowerStationId(int powerStationId, string nowDay)
|
|
{
|
|
List<PowerIrradiance> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var sql_power = @$"SELECT DATE_FORMAT(ps.timestamp, '%Y-%m-%d %H') AS Label, ps.KWH AS PowerData, pyr.Irradiance AS IrradianceData
|
|
FROM power_station_history_hour ps
|
|
LEFT JOIN pyrheliometer_history_hour pyr ON ps.PowerStationId = pyr.PowerStationId AND DATE_FORMAT(ps.timestamp, '%Y-%m-%d %H') = DATE_FORMAT(pyr.timestamp, '%Y-%m-%d %H')
|
|
WHERE ps.PowerStationId = @PowerStationId
|
|
AND DATE_FORMAT(ps.timestamp, '%Y-%m-%d') = @NowDay";
|
|
|
|
result = (await conn.QueryAsync<PowerIrradiance>(sql_power, new { PowerStationId = powerStationId, NowDay = nowDay })).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
public async Task<List<PowerIrradiance>> GetListPowerIrradiance7dayByPowerStationId(int powerStationId, string nowDay)
|
|
{
|
|
List<PowerIrradiance> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var startDay = Convert.ToDateTime(nowDay).AddDays(-7).ToString("yyyy-MM-dd");
|
|
|
|
var sql_power = @$"SELECT DATE_FORMAT(ps.timestamp, '%Y-%m-%d') AS Label, ps.TODAYKWH AS PowerData, pyr.Irradiance AS IrradianceData
|
|
FROM power_station_history_day ps
|
|
LEFT JOIN pyrheliometer_history_day pyr ON ps.PowerStationId = pyr.PowerStationId AND DATE_FORMAT(ps.timestamp, '%Y-%m-%d') = DATE_FORMAT(FROM_UNIXTIME(pyr.timestamp), '%Y-%m-%d')
|
|
WHERE ps.PowerStationId = @PowerStationId
|
|
AND DATE_FORMAT(ps.timestamp, '%Y-%m-%d') BETWEEN @StartDay AND @NowDay";
|
|
|
|
result = (await conn.QueryAsync<PowerIrradiance>(sql_power, new { PowerStationId = powerStationId, StartDay = startDay, NowDay = nowDay })).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
public async Task<List<PowerIrradiance>> GetListPowerIrradianceMonthByPowerStationId(int powerStationId, string nowDay)
|
|
{
|
|
List<PowerIrradiance> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var startDay = Convert.ToDateTime(nowDay).ToString("yyyy-MM-01");
|
|
|
|
var sql_power = @$"SELECT DATE_FORMAT(ps.timestamp, '%Y-%m-%d') AS Label, ps.TODAYKWH AS PowerData, pyr.Irradiance AS IrradianceData
|
|
FROM power_station_history_day ps
|
|
LEFT JOIN pyrheliometer_history_day pyr ON ps.PowerStationId = pyr.PowerStationId AND DATE_FORMAT(ps.timestamp, '%Y-%m-%d') = DATE_FORMAT(FROM_UNIXTIME(pyr.timestamp), '%Y-%m-%d')
|
|
WHERE ps.PowerStationId = @PowerStationId
|
|
AND DATE_FORMAT(ps.timestamp, '%Y-%m-%d') BETWEEN @StartDay AND @NowDay";
|
|
|
|
result = (await conn.QueryAsync<PowerIrradiance>(sql_power, new { PowerStationId = powerStationId, StartDay = startDay, NowDay = nowDay })).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public async Task<List<PowerIrradiance>> GetListPowerIrradianceYearByPowerStationId(int powerStationId, string nowDay)
|
|
{
|
|
List<PowerIrradiance> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var startyear = Convert.ToDateTime(nowDay).ToString("yyyy");
|
|
|
|
var sql_power = @$"SELECT DATE_FORMAT(ps.timestamp, '%Y-%m') AS Label, ps.MONTHKWH AS PowerData, pyr.Irradiance AS IrradianceData
|
|
FROM power_station_history_month ps
|
|
LEFT JOIN pyrheliometer_history_month pyr ON ps.PowerStationId = pyr.PowerStationId AND DATE_FORMAT(ps.timestamp, '%Y-%m') = DATE_FORMAT(FROM_UNIXTIME(pyr.timestamp), '%Y-%m')
|
|
WHERE ps.PowerStationId = @PowerStationId
|
|
AND DATE_FORMAT(ps.timestamp, '%Y') = @Year";
|
|
|
|
result = (await conn.QueryAsync<PowerIrradiance>(sql_power, new { PowerStationId = powerStationId, Year = startyear })).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public async Task<List<CheckBox>> GetInvertCheckBoxByPowerStationId(int powerStationId, string db_name)
|
|
{
|
|
List<CheckBox> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var sql = @$"SELECT i.Id AS Value, i.InverterName AS Name FROM {db_name}.inverter i
|
|
LEFT JOIN {db_name}.controller c ON i.ControllerId = c.Id AND c.Deleted = 0
|
|
WHERE i.Deleted = 0 AND c.PowerStationId = @PowerStationId";
|
|
|
|
result = (await conn.QueryAsync<CheckBox>(sql, new { PowerStationId = powerStationId })).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public async Task<List<InverterHistory>> GetListInverterByPowerStationIdAndDate(int powerStationId, string dateTime)
|
|
{
|
|
List<InverterHistory> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var sql = @$"SELECT * FROM inverter_history_hour WHERE PowerStationId = @PowerStationId AND DATE_FORMAT(TIMESTAMP, '%Y-%m-%d') = @DateTime";
|
|
|
|
result = (await conn.QueryAsync<InverterHistory>(sql, new { PowerStationId = powerStationId, DateTime = dateTime })).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public async Task<List<ExceptionDataTable>> GetExceptionTable(ExceptionSent post)
|
|
{
|
|
|
|
|
|
List<ExceptionDataTable> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
DateTime start;
|
|
DateTime end;
|
|
var sql = @$"select pr.FormId as FormId, pr.Id as ErrorID, a.id, site_id, `timestamp`, FROM_UNIXTIME((`timestamp` / 1000), '%Y-%m-%d %H:%i:%s') dev_time , a.sourceState err_status, FROM_UNIXTIME( (a.normalTime / 1000), '%Y-%m-%d %H:%i:%s') normalTime,
|
|
a.alarmClass, b.alarmClass as alarmClassName,ps.Name as PowerStationName,
|
|
errDevice, err_valueKind, errValue, FROM_UNIXTIME( (a.lastUpdate / 1000), '%Y-%m-%d %H:%i:%s') lastUpdate,
|
|
case when c.errMsg_tw is null then d.errMsg_tw else c.errMsg_tw end errMsg
|
|
from err_main a
|
|
join alarmorion_orionalarmclass b on a.alarmclass = b.id
|
|
left join ref_err_device c on trim(b.alarmClass) = c.deviceType
|
|
left join ref_err_inv d on lower(b.alarmClass) = d.deviceType
|
|
and case when lower(b.alarmClass) = 'inverter' and err_valuekind = 'e' then errvalue else '' end = d.errCode
|
|
left join power_station ps on ps.Code = site_id
|
|
left join operation_record pr on pr.ErrorCode = a.id
|
|
WHERE a.sourceState = @Status AND ps.Id = @PowerStationId";
|
|
|
|
|
|
if (!string.IsNullOrEmpty(post.Range))
|
|
{
|
|
post.StartTime = post.Range.Split('-')[0];
|
|
post.EndTime = post.Range.Split('-')[1];
|
|
start = Convert.ToDateTime(post.StartTime);
|
|
end = Convert.ToDateTime(post.EndTime);
|
|
var startime = (Int64)(start.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
|
|
var endtime = (Int64)(end.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
|
|
sql += @$" AND `timestamp` BETWEEN {startime*1000} AND {endtime*1000}";
|
|
}
|
|
|
|
result = (await conn.QueryAsync<ExceptionDataTable>(sql,
|
|
new
|
|
{
|
|
PowerStationId = post.Id,
|
|
Status = post.Status,
|
|
})).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public async Task<List<InverterHistory>> GetListInverterDayByPowerStationId(int powerStationId, string day)
|
|
{
|
|
List<InverterHistory> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var sql_power = @$"SELECT DATE_FORMAT(inv.TIMESTAMP, '%Y-%m-%d %H') AS TIMESTAMP,
|
|
inv.INVERTERID,
|
|
inv.KWH
|
|
FROM inverter_history_hour inv
|
|
WHERE inv.PowerStationId = @PowerStationId
|
|
AND DATE_FORMAT(inv.timestamp, '%Y-%m-%d') = @Day";
|
|
|
|
result = (await conn.QueryAsync<InverterHistory>(sql_power, new { PowerStationId = powerStationId, Day = day })).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public async Task<List<InverterHistory>> GetListInverterMonthByPowerStationId(int powerStationId, string month)
|
|
{
|
|
List<InverterHistory> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var sql_power = @$"SELECT DATE_FORMAT(inv.TIMESTAMP, '%Y-%m-%d') AS TIMESTAMP,
|
|
inv.INVERTERID,
|
|
inv.KWH
|
|
FROM inverter_history_day inv
|
|
WHERE inv.PowerStationId = @PowerStationId
|
|
AND DATE_FORMAT(inv.timestamp, '%Y-%m') = @Month";
|
|
|
|
result = (await conn.QueryAsync<InverterHistory>(sql_power, new { PowerStationId = powerStationId, Month = month })).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public async Task<List<InverterHistory>> GetListInverterQuaryerlyByPowerStationId(int powerStationId, string startMonth, string endMonth)
|
|
{
|
|
List<InverterHistory> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var sql_power = @$"SELECT DATE_FORMAT(inv.TIMESTAMP, '%Y-%m') AS TIMESTAMP,
|
|
inv.INVERTERID,
|
|
inv.KWH
|
|
FROM inverter_history_month inv
|
|
WHERE inv.PowerStationId = @PowerStationId
|
|
AND DATE_FORMAT(inv.timestamp, '%Y-%m') BETWEEN @StartMonth AND @EndMonth";
|
|
|
|
result = (await conn.QueryAsync<InverterHistory>(sql_power, new { PowerStationId = powerStationId, StartMonth = startMonth, EndMonth = endMonth })).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public async Task<List<InverterHistory>> GetListInverterYearByPowerStationId(int powerStationId, string year)
|
|
{
|
|
List<InverterHistory> result;
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
try
|
|
{
|
|
var sql_power = @$"SELECT DATE_FORMAT(inv.TIMESTAMP, '%Y-%m') AS TIMESTAMP,
|
|
inv.INVERTERID,
|
|
inv.KWH
|
|
FROM inverter_history_month inv
|
|
WHERE inv.PowerStationId = @PowerStationId
|
|
AND DATE_FORMAT(inv.timestamp, '%Y') = @Year";
|
|
|
|
result = (await conn.QueryAsync<InverterHistory>(sql_power, new { PowerStationId = powerStationId, Year = year })).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public async Task<List<HistoryTable>> GethistoryTable(HistorySent post)
|
|
{
|
|
List<HistoryTable> result;
|
|
|
|
using (IDbConnection conn = this._databaseHelper.GetConnection())
|
|
{
|
|
var kwh = "";
|
|
var usedb = "";
|
|
var pyrdb = "";
|
|
var timeGroup = "";
|
|
var range = "";
|
|
switch(post.GroupType)
|
|
{
|
|
case 0:
|
|
kwh = "C.KWH";
|
|
usedb = "power_station_history_hour";
|
|
pyrdb = "pyrheliometer_history_hour";
|
|
timeGroup = "%Y-%m-%d %H:%M:%S";
|
|
range = $" WHERE DATE_FORMAT(V.TIMESTAMP,'%Y-%m-%d') = '{post.HistoryRange}'";
|
|
break;
|
|
case 1:
|
|
kwh = "C.TODAYKWH";
|
|
usedb = "power_station_history_day";
|
|
pyrdb = "pyrheliometer_history_day";
|
|
timeGroup = "%Y-%m-%d";
|
|
range = $" WHERE DATE_FORMAT(V.TIMESTAMP,'%Y-%m') = '{post.HistoryRange}'";
|
|
break;
|
|
case 2:
|
|
kwh = "C.MONTHKWH";
|
|
usedb = "power_station_history_month";
|
|
pyrdb = "pyrheliometer_history_month";
|
|
timeGroup = "%Y-%m";
|
|
range = $" WHERE DATE_FORMAT(V.TIMESTAMP,'%Y') = '{post.HistoryRange}'";
|
|
break;
|
|
case 3:
|
|
kwh = "C.TOTALKWH";
|
|
usedb = "power_station_history_month";
|
|
pyrdb = "pyrheliometer_history_month";
|
|
timeGroup = "%Y-%m";
|
|
range = "";
|
|
break;
|
|
}
|
|
|
|
try
|
|
{
|
|
var sql = @$"SELECT *, SOLARHOUR-PSValue AS DiffSOLARHOUR
|
|
FROM
|
|
(
|
|
SELECT B.*, IFNULL(A.SOLARHOUR,0) AS PSValue
|
|
FROM
|
|
(
|
|
SELECT DENSE_RANK() OVER(ORDER BY C.TIMESTAMP) AS ROWID
|
|
, (DENSE_RANK() OVER(ORDER BY C.TIMESTAMP)) - 1 AS PreROWID,
|
|
C.TIMESTAMP,{kwh} AS KWH,C.SOLARHOUR,C.PR,P.Irradiance,P.Temperature AS Temp
|
|
FROM {usedb} C
|
|
LEFT JOIN {pyrdb} P ON DATE_FORMAT(P.TIMESTAMP,'{timeGroup}') = DATE_FORMAT(C.TIMESTAMP,'{timeGroup}')
|
|
WHERE C.PowerStationId = {post.PowerstationId} GROUP BY C.TIMESTAMP ORDER BY C.TIMESTAMP
|
|
) A
|
|
RIGHT OUTER JOIN
|
|
(
|
|
SELECT DENSE_RANK() OVER(ORDER BY C.TIMESTAMP) AS ROWID
|
|
, (DENSE_RANK() OVER(ORDER BY C.TIMESTAMP)) - 1 AS PreROWID,
|
|
C.TIMESTAMP,{kwh} AS KWH,C.SOLARHOUR,C.PR,P.Irradiance,P.Temperature AS Temp
|
|
FROM {usedb} C
|
|
LEFT JOIN {pyrdb} P ON DATE_FORMAT(P.TIMESTAMP,'{timeGroup}') = DATE_FORMAT(C.TIMESTAMP,'{timeGroup}')
|
|
WHERE C.PowerStationId = {post.PowerstationId} GROUP BY C.TIMESTAMP ORDER BY C.TIMESTAMP
|
|
) B
|
|
ON A.ROWID = B.PreROWID
|
|
) V {range}" ;
|
|
result = (await conn.QueryAsync<HistoryTable>(sql)).ToList();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
}
|