protected override bool onButtonClick(NbtButtonData ButtonData)
{
if (null != ButtonData.NodeTypeProp)
{
string OCPPropName = ButtonData.NodeTypeProp.getObjectClassPropName();
switch (OCPPropName)
{
case PropertyName.Request:
if (_CswNbtResources.Permit.can(CswEnumNbtActionName.Submit_Request))
{
ButtonData.Action = CswEnumNbtButtonAction.request;
CswNbtActRequesting RequestAct = new CswNbtActRequesting(_CswNbtResources);
CswNbtObjClassRequestItem RequestItem = RequestAct.makeEnterprisePartRequestItem(this, ButtonData);
ButtonData.Data["titleText"] = "Add to Cart: " + RequestItem.Type.Value;
ButtonData.Data["requestItemProps"] = RequestAct.getRequestItemAddProps(RequestItem.Node);
ButtonData.Data["requestItemNodeTypeId"] = RequestItem.NodeTypeId;
}
else
{
throw new CswDniException(CswEnumErrorType.Warning, "You do not have permission to the Submit Request action.", "You do not have permission to the Submit Request action.");
}
break;
}
}
return(true);
}
/// <summary>
/// Instance a new EnterprisePart Request Item
/// </summary>
public CswNbtObjClassRequestItem makeEnterprisePartRequestItem(CswNbtObjClassEnterprisePart EnterprisePart, CswNbtObjClass.NbtButtonData ButtonData)
{
checkForCentralInventoryGroups(_CswNbtResources);
CswNbtObjClassRequestItem RequestItem = null;
CswNbtMetaDataObjectClass RequestItemOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.RequestItemClass);
CswNbtMetaDataNodeType RequestItemNT = RequestItemOC.getNodeTypes().FirstOrDefault();
CswNbtSdTabsAndProps PropsAction = new CswNbtSdTabsAndProps(_CswNbtResources);
if (null != RequestItemNT)
{
RequestItem = PropsAction.getAddNodeAndPostChanges(RequestItemNT, delegate(CswNbtNode NewNode)
{
CswNbtObjClassRequestItem RequestItemNode = NewNode;
RequestItemNode.EnterprisePart.RelatedNodeId = EnterprisePart.NodeId;
RequestItemNode.Type.Value = CswNbtObjClassRequestItem.Types.EnterprisePart;
if (null != _ThisUser.DefaultLocationId)
{
CswNbtObjClassLocation DefaultAsLocation = _CswNbtResources.Nodes.GetNode(_ThisUser.DefaultLocationId);
if (null != DefaultAsLocation)
{
RequestItemNode.Location.SelectedNodeId = DefaultAsLocation.NodeId;
RequestItemNode.Location.CachedNodeName = DefaultAsLocation.Location.CachedNodeName;
RequestItemNode.Location.CachedPath = DefaultAsLocation.Location.CachedPath;
}
}
});
}
return(RequestItem);
}
protected override void OnEnable()
{
//Show the following Container properties...
// Requests
// Submitted Requests
CswNbtMetaDataObjectClass ContainerOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ContainerClass);
foreach (int NodeTypeId in ContainerOC.getNodeTypeIds().Keys)
{
_CswNbtResources.Modules.ShowProp(NodeTypeId, CswNbtObjClassContainer.PropertyName.Request);
_CswNbtResources.Modules.ShowProp(NodeTypeId, CswNbtObjClassContainer.PropertyName.SubmittedRequests);
}
//Show the following Inventory Group properties...
// Limit Request Delivery Location
CswNbtMetaDataObjectClass InventoryGroupOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.InventoryGroupClass);
foreach (int NodeTypeId in InventoryGroupOC.getNodeTypeIds().Keys)
{
_CswNbtResources.Modules.ShowProp(NodeTypeId, CswNbtObjClassInventoryGroup.PropertyName.LimitRequestDeliveryLocation);
}
//Show the following Location properties...
// Request Delivery Location
CswNbtMetaDataObjectClass LocationOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.LocationClass);
foreach (int NodeTypeId in LocationOC.getNodeTypeIds().Keys)
{
_CswNbtResources.Modules.ShowProp(NodeTypeId, CswNbtObjClassLocation.PropertyName.RequestDeliveryLocation);
}
//Show the following Material properties...
// Request Button
CswNbtMetaDataPropertySet MaterialSet = _CswNbtResources.MetaData.getPropertySet(CswEnumNbtPropertySetName.MaterialSet);
foreach (CswNbtMetaDataObjectClass MaterialOC in MaterialSet.getObjectClasses())
{
foreach (int NodeTypeId in MaterialOC.getNodeTypeIds().Keys)
{
_CswNbtResources.Modules.ShowProp(NodeTypeId, CswNbtObjClassChemical.PropertyName.Request);
}
}
//Show all views in the Requests category
_CswNbtResources.Modules.ToggleViewsInCategory(false, "Requests", CswEnumNbtViewVisibility.Global);
//Show the request fulfiller Role/User
_CswNbtResources.Modules.ToggleRoleNodes(false, "request_fulfiller");
_CswNbtResources.Modules.ToggleUserNodes(false, "request_fulfiller");
//TODO - Case 31274 - Add CISPro_Guardian Role/User to this list
// Case 28930 - Enable Scheduled Rules
_CswNbtResources.Modules.ToggleScheduledRule(CswEnumNbtScheduleRuleNames.GenRequest, Disabled: false);
//Case 31546 - If we're enabling Requesting AFTER MLM, we need to show the MLM props
if (_CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.MLM))
{
CswNbtObjClassRequestItem.ToggleMLMProps(_CswNbtResources, false);
}
}
}//importC3Product()
public static void CreateMaterialRequestFromC3(ICswResources CswResources, CswNbtC3CreateMaterialReturn Return, CswNbtC3Import.Request Request)
{
CswNbtResources NbtResources = (CswNbtResources)CswResources;
CswNbtMetaDataObjectClass RequestItemOC = NbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.RequestItemClass);
CswNbtMetaDataNodeType FirstRequestItemNT = RequestItemOC.getNodeTypes().FirstOrDefault();
if (null == FirstRequestItemNT)
{
throw new CswDniException(CswEnumErrorType.Error, "Cannot create a Create Material Request because there are no Request Item Types", "Cannot create a Create Material Request when there are no Request Item Nodetypes");
}
CswNbtObjClassRequestItem RequestItemNode = NbtResources.Nodes.makeNodeFromNodeTypeId(FirstRequestItemNT.NodeTypeId, IsTemp : true, OnAfterMakeNode : delegate(CswNbtNode NewNode)
{
CswNbtObjClassRequestItem AsRequestItem = NewNode;
AsRequestItem.Type.Value = CswNbtObjClassRequestItem.Types.MaterialCreate;
AsRequestItem.C3CDBRegNo.Value = Request.Cdbregno;
AsRequestItem.C3ProductId.Value = Request.C3ProductId;
AsRequestItem.NewMaterialTradename.Text = "TEST THING";
});
//RequestItemNode.NewMaterialSupplier.setHidden( true, true );
//RequestItemNode.NewMaterialTradename.setHidden( true, true );
//RequestItemNode.NewMaterialPartNo.setHidden( true, true );
//RequestItemNode.Location.setHidden( true, true );
//RequestItemNode.postChanges( false );
Return.Data.state = new C3CreateMaterialResponse.State();
Return.Data.state.materialType = new C3CreateMaterialResponse.State.MaterialType();
Return.Data.state.materialId = RequestItemNode.NodeId.ToString();
Return.Data.state.materialType.name = FirstRequestItemNT.NodeTypeName;
Return.Data.state.materialType.val = FirstRequestItemNT.NodeTypeId;
}
protected CswNbtRequestItemType(CswNbtResources CswNbtResources, CswNbtObjClassRequestItem RequestItem)
{
_CswNbtResources = CswNbtResources;
_RequestItem = RequestItem;
//Set RequestItemType explicitly in the constructor in case the referenced RequestItem object's Type value changes
RequestItemType = _RequestItem.Type.Value;
}
/// <summary>
/// WCF method to fulfill a Move Containers request
/// </summary>
public static void fulfillContainerMoveRequest(ICswResources CswResources, CswNbtRequestDataModel.CswRequestReturn Ret, CswNbtRequestDataModel.RequestFulfill Request)
{
CswNbtResources NbtResources = _validate(CswResources);
CswNbtObjClassRequestItem RequestItem = NbtResources.Nodes[Request.RequestItemId];
if (null != RequestItem)
{
Int32 ContainersMoved = moveContainers(NbtResources, RequestItem, Request);
Ret.Data.Succeeded = ContainersMoved > 0;
if (Ret.Data.Succeeded)
{
if (CswTools.IsDouble(RequestItem.TotalMoved.Value))
{
RequestItem.TotalMoved.Value += ContainersMoved;
}
else
{
RequestItem.TotalMoved.Value = ContainersMoved;
}
RequestItem.Status.Value = CswNbtObjClassRequestItem.Statuses.Moved;
RequestItem.FulfillmentHistory.AddComment("Moved " + ContainersMoved + " containers to " +
CswNbtNode.getNodeLink(RequestItem.Location.SelectedNodeId, RequestItem.Location.CachedFullPath));
RequestItem.postChanges(ForceUpdate: false);
}
}
}
private bool _allRequestItemsCompleted(ICswNbtTree RequestItemTree)
{
bool allRequestItemsCompleted = true;
int RequestCount = RequestItemTree.getChildNodeCount();
if (RequestCount == 1)
{
RequestItemTree.goToNthChild(0);
if (RequestItemTree.getChildNodeCount() > 0)
{
for (Int32 N = 0; N < RequestItemTree.getChildNodeCount(); N += 1)
{
RequestItemTree.goToNthChild(N);
CswNbtObjClassRequestItem RequestItem = RequestItemTree.getNodeForCurrentPosition();
if (null != RequestItem)
{
if (CswNbtObjClassRequestItem.Statuses.Completed != RequestItem.Status.Value)
{
allRequestItemsCompleted = false;
}
}
RequestItemTree.goToParentNode();
}
}
}
return(allRequestItemsCompleted);
}
private void onSubmittedDatePropChange(CswNbtNodeProp NodeProp, bool Creating)
{
if (SubmittedDate.DateTimeValue != DateTime.MinValue)
{
ICswNbtTree Tree = _getRelatedRequestItemsTree(FilterByStatus: CswNbtObjClassRequestItem.Statuses.Pending);
int RequestCount = Tree.getChildNodeCount();
if (RequestCount == 1)
{
Tree.goToNthChild(0);
Int32 RequestItemNodeCount = Tree.getChildNodeCount();
if (RequestItemNodeCount > 0)
{
for (Int32 N = 0; N < RequestItemNodeCount; N += 1)
{
Tree.goToNthChild(N);
CswNbtObjClassRequestItem RequestItem = Tree.getNodeForCurrentPosition();
RequestItem.Status.Value = CswNbtObjClassRequestItem.Statuses.Submitted;
RequestItem.Request.RefreshNodeName();
RequestItem.Name.RecalculateReferenceValue();
RequestItem.postChanges(ForceUpdate: false);
Tree.goToParentNode();
}
}
}
}
}
public void resetCartCounts(CswNbtObjClassUser User)
{
if (null != User)
{
CswNbtObjClassUser.Cache UserCache = User.CurrentCache;
UserCache.CartCounts = new CswNbtObjClassUser.Cache.Cart();
CswNbtView ReqView = new CswNbtView(_CswNbtResources);
CswNbtMetaDataObjectClass RequestOc = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.RequestClass);
CswNbtViewRelationship RootVr = ReqView.AddViewRelationship(RequestOc, IncludeDefaultFilters: false);
CswNbtMetaDataObjectClassProp RequestorOcp = RequestOc.getObjectClassProp(CswNbtObjClassRequest.PropertyName.Requestor);
ReqView.AddViewPropertyAndFilter(RootVr, RequestorOcp, FilterMode: CswEnumNbtFilterMode.Equals, SubFieldName: CswEnumNbtSubFieldName.NodeID, Value: User.NodeId.PrimaryKey.ToString());
CswNbtMetaDataObjectClassProp RequestOcp = _RequestItemOC.getObjectClassProp(CswNbtObjClassRequestItem.PropertyName.Request);
CswNbtViewRelationship RequestItemRel = ReqView.AddViewRelationship(RootVr,
CswEnumNbtViewPropOwnerType.Second,
RequestOcp, IncludeDefaultFilters: false);
ICswNbtTree Tree = _CswNbtResources.Trees.getTreeFromView(ReqView, IncludeSystemNodes: false, RequireViewPermissions: false, IncludeHiddenNodes: false);
Int32 RequestCount = Tree.getChildNodeCount();
if (RequestCount > 0)
{
for (Int32 R = 0; R < RequestCount; R += 1)
{
Tree.goToNthChild(R);
CswNbtObjClassRequest Request = Tree.getNodeForCurrentPosition();
if (Request.IsFavorite.Checked == CswEnumTristate.True)
{
UserCache.CartCounts.FavoriteRequestItems += Tree.getChildNodeCount();
}
else if (Request.IsRecurring.Checked == CswEnumTristate.True)
{
UserCache.CartCounts.RecurringRequestItems += Tree.getChildNodeCount();
}
else
{
for (Int32 I = 0; I < Tree.getChildNodeCount(); I += 1)
{
Tree.goToNthChild(I);
CswNbtObjClassRequestItem RequestItem = Tree.getNodeForCurrentPosition();
if (RequestItem.Status.Text == CswNbtObjClassRequestItem.Statuses.Pending)
{
UserCache.CartCounts.PendingRequestItems += 1;
}
else//Won't this also include completed and cancelled Request Items? Is that what we want?
{
UserCache.CartCounts.SubmittedRequestItems += 1;
}
Tree.goToParentNode();
}
}
Tree.goToParentNode();
}
}
User.CurrentCache = UserCache;
User.postChanges(ForceUpdate: false);
}
}
private bool _doesRequestItemCopyNow(CswNbtObjClassRequestItem CurrentRequestItem)
{
//A lot of these checks seem excessive...
return(null != CurrentRequestItem && // The Request Item isn't null
CurrentRequestItem.IsRecurring.Checked == CswEnumTristate.True && // This is actually a recurring request
false == CurrentRequestItem.RecurringFrequency.Empty && // The recurring frequency has been defined
(CurrentRequestItem.RecurringFrequency.RateInterval.RateType != CswEnumRateIntervalType.Hourly || // Recurring on any frequency other than hourly
(CurrentRequestItem.NextReorderDate.DateTimeValue.Date <= DateTime.Today && // Recurring no more than once per hour
DateTime.Now.AddHours(1).Subtract(CurrentRequestItem.NextReorderDate.DateTimeValue).Hours >= 1)));
}
private void _processRequest(String RequestItemId, CswNbtPropertySetMaterial Material)
{
CswNbtObjClassRequestItem RequestItemMaterialCreate = _CswNbtResources.Nodes[RequestItemId];
RequestItemMaterialCreate.Material.RelatedNodeId = Material.NodeId;
RequestItemMaterialCreate.Status.Value = CswNbtObjClassRequestItem.Statuses.Created;
RequestItemMaterialCreate.Type.Value = CswNbtObjClassRequestItem.Types.MaterialBulk;
RequestItemMaterialCreate.FulfillmentHistory.AddComment("Created " + Material.Node.NodeLink);
RequestItemMaterialCreate.postChanges(ForceUpdate: false);
}
/// <summary>
/// Returns a view used to show the containers available for dispense for the given Request Item
/// </summary>
/// <returns></returns>
public CswNbtView getDispensibleContainersView(CswPrimaryKey RequestItemId)
{
CswNbtView Ret = new CswNbtView(_CswNbtResources);
CswNbtObjClassRequestItem NodeAsRequestItem = _CswNbtResources.Nodes[RequestItemId];
if (null != NodeAsRequestItem)
{
//TODO - if we're dispensing a specific container or EP, we don't care about the specific material
CswNbtNode TargetNode = _CswNbtResources.Nodes[NodeAsRequestItem.Target.RelatedNodeId];
if (null != TargetNode)
{
Ret.ViewName = "Containers of " + TargetNode.NodeName;
Ret.ViewMode = CswEnumNbtViewRenderingMode.Grid;
Ret.Category = "Dispensing";
CswNbtMetaDataObjectClass ContainerOc = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ContainerClass);
CswNbtViewRelationship ContainerRel = Ret.AddViewRelationship(ContainerOc, true);
CswNbtViewProperty BarcodeVp = Ret.AddViewProperty(ContainerRel, ContainerOc.getObjectClassProp(CswNbtObjClassContainer.PropertyName.Barcode));
//Filter Containers by Materials in Requested EP
if (NodeAsRequestItem.Type.Value == CswNbtObjClassRequestItem.Types.EnterprisePart)
{
CswCommaDelimitedString EPMaterialPks = _getMaterialPKsForEP(NodeAsRequestItem.EnterprisePart.RelatedNodeId);
Ret.AddViewPropertyAndFilter(ContainerRel, ContainerOc.getObjectClassProp(CswNbtObjClassContainer.PropertyName.Material), SubFieldName: CswEnumNbtSubFieldName.NodeID, FilterMode: CswEnumNbtFilterMode.In, Value: EPMaterialPks.ToString(), ShowInGrid: false);
}
else//Filters Containers by Requested Material
{
Ret.AddViewPropertyAndFilter(ContainerRel, ContainerOc.getObjectClassProp(CswNbtObjClassContainer.PropertyName.Material), SubFieldName: CswEnumNbtSubFieldName.NodeID, Value: TargetNode.NodeId.PrimaryKey.ToString(), ShowInGrid: false);
}
Ret.AddViewPropertyAndFilter(ContainerRel, ContainerOc.getObjectClassProp(CswNbtObjClassContainer.PropertyName.Missing), FilterMode: CswEnumNbtFilterMode.NotEquals, Value: CswEnumTristate.True, ShowInGrid: false);
Ret.AddViewPropertyAndFilter(ContainerRel, ContainerOc.getObjectClassProp(CswNbtObjClassContainer.PropertyName.Quantity), SubFieldName: CswEnumNbtSubFieldName.Value, FilterMode: CswEnumNbtFilterMode.GreaterThan, Value: "0");
Ret.AddViewPropertyAndFilter(ContainerRel, ContainerOc.getObjectClassProp(CswNbtObjClassContainer.PropertyName.Status), FilterMode: CswEnumNbtFilterMode.NotEquals, Value: CswEnumNbtContainerStatuses.Expired, ShowInGrid: false);
Ret.AddViewProperty(ContainerRel, ContainerOc.getObjectClassProp(CswNbtObjClassContainer.PropertyName.Location));
CswNbtMetaDataObjectClass LocationOc = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.LocationClass);
CswNbtMetaDataObjectClassProp InventoryGroupOcp = LocationOc.getObjectClassProp(CswNbtObjClassLocation.PropertyName.InventoryGroup);
CswNbtViewRelationship LocationVr = Ret.AddViewRelationship(ContainerRel, CswEnumNbtViewPropOwnerType.First, ContainerOc.getObjectClassProp(CswNbtObjClassContainer.PropertyName.Location), IncludeDefaultFilters: true);
if (CswTools.IsPrimaryKey(NodeAsRequestItem.InventoryGroup.RelatedNodeId)) //Filter by Inventory Group
{
Ret.AddViewPropertyAndFilter(LocationVr, InventoryGroupOcp, SubFieldName: CswEnumNbtSubFieldName.NodeID, Value: NodeAsRequestItem.InventoryGroup.RelatedNodeId.PrimaryKey.ToString(), ShowInGrid: false);
}
else
{
Ret.AddViewPropertyAndFilter(LocationVr, InventoryGroupOcp, SubFieldName: CswEnumNbtSubFieldName.NodeID, FilterMode: CswEnumNbtFilterMode.Null, ShowInGrid: false);
}
if (NodeAsRequestItem.Type.Value == CswNbtObjClassRequestItem.Types.MaterialSize) //Filter By Size (if present)
{
Ret.AddViewPropertyAndFilter(ContainerRel, ContainerOc.getObjectClassProp(CswNbtObjClassContainer.PropertyName.Size), SubFieldName: CswEnumNbtSubFieldName.NodeID, Value: NodeAsRequestItem.Size.RelatedNodeId.PrimaryKey.ToString(), ShowInGrid: false);
}
}
}
return(Ret);
}
protected override void afterPromoteNodeLogic()
{
CswNbtObjClassRequestItem RequestItemNode = _CswNbtResources.Nodes[RequestItem.RelatedNodeId];
if (null != RequestItemNode)
{
RequestItemNode.FulfillmentHistory.AddComment("Received " + Node.NodeLink);
RequestItemNode.Status.Value = CswNbtObjClassRequestItem.Statuses.Received;
RequestItemNode.postChanges(false);
}
}
/// <summary>
/// Instance a new Container Request Item based on the selected button option - the type will either be Dispense, Move, or Dispose.
/// </summary>
public CswNbtObjClassRequestItem makeContainerRequestItem(CswNbtObjClassContainer Container, CswNbtObjClass.NbtButtonData ButtonData)
{
checkForCentralInventoryGroups(_CswNbtResources);
CswNbtObjClassRequestItem RequestItem;
CswNbtMetaDataObjectClass RequestItemOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.RequestItemClass);
CswNbtMetaDataNodeType RequestItemNT = RequestItemOC.getNodeTypes().FirstOrDefault();
CswNbtSdTabsAndProps PropsAction = new CswNbtSdTabsAndProps(_CswNbtResources);
RequestItem = PropsAction.getAddNodeAndPostChanges(RequestItemNT, delegate(CswNbtNode NewNode)
{
CswNbtObjClassRequestItem RequestItemNode = NewNode;
if (null != getCurrentRequestNodeId() && null != Container)
{
RequestItemNode.Container.RelatedNodeId = Container.NodeId;
RequestItemNode.Material.RelatedNodeId = Container.Material.RelatedNodeId;
CswPrimaryKey SelectedLocationId = CswTools.IsPrimaryKey(_ThisUser.DefaultLocationId) ?
_ThisUser.DefaultLocationId :
Container.Location.SelectedNodeId;
ButtonData.Action = CswEnumNbtButtonAction.request;
switch (ButtonData.SelectedText)
{
case CswEnumNbtContainerRequestMenu.Dispense:
RequestItemNode.Type.Value = CswNbtObjClassRequestItem.Types.ContainerDispense;
RequestItemNode.Quantity.UnitId = Container.Quantity.UnitId;
RequestItemNode.Size.RelatedNodeId = Container.Size.RelatedNodeId;
RequestItemNode.Location.SelectedNodeId = SelectedLocationId;
//Scope available units of measure on Quantity based on the Container's Material
CswNbtNode MaterialNode = _CswNbtResources.Nodes[Container.Material.RelatedNodeId];
if (null != MaterialNode)
{
CswNbtUnitViewBuilder Vb = new CswNbtUnitViewBuilder(_CswNbtResources);
Vb.setQuantityUnitOfMeasureView(MaterialNode, RequestItemNode.Quantity);
}
break;
case CswEnumNbtContainerRequestMenu.Dispose:
RequestItemNode.Type.Value = CswNbtObjClassRequestItem.Types.ContainerDispose;
RequestItemNode.Location.SelectedNodeId = Container.Location.SelectedNodeId;
break;
case CswEnumNbtContainerRequestMenu.Move:
RequestItemNode.Type.Value = CswNbtObjClassRequestItem.Types.ContainerMove;
RequestItemNode.Location.SelectedNodeId = SelectedLocationId;
break;
}
RequestItemNode.Location.RefreshNodeName();
}
});
if (null == RequestItem)
{
throw new CswDniException(CswEnumErrorType.Error, "Could not generate a new request item.", "Failed to create a new Request Item node.");
}
return(RequestItem);
}
} // update()
private void _updateRequestItems( CswNbtMetaDataNodeType RequestItemNT, CswNbtMetaDataNodeTypeProp ItemNumberNTP )
{
CswNbtView RequestItems = _CswNbtSchemaModTrnsctn.makeNewView( "RequestItemsNoItemNo31861", CswEnumNbtViewVisibility.Hidden );
CswNbtViewRelationship Parent = RequestItems.AddViewRelationship( RequestItemNT, false );
RequestItems.AddViewPropertyAndFilter( Parent, ItemNumberNTP, FilterMode : CswEnumNbtFilterMode.Null );
ICswNbtTree RequestItemsTree = _CswNbtSchemaModTrnsctn.getTreeFromView( RequestItems, false );
for( int i = 0; i < RequestItemsTree.getChildNodeCount(); i++ )
{
RequestItemsTree.goToNthChild( i );
CswNbtObjClassRequestItem RequestItem = RequestItemsTree.getNodeForCurrentPosition();
RequestItem.ItemNumber.setSequenceValue();
RequestItem.postChanges( false );
RequestItemsTree.goToParentNode();
}
}
//updates total dispensed for all dispense request fulfillment actions
private void _onCreateFromRequestItem()
{
if( CswTools.IsPrimaryKey( RequestItem.RelatedNodeId ) )
{
CswNbtObjClassRequestItem RequestItemNode = _CswNbtResources.Nodes[RequestItem.RelatedNodeId];
if( null != RequestItemNode )
{
if( Type.Value == CswEnumNbtContainerDispenseType.Dispense.ToString() )
{
CswNbtUnitConversion Conversion = new CswNbtUnitConversion( _CswNbtResources, QuantityDispensed.UnitId, RequestItemNode.TotalDispensed.UnitId, RequestItemNode.Material.RelatedNodeId );
double DispensedQuantity = Conversion.convertUnit( QuantityDispensed.Quantity );
RequestItemNode.TotalDispensed.Quantity -= DispensedQuantity; // Subtracting a negative number in order to add
RequestItemNode.FulfillmentHistory.AddComment( "Dispensed " + QuantityDispensed.Gestalt + " into " + CswNbtNode.getNodeLink( DestinationContainer.RelatedNodeId, DestinationContainer.Gestalt ) );
RequestItemNode.Status.Value = CswNbtObjClassRequestItem.Statuses.Dispensed;
}
RequestItemNode.postChanges( false );
}
}
}
private static Int32 moveContainers(CswNbtResources NbtResources, CswNbtObjClassRequestItem RequestItem, CswNbtRequestDataModel.RequestFulfill Request)
{
Int32 Ret = 0;
if (null != RequestItem)
{
foreach (string ContainerId in Request.ContainerIds)
{
CswNbtObjClassContainer ContainerNode = NbtResources.Nodes[ContainerId];
if (null != ContainerNode)
{
ContainerNode.Location.SelectedNodeId = RequestItem.Location.SelectedNodeId;
ContainerNode.Location.RefreshNodeName();
ContainerNode.postChanges(ForceUpdate: false);
Ret += 1;
}
}
}
return(Ret);
}
/// <summary>
/// Instance a new Material Request Item based on the selected button option - the type will either be By Bulk or By Size.
/// </summary>
public CswNbtObjClassRequestItem makeMaterialRequestItem(CswNbtPropertySetMaterial Material, CswNbtObjClass.NbtButtonData ButtonData)
{
checkForCentralInventoryGroups(_CswNbtResources);
CswNbtObjClassRequestItem RequestItem = null;
CswNbtMetaDataObjectClass RequestItemOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.RequestItemClass);
CswNbtMetaDataNodeType RequestItemNT = RequestItemOC.getNodeTypes().FirstOrDefault();
CswNbtSdTabsAndProps PropsAction = new CswNbtSdTabsAndProps(_CswNbtResources);
if (null != RequestItemNT)
{
RequestItem = PropsAction.getAddNodeAndPostChanges(RequestItemNT, delegate(CswNbtNode NewNode)
{
CswNbtObjClassRequestItem RequestItemNode = NewNode;
RequestItemNode.Material.RelatedNodeId = Material.NodeId;
if (null != _ThisUser.DefaultLocationId)
{
CswNbtObjClassLocation DefaultAsLocation = _CswNbtResources.Nodes.GetNode(_ThisUser.DefaultLocationId);
if (null != DefaultAsLocation)
{
RequestItemNode.Location.SelectedNodeId = DefaultAsLocation.NodeId;
RequestItemNode.Location.CachedNodeName = DefaultAsLocation.Location.CachedNodeName;
RequestItemNode.Location.CachedPath = DefaultAsLocation.Location.CachedPath;
}
}
switch (ButtonData.SelectedText)
{
case CswNbtPropertySetMaterial.CswEnumRequestOption.Size:
RequestItemNode.Type.Value = CswNbtObjClassRequestItem.Types.MaterialSize;
break;
default: //Request by Bulk
RequestItemNode.Type.Value = CswNbtObjClassRequestItem.Types.MaterialBulk;
break;
}
});
}
return(RequestItem);
}
protected override bool onButtonClick( NbtButtonData ButtonData )
{
if( null != ButtonData.NodeTypeProp )
{
bool HasPermission = false;
string OCPPropName = ButtonData.NodeTypeProp.getObjectClassPropName();
switch( OCPPropName )
{
case PropertyName.Request:
if( _CswNbtResources.Permit.can( CswEnumNbtActionName.Submit_Request ) )
{
// Case CIS-52280
if( Obsolete.Checked == CswEnumTristate.True )
{
throw new CswDniException( CswEnumErrorType.Warning, "Can't request Material " + TradeName + " because it is obsolete.", "Material is obsolete" );
}
HasPermission = true;
CswNbtActRequesting RequestAct = new CswNbtActRequesting( _CswNbtResources );
CswNbtObjClassRequestItem RequestItem = RequestAct.makeMaterialRequestItem( this, ButtonData );
ButtonData.Data["requestaction"] = ButtonData.SelectedText;
//ButtonData.Data["requestaction"] = OCPPropName;
//Case 31298: Default Option Text "Request" != "Request By Bulk"
if( ButtonData.SelectedText == "Request" )
{
ButtonData.SelectedText = CswEnumRequestOption.Bulk;
}
ButtonData.Data["titleText"] = ButtonData.SelectedText + " for " + TradeName.Text;
ButtonData.Data["requestItemProps"] = RequestAct.getRequestItemAddProps( RequestItem.Node );
ButtonData.Data["requestItemNodeTypeId"] = RequestItem.NodeTypeId;
ButtonData.Data["relatednodeid"] = NodeId.ToString();
ButtonData.Action = CswEnumNbtButtonAction.request;
}
break;
case PropertyName.Receive:
if( _CswNbtResources.Permit.can( CswEnumNbtActionName.Receiving ) )
{
// Case CIS-52280
if( Obsolete.Checked == CswEnumTristate.True )
{
throw new CswDniException( CswEnumErrorType.Warning, "Can't receive Material " + TradeName + " because it is obsolete.", "Material is obsolete" );
}
HasPermission = true;
CswNbtActReceiving Act = new CswNbtActReceiving( _CswNbtResources, NodeId );
_CswNbtResources.setAuditActionContext( CswEnumNbtActionName.Receiving );
Action<CswNbtNode> After = delegate( CswNbtNode NewNode )
{
CswNbtObjClassContainer newContainer = NewNode;
//Case 29436
if( newContainer.isLocationInAccessibleInventoryGroup( _CswNbtResources.CurrentNbtUser.DefaultLocationId ) )
{
newContainer.Location.SelectedNodeId = _CswNbtResources.CurrentNbtUser.DefaultLocationId;
}
newContainer.Owner.RelatedNodeId = _CswNbtResources.CurrentNbtUser.UserId;
DateTime ExpirationDate = getDefaultExpirationDate( DateTime.Now );
if( DateTime.MinValue != ExpirationDate )
{
newContainer.ExpirationDate.DateTimeValue = ExpirationDate;
}
//Container.postChanges( false );
};
CswNbtObjClassContainer Container = Act.makeContainer( After );
ButtonData.Data["state"] = new JObject();
ButtonData.Data["state"]["materialId"] = NodeId.ToString();
ButtonData.Data["state"]["materialNodeTypeId"] = NodeTypeId;
ButtonData.Data["state"]["tradeName"] = TradeName.Text;
ButtonData.Data["state"]["nodeName"] = NodeName;
Int32 ContainerLimit = CswConvert.ToInt32( _CswNbtResources.ConfigVbls.getConfigVariableValue( CswEnumNbtConfigurationVariables.container_receipt_limit.ToString() ) );
ButtonData.Data["state"]["containerlimit"] = ContainerLimit;
ButtonData.Data["state"]["containerNodeId"] = Container.NodeId.ToString();
ButtonData.Data["state"]["containerNodeTypeId"] = Container.NodeTypeId;
bool customBarcodes = CswConvert.ToBoolean( _CswNbtResources.ConfigVbls.getConfigVariableValue( CswEnumNbtConfigurationVariables.custom_barcodes.ToString() ) );
ButtonData.Data["state"]["customBarcodes"] = customBarcodes;
ButtonData.Data["state"]["nodetypename"] = this.NodeType.NodeTypeName;
ButtonData.Data["state"]["containerAddLayout"] = Act.getContainerAddProps( Container );
onReceiveButtonClick( ButtonData );
_setCofAData( ButtonData );
ButtonData.Action = CswEnumNbtButtonAction.receive;
}
break;
case CswNbtObjClass.PropertyName.Save:
HasPermission = true;
break;
}
HasPermission = HasPermission || onPropertySetButtonClick( ButtonData );
if( false == HasPermission )
{
throw new CswDniException( CswEnumErrorType.Warning, "You do not have permission to the " + OCPPropName + " action.", "You do not have permission to the " + OCPPropName + " action." );
}
}
return true;
}
public CswNbtRequestItemTypeEnterprisePart(CswNbtResources CswNbtResources, CswNbtObjClassRequestItem RequestItem) : base(CswNbtResources, RequestItem)
{
}
public CswNbtRequestItemTypeMaterialCreate(CswNbtResources CswNbtResources, CswNbtObjClassRequestItem RequestItem) : base(CswNbtResources, RequestItem)
{
}
/// <summary>
/// Create an ObjClass instance for given ObjectClass and Node
/// </summary>
public static CswNbtObjClass makeObjClass(CswNbtResources CswNbtResources, CswNbtMetaDataObjectClass ObjectClass, CswNbtNode Node = null)
{
CswNbtObjClass ReturnVal = null;
switch (ObjectClass.ObjectClass)
{
case CswEnumNbtObjectClass.BalanceClass:
ReturnVal = new CswNbtObjClassBalance(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.BalanceConfigurationClass:
ReturnVal = new CswNbtObjClassBalanceConfiguration(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.BatchOpClass:
ReturnVal = new CswNbtObjClassBatchOp(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.BiologicalClass:
ReturnVal = new CswNbtObjClassBiological(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CertDefCharacteristicLimitClass:
ReturnVal = new CswNbtObjClassCertDefCharacteristicLimit(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CertDefSpecClass:
ReturnVal = new CswNbtObjClassCertDefSpec(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CertificateDefinitionClass:
ReturnVal = new CswNbtObjClassCertificateDefinition(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CertDefConditionClass:
ReturnVal = new CswNbtObjClassCertDefCondition(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CertDefSpecLevelClass:
ReturnVal = new CswNbtObjClassCertDefSpecLevel(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CofADocumentClass:
ReturnVal = new CswNbtObjClassCofADocument(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CofAMethodClass:
ReturnVal = new CswNbtObjClassCofAMethod(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CofAMethodTemplateClass:
ReturnVal = new CswNbtObjClassCofAMethodTemplate(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ContainerClass:
ReturnVal = new CswNbtObjClassContainer(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ContainerDispenseTransactionClass:
ReturnVal = new CswNbtObjClassContainerDispenseTransaction(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ContainerGroupClass:
ReturnVal = new CswNbtObjClassContainerGroup(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ContainerLocationClass:
ReturnVal = new CswNbtObjClassContainerLocation(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ControlZoneClass:
ReturnVal = new CswNbtObjClassControlZone(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.CustomerClass:
ReturnVal = new CswNbtObjClassCustomer(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DepartmentClass:
ReturnVal = new CswNbtObjClassDepartment(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DesignNodeTypeClass:
ReturnVal = new CswNbtObjClassDesignNodeType(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DesignNodeTypePropClass:
ReturnVal = new CswNbtObjClassDesignNodeTypeProp(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DesignNodeTypeTabClass:
ReturnVal = new CswNbtObjClassDesignNodeTypeTab(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DesignSequenceClass:
ReturnVal = new CswNbtObjClassDesignSequence(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DocumentClass:
ReturnVal = new CswNbtObjClassDocument(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.DSDPhraseClass:
ReturnVal = new CswNbtObjClassDSDPhrase(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.EnterprisePartClass:
ReturnVal = new CswNbtObjClassEnterprisePart(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.EquipmentAssemblyClass:
ReturnVal = new CswNbtObjClassEquipmentAssembly(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.EquipmentClass:
ReturnVal = new CswNbtObjClassEquipment(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.EquipmentTypeClass:
ReturnVal = new CswNbtObjClassEquipmentType(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.FeedbackClass:
ReturnVal = new CswNbtObjClassFeedback(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.FireClassExemptAmountClass:
ReturnVal = new CswNbtObjClassFireClassExemptAmount(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.FireClassExemptAmountSetClass:
ReturnVal = new CswNbtObjClassFireClassExemptAmountSet(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.GenericClass:
ReturnVal = new CswNbtObjClassGeneric(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.GHSClass:
ReturnVal = new CswNbtObjClassGHS(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.GHSClassificationClass:
ReturnVal = new CswNbtObjClassGHSClassification(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.GHSPhraseClass:
ReturnVal = new CswNbtObjClassGHSPhrase(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.GHSSignalWordClass:
ReturnVal = new CswNbtObjClassGHSSignalWord(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InspectionDesignClass:
ReturnVal = new CswNbtObjClassInspectionDesign(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InspectionRouteClass:
ReturnVal = new CswNbtObjClassInspectionRoute(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InspectionTargetClass:
ReturnVal = new CswNbtObjClassInspectionTarget(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InspectionTargetGroupClass:
ReturnVal = new CswNbtObjClassInspectionTargetGroup(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InventoryGroupClass:
ReturnVal = new CswNbtObjClassInventoryGroup(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InventoryGroupPermissionClass:
ReturnVal = new CswNbtObjClassInventoryGroupPermission(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.InventoryLevelClass:
ReturnVal = new CswNbtObjClassInventoryLevel(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.JurisdictionClass:
ReturnVal = new CswNbtObjClassJurisdiction(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.Level:
ReturnVal = new CswNbtObjClassLevel(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.LocationClass:
ReturnVal = new CswNbtObjClassLocation(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.LQNoClass:
ReturnVal = new CswNbtObjClassLQNo(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ManufacturerClass:
ReturnVal = new CswNbtObjClassManufacturer(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ManufacturerEquivalentPartClass:
ReturnVal = new CswNbtObjClassManufacturerEquivalentPart(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ChemicalClass:
ReturnVal = new CswNbtObjClassChemical(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MaterialComponentClass:
ReturnVal = new CswNbtObjClassMaterialComponent(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MaterialSynonymClass:
ReturnVal = new CswNbtObjClassMaterialSynonym(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MailReportClass:
ReturnVal = new CswNbtObjClassMailReport(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MailReportGroupClass:
ReturnVal = new CswNbtObjClassMailReportGroup(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MailReportGroupPermissionClass:
ReturnVal = new CswNbtObjClassMailReportGroupPermission(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MethodClass:
ReturnVal = new CswNbtObjClassMethod(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MethodCharacteristicClass:
ReturnVal = new CswNbtObjClassMethodCharacteristic(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.MethodConditionClass:
ReturnVal = new CswNbtObjClassMethodCondition(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.NonChemicalClass:
ReturnVal = new CswNbtObjClassNonChemical(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.PrinterClass:
ReturnVal = new CswNbtObjClassPrinter(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.PrintJobClass:
ReturnVal = new CswNbtObjClassPrintJob(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.PrintLabelClass:
ReturnVal = new CswNbtObjClassPrintLabel(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ProblemClass:
ReturnVal = new CswNbtObjClassProblem(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ReceiptLotClass:
ReturnVal = new CswNbtObjClassReceiptLot(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RegulatoryListClass:
ReturnVal = new CswNbtObjClassRegulatoryList(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RegulatoryListCasNoClass:
ReturnVal = new CswNbtObjClassRegulatoryListCasNo(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RegulatoryListMemberClass:
ReturnVal = new CswNbtObjClassRegulatoryListMember(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RegulatoryListListCodeClass:
ReturnVal = new CswNbtObjClassRegulatoryListListCode(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ReportClass:
ReturnVal = new CswNbtObjClassReport(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ReportGroupClass:
ReturnVal = new CswNbtObjClassReportGroup(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.ReportGroupPermissionClass:
ReturnVal = new CswNbtObjClassReportGroupPermission(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RequestClass:
ReturnVal = new CswNbtObjClassRequest(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RequestItemClass:
ReturnVal = new CswNbtObjClassRequestItem(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.RoleClass:
ReturnVal = new CswNbtObjClassRole(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.SDSDocumentClass:
ReturnVal = new CswNbtObjClassSDSDocument(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.TestingLabClass:
ReturnVal = new CswNbtObjClassTestingLab(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.GeneratorClass:
ReturnVal = new CswNbtObjClassGenerator(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.SizeClass:
ReturnVal = new CswNbtObjClassSize(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.TaskClass:
ReturnVal = new CswNbtObjClassTask(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.TestingLabUserAssignmentClass:
ReturnVal = new CswNbtObjClassTestingLabUserAssignment(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.TestingLabMethodAssignmentClass:
ReturnVal = new CswNbtObjClassTestingLabMethodAssignment(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.UnitOfMeasureClass:
ReturnVal = new CswNbtObjClassUnitOfMeasure(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.UserClass:
ReturnVal = new CswNbtObjClassUser(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.VendorClass:
ReturnVal = new CswNbtObjClassVendor(CswNbtResources, Node);
break;
case CswEnumNbtObjectClass.WorkUnitClass:
ReturnVal = new CswNbtObjClassWorkUnit(CswNbtResources, Node);
break;
default:
//ReturnVal = new CswNbtObjClassDefault( CswNbtResources, _CswNbtNode );
throw (new CswDniException("There is no NbtObjClass derivative for object class " + ObjectClass.ObjectClass.ToString()));
}//switch
return(ReturnVal);
} //makeObjClass()
}//initScheduleLogicDetail()
public void threadCallBack(ICswResources CswResources)
{
_LogicRunStatus = CswEnumScheduleLogicRunStatus.Running;
CswNbtResources _CswNbtResources = (CswNbtResources)CswResources;
_CswNbtResources.AuditContext = "Scheduler Task: " + RuleName;
if (CswEnumScheduleLogicRunStatus.Stopping != _LogicRunStatus)
{
try
{
if (_CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.Containers))
{
Int32 RequestsLimit = CswConvert.ToInt32(_CswNbtResources.ConfigVbls.getConfigVariableValue(CswEnumNbtConfigurationVariables.generatorlimit.ToString()));
if (RequestsLimit <= 0)
{
RequestsLimit = 1;
}
CswNbtActRequesting ActRequesting = new CswNbtActRequesting(_CswNbtResources);
CswNbtView AllRecurringRequests = ActRequesting.getDueRecurringRequestItemsView();
ICswNbtTree Tree = _CswNbtResources.Trees.getTreeFromView(AllRecurringRequests, RequireViewPermissions: false, IncludeSystemNodes: false, IncludeHiddenNodes: false);
Int32 TotalRequestsProcessed = 0;
string RequestDescriptions = string.Empty;
Int32 TotatRequests = Tree.getChildNodeCount();
for (Int32 ChildN = 0; (ChildN < TotatRequests && TotalRequestsProcessed < RequestsLimit) && (CswEnumScheduleLogicRunStatus.Stopping != _LogicRunStatus); ChildN++)
{
string Description = "";
try
{
Tree.goToNthChild(ChildN);
CswNbtObjClassRequestItem CurrentRequestItem = Tree.getNodeForCurrentPosition();
if (_doesRequestItemCopyNow(CurrentRequestItem))
{
Description = CurrentRequestItem.Description.StaticText;
CswNbtObjClassRequest RecurringRequest = _CswNbtResources.Nodes[CurrentRequestItem.Request.RelatedNodeId];
if (null != RecurringRequest)
{
CswNbtObjClassUser Requestor = _CswNbtResources.Nodes[RecurringRequest.Requestor.RelatedNodeId];
if (null != Requestor)
{
CswNbtObjClassRequestItem CopiedRequestItem = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(CurrentRequestItem.NodeTypeId, delegate(CswNbtNode NewNode)
{
// We'd get all of this for free if we used copyNode,
// but then we'd have to manually do as much work in the other direction:
// un-hiding properties, etc.
CswNbtActRequesting ThisUserAct = new CswNbtActRequesting(_CswNbtResources, Requestor);
CswNbtObjClassRequest UsersCartNode = ThisUserAct.getCurrentRequestNode();
if (null != UsersCartNode)
{
CswNbtObjClassRequestItem NewRequestItem = NewNode;
// Most importantly, put the new request item in the current cart
NewRequestItem.Request.RelatedNodeId = UsersCartNode.NodeId;
NewRequestItem.Requestor.RelatedNodeId = CurrentRequestItem.Requestor.RelatedNodeId;
NewRequestItem.Material.RelatedNodeId = CurrentRequestItem.Material.RelatedNodeId;
NewRequestItem.Material.CachedNodeName = CurrentRequestItem.Material.CachedNodeName;
NewRequestItem.InventoryGroup.RelatedNodeId = CurrentRequestItem.InventoryGroup.RelatedNodeId;
NewRequestItem.Location.SelectedNodeId = CurrentRequestItem.Location.SelectedNodeId;
NewRequestItem.Location.CachedPath = CurrentRequestItem.Location.CachedPath;
NewRequestItem.Comments.CommentsJson = CurrentRequestItem.Comments.CommentsJson;
NewRequestItem.Type.Value = CurrentRequestItem.Type.Value;
if (CurrentRequestItem.Type.Value == CswNbtObjClassRequestItem.Types.MaterialSize)
{
NewRequestItem.Size.RelatedNodeId = CurrentRequestItem.Size.RelatedNodeId;
NewRequestItem.Size.CachedNodeName = CurrentRequestItem.Size.CachedNodeName;
NewRequestItem.SizeCount.Value = CurrentRequestItem.SizeCount.Value;
}
else
{
NewRequestItem.Quantity.Quantity = CurrentRequestItem.Quantity.Quantity;
NewRequestItem.Quantity.CachedUnitName = CurrentRequestItem.Quantity.CachedUnitName;
NewRequestItem.Quantity.UnitId = CurrentRequestItem.Quantity.UnitId;
}
NewRequestItem.Status.Value = CswNbtObjClassRequestItem.Statuses.Pending;
NewRequestItem.postChanges(ForceUpdate: false);
CurrentRequestItem.NextReorderDate.DateTimeValue = CswNbtPropertySetSchedulerImpl.getNextDueDate(CurrentRequestItem.Node, CurrentRequestItem.NextReorderDate, CurrentRequestItem.RecurringFrequency, ForceUpdate: true);
CurrentRequestItem.postChanges(ForceUpdate: false);
}
});
}
RequestDescriptions += CurrentRequestItem.Description + "; ";
}
}
Tree.goToParentNode();
} // if ~( not null, is recurring and is due)
catch (Exception Exception)
{
string Message = "Unable to create recurring request " + Description + ", due to the following exception: " + Exception.Message;
RequestDescriptions += Message;
_CswNbtResources.logError(new CswDniException(Message));
} //catch
finally
{
TotalRequestsProcessed += 1;
}
} //iterate requests
string StatusMessage = "No Recurring Requests found to process";
if (TotalRequestsProcessed > 0)
{
StatusMessage = TotalRequestsProcessed.ToString() + " requests processed: " + RequestDescriptions;
}
_CswScheduleLogicDetail.StatusMessage = StatusMessage;
_LogicRunStatus = CswEnumScheduleLogicRunStatus.Succeeded; //last line
}
}//try
catch (Exception Exception)
{
_CswScheduleLogicDetail.StatusMessage = "CswScheduleLogicNbtGenRequests::threadCallBack() exception: " + Exception.Message + "; " + Exception.StackTrace;
_CswNbtResources.logError(new CswDniException(_CswScheduleLogicDetail.StatusMessage));
_LogicRunStatus = CswEnumScheduleLogicRunStatus.Failed;
} //catch
} //if we're not shutting down
} //threadCallBack()
protected override void OnEnable()
{
//Turn on all views in the MLM (demo) category
_CswNbtResources.Modules.ToggleViewsInCategory(false, "MLM (demo)", CswEnumNbtViewVisibility.Global);
//Case 27866/28156 on enable show Container props...
// Lot Controlled
// Requisitionable
// Reserved For
// Receipt Lot
CswNbtMetaDataObjectClass containerOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ContainerClass);
foreach (CswNbtMetaDataNodeType containerNT in containerOC.getNodeTypes())
{
_CswNbtResources.Modules.ShowProp(containerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.LotControlled);
_CswNbtResources.Modules.ShowProp(containerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.Requisitionable);
_CswNbtResources.Modules.ShowProp(containerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.ReservedFor);
//Case 30723 - Receipt Lot is only "semi-disabled" when MLM is off, so just add it back to the layout when it's enabled
CswNbtMetaDataNodeTypeProp ReceiptLotNTP = _CswNbtResources.MetaData.getNodeTypeProp(containerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.ReceiptLot);
if (null != ReceiptLotNTP)
{
CswNbtMetaDataNodeTypeProp StatusNTP = containerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Status);
ReceiptLotNTP.updateLayout(CswEnumNbtLayoutType.Edit, StatusNTP, true);
}
}
//Case 31546 - If requesting is disabled, we don't need to show anything on the Request Item OC because it is not available
if (_CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.Requesting))
{
CswNbtObjClassRequestItem.ToggleMLMProps(_CswNbtResources, false);
}
//Case 28339
// Show Vendor.VendorType and CorporateEntity
// Add a filter to Material.Supplier where VendorType = 'Coporate'
CswNbtMetaDataObjectClass vendorOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.VendorClass);
foreach (CswNbtMetaDataNodeType vendorNT in vendorOC.getNodeTypes())
{
_CswNbtResources.Modules.ShowProp(vendorNT.NodeTypeId, CswNbtObjClassVendor.PropertyName.VendorTypeName);
_CswNbtResources.Modules.ShowProp(vendorNT.NodeTypeId, CswNbtObjClassVendor.PropertyName.CorporateEntityName);
}
_toggleMaterialSupplierView(false);
_toggleReceiptLotManufacturerView(false);
setReceiptLotPermissions(_CswNbtResources, true);
//Case CIS-52280 on enable show Material props...
// Manufacturing Sites Grid
// Requires Cleaning Event
CswNbtMetaDataPropertySet materialPS = _CswNbtResources.MetaData.getPropertySet(CswEnumNbtPropertySetName.MaterialSet);
foreach (CswNbtMetaDataObjectClass materialOC in materialPS.getObjectClasses())
{
foreach (CswNbtMetaDataNodeType materialNT in materialOC.getNodeTypes())
{
_CswNbtResources.Modules.ShowProp(materialNT.NodeTypeId, CswNbtPropertySetMaterial.PropertyName.ManufacturingSites);
_CswNbtResources.Modules.ShowProp(materialNT.NodeTypeId, CswNbtPropertySetMaterial.PropertyName.RequiresCleaningEvent);
}
}
} // OnEnable()
} // OnEnable()
protected override void OnDisable()
{
//Turn on off views in the MLM (demo) category
_CswNbtResources.Modules.ToggleViewsInCategory(true, "MLM (demo)", CswEnumNbtViewVisibility.Global);
//Case 27866 on disable hide Container props...
// Lot Controlled
// Requisitionable
// Reserved For
CswNbtMetaDataObjectClass containerOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ContainerClass);
foreach (CswNbtMetaDataNodeType containerNT in containerOC.getNodeTypes())
{
_CswNbtResources.Modules.HideProp(containerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.LotControlled);
_CswNbtResources.Modules.HideProp(containerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.Requisitionable);
_CswNbtResources.Modules.HideProp(containerNT.NodeTypeId, CswNbtObjClassContainer.PropertyName.ReservedFor);
//if( null != cmgTab )
//{
// cmgTab.DesignNode.Node.delete( false, true );
//}
}
//Case 31546 - If requesting is disabled, we don't need to hide anything on the Request Item OC because it is not available
if (_CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.Requesting))
{
CswNbtObjClassRequestItem.ToggleMLMProps(_CswNbtResources, true);
}
//Case 28339
// Hide Vendor.VendorType and CorporateEntity
// Remove filter on Material.Supplier
CswNbtMetaDataObjectClass vendorOC = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.VendorClass);
foreach (CswNbtMetaDataNodeType vendorNT in vendorOC.getNodeTypes())
{
_CswNbtResources.Modules.HideProp(vendorNT.NodeTypeId, CswNbtObjClassVendor.PropertyName.VendorTypeName);
_CswNbtResources.Modules.HideProp(vendorNT.NodeTypeId, CswNbtObjClassVendor.PropertyName.CorporateEntityName);
}
CswNbtView newSupplierPropView = new CswNbtView(_CswNbtResources);
newSupplierPropView.saveNew("Supplier", CswEnumNbtViewVisibility.Property);
newSupplierPropView.AddViewRelationship(vendorOC, true);
newSupplierPropView.save();
_toggleMaterialSupplierView(true);
_toggleReceiptLotManufacturerView(true);
//Case CIS-52280 on disable hide Material props...
// Manufacturing Sites Grid
// Requires Cleaning Event
CswNbtMetaDataPropertySet materialPS = _CswNbtResources.MetaData.getPropertySet(CswEnumNbtPropertySetName.MaterialSet);
foreach (CswNbtMetaDataObjectClass materialOC in materialPS.getObjectClasses())
{
foreach (CswNbtMetaDataNodeType materialNT in materialOC.getNodeTypes())
{
_CswNbtResources.Modules.HideProp(materialNT.NodeTypeId, CswNbtPropertySetMaterial.PropertyName.ManufacturingSites);
_CswNbtResources.Modules.HideProp(materialNT.NodeTypeId, CswNbtPropertySetMaterial.PropertyName.RequiresCleaningEvent);
}
}
setReceiptLotPermissions(_CswNbtResources, false);
} // OnDisable()
public CswNbtRequestItemTypeContainerDispose(CswNbtResources CswNbtResources, CswNbtObjClassRequestItem RequestItem) : base(CswNbtResources, RequestItem)
{
}
public static CswNbtRequestItemType makeRequestItemType(CswNbtResources CswNbtResources, CswNbtObjClassRequestItem RequestItem)
{
string RequestItemType = RequestItem.Type.Value;
CswNbtRequestItemType TypeDef;
switch (RequestItemType)
{
case CswNbtObjClassRequestItem.Types.EnterprisePart:
TypeDef = new CswNbtRequestItemTypeEnterprisePart(CswNbtResources, RequestItem);
break;
case CswNbtObjClassRequestItem.Types.MaterialCreate:
TypeDef = new CswNbtRequestItemTypeMaterialCreate(CswNbtResources, RequestItem);
break;
case CswNbtObjClassRequestItem.Types.MaterialBulk:
TypeDef = new CswNbtRequestItemTypeMaterialByBulk(CswNbtResources, RequestItem);
break;
case CswNbtObjClassRequestItem.Types.MaterialSize:
TypeDef = new CswNbtRequestItemTypeMaterialBySize(CswNbtResources, RequestItem);
break;
case CswNbtObjClassRequestItem.Types.ContainerDispense:
TypeDef = new CswNbtRequestItemTypeContainerDispense(CswNbtResources, RequestItem);
break;
case CswNbtObjClassRequestItem.Types.ContainerDispose:
TypeDef = new CswNbtRequestItemTypeContainerDispose(CswNbtResources, RequestItem);
break;
case CswNbtObjClassRequestItem.Types.ContainerMove:
TypeDef = new CswNbtRequestItemTypeContainerMove(CswNbtResources, RequestItem);
break;
default:
throw new CswDniException(CswEnumErrorType.Error,
"Unhandled item type: " + RequestItemType,
"CswNbtRequestItemTypeFactory did not recognize item type: " + RequestItemType);
}
return(TypeDef);
}
