430 lines
12 KiB
C#
430 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Linq.Expressions;
|
|
using System.Text.RegularExpressions;
|
|
using MileageTraker.Web.Models;
|
|
using MileageTraker.Web.Utility;
|
|
using MileageTraker.Web.ViewModels;
|
|
|
|
namespace MileageTraker.Web.DAL
|
|
{
|
|
public class DataService : IDisposable
|
|
{
|
|
private readonly MileageTrakerContext _db = new MileageTrakerContext();
|
|
|
|
#region Log
|
|
|
|
public void AddLog(Log log)
|
|
{
|
|
log.Created = DateTime.Now;
|
|
_db.Logs.Add(log);
|
|
_db.SaveChanges();
|
|
|
|
UpdateCurrentOdometer(log.VehicleId);
|
|
}
|
|
|
|
public IQueryable<Log> GetLogs()
|
|
{
|
|
return _db.Logs;
|
|
}
|
|
|
|
public Log GetLog(int id)
|
|
{
|
|
return _db.Logs.Find(id);
|
|
}
|
|
|
|
public IEnumerable<int> GetValidLogYears()
|
|
{
|
|
return
|
|
from l in GetLogs()
|
|
group l by new {year = l.Date.Year}
|
|
into y
|
|
orderby y.Key descending
|
|
select y.Key.year;
|
|
}
|
|
|
|
public IEnumerable<int> GetValidLogMonths(int year)
|
|
{
|
|
var start = new DateTime(year, 1, 1);
|
|
var end = new DateTime(year + 1, 1, 1);
|
|
return
|
|
from l in GetLogs()
|
|
where l.Date >= start && l.Date < end
|
|
group l by new { month = l.Date.Month }
|
|
into m
|
|
orderby m.Key descending
|
|
select m.Key.month;
|
|
}
|
|
|
|
public IEnumerable<LogIndexViewModel> GetLogIndexViewModels(IQueryable<Log> logs)
|
|
{
|
|
var t =
|
|
from log in logs
|
|
let previousLog = (from ol in _db.Logs
|
|
where ol.VehicleId == log.VehicleId &&
|
|
((ol.Date <= log.Date && ol.EndOdometer < log.EndOdometer) ||
|
|
(ol.EndOdometer == log.EndOdometer && ol.Created < log.Created))
|
|
orderby ol.EndOdometer descending, ol.Created descending
|
|
select ol).FirstOrDefault()
|
|
select new {log, previousLog};
|
|
return from l in t.ToList()
|
|
select new LogIndexViewModel(l.log, l.previousLog);
|
|
}
|
|
|
|
public IEnumerable<VehicleMileageItem> GetMonthlyVehicleMileageItems(LogQueryViewModel query)
|
|
{
|
|
var items =
|
|
from l in
|
|
from log in FilterLogs(_db.Logs, query)
|
|
let previousLog = (from ol in _db.Logs
|
|
where ol.VehicleId == log.VehicleId &&
|
|
((ol.Date <= log.Date && ol.EndOdometer < log.EndOdometer) ||
|
|
(ol.EndOdometer == log.EndOdometer && ol.Created < log.Created))
|
|
orderby ol.EndOdometer descending, ol.Created descending
|
|
select ol).FirstOrDefault()
|
|
select new {log, previousLog, miles = (previousLog != null ? log.EndOdometer - previousLog.EndOdometer : 0)}
|
|
group l by l.log.VehicleId
|
|
into g
|
|
join v in _db.Vehicles on g.Key equals v.VehicleId
|
|
let miles = g.Sum(l => l.miles)
|
|
let gasPurchased = g.Sum(l => l.log.GasPurchased)
|
|
where miles > 0 || gasPurchased > 0
|
|
let logPairs =
|
|
from i in g
|
|
orderby i.log.Date descending , i.log.EndOdometer descending
|
|
select new { PreviousLog = i.previousLog, Log = i.log }
|
|
select
|
|
new
|
|
{
|
|
VehicleId = g.Key,
|
|
GasPurchased = gasPurchased,
|
|
Miles = miles,
|
|
v.Prog,
|
|
LogPairs = logPairs
|
|
};
|
|
|
|
return items.ToList().Select(i => new VehicleMileageItem
|
|
{
|
|
VehicleId = i.VehicleId,
|
|
GasPurchased = i.GasPurchased,
|
|
Miles = i.Miles,
|
|
Prog = i.Prog,
|
|
LogPairs = i.LogPairs.ToList()
|
|
.Select(lp => new Tuple<Log,Log>(lp.PreviousLog, lp.Log))
|
|
});
|
|
}
|
|
|
|
|
|
public IEnumerable<EmployeeMileageItem> GetMonthlyEmployeeMileageItems(LogQueryViewModel query)
|
|
{
|
|
var items =
|
|
from l in
|
|
from log in FilterLogs(_db.Logs, query)
|
|
let previousLog = (from ol in _db.Logs
|
|
where ol.VehicleId == log.VehicleId &&
|
|
((ol.Date <= log.Date && ol.EndOdometer < log.EndOdometer) ||
|
|
(ol.EndOdometer == log.EndOdometer && ol.Created < log.Created))
|
|
orderby ol.EndOdometer descending, ol.Created descending
|
|
select ol).FirstOrDefault()
|
|
select new { log, previousLog, miles = (previousLog != null ? log.EndOdometer - previousLog.EndOdometer : 0) }
|
|
group l by l.log.EmployeeName
|
|
into g
|
|
let miles = g.Sum(l => l.miles)
|
|
let gasPurchased = g.Sum(l => l.log.GasPurchased)
|
|
where miles > 0 || gasPurchased > 0
|
|
let logPairs =
|
|
from i in g
|
|
orderby i.log.Date descending, i.log.EndOdometer descending
|
|
select new { PreviousLog = i.previousLog, Log = i.log }
|
|
select
|
|
new
|
|
{
|
|
EmployeeName = g.Key,
|
|
GasPurchased = gasPurchased,
|
|
Miles = miles,
|
|
LogPairs = logPairs
|
|
};
|
|
|
|
return items.ToList().Select(i => new EmployeeMileageItem
|
|
{
|
|
EmployeeName = i.EmployeeName,
|
|
GasPurchased = i.GasPurchased,
|
|
Miles = i.Miles,
|
|
LogPairs = i.LogPairs.ToList()
|
|
.Select(lp => new Tuple<Log, Log>(lp.PreviousLog, lp.Log))
|
|
});
|
|
}
|
|
|
|
public static IQueryable<Log> FilterLogs(IQueryable<Log> logs, LogQueryViewModel query)
|
|
{
|
|
if (query.Year.HasValue & query.Month.HasValue)
|
|
{
|
|
var start = new DateTime(query.Year.Value, query.Month.Value, 1);
|
|
var end = start.AddMonths(1);
|
|
logs = logs.Where(l => l.Date >= start && l.Date < end);
|
|
}
|
|
|
|
if (query.LogType.HasValue)
|
|
{
|
|
// WTF The specified value is not an instance of type 'Edm.Int32'
|
|
Expression<Func<Log, bool>> predicate;
|
|
switch (query.LogType.Value)
|
|
{
|
|
case MileageLogType.NonCommuting:
|
|
predicate = l => l.LogType.Value == 1;
|
|
break;
|
|
case MileageLogType.Commuting:
|
|
predicate = l => l.LogType.Value == 2;
|
|
break;
|
|
case MileageLogType.GasPurchase:
|
|
predicate = l => l.LogType.Value == 3;
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
logs = logs.Where(predicate);
|
|
}
|
|
|
|
return logs;
|
|
}
|
|
|
|
public Log GetPreviousLog(Log current)
|
|
{
|
|
var vehicleId = current.VehicleId;
|
|
var date = current.Date;
|
|
var endOdometer = current.EndOdometer;
|
|
return GetPreviousLog(endOdometer, vehicleId, date, current.Created);
|
|
}
|
|
|
|
public Log GetPreviousLog(int endOdometer, string vehicleId, DateTime date, DateTime created)
|
|
{
|
|
return GetPreviousLogQuery(endOdometer, vehicleId, date, created).FirstOrDefault();
|
|
}
|
|
|
|
private IOrderedQueryable<Log> GetPreviousLogQuery(int endOdometer, string vehicleId, DateTime date, DateTime created)
|
|
{
|
|
return from pl in _db.Logs
|
|
where pl.VehicleId == vehicleId &&
|
|
((pl.Date <= date && pl.EndOdometer < endOdometer)
|
|
|| (pl.EndOdometer == endOdometer && pl.Created < created))
|
|
orderby pl.EndOdometer descending, pl.Created descending
|
|
select pl;
|
|
}
|
|
|
|
public Log GetNextLog(Log current)
|
|
{
|
|
var vehicleId = current.VehicleId;
|
|
var date = current.Date;
|
|
var endOdometer = current.EndOdometer;
|
|
return GetNextLog(endOdometer, vehicleId, date, current.Created);
|
|
}
|
|
|
|
public Log GetNextLog(int endOdometer, string vehicleId, DateTime date, DateTime created)
|
|
{
|
|
return (from nl in GetLogs()
|
|
where nl.VehicleId == vehicleId &&
|
|
((nl.Date >= date && nl.EndOdometer > endOdometer)
|
|
|| (nl.EndOdometer == endOdometer && nl.Created > created))
|
|
orderby nl.EndOdometer ascending, nl.Created ascending
|
|
select nl).FirstOrDefault();
|
|
}
|
|
|
|
public void UpdateLog(Log log)
|
|
{
|
|
var currentLog = GetLog(log.LogId);
|
|
|
|
// ignore these properties while updating
|
|
log.Created = currentLog.Created;
|
|
log.Source = currentLog.Source;
|
|
log.UserAgent = currentLog.UserAgent;
|
|
log.UserHostAddress = currentLog.UserHostAddress;
|
|
|
|
_db.Entry(currentLog).CurrentValues.SetValues(log);
|
|
|
|
_db.Entry(currentLog).State = EntityState.Modified;
|
|
_db.SaveChanges();
|
|
|
|
UpdateCurrentOdometer(log.VehicleId);
|
|
}
|
|
|
|
public void DeleteLog(int id)
|
|
{
|
|
var log = _db.Logs.Find(id);
|
|
_db.Logs.Remove(log);
|
|
_db.SaveChanges();
|
|
|
|
UpdateCurrentOdometer(log.VehicleId);
|
|
}
|
|
|
|
public IEnumerable<Log> GetRecentLogsByEmployee(string employeeName)
|
|
{
|
|
return
|
|
(from l in _db.Logs
|
|
where l.EmployeeName == employeeName
|
|
orderby l.Created descending
|
|
select l)
|
|
.Take(3)
|
|
.ToList();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Vehicle
|
|
|
|
public void AddVehicle(Vehicle vehicle)
|
|
{
|
|
if (vehicle.Assigned == "Unassigned")
|
|
vehicle.Assigned = null;
|
|
_db.Vehicles.Add(vehicle);
|
|
_db.SaveChanges();
|
|
}
|
|
|
|
public IEnumerable<Vehicle> GetVehicles()
|
|
{
|
|
var vehicles = _db.Vehicles;
|
|
return vehicles;
|
|
}
|
|
|
|
public Vehicle GetVehicle(string id)
|
|
{
|
|
return _db.Vehicles.Find(id);
|
|
}
|
|
|
|
public void UpdateVehicle(Vehicle vehicle)
|
|
{
|
|
if (vehicle.Assigned == "Unassigned")
|
|
vehicle.Assigned = null;
|
|
_db.Entry(vehicle).State = EntityState.Modified;
|
|
_db.SaveChanges();
|
|
}
|
|
|
|
public void UpdateCurrentOdometer(string vehicleId)
|
|
{
|
|
var mostRecentOdometerQuery =
|
|
from log in _db.Logs
|
|
where
|
|
log.VehicleId == vehicleId
|
|
orderby log.Date descending, log.EndOdometer descending
|
|
select log;
|
|
var mostRecentOdometer = mostRecentOdometerQuery.FirstOrDefault();
|
|
var vehicle = _db.Vehicles.Find(vehicleId);
|
|
if (mostRecentOdometer != null && mostRecentOdometer.EndOdometer != vehicle.CurrentOdometer)
|
|
{
|
|
vehicle.CurrentOdometer = mostRecentOdometer.EndOdometer;
|
|
UpdateVehicle(vehicle);
|
|
}
|
|
}
|
|
|
|
public void ValidateOdometerChronology(string vehicleId, int odometer, DateTime date)
|
|
{
|
|
var conflictingLog = GetFirstConflictingOdometerChronologyLog(vehicleId, date, odometer);
|
|
if (conflictingLog != null)
|
|
{
|
|
throw new ChronologicalOrderException(
|
|
String.Format(
|
|
"Odometer of {0} miles on {1:d} conflicts with other logs for vehicle {2}" +
|
|
", including an odometer log of {3} miles on {4:d} reported by {5}.",
|
|
odometer, date, vehicleId, conflictingLog.EndOdometer, conflictingLog.Date, conflictingLog.EmployeeName));
|
|
}
|
|
}
|
|
|
|
public Log GetFirstConflictingOdometerChronologyLog(string vehicleId, DateTime date, int odometer)
|
|
{
|
|
// TODO HACK for testing, delete later
|
|
try
|
|
{
|
|
if (_db.Logs.Count() == 0)
|
|
return null;
|
|
}
|
|
catch (NullReferenceException)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var conflictingLogsQuery =
|
|
from log in _db.Logs
|
|
let existingDate = log.Date
|
|
let existingOdometer = log.EndOdometer
|
|
where
|
|
log.VehicleId == vehicleId &&
|
|
!(existingDate == date
|
|
|| existingOdometer == odometer
|
|
|| existingDate < date && existingOdometer < odometer
|
|
|| existingDate > date && existingOdometer > odometer)
|
|
orderby existingOdometer descending
|
|
select log;
|
|
|
|
return conflictingLogsQuery.FirstOrDefault();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Employee Name
|
|
|
|
public string GetEmployeeNameCorrected(string term)
|
|
{
|
|
var names = GetEmployeeNames().ToList();
|
|
return (from potentialName in names
|
|
let potentialNameClean = Regex.Replace(potentialName, @"\s*\(.*\)", "").ToLower()
|
|
let name = term.ToLower()
|
|
let similarity = Algorithms.Similarity(potentialNameClean, name)
|
|
where similarity > .7 || potentialNameClean.StartsWith(name)
|
|
orderby similarity descending
|
|
select potentialName).FirstOrDefault();
|
|
}
|
|
|
|
public IEnumerable<string> GetEmployeeNamesAutocomplete(string term)
|
|
{
|
|
var termLower = term.ToLower();
|
|
return from name in GetEmployeeNames()
|
|
let nameLower = name.ToLower()
|
|
where nameLower.StartsWith(termLower) || Algorithms.Similarity(nameLower, termLower) > .8
|
|
select name;
|
|
}
|
|
|
|
public IEnumerable<string> GetEmployeeNames()
|
|
{
|
|
var names = _db.Vehicles.Select(v => v.Assigned).Where(n => !String.IsNullOrEmpty(n) && n != "to be sold");
|
|
var logNames =
|
|
(from l in _db.Logs
|
|
select l.EmployeeName);
|
|
return names.Union(logNames).Distinct();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region City
|
|
|
|
public string GetCitiesCorrected(string term)
|
|
{
|
|
var termLower = term.ToLower();
|
|
return (from city in GetCities().ToList()
|
|
let cityToLower = city.Name.ToLower()
|
|
let similarity = Algorithms.Similarity(cityToLower, termLower)
|
|
where city.Name.StartsWith(term) || Algorithms.Similarity(cityToLower, termLower) > .8
|
|
select city.Name).FirstOrDefault();
|
|
}
|
|
|
|
public IEnumerable<string> GetCitiesAutocomplete(string term)
|
|
{
|
|
return
|
|
from city in GetCities()
|
|
where city.Name.StartsWith(term)
|
|
select city.Name;
|
|
}
|
|
|
|
private IQueryable<City> GetCities()
|
|
{
|
|
return _db.Cities;
|
|
}
|
|
|
|
#endregion
|
|
|
|
public void Dispose()
|
|
{
|
|
_db.Dispose();
|
|
}
|
|
}
|
|
} |