}//threadCallBack()
private bool _doesGeneratorRunNow(CswNbtObjClassGenerator CurrentGenerator)
{
bool RunNow = false;
DateTime ThisDueDateValue = CurrentGenerator.NextDueDate.DateTimeValue.Date;
DateTime InitialDueDateValue = CurrentGenerator.DueDateInterval.getStartDate().Date;
if (InitialDueDateValue == DateTime.MinValue)
{
InitialDueDateValue = ThisDueDateValue;
}
DateTime FinalDueDateValue = CurrentGenerator.FinalDueDate.DateTimeValue.Date;
if (ThisDueDateValue != DateTime.MinValue)
{
if (CurrentGenerator.RunTime.DateTimeValue != DateTime.MinValue &&
CswEnumRateIntervalType.Hourly != CurrentGenerator.DueDateInterval.RateInterval.RateType) // Ignore runtime for hourly generators
{
ThisDueDateValue = ThisDueDateValue.AddTicks(CurrentGenerator.RunTime.DateTimeValue.TimeOfDay.Ticks);
}
Int32 WarnDays = CswConvert.ToInt32(CurrentGenerator.WarningDays.Value);
if (WarnDays > 0)
{
TimeSpan WarningDaysSpan = new TimeSpan(WarnDays, 0, 0, 0, 0);
ThisDueDateValue = ThisDueDateValue.Subtract(WarningDaysSpan);
InitialDueDateValue = InitialDueDateValue.Subtract(WarningDaysSpan);
}
// if we're within the initial and final due dates, but past the current due date (- warning days) and runtime
RunNow = (DateTime.Now.Date >= InitialDueDateValue) &&
(DateTime.Now.Date <= FinalDueDateValue || DateTime.MinValue.Date == FinalDueDateValue) &&
(DateTime.Now >= ThisDueDateValue);
}
return(RunNow);
}
} // update()
private void _fixBadScheudlesAndTasks()
{
ICswNbtTree BadSchedulesTree = _CswNbtSchemaModTrnsctn.getTreeFromView( _getBadSchedulesAndTasksView(), false );
BadSchedulesTree.goToRoot();
for( int i = 0; i < BadSchedulesTree.getChildNodeCount(); i++ )
{
BadSchedulesTree.goToNthChild( i );
CswNbtObjClassGenerator ScheduleNode = BadSchedulesTree.getNodeForCurrentPosition();
int TargetTypeId = ScheduleNode.NodeTypeId == AssemblyScheduleNT.NodeTypeId ? AssemblyTaskNT.NodeTypeId : EquipmentTaskNT.NodeTypeId;
ScheduleNode.TargetType.SelectedNodeTypeIds.Clear();
ScheduleNode.TargetType.SelectedNodeTypeIds.Add( CswConvert.ToString( TargetTypeId ) );
ScheduleNode.postChanges( false );
for( int j = 0; j < BadSchedulesTree.getChildNodeCount(); j++ )
{
BadSchedulesTree.goToNthChild( j );
CswNbtNode OldTaskNode = BadSchedulesTree.getNodeForCurrentPosition();
CswNbtObjClassTask NewTaskNode = _CswNbtSchemaModTrnsctn.Nodes.makeNodeFromNodeTypeId( TargetTypeId, CswEnumNbtMakeNodeOperation.WriteNode );
NewTaskNode.Node.copyPropertyValues( OldTaskNode );
NewTaskNode.Owner.RelatedNodeId = ScheduleNode.Owner.RelatedNodeId;
OldTaskNode.delete();
NewTaskNode.postChanges( false );
BadSchedulesTree.goToParentNode();
}
BadSchedulesTree.goToParentNode();
}
}
public void updateNextDueDateTest_ExplicitUpdate()
{
CswNbtObjClassGenerator GeneratorNode = TestData.Nodes.createGeneratorNode(CswEnumRateIntervalType.WeeklyByDay);
GeneratorNode.updateNextDueDate(ForceUpdate: false, DeleteFutureNodes: false);
Assert.AreEqual(getNextDay(DayOfWeek.Monday), GeneratorNode.NextDueDate.DateTimeValue);
}
internal CswNbtNode createGeneratorNode(CswEnumRateIntervalType IntervalType, String NodeTypeName = "Equipment Schedule", int WarningDays = 0, SortedList Days = null, DateTime?StartDate = null)
{
CswNbtNode ret = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(_getNodeTypeId(NodeTypeName), delegate(CswNbtNode NewNode)
{
CswNbtObjClassGenerator GeneratorNode = NewNode;
CswRateInterval RateInt = new CswRateInterval(_CswNbtResources);
DateTime StDate = StartDate != null ? (DateTime)StartDate : new DateTime(2012, 1, 15);
if (IntervalType == CswEnumRateIntervalType.WeeklyByDay)
{
if (null == Days)
{
Days = new SortedList {
{ DayOfWeek.Monday, DayOfWeek.Monday }
};
}
RateInt.setWeeklyByDay(Days, StDate);
}
else if (IntervalType == CswEnumRateIntervalType.MonthlyByDate)
{
RateInt.setMonthlyByDate(1, StDate.Day, StDate.Month, StDate.Year);
}
GeneratorNode.DueDateInterval.RateInterval = RateInt;
GeneratorNode.WarningDays.Value = WarningDays;
//GeneratorNode.postChanges( ForceUpdate: false );
});
_finalize();
return(ret);
} // createGeneratorNode()
public void updateNextDueDateTest_DeleteFutureMonthly()
{
CswNbtObjClassGenerator GeneratorNode = TestData.Nodes.createGeneratorNode(CswEnumRateIntervalType.MonthlyByDate);
CswNbtObjClassGenerator ExistingGen = TestData.CswNbtResources.Nodes[GeneratorNode.NodeId];
ExistingGen.updateNextDueDate(ForceUpdate: false, DeleteFutureNodes: true);
Assert.AreEqual(getNextDate(15), ExistingGen.NextDueDate.DateTimeValue);
}
public void updateNextDueDateTest_ExplicitSet()
{
CswNbtObjClassGenerator GeneratorNode = TestData.Nodes.createGeneratorNode(CswEnumRateIntervalType.WeeklyByDay);
GeneratorNode.NextDueDate.DateTimeValue = DateTime.Today;
GeneratorNode.postChanges(true);
Assert.AreEqual(DateTime.Today, GeneratorNode.NextDueDate.DateTimeValue);
}
public void updateNextDueDateTest_AWeekFromToday()
{
DayOfWeek Today = DateTime.Today.DayOfWeek;
CswNbtObjClassGenerator GeneratorNode = TestData.Nodes.createGeneratorNode(CswEnumRateIntervalType.WeeklyByDay, Days: new SortedList {
{ Today, Today }
}, StartDate: DateTime.Today);
Assert.AreEqual(DateTime.Today.AddDays(7), GeneratorNode.NextDueDate.DateTimeValue);
}
} // makeBatchOp()
/// <summary>
/// Run the next iteration of this batch operation
/// </summary>
public void runBatchOp(CswNbtObjClassBatchOp BatchNode)
{
try
{
if (BatchNode != null && BatchNode.OpNameValue == CswEnumNbtBatchOpName.FutureNodes)
{
BatchNode.start();
FutureNodesBatchData BatchData = new FutureNodesBatchData(BatchNode.BatchData.Text);
if (BatchData.GeneratorNodeId != null && BatchData.NextStartDate != DateTime.MinValue)
{
CswNbtNode GenNode = _CswNbtResources.Nodes[BatchData.GeneratorNodeId];
if (null != GenNode)
{
CswNbtObjClassGenerator GeneratorNode = (CswNbtObjClassGenerator)GenNode;
DateTime ThisDate = BatchData.NextStartDate;
CswNbtActGenerateNodes CswNbtActGenerateNodes = new CswNbtActGenerateNodes(_CswNbtResources);
CswNbtActGenerateNodes.MarkFuture = true;
// Run this iteration
bool Finished = false;
if (ThisDate != DateTime.MinValue &&
ThisDate.Date <= BatchData.FinalDate.Date &&
(GeneratorNode.FinalDueDate.Empty || ThisDate.Date <= GeneratorNode.FinalDueDate.DateTimeValue.Date))
{
Finished = CswNbtActGenerateNodes.makeNode(GenNode, ThisDate);
//BatchNode.appendToLog( "Created future task for " + ThisDate.ToShortDateString() + "." );
}
else
{
BatchNode.finish();
}
// Setup for next iteration
if (Finished)
{
BatchData.NextStartDate = GeneratorNode.DueDateInterval.getNextOccuranceAfter(ThisDate);
if (BatchData.NextStartDate.Date == ThisDate.Date) // infinite loop guard
{
BatchNode.finish();
}
BatchData.IterationCount += 1;
}
BatchNode.BatchData.Text = BatchData.ToString();
BatchNode.PercentDone.Value = getPercentDone(BatchNode);
} // if( null != GenNode )
} // if( _BatchData.GeneratorNodeId != null && _BatchData.NextStartDate != DateTime.MinValue )
BatchNode.postChanges(false);
} // if( BatchNode != null && BatchNode.OpNameValue == NbtBatchOpName.FutureNodes )
}
catch (Exception ex)
{
BatchNode.error(ex);
}
} // runBatchOp()
private CswNbtNode _getTargetNodeForGenerator(CswNbtNode CswNbtNodeGenerator, CswPrimaryKey ParentPk, string TargetDateFilter)
{
CswNbtNode ReturnVal = null;
CswNbtObjClassGenerator GeneratorNode = (CswNbtObjClassGenerator)CswNbtNodeGenerator;
if (String.IsNullOrEmpty(GeneratorNode.TargetType.SelectedNodeTypeIds.ToString()))
{
throw new CswDniException(CswEnumErrorType.Error, "Invalid generator configuration", "_getTargetNodeForGenerator got a null SelectedNodeTypeIds on nodeid " + GeneratorNode.NodeId);
}
else
{
Int32 NodeTypeId = CswConvert.ToInt32(GeneratorNode.TargetType.SelectedNodeTypeIds[0]); // case 28612 - just check the first one
if (Int32.MinValue != NodeTypeId)
{
CswNbtMetaDataNodeType ThisCreatedNodeType = _CswNbtResources.MetaData.getNodeType(NodeTypeId);
if (null != ThisCreatedNodeType)
{
CswNbtMetaDataNodeType CreatedNodeType = ThisCreatedNodeType.getNodeTypeLatestVersion();
CswNbtMetaDataObjectClass CreatedMetaDataObjectClass = CreatedNodeType.getObjectClass();
CswNbtObjClass CreatedObjClass = CswNbtObjClassFactory.makeObjClass(_CswNbtResources, CreatedMetaDataObjectClass);
if (!(CreatedObjClass is CswNbtPropertySetGeneratorTarget))
{
throw new CswDniException("CswNbtActGenerateNodes got an invalid object class: " + CreatedObjClass.ObjectClass.ToString());
}
CswNbtPropertySetGeneratorTarget GeneratorTarget = (CswNbtPropertySetGeneratorTarget)CreatedObjClass;
// CreatedForNTP is the parent or owner of the new node. Inspections created for Inspection Targets, Tasks for Equipment, etc.
CswNbtMetaDataNodeTypeProp CreatedForNTP = CreatedNodeType.getNodeTypePropByObjectClassProp(GeneratorTarget.ParentPropertyName);
CswNbtMetaDataNodeTypeProp GeneratorNTP = CreatedNodeType.getNodeTypePropByObjectClassProp(CswNbtPropertySetGeneratorTarget.PropertyName.Generator);
CswNbtMetaDataNodeTypeProp DueDateNTP = CreatedNodeType.getNodeTypePropByObjectClassProp(CswNbtPropertySetGeneratorTarget.PropertyName.DueDate);
CswNbtView CswNbtView = new CswNbtView(_CswNbtResources);
CswNbtView.ViewName = "Nodes for Generator";
CswNbtViewRelationship RootRelationship = CswNbtView.AddViewRelationship(CreatedNodeType, false);
CswNbtViewProperty CreatedForParentProp = CswNbtView.AddViewProperty(RootRelationship, CreatedForNTP);
CswNbtView.AddViewPropertyFilter(CreatedForParentProp, CswNbtFieldTypeRuleRelationship.SubFieldName.NodeID, CswEnumNbtFilterMode.Equals, ParentPk.PrimaryKey.ToString(), false);
CswNbtViewProperty GeneratorProp = CswNbtView.AddViewProperty(RootRelationship, GeneratorNTP);
CswNbtView.AddViewPropertyFilter(GeneratorProp, CswNbtFieldTypeRuleRelationship.SubFieldName.NodeID, CswEnumNbtFilterMode.Equals, CswNbtNodeGenerator.NodeId.PrimaryKey.ToString(), false);
CswNbtViewProperty DueDateProp = CswNbtView.AddViewProperty(RootRelationship, DueDateNTP);
//Case 24572
CswNbtView.AddViewPropertyFilter(DueDateProp, CswNbtFieldTypeRuleDateTime.SubFieldName.Value, CswEnumNbtFilterMode.Equals, TargetDateFilter, false);
ICswNbtTree ExistingNodesTree = _CswNbtResources.Trees.getTreeFromView(_CswNbtResources.CurrentNbtUser, CswNbtView, true, false, false);
if (ExistingNodesTree.getChildNodeCount() > 0)
{
ExistingNodesTree.goToNthChild(0);
ReturnVal = ExistingNodesTree.getNodeForCurrentPosition();
}
}
}
}
return(ReturnVal);
}//_getTargetNodeForGenerator
} // makeBatchOp()
/// <summary>
/// Create a new batch operation to handle future node generation
/// </summary>
/// <param name="GenNode">Generator Node</param>
/// <param name="FinalDate"></param>
public CswNbtObjClassBatchOp makeBatchOp(CswNbtNode GenNode, DateTime FinalDate)
{
CswNbtObjClassBatchOp BatchNode = null;
if (null != GenNode)
{
CswNbtObjClassGenerator GeneratorNode = (CswNbtObjClassGenerator)GenNode;
// BZ 6752 - The first future node is the first node generated
// after today + warning days, according to the time interval
// But it has to include initial due date, no matter what the time interval.
CswNbtNodePropTimeInterval NextDueDateTimeInterval = GeneratorNode.DueDateInterval;
Double WarningDays = 0;
if (GeneratorNode.WarningDays.Value > 0)
{
WarningDays = GeneratorNode.WarningDays.Value;
}
DateTime StartDate = DateTime.Now.AddDays(WarningDays).Date; //bz# 6937 (capture date only, not time)
DateTime DateOfNextOccurance = DateTime.MinValue;
if (GeneratorNode.DueDateInterval.getStartDate().Date >= StartDate) //bz # 6937 (change gt to gteq)
{
DateOfNextOccurance = GeneratorNode.DueDateInterval.getStartDate().Date;
}
else
{
DateOfNextOccurance = NextDueDateTimeInterval.getNextOccuranceAfter(StartDate);
}
// Determine number of iterations
Int32 StartingCount = 0;
DateTime ThisDate = DateOfNextOccurance;
while (ThisDate != DateTime.MinValue &&
ThisDate.Date <= FinalDate &&
(GeneratorNode.FinalDueDate.Empty || ThisDate.Date <= GeneratorNode.FinalDueDate.DateTimeValue.Date))
{
StartingCount++;
ThisDate = GeneratorNode.DueDateInterval.getNextOccuranceAfter(ThisDate);
}
FutureNodesBatchData BatchData = new FutureNodesBatchData(string.Empty);
BatchData.GeneratorNodeId = GenNode.NodeId;
BatchData.NextStartDate = DateOfNextOccurance;
BatchData.FinalDate = FinalDate;
BatchData.StartingCount = StartingCount;
BatchData.IterationCount = 0;
BatchNode = CswNbtBatchManager.makeNew(_CswNbtResources, _BatchOpName, BatchData.ToString());
} // if(null != GeneratorNode)
return(BatchNode);
} // makeBatchOp()
public void updateNextDueDateTest_FinalDueDateBeforeNextDueDate()
{
DayOfWeek FiveDaysFromNow = DateTime.Today.AddDays(5).DayOfWeek;
CswNbtObjClassGenerator GeneratorNode = TestData.Nodes.createGeneratorNode(CswEnumRateIntervalType.WeeklyByDay, Days: new SortedList {
{ FiveDaysFromNow, FiveDaysFromNow }
}, WarningDays: 1);
CswNbtObjClassGenerator ExistingGen = TestData.CswNbtResources.Nodes[GeneratorNode.NodeId];
ExistingGen.FinalDueDate.DateTimeValue = DateTime.Today;
ExistingGen.postChanges(false);
Assert.AreEqual(DateTime.MinValue, ExistingGen.NextDueDate.DateTimeValue);
}
public void updateNextDueDateTest_NextDueDateEqualsStartDate()
{
DayOfWeek ThreeDaysFromNow = DateTime.Today.AddDays(3).DayOfWeek;
CswNbtObjClassGenerator GeneratorNode = TestData.Nodes.createGeneratorNode(CswEnumRateIntervalType.WeeklyByDay, Days: new SortedList {
{ ThreeDaysFromNow, ThreeDaysFromNow }
}, StartDate: DateTime.Today.AddDays(3), WarningDays: 5);
Assert.AreEqual(GeneratorNode.DueDateInterval.getStartDate(), GeneratorNode.NextDueDate.DateTimeValue);
CswNbtObjClassGenerator ExistingGen = TestData.CswNbtResources.Nodes[GeneratorNode.NodeId];
ExistingGen.updateNextDueDate(ForceUpdate: true, DeleteFutureNodes: false);
Assert.AreEqual(DateTime.Today.AddDays(10), ExistingGen.NextDueDate.DateTimeValue);
}
public CswNbtView getTreeViewOfFutureNodes(IEnumerable GeneratorNodes)
{
CswNbtView ReturnVal = new CswNbtView(_CswNbtResources);
ReturnVal.ViewName = "All Future Nodes";
CswNbtMetaDataObjectClass GeneratorObjectClass = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.GeneratorClass);
CswNbtViewRelationship GeneratorRelationship = ReturnVal.AddViewRelationship(GeneratorObjectClass, false);
ArrayList TargetNodeTypeIds = new ArrayList();
foreach (CswNbtNode CurrentGeneratorNode in GeneratorNodes)
{
GeneratorRelationship.NodeIdsToFilterIn.Add(CurrentGeneratorNode.NodeId);
CswNbtObjClassGenerator Generator = CurrentGeneratorNode;
foreach (String nodeTypeId in Generator.TargetType.SelectedNodeTypeIds)
{
Int32 CurrentTargetNodeTypeId = CswConvert.ToInt32(nodeTypeId);
if (!(TargetNodeTypeIds.Contains(CurrentTargetNodeTypeId)))
{
TargetNodeTypeIds.Add(CurrentTargetNodeTypeId);
}
}
}
foreach (Int32 TargetNodeTypeId in TargetNodeTypeIds)
{
CswNbtMetaDataNodeType TargetNodeType = _CswNbtResources.MetaData.getNodeType(TargetNodeTypeId);
if (TargetNodeType != null)
{
CswNbtMetaDataObjectClass TargetObjectClass = TargetNodeType.getObjectClass();
CswNbtObjClass TargetObjClass = CswNbtObjClassFactory.makeObjClass(_CswNbtResources, TargetObjectClass);
if (!(TargetObjClass is CswNbtPropertySetGeneratorTarget))
{
throw new CswDniException("CswNbtActGenerateFutureNodes.getTreeViewOfFutureNodes() got an invalid object class: " + TargetObjectClass.ObjectClass);
}
CswNbtViewRelationship TargetRelationship = ReturnVal.AddViewRelationship(GeneratorRelationship, CswEnumNbtViewPropOwnerType.Second, TargetNodeType.getNodeTypePropByObjectClassProp(CswNbtPropertySetGeneratorTarget.PropertyName.Generator), false);
CswNbtViewProperty IsFutureFlagProperty = ReturnVal.AddViewProperty(TargetRelationship, TargetNodeType.getNodeTypePropByObjectClassProp(CswNbtPropertySetGeneratorTarget.PropertyName.IsFuture));
CswNbtViewPropertyFilter IsFutureFilter = ReturnVal.AddViewPropertyFilter(IsFutureFlagProperty, CswNbtFieldTypeRuleLogical.SubFieldName.Checked, CswEnumNbtFilterMode.Equals, CswEnumTristate.True, false);
}
}
return(ReturnVal);
}//getTreeViewOfFutureNodes()
public CswNbtObjClassBatchOp makeNodesBatch(CswNbtNode CswNbtNodeGenerator, DateTime FutureDate)
{
CswNbtObjClassBatchOp BatchNode = null;
CswNbtObjClassGenerator GeneratorNode = CswNbtNodeGenerator;
Int32 TargetNodeTypeId = CswConvert.ToInt32(GeneratorNode.TargetType.SelectedNodeTypeIds);
// Must have create permissions on this generator's target's nodetype
if (_CswNbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Create, _CswNbtResources.MetaData.getNodeType(TargetNodeTypeId)))
{
deleteExistingFutureNodes(CswNbtNodeGenerator);
// Send to background task
CswNbtBatchOpFutureNodes BatchOp = new CswNbtBatchOpFutureNodes(_CswNbtResources);
BatchNode = BatchOp.makeBatchOp(CswNbtNodeGenerator, FutureDate);
}
return(BatchNode);
}
public void updateNextDueDateTest_ForceUpdateRevert()
{
CswNbtObjClassGenerator GeneratorNode = TestData.Nodes.createGeneratorNode(CswEnumRateIntervalType.MonthlyByDate);
CswNbtObjClassGenerator ExistingGen = TestData.CswNbtResources.Nodes[GeneratorNode.NodeId];
ExistingGen.updateNextDueDate(ForceUpdate: true, DeleteFutureNodes: false);
ExistingGen.postChanges(true);
Assert.AreEqual(getNextDate(15).AddMonths(1), ExistingGen.NextDueDate.DateTimeValue);
DateTime LastDueDate = ExistingGen.DueDateInterval.getLastOccuranceBefore(ExistingGen.NextDueDate.DateTimeValue);
if (LastDueDate > DateTime.Today)
{
ExistingGen.NextDueDate.DateTimeValue = DateTime.Now;
ExistingGen.updateNextDueDate(ForceUpdate: true, DeleteFutureNodes: false);
ExistingGen.postChanges(true);
}
Assert.AreEqual(getNextDate(15), ExistingGen.NextDueDate.DateTimeValue);
}
public void updateNextDueDateTest_FutureStartDateEnforced()
{
DateTime StartDate = DateTime.Today.AddDays(10);
CswNbtObjClassGenerator GeneratorNode = TestData.Nodes.createGeneratorNode(
CswEnumRateIntervalType.WeeklyByDay,
Days: new SortedList
{
{ DayOfWeek.Monday, DayOfWeek.Monday },
{ DayOfWeek.Wednesday, DayOfWeek.Wednesday },
{ DayOfWeek.Friday, DayOfWeek.Friday }
},
WarningDays: 0,
StartDate: StartDate);
CswNbtObjClassGenerator ExistingGen = TestData.CswNbtResources.Nodes[GeneratorNode.NodeId];
Assert.IsTrue(ExistingGen.NextDueDate.DateTimeValue >= StartDate,
"NextDueDate (" + ExistingGen.NextDueDate.DateTimeValue.ToShortDateString() + ") is not greater than StartDate (" + StartDate.ToShortDateString() + ").");
}
private void _processGenerator(CswNbtResources CswNbtResources, CswNbtObjClassGenerator CurrentGenerator)
{
try
{
// case 28069
// It should not be possible to make more than 24 nodes per parent in a single day,
// since the fastest interval is 1 hour, and we're not creating things into the past anymore.
// Therefore, disable anything that is erroneously spewing things.
if (CurrentGenerator.GeneratedNodeCount(DateTime.Today) >= (24 * CurrentGenerator.TargetParents.Count))
{
string Message = "Disabled due to error: Generated too many " + CurrentGenerator.TargetType.SelectedNodeTypeNames() + " targets in a single day";
_StatusMessage += Message + "; ";
CurrentGenerator.Enabled.Checked = CswEnumTristate.False;
CurrentGenerator.RunStatus.AddComment(Message);
CurrentGenerator.postChanges(false);
}
else
{
CswNbtActGenerateNodes CswNbtActGenerateNodes = new CswNbtActGenerateNodes(CswNbtResources);
bool Finished = CswNbtActGenerateNodes.makeNode(CurrentGenerator.Node);
if (Finished) // case 26111
{
string Message = "Created all " + CurrentGenerator.TargetType.SelectedNodeTypeNames() + " target(s) for " + CurrentGenerator.NextDueDate.DateTimeValue.Date.ToShortDateString();
CurrentGenerator.RunStatus.AddComment(Message);
CurrentGenerator.updateNextDueDate(ForceUpdate: true, DeleteFutureNodes: false);
CurrentGenerator.postChanges(false);
}
_StatusMessage += CurrentGenerator.Description.Text + "; ";
} // if-else( CurrentGenerator.GeneratedNodeCount( DateTime.Today ) >= 24 )
} //try
catch (Exception Exception)
{
string Message = "Unable to process generator " + CurrentGenerator.Description.Text + ", which will now be disabled, due to the following exception: " + Exception.Message;
_StatusMessage += Message + "; ";
CurrentGenerator.Enabled.Checked = CswEnumTristate.False;
CurrentGenerator.RunStatus.AddComment("Disabled due to exception: " + Exception.Message);
CurrentGenerator.postChanges(false);
CswNbtResources.logError(new CswDniException(Message));
}
}
/// <summary>
/// Generates a future IGeneratorTarget node. If an existing node has the same due date, no node is generated.
/// </summary>
/// <returns>True if a future node was generated</returns>
public bool makeNode(CswNbtNode CswNbtNodeGenerator, DateTime DueDate)
{
Int32 NodesCreated = 0;
CswNbtObjClassGenerator GeneratorNodeAsGenerator = (CswNbtObjClassGenerator)CswNbtNodeGenerator;
string SelectedNodeTypeIdStr = string.Empty;
Int32 SelectedNodeTypeId = Int32.MinValue;
if (0 < GeneratorNodeAsGenerator.TargetType.SelectedNodeTypeIds.Count)
{
SelectedNodeTypeIdStr = GeneratorNodeAsGenerator.TargetType.SelectedNodeTypeIds[0];
SelectedNodeTypeId = CswConvert.ToInt32(SelectedNodeTypeIdStr);
}
if (string.IsNullOrEmpty(SelectedNodeTypeIdStr) ||
"0" == SelectedNodeTypeIdStr ||
Int32.MinValue == SelectedNodeTypeId ||
null == _CswNbtResources.MetaData.getNodeType(SelectedNodeTypeId))
{
throw (new CswDniException("Generator node " + CswNbtNodeGenerator.NodeName + " (" + CswNbtNodeGenerator.NodeId.ToString() + ") does not have a valid nodetypeid"));
}
if (DueDate == DateTime.MinValue)
{
DueDate = GeneratorNodeAsGenerator.NextDueDate.DateTimeValue.Date;
}
if (DueDate == DateTime.MinValue)
{
DueDate = GeneratorNodeAsGenerator.DueDateInterval.getStartDate().Date;
}
string DateFilter = DueDate.ToShortDateString();
bool GeneratorBaseIsProperlyConfigured = (null != GeneratorNodeAsGenerator.Owner &&
null != GeneratorNodeAsGenerator.Owner.RelatedNodeId &&
null != _CswNbtResources.Nodes.GetNode(GeneratorNodeAsGenerator.Owner.RelatedNodeId) &&
GeneratorNodeAsGenerator.TargetType.SelectedNodeTypeIds.Count > 0);
if (false == GeneratorBaseIsProperlyConfigured)
{
throw new CswDniException(CswEnumErrorType.Error, "Cannot execute generator task if the generator does not have an owner and a target type.", "Generator node did not define both an Owner and a Target Type.");
}
// case 26111 - only generate a few at a time, and only increment NextDueDate when we're completely done
Int32 GeneratorTargetLimit = CswConvert.ToInt32(_CswNbtResources.ConfigVbls.getConfigVariableValue(CswEnumNbtConfigurationVariables.generatortargetlimit.ToString()));
if (Int32.MinValue == GeneratorTargetLimit)
{
GeneratorTargetLimit = 5;
}
foreach (CswPrimaryKey NewParentPk in GeneratorNodeAsGenerator.TargetParents)
{
if (null != NewParentPk && NodesCreated < GeneratorTargetLimit)
{
CswNbtPropertySetGeneratorTarget ExistingNode = null;
if (GeneratorNodeAsGenerator.DueDateInterval.RateInterval.RateType != CswEnumRateIntervalType.Hourly)
{
ExistingNode = _getTargetNodeForGenerator(CswNbtNodeGenerator, NewParentPk, DateFilter);
}
if (null == ExistingNode)
{
Collection <Int32> SelectedNodeTypeIds = GeneratorNodeAsGenerator.TargetType.SelectedNodeTypeIds.ToIntCollection();
foreach (Int32 refNodeTypeId in SelectedNodeTypeIds)
{
CswNbtMetaDataNodeType LatestVersionNT = _CswNbtResources.MetaData.getNodeType(refNodeTypeId).getNodeTypeLatestVersion();
//CswNbtPropertySetGeneratorTarget NewNode = _CswNbtResources.Nodes.makeNodeFromNodeTypeId( LatestVersionNT.NodeTypeId, CswEnumNbtMakeNodeOperation.DoNothing );
//NewNode.Node.copyPropertyValues( CswNbtNodeGenerator );
_CswNbtResources.Nodes.makeNodeFromNodeTypeId(LatestVersionNT.NodeTypeId, delegate(CswNbtNode NewNode)
{
NewNode.copyPropertyValues(CswNbtNodeGenerator);
CswNbtPropertySetGeneratorTarget NewTarget = NewNode;
NewTarget.DueDate.DateTimeValue = DueDate;
NewTarget.DueDate.setReadOnly(value: true, SaveToDb: true); //bz # 5349
NewTarget.Generator.RelatedNodeId = CswNbtNodeGenerator.NodeId;
NewTarget.Generator.CachedNodeName = CswNbtNodeGenerator.NodeName;
NewTarget.Parent.RelatedNodeId = NewParentPk;
//NewTaskNodeAsTask.Completed.Checked = Tristate.False;
if (MarkFuture)
{
NewTarget.IsFuture.Checked = CswEnumTristate.True;
}
else
{
NewTarget.IsFuture.Checked = CswEnumTristate.False;
}
if (null != onBeforeInsertNode)
{
onBeforeInsertNode(NewNode);
}
NodesCreated += 1;
NewNode.PendingUpdate = true;
//NewNode.postChanges( true );
});
} // foreach( Int32 refNodeTypeId in SelectedNodeTypeIds )
} //if ( null == ExistingNode )
else
{
if (false == MarkFuture)
{
if (ExistingNode.IsFuture.Checked == CswEnumTristate.True)
{
ExistingNode.IsFuture.Checked = CswEnumTristate.False;
}
}
else
{
if (DateTime.Now.Date >= ExistingNode.DueDate.DateTimeValue.Date)
{
ExistingNode.IsFuture.Checked = CswEnumTristate.False;
}
}
ExistingNode.postChanges(false); //BZ # 6961
} //if-else ( null == ExistingNode )
} // if( null != NewParentPk )
} // foreach( CswPrimaryKey NewParentPk in Parents )
// case 26111 - we're finished if we ran out of nodes to generate
return(NodesCreated < GeneratorTargetLimit);
} //makeNode()
public void updateNextDueDateTest_NewGenerator()
{
CswNbtObjClassGenerator GeneratorNode = TestData.Nodes.createGeneratorNode(CswEnumRateIntervalType.WeeklyByDay);
Assert.AreEqual(getNextDay(DayOfWeek.Monday), GeneratorNode.NextDueDate.DateTimeValue);
}