public void TestSaveProject_AddProject_WithTasks()
{
using (SQLitePersistence sqlite = new SQLitePersistence(new SQLitePersistenceConfig(GetTestDBLocation())))
{
Collection <Project> prjList = sqlite.LoadProjects();
DefinedContexts dc = sqlite.LoadContexts();
var removedProjectID = prjList[0].UniqueID;
var newProject = new Project("New Test Project");
var newTask = new Task("New Task")
{
ContextID = dc.FindIdByDescr("Home").ID
};
newProject.AddTask(newTask);
prjList.Add(newProject);
sqlite.SaveProjects(prjList);
Collection <Project> prjListNew = sqlite.LoadProjects();
Assert.IsTrue(ProjectComparer.AreListsEquivalent(prjList, prjListNew,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList));
Assert.IsTrue(prjListNew[10].TaskList.Select(t => t.UniqueID == newTask.UniqueID).First());
}
}
public void TestSame_NoTasks()
{
var prj1 = new Project("Test Project 1");
var prj2 = new Project("Test Project 2");
var prj3 = new Project("Test Project 1");
var prj4 = new Project("Test Project 2");
prj3.UniqueID = prj1.UniqueID;
prj3.DateTimeCreated = prj1.DateTimeCreated;
prj4.UniqueID = prj2.UniqueID;
prj4.DateTimeCreated = prj2.DateTimeCreated;
Collection <Project> prjList1 = new Collection <Project>
{
prj1,
prj2
};
Collection <Project> prjList2 = new Collection <Project>
{
prj3,
prj4
};
Assert.IsTrue(ProjectComparer.AreListsEquivalent(prjList1, prjList2,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList));
}
public void TestDifferent_NoTasks()
{
var prj1 = new Project("Test Project 1");
var prj2 = new Project("Test Project 2");
var prj3 = new Project("Test Project 1");
var prj4 = new Project("Test Project 2");
Collection <Project> prjList1 = new Collection <Project>
{
prj1,
prj2
};
Collection <Project> prjList2 = new Collection <Project>
{
prj3,
prj4
};
// Different UniqueIDs and DateTimeCreated
Assert.IsFalse(ProjectComparer.AreListsEquivalent(prjList1, prjList2,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList));
Assert.AreEqual(2, addList.Count);
Assert.AreEqual(0, chgList.Count);
Assert.AreEqual(2, delList.Count);
Assert.AreEqual(0, chgTaskList.Count);
}
public void GetAllProjectsTest()
{
var projectController = new ProjectController()
{
Request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri(ServiceBaseURL)
}
};
projectController.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
_response = projectController.Get();
var responseResultSearch = JsonConvert.DeserializeObject <List <vw_ProjectSearch> >(_response.Content.ReadAsStringAsync().Result);
var projectList =
responseResultSearch.Select(
projectEntity =>
new Project
{
Project_ID = projectEntity.Project_ID,
Project1 = projectEntity.ProjectName,
Priority = projectEntity.Project_Priority,
Start_Date = projectEntity.Start_Date,
End_Date = projectEntity.End_Date
}).ToList();
Assert.AreEqual(_response.StatusCode, HttpStatusCode.OK);
Assert.AreEqual(projectList.Any(), true);
var comparer = new ProjectComparer();
CollectionAssert.AreEqual(projectList.OrderBy(project => project, comparer), _projects.OrderBy(project => project, comparer), comparer);
}
public async Task CheckConsolidateSolution()
{
var solution = await Scanner.ScanSolution(@"F:\Projects\_GitHub\Exercise.DynamicProxy", Progress, false);
var comparer = new ProjectComparer();
var result = comparer.FindConsolidateReferences(solution).ToList();
}
public void TestSame_WithTasks()
{
CreateTwoIdenticalProjectLists(out Collection <Project> prjList1, out Collection <Project> prjList2);
Assert.IsTrue(ProjectComparer.AreListsEquivalent(prjList1, prjList2,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList));
}
public void ComparerSeesNoChange()
{
var p1 = new Project()
{
attributes = new Attributes()
{
name = "foo"
}
};
var comparer = new ProjectComparer(p1, p1);
comparer.DidProjectChange(out var changes).Should().BeFalse();
changes.Should().BeEmpty();
}
public void TestSameProjectAttrs_DifferentTasks()
{
CreateTwoIdenticalProjectLists(out Collection <Project> prjList1, out Collection <Project> prjList2);
var changedProjectID = prjList2[0].UniqueID;
prjList2[0].TaskList[0].Name = "Changed Name 1";
Assert.IsFalse(ProjectComparer.AreListsEquivalent(prjList1, prjList2,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList));
Assert.AreEqual(0, addList.Count);
Assert.AreEqual(0, chgList.Count);
Assert.AreEqual(0, delList.Count);
Assert.AreEqual(1, chgTaskList.Count);
Assert.AreEqual(changedProjectID, chgTaskList[0].UniqueID);
}
public void TestSaveProject_ChangedProject()
{
using (SQLitePersistence sqlite = new SQLitePersistence(new SQLitePersistenceConfig(GetTestDBLocation())))
{
Collection <Project> prjList = sqlite.LoadProjects();
var changedID = prjList[0].UniqueID;
prjList[0].ProjectName = "Changed Name";
sqlite.SaveProjects(prjList);
Collection <Project> prjListNew = sqlite.LoadProjects();
Assert.IsTrue(ProjectComparer.AreListsEquivalent(prjList, prjListNew,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList));
}
}
public void TestSaveProject_AddProject_NoTasks()
{
using (SQLitePersistence sqlite = new SQLitePersistence(new SQLitePersistenceConfig(GetTestDBLocation())))
{
Collection <Project> prjList = sqlite.LoadProjects();
var removedProjectID = prjList[0].UniqueID;
var newProject = new Project("New Test Project");
prjList.Add(newProject);
sqlite.SaveProjects(prjList);
Collection <Project> prjListNew = sqlite.LoadProjects();
Assert.IsTrue(ProjectComparer.AreListsEquivalent(prjList, prjListNew,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList));
}
}
public void TestSecondNull()
{
var prj1 = new Project("Test Project 1");
var prj2 = new Project("Test Project 2");
Collection <Project> prjList1 = new Collection <Project>
{
prj1,
prj2
};
Collection <Project> prjList2 = null;
Assert.IsFalse(ProjectComparer.AreListsEquivalent(prjList1, prjList2,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList));
Assert.AreEqual(0, addList.Count);
Assert.AreEqual(0, chgList.Count);
Assert.AreEqual(2, delList.Count);
Assert.AreEqual(0, chgTaskList.Count);
}
private async Task GetDataFromServerAsync()
{
var response = await _repository.GetProjects();
if (response.HasError)
{
var properties = new Dictionary <string, string>();
properties["Method Name"] = "GetProjectsFromServer";
Telemetry.Instance.TrackException(response.Exception, properties);
if (response.Exception.GetType() == typeof(AppVeyorUnauthorizedException))
{
// (Errors.IsEmpty() || (!Errors.IsEmpty() && Errors.Any(x => (DateTime.Now - x.TimeStamp).Minutes > 1)))
{
AddAlert(response.Exception, response.Exception.Message);
}
//if unauthorized pause till correct token is set
StopPollingForProjects();
ShowMessageOnUI("Error occurred...Please check Errors tab for more details.");
}
else
{
AddAlert(response.Exception, response.Exception.Message);
}
}
else
{
var projectsFromServer = response.Result.ToObservableCollection();
var comparer = new ProjectComparer();
if (!_searchResultDisplayed && !projectsFromServer.ListEqual(Projects, comparer))
{
//rebind only if any of the project properties are changed
await Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background, new Action(delegate()
{
Projects = projectsFromServer;
IsLoading = Visibility.Collapsed;
HideMessageFromUI();
}));
}
}
// Users = await model.GetUsers();
// Environments = await model.GetEnvironments();
}
public void TestSaveProject_DeleteExistingTask()
{
using (SQLitePersistence sqlite = new SQLitePersistence(new SQLitePersistenceConfig(GetTestDBLocation())))
{
Collection <Project> prjList = sqlite.LoadProjects();
DefinedContexts dc = sqlite.LoadContexts();
var deletedTask = prjList[3].TaskList[1].UniqueID;
prjList[3].TaskList.RemoveAt(1);
sqlite.SaveProjects(prjList);
Collection <Project> prjListNew = sqlite.LoadProjects();
Assert.IsTrue(ProjectComparer.AreListsEquivalent(prjList, prjListNew,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList));
Assert.AreEqual(0, prjListNew[3].TaskList.Where(t => t.UniqueID == deletedTask).Count());
}
}
public void GetAllProjectsTest()
{
var projects = _projectService.GetAllProjects();
var projectList =
projects.Select(
projectEntity =>
new Project
{
Project_ID = projectEntity.Project_ID,
Project1 = projectEntity.Project1,
Priority = projectEntity.Priority,
Start_Date = projectEntity.Start_Date,
End_Date = projectEntity.End_Date
}).ToList();
var comparer = new ProjectComparer();
CollectionAssert.AreEqual(
projectList.OrderBy(project => project, comparer),
_projects.OrderBy(project => project, comparer), comparer);
}
public void TestSaveProject_ChangeExistingTask()
{
using (SQLitePersistence sqlite = new SQLitePersistence(new SQLitePersistenceConfig(GetTestDBLocation())))
{
Collection <Project> prjList = sqlite.LoadProjects();
DefinedContexts dc = sqlite.LoadContexts();
var changedTask = prjList[2].TaskList[4].UniqueID;
prjList[2].TaskList[4].Details = "New details";
sqlite.SaveProjects(prjList);
Collection <Project> prjListNew = sqlite.LoadProjects();
Assert.IsTrue(ProjectComparer.AreListsEquivalent(prjList, prjListNew,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList));
Assert.AreEqual("New details", prjListNew[2].TaskList.Where(t => t.UniqueID == changedTask).First().Details);
}
}
public void TestSaveProject_DeleteProject()
{
using (SQLitePersistence sqlite = new SQLitePersistence(new SQLitePersistenceConfig(GetTestDBLocation())))
{
Collection <Project> prjList = sqlite.LoadProjects();
var removedProjectID = prjList[0].UniqueID;
prjList.RemoveAt(0);
sqlite.SaveProjects(prjList);
Collection <Project> prjListNew = sqlite.LoadProjects();
Assert.IsTrue(ProjectComparer.AreListsEquivalent(prjList, prjListNew,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList));
// test that tasks tied to the removed project have been deleted from the DB
Assert.AreEqual(0, sqlite.LoadTasks(removedProjectID.ToString()).Count);
}
}
public void CanDetectNameChange()
{
var p1 = new Project()
{
attributes = new Attributes()
{
name = "foo"
}
};
var p2 = new Project()
{
attributes = new Attributes()
{
name = "bar"
}
};
var comparer = new ProjectComparer(p1, p2);
comparer.DidProjectChange(out var changes).Should().BeTrue();
changes.Single().Key.Should().Be("name");
}
public void TestSaveProject_AddTaskToExistingProject()
{
using (SQLitePersistence sqlite = new SQLitePersistence(new SQLitePersistenceConfig(GetTestDBLocation())))
{
Collection <Project> prjList = sqlite.LoadProjects();
DefinedContexts dc = sqlite.LoadContexts();
var prjIDWithNewTask = prjList[0].UniqueID;
var newTask = new Task("New Task")
{
ContextID = dc.FindIdByDescr("Home").ID
};
prjList[0].AddTask(newTask);
sqlite.SaveProjects(prjList);
Collection <Project> prjListNew = sqlite.LoadProjects();
Assert.IsTrue(ProjectComparer.AreListsEquivalent(prjList, prjListNew,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList));
Assert.IsNotNull(prjListNew[0].TaskList.Where(t => t.UniqueID == newTask.UniqueID).First());
}
}
public void CanDetectMultipleChanges()
{
var p1 = new Project()
{
attributes = new Attributes()
{
name = "foo", description = "derp", state = "published"
}
};
var p2 = new Project()
{
attributes = new Attributes()
{
name = "bar", description = "derp", state = "archived"
}
};
var comparer = new ProjectComparer(p1, p2);
comparer.DidProjectChange(out var changes).Should().BeTrue();
changes.Count().Should().Be(2);
changes.Should().ContainKey("name");
changes.Should().ContainKey("state");
}
static async Task RunScraper(string?slackWebhookUrl, bool useCache, bool saveToDb)
{
MarkupLine($"[green]Welcome to RezoningScraper v{Assembly.GetExecutingAssembly().GetName().Version}[/]");
if (string.IsNullOrWhiteSpace(slackWebhookUrl))
{
WriteLine($"Slack URI not specified; will not publish updates to Slack.");
}
if (!saveToDb)
{
WriteLine("Dry run; will not write results to database");
}
WriteLine();
// Use Spectre.Console's Status UI https://spectreconsole.net/live/status
await AnsiConsole.Status().StartAsync("Opening DB...", async ctx =>
{
var db = DbHelper.OpenInitializedDbFromFile();
ctx.Status = "Loading token...";
var token = await TokenHelper.GetTokenFromDbOrWebsite(db, useCache);
ctx.Status = "Querying API...";
WriteLine("Starting API query...");
var stopwatch = Stopwatch.StartNew();
var latestProjects = await API.GetAllProjects(token.JWT, useCache).ToListAsync();
MarkupLine($"API query finished: retrieved {latestProjects.Count} projects in [yellow]{stopwatch.ElapsedMilliseconds}ms[/]");
ctx.Status = "Comparing against projects in local database...";
stopwatch.Restart();
List <Project> newProjects = new();
List <ChangedProject> changedProjects = new();
var tran = db.BeginTransaction();
foreach (var project in latestProjects)
{
if (db.ContainsProject(project))
{
var oldVersion = db.GetProject(project.id !);
var comparer = new ProjectComparer(oldVersion, project);
if (comparer.DidProjectChange(out var changes))
{
changedProjects.Add(new(oldVersion, project, changes));
}
}
else
{
newProjects.Add(project);
}
if (saveToDb)
{
db.UpsertProject(project);
}
}
tran.Commit();
MarkupLine($"Upserted {latestProjects.Count} projects to the DB in [yellow]{stopwatch.ElapsedMilliseconds}ms[/]");
MarkupLine($"Found [green]{newProjects.Count}[/] new projects and [green]{changedProjects.Count}[/] modified projects.");
if (!string.IsNullOrEmpty(slackWebhookUrl) && (newProjects.Any() || changedProjects.Any()))
{
await PostToSlack(slackWebhookUrl, newProjects, changedProjects);
}
PrintNewProjects(newProjects);
PrintChangedProjects(changedProjects);
});
}
public void SaveProjects(Collection <Project> prjListNew)
{
log.Info("Saving Projects");
var prjListFromDB = new Collection <Project>();
using (SQLiteConnection db = new SQLiteConnection(_connStrBuilder.ConnectionString))
{
prjListFromDB = LoadProjects();
}
if (!ProjectComparer.AreListsEquivalent(prjListFromDB, prjListNew,
out List <Project> chgList, out List <Project> addList, out List <Project> delList,
out List <Project> chgTaskList))
{
using (SQLiteConnection db = new SQLiteConnection(_connStrBuilder.ConnectionString))
{
db.Open();
foreach (var changedPrj in chgList)
{
SQLiteCommand cmd = BuildChangedProjectSQL(changedPrj, db);
cmd.ExecuteNonQuery();
}
foreach (var deletedPrj in delList)
{
DeleteAttachedTasks(deletedPrj, db);
SQLiteCommand cmd = BuildDeleteProjectSQL(deletedPrj, db);
cmd.ExecuteNonQuery();
}
foreach (var addedPrj in addList)
{
SQLiteCommand cmd = BuildAddProjectSQL(addedPrj, db);
cmd.ExecuteNonQuery();
AddAttachedTasks(addedPrj.TaskList, addedPrj.UniqueID, db);
}
//changed tasks
foreach (var prj in chgTaskList)
{
var prjFromDB = prjListFromDB.First(p => p.UniqueID == prj.UniqueID);
if (!new TaskComparer().AreListsEquivalent(prjFromDB.TaskList.ToList(),
prj.TaskList.ToList(), out List <Task> chgTaskListPerPrj,
out List <Task> addTaskList, out List <Task> delTaskList))
{
foreach (var changedTask in chgTaskListPerPrj)
{
SQLiteCommand cmd = BuildChangedTaskSQL(changedTask,
prj.UniqueID.ToString(), db);
cmd.ExecuteNonQuery();
}
foreach (var addedTask in addTaskList)
{
SQLiteCommand cmd = BuildAddTaskSQL(addedTask,
prj.UniqueID.ToString(), db);
cmd.ExecuteNonQuery();
}
foreach (var deletedTask in delTaskList)
{
SQLiteCommand cmd = BuildDeleteTaskSQL(deletedTask, db);
cmd.ExecuteNonQuery();
}
}
}
db.Close();
}
}
log.Info("Done saving Projects");
}
