public void Test_ToPagedList()
{
using (var db = new TrackerDataContext {
Log = Console.Out
})
{
var q1 = from u in db.User
orderby u.EmailAddress
select u;
var users = q1.ToPagedList(0, 5);
Assert.IsNotNull(users);
Assert.AreEqual(5, users.Count);
var p2 = users.NextPage();
Assert.IsNotNull(p2);
Assert.AreEqual(2, p2.PageNumber);
var p21 = p2.NextPage();
Assert.IsNotNull(p21);
Assert.AreEqual(3, p21.PageNumber);
var p22 = p21.NextPage();
Assert.IsNull(p22);
var p3 = users.PreviousPage();
Assert.IsNull(p3);
var p4 = users.GotoPage(2);
Assert.IsNotNull(p4);
Assert.AreEqual(3, p4.PageNumber);
}
}
public void Test_Create()
{
var password = _mock.Create <string>();
var authentication = _mock.Build <AuthenticationModel>()
.With(x => x.ConfirmPassword, password)
.With(x => x.NewPassword, password)
.Create();
var model = _mock.Build <ClientModel>()
.With(x => x.Emails, "*****@*****.**")
.With(x => x.Authentication, authentication)
.With(x => x.ContractDate, DateTimeProvider.Now.ToString())
.With(x => x.DefaultSenderId, TestConstants.TestSenderId)
.Create();
var transit = _mock.Build <TransitEditModel>()
.With(x => x.CityId, TestConstants.TestCityId1)
.Create();
_controller.Create(model, transit);
var context = new TrackerDataContext(Settings.Default.MainConnectionString);
var client = context.Clients.First(x => x.User.Login == authentication.Login);
client.User.PasswordHash.Should().NotBe(new byte[0]);
client.User.PasswordSalt.Should().NotBe(new byte[0]);
client.ShouldBeEquivalentTo(
model,
options => options.ExcludingMissingProperties()
.Excluding(x => x.ContractDate)
.Excluding(x => x.InsuranceRate));
client.ContractDate.ToString().ShouldBeEquivalentTo(model.ContractDate);
client.InsuranceRate.ShouldBeEquivalentTo(model.InsuranceRate / 100);
client.Transit.ShouldBeEquivalentTo(transit, options => options.ExcludingMissingProperties());
}
public void Test_Manager_And_Query_Gets()
{
using (var db = new TrackerDataContext {
Log = Console.Out
})
{
Task task = db.Manager.Task.GetByKey(SpockId);
IQueryable <Task> tasks = db.Manager.Task.GetByAssignedIdStatus(SpockId, Status.InProgress);
List <Task> taskList = tasks.ToList();
}
using (var db = new TrackerDataContext {
Log = Console.Out
})
{
try
{
Task task = db.Task.GetByKey(SpockId);
IQueryable <Task> tasks = db.Task
.ByAssignedId(SpockId)
.ByStatus(Status.InProgress);
//tasks = tasks.OrderBy(t => t.CompleteDate);
var list = tasks.ToPagedList <Task>(1, 10);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
public ActionResult EditPost(int id)
{
Task task = null;
try
{
using (var db = new TrackerDataContext())
{
var options = new DataLoadOptions();
options.LoadWith <Task>(t => t.CreatedUser);
db.LoadOptions = options;
task = db.Task.GetByKey(id);
UpdateModel(task);
db.SubmitChanges();
var audit = new Audit(db.LastAudit);
audit.Task = task;
db.Audit.InsertOnSubmit(audit);
db.SubmitChanges();
}
return(RedirectToAction("Edit", new { id = task.Id }));
}
catch (BrokenRuleException e)
{
foreach (BrokenRule rule in e.BrokenRules)
{
ModelState.AddModelError(rule.Context.Rule.TargetProperty, rule.Message);
}
task.Detach();
return(View(GetData(task)));
}
}
public ActionResult Index()
{
ViewData["Message"] = "Welcome to PLINQO!";
if (User.Identity.IsAuthenticated)
{
var dashboard = new Dashboard();
using (var db = new TrackerDataContext())
{
dashboard.CurrentUser = db.User.GetByEmailAddress(User.Identity.Name);
if (dashboard.CurrentUser != null)
{
dashboard.TasksNotStarted = db.Task.ByAssignedId(dashboard.CurrentUser.Id).ByStatus(Status.NotStarted).Future();
dashboard.TasksInProgress = db.Task.ByAssignedId(dashboard.CurrentUser.Id).ByStatus(Status.InProgress).Future();
dashboard.TasksCompleted = db.Task.ByAssignedId(dashboard.CurrentUser.Id).ByStatus(Status.Completed).Future();
dashboard.TasksWaitingOnSomeone = db.Task.ByAssignedId(dashboard.CurrentUser.Id).ByStatus(Status.WaitingOnSomeoneElse).Future();
dashboard.TotalTasks = db.Task.FutureCount();
dashboard.TotalTasksCreatedByMe = db.Task.ByCreatedId(dashboard.CurrentUser.Id).FutureCount();
dashboard.TotalTasksAssignedToMe = db.Task.ByAssignedId(dashboard.CurrentUser.Id).FutureCount();
dashboard.TotalTasksCompleted = db.Task.ByStatus(Status.Completed).FutureCount();
}
db.ExecuteFutureQueries();
}
return(View(dashboard));
}
else
{
return(View());
}
}
public ActionResult AvatarPost(int id)
{
if (Request.Files.Count != 1)
{
using (var db = new TrackerDataContext())
{
var user = db.User.GetByKey(id);
ModelState.AddModelError("file", "Must select a file to upload.");
return(View("Edit", GetData(user)));
}
}
var file = Request.Files[0];
var buffer = new byte[file.ContentLength];
file.InputStream.Read(buffer, 0, buffer.Length);
using (var db = new TrackerDataContext())
{
var user = db.User.GetByKey(id);
user.Avatar = new Binary(buffer);
user.AvatarType = file.ContentType;
db.SubmitChanges();
var audit = new Audit(db.LastAudit);
audit.User = user;
db.Audit.InsertOnSubmit(audit);
db.SubmitChanges();
}
return(RedirectToAction("Edit", new { id = id }));
}
public ActionResult Create([Bind(Exclude = "Id")] Task task)
{
try
{
using (var db = new TrackerDataContext())
{
db.Task.InsertOnSubmit(task);
db.SubmitChanges();
var audit = new Audit(db.LastAudit);
audit.Task = task;
db.Audit.InsertOnSubmit(audit);
db.SubmitChanges();
}
return(RedirectToAction("Edit", new { id = task.Id }));
}
catch (BrokenRuleException e)
{
foreach (BrokenRule rule in e.BrokenRules)
{
ModelState.AddModelError(rule.Context.Rule.TargetProperty, rule.Message);
}
return(View(GetData()));
}
}
public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
var taskViewData = new TaskViewData();
int?id = null;
if (controllerContext.RouteData.Values["Id"].ToString().Length > 0)
{
id = Int32.Parse(controllerContext.RouteData.Values["Id"].ToString());
}
using (var db = new TrackerDataContext())
{
if (id != null)
{
taskViewData.Task = db.Task.GetByKey(id.Value);
taskViewData.Task.Detach();
}
else
{
taskViewData.Task = new Task();
}
}
return(taskViewData);
}
public void SlidingExpirationTest()
{
using (var db = new TrackerDataContext { Log = Console.Out })
{
var query = db.Role.Where(r => r.Name == "Test Role");
var key = query.Take(1).GetHashKey();
var role = query.FromCacheFirstOrDefault(new CacheSettings(TimeSpan.FromSeconds(2)));
var cache = CacheManager.Get<ICollection<Role>>(key);
Assert.IsNotNull(cache);
Assert.AreEqual(role.Id, cache.FirstOrDefault().Id);
System.Threading.Thread.Sleep(1500);
cache = CacheManager.Get<ICollection<Role>>(key);
Assert.IsNotNull(cache);
Assert.AreEqual(role.Id, cache.FirstOrDefault().Id);
System.Threading.Thread.Sleep(1500);
cache = CacheManager.Get<ICollection<Role>>(key);
Assert.IsNotNull(cache);
Assert.AreEqual(role.Id, cache.FirstOrDefault().Id);
System.Threading.Thread.Sleep(2500);
cache = CacheManager.Get<ICollection<Role>>(key);
Assert.IsNull(cache);
}
}
public int SaveTracker(ClsTracker objSave, ClsCarFleet clsCarFleet)
{
try
{
using (TransactionScope scope = new TransactionScope())
{
using (this.objDataContext = new TrackerDataContext(Functions.StrConnection))
{
var result = this.objDataContext.InsertOrUpdateTracker(objSave.inId, objSave.strTripStart,
objSave.strTripEnd, objSave.strLocationStart, objSave.strLocationEnd,
objSave.strReasonRemarks, objSave.inKmStart, objSave.inKmEnd, objSave.inKmDriven,
objSave.inFuelStart, objSave.inFuelEnd, mySession.Current.UserId, objSave.strEntryMethod,
true, objSave.blActive, PageMaster.Tracker.ToString().intSafe(), objSave.inCarId,
objSave.lgReasonId, null, null, objSave.lgCompanyId, clsCarFleet.strReg, clsCarFleet.strCode,
mySession.Current.Firstname, mySession.Current.Lastname)
.FirstOrDefault();
if (result != null)
{
objSave.inId = result.InsertedId;
}
}
scope.Complete();
}
return(objSave.inId);
}
catch (Exception ex)
{
Functions.Write(ex, System.Reflection.MethodBase.GetCurrentMethod().Name, PageMaster.Tracker, mySession.Current.UserId);
return(0);
}
}
public void FromCacheFutre()
{
var db = new TrackerDataContext {
Log = Console.Out
};
CacheSettings cache = new CacheSettings(120);
// build up queries
var q1 = db.Task
.Where(t => t.Summary == "Test")
.FromCache(cache)
.ToList();
// duplicate query except count
var q2 = db.Task
.Where(t => t.Summary == "Test")
.FutureCache(120);
var q3 = db.Task
.Where(t => t.Summary == "Test")
.FutureCacheCount(cache);
var count = q3.Value;
Assert.Greater(count, 0);
var tasks = q2.ToList();
Assert.IsNotNull(tasks);
Assert.AreEqual(q1.Count, tasks.Count);
}
public void TestInitialize()
{
_db = new TrackerDataContext(Settings.Default.MainConnectionString);
_composition = new CompositionHelper(Settings.Default.MainConnectionString, Settings.Default.FilesConnectionString);
_controller = _composition.Kernel.Get <AirWaybillController>();
}
public void SlidingExpirationTest()
{
var db = new TrackerDataContext {
Log = Console.Out
};
var query = db.Role.Where(r => r.Name == "Test Role");
var key = query.GetHashKey();
var roles = query
.FromCache(new CacheSettings(TimeSpan.FromSeconds(2)))
.ToList();
var cache = CacheManager.Get <ICollection <Role> >(key);
Assert.IsNotNull(cache);
Assert.AreEqual(roles.Count, cache.Count);
System.Threading.Thread.Sleep(1500);
cache = CacheManager.Get <ICollection <Role> >(key);
Assert.IsNotNull(cache);
Assert.AreEqual(roles.Count, cache.Count);
System.Threading.Thread.Sleep(1500);
cache = CacheManager.Get <ICollection <Role> >(key);
Assert.IsNotNull(cache);
Assert.AreEqual(roles.Count, cache.Count);
System.Threading.Thread.Sleep(2500);
cache = CacheManager.Get <ICollection <Role> >(key);
Assert.IsNull(cache);
}
public ActionResult Delete(int id)
{
var user = UIHelper.GetCurrentUser();
if (user != null && user.Id != id)
{
using (var db = new TrackerDataContext())
using (var scope = new TransactionScope())
{
db.UserRole.Delete(r => r.UserId == id);
db.Audit.Delete(a => a.UserId == id);
var q1 = from a in db.Audit
join t in db.Task on a.TaskId equals t.Id
join u in db.User on t.CreatedId equals u.Id into created
from x in created.DefaultIfEmpty()
join u in db.User on t.AssignedId equals u.Id into assigned
from y in assigned.DefaultIfEmpty()
where t.AssignedId != null || t.CreatedId != null
select a;
db.Audit.Delete(q1);
db.Task.Delete(a => a.CreatedId == id || a.AssignedId == id);
db.User.Delete(id);
scope.Complete();
}
}
return(RedirectToAction("Index"));
}
public void FutureLoadWith()
{
var db = new TrackerDataContext {
Log = Console.Out
};
DataLoadOptions options = new DataLoadOptions();
options.LoadWith <Task>(t => t.CreatedUser);
db.LoadOptions = options;
var q1 = db.User
.ByEmailAddress("*****@*****.**")
.Future();
var q2 = db.Task
.Where(t => t.LastModifiedBy == "*****@*****.**")
.Future();
var users = q1.ToList();
Assert.IsNotNull(users);
var tasks = q2.ToList();
Assert.IsNotNull(tasks);
}
public void TestFixtureSetUp()
{
// setup memcached
_memcached = Process.Start(
@"..\..\..\..\Libraries\memcached.exe",
"-vv -p 11200");
using (var db = new TrackerDataContext())
{
var role1 = new Role
{
Name = "Test Role"
};
var role2 = new Role
{
Name = "Duck Roll"
};
db.Role.InsertOnSubmit(role1);
db.Role.InsertOnSubmit(role2);
db.SubmitChanges();
_roleIds.Add(role1.Id);
_roleIds.Add(role2.Id);
}
}
public void TestFixtureSetUp()
{
using (var db = new TrackerDataContext {
Log = Console.Out
})
{
db.Guid.InsertOnSubmit(new Core.Data.Guid
{
Id = _guid1Id,
AlternateId = null
});
db.Guid.InsertOnSubmit(new Core.Data.Guid
{
Id = _guid2Id,
AlternateId = _guid2Alt
});
db.Guid.InsertOnSubmit(new Core.Data.Guid
{
Id = _guid3Id,
AlternateId = _guid3Alt
});
db.SubmitChanges();
}
}
private static int GetCurrentUserNameUserId()
{
var user = new User();
string currentUserName = String.Empty;
IPrincipal currentUser = null;
HttpContext current = HttpContext.Current;
if (current != null)
{
currentUser = current.User;
}
if ((currentUser != null) && (currentUser.Identity != null))
{
currentUserName = currentUser.Identity.Name;
}
using (var db = new TrackerDataContext())
{
db.ObjectTrackingEnabled = false;
user = db.User.GetByEmailAddress(currentUserName);
}
return(user.Id);
}
public void TestFixtureTearDown()
{
using (var db = new TrackerDataContext {
Log = Console.Out
})
db.Role.Delete(r => _roleIds.Contains(r.Id));
}
public void Self()
{
int parentId;
using (var db = new TrackerDataContext())
{
var parent = new Self {
Name = "Parent"
};
db.Self.InsertOnSubmit(parent);
db.SubmitChanges();
parentId = parent.Id;
var child = new Self {
Name = "Child", MySelf = parent
};
db.Self.InsertOnSubmit(child);
db.SubmitChanges();
}
using (var db = new TrackerDataContext())
{
var child = db.Self
.ByName("Child")
.FirstOrDefault();
Assert.AreEqual(parentId, child.MySelf.Id);
db.Self.DeleteOnSubmit(child);
db.Self.DeleteOnSubmit(child.MySelf);
db.SubmitChanges();
}
}
public void FutureCountTest()
{
var db = new TrackerDataContext {
Log = Console.Out
};
// build up queries
var q1 = db.User
.ByEmailAddress("*****@*****.**")
.Future();
var q2 = db.Task
.Where(t => t.Summary == "Test")
.FutureCount();
// should be 2 queries
//Assert.AreEqual(2, db.FutureQueries.Count);
// this triggers the loading of all the future queries
var users = q1.ToList();
Assert.IsNotNull(users);
// should be cleared at this point
//Assert.AreEqual(0, db.FutureQueries.Count);
// this should already be loaded
Assert.IsTrue(((IFutureQuery)q2).IsLoaded);
int count = q2.Value;
Assert.Greater(count, 0);
}
public void TestFixtureSetUp()
{
using (var db = new TrackerDataContext())
{
var oldUser = db.User
.ByEmailAddress("*****@*****.**")
.FirstOrDefault();
if (oldUser != null)
{
db.User.DeleteOnSubmit(oldUser);
}
var oldRole = db.Role
.ByName("Tester")
.FirstOrDefault();
if (oldRole != null)
{
db.Role.DeleteOnSubmit(oldRole);
}
if (oldUser != null || oldRole != null)
{
db.SubmitChanges();
}
}
}
public void ManyToMany()
{
using (var db = new TrackerDataContext())
{
var user = db.User.GetByKey(UserId);
Assert.AreEqual(1, user.RoleList.Count);
var role = db.Role.GetByKey(RoleId);
user.RoleList.Remove(role);
db.SubmitChanges();
Assert.AreEqual(0, user.RoleList.Count);
}
using (var db = new TrackerDataContext())
{
var user = db.User.GetByKey(UserId);
Assert.AreEqual(0, user.RoleList.Count);
var role = db.Role.GetByKey(RoleId);
user.RoleList.Add(role);
db.SubmitChanges();
Assert.AreEqual(1, user.RoleList.Count);
}
using (var db = new TrackerDataContext())
{
var user = db.User.GetByKey(UserId);
Assert.AreEqual(1, user.RoleList.Count);
}
}
public void Inheritance()
{
try
{
using (var db = new TrackerDataContext())
{
var x = db.User
.Select(u => new Two {
FirstName = u.FirstName, LastName = u.LastName
})
.FirstOrDefault();
var y = db.User
.Select(u => new Two {
FirstName = u.FirstName, LastName = u.LastName
})
.FutureFirstOrDefault();
var z = y.Value;
Assert.AreEqual(x.FirstName, z.FirstName);
}
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public AwbRepository(IDbConnection connection)
{
_context = new TrackerDataContext(connection);
_selector = x => new AirWaybillData
{
ArrivalAirport = x.ArrivalAirport,
Bill = x.Bill,
BrokerId = x.BrokerId,
CreationTimestamp = x.CreationTimestamp,
DateOfArrival = x.DateOfArrival,
DateOfDeparture = x.DateOfDeparture,
DepartureAirport = x.DepartureAirport,
GTD = x.GTD,
Id = x.Id,
StateId = x.StateId,
StateChangeTimestamp = x.StateChangeTimestamp,
AdditionalCost = x.AdditionalCost,
BrokerCost = x.BrokerCost,
CustomCost = x.CustomCost,
FlightCost = x.FlightCost,
TotalCostOfSenderForWeight = x.TotalCostOfSenderForWeight,
IsActive = x.IsActive,
CreatorUserId = x.CreatorUserId,
SenderUserId = x.SenderUserId
};
}
public void ProcessRequest(HttpContext context)
{
context.Response.AddHeader("Access-Control-Allow-Origin", "*");
context.Response.AddHeader("Access-Control-Allow-Methods", "POST");
context.Response.AddHeader("Access-Control-Allow-Headers", "Content-Type, Accept");
TrackerDataContext context2 = new TrackerDataContext();
String SessionID = Tracker.Session.Finalize();
}
public void Nullable()
{
var db = new TrackerDataContext {
Log = Console.Out
};
var q1 = db.Task.Where("AssignedId == null || AssignedId == 1");
var list = q1.ToList();
}
public ActionResult Delete(int id)
{
using (var db = new TrackerDataContext())
{
db.Audit.Delete(a => a.TaskId == id);
db.Task.Delete(id);
}
return(RedirectToAction("Index"));
}
//
// GET: /User/
public ActionResult Index()
{
List <User> users = null;
using (var db = new TrackerDataContext())
{
users = db.User.OrderBy(u => u.EmailAddress).ToList();
}
return(View(users));
}
public void TestFixtureTearDown()
{
using (var db = new TrackerDataContext {
Log = Console.Out
})
{
db.Task.Delete(t => TaskIds.Contains(t.Id));
db.User.Delete(u => UserIds.Contains(u.Id));
}
}
