/// <summary>
/// Get End Point Type Image
/// </summary>
/// <param name="pEndPointType"></param>
/// <returns></returns>
public static string GetEndPointTypeImage(EndPointType pEndPointType)
{
string imageURL = string.Empty;
switch (pEndPointType)
{
case EndPointType.None:
case EndPointType.Database:
{
imageURL = "~/Contents/Images/database_128.png";
}
break;
case EndPointType.WebService:
{
imageURL = "~/Contents/Images/webservice_256.png";
}
break;
default:
break;
}
return(imageURL);
}
/// <summary>
/// Validate Adapter
/// </summary>
/// <param name="pCheckType"></param>
/// <returns></returns>
protected bool ValidateAdapter(IntegrationChannelType pCheckType)
{
bool isValidMetadata = false;
if (this.ProcessMetadata != null)
{
if (this.AdapterMetadata != null && this.AdapterMetadata.IntegrationAdapterType.ToEnum <IntegrationChannelType>() == pCheckType)
{
EndPointType endPointType = this.AdapterMetadata.EndPointType.ToEnum <EndPointType>();
if (endPointType == EndPointType.Database)
{
if (this.AdapterMetadata.ApplicationDatabaseQuery != null && this.AdapterMetadata.ApplicationDatabaseQuery.ApplicationDatabas != null)
{
isValidMetadata = true;
}
}
else if (endPointType == EndPointType.WebService)
{
if (this.AdapterMetadata.ApplicationWebServiceRequest != null && this.AdapterMetadata.ApplicationWebServiceRequest.ApplicationWebService != null)
{
isValidMetadata = true;
}
}
}
}
return(isValidMetadata);
}
public PartialViewResult EditPV(long id)
{
EndPointType endPointType = uof_repos.repoEndpointTypes.Find(id);
ViewBag.IconID = new SelectList(uof_repos.repoMediaFiles.GetList(), "ID", "Title", endPointType.IconID);
ViewBag.TypeCategoryID = new SelectList(uof_repos.repoEndpointTypeCategorys.GetList(), "ID", "Title", endPointType.TypeCategoryID);
return(PartialView("_Edit", endPointType));
}
public EndPointRow[] GetActiveOriginationsByType_Registration(EndPointType pEndPointType, EPRegistration pRegistration)
{
/*
* SELECT EndPoint.*
* FROM EndPoint INNER JOIN DialPeer ON
* EndPoint.end_point_id = DialPeer.end_point_id
* .....
*/
string _sqlStr = "SELECT " +
"EndPoint." + EndPointRow.end_point_id_DbName + ", " +
"EndPoint." + EndPointRow.alias_DbName + ", " +
"EndPoint." + EndPointRow.with_alias_authentication_DbName + ", " +
"EndPoint." + EndPointRow.status_DbName + ", " +
"EndPoint." + EndPointRow.type_DbName + ", " +
"EndPoint." + EndPointRow.protocol_DbName + ", " +
"EndPoint." + EndPointRow.port_DbName + ", " +
"EndPoint." + EndPointRow.registration_DbName + ", " +
"EndPoint." + EndPointRow.is_registered_DbName + ", " +
"EndPoint." + EndPointRow.ip_address_range_DbName + ", " +
"EndPoint." + EndPointRow.max_calls_DbName + ", " +
"EndPoint." + EndPointRow.password_DbName + ", " +
"EndPoint." + EndPointRow.prefix_in_type_id_DbName + ", " +
"EndPoint." + EndPointRow.virtual_switch_id_DbName + " " +
" FROM EndPoint INNER JOIN DialPeer ON " +
"EndPoint." + EndPointRow.end_point_id_DbName + " = DialPeer." + DialPeerRow.end_point_id_DbName + " " +
" WHERE [" + EndPointRow.type_DbName + "]=" + base.Database.CreateSqlParameterName(EndPointRow.type_PropName) +
" AND " +
"[" + EndPointRow.registration_DbName + "]=" + base.Database.CreateSqlParameterName(EndPointRow.registration_PropName) +
" AND " +
"[" + EndPointRow.status_DbName + "]=" + base.Database.CreateSqlParameterName(EndPointRow.status_PropName) +
" GROUP BY " +
"EndPoint." + EndPointRow.end_point_id_DbName + ", " +
"EndPoint." + EndPointRow.alias_DbName + ", " +
"EndPoint." + EndPointRow.with_alias_authentication_DbName + ", " +
"EndPoint." + EndPointRow.status_DbName + ", " +
"EndPoint." + EndPointRow.type_DbName + ", " +
"EndPoint." + EndPointRow.protocol_DbName + ", " +
"EndPoint." + EndPointRow.port_DbName + ", " +
"EndPoint." + EndPointRow.registration_DbName + ", " +
"EndPoint." + EndPointRow.is_registered_DbName + ", " +
"EndPoint." + EndPointRow.ip_address_range_DbName + ", " +
"EndPoint." + EndPointRow.max_calls_DbName + ", " +
"EndPoint." + EndPointRow.password_DbName + ", " +
"EndPoint." + EndPointRow.prefix_in_type_id_DbName + ", " +
"EndPoint." + EndPointRow.virtual_switch_id_DbName + " ";
IDbCommand _cmd = base.Database.CreateCommand(_sqlStr);
AddParameter(_cmd, EndPointRow.type_PropName, pEndPointType);
AddParameter(_cmd, EndPointRow.registration_PropName, pRegistration);
AddParameter(_cmd, EndPointRow.status_PropName, (byte)Status.Active);
using (IDataReader _reader = _cmd.ExecuteReader()) {
return(MapRecords(_reader));
}
}
public static APIEndPointType fromEndPointType(EndPointType sourceEndPointType)
{
APIEndPointType result = new APIEndPointType();
result.ID = sourceEndPointType.ID;
result.Title = sourceEndPointType.Title;
return(result);
}
public ActionResult EditPV([Bind(Include = "ID,Title,Measurement,TypeCategoryID,IconID")] EndPointType endPointType)
{
ResultInfo.Result res = ResultInfo.GetResultByID(1);
if (ModelState.IsValid)
{
res = uof_repos.repoEndpointTypes.Edit(endPointType.ID, endPointType.Title, endPointType.measurement, (long)endPointType.TypeCategoryID, (long)endPointType.IconID);
return(Json(res));
}
return(Json(res));
}
public ActionResult Details(long id)
{
if (ValidateUserPermissions(false, false) == false)
{
return(RedirectToAction("Login", "Account"));
}
EndPointType ThingCat = uof_repos.repoEndpointTypes.Find(id);
return(View(ThingCat));
}
public ActionResult DeletePV([Bind(Include = "ID")] EndPointType EndPointType)
{
ResultInfo.Result res = ResultInfo.GetResultByID(1);
if (ModelState.IsValid)
{
res = uof_repos.repoEndpointTypes.Delete(EndPointType.ID);
return(Json(res));
}
return(Json(res));
}
private void AdjustEndPointTypeUX(EndPointType pEndPointType)
{
if (this.trDatabaseQuery != null)
{
this.trDatabaseQuery.Visible = pEndPointType == EndPointType.Database;
}
if (this.trWebServiceRequest != null)
{
this.trWebServiceRequest.Visible = pEndPointType == EndPointType.WebService;
}
}
public PartialViewResult DeletePV(long id)
{
if (!User.IsInRole("Admin"))
{
ResultInfo.Result rm = Core.ResultInfo.GetResultByID(1);
return(PartialView("_PVResult", rm));
}
EndPointType EndPointType = uof_repos.repoEndpointTypes.Find(id);
return(PartialView("_Delete", EndPointType));
}
/// <summary>
/// Initializes a new instance of the <see cref="EndPoint{T}"/> class.
/// </summary>
/// <param name="value">
/// The value.
/// </param>
/// <param name="endPointType">
/// The end point type.
/// </param>
/// <param name="isInclusive">
/// The is inclusive.
/// </param>
/// <param name="interval">
/// The interval.
/// </param>
public EndPoint(T value, EndPointType endPointType, bool isInclusive, IInterval <T> interval)
{
this.interval = interval;
this.endPointType = endPointType;
this.Value = value;
this.isMin = endPointType == EndPointType.Min;
this.isInclusive = isInclusive;
}
/// <summary>
/// Initializes a new instance of the <see cref="EndPoint{T}"/> class.
/// </summary>
/// <param name="interval">
/// The interval.
/// </param>
/// <param name="endPointType">
/// The edge type.
/// </param>
public EndPoint(IInterval <T> interval, EndPointType endPointType)
{
this.interval = interval;
this.endPointType = endPointType;
this.Value = endPointType == EndPointType.Min ? interval.Min.Value : interval.Max.Value;
this.isMin = endPointType == EndPointType.Min;
this.isInclusive = endPointType == EndPointType.Min ? interval.Min.IsInclusive : interval.Max.IsInclusive;
}
public WebRemotingEndPoint(GrainIdGenerator idGenerator, string name, EndPointType type,
IAuthenticator clientAuthenticator,
IAuthenticator serverAuthenticator,
ICodeGenerator codeGenerator,
HeartbeatSettings heartbeatSettings,
LatencySettings latencySettings,
EndPointSettings endPointSettings)
: base(
idGenerator, name, type, clientAuthenticator, serverAuthenticator, codeGenerator, heartbeatSettings,
latencySettings, endPointSettings)
{
}
public static APIEndPointType fromEndPointType(EndPointType sourceEndPointType)
{
APIEndPointType result = new APIEndPointType();
result.ID = sourceEndPointType.ID;
result.Title = sourceEndPointType.Title;
result.IconID = sourceEndPointType.IconID;
result.measurement = sourceEndPointType.measurement;
result.EndPointTypeCategory = TypesMapper.APIEndPointTypeCategoryAdapter.fromEndPointTypeCategory(sourceEndPointType.EndPointTypeCategory);
return(result);
}
internal AbstractNamedPipeEndPoint(string name,
EndPointType type,
IAuthenticator clientAuthenticator,
IAuthenticator serverAuthenticator,
ICodeGenerator codeGenerator,
HeartbeatSettings heartbeatSettings,
LatencySettings latencySettings,
EndPointSettings endPointSettings)
: base(
new GrainIdGenerator(type), name, type, clientAuthenticator, serverAuthenticator, codeGenerator,
heartbeatSettings,
latencySettings, endPointSettings)
{
}
public void CompareTo_DifferentSmallerAndLargerEndpointValues_Returns_Minus_1(
bool includeFirstIntervalEdge, bool includeSecondIntervalEdge,
EndPointType firstEndPointType, EndPointType secondEndPointType,
int expectedResult)
{
//Arrange
var endPoint1 = new EndPoint<DateTime>(new Interval<DateTime>(now, inOneHour, firstEndPointType != EndPointType.Min || includeFirstIntervalEdge, firstEndPointType != EndPointType.Max || includeFirstIntervalEdge), firstEndPointType);
var endPoint2 = new EndPoint<DateTime>(new Interval<DateTime>(inTwoHours, inThreeHours, secondEndPointType != EndPointType.Min || includeSecondIntervalEdge, secondEndPointType != EndPointType.Max || includeSecondIntervalEdge), secondEndPointType);
//Act
int compareResult = endPoint1.CompareTo(endPoint2);
//Assert
Assert.AreEqual(expectedResult, compareResult);
}
/// <summary>
/// Find Endpoint Type by EndPoint Type ID
/// </summary>
/// <param name="id">EndPoint Type ID</param>
/// <returns>Endpoint object</returns>
public EndPointType Find(long id)
{
EndPointType epType = new EndPointType();
List <EndPointType> epTypes = db.EndPointTypes.Where(l => l.ID == id).ToList();
if (epTypes.Count == 1)
{
epType = epTypes[0];
}
else
{
throw new Exception("Not Found");
}
return(epType);
}
public static GrainIdRange GetRangeFor(EndPointType type)
{
const ulong midPoint = (MaxValue - MinValue) / 2 + MinValue;
switch (type)
{
case EndPointType.Client:
return(new GrainIdRange(MinValue, midPoint - 1));
case EndPointType.Server:
return(new GrainIdRange(midPoint, MaxValue));
default:
throw new InvalidEnumArgumentException(nameof(type), (int)type, typeof(EndPointType));
}
}
public void CompareTo_DifferentSmallerAndLargerEndpointValues_Returns_Minus_1(
bool includeFirstIntervalEdge, bool includeSecondIntervalEdge,
EndPointType firstEndPointType, EndPointType secondEndPointType,
int expectedResult)
{
//Arrange
var endPoint1 = new EndPoint <DateTime>(new Interval <DateTime>(now, inOneHour, firstEndPointType != EndPointType.Min || includeFirstIntervalEdge, firstEndPointType != EndPointType.Max || includeFirstIntervalEdge), firstEndPointType);
var endPoint2 = new EndPoint <DateTime>(new Interval <DateTime>(inTwoHours, inThreeHours, secondEndPointType != EndPointType.Min || includeSecondIntervalEdge, secondEndPointType != EndPointType.Max || includeSecondIntervalEdge), secondEndPointType);
//Act
int compareResult = endPoint1.CompareTo(endPoint2);
//Assert
Assert.AreEqual(expectedResult, compareResult);
}
public void CompareTo_TheSameEndpointValue_ReturnsCorrectExpectedResult(
bool includeFirstIntervalEdge, bool includeSecondIntervalEdge,
EndPointType firstEndPointType, EndPointType secondEndPointType,
int expectedResult)
{
//Arrange
// use 0 length intervals here for easier testing
var endPoint1 = new EndPoint <DateTime>(new Interval <DateTime>(now, now, firstEndPointType != EndPointType.Min || includeFirstIntervalEdge, firstEndPointType != EndPointType.Max || includeFirstIntervalEdge), firstEndPointType);
var endPoint2 = new EndPoint <DateTime>(new Interval <DateTime>(now, now, secondEndPointType != EndPointType.Min || includeSecondIntervalEdge, secondEndPointType != EndPointType.Max || includeSecondIntervalEdge), secondEndPointType);
//Act
int compareResult = endPoint1.CompareTo(endPoint2);
//Assert
Assert.AreEqual(expectedResult, compareResult);
}
public DataCenterConfiguration(EndPointType type)
{
switch (type)
{
case EndPointType.Beta:
this.DataCenterDomain = "http://webservices.beta.netsuite.com";
break;
case EndPointType.Sandbox:
this.DataCenterDomain = "http://webservices.sandbox.netsuite.com";
break;
default:
this.DataCenterDomain = "http://webservices.netsuite.com";
break;
}
}
public void CreateEndPointLog(EndPointContext context, string body, EndPointType type)
{
if (context == null)
{
return;
}
EndPointLog log = new EndPointLog
{
ClientIp = context.ClientIP,
Body = body,
TimeStamp = DateTime.Now,
EndPointType = type
};
database.StoreEndPointLog(log);
}
public ResultInfo.Result Add(string Title, string measurment, long TypeCategoryID, long IconID)
{
try
{
EndPointType epType = new EndPointType();
epType.Title = Title;
epType.measurement = measurment;
epType.TypeCategoryID = TypeCategoryID;
epType.IconID = IconID;
db.EndPointTypes.Add(epType);
db.SaveChanges();
return(Result.GenerateOKResult("Saved", epType.ID.ToString()));
}
catch
{
return(Result.GenerateFailedResult());
}
}
/// <summary>
/// Initializes this generator for the given endpoint type.
/// </summary>
/// <param name="type"></param>
public GrainIdGenerator(EndPointType type)
{
const ulong midPoint = (MaxValue - MinValue) / 2 + MinValue;
switch (type)
{
case EndPointType.Client:
_range = new GrainIdRange(MinValue, midPoint - 1);
break;
case EndPointType.Server:
_range = new GrainIdRange(midPoint, MaxValue);
break;
default:
throw new InvalidEnumArgumentException(nameof(type), (int)type, typeof(EndPointType));
}
_nextId = _range.Minimum;
}
public void AttatchToBar(RigidElement bar, EndPointType pointType)
{
AttatchedBar = bar;
transform.parent = bar.transform;
transform.localPosition = TensegrityUtil.CleanUp(transform.localPosition);
type = pointType;
switch (pointType)
{
case EndPointType.IsStart:
transform.localRotation = Quaternion.Euler(-90f, 0, 0);
bar.startPoint = this;
break;
case EndPointType.IsEnd:
transform.localRotation = Quaternion.Euler(90f, 0, 0);
bar.endPoint = this;
break;
}
}
/// <summary>
/// Creates a new socket end point that (optionally) is bound to the given
/// P2P name, if PNRP is available, otherwise the name is only used for debugging.
/// </summary>
/// <param name="type">The type of endpoint to create</param>
/// <param name="name">
/// The name of this socket, used to publish it via PNRP as well as to refer to this endpoint in
/// diagnostic output
/// </param>
/// <param name="clientAuthenticator">
/// The authenticator, if any, to authenticate a client against a server (both need to
/// use the same authenticator)
/// </param>
/// <param name="serverAuthenticator">
/// The authenticator, if any, to authenticate a server against a client (both need to
/// use the same authenticator)
/// </param>
/// <param name="networkServiceDiscoverer">The discoverer used to find services by name within the local network</param>
/// <param name="codeGenerator">The code generator to create proxy and servant types</param>
/// <param name="heartbeatSettings">
/// The settings for heartbeat mechanism, if none are specified, then default settings are
/// used
/// </param>
/// <param name="latencySettings">
/// The settings for latency measurements, if none are specified, then default settings are
/// used
/// </param>
/// <param name="endPointSettings">The settings for the endpoint itself (max. number of concurrent calls, etc...)</param>
public SocketEndPoint(EndPointType type,
string name = null,
IAuthenticator clientAuthenticator = null,
IAuthenticator serverAuthenticator = null,
INetworkServiceDiscoverer networkServiceDiscoverer = null,
ICodeGenerator codeGenerator = null,
HeartbeatSettings heartbeatSettings = null,
LatencySettings latencySettings = null,
EndPointSettings endPointSettings = null)
: base(new GrainIdGenerator(type),
name,
type,
clientAuthenticator,
serverAuthenticator,
codeGenerator,
heartbeatSettings,
latencySettings,
endPointSettings)
{
_networkServiceDiscoverer = networkServiceDiscoverer;
}
public static ServiceType GetWcfServiceType(this EndPointType endPointType)
{
if (endPointType == EndPointType.HTTP)
{
return(ServiceType.HTTP);
}
if (endPointType == EndPointType.TCP)
{
return(ServiceType.TCP);
}
if (endPointType == EndPointType.REST)
{
return(ServiceType.REST);
}
if (endPointType == EndPointType.WSHTTP)
{
return(ServiceType.WSHTTP);
}
throw new InvalidDataException("No ServiceType exists for EndPointType: " + endPointType);
}
private void AdjustEndPointDBValues(OrderedDictionary pValues)
{
if (pValues != null)
{
EndPointType _EndPointType = pValues["EndPointType"].SafeIntegerParse(1).ToEnum <EndPointType>();
var _ApplicationDatabaseQueryID = pValues[ApplicationDatabaseQuery.sEntityKey];
if (_EndPointType != EndPointType.Database || !_ApplicationDatabaseQueryID.SafeToString().IsValidString())
{
pValues.Remove(ApplicationDatabaseQuery.sEntityKey);
pValues.Add(ApplicationDatabaseQuery.sEntityKey, null);
}
var _ApplicationWebServiceRequestID = pValues[ApplicationWebServiceRequest.sEntityKey];
if (_EndPointType != EndPointType.WebService || !_ApplicationWebServiceRequestID.SafeToString().IsValidString())
{
pValues.Remove(ApplicationWebServiceRequest.sEntityKey);
pValues.Add(ApplicationWebServiceRequest.sEntityKey, null);
}
}
}
private string GetEndPoint(EndPointType endPointType)
{
string endpointype = endPointType == EndPointType.authorize ? "authorize" : "token";
return(string.Format("{0}/{1}/{2}/{3}", Config.Authority, Config.TanentId, Config.OAuthVersion, endpointype));
}
public static EndPointStrategy Default(Network network, EndPointType endPointType)
{
var port = endPointType == EndPointType.Rpc ? network.RPCPort : network.DefaultPort;
return(new EndPointStrategy(EndPointStrategyType.Default, new IPEndPoint(IPAddress.Loopback, port)));
}
public void CompareTo_TheSameEndpointValue_ReturnsCorrectExpectedResult(
bool includeFirstIntervalEdge, bool includeSecondIntervalEdge,
EndPointType firstEndPointType, EndPointType secondEndPointType,
int expectedResult)
{
//Arrange
// use 0 length intervals here for easier testing
var endPoint1 = new EndPoint<DateTime>(new Interval<DateTime>(now, now, firstEndPointType != EndPointType.Min || includeFirstIntervalEdge, firstEndPointType != EndPointType.Max || includeFirstIntervalEdge), firstEndPointType);
var endPoint2 = new EndPoint<DateTime>(new Interval<DateTime>(now, now, secondEndPointType != EndPointType.Min || includeSecondIntervalEdge, secondEndPointType != EndPointType.Max || includeSecondIntervalEdge), secondEndPointType);
//Act
int compareResult = endPoint1.CompareTo(endPoint2);
//Assert
Assert.AreEqual(expectedResult, compareResult);
}
public Chart IOs_Months(long ThingID, long EndPointTypeID, long Year)
{
EndPointType endType = UnitOfWork_Repositories.repoEndpointTypes.Find(EndPointTypeID);
Thing th = UnitOfWork_Repositories.repoThings.Find(ThingID);
Chart hc = new Chart("HC_" + "Thing" + ThingID + "EndPointType" + EndPointTypeID + "Inputs");
hc.title.Text = "Last 12 Months";
hc.subTitle.Text = th.Title + " - " + endType.Title;
hc.xAxis.GenerateMonthsList();
hc.legend.layout = Layout.vertical.ToString();
List <Rpt_ThingEnd_IOs_Months_Result> rpt = db.Rpt_ThingEnd_IOs_Months(ThingID, EndPointTypeID, Year).ToList();
#region GetMin
Serie s1 = new Serie();
s1.Name = "Min";
Rpt_ThingEnd_IOs_Months_Result rpt1 = rpt[0];
List <int> resultMin = new List <int>();
resultMin.Add(rpt1.C1.GetValueOrDefault());
resultMin.Add(rpt1.C2.GetValueOrDefault());
resultMin.Add(rpt1.C3.GetValueOrDefault());
resultMin.Add(rpt1.C4.GetValueOrDefault());
resultMin.Add(rpt1.C5.GetValueOrDefault());
resultMin.Add(rpt1.C6.GetValueOrDefault());
resultMin.Add(rpt1.C7.GetValueOrDefault());
resultMin.Add(rpt1.C8.GetValueOrDefault());
resultMin.Add(rpt1.C9.GetValueOrDefault());
resultMin.Add(rpt1.C10.GetValueOrDefault());
resultMin.Add(rpt1.C11.GetValueOrDefault());
resultMin.Add(rpt1.C12.GetValueOrDefault());
resultMin.Reverse();
s1.Data = resultMin;
hc.series.Add(s1);
#endregion
#region GetMax
Serie s2 = new Serie();
s2.Name = "Max";
Rpt_ThingEnd_IOs_Months_Result rpt2 = rpt[1];
List <int> resultMax = new List <int>();
resultMax.Add(rpt2.C1.GetValueOrDefault());
resultMax.Add(rpt2.C2.GetValueOrDefault());
resultMax.Add(rpt2.C3.GetValueOrDefault());
resultMax.Add(rpt2.C4.GetValueOrDefault());
resultMax.Add(rpt2.C5.GetValueOrDefault());
resultMax.Add(rpt2.C6.GetValueOrDefault());
resultMax.Add(rpt2.C7.GetValueOrDefault());
resultMax.Add(rpt2.C8.GetValueOrDefault());
resultMax.Add(rpt2.C9.GetValueOrDefault());
resultMax.Add(rpt2.C10.GetValueOrDefault());
resultMax.Add(rpt2.C11.GetValueOrDefault());
resultMax.Add(rpt2.C12.GetValueOrDefault());
resultMax.Reverse();
s2.Data = resultMax;
hc.series.Add(s2);
#endregion
#region GetAvg
Serie s3 = new Serie();
s3.Name = "Avg";
Rpt_ThingEnd_IOs_Months_Result rpt3 = rpt[2];
List <int> resultAvg = new List <int>();
resultAvg.Add(rpt3.C1.GetValueOrDefault());
resultAvg.Add(rpt3.C2.GetValueOrDefault());
resultAvg.Add(rpt3.C3.GetValueOrDefault());
resultAvg.Add(rpt3.C4.GetValueOrDefault());
resultAvg.Add(rpt3.C5.GetValueOrDefault());
resultAvg.Add(rpt3.C6.GetValueOrDefault());
resultAvg.Add(rpt3.C7.GetValueOrDefault());
resultAvg.Add(rpt3.C8.GetValueOrDefault());
resultAvg.Add(rpt3.C9.GetValueOrDefault());
resultAvg.Add(rpt3.C10.GetValueOrDefault());
resultAvg.Add(rpt3.C11.GetValueOrDefault());
resultAvg.Add(rpt3.C12.GetValueOrDefault());
resultAvg.Reverse();
s3.Data = resultAvg;
hc.series.Add(s3);
#endregion
return(hc);
}
