public void UpsertPlanContainer_Existing_Plan_Container_Succeeds()
{
// Arrange
Guid containerUId = Guid.NewGuid();
;
PlanContainer container = new PlanContainer()
{
UId = containerUId,
Name = _containerPrefix + containerUId
};
DynamoDbDal dal = new DynamoDbDal
{
ContainerTable = _containerTable
};
// Act
dal.UpsertPlanContainer(container);
container.Description = "Modified";
dal.UpsertPlanContainer(container);
PlanContainer retContainer = dal.GetPlanContainerByUId(container.UId);
// Assert
Assert.AreEqual(container.UId, retContainer.UId);
Assert.AreEqual(container.Name, retContainer.Name);
Assert.AreEqual(container.Description, retContainer.Description);
}
public void GetPlanContainerByAny_Existing_Plan_Container_Succeeds()
{
Guid containerUId = Guid.NewGuid();
PlanContainer container = new PlanContainer()
{
UId = containerUId,
Name = _containerPrefix + containerUId
};
DynamoDbDal dal = new DynamoDbDal
{
ContainerTable = _containerTable
};
// Act
dal.UpsertPlanContainer(container);
var retContainers = dal.GetPlanContainerByAny(containerUId, null, null, null, null, null, null);
// Assert
Assert.IsTrue(retContainers.Count > 0);
foreach (PlanContainer c in retContainers)
{
Assert.AreEqual(c.UId, container.UId);
Assert.AreEqual(c.Name, container.Name);
}
}
private void UpdateSemestersInDataSet(PlanContainer container)
{
var planRow = m_collegeDataSet.Plans.Where(row =>
{
if (row.RowState != DataRowState.Deleted)
{
return(row.plan_record_id == container.PlanRecordId);
}
else
{
return(false);
}
}).First();
foreach (var row in m_collegeDataSet.Semesters.Where(row =>
row.RowState != DataRowState.Deleted &&
row.plan_record_id == planRow.plan_record_id))
{
row.Delete();
}
foreach (var semesterCont in container.ListSemesters)
{
m_collegeDataSet.Semesters.AddSemestersRow(planRow,
semesterCont.SemesterNumber, semesterCont.HoursCount,
semesterCont.HoursPerWeek, semesterCont.HoursCountLPZ,
semesterCont.HoursCountKP, semesterCont.Exam);
}
}
public Plan GetPlan(string planUniqueName)
{
PlanContainer planContainer = GetPlanContainer(planUniqueName, returnTail: true, planItem: out PlanItem planItem);
IPlanExecuteReader reader = GetPlanExecuteReader(planContainer);
return(reader.GetPlan(planItem.PlanFile));
}
public IEnumerable <string> GetPlanList(string filter = null, bool isRegexFilter = true)
{
PlanContainer planContainer = GetPlanContainer(filter, returnTail: true);
IPlanExecuteReader reader = GetPlanExecuteReader(planContainer);
return(reader.GetPlanList(planContainer.PlansUri, isRegexFilter));
}
static void Main(string[] args)
{
EnterpriseStore store = new EnterpriseStore();
EnterpriseMemoryDal dal = new EnterpriseMemoryDal(store);
Group fooGroup = new Group {
UId = Guid.NewGuid(), Name = "fooGroup", IsLocal = true
};
Group gooGroup = new Group {
UId = Guid.NewGuid(), Name = "gooGroup", IsLocal = true
};
User steve = new User {
UId = Guid.NewGuid(), Name = "steve"
};
dal.UpsertGroup(fooGroup);
dal.UpsertUser(steve);
dal.UpsertGroupMembership(new GroupMembershipItem(group: fooGroup, member: steve));
PlanContainer top = new PlanContainer {
UId = Guid.NewGuid(), Name = "top"
};
top.Security.Dacl.Add(new AccessControlEntry <FileSystemRight> {
TrusteeUId = gooGroup.UId.Value, Right = FileSystemRight.Execute
});
PlanContainer child = new PlanContainer {
UId = Guid.NewGuid(), Name = "child"
};
child.Security.Dacl.Add(new AccessControlEntry <FileSystemRight> {
TrusteeUId = fooGroup.UId.Value, Right = FileSystemRight.Execute
});
top.Children.Add(child);
store.Containers = new List <PlanContainer>
{
top
};
PlanItem planItem = new PlanItem
{
Name = "xxx",
UniqueName = "xxx",
PlanContainerUId = child.UId
};
store.PlanItems = new List <PlanItem>
{
planItem
};
bool hasAccess = dal.HasAccess("steve", @"top\child\xxx");
}
private void AddPlanToDB(PlanContainer container)
{
int groupId = m_type == 0 ? m_groupSelector.GroupInfo.group_id :
m_planSelector.GroupInfo.group_id;
m_college.AdapterManager.PlansTableAdapter.Insert(
groupId, container.Subject.subject_id,
container.SubjectType.subject_type_id, container.OKRCount,
container.IKRCount);
GetPlanAdapter(groupId).Fill(m_collegeDataSet.Plans);
container.PlanRecordId = Convert.ToInt32(m_college.IdentCurrent("Plans"));
UpdateSemestersInDataSet(container);
}
private void InitList()
{
m_planList = new ListContainer <PlanContainer>();
int height = new PlanContainer().Height;
m_planList.Init(height + 5, new Point(0, m_groupSelector.Height),
"m_planList", new Size(), 3, 5);
m_planList.BackColor = SystemColors.ControlLight;
m_planList.HorizontalScroll.Enabled = false;
m_planList.HorizontalScroll.Visible = false;
UpdateListSize();
Controls.Add(m_planList);
}
public void UpsertPlanContainer_Null_Plan_Container_Throws_Exception()
{
// Arrange
PlanContainer container = null;
DynamoDbDal dal = new DynamoDbDal
{
ContainerTable = _containerTable
};
// Act
Exception ex = Assert.Throws <Exception>(() => dal.UpsertPlanContainer(container));
// Assert
StringAssert.AreEqualIgnoringCase("Plan container cannot be null.", ex.Message);
}
PlanContainer GetPlanContainer(string planUniqueName, bool returnTail, out PlanItem planItem)
{
string[] paths = planUniqueName.Split('\\');
List <PlanContainer> list = _store.Containers;
bool ok = true;
PlanContainer root = null;
PlanContainer tail = null;
for (int i = 0; i < paths.Length - 1; i++)
{
PlanContainer curr = list.Find(x => x.Name.Equals(paths[i], StringComparison.OrdinalIgnoreCase));
if (curr != null)
{
if (tail == null)
{
tail = curr.Clone(true);
tail.Security = curr.Security;
root = tail;
}
else
{
PlanContainer child = curr.Clone(true);
child.Security = curr.Security;
tail.Children.Add(child);
tail = child;
}
list = curr.Children;
}
else
{
ok = false;
break;
}
}
planItem = null;
if (ok)
{
planItem = _store.PlanItems.Find(p =>
p.UniqueName.Equals(paths[paths.Length - 1], StringComparison.OrdinalIgnoreCase) && p.PlanContainerUId == tail.UId);
ok = planItem != null;
}
return(ok ? returnTail ? tail : root : null);
}
IPlanExecuteReader GetPlanExecuteReader(PlanContainer planContainer)
{
PlanExecuteReaderItem ri = _store.DefaultExecuteReader;
if (planContainer.HasPlanExecuteReaderKey)
{
ri = _store.ExecuteReaders.SingleOrDefault(r => r.Key.Equals(planContainer.PlanExecuteReaderKey, StringComparison.OrdinalIgnoreCase));
}
if (ri == null)
{
throw new Exception($"Could not load PlanExecuteReader [{planContainer.PlanExecuteReaderKey}].");
}
return(AssemblyLoader.Load <IPlanExecuteReader>(ri.Type, string.Empty));
}
public void DeletePlanContainer_Existing_Container_Succeeds()
{
// Arrange
Guid containerUId = Guid.NewGuid();
;
PlanContainer container = new PlanContainer()
{
UId = containerUId,
Name = _containerPrefix + containerUId
};
DynamoDbDal dal = new DynamoDbDal
{
ContainerTable = _containerTable
};
// Act
dal.UpsertPlanContainer(container);
Assert.DoesNotThrow(() => dal.DeletePlanContainer(containerUId));
}
private void UpdatePlanInDataSet(PlanContainer container)
{
var planRow = m_collegeDataSet.Plans.Where(row =>
{
if (row.RowState != DataRowState.Deleted)
{
return(row.plan_record_id == container.PlanRecordId);
}
else
{
return(false);
}
}).First();
planRow.ikr_count = container.IKRCount;
planRow.okr_count = container.OKRCount;
planRow.subject_id = container.Subject.subject_id;
planRow.subject_type_id = container.SubjectType.subject_type_id;
UpdateSemestersInDataSet(container);
}
public void UpsertPlanContainer_Empty_Plan_Container_UId_Throws_Exception()
{
// Arrange
Guid containerUId = Guid.Empty;
;
PlanContainer container = new PlanContainer()
{
UId = containerUId
};
DynamoDbDal dal = new DynamoDbDal
{
ContainerTable = _containerTable
};
// Act
Exception ex = Assert.Throws <Exception>(() => dal.UpsertPlanContainer(container));
// Assert
StringAssert.AreEqualIgnoringCase("Plan container unique id cannot be empty.", ex.Message);
}
public void UpsertPlanContainer_Plan_Container_Without_Name_Throws_Exception()
{
// Arrange
Guid containerUId = Guid.NewGuid();
;
PlanContainer container = new PlanContainer()
{
UId = containerUId
};
DynamoDbDal dal = new DynamoDbDal
{
ContainerTable = _containerTable
};
// Act
Exception ex = Assert.Throws <Exception>(() => dal.UpsertPlanContainer(container));
// Assert
StringAssert.AreEqualIgnoringCase("Plan container name cannot be null or empty.", ex.Message);
}
public void UpsertPlanContainer_Null_Plan_Container_Table_Throws_Exception()
{
// Arrange
Guid containerUId = Guid.NewGuid();
;
PlanContainer container = new PlanContainer()
{
UId = containerUId,
Name = _containerPrefix + containerUId
};
DynamoDbDal dal = new DynamoDbDal
{
ContainerTable = ""
};
// Act
Exception ex = Assert.Throws <Exception>(() => dal.UpsertPlanContainer(container));
// Assert
StringAssert.AreEqualIgnoringCase("Plan container table name must be specified.", ex.Message);
}
private PlanContainer AddPlanContainer()
{
try
{
PlanContainer container = new PlanContainer(m_collegeDataSet.Subjects,
m_collegeDataSet.SubjectTypes);
container.SubjectChanged += (sender, e) =>
{
if (e.OldSubject != null)
{
foreach (var row in m_collegeDataSet.Subjects)
{
if (row.RowState == DataRowState.Deleted)
{
row.RejectChanges();
if (row.subject_id == e.OldSubject.subject_id)
{
break;
}
row.Delete();
}
}
}
var deleteRow = m_collegeDataSet.Subjects.Where(row =>
row.RowState != DataRowState.Deleted && row.subject_id ==
container.Subject.subject_id).First();
deleteRow.Delete();
};
m_planList.Add(container);
return(container);
}
catch (ApplicationException exc)
{
MyMessageBox.ShowError(exc.Message);
}
return(null);
}
public void UpsertPlanContainer_Non_Existent_Table_Throws_Exception()
{
// Arrange
Guid containerUId = Guid.NewGuid();
;
PlanContainer container = new PlanContainer()
{
UId = containerUId,
Name = _containerPrefix + containerUId
};
DynamoDbDal dal = new DynamoDbDal
{
ContainerTable = "XXXXXX"
};
// Act
Exception ex = Assert.Throws <ResourceNotFoundException>(() => dal.UpsertPlanContainer(container));
// Assert
StringAssert.Contains("Requested resource not found: Table", ex.Message);
}
public PlanContainer UpsertPlanContainer(PlanContainer planContainer)
{
if (planContainer == null)
{
throw new Exception("Plan container cannot be null.");
}
if (planContainer.UId == Guid.Empty)
{
throw new Exception("Plan container unique id cannot be empty.");
}
if (string.IsNullOrWhiteSpace(planContainer.Name))
{
throw new Exception("Plan container name cannot be null or empty.");
}
if (string.IsNullOrWhiteSpace(ContainerTable))
{
throw new Exception("Plan container table name must be specified.");
}
try
{
string output = JsonConvert.SerializeObject(planContainer, Formatting.Indented, _settings);
Document doc = Document.FromJson(output);
Table table = Table.LoadTable(_client, ContainerTable);
table.PutItem(doc);
}
catch (Exception ex)
{
Debug.Write(ex.Message);
throw;
}
return(planContainer);
}
private PlanContainer AddPlanContainerWithData(CollegeDataSet.PlansRow row)
{
var subjectRow = m_collegeDataSet.Subjects.
FindBysubject_id(row.subject_id);
if (subjectRow == null)
{
throw new ApplicationException("Невозможно добавить запись, " +
"т.к. запись с такой дисциплиной уже есть.");
}
PlanContainer container = AddPlanContainer();
container.Subject = CopySubjectRow(subjectRow);
container.SubjectType = m_collegeDataSet.SubjectTypes.
FindBysubject_type_id(row.subject_type_id);
container.OKRCount = row.okr_count;
container.IKRCount = row.ikr_count;
container.PlanRecordId = row.plan_record_id;
var semesterTable = m_college.GetSemestersByPlan(row.plan_record_id);
foreach (var semesterRow in semesterTable)
{
SemesterDataContainer semesterCont = new SemesterDataContainer();
semesterCont.SemesterNumber = semesterRow.semester_number;
semesterCont.Exam = semesterRow.exam;
semesterCont.HoursCount = semesterRow.hours_count;
semesterCont.HoursPerWeek = semesterRow.hours_per_week;
semesterCont.HoursCountKP = semesterRow.kp_hours_count;
semesterCont.HoursCountLPZ = semesterRow.lpz_hours_count;
container.ListSemesters.Add(semesterCont);
}
container.IsChanged = false;
semesterTable.Dispose();
return(container);
}
public void UpsertPlanContainer_Valid_Details_Succeeds()
{
// Arrange
Guid containerUId = Guid.NewGuid();
;
PlanContainer container = new PlanContainer()
{
UId = containerUId,
Name = _containerPrefix + containerUId
};
DynamoDbDal dal = new DynamoDbDal
{
ContainerTable = _containerTable
};
// Act
dal.UpsertPlanContainer(container);
PlanContainer retContainer = dal.GetPlanContainerByUId(container.UId);
// Assert
Assert.AreEqual(container.UId, retContainer.UId);
Assert.AreEqual(container.Name, retContainer.Name);
}
/// <summary>
/// Computes the plan.
/// </summary>
/// <returns>
/// Plan status.
/// </returns>
/// <param name='currentState'>
/// Agent state.
/// </param>
/// <param name='_goalState'>
/// Goal state.
/// </param>
/// <param name='plan'>
/// Dictionary where plan will be stored.
/// </param>
/// <param name='inflation'>
/// Inflation factor.
/// </param>
/// <param name='maxTime'>
/// Maximum alloted time.
/// </param>
public PathStatus computePlan(ref DefaultState currentState, ref DefaultState _goalState,
ref Dictionary <DefaultState, ARAstarNode> plan, ref float inflation, float maxTime)
{
DefaultState s = default(DefaultState);
selectedPlanningDomain = default(PlanningDomainBase);
goalState = _goalState;
DetermineDomain(ref selectedPlanningDomain, ref currentState);
currentStart = currentState;
// introducing function that clears some temp data (e.g. tracked non det obstacles) from domain at the beginning
// of each plan iteration
//domain.clearAtBeginningOfEveryPlanIteration ();
if (firstTime)
{
//inflationFactor = inflation;
InitializeValues(ref currentState, ref goalState, inflation);
Plan = new PlanContainer(plan);
if (OneStep)
{
PerformOneStep();
}
else
{
ImprovePath(maxTime);
}
}
else
{
if (goalMoved)
{
UpdateAfterGoalMoved(goalState);
}
if (moved)
{
UpdateAfterStartMoved(currentState);
}
if (inflationFactor < 1.0f)
{
inflationFactor = 1.0f;
}
//Check start node if it moved
if (OneStep)
{
PerformOneStep();
}
else
{
ImprovePath(maxTime);
}
if (inflationFactor == 1.0f)
{
plannerFinished = true;
}
}
//TODO: please return Status here
//return true;
return(Status);
//return (inflationFactor == 1.0F);
}
public bool HasAccess(string securityContext, string planUniqueName, FileSystemRight right = FileSystemRight.Execute)
{
PlanContainer root = GetPlanContainer(planUniqueName);
if (root == null)
{
throw new Exception("Plan path invalid or Plan not found.");
}
User user = _store.Users.GetByNameOrDefault <User>(securityContext);
if (user == null || !user.IsEnabled)
{
return(false);
}
//stores the Guids from Suplex + ActiveDirectory for user's group membership
List <Guid> groupMembership = new List <Guid>();
//get the user's groupMembership from Suplex
IEnumerable <GroupMembershipItem> gm = GetGroupMembership(user.UId.Value);
foreach (GroupMembershipItem gmi in gm)
{
groupMembership.Add(gmi.GroupUId);
}
//get the Active Directory groupMembership, resolve the groups from Suplex
List <string> adgm = DirectoryServicesHelper.GetGroupMembership(securityContext, ldapRoot: null, externalGroups: null);
foreach (string group in adgm)
{
Group g = _store.Groups.GetByNameOrDefault <Group>(group);
if (g != null && g.IsEnabled)
{
groupMembership.Add(g.UId.Value);
}
}
//delete any aces assigned to Trustees to which the user /does not belong/
PlanContainer planCont = root;
while (planCont != null)
{
for (int n = planCont.Security.Dacl.Count - 1; n >= 0; n--)
{
if (!groupMembership.Contains(planCont.Security.Dacl[n].TrusteeUId.Value))
{
planCont.Security.Dacl.RemoveAt(n);
}
}
planCont = planCont.Children?.Count > 0 ? planCont.Children[0] : null;
}
//return root.EvalSecurity().GetByTypeRight( right ).AccessAllowed;
//root.EvalSecurity();
//return planCont.Security.Results.GetByTypeRight( right ).AccessAllowed;
//eval security from top->down, return result from bottom node (last node found in while loop above)
root.EvalSecurity();
return(planCont.Security.HasAccess(right));
}
// TODO: Check with Steve on returnAsHierarchy, startUId, validateRls
public List <PlanContainer> GetPlanContainerByAny(Guid?planContainerUId, string name, string nodeUri, string createdBy, DateTime?createdTime, string modifiedBy, DateTime?modifiedTime, bool returnAsHierarchy = false,
Guid?startUId = null, bool validateRls = false)
{
List <PlanContainer> containerList = new List <PlanContainer>();
if (string.IsNullOrWhiteSpace(ContainerTable))
{
throw new Exception("Plan container table name must be specified.");
}
try
{
Table table = Table.LoadTable(_client, ContainerTable);
ScanFilter scanFilter = new ScanFilter();
if (planContainerUId != null && planContainerUId != Guid.Empty)
{
scanFilter.AddCondition("UId", ScanOperator.Equal, planContainerUId);
}
if (!string.IsNullOrWhiteSpace(name))
{
scanFilter.AddCondition("Name", ScanOperator.Equal, name);
}
if (!string.IsNullOrWhiteSpace(nodeUri))
{
scanFilter.AddCondition("NodeUri", ScanOperator.Equal, nodeUri);
}
if (!string.IsNullOrWhiteSpace(createdBy))
{
scanFilter.AddCondition("AuditCreatedBy", ScanOperator.Equal, createdBy);
}
if (createdTime != null)
{
scanFilter.AddCondition("AuditCreatedTime", ScanOperator.Equal, createdTime);
}
if (!string.IsNullOrWhiteSpace(modifiedBy))
{
scanFilter.AddCondition("AuditModifiedBy", ScanOperator.Equal, modifiedBy);
}
if (modifiedTime != null)
{
scanFilter.AddCondition("AuditModifiedTime", ScanOperator.Equal, modifiedTime);
}
if (scanFilter.ToConditions().Count == 0)
{
throw new Exception("At least one filter condition must be specified.");
}
Search search = table.Scan(scanFilter);
do
{
List <Document> documentList = search.GetNextSet();
if (documentList.Count == 0)
{
throw new Exception("Plan container cannot be found.");
}
foreach (Document document in documentList)
{
string json = document.ToJsonPretty();
PlanContainer container = JsonConvert.DeserializeObject <PlanContainer>(json, _settings);
containerList.Add(container);
}
} while (!search.IsDone);
}
catch (Exception ex)
{
Debug.Write(ex.Message);
throw;
}
return(containerList);
}
