/// <summary>
/// Initialises this instance.
/// </summary>
/// <remarks></remarks>
public override void Initialise()
{
base.Initialise();
DirectoryInfo storeDirectory = new DirectoryInfo(storeLocation);
if (storeDirectory.Exists)
{
FileInfo[] sessions = storeDirectory.GetFiles("*.session");
XmlDocument sessionXml = new XmlDocument();
foreach (FileInfo sessionFile in sessions)
{
try
{
sessionXml.Load(sessionFile.FullName);
string sessionToken = sessionXml.DocumentElement.GetAttribute("token");
string userName = sessionXml.DocumentElement.GetAttribute("userName");
string expiryTime = sessionXml.DocumentElement.GetAttribute("expiry");
SessionDetails session = new SessionDetails(userName, DateTime.Parse(expiryTime, CultureInfo.CurrentCulture));
foreach (XmlElement value in sessionXml.SelectNodes("//value"))
{
string valueKey = value.GetAttribute("key");
session.Values[valueKey] = value.InnerText;
}
AddToCacheInternal(sessionToken, session);
}
catch { } // Ignore any exceptions - just assume that the session is invalid
}
}
else
{
storeDirectory.Create();
}
}
/// <summary>
/// Adds to cache internal.
/// </summary>
/// <param name="sessionToken">The session token.</param>
/// <param name="session">The session.</param>
/// <remarks></remarks>
protected virtual void AddToCacheInternal(string sessionToken, SessionDetails session)
{
lock (this)
{
cache.Add(sessionToken, session);
}
}
private static async Task <int> OutputStats(string baseUrl, string dataViewName, string username, string password)
{
using (LoggingHandler loggingHandler = new LoggingHandler())
{
ILogger <Program> logger = loggingHandler.CreateLogger <Program>();
ApiConnectorFactory connectorFactory = new ApiConnectorFactory(baseUrl);
LoginService loginService = new LoginService(connectorFactory, dataViewName);
SessionDetails sessionDetails = await loginService.Login(username, password);
if (sessionDetails == null)
{
logger.LogError($"Couldn't log in to data view {dataViewName} as user {username}");
return(-1);
}
try
{
StatsGatherer statsGatherer = new StatsGatherer(connectorFactory, dataViewName, loggingHandler.CreateLogger <StatsGatherer>());
bool success = await statsGatherer.OutputStats(sessionDetails, System.Console.Out);
return(success ? 0 : -1);
}
finally
{
await loginService.Logout(sessionDetails);
}
}
}
/// <summary>
/// This implementation of the ReleaseSession method is
/// invoked to release any locks that are currently being
/// held on the specified session.
/// </summary>
/// <param name="sessionId">
/// The session id of the session being released.
/// </param>
public void ReleaseSession(string sessionId)
{
// REC: Ensure that the session id corresponds to
// an actual instance of an acquired session:
if (_mapSessions.ContainsKey(sessionId))
{
// REC: Retrieve the session details for the
// specifies session:
SessionDetails details = _mapSessions[sessionId];
// REC: Close the writers that are associated
// with the specified session:
details.IdxWriter.Close();
details.MsgWriter.Close();
// REC: Test for the presence of a lock file for
// the specified session and delete it if found:
string lockPath = Path.Combine(_rootPath, sessionId);
string lockFile = Path.Combine(lockPath, "Locked.txt");
if (File.Exists(lockFile))
{
File.Delete(lockFile);
}
// REC: Remove the session details from the map:
_mapSessions.Remove(sessionId);
}
}
public async Task <List <string> > CalculateCube(string systemName, SessionDetails sessionDetails, Query baseQuery, List <Dimension> dimensions, List <Measure> measures, TimeSpan timeout)
{
if (baseQuery?.Selection?.TableName == null)
{
throw new ArgumentException("The specified baseQuery must have at least a selection with a table name in order for it to be a valid query", nameof(baseQuery));
}
ICubesApi cubesApi = connectorFactory.CreateCubesApi(sessionDetails);
Cube cube = new Cube(
BaseQuery: baseQuery,
ResolveTableName: baseQuery.Selection.TableName,
Storage: Cube.StorageEnum.Full,
Dimensions: dimensions,
Measures: measures);
CubeResult cubeResult = await cubesApi.CubesCalculateCubeSynchronouslyAsync(dataViewName, systemName, cube, (int)timeout.TotalSeconds, true);
List <string> data = new List <string>();
if (cubeResult?.MeasureResults != null)
{
for (int measureIndex = 0; measureIndex < cubeResult.MeasureResults.Count; measureIndex++)
{
MeasureResult measureResult = cubeResult.MeasureResults[measureIndex];
Measure measure = measures[measureIndex];
AddMeaureToData(data, measure, measureResult, cubeResult.DimensionResults);
data.Add("");
}
}
return(data);
}
/// <summary>
/// Adds a session to the cache and generates a session token.
/// </summary>
/// <param name="userName">The user name to add.</param>
/// <returns>The session token.</returns>
public virtual string AddToCache(string userName)
{
string sessionToken = Guid.NewGuid().ToString();
SessionDetails session = new SessionDetails(userName, clock.Now.AddMinutes(durationInMinutes));
AddToCacheInternal(sessionToken, session);
return sessionToken;
}
/// <summary>
/// Retrieves the session details based on a token.
/// </summary>
/// <param name="sessionToken">The session token to use.</param>
/// <returns>The details, of valid, null otherwise.</returns>
protected virtual SessionDetails RetrieveSessionDetails(string sessionToken)
{
if (cache.ContainsKey(sessionToken))
{
SessionDetails session = cache[sessionToken];
if (clock.Now < session.ExpiryTime)
{
if (expiryMode == SessionExpiryMode.Sliding)
{
lock (this)
{
cache[sessionToken].ExpiryTime = clock.Now.AddMinutes(durationInMinutes);
}
}
return(session);
}
else
{
RemoveFromCache(sessionToken);
return(null);
}
}
else
{
return(null);
}
}
private static async Task <int> OutputRows(string baseUrl, string dataViewName, string username, string password, string systemName, string queryFilePath, List <string> variableNames)
{
using (LoggingHandler loggingHandler = new LoggingHandler())
{
ILogger <Program> logger = loggingHandler.CreateLogger <Program>();
ApiConnectorFactory connectorFactory = new ApiConnectorFactory(baseUrl);
LoginService loginService = new LoginService(connectorFactory, dataViewName);
SessionDetails sessionDetails = await loginService.Login(username, password);
if (sessionDetails == null)
{
logger.LogError($"Couldn't log in to data view {dataViewName} as user {username}");
return(-1);
}
try
{
DataExplorer dataExplorer = new DataExplorer(connectorFactory, dataViewName, loggingHandler.CreateLogger <DataExplorer>());
bool success = await dataExplorer.TryShowRowsForQuery(sessionDetails, systemName, queryFilePath, variableNames, 100, System.Console.Out);
return(success ? 0 : -1);
}
finally
{
await loginService.Logout(sessionDetails);
}
}
}
public async Task <List <string> > GetSystemNames(SessionDetails sessionDetails)
{
IFastStatsSystemsApi systemApi = connectorFactory.CreateFastStatsSystemsApi(sessionDetails);
PagedResultsFastStatsSystemSummary systems = await systemApi.FastStatsSystemsGetFastStatsSystemsAsync(dataViewName, null, null, null, 1000);
return(systems?.List?.Select(s => s.Name).ToList() ?? new List <string>());
}
/// <inheritdoc />
public DefaultSessionMessageContext([NotNull] IConnectionService connectionService, [NotNull] IPeerPayloadSendService <TPayloadWriteType> payloadSendService, [NotNull] IPeerRequestSendService <TPayloadWriteType> requestSendService, [NotNull] SessionDetails details)
{
ConnectionService = connectionService ?? throw new ArgumentNullException(nameof(connectionService));
PayloadSendService = payloadSendService ?? throw new ArgumentNullException(nameof(payloadSendService));
RequestSendService = requestSendService ?? throw new ArgumentNullException(nameof(requestSendService));
Details = details ?? throw new ArgumentNullException(nameof(details));
}
public async Task <bool> TryShowRowForUrn(SessionDetails sessionDetails, string systemName, string referenceVariableName, string urnValue, List <string> variableNames, TextWriter outputWriter)
{
FastStatsSystemService fastStatsSystemService = new FastStatsSystemService(connectorFactory, dataViewName);
Variable referenceVariable = await fastStatsSystemService.GetVariable(sessionDetails, systemName, referenceVariableName);
if (referenceVariable == null)
{
throw new Exception($"The variable {referenceVariableName} wasn't found in the system {systemName}");
}
Query query = BuildQueryForUrn(referenceVariable, urnValue);
variableNames.Insert(0, referenceVariableName);
List <Column> columns = BuildExportColumns(variableNames);
ExportsService exportsService = new ExportsService(connectorFactory, dataViewName);
List <string> rows = await exportsService.ExportData(systemName, sessionDetails, query, columns, 1, TimeSpan.FromMinutes(5));
if (rows == null)
{
return(false);
}
foreach (string row in rows)
{
outputWriter.WriteLine(row);
}
return(true);
}
private void SpecialSessionList_MouseDoubleClick(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
var specialSession = (SpecialSessionDTO)SpecialSessionList.SelectedItem;
SessionDetails newWindow = new SessionDetails(null, specialSession);
newWindow.ShowDialog();
}
/// <summary>
/// Adds to cache internal.
/// </summary>
/// <param name="sessionToken">The session token.</param>
/// <param name="session">The session.</param>
/// <remarks></remarks>
protected virtual void AddToCacheInternal(string sessionToken, SessionDetails session)
{
lock (this)
{
cache.Add(sessionToken, session);
}
}
/// <summary>
/// Adds a session to the cache and generates a session token.
/// </summary>
/// <param name="userName">The user name to add.</param>
/// <returns>The session token.</returns>
public virtual string AddToCache(string userName)
{
string sessionToken = Guid.NewGuid().ToString();
SessionDetails session = new SessionDetails(userName, clock.Now.AddMinutes(durationInMinutes));
AddToCacheInternal(sessionToken, session);
return(sessionToken);
}
/// <inheritdoc />
public ZoneClientSession(IManagedNetworkServerClient <GameServerPacketPayload, GameClientPacketPayload> internalManagedNetworkClient,
SessionDetails details,
MessageHandlerService <GameClientPacketPayload, GameServerPacketPayload, IPeerSessionMessageContext <GameServerPacketPayload> > messageHandlers,
[NotNull] ILog logger)
: base(internalManagedNetworkClient, details)
{
MessageHandlers = messageHandlers ?? throw new ArgumentNullException(nameof(messageHandlers));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public async Task Logout(SessionDetails sessionDetails)
{
if (sessionDetails == null)
{
throw new Exception("No session has been created - please log in");
}
ISessionsApi sessionsApi = connectorFactory.CreateSessionsApi(sessionDetails);
await sessionsApi.SessionsLogoutSessionAsync(dataViewName, sessionDetails.SessionId);
}
public SessionDetails Get(string sessionId, bool detailed)
{
SessionController sessionController = new SessionController();
ISession session = sessionController.GetSessionWithId(new SessionId(sessionId)).Result;
SessionDetails retVal = new SessionDetails
{
Description = session.Description,
SessionId = session.SessionId.ToString(),
StartTime = session.StartTime.ToString("yyyy-MM-dd HH:mm:ss"),
EndTime = session.EndTime.ToString("yyyy-MM-dd HH:mm:ss"),
Status = session.Status
};
foreach (IDiagnoserSession diagSession in session.GetDiagnoserSessions())
{
DiagnoserSessionDetails diagSessionDetails = new DiagnoserSessionDetails
{
Name = diagSession.Diagnoser.Name,
CollectorStatus = diagSession.CollectorStatus,
AnalyzerStatus = diagSession.AnalyzerStatus,
};
foreach (Log log in diagSession.GetLogs())
{
LogDetails logDetails = new LogDetails
{
FileName = log.FileName,
RelativePath = log.RelativePath,
FullPermanentStoragePath = log.FullPermanentStoragePath,
StartTime = log.StartTime.ToString("yyyy-MM-dd HH:mm:ss"),
EndTime = log.EndTime.ToString("yyyy-MM-dd HH:mm:ss")
};
diagSessionDetails.AddLog(logDetails);
}
foreach (Report report in diagSession.GetReports())
{
ReportDetails reportDetails = new ReportDetails
{
FileName = report.FileName,
RelativePath = report.RelativePath,
FullPermanentStoragePath = report.FullPermanentStoragePath
};
diagSessionDetails.AddReport(reportDetails);
}
retVal.AddDiagnoser(diagSessionDetails);
}
return(retVal);
}
private void ExecuteEditPassCommand(SessionDetails obj)
{
try
{
_windowService.ShowEditPassWindow();
}
catch (Exception e)
{
ReportException(e);
}
}
public async Task <SessionDetails> Login(string username, string password)
{
ISessionsApi sessionsApi = connectorFactory.CreateSessionsApi(null);
SessionDetails details = await sessionsApi.SessionsCreateSessionSimpleAsync(dataViewName, username, password);
if (details?.AccessToken == null)
{
return(null);
}
return(details);
}
/// <summary>
/// Removes the session key from internal and DB storage
/// </summary>
/// <param name="sessionId">The session key of the session to remove</param>
private void RemoveFromStorage(string sessionId)
{
SessionDetails session = new SessionDetails();
session.SessionId = sessionId;
this.updatesToStore.Enqueue(session);
if (this.internalStore.ContainsKey(sessionId))
{
SessionDetails output = null;
this.internalStore.TryRemove(sessionId, out output);
}
}
private static Session PopulateFromDBDetailsObject(SessionDetails obj)
{
Session objNew = new Session();
objNew.LoginNo = obj.LoginNo;
objNew.SessionName = obj.SessionName;
objNew.SessionTimestamp = obj.SessionTimestamp;
objNew.StartTime = obj.StartTime;
objNew.IPAddress = obj.IPAddress;
objNew.EmployeeName = obj.EmployeeName;
return(objNew);
}
/// <summary>
/// Stores a value for a session.
/// </summary>
/// <param name="sessionToken">The session token to use.</param>
/// <param name="key">The key of the value.</param>
/// <param name="value">The value to store.</param>
public virtual void StoreSessionValue(string sessionToken, string key, object value)
{
SessionDetails details = RetrieveSessionDetails(sessionToken);
if (details != null)
{
lock (this)
{
details.Values[key] = value;
}
}
}
public bool Login(string username, string password)
{
ISessionsApi sessionsApi = apiConnectorFactory.CreateSessionsApi(null);
SessionDetails details = sessionsApi.SessionsCreateSessionSimple(dataView, username, password);
if (details?.AccessToken == null)
{
return(false);
}
sessionDetails = details;
return(true);
}
/// <summary>
/// Retrieves a user name from the cache based on a session token.
/// </summary>
/// <param name="sessionToken">The session token to use.</param>
/// <returns>The user name if the token is valid, null otherwise.</returns>
public virtual string RetrieveFromCache(string sessionToken)
{
SessionDetails details = RetrieveSessionDetails(sessionToken);
if (details == null)
{
return(null);
}
else
{
return(details.UserName);
}
}
public async Task <Query> GetQueryDefinitionFromFile(string systemName, SessionDetails sessionDetails, string filePath, TimeSpan timeout)
{
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
IQueriesApi queriesApi = connectorFactory.CreateQueriesApi(sessionDetails);
QueryResult queryResult = await queriesApi.QueriesPerformGetQueryFileDefinitionSynchronouslyAsync(dataViewName, systemName, new QueryFile(filePath));
return(queryResult?.Query);
}
public async Task <bool> TryShowCubeForVariables(SessionDetails sessionDetails, string systemName, string queryFilePath, List <string> variableNames, TextWriter outputWriter)
{
QueriesService queriesService = new QueriesService(connectorFactory, dataViewName);
Query query = await queriesService.GetQueryDefinitionFromFile(systemName, sessionDetails, queryFilePath, TimeSpan.FromMinutes(5));
if (query == null)
{
return(false);
}
if (query?.Selection?.TableName == null)
{
throw new Exception($"The query {queryFilePath} must have at least a selection with a table name");
}
FastStatsSystemService fastStatsSystemService = new FastStatsSystemService(connectorFactory, dataViewName);
foreach (string variableName in variableNames)
{
Variable variable = await fastStatsSystemService.GetVariable(sessionDetails, systemName, variableName);
if (variable == null)
{
throw new Exception($"Couldn't find a variable with the name {variableName} in the system {systemName}");
}
if (variable.Type != Variable.TypeEnum.Selector)
{
throw new Exception($"The DataAggregator can only build cubes with selector variables, but {variable.Description} is of type {variable.Type}");
}
}
List <Dimension> dimensions = BuildDimensions(variableNames);
List <Measure> measures = BuildMeasures(query.Selection.TableName);
CubesService cubesService = new CubesService(connectorFactory, dataViewName);
List <string> rows = await cubesService.CalculateCube(systemName, sessionDetails, query, dimensions, measures, TimeSpan.FromMinutes(5));
if (rows == null)
{
return(false);
}
foreach (string row in rows)
{
outputWriter.WriteLine(row);
}
return(true);
}
/// <summary>
/// Retrieves a value from a session.
/// </summary>
/// <param name="sessionToken">The session token to use.</param>
/// <param name="key">The key of the value.</param>
/// <returns>The value if available, null otherwise.</returns>
public virtual object RetrieveSessionValue(string sessionToken, string key)
{
object value = null;
SessionDetails details = RetrieveSessionDetails(sessionToken);
if (details != null)
{
if (cache[sessionToken].Values.ContainsKey(key))
{
value = cache[sessionToken].Values[key];
}
}
return(value);
}
public async Task <Variable> GetReferenceVariableForTable(SessionDetails sessionDetails, string systemName, string tableName)
{
IFastStatsSystemsApi systemApi = connectorFactory.CreateFastStatsSystemsApi(sessionDetails);
string filter = $"(TableName eq '{tableName}') and (Type eq 'Reference')";
PagedResultsVariable variables = await systemApi.FastStatsSystemsGetFastStatsVariablesAsync(dataViewName, systemName, filter, null, null, 1000000);
if (variables.List.Count == 0)
{
return(null);
}
return(variables.List[0]);
}
public void GruntAndShake()
{
//Play grunt
GetComponent <AudioSource>().PlayOneShot(GruntSfx);
//Shake Camera
currectShakeBounces = 0;
//shakeCamera = true;
//Take Damage
GameObject sessionObj = FindObjectsOfType <GameObject>().Where(g => g.GetComponent <SessionDetails>() != null).FirstOrDefault();
SessionDetails session = sessionObj.GetComponent <SessionDetails>();
session.TakeDamage(1);
}
private Configuration CreateConfiguration(SessionDetails sessionDetails)
{
Dictionary <string, string> defaultHeaders = new Dictionary <string, string>();
if (sessionDetails != null)
{
defaultHeaders.Add("Authorization", "Bearer " + sessionDetails.AccessToken);
}
return(new Configuration()
{
DefaultHeader = defaultHeaders,
BasePath = baseUrl
});
}
/// <summary>
/// Updates the interal storage and the database storage and keeps them in sync
/// </summary>
/// <param name="sessionId">The sessionId to store</param>
/// <param name="role">The session Data to store</param>
private void UpdateStorage(string sessionId, string role)
{
if (!this.internalStore.ContainsKey(sessionId))
{
SessionDetails session = new SessionDetails();
session.SessionId = sessionId;
session.Role = role;
session.LastAccess = DateTime.Now;
this.internalStore.TryAdd(sessionId, session);
}
else
{
this.internalStore[sessionId].Role = role;
this.internalStore[sessionId].LastAccess = DateTime.Now;
}
this.updatesToStore.Enqueue(this.internalStore[sessionId]);
}
/// <summary>
/// Saves the session.
/// </summary>
/// <param name="sessionToken">The session token.</param>
/// <remarks></remarks>
protected virtual void SaveSession(string sessionToken)
{
SessionDetails details = RetrieveSessionDetails(sessionToken);
string sessionFile = GenerateFileName(sessionToken);
XmlDocument sessionXml = new XmlDocument();
XmlElement sessionRoot;
XmlElement valuesNode;
if (File.Exists(sessionFile))
{
sessionXml.Load(sessionFile);
sessionRoot = sessionXml.DocumentElement;
}
else
{
sessionRoot = sessionXml.CreateElement("session");
sessionRoot.SetAttribute("token", sessionToken);
sessionXml.AppendChild(sessionRoot);
}
sessionRoot.SetAttribute("userName", details.UserName);
sessionRoot.SetAttribute("expiry", details.ExpiryTime.ToString("o", CultureInfo.CurrentCulture));
// Wipe the existing values
valuesNode = sessionXml.SelectSingleNode("values") as XmlElement;
if (valuesNode != null)
{
valuesNode.ParentNode.RemoveChild(valuesNode);
}
// Add the values
valuesNode = sessionXml.CreateElement("values");
sessionRoot.AppendChild(valuesNode);
foreach (string key in details.Values.Keys)
{
XmlElement valueNode = sessionXml.CreateElement("value");
valueNode.SetAttribute("key", key);
object keyValue = details.Values[key];
valueNode.SetAttribute("type", keyValue.GetType().Name);
valueNode.InnerText = keyValue.ToString();
valuesNode.AppendChild(valueNode);
}
sessionXml.Save(sessionFile);
}
/// <summary>
/// Initialises this instance.
/// </summary>
/// <remarks></remarks>
public override void Initialise()
{
base.Initialise();
DirectoryInfo storeDirectory = new DirectoryInfo(storeLocation);
if (storeDirectory.Exists)
{
FileInfo[] sessions = storeDirectory.GetFiles("*.session");
XmlDocument sessionXml = new XmlDocument();
foreach (FileInfo sessionFile in sessions)
{
try
{
sessionXml.Load(sessionFile.FullName);
string sessionToken = sessionXml.DocumentElement.GetAttribute("token");
string userName = sessionXml.DocumentElement.GetAttribute("userName");
string expiryTime = sessionXml.DocumentElement.GetAttribute("expiry");
SessionDetails session = new SessionDetails(userName, DateTime.Parse(expiryTime, CultureInfo.CurrentCulture));
foreach (XmlElement value in sessionXml.SelectNodes("//value"))
{
string valueKey = value.GetAttribute("key");
session.Values[valueKey] = value.InnerText;
}
AddToCacheInternal(sessionToken, session);
}
catch { } // Ignore any exceptions - just assume that the session is invalid
}
}
else
{
storeDirectory.Create();
}
}
public string Add(StudentModelView student)
{
if(ModelState.IsValid)
{
int session_id = SessionHandler.GetSchoolSessionID();
if(session_id < 0)
{
return Utils.Response(false, "Please select a default session before adding session");
}
int user_id = SessionHandler.GetUserID();
int school_id = SessionHandler.GetSchoolID();
var std = new Student()
{
first_name = student.FirstName,
last_name = student.LastName,
gender = student.Gender,
parent_id = student.Parent,
class_id = student.Class,
school_id= school_id,
roll = student.RollNo,
monthly_fee = student.MonthlyFee,
admission_fee = student.AdmissionFee,
examination_fee = student.ExaminationFee,
other_charges = student.OtherCharges,
discount = student.Discount,
email = student.EmailAddress,
password = student.Password,
address = student.Address,
birthday = student.DateofBirth
};
std.school_id = school_id;
std.created_by = user_id;
int student_id = _sd.Insert(std);
if (student_id != -1)
{
var session = new SessionDetails().FindSingle(session_id ,school_id);
var months = Utils.GetMonths(session.start_date, session.end_date);
SchoolFeeStructure feestr = Utils.GetFeeStructure(school_id);
insertStudentFeeDetail(FeeType.ADMISSION_FEE, student_id, std.class_id,session_id);
insertStudentFeeDetail(FeeType.EXAMINATION_FEE, student_id, std.class_id, session_id);
insertStudentFeeDetail(FeeType.OTHER_CHARGES, student_id, std.class_id, session_id);
foreach(var month in months)
{
insertStudentFeeDetail(FeeType.MONTHLY_FEE, student_id, std.class_id, session_id, month);
}
return student_id.ToJSON();
}
return true.ToJSON();
}
return false.ToJSON();
}
private string GenerateOAT_String(Stream fileInputStream, Dictionary<string, object> MapMatchingMetaData)
{
try
{
StringBuilder finalOatInput = new StringBuilder();
StreamReader CsvFile = new StreamReader(fileInputStream, Encoding.UTF8, true);
DataTable dtFromCsv = null;
//bool IsFirstRow = true;
//char separator = ',';
List<string> wordList = new List<string>();
List<string> NIdValuePair = new List<string>();
if (Session["CurrentSelectedAreaNids"] != null)
{
Session["CurrentSelectedAreaNids"] = null;
}
#region Convert CSV to DataTable
if (MapMatchingMetaData["tPeriosCol"].ToString().LastIndexOf(",") > -1)
{
dtFromCsv = getDTForAllColumnTimePeriod(CsvFile, wordList, MapMatchingMetaData);
MapMatchingMetaData["tPeriosCol"] = getTimePeriodIndex(MapMatchingMetaData); ;
}
else
{
dtFromCsv = getDTForSelectedTimePeriod(CsvFile, wordList, MapMatchingMetaData);
}
#endregion
#region Getting those Column Indexes which do not qualify for Numeric DataValues
List<int> NonNumericColumns = new List<int>();
bool checkForMoreNumericCols = true;
int firstNumericCol = -1;
for (int i = dtFromCsv.Columns.Count - 1; i > -1; i--)
{
if (!checkForMoreNumericCols) NonNumericColumns.Add(i);
else
{
foreach (DataRow dr in dtFromCsv.Rows)
{
float tmpVal = 0;
if (!float.TryParse(dr[i].ToString(), out tmpVal)) // If Non Numeric Found
{
if (dr[i].ToString() != string.Empty && dr[i].ToString() != "-" && dr[i].ToString() != " ")
{
NonNumericColumns.Add(i);
break;
}
}
else // Figuring out consecutive numerics columns otherwise consider all as No-Numeric columns
{
if (firstNumericCol == -1) firstNumericCol = i;
else
{
if (firstNumericCol == i + 1 || firstNumericCol == i) firstNumericCol = i;
else
{
checkForMoreNumericCols = false;
NonNumericColumns.Add(i);
break;
}
}
}
}
}
NIdValuePair.Add(dtFromCsv.Columns[i].ColumnName);
}
if (!string.IsNullOrEmpty(Convert.ToString(MapMatchingMetaData["tPeriosCol"])))
{
dtFromCsv = getMrdUpdatedTable(dtFromCsv, MapMatchingMetaData, NonNumericColumns);
NonNumericColumns.Add(Convert.ToInt32(MapMatchingMetaData["tPeriosCol"]));
NonNumericColumns.Add(dtFromCsv.Columns.Count - 1);
NonNumericColumns.Sort();
NonNumericColumns.Reverse();
dtFromCsv.Columns[Convert.ToInt32(MapMatchingMetaData["tPeriosCol"])].ColumnName = "Time Period";
}
DataTable dtForMap = new System.Data.DataTable();
dtForMap.Load(dtFromCsv.CreateDataReader(), System.Data.LoadOption.OverwriteChanges);
for (int i = 0; i < dtFromCsv.Columns.Count; i++)
{
if (!NonNumericColumns.Contains(i)) // Numeric column found
{
//dtForMap.Columns.Add("[**Data_Value**]" + i.ToString(), typeof(decimal));
dtForMap.Columns[i].Caption = "[**" + Data.DataValue + "**]" + i.ToString();
foreach (DataRow dr in dtForMap.Rows)
{
string CurrentDataValue = dr[i].ToString();
if (CurrentDataValue == "-") dr[i] = string.Empty;
}
}
}
#endregion
#region Utilize additional information for "map" creation
if (MapMatchingMetaData["arIDColIndex"].ToString() != "-1") // Area ID information is provided by meta data
{
int AreaIdColIndex = Convert.ToInt16(MapMatchingMetaData["arIDColIndex"]);
//AreaIdColIndex += dtFromCsv.Columns.Count - NonNumericColumns.Count;
dtForMap.Columns[AreaIdColIndex].Caption = Area.AreaID;
#region User selection matching is utilized
if (!string.IsNullOrEmpty(MapMatchingMetaData["mappingStr"].ToString())) // Matching areas is done manually
{
string[] ManuallyMatchedAreas = MapMatchingMetaData["mappingStr"].ToString().Replace("{||}", "#").Split("#".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
foreach (string matchedArea in ManuallyMatchedAreas)
{
string[] AreaName_AreaID = matchedArea.Replace("{}", "|").Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
foreach (DataRow dr in dtForMap.Rows)
{
if (dr[AreaIdColIndex].ToString() == AreaName_AreaID[0]) // Faulty Area ID is found, now replace it
{
if (AreaName_AreaID.Length == 2) dr[AreaIdColIndex] = AreaName_AreaID[1];
else dr[AreaIdColIndex] = "";
}
}
}
}
#endregion
StringBuilder sbAreaIdsForSQL = new StringBuilder();
foreach (DataRow dr in dtForMap.Rows) sbAreaIdsForSQL.Append("{}" + dr[AreaIdColIndex].ToString());
if (sbAreaIdsForSQL.Length > 0) sbAreaIdsForSQL.Remove(0, 2);
string nowDBnid = Global.GetDefaultDbNId();
DataTable dtMatchedAreaIds = GetDataTable(int.Parse(nowDBnid), sbAreaIdsForSQL.ToString(), "aid", "en");
string UnMatchedAreaIDs = filterRecords(dtMatchedAreaIds, sbAreaIdsForSQL.ToString());
string[] arrUnmatchedAreaIDs = UnMatchedAreaIDs.Split(new string[] { "{}" }, StringSplitOptions.None);
foreach (string UnMatchedAreaID in arrUnmatchedAreaIDs)
{
foreach (DataRow dr in dtForMap.Rows)
{
if (dr[AreaIdColIndex].ToString() == UnMatchedAreaID)
{
dr[AreaIdColIndex] = "";
}
}
}
}
if (MapMatchingMetaData["arNameColIndex"].ToString() != "-1") // Area Name is provided
{
int AreaNameColIndex = Convert.ToInt16(MapMatchingMetaData["arNameColIndex"]);
//AreaNameColIndex += dtFromCsv.Columns.Count - NonNumericColumns.Count;
dtForMap.Columns[AreaNameColIndex].Caption = Area.AreaName;
#region Area ID is fetched & updated from DB
StringBuilder sbAreaNamesForSQL = new StringBuilder();
foreach (DataRow dr in dtForMap.Rows) sbAreaNamesForSQL.Append("{}" + dr[AreaNameColIndex].ToString().Trim());
if (sbAreaNamesForSQL.Length > 0) sbAreaNamesForSQL.Remove(0, 2);
string nowDBnid = Global.GetDefaultDbNId();
string langCode = "";
if (Session["hlngcode"] != null)
{
langCode = Session["hlngcode"].ToString().Trim();
}
else
{
langCode = Global.GetDefaultLanguageCode();
}
DataTable dtMatchedAreaNames = GetDataTable(int.Parse(nowDBnid), sbAreaNamesForSQL.ToString(), "aname", langCode);
#region User selection matching is utilized
if (!string.IsNullOrEmpty(MapMatchingMetaData["mappingStr"].ToString())) // Matching areas is done manually
{
string[] ManuallyMatchedAreas = MapMatchingMetaData["mappingStr"].ToString().Replace("{||}", "#").Split("#".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
foreach (string matchedArea in ManuallyMatchedAreas)
{
string[] AreaName_AreaID = matchedArea.Replace("{}", "|").Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
// To be fixed: Column names should be fixed
if (AreaName_AreaID.Length == 2)
{
string areaName = AreaName_AreaID[0].Trim().ToLower();
string areaId = AreaName_AreaID[1].Trim().ToLower();
for (int i = 0; i < dtMatchedAreaNames.Rows.Count; i++)
{
string dtAreaName = dtMatchedAreaNames.Rows[i][0].ToString().Trim().ToLower();
string dtAreaId = dtMatchedAreaNames.Rows[i][1].ToString().Trim().ToLower();
if (areaName == dtAreaName)
{
dtMatchedAreaNames.Rows.RemoveAt(i);
i--;
}
}
DataRow drAreaID_Name = dtMatchedAreaNames.NewRow();
drAreaID_Name["Area_name"] = AreaName_AreaID[0];
drAreaID_Name["Area_id"] = AreaName_AreaID[1];
dtMatchedAreaNames.Rows.Add(drAreaID_Name);
}
}
}
#endregion
int indexOfAreaID = -1;
//if (!dtForMap.Columns.Contains("Area_ID"))
if (MapMatchingMetaData["arIDColIndex"].ToString() == "-1")
{
dtForMap.Columns.Add("Area_ID");
indexOfAreaID = dtForMap.Columns.Count - 1;
}
else
{
indexOfAreaID = int.Parse(MapMatchingMetaData["arIDColIndex"].ToString());
}
foreach (DataRow dr in dtForMap.Rows)
{
string AreaIdFromDB = string.Empty;
foreach (DataRow drAreaIdName in dtMatchedAreaNames.Rows)
{
if (drAreaIdName["Area_name"].ToString().Trim().ToLower() == dr[AreaNameColIndex].ToString().Trim().ToLower())
{
AreaIdFromDB = drAreaIdName["Area_ID"].ToString();
break;
}
}
if (!string.IsNullOrEmpty(AreaIdFromDB)) dr[indexOfAreaID] = AreaIdFromDB;
}
#endregion
}
if (!string.IsNullOrEmpty(Convert.ToString(MapMatchingMetaData["tPeriosCol"])))
{
dtForMap.Columns[Convert.ToInt32(MapMatchingMetaData["tPeriosCol"])].Caption = Timeperiods.TimePeriod;
}
#endregion
#region Prepare Headers & KeyValue pairs for all columns
string Headers = string.Empty;
string Titles = string.Empty;
for (int i = NonNumericColumns.Count - 1; i > -1; i--)
//for (int i = 0; i < NonNumericColumns.Count; i++)
{
DataTable dtDistinctVals = dtFromCsv.DefaultView.ToTable(true, dtFromCsv.Columns[NonNumericColumns[i]].ColumnName);
if (dtDistinctVals.Rows.Count == 1) // If Column has same data then send it to Titles
{
if (dtFromCsv.Columns[NonNumericColumns[i]].ColumnName != "isMRD")
Titles += dtDistinctVals.Rows[0][0].ToString() + " - ";
//else
// Headers += "isMRD|";
}
else // Make NId:Value pair for them and append them in headers
{
Headers += dtFromCsv.Columns[NonNumericColumns[i]].ColumnName + "|";
foreach (DataRow dr in dtDistinctVals.Rows)
{
NIdValuePair.Add(dr[dtFromCsv.Columns[NonNumericColumns[i]].ColumnName].ToString()); //.Replace("'","")
}
}
}
Headers += "Data Column|Data Value";
if (Titles.EndsWith("Data Column")) Titles = Titles.Substring(0, Titles.Length - 3);
#endregion
foreach (string ValueOfKey in NIdValuePair)
{
int indexOfValue = NIdValuePair.IndexOf(ValueOfKey);
finalOatInput.Append(indexOfValue + ":" + ValueOfKey + "|");
}
finalOatInput.Append(Constants.Delimiters.PivotRowDelimiter);
finalOatInput.Append(Titles + Constants.Delimiters.PivotRowDelimiter);
finalOatInput.Append(Headers + Constants.Delimiters.PivotRowDelimiter);
#region OAT data rows are prepared in string format
foreach (DataRow dr in dtFromCsv.Rows)
{
string tmpRow = string.Empty;
for (int i = 0; i < dtFromCsv.Columns.Count; i++)// If Non-Numeric distinct columns then append their NIds
{
if (Headers.Contains(dtFromCsv.Columns[i].ColumnName + "|")
&& NonNumericColumns.Contains(i))
{
tmpRow += NIdValuePair.IndexOf(dr[i].ToString()).ToString() + "|";
}
}
for (int i = 0; i < dtFromCsv.Columns.Count; i++)
{
if (!Headers.Contains(dtFromCsv.Columns[i].ColumnName + "|")
&& !NonNumericColumns.Contains(i)) // If Non-Numeric distinct columns then append their NIds
{
finalOatInput.Append(tmpRow
+ NIdValuePair.IndexOf(dtFromCsv.Columns[i].ColumnName).ToString()
+ "|" + dr[i].ToString() + Constants.Delimiters.PivotRowDelimiter);
}
}
}
#endregion
//Handling of creating map visualization after session time out
SessionDetails sdetails = new SessionDetails();
if (HttpContext.Current.Request.Cookies["SessionID"] == null)
{
Global.SaveCookie("SessionID", HttpContext.Current.Session.SessionID, this.Page);
}
sdetails.DataViewNonQDS = dtForMap;
sdetails.IsMyData = true;
Global.SerializeObject(TempPath + HttpContext.Current.Request.Cookies["SessionID"].Value + "_sessionDetails" + ".xml", sdetails);
Session["DataViewNonQDS"] = dtForMap;
if (Session["DIMap"] != null)
{
((DevInfo.Lib.DI_LibMap.Map)Session["DIMap"]).Dispose();
Session["DIMap"] = null;
}
return finalOatInput.ToString();
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
return "false";
}
}
/// <summary>
/// ?callback=3¶m1=QS_ASI_L2,QS_ASI_L3[****]1764[****]103[****]isMRD:1||dvStart:46||dvEnd:484
/// requestParam = "[****]16,78,155,314,112,30[****]201[****]isMRD:1||IUS_NId:16||dvStart:0||dvEnd:50";
/// requestParam = "30[****]199,200,213[****]201";
/// </summary>
/// <param name="requestParam"></param>
/// <returns></returns>
public string GetDataView(string requestParam)
{
string Result = string.Empty;
string UILanguage = string.Empty;
StringBuilder sbResult = new StringBuilder();
List<System.Data.Common.DbParameter> DbParams = new List<System.Data.Common.DbParameter>();
string[] Params = Global.SplitString(requestParam, Constants.Delimiters.ParamDelimiter);
//Params after DBNID in this order : Source_NId, TimePeriod_NId, isMRD, dvStart, dvEnd
string AreaNids = Params[0];
string IUSNids = Params[1];
int DbNid = int.Parse(Params[2]);
UILanguage = Params[3];
string AreaO = Params[4];
string IndO = Params[5];
Session["hselindo"] = IndO;
Session["hselareao"] = AreaO;
Session["hselind"] = IUSNids;
Session["hselarea"] = AreaNids;
Session["hdsby"] = "dataview.aspx";
tmpDBNId = DbNid;
int filterIUS_NId = 0;
int filterDvStart = 0;
int filterDvEnd = 0;
// 1. Separate Data Value Filter String from param
// 2. Fetch datavaiew based on Area IUS , Time Period Filter, Source filter
// 3. Get rows satisfying Datavalue filter
// 4. Get unique AreaNId,.... for from above rows
#region Prepare parameters from requestParam for stored procedure execution.
try
{
if (String.IsNullOrEmpty(AreaNids))
{
AreaNids = Global.GetDefaultArea(DbNid.ToString());
}
if (String.IsNullOrEmpty(IUSNids))
{
IUSNids = Global.GetDefaultIusNIds(DbNid.ToString());
}
AreaNids = formatCommaLimitedString(AreaNids);
IUSNids = formatCommaLimitedString(IUSNids);
Session["CurrentSelectedAreaNids"] = AreaNids;
if (_DBCon == null)
{
this.GetDbConnection(tmpDBNId);
}
if (_DBCon != null)
{
System.Data.Common.DbParameter Param1 = _DBCon.CreateDBParameter();
Param1.ParameterName = "strAllAreaQSIds_Nids";
Param1.DbType = DbType.String;
Param1.Value = AreaNids;
DbParams.Add(Param1);
System.Data.Common.DbParameter Param2 = _DBCon.CreateDBParameter();
Param2.ParameterName = "strIUS_Nids";
Param2.DbType = DbType.String;
Param2.Value = IUSNids;
DbParams.Add(Param2);
//try //Code for capturing optional parameters for filtering
//{
// string[] OptionalParams = Global.SplitString(Params[4], "||");
// foreach (string spParamName in OptionalParams)
// {
// string[] KeyVal = spParamName.Split(':');
// switch (KeyVal[0])
// {
// case "IUS_NId":
// {
// filterIUS_NId = Convert.ToInt32(KeyVal[1]);
// break;
// }
// case "dvStart":
// {
// filterDvStart = Convert.ToInt32(KeyVal[1]);
// break;
// }
// case "dvEnd":
// {
// filterDvEnd = Convert.ToInt32(KeyVal[1]);
// break;
// }
// default:
// {
// System.Data.Common.DbParameter dbParam = _DBCon.CreateDBParameter();
// dbParam.ParameterName = KeyVal[0];
// dbParam.DbType = DbType.String;
// dbParam.Value = KeyVal[1];
// DbParams.Add(dbParam);
// break;
// }
// }
// }
//}
//catch (Exception) { }
#endregion
string CurrentLanguage = Global.GetDefaultLanguageCodeDB(DbNid.ToString(), UILanguage);
//Get all data with MRD, Sources & Time period filter. If needed then DataValue filters would be applied over this set of data.
DataTable dtDataviewWithoutDataValueFilter = _DBCon.ExecuteDataTable("sp_get_dataview_" + CurrentLanguage, CommandType.StoredProcedure, DbParams);
//Handling of creating map visualization after session time out
SessionDetails sdetails = new SessionDetails();
if (HttpContext.Current.Request.Cookies["SessionID"] == null)
{
Global.SaveCookie("SessionID", HttpContext.Current.Session.SessionID, this.Page);
}
sdetails.IsMyData = false;
sdetails.DataViewNonQDS = dtDataviewWithoutDataValueFilter;
sdetails.CurrentSelectedAreaNids = Session["CurrentSelectedAreaNids"].ToString();
Global.SerializeObject(TempPath + HttpContext.Current.Request.Cookies["SessionID"].Value + "_sessionDetails" + ".xml", sdetails);
Session["IsMyData"] = false;
Session["DataViewNonQDS"] = dtDataviewWithoutDataValueFilter;
if (Session["DIMap"] != null)
{
((DevInfo.Lib.DI_LibMap.Map)Session["DIMap"]).Dispose();
Session["DIMap"] = null;
}
Result = PrepareDataViewString(dtDataviewWithoutDataValueFilter, CurrentLanguage, filterIUS_NId, filterDvStart, filterDvEnd);
return Result;
}
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
return "false";
}
finally
{
if (_DBCon != null)
{
_DBCon.Dispose();
}
}
return Result;
}
/// <summary>
/// ?callback=13¶m1=FULL_HTML_FOR_OAT
/// </summary>
/// <param name="requestParam"></param>
/// <returns></returns>
public string GetDataViewDataNids(string requestParam)
{
string Result = string.Empty;
StringBuilder sbResult = new StringBuilder();
string DataNids = string.Empty;
string SelectedDimension = string.Empty;
string UILanguage = string.Empty;
List<string> DefaultSubgroups = new List<string>();
List<System.Data.Common.DbParameter> DbParams = new List<System.Data.Common.DbParameter>();
string[] Params = Global.SplitString(requestParam, Constants.Delimiters.ParamDelimiter);
UILanguage = Params[2]; // UI language code
string[] paramFromQds = Params[0].Split(":".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
if (paramFromQds.Length == 2) // QDS Visualize feature is used with a selected dimension
{
DataNids = paramFromQds[0];
SelectedDimension = paramFromQds[1];
}
else if (paramFromQds.Length == 1) // QDS 'add to cart' feature is used
{
string[] paramsDataNIds_DefaultSGs = paramFromQds[0].Split(',');
foreach (string paramVal in paramsDataNIds_DefaultSGs)
{
string[] paramDV_SG = paramVal.Split('-');
DataNids += "," + paramDV_SG[0];
if (!DefaultSubgroups.Contains(paramDV_SG[1])) DefaultSubgroups.Add(paramDV_SG[1]);
}
if (DataNids.Length > 0) DataNids = DataNids.Substring(1);
}
//Params after DBNID in this order : Source_NId, TimePeriod_NId, isMRD, dvStart, dvEnd
//DataNids = Params[0].Split(':')[0];
int DbNid = int.Parse(Params[1]);
tmpDBNId = DbNid;
int filterIUS_NId = 0;
int filterDvStart = 0;
int filterDvEnd = 0;
string AreaNids = string.Empty;
try
{
if (_DBCon == null)
{
this.GetDbConnection(tmpDBNId);
}
if (String.IsNullOrEmpty(AreaNids))
{
AreaNids = Global.GetDefaultArea(DbNid.ToString());
}
if (_DBCon != null)
{
System.Data.Common.DbParameter Param1 = _DBCon.CreateDBParameter();
Param1.ParameterName = "strAllData_Nids";
Param1.DbType = DbType.String;
Param1.Value = DataNids;
DbParams.Add(Param1);
try //Code for capturing optional parameters for filtering
{
if (Params.Length > 3)
{
string[] OptionalParams = Global.SplitString(Params[3], "||");
foreach (string spParamName in OptionalParams)
{
string[] KeyVal = spParamName.Split(':');
switch (KeyVal[0])
{
case "IUS_NId":
{
filterIUS_NId = Convert.ToInt32(KeyVal[1]);
break;
}
case "dvStart":
{
filterDvStart = Convert.ToInt32(KeyVal[1]);
break;
}
case "dvEnd":
{
filterDvEnd = Convert.ToInt32(KeyVal[1]);
break;
}
default:
{
System.Data.Common.DbParameter dbParam = _DBCon.CreateDBParameter();
dbParam.ParameterName = KeyVal[0];
dbParam.DbType = DbType.String;
dbParam.Value = KeyVal[1];
DbParams.Add(dbParam);
break;
}
}
}
}
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
}
string CurrentLanguage = CurrentLanguage = Global.GetDefaultLanguageCodeDB(DbNid.ToString(), UILanguage);
DataTable dtDataviewWithoutDataValueFilter = _DBCon.ExecuteDataTable("sp_get_dataview_datanid_" + CurrentLanguage, CommandType.StoredProcedure, DbParams);
//Handling of creating map visualization after session time out
SessionDetails sdetails = new SessionDetails();
if (HttpContext.Current.Request.Cookies["SessionID"] == null)
{
Global.SaveCookie("SessionID", HttpContext.Current.Session.SessionID, this.Page);
}
sdetails.IsMyData = false;
sdetails.DataViewNonQDS = dtDataviewWithoutDataValueFilter;
Global.SerializeObject(TempPath + HttpContext.Current.Request.Cookies["SessionID"].Value + "_sessionDetails" + ".xml", sdetails);
Session["IsMyData"] = false;
Session["DataViewNonQDS"] = dtDataviewWithoutDataValueFilter;
if (Session["DIMap"] != null)
{
((DevInfo.Lib.DI_LibMap.Map)Session["DIMap"]).Dispose();
Session["DIMap"] = null;
}
Session["CurrentSelectedAreaNids"] = null;
Result = PrepareDataViewString(dtDataviewWithoutDataValueFilter, CurrentLanguage, filterIUS_NId, filterDvStart, filterDvEnd, SelectedDimension, DefaultSubgroups);
return Result;
}
}
catch (Exception ex)
{
Global.CreateExceptionString(ex, null);
return "false";
}
finally
{
if (_DBCon != null)
{
_DBCon.Dispose();
}
}
return Result;
}
