public Employee(DataBaseEntry x)
{
if (x.EventType.Equals("SessionLock") || x.EventType.Equals("SessionLogoff") || x.EventType.Equals("AssumedAway") || x.RemoteAccess == true || x.EventType.Equals("ConsoleDisconnect"))//Change When We know session names
{
atDesk = false;
}
else
{
atDesk = true;
}
name = x.UserName;
userID = x.UserID;
eta = x.ETA;
time = x.TimeOfEvent;
}
public async void AddAppletEntry(DataBaseEntry entry)
{
//Prevent double-adding lock event
recentEntry = entry.AutomaticLock ? false:true;
Trace.WriteLine("ADD APPLET ENTRY ENTERED TRACE");
using (IAsyncDocumentSession s = ds.OpenAsyncSession())
{
//Load DeviceIDs from db
IList <string> deviceIDs = await s.Query <Device>("Device_Search").Select(x => x.DeviceID).ToListAsync();
//Check that device and user exist
if (deviceIDs.Contains(entry.DeviceID))
{
//Add to db and save
await s.StoreAsync(entry);
await s.SaveChangesAsync();
}
}
}
public string DBTest()
{
Device d = new Device();
d.DeviceID = "TestDeviceID";
d.DeviceName = "InternBox4";
d.UserID = "TestUserID";
d.VM = false;
string str = "Error";
using (IDocumentStore store = new Raven.Client.Documents.DocumentStore
{
Urls = new[]
{
"http://192.168.10.153:8080"
},
Database = "TestDB",
Conventions = { }
})
{
try
{
store.Initialize();
using (IDocumentSession session = store.OpenSession())
{
session.Store(d);
session.SaveChanges();
DataBaseEntry loadedEnt = session.Load <DataBaseEntry>("DataBaseEntries/2-A");
str = loadedEnt.DeviceID;
}
return(str);
}
catch (Exception e)
{
return(e.Message);
}
}
}
public string EntryOutput(DataBaseEntry str)
{
return(str.EventType + ", " + str.UserID + ", " + str.DeviceID + ", " + str.AutomaticLock + ", " + str.ETA.ToString() + ", " + str.TimeOfEvent.ToString());
}
public async void AddServiceEntry(DataBaseEntry entry)
{
Trace.WriteLine("ADD SERVICE ENTRY START RECENTENTRY: " + recentEntry);
if (!recentEntry) //Prevets double recording of lock events
{
Trace.WriteLine("ADD SERVICE ENTRY ENTERED");
Trace.WriteLine("EVENT TYPE: " + entry.EventType + " User: "******" Machine: " + entry.MachineName);
if (entry.EventType == "SessionLock" || entry.EventType == "SessionUnlock")
{
var inactiveClients = new List <string>();
foreach (var client in clients)
{
Trace.Write(client.Key);
if (client.Key.Substring(client.Key.Length - 7) != "-Service") //stops services being called
{
try //Tries to connect to client, if it fails it adds to inactiveClients to be removed
{
//The applet then calls the AddAppletEntry method to complete the record
Trace.WriteLine("ATTEMPTING FINISHDATABASEENTRY");
client.Value.FinishDataBaseEntry(entry);
}
catch
{
Trace.WriteLine("CLIENT CAUGHT");
inactiveClients.Add(client.Key);
}
}
}
//removes inactive clients from client list
if (inactiveClients.Count > 0)
{
foreach (var client in inactiveClients)
{
clients.Remove(client);
}
}
}
//Record log-off events immediately
else
{
Trace.WriteLine("ATTEMPTING IMMEDIATE ADD");
using (IAsyncDocumentSession s = ds.OpenAsyncSession())
{
try
{
Trace.WriteLine("NEW ENTRY DEVICE ID: " + entry.DeviceID);
//Find last entry for device
DataBaseEntry dBE = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.DeviceID == entry.DeviceID).OrderByDescending(y => y.TimeOfEvent).FirstAsync();
entry.UserID = dBE.UserID;
entry.UserName = dBE.UserName;
Trace.WriteLine("Last entry UserID: " + dBE.UserID + "\nLast entry UserName: " + dBE.UserName);
}
catch
{
//Must be the device's first entry or something
}
}
AddAppletEntry(entry);
}
}
recentEntry = false;
}
//Returns list of all employees constructed from the last DataBaseEntry associated with their UserID
public async Task <List <Employee> > GetEntriesForAlice()
{
List <Employee> ret = new List <Employee>();
try
{
// Connect To db
using (IAsyncDocumentSession s = ds.OpenAsyncSession())
{
s.Advanced.MaxNumberOfRequestsPerSession = 200;
//List of devices
List <Device> devices = await s.Query <Device>("Device_Search").ToListAsync();
//List of userIDs
List <string> userIDs = devices.Select(x => x.UserID).Distinct().ToList();
//Iterate through list of users, select latest DataBaseEntry, create employee object, and add UserName to Employee
foreach (var u in userIDs)
{
//Try create an employee object. If no DataBase Entry is found for the user, skip
try
{
//Fetch latest 20 DataBaseEntries from user
List <DataBaseEntry> entries = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.UserID == u).OrderByDescending(x => x.TimeOfEvent).Take(20).ToListAsync();
//Find latest non-VPN login on non-VM machine
bool validEntry = false;
int index = 0;
for (int i = 0; i < entries.Count; i++)
{
if (!entries[i].RemoteAccess && !devices.Find(x => x.DeviceID == entries[i].DeviceID).VM)
{
index = i;
validEntry = true;
break;
}
}
DataBaseEntry entry = validEntry? entries[index]:null;
//Create Employee from Entry
Employee emp = new Employee(entry);
try
{
emp.ProfilePic = await s.Query <User>("User_Search").Where(x => x.UserID == emp.UserID).Select(y => y.ProfilePic).FirstOrDefaultAsync();
}
catch (Exception e)
{
emp.ProfilePic = e.Message;
//No profile pic for you
}
//Add to list
ret.Add(emp);
}
catch
{
//If the user hasn't signed in physically (ie non-VPN) on a non-WM machine in their last 20 entries, find there last logged action
DataBaseEntry dBE = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.UserID == u).OrderByDescending(y => y.TimeOfEvent).FirstOrDefaultAsync();
if (dBE != null)
{
dBE.EventType = "AssumedAway";
Employee awayEmployee = new Employee(dBE);
ret.Add(awayEmployee);
}
}
}
}
}
catch (Exception e)
{
//Error Message as DataBaseEntry
Employee error = new Employee(new DataBaseEntry(e.Message, "Error", e.Message, "NoDeviceID", "NoMachineName", "NoSessionID", DateTime.Now, false, false, TimeSpan.Zero));
error.Name = e.Message;
ret.Add(error);
}
return(ret.OrderBy(x => x.Name).ToList());
}
public async Task <Tuple <List <DataBaseEntry>, int> > GetEntriesBetweenForUser(string UserName, DateTime start, DateTime end, int indexStart, string sortField, string sortDirection)
{
List <DataBaseEntry> ret = new List <DataBaseEntry>();
int numResults = 0;
QueryStatistics stats = new QueryStatistics();
string[] userTerms = UserName.Split(' ');
try
{
//Connect to database
using (IAsyncDocumentSession s = ds.OpenAsyncSession())
{
switch (sortDirection)
{
case "Ascending":
switch (sortField)
{
case "UserName":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderBy(x => x.UserName).Skip(indexStart).Take(20).ToListAsync();
Trace.WriteLine("UserName:"******" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end);
//ret = await s.Advanced.AsyncDocumentQuery<DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start +" AND TimeOfEvent < " + end).OrderBy(x => x.UserName).Skip(indexStart).Take(20).ToListAsync();
break;
case "EventType":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderBy(x => x.EventType).Skip(indexStart).Take(20).ToListAsync();
break;
case "UserID":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderBy(x => x.UserID).Skip(indexStart).Take(20).ToListAsync();
break;
case "MachineName":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderBy(x => x.MachineName).Skip(indexStart).Take(20).ToListAsync();
break;
case "DeviceID":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderBy(x => x.DeviceID).Skip(indexStart).Take(20).ToListAsync();
break;
case "TimeOfEvent":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderBy(x => x.TimeOfEvent).Skip(indexStart).Take(20).ToListAsync();
break;
case "AutomaticLock":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderBy(x => x.AutomaticLock).Skip(indexStart).Take(20).ToListAsync();
break;
case "ETA":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderBy(x => x.ETA).Skip(indexStart).Take(20).ToListAsync();
break;
case "RemoteAccess":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderBy(x => x.RemoteAccess).Skip(indexStart).Take(20).ToListAsync();
break;
}
break;
case "Descending":
switch (sortField)
{
case "UserName":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderByDescending(x => x.UserName).Skip(indexStart).Take(20).ToListAsync();
break;
case "EventType":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderByDescending(x => x.EventType).Skip(indexStart).Take(20).ToListAsync();
break;
case "UserID":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderByDescending(x => x.UserID).Skip(indexStart).Take(20).ToListAsync();
break;
case "MachineName":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderByDescending(x => x.MachineName).Skip(indexStart).Take(20).ToListAsync();
break;
case "DeviceID":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderByDescending(x => x.DeviceID).Skip(indexStart).Take(20).ToListAsync();
break;
case "TimeOfEvent":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderByDescending(x => x.TimeOfEvent).Skip(indexStart).Take(20).ToListAsync();
break;
case "AutomaticLock":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderByDescending(x => x.AutomaticLock).Skip(indexStart).Take(20).ToListAsync();
break;
case "ETA":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderByDescending(x => x.ETA).Skip(indexStart).Take(20).ToListAsync();
break;
case "RemoteAccess":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).OrderByDescending(x => x.RemoteAccess).Skip(indexStart).Take(20).ToListAsync();
break;
}
break;
}
await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().Statistics(out stats).WhereLucene("UserName", string.Join(" AND ", userTerms) + " AND TimeOfEvent > " + start + " AND TimeOfEvent < " + end).ToListAsync();
numResults = stats.TotalResults;
}
}
catch (Exception e)
{
//Error Message as DataBaseEntry
DataBaseEntry error = new DataBaseEntry("Error", "Error", e.Message, "NoDeviceID", "NoMachineName", "NoSessionID", DateTime.Now, false, false, TimeSpan.Zero);
ret.Add(error);
}
//Return all entries between a specific time period for a specific user
return(new Tuple <List <DataBaseEntry>, int>(ret, numResults));
}
public async Task <Tuple <List <DataBaseEntry>, int> > GetAllEntries(int indexStart, string sortField, string sortDirection)
{
//try
//{
// Trace.WriteLine("USER: "******"Error " + e.Message);
//}
int numResults = 0;
QueryStatistics stats = new QueryStatistics();
List <DataBaseEntry> ret = new List <DataBaseEntry>();
try
{
//Connect to database
using (IAsyncDocumentSession s = ds.OpenAsyncSession())
{
//Get all entries
switch (sortDirection)
{
case "Ascending":
switch (sortField)
{
case "UserName":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderBy(x => x.UserName).Skip(indexStart).Take(20).ToListAsync();
break;
case "EventType":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderBy(x => x.EventType).Skip(indexStart).Take(20).ToListAsync();
break;
case "UserID":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderBy(x => x.UserID).Skip(indexStart).Take(20).ToListAsync();
break;
case "MachineName":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderBy(x => x.MachineName).Skip(indexStart).Take(20).ToListAsync();
break;
case "DeviceID":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderBy(x => x.DeviceID).Skip(indexStart).Take(20).ToListAsync();
break;
case "TimeOfEvent":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderBy(x => x.TimeOfEvent).Skip(indexStart).Take(20).ToListAsync();
break;
case "AutomaticLock":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderBy(x => x.AutomaticLock).Skip(indexStart).Take(20).ToListAsync();
break;
case "ETA":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderBy(x => x.ETA).Skip(indexStart).Take(20).ToListAsync();
break;
case "RemoteAccess":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderBy(x => x.RemoteAccess).Skip(indexStart).Take(20).ToListAsync();
break;
}
break;
case "Descending":
switch (sortField)
{
case "UserName":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderByDescending(x => x.UserName).Skip(indexStart).Take(20).ToListAsync();
break;
case "EventType":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderByDescending(x => x.EventType).Skip(indexStart).Take(20).ToListAsync();
break;
case "UserID":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderByDescending(x => x.UserID).Skip(indexStart).Take(20).ToListAsync();
break;
case "MachineName":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderByDescending(x => x.MachineName).Skip(indexStart).Take(20).ToListAsync();
break;
case "DeviceID":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderByDescending(x => x.DeviceID).Skip(indexStart).Take(20).ToListAsync();
break;
case "TimeOfEvent":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderByDescending(x => x.TimeOfEvent).Skip(indexStart).Take(20).ToListAsync();
break;
case "AutomaticLock":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderByDescending(x => x.AutomaticLock).Skip(indexStart).Take(20).ToListAsync();
break;
case "ETA":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderByDescending(x => x.ETA).Skip(indexStart).Take(20).ToListAsync();
break;
case "RemoteAccess":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").OrderByDescending(x => x.RemoteAccess).Skip(indexStart).Take(20).ToListAsync();
break;
}
break;
}
await s.Query <DataBaseEntry>("DataBaseEntry_Search").Statistics(out stats).ToListAsync();
numResults = stats.TotalResults;
}
}
catch (Exception e)
{
//Error Message as DataBaseEntry
DataBaseEntry error = new DataBaseEntry("Error", "Error", e.Message, "NoDeviceID", "NoMachineName", "NoSessionID", DateTime.Now, false, false, TimeSpan.Zero);
ret.Add(error);
}
return(new Tuple <List <DataBaseEntry>, int>(ret, numResults));
}
public async Task <Tuple <List <DataBaseEntry>, int> > GetEntriesBetween(DateTime start, DateTime end, int indexStart, string sortField, string sortDirection)
{
int numResults = 0;
QueryStatistics stats = new QueryStatistics();
List <DataBaseEntry> ret = new List <DataBaseEntry>();
try
{
//Connect to database
using (IAsyncDocumentSession s = ds.OpenAsyncSession())
{
switch (sortDirection)
{
case "Ascending":
switch (sortField)
{
case "UserName":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderBy(x => x.UserName).Skip(indexStart).Take(20).ToListAsync();
break;
case "EventType":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderBy(x => x.EventType).Skip(indexStart).Take(20).ToListAsync();
break;
case "UserID":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderBy(x => x.UserID).Skip(indexStart).Take(20).ToListAsync();
break;
case "MachineName":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderBy(x => x.MachineName).Skip(indexStart).Take(20).ToListAsync();
break;
case "DeviceID":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderBy(x => x.DeviceID).Skip(indexStart).Take(20).ToListAsync();
break;
case "TimeOfEvent":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderBy(x => x.TimeOfEvent).Skip(indexStart).Take(20).ToListAsync();
break;
case "AutomaticLock":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderBy(x => x.AutomaticLock).Skip(indexStart).Take(20).ToListAsync();
break;
case "ETA":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderBy(x => x.ETA).Skip(indexStart).Take(20).ToListAsync();
break;
case "RemoteAccess":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderBy(x => x.RemoteAccess).Skip(indexStart).Take(20).ToListAsync();
break;
}
break;
case "Descending":
switch (sortField)
{
case "UserName":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderByDescending(x => x.UserName).Skip(indexStart).Take(20).ToListAsync();
break;
case "EventType":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderByDescending(x => x.EventType).Skip(indexStart).Take(20).ToListAsync();
break;
case "UserID":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderByDescending(x => x.UserID).Skip(indexStart).Take(20).ToListAsync();
break;
case "MachineName":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderByDescending(x => x.MachineName).Skip(indexStart).Take(20).ToListAsync();
break;
case "DeviceID":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderByDescending(x => x.DeviceID).Skip(indexStart).Take(20).ToListAsync();
break;
case "TimeOfEvent":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderByDescending(x => x.TimeOfEvent).Skip(indexStart).Take(20).ToListAsync();
break;
case "AutomaticLock":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderByDescending(x => x.AutomaticLock).Skip(indexStart).Take(20).ToListAsync();
break;
case "ETA":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderByDescending(x => x.ETA).Skip(indexStart).Take(20).ToListAsync();
break;
case "RemoteAccess":
ret = await s.Query <DataBaseEntry>("DataBaseEntry_Search").Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).OrderByDescending(x => x.RemoteAccess).Skip(indexStart).Take(20).ToListAsync();
break;
}
break;
}
await s.Query <DataBaseEntry>("DataBaseEntry_Search").Statistics(out stats).Where(x => x.TimeOfEvent >= start && x.TimeOfEvent <= end).ToListAsync();
numResults = stats.TotalResults;
}
}
catch (Exception e)
{
//Error Message as DataBaseEntry
DataBaseEntry error = new DataBaseEntry("Error", "Error", e.Message, "NoDeviceID", "NoMachineName", "NoSessionID", DateTime.Now, false, false, TimeSpan.Zero);
ret.Add(error);
}
//Return all entries between a specific time period
return(new Tuple <List <DataBaseEntry>, int>(ret, numResults));
}
public async Task <Tuple <List <DataBaseEntry>, int> > GetEntriesOfUser(string UserName, int indexStart, string sortField, string sortDirection)
{
int numResults = 0;
QueryStatistics stats = new QueryStatistics();
List <DataBaseEntry> ret = new List <DataBaseEntry>();
string[] userTerms = UserName.Split(' ');
try
{
//Connect to database
using (IAsyncDocumentSession s = ds.OpenAsyncSession())
{
var sortProperty = typeof(DataBaseEntry).GetProperty(sortField, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
//Return entries of a specific user
switch (sortDirection)
{
case "Ascending":
switch (sortField)
{
case "UserName":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderBy(x => x.UserName).Skip(indexStart).Take(20).ToListAsync();
//ret = await s.Query<DataBaseEntry>("DataBaseEntry_Search").Search(x => x.UserName, "*" + UserName + "*").OrderBy(x => x.UserName).Skip(indexStart).Take(20).ToListAsync();
break;
case "EventType":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderBy(x => x.EventType).Skip(indexStart).Take(20).ToListAsync();
break;
case "UserID":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderBy(x => x.UserID).Skip(indexStart).Take(20).ToListAsync();
break;
case "MachineName":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderBy(x => x.MachineName).Skip(indexStart).Take(20).ToListAsync();
break;
case "DeviceID":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderBy(x => x.DeviceID).Skip(indexStart).Take(20).ToListAsync();
break;
case "TimeOfEvent":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderBy(x => x.TimeOfEvent).Skip(indexStart).Take(20).ToListAsync();
break;
case "AutomaticLock":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderBy(x => x.AutomaticLock).Skip(indexStart).Take(20).ToListAsync();
break;
case "ETA":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderBy(x => x.ETA).Skip(indexStart).Take(20).ToListAsync();
break;
case "RemoteAccess":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderBy(x => x.RemoteAccess).Skip(indexStart).Take(20).ToListAsync();
break;
}
break;
case "Descending":
switch (sortField)
{
case "UserName":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderByDescending(x => x.UserName).Skip(indexStart).Take(20).ToListAsync();
break;
case "EventType":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderByDescending(x => x.EventType).Skip(indexStart).Take(20).ToListAsync();
break;
case "UserID":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderByDescending(x => x.UserID).Skip(indexStart).Take(20).ToListAsync();
break;
case "MachineName":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderByDescending(x => x.MachineName).Skip(indexStart).Take(20).ToListAsync();
break;
case "DeviceID":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderByDescending(x => x.DeviceID).Skip(indexStart).Take(20).ToListAsync();
break;
case "TimeOfEvent":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderByDescending(x => x.TimeOfEvent).Skip(indexStart).Take(20).ToListAsync();
break;
case "AutomaticLock":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderByDescending(x => x.AutomaticLock).Skip(indexStart).Take(20).ToListAsync();
break;
case "ETA":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderByDescending(x => x.ETA).Skip(indexStart).Take(20).ToListAsync();
break;
case "RemoteAccess":
ret = await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().WhereLucene("UserName", string.Join(" AND ", userTerms)).OrderByDescending(x => x.RemoteAccess).Skip(indexStart).Take(20).ToListAsync();
break;
}
break;
}
await s.Advanced.AsyncDocumentQuery <DataBaseEntry>().Statistics(out stats).WhereLucene("UserName", string.Join(" AND ", userTerms)).ToListAsync();
numResults = stats.TotalResults;
}
}
catch (Exception e)
{
//Error Message as DataBaseEntry
DataBaseEntry error = new DataBaseEntry("Error", "Error", e.Message, "NoDeviceID", "NoMachineName", "NoSessionID", DateTime.Now, false, false, TimeSpan.Zero);
ret.Add(error);
}
return(new Tuple <List <DataBaseEntry>, int>(ret, numResults));
}
