public static void ReceiveMaterial(ICswResources CswResources, CswNbtReceivingDefinitionReturn Response, CswNbtReceivingDefinition ReceivingDefiniton)
{
CswNbtResources NbtResources = (CswNbtResources)CswResources;
CswNbtActReceiving ActReceiving = new CswNbtActReceiving(NbtResources, ReceivingDefiniton.MaterialNodeId);
JObject ActionData = ActReceiving.receiveMaterial(ReceivingDefiniton);
Response.Data.ActionData = ActionData.ToString();
//Create Print Job
if (null != ReceivingDefiniton.PrintLabelId && null != ReceivingDefiniton.PrinterNodeId)
{
CswNbtObjClassContainer InitialContainer = NbtResources.Nodes.GetNode(ReceivingDefiniton.ContainerNodeId);
Collection <Dictionary <string, string> > PropVals = new Collection <Dictionary <string, string> >();
foreach (CswNbtAmountsGridQuantity Quant in ReceivingDefiniton.Quantities)
{
CswNbtObjClassUnitOfMeasure UoMNode = NbtResources.Nodes.GetNode(Quant.UnitNodeId);
for (int i = 0; i < Quant.NumContainers; i++)
{
Dictionary <string, string> vals = InitialContainer.Node.getPropertiesAndValues();
vals[InitialContainer.Barcode.PropName] = Quant.getBarcodes()[i];
vals[InitialContainer.Quantity.PropName] = Quant.Quantity + " " + UoMNode.BaseUnit.Text;
PropVals.Add(vals);
}
}
CswNbtWebServicePrintLabels.newPrintJob(CswResources, ReceivingDefiniton.PrinterNodeId, ReceivingDefiniton.PrintLabelId, ReceivingDefiniton.ContainerNodeId, PropVals);
}
}
public CswNbtContainerDispenser(CswNbtResources CswNbtResources, CswNbtContainerDispenseTransactionBuilder ContainerDispenseTransactionBuilder, CswNbtObjClassContainer Container, bool IsImport = false)
{
_CswNbtResources = CswNbtResources;
_ContainerDispenseTransactionBuilder = ContainerDispenseTransactionBuilder;
_Container = Container;
_IsImport = IsImport;
}
}//_dispense()
private void _reconcile(string operation, string barcode, JObject update, CswNbtObjClassBatchOp BatchNode)
{
try
{
string newLocationBarcode = update["location"].ToString();
CswNbtObjClassContainer containerNode = _getNodeFromBarcode(barcode, CswEnumNbtObjectClass.ContainerClass, CswNbtObjClassContainer.PropertyName.Barcode, false);
if (null != containerNode)
{
containerNode.CreateContainerLocationNode(CswEnumNbtContainerLocationTypeOptions.ReconcileScans, newLocationBarcode, barcode);
containerNode.Location.RefreshNodeName();
containerNode.postChanges(false);
}
else
{
string msg = _generateErrorMessage(operation, barcode, null, "A container with barcode " + barcode + " does not exist.");
_storeError(BatchNode, msg);
}
}
catch (Exception e)
{
string msg = "The reconcile operation failed for the container barcode " + barcode + "with exception: " + e;
_storeError(BatchNode, msg);
}
}//_reconcile()
private CswNbtObjClassContainer _createChildContainer(string ContainerNodeTypeId, CswPrimaryKey UnitId, string Barcode)
{
CswNbtObjClassContainer ChildContainer = null;
CswNbtMetaDataNodeType ContainerNT = _CswNbtResources.MetaData.getNodeType(CswConvert.ToInt32(ContainerNodeTypeId));
if (ContainerNT != null)
{
_CswNbtResources.Nodes.makeNodeFromNodeTypeId(ContainerNT.NodeTypeId, delegate(CswNbtNode CopyNode)
{
CopyNode.copyPropertyValues(_SourceContainer.Node);
ChildContainer = CopyNode;
if (false == String.IsNullOrEmpty(Barcode))
{
ChildContainer.Barcode.setBarcodeValueOverride(Barcode, false);
}
else
{
ChildContainer.Barcode.setBarcodeValue();
}
ChildContainer.ReceiptLot.RelatedNodeId = null;
ChildContainer.ExpirationDate.DateTimeValue = _SourceContainer.ExpirationDate.DateTimeValue;
ChildContainer.SourceContainer.RelatedNodeId = _SourceContainer.NodeId;
ChildContainer.Quantity.Quantity = 0;
ChildContainer.Quantity.UnitId = UnitId;
ChildContainer.Disposed.Checked = CswEnumTristate.False;
//ChildContainer.postChanges( false );
//ChildContainer.Undispose.setHidden( value: true, SaveToDb: true );
_ContainersToView.Add(ChildContainer.NodeId);
});
}
return(ChildContainer);
}
public CswNbtActDispenseContainer(CswNbtResources CswNbtResources, string SourceContainerNodeId, string DispenseTransactionId = null, string DispenseTransactionProperties = null)
{
_CswNbtResources = CswNbtResources;
_CswNbtSdTabsAndProps = new CswNbtSdTabsAndProps(_CswNbtResources);
if (false == String.IsNullOrEmpty(SourceContainerNodeId))
{
CswPrimaryKey SourceContainerPK = new CswPrimaryKey();
SourceContainerPK.FromString(SourceContainerNodeId);
_SourceContainer = _CswNbtResources.Nodes.GetNode(SourceContainerPK);
if (false == String.IsNullOrEmpty(DispenseTransactionId))
{
CswPrimaryKey ContainerDispenseTransactionId = new CswPrimaryKey();
ContainerDispenseTransactionId.FromString(DispenseTransactionId);
_TempDispenseTransaction = _CswNbtResources.Nodes.GetNode(ContainerDispenseTransactionId);
if (null != _TempDispenseTransaction)
{
_CswNbtSdTabsAndProps.saveProps(_TempDispenseTransaction.NodeId, Int32.MinValue, CswConvert.ToJObject(DispenseTransactionProperties), _TempDispenseTransaction.NodeTypeId, null, IsIdentityTab: false, setIsTempToFalse: false);
}
_SourceContainer.Dispenser = new CswNbtContainerDispenser(_CswNbtResources, new CswNbtContainerDispenseTransactionBuilder(_CswNbtResources, _TempDispenseTransaction), _SourceContainer);
}
}
else
{
throw new CswDniException(CswEnumErrorType.Error, "Cannot execute dispense contianer action with an undefined Source Container.", "Attempted to constuct CswNbtActDispenseContainer without a valid Source Container.");
}
if (false == _CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.CISPro))
{
throw new CswDniException(CswEnumErrorType.Error, "Cannot use the Dispense action without the required module.", "Attempted to constuct CswNbtActSubmitRequest without the required module.");
}
}
public JObject dispenseIntoChildContainers(string ContainerNodeTypeId, string DispenseGrid, string RequestItemId)
{
JObject ret = new JObject();
if (null != _SourceContainer)
{
CswPrimaryKey RequestItemPk = new CswPrimaryKey();
RequestItemPk.FromString(RequestItemId);
JArray GridArray = JArray.Parse(DispenseGrid);
JObject jBarcodes = new JObject();
ret["barcodes"] = jBarcodes;
for (Int32 i = 0; i < GridArray.Count; i += 1)
{
if (GridArray[i].Type == JTokenType.Object)
{
JObject CurrentRow = (JObject)GridArray[i];
int NumOfContainers = CswConvert.ToInt32(CurrentRow["containerNo"]);
double QuantityToDispense = CswConvert.ToDouble(CurrentRow["quantity"]);
string UnitId = CswConvert.ToString(CurrentRow["unitid"]);
CswCommaDelimitedString Barcodes = new CswCommaDelimitedString();
Barcodes.FromString(CswConvert.ToString(CurrentRow["barcodes"]));
CswPrimaryKey UnitOfMeasurePK = new CswPrimaryKey();
UnitOfMeasurePK.FromString(UnitId);
if (NumOfContainers == 0)
{
_SourceContainer.DispenseOut(
CswEnumNbtContainerDispenseType.Dispense, QuantityToDispense,
UnitOfMeasurePK, RequestItemPk);
_SourceContainer.postChanges(false);
}
else
{
for (Int32 c = 0; c < NumOfContainers; c += 1)
{
CswNbtObjClassContainer ChildContainer = _createChildContainer(ContainerNodeTypeId,
UnitOfMeasurePK, Barcodes[c]);
_SourceContainer.DispenseOut(
CswEnumNbtContainerDispenseType.Dispense, QuantityToDispense,
UnitOfMeasurePK, RequestItemPk, ChildContainer);
//ChildContainer.DispenseIn( CswEnumNbtContainerDispenseType.Dispense, QuantityToDispense, UnitOfMeasurePK, RequestItemPk, _SourceContainer );
ChildContainer.postChanges(false);
JObject BarcodeNode = new JObject();
jBarcodes[ChildContainer.NodeId.ToString()] = BarcodeNode;
BarcodeNode["nodeid"] = ChildContainer.NodeId.ToString();
BarcodeNode["nodename"] = ChildContainer.NodeName;
}
_SourceContainer.postChanges(false);
}
}
}
_SourceContainer.postChanges(false);
string ViewId = _getViewForAllDispenseContainers();
ret["viewId"] = ViewId;
}
return(ret);
}
private void _setContainerLocations()
{
IEnumerable <CswPrimaryKey> ContainerNodePks = this.getContainersInGroup();
if (ContainerNodePks.Count() > 0)
{
int BatchThreshold = CswNbtBatchManager.getBatchThreshold(_CswNbtResources);
if (ContainerNodePks.Count() > BatchThreshold)
{
// Shelve this to a batch operation
CswNbtBatchOpSyncLocation op = new CswNbtBatchOpSyncLocation(_CswNbtResources);
CswNbtObjClassBatchOp BatchNode = op.makeBatchOp(ContainerNodePks, this.Location.SelectedNodeId);
}
else
{
foreach (CswPrimaryKey CurrentContainerNodePk in ContainerNodePks)
{
CswNbtObjClassContainer CurrentContainer = _CswNbtResources.Nodes[CurrentContainerNodePk];
if (null != CurrentContainer)
{
CurrentContainer.Location.SelectedNodeId = this.Location.SelectedNodeId;
CurrentContainer.postChanges(false);
}
}
}
}
}
private void _executeReconciliationAction(CswNbtResources _CswNbtResources, CswNbtObjClassContainerLocation ContainerLocation)
{
CswNbtObjClassUser UserNode = _CswNbtResources.Nodes[ContainerLocation.ActionByUser.RelatedNodeId];
// case 30346 - use user's info for audit context
if (null != UserNode)
{
_CswNbtResources.AuditFirstName = UserNode.FirstName;
_CswNbtResources.AuditLastName = UserNode.LastName;
_CswNbtResources.AuditUsername = UserNode.Username;
}
CswNbtObjClassContainer Container = _CswNbtResources.Nodes[ContainerLocation.Container.RelatedNodeId];
if (null != Container)
{
CswEnumNbtContainerLocationActionOptions Action = ContainerLocation.Action.Value;
if (Action == CswEnumNbtContainerLocationActionOptions.Undispose ||
Action == CswEnumNbtContainerLocationActionOptions.UndisposeAndMove)
{
Container.UndisposeContainer(OverridePermissions: true, CreateContainerLocation: false);
}
if (Action == CswEnumNbtContainerLocationActionOptions.MoveToLocation ||
Action == CswEnumNbtContainerLocationActionOptions.UndisposeAndMove)
{
Container.Location.SelectedNodeId = ContainerLocation.Location.SelectedNodeId;
Container.Location.RefreshNodeName();
Container.Location.CreateContainerLocation = false;
}
Container.Missing.Checked = Action == CswEnumNbtContainerLocationActionOptions.MarkMissing
? CswEnumTristate.True
: CswEnumTristate.False;
Container.postChanges(false);
}
}
private void OnContainerScanPropChange( CswNbtNodeProp Prop, bool Creating )
{
if( null != ContainerScan.Text )
{
CswNbtMetaDataObjectClass ContainerOc = _CswNbtResources.MetaData.getObjectClass( CswEnumNbtObjectClass.ContainerClass );
CswNbtView ContainerView = new CswNbtView( _CswNbtResources );
CswNbtViewRelationship ContainerRel = ContainerView.AddViewRelationship( ContainerOc, false );
CswNbtMetaDataObjectClassProp BarcodeOcp = ContainerOc.getObjectClassProp( CswNbtObjClassContainer.PropertyName.Barcode );
ContainerView.AddViewPropertyAndFilter( ContainerRel, BarcodeOcp, ContainerScan.Text );
ICswNbtTree ContainerTree = _CswNbtResources.Trees.getTreeFromView( ContainerView, false, false, true );
if( ContainerTree.getChildNodeCount() > 0 )
{
ContainerTree.goToNthChild( 0 );
CswNbtObjClassContainer ContainerNode = ContainerTree.getNodeForCurrentPosition();
Container.RelatedNodeId = ContainerNode.NodeId;
}
else
{
Container.RelatedNodeId = null;
}
}
_setStatus();
}
public void processReconciliationActionsTestUndisposeAndMove()
{
CswPrimaryKey ContainerLocId, ContainerLocationLocId;
TestData.getTwoDifferentLocationIds(out ContainerLocId, out ContainerLocationLocId);
CswNbtObjClassContainer ContainerNode = TestData.Nodes.createContainerNode(LocationId: ContainerLocId);
ContainerNode.DisposeContainer();
Assert.AreEqual(CswEnumTristate.True, ContainerNode.Disposed.Checked.ToString());
CswNbtObjClassContainerLocation ContainerLocationNode = TestData.Nodes.createContainerLocationNode(
ContainerNode.Node,
CswEnumNbtContainerLocationActionOptions.UndisposeAndMove.ToString(),
LocationId: ContainerLocationLocId,
Type: CswEnumNbtContainerLocationTypeOptions.ReconcileScans.ToString());
Assert.AreNotEqual(ContainerLocationNode.Location.SelectedNodeId, ContainerNode.Location.SelectedNodeId);
Assert.AreEqual(CswEnumNbtContainerLocationStatusOptions.DisposedAtWrongLocation.ToString(), ContainerLocationNode.Status.Value);
CswScheduleLogicNbtContainerReconciliationActions Sched = _getReconciliationActionSched();
Sched.processReconciliationActions(TestData.CswNbtResources);
Assert.AreEqual(CswEnumTristate.True, ContainerLocationNode.ActionApplied.Checked.ToString());
Assert.AreEqual(ContainerLocationNode.Location.SelectedNodeId, ContainerNode.Location.SelectedNodeId);
Assert.AreEqual(CswEnumTristate.False, ContainerNode.Missing.Checked.ToString());
Assert.AreEqual(CswEnumTristate.False, ContainerNode.Disposed.Checked.ToString());
}
/// <summary>
/// Updates the default Expiration Date on containers to receive based on Receipt Lot's Manufactured Date
/// </summary>
public ContainerData.ReceivingData updateExpirationDate(ContainerData.ReceiptLotRequest Request)
{
ContainerData.ReceivingData ReceiveData = new ContainerData.ReceivingData();
JObject ReceiptLotPropsObj = CswConvert.ToJObject(Request.ReceiptLotProps);
if (ReceiptLotPropsObj.HasValues)
{
CswPrimaryKey ReceiptLotId = CswConvert.ToPrimaryKey(Request.ReceiptLotId);
if (CswTools.IsPrimaryKey(ReceiptLotId))
{
CswNbtObjClassReceiptLot ReceiptLot = _CswNbtResources.Nodes.GetNode(ReceiptLotId);
_CswNbtSdTabsAndProps.saveNodeProps(ReceiptLot.Node, ReceiptLotPropsObj);
CswPrimaryKey ContainerId = CswConvert.ToPrimaryKey(Request.ContainerId);
if (CswTools.IsPrimaryKey(ContainerId) &&
ReceiptLot.ManufacturedDate.DateTimeValue != DateTime.MinValue)
{
CswNbtObjClassContainer Container = _CswNbtResources.Nodes.GetNode(ContainerId);
CswNbtPropertySetMaterial Material = _CswNbtResources.Nodes.GetNode(Container.Material.RelatedNodeId);
Container.ExpirationDate.DateTimeValue = Material.getDefaultExpirationDate(ReceiptLot.ManufacturedDate.DateTimeValue);
Container.postChanges(false);
JObject ContainerProps = getContainerAddProps(Container);
ReceiveData.ContainerProps = ContainerProps.ToString();
}
}
}
return(ReceiveData);
}
///<summary>
/// Instance a new container according to Object Class rules. Note: this does not get the properties.
/// </summary>
public CswNbtObjClassContainer makeContainer(Action <CswNbtNode> After)
{
CswNbtObjClassContainer ret = null;
CswNbtMetaDataNodeType ContainerNt = _ContainerOc.getLatestVersionNodeTypes().FirstOrDefault();
if (null != ContainerNt)
{
Action <CswNbtNode> After2 = delegate(CswNbtNode NewNode)
{
CswNbtObjClassContainer RetAsContainer = NewNode;
RetAsContainer.Material.RelatedNodeId = _MaterialId;
//cases 30647 and 31079
//RetAsContainer.Material.setHidden( value: true, SaveToDb: false );
//RetAsContainer.Size.setHidden( value: true, SaveToDb: false );
if (null != After)
{
After(NewNode);
}
};
ret = _CswNbtSdTabsAndProps.getAddNodeAndPostChanges(ContainerNt, After2);
if (null == ret)
{
throw new CswDniException(CswEnumErrorType.Error, "Could not create a new container.", "Failed to create a new Container node.");
}
}
return(ret);
} // makeContainer()
internal CswNbtNode createContainerNode(string NodeTypeName = "Container", double Quantity = 1.0, CswNbtNode UnitOfMeasure = null, CswNbtNode Material = null, CswPrimaryKey LocationId = null, string UseType = "", bool Missing = false)
{
CswNbtNode ret = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(_getNodeTypeId(NodeTypeName), delegate(CswNbtNode NewNode)
{
CswNbtObjClassContainer ContainerNode = NewNode;
ContainerNode.Quantity.Quantity = Quantity;
if (null == UnitOfMeasure)
{
UnitOfMeasure = createUnitOfMeasureNode("Volume", "Liters" + Sequence, 1.0, 0, CswEnumTristate.True);
}
ContainerNode.Quantity.UnitId = UnitOfMeasure.NodeId;
ContainerNode.UseType.Value = UseType ?? CswEnumNbtContainerUseTypes.Storage;
ContainerNode.StorageTemperature.Value = CswEnumNbtContainerStorageTemperatures.RoomTemperature;
ContainerNode.StoragePressure.Value = CswEnumNbtContainerStoragePressures.Atmospheric;
if (Material != null)
{
ContainerNode.Material.RelatedNodeId = Material.NodeId;
}
if (LocationId != null)
{
ContainerNode.Location.SelectedNodeId = LocationId;
ContainerNode.Location.RefreshNodeName();
}
if (Missing)
{
ContainerNode.Missing.Checked = CswEnumTristate.True;
}
//ContainerNode.MaterialObsolete..CachedValue = "";
});
_finalize();
return(ret);
}
public override void CommitOperation(ref OperationData OpData)
{
CswNbtObjClassContainer containerToDispose = _CswNbtResources.Nodes[OpData.Field1.NodeId];
if (_CswNbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Edit, containerToDispose.NodeType) && _CswNbtResources.Permit.can(CswEnumNbtActionName.DisposeContainer))
{
if (CswEnumTristate.True == containerToDispose.Disposed.Checked)
{
OpData.Field1.StatusMsg = "Container " + OpData.Field1.Value + " is already disposed";
OpData.Log.Add(DateTime.Now + " - ERROR: Attempted to dispose already disposed container " + OpData.Field1.Value);
}
else
{
containerToDispose.DisposeContainer();
containerToDispose.postChanges(false);
OpData.Log.Add(DateTime.Now + " - Disposed container " + OpData.Field1.Value);
OpData.Field1.Value = string.Empty;
}
OpData.Field1.ServerValidated = false;
}
else
{
string statusMsg = "You do not have permission to dispose Container (" + OpData.Field1.Value + ")";
OpData.Field1.StatusMsg = statusMsg;
OpData.Field1.ServerValidated = false;
OpData.Log.Add(DateTime.Now + " - ERROR: " + statusMsg);
}
}
public override void CommitOperation(ref OperationData OpData)
{
CswNbtObjClassContainer containerToDispense = _CswNbtResources.Nodes[OpData.Field1.NodeId];
if (_CswNbtResources.Permit.canNodeType(CswEnumNbtNodeTypePermission.Edit, containerToDispense.NodeType) && _CswNbtResources.Permit.can(CswEnumNbtActionName.DispenseContainer))
{
double quantityToDispense = CswConvert.ToDouble(OpData.Field2.Value);
if (quantityToDispense > containerToDispense.Quantity.Quantity)
{
OpData.Field2.StatusMsg = "Cannot dispense " + quantityToDispense + containerToDispense.Quantity.CachedUnitName + " when containter only has " + containerToDispense.Quantity.Gestalt;
OpData.Log.Add(DateTime.Now + " - ERROR: Attempted to dispense " + quantityToDispense + containerToDispense.Quantity.CachedUnitName + " when containter only has " + containerToDispense.Quantity.Gestalt);
OpData.Field2.ServerValidated = false;
}
else
{
containerToDispense.DispenseOut(CswEnumNbtContainerDispenseType.Dispense, quantityToDispense, containerToDispense.Quantity.UnitId);
containerToDispense.postChanges(false);
OpData.Field1.SecondValue = " (current quantity: " + containerToDispense.Quantity.Quantity + containerToDispense.Quantity.CachedUnitName + ")";
OpData.Log.Add(DateTime.Now + " - Dispensed " + OpData.Field2.Value + " " + containerToDispense.Quantity.CachedUnitName + " out of container " + containerToDispense.Barcode.Barcode + ". " + containerToDispense.Quantity.Gestalt + " left in container");
base.CommitOperation(ref OpData);
}
}
else
{
string statusMsg = "You do not have permission to dispense Container (" + OpData.Field2.Value + ")";
OpData.Field2.StatusMsg = statusMsg;
OpData.Field2.ServerValidated = false;
OpData.Log.Add(DateTime.Now + " - ERROR: " + statusMsg);
}
}
/// <summary>
/// Abstract override to be called on onButtonClick
/// </summary>
public override bool onPropertySetButtonClick(NbtButtonData ButtonData)
{
if (null != ButtonData.NodeTypeProp)
{
//Remember: Save is an OCP too
switch (ButtonData.NodeTypeProp.getObjectClassPropName())
{
case PropertyName.Fulfill:
CswNbtObjClassContainer NodeAsContainer = null;
switch (ButtonData.SelectedText)
{
case FulfillMenu.Dispense:
NodeAsContainer = _CswNbtResources.Nodes.GetNode(Container.RelatedNodeId);
if (null != NodeAsContainer && null != NodeAsContainer.Dispense.NodeTypeProp)
{
NbtButtonData DispenseData = new NbtButtonData(NodeAsContainer.Dispense.NodeTypeProp);
NodeAsContainer.triggerOnButtonClick(DispenseData);
ButtonData.clone(DispenseData);
}
else
{
ButtonData.Data["containernodetypeid"] = Container.TargetId;
ButtonData.Data["containerobjectclassid"] = Container.TargetId;
JObject InitialQuantity = null;
if (null != Size.RelatedNodeId && Int32.MinValue != Size.RelatedNodeId.PrimaryKey)
{
CswNbtObjClassSize NodeAsSize = _CswNbtResources.Nodes[Size.RelatedNodeId];
if (null != NodeAsSize)
{
InitialQuantity = new JObject();
NodeAsSize.InitialQuantity.ToJSON(InitialQuantity);
ButtonData.Data["initialQuantity"] = InitialQuantity;
}
}
else if (false == Quantity.Empty)
{
InitialQuantity = new JObject();
Quantity.ToJSON(InitialQuantity);
}
if (null != InitialQuantity)
{
ButtonData.Data["initialQuantity"] = InitialQuantity;
}
ButtonData.Action = CswEnumNbtButtonAction.dispense;
}
break;
} //switch( ButtonData.SelectedText )
_getNextStatus(ButtonData.SelectedText);
ButtonData.Data["requestitem"] = ButtonData.Data["requestitem"] ?? new JObject();
ButtonData.Data["requestitem"]["requestitemid"] = NodeId.ToString();
ButtonData.Data["requestitem"]["materialid"] = (Material.RelatedNodeId ?? new CswPrimaryKey()).ToString();
ButtonData.Data["requestitem"]["containerid"] = (Container.RelatedNodeId ?? new CswPrimaryKey()).ToString();
ButtonData.Data["requestitem"]["locationid"] = (Location.SelectedNodeId ?? new CswPrimaryKey()).ToString();
break; //case PropertyName.Fulfill:
}
}
return(true);
}
public void setStatusTestNotScanned()
{
CswNbtObjClassContainer ContainerNode = TestData.Nodes.createContainerNode();
CswNbtObjClassContainerLocation ContainerLocationNode = TestData.Nodes.createContainerLocationNode(
ContainerNode.Node,
CswEnumNbtContainerLocationActionOptions.Ignore.ToString(),
Type: CswEnumNbtContainerLocationTypeOptions.Missing.ToString());
Assert.AreEqual(CswEnumNbtContainerLocationStatusOptions.NotScanned.ToString(), ContainerLocationNode.Status.Value);
}
private bool _canViewProp(int NodeTypePropId, CswPrimaryKey PermissionGroupId)
{
CswNbtMetaDataNodeTypeProp NTProp = _CswNbtResources.MetaData.getNodeTypeProp(NodeTypePropId);
// Must have permission to at least one tab where this property appears
Dictionary <Int32, CswNbtMetaDataNodeTypeLayoutMgr.NodeTypeLayout> EditLayouts = NTProp.getEditLayouts();
bool canView = EditLayouts.Values.Aggregate(false,
(current, EditLayout) => current || _CswNbtResources.Permit.canTab(
CswEnumNbtNodeTypePermission.View,
NTProp.getNodeType(),
_CswNbtResources.MetaData.getNodeTypeTab(EditLayout.TabId)));
#region Container Request Button Inventory Group Permission
if (canView)
{
CswNbtMetaDataObjectClass ContainerClass = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ContainerClass);
if (null != ContainerClass)
{
CswNbtMetaDataObjectClassProp RequestProp = _CswNbtResources.MetaData.getObjectClassProp(ContainerClass.ObjectClassId, CswNbtObjClassContainer.PropertyName.Request);
if (NTProp.ObjectClassPropId == RequestProp.PropId)
{
if (_CswNbtResources.Modules.IsModuleEnabled(CswEnumNbtModuleName.Requesting))
{
canView = CswNbtObjClassContainer.canContainer(_CswNbtResources, _CswNbtResources.Actions[CswEnumNbtActionName.Submit_Request], PermissionGroupId);
}
else
{
canView = false; // case 31851
}
}
}
}
#endregion
#region Material Receive Button View Permission
if (canView)
{
CswNbtMetaDataObjectClass MaterialClass = _CswNbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.ChemicalClass);
if (null != MaterialClass)
{
CswNbtMetaDataObjectClassProp RequestProp = _CswNbtResources.MetaData.getObjectClassProp(MaterialClass.ObjectClassId, CswNbtPropertySetMaterial.PropertyName.Receive);
if (NTProp.ObjectClassPropId == RequestProp.PropId)
{
canView = _CswNbtResources.Permit.can(CswEnumNbtActionName.Receiving);
}
}
}
#endregion
return(canView);
}
public void testReceivingBarcodesNoBarcode()
{
CswNbtMetaDataNodeType ChemicalNT = TestData.CswNbtResources.MetaData.getNodeType("Chemical");
CswNbtObjClassChemical ChemicalNode = TestData.CswNbtResources.Nodes.makeNodeFromNodeTypeId(ChemicalNT.NodeTypeId);
CswNbtObjClassUnitOfMeasure GramNode = TestData.CswNbtResources.Nodes.GetNode(new CswPrimaryKey("nodes", 26745));
CswNbtMetaDataNodeType SizeNT = TestData.CswNbtResources.MetaData.getNodeType("Size");
CswNbtObjClassSize Size = TestData.CswNbtResources.Nodes.makeNodeFromNodeTypeId(SizeNT.NodeTypeId, OnAfterMakeNode : delegate(CswNbtNode NewNode)
{
CswNbtObjClassSize AsSize = NewNode;
AsSize.Material.RelatedNodeId = ChemicalNode.NodeId;
AsSize.UnitCount.Value = 5;
AsSize.InitialQuantity.Quantity = 10;
AsSize.InitialQuantity.UnitId = GramNode.NodeId;
}, OverrideUniqueValidation: true);
CswNbtActReceiving ReceivingAction = new CswNbtActReceiving(TestData.CswNbtResources, ChemicalNode.NodeId);
CswNbtMetaDataNodeType ContainerNT = TestData.CswNbtResources.MetaData.getNodeType("Container");
CswNbtObjClassContainer InitialContainer = ReceivingAction.makeContainer(null);
JObject ContainerAddProps = ReceivingAction.getContainerAddProps(InitialContainer);
int NumContainers = 2;
CswNbtReceivingDefinition ReceiptDef = new CswNbtReceivingDefinition()
{
ContainerNodeId = InitialContainer.NodeId,
ContainerNodeTypeId = ContainerNT.NodeTypeId,
ContainerProps = ContainerAddProps,
MaterialNodeId = ChemicalNode.NodeId,
Quantities = new Collection <CswNbtAmountsGridQuantity>()
{
new CswNbtAmountsGridQuantity()
{
NumContainers = NumContainers,
Quantity = 10,
SizeName = Size.NodeName,
SizeNodeId = Size.NodeId,
UnitNodeId = GramNode.NodeId,
ContainerIds = new Collection <string>()
{
InitialContainer.NodeId.ToString()
}
}
}
};
CswNbtMetaDataNodeTypeProp BarcodeNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Barcode);
string Before = BarcodeNTP.Sequence.getCurrent();
ReceivingAction.receiveMaterial(ReceiptDef);
string After = BarcodeNTP.Sequence.getCurrent();
Assert.AreNotEqual(Before, After, "Creating containers in receiving with no custom barcodes specified did not consume sequence values when it should have");
}
/// <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);
}
/// <summary>
/// Checks permission and disposes a container (does not post changes!)
/// </summary>
public void Dispose(bool OverridePermissions = false)
{
if (OverridePermissions || CswNbtObjClassContainer.canContainer(_CswNbtResources, _CswNbtResources.Actions[CswEnumNbtActionName.DisposeContainer], _Container.getPermissionGroupId()))
{
_ContainerDispenseTransactionBuilder.create(CswEnumNbtContainerDispenseType.Dispose, -_Container.Quantity.Quantity, _Container.Quantity.UnitId, SrcContainer: _Container);
_Container.Quantity.Quantity = 0;
_Container.Disposed.Checked = CswEnumTristate.True;
_Container.CreateContainerLocationNode(CswEnumNbtContainerLocationTypeOptions.Dispose);
_Container.Node.IconFileNameOverride = "x.png";
_Container.Node.Searchable = false;
}
}
public void setStatusTestMissing()
{
CswNbtObjClassContainer ContainerNode = TestData.Nodes.createContainerNode();
ContainerNode.Missing.Checked = CswEnumTristate.True;
ContainerNode.postChanges(false);
CswNbtObjClassContainerLocation ContainerLocationNode = TestData.Nodes.createContainerLocationNode(
ContainerNode.Node,
CswEnumNbtContainerLocationActionOptions.Ignore.ToString(),
Type: CswEnumNbtContainerLocationTypeOptions.ReconcileScans.ToString());
Assert.AreEqual(CswEnumNbtContainerLocationStatusOptions.Missing.ToString(), ContainerLocationNode.Status.Value);
}
/// <summary>
/// Get the Add Layout properties for a container
/// </summary>
public JObject getContainerAddProps(CswNbtObjClassContainer Container)
{
JObject Ret = new JObject();
CswEnumNbtNodeEditMode PrevEditMode = _CswNbtResources.EditMode;
_CswNbtResources.EditMode = CswEnumNbtNodeEditMode.Add;
if (null != Container)
{
Ret = _CswNbtSdTabsAndProps.getProps(Container.Node, "", null, CswEnumNbtLayoutType.Add);
}
_CswNbtResources.EditMode = PrevEditMode;
return(Ret);
}
public void processReconciliationActionsTestMoreRecentExists()
{
CswNbtObjClassContainer ContainerNode = TestData.Nodes.createContainerNode();
CswNbtObjClassContainerLocation FirstContainerLocationNode = TestData.Nodes.createContainerLocationNode(ContainerNode.Node, CswEnumNbtContainerLocationActionOptions.Undispose.ToString(), DateTime.Now.AddSeconds(-1));
TestData.Nodes.createContainerLocationNode(ContainerNode.Node, CswEnumNbtContainerLocationActionOptions.Ignore.ToString());
CswScheduleLogicNbtContainerReconciliationActions Sched = _getReconciliationActionSched();
Sched.processReconciliationActions(TestData.CswNbtResources);
Assert.AreEqual(CswEnumTristate.True, FirstContainerLocationNode.ActionApplied.Checked.ToString());
Assert.AreEqual(CswEnumTristate.False, ContainerNode.Missing.Checked.ToString());
}
public void setStatusTestCorrect()
{
CswPrimaryKey ContainerLocId, ContainerLocationLocId;
TestData.getTwoDifferentLocationIds(out ContainerLocId, out ContainerLocationLocId);
CswNbtObjClassContainer ContainerNode = TestData.Nodes.createContainerNode(LocationId: ContainerLocId);
CswNbtObjClassContainerLocation ContainerLocationNode = TestData.Nodes.createContainerLocationNode(
ContainerNode.Node,
CswEnumNbtContainerLocationActionOptions.Ignore.ToString(),
LocationId: ContainerLocId);
Assert.AreEqual(ContainerLocationNode.Location.SelectedNodeId, ContainerNode.Location.SelectedNodeId);
Assert.AreEqual(CswEnumNbtContainerLocationStatusOptions.Correct.ToString(), ContainerLocationNode.Status.Value);
}
public void processReconciliationActionsTestMarkMissing()
{
CswNbtObjClassContainer ContainerNode = TestData.Nodes.createContainerNode();
CswNbtObjClassContainerLocation ContainerLocationNode = TestData.Nodes.createContainerLocationNode(
ContainerNode.Node,
CswEnumNbtContainerLocationActionOptions.MarkMissing.ToString(),
Type: CswEnumNbtContainerLocationTypeOptions.Missing.ToString());
CswScheduleLogicNbtContainerReconciliationActions Sched = _getReconciliationActionSched();
Sched.processReconciliationActions(TestData.CswNbtResources);
Assert.AreEqual(CswEnumTristate.True, ContainerLocationNode.ActionApplied.Checked.ToString());
Assert.AreEqual(CswEnumTristate.True, ContainerNode.Missing.Checked.ToString());
}
/// <summary>
/// Abstract override to be called on onButtonClick
/// </summary>
public override bool onPropertySetButtonClick(NbtButtonData ButtonData)
{
if (null != ButtonData.NodeTypeProp)
{
//Remember: Save is an OCP too
switch (ButtonData.NodeTypeProp.getObjectClassPropName())
{
case PropertyName.Fulfill:
CswNbtObjClassContainer NodeAsContainer = null;
switch (ButtonData.SelectedText)
{
case FulfillMenu.Dispose:
NodeAsContainer = _CswNbtResources.Nodes.GetNode(Container.RelatedNodeId);
if (null != NodeAsContainer)
{
NodeAsContainer.DisposeContainer();
NodeAsContainer.postChanges(true);
Status.Value = Statuses.Completed;
}
ButtonData.Action = CswEnumNbtButtonAction.refresh;
break;
case FulfillMenu.Move:
if (null != Container.RelatedNodeId)
{
NodeAsContainer = _CswNbtResources.Nodes.GetNode(Container.RelatedNodeId);
if (null != NodeAsContainer)
{
NodeAsContainer.Location.SelectedNodeId = Location.SelectedNodeId;
NodeAsContainer.Location.CachedNodeName = Location.CachedNodeName;
NodeAsContainer.Location.CachedPath = Location.CachedPath;
NodeAsContainer.postChanges(false);
Status.Value = Statuses.Completed;
ButtonData.Action = CswEnumNbtButtonAction.refresh;
}
}
break;
} //switch( ButtonData.SelectedText )
_getNextStatus(ButtonData.SelectedText);
ButtonData.Data["requestitem"] = ButtonData.Data["requestitem"] ?? new JObject();
ButtonData.Data["requestitem"]["requestitemid"] = NodeId.ToString();
ButtonData.Data["requestitem"]["containerid"] = (Container.RelatedNodeId ?? new CswPrimaryKey()).ToString();
ButtonData.Data["requestitem"]["locationid"] = (Location.SelectedNodeId ?? new CswPrimaryKey()).ToString();
break;
}//case PropertyName.Fulfill:
}
return(true);
}
public void testNonTempNodeCreateNoBarcode()
{
CswNbtMetaDataNodeType ContainerNT = TestData.CswNbtResources.MetaData.getNodeType("Container");
CswNbtMetaDataNodeTypeProp BarcodeNTP = ContainerNT.getNodeTypePropByObjectClassProp(CswNbtObjClassContainer.PropertyName.Barcode);
string Before = BarcodeNTP.Sequence.getCurrent();
CswNbtObjClassContainer Container = TestData.CswNbtResources.Nodes.makeNodeFromNodeTypeId(ContainerNT.NodeTypeId);
string After = BarcodeNTP.Sequence.getCurrent();
Assert.IsNotNull(Container.Barcode.Barcode, "Creating a container and not assigning it a custom barcode did not create a barcode when it should have");
Assert.AreNotEqual(Before, After, "Creating a container with no custom barcode did not consume a sequence value when it should have");
}
public override void setQuantityOptions()
{
CswNbtObjClassContainer ContainerNode = _CswNbtResources.Nodes.GetNode(_RequestItem.Container.RelatedNodeId);
if (null != ContainerNode)
{
CswNbtNode MaterialNode = _CswNbtResources.Nodes.GetNode(ContainerNode.Material.RelatedNodeId);
if (MaterialNode != null)
{
CswNbtUnitViewBuilder Vb = new CswNbtUnitViewBuilder(_CswNbtResources);
Vb.setQuantityUnitOfMeasureView(MaterialNode, _RequestItem.Quantity);
}
}
}
private void onContainerPropChange(CswNbtNodeProp Prop)
{
if (null != Container.RelatedNodeId)
{
Container.setReadOnly(value: true, SaveToDb: true);
if (null == Material.RelatedNodeId)
{
CswNbtObjClassContainer NodeAsContainer = _CswNbtResources.Nodes[Container.RelatedNodeId];
if (null != NodeAsContainer)
{
Material.RelatedNodeId = NodeAsContainer.Material.RelatedNodeId;
}
}
}
}
