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);
}
}
public Cart getCart(Cart Cart, bool CalculateCounts = false)
{
CswNbtObjClassRequest NodeAsRequest = getCurrentRequestNode();
if (null != NodeAsRequest)
{
Cart.CurrentRequest = new CswNbtNode.Node(NodeAsRequest.Node);
}
CswNbtView PendingItemsView = getPendingItemsView();
PendingItemsView.SaveToCache(IncludeInQuickLaunch: false);
Cart.PendingItemsView = PendingItemsView;
CswNbtView FavoritesView = getFavoriteRequestNamesView();
FavoritesView.SaveToCache(IncludeInQuickLaunch: false);
Cart.FavoritesView = FavoritesView;
CswNbtView SubmittedItems = getSubmittedRequestItemsView();
SubmittedItems.SaveToCache(IncludeInQuickLaunch: false);
Cart.SubmittedItemsView = SubmittedItems;
CswNbtView RecurringItems = getUsersRecurringRequestItemsView();
RecurringItems.SaveToCache(IncludeInQuickLaunch: false);
Cart.RecurringItemsView = RecurringItems;
CswNbtView FavoriteItems = getFavoriteRequestsItemsView();
FavoriteItems.SaveToCache(IncludeInQuickLaunch: false);
Cart.FavoriteItemsView = FavoriteItems;
Cart.CopyableRequestTypes = new Collection <String>
{
CswNbtObjClassRequestItem.Types.EnterprisePart,
CswNbtObjClassRequestItem.Types.MaterialBulk,
CswNbtObjClassRequestItem.Types.MaterialSize
};
Cart.Counts = CswNbtObjClassUser.getCurrentUserCache(_CswNbtResources).CartCounts;
//if( CalculateCounts )
//{
// //This is expensive and we can do it in the next async request
// Cart.Counts.PendingRequestItems = getCartContentCount();
// Cart.Counts.SubmittedRequestItems = _getItemCount( SubmittedItems );
// Cart.Counts.RecurringRequestItems = _getItemCount( RecurringItems );
// Cart.Counts.FavoriteRequestItems = _getItemCount( FavoriteItems );
//}
return(Cart);
}
public CswPrimaryKey getRecurringRequestNodeId()
{
CswPrimaryKey Ret = null;
CswNbtObjClassRequest RecurringRequest = getRecurringRequestNode();
if (null != RecurringRequest)
{
Ret = RecurringRequest.NodeId;
}
return(Ret);
}
//Is this really necessary?
public CswPrimaryKey getCurrentRequestNodeId()
{
CswPrimaryKey Ret = null;
CswNbtObjClassRequest RequestNode = getCurrentRequestNode();
if (null != RequestNode)
{
Ret = RequestNode.NodeId;
}
return(Ret);
}
//this is the open carts view, scoped to the user's current Request
public CswNbtView getPendingItemsView()
{
CswNbtView Ret = getOpenCartsView();
Ret.ViewName = PendingItemsViewName;
CswNbtObjClassRequest Request = getCurrentRequestNode();
CswNbtViewRelationship RootVr = Ret.Root.ChildRelationships[0];
RootVr.NodeIdsToFilterIn.Clear();
RootVr.NodeIdsToFilterIn.Add(Request.NodeId);
return(Ret);
}
/// <summary>
/// WCF method to copy request items to recurring
/// </summary>
public static void copyRecurring(ICswResources CswResources, CswNbtRequestDataModel.CswRequestReturn Ret, CswNbtRequestDataModel.CswRequestReturn.Ret Request)
{
CswNbtResources NbtResources = _validate(CswResources);
bool Succeeded = false;
if (Request.RequestItems.Any())
{
CswNbtWebServiceRequesting ws = new CswNbtWebServiceRequesting(NbtResources);
CswNbtActRequesting act = new CswNbtActRequesting(NbtResources);
//So here we're getting the "Recurring" Request and copying the request items from the current request into there
CswNbtObjClassRequest RequestNode = act.getRecurringRequestNode();
applyCopyLogic SetRequest = (Item) =>
{
Item.Request.RelatedNodeId = RequestNode.NodeId;
Item.IsRecurring.Checked = CswEnumTristate.True;
};
Succeeded = ws.copyRequestItems(Request, SetRequest);
}
Ret.Data.Succeeded = Succeeded;
}
/// <summary>
/// Sumbits all pending Request Items
/// </summary>
/// <returns>true on success</returns>
public bool submitRequest(CswPrimaryKey NodeId, string NodeName)
{
bool Ret = false;
if (null != NodeId)
{
CswNbtObjClassRequest NodeAsRequest = _CswNbtResources.Nodes.GetNode(NodeId);
if (null != NodeAsRequest)
{
if (getCartContentCount() > 0)
{
NodeAsRequest.SubmittedDate.DateTimeValue = DateTime.Now;
NodeAsRequest.Name.Text = NodeName;
NodeAsRequest.postChanges(true);
Ret = true;
}
}
}
return(Ret);
}
//Get the first pending request, or make a new one if one doesn't exist
public CswNbtObjClassRequest getCurrentRequestNode()
{
if (null == _CurrentRequestNode &&
false == (_ThisUser is CswNbtSystemUser))
{
_CurrentRequestNode = _getFirstPendingRequest();
if (null == _CurrentRequestNode)
{
CswNbtMetaDataNodeType RequestNt = _RequestOC.getLatestVersionNodeTypes().FirstOrDefault();
if (null == RequestNt)
{
//This error makes slightly more sense, but again,
//it sounds like it's the user's fault that RequestNT doesn't exist
throw new CswDniException(CswEnumErrorType.Warning,
"Cannot Submit Request without a valid Request object.",
"No Request NodeType could be found.");
}
_CurrentRequestNode = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(RequestNt.NodeTypeId);
}
}
return(_CurrentRequestNode);
}
/// <summary>
/// WCF method to create a favorite
/// </summary>
public static void createFavorite(ICswResources CswResources, CswNbtRequestDataModel.CswRequestReturn Ret, CswNbtRequestDataModel.CswRequestReturn.Ret Request)
{
CswNbtResources NbtResources = _validate(CswResources);
bool Succeeded = false;
//This webservice is being called in the webclient twice - once to create the temp, and again to save the changes
//this is really awkward - all this webservice should really do is return the Nodetypeid needed to do a traditional add
//...oh, but wait, we need to make sure Favorite is checked in this case (and ONLY in this case) - *sigh*
if (null != Request && false == string.IsNullOrEmpty(Request.RequestId))
{
CswNbtObjClassRequest Favorite = NbtResources.Nodes[Request.RequestId];
if (null != Favorite)
{
Succeeded = true;
Favorite.PromoteTempToReal();
}
}
else
{
CswNbtMetaDataObjectClass RequestOc = NbtResources.MetaData.getObjectClass(CswEnumNbtObjectClass.RequestClass);
CswNbtMetaDataNodeType RequestNt = RequestOc.getLatestVersionNodeTypes().FirstOrDefault();
if (null != RequestNt)
{
CswNbtObjClassRequest Favorite = NbtResources.Nodes.makeNodeFromNodeTypeId(RequestNt.NodeTypeId, IsTemp: true);
if (null != Favorite)
{
Favorite.IsFavorite.Checked = CswEnumTristate.True;
Favorite.Name.Text = string.Empty;
Favorite.postChanges(ForceUpdate: false);
Succeeded = true;
CswPropIdAttr NameIdAttr = new CswPropIdAttr(Favorite.Node, Favorite.Name.NodeTypeProp);
Ret.Data.CswRequestId = Favorite.NodeId;
Ret.Data.CswRequestName = NameIdAttr;
}
}
}
Ret.Data.Succeeded = Succeeded;
}
//so this makes it sound like we get the first, and only the first recurring Request - is that right?
public CswNbtObjClassRequest getRecurringRequestNode()
{
if (null == _RecurringRequestNode &&
false == (_ThisUser is CswNbtSystemUser))
{
CswNbtView RequestView = getRequestViewBase(LimitToUnsubmitted: false, IncludeDefaultFilters: false);
CswNbtViewRelationship RootVr = RequestView.Root.ChildRelationships[0];
RequestView.AddViewPropertyAndFilter(RootVr, _RequestOC.getObjectClassProp(CswNbtObjClassRequest.PropertyName.IsRecurring), Value: CswEnumTristate.True.ToString());
RequestView.AddViewPropertyAndFilter(RootVr, _RequestOC.getObjectClassProp(CswNbtObjClassRequest.PropertyName.Requestor), SubFieldName: CswEnumNbtSubFieldName.NodeID, Value: _ThisUser.UserId.PrimaryKey.ToString());
ICswNbtTree Tree = _CswNbtResources.Trees.getTreeFromView(RequestView, RequireViewPermissions: false, IncludeHiddenNodes: false, IncludeSystemNodes: false);
if (Tree.getChildNodeCount() > 0)
{
Tree.goToNthChild(0);
_RecurringRequestNode = Tree.getNodeForCurrentPosition();
}
if (null == _RecurringRequestNode)
{
CswNbtMetaDataNodeType RequestNt = _RequestOC.getLatestVersionNodeTypes().FirstOrDefault();
if (null == RequestNt)
{
//This error is misleading - it makes it sound like the user did something wrong
throw new CswDniException(CswEnumErrorType.Warning,
"Cannot make a Request without a valid Request object.",
"No Request NodeType could be found.");
}
_RecurringRequestNode = _CswNbtResources.Nodes.makeNodeFromNodeTypeId(RequestNt.NodeTypeId, delegate(CswNbtNode NewNode)
{
((CswNbtObjClassRequest)NewNode).IsRecurring.Checked = CswEnumTristate.True;
});
}
}
return(_RecurringRequestNode);
}
/// <summary>
/// WCF method to copy a favorite to the current cart
/// </summary>
public static void copyFavorite(ICswResources CswResources, CswNbtRequestDataModel.CswRequestReturn Ret, CswNbtRequestDataModel.CswRequestReturn.Ret Request)
{
CswNbtResources NbtResources = _validate(CswResources);
bool Succeeded = false;
//...I have no idea what the difference is between Request.RequestId and Request.CswRequestId
//I think they both refer to the current cart,
//but then how are we differentiating between the current Request and the Favorite Request?
if (CswTools.IsPrimaryKey(Request.CswRequestId) && Request.RequestItems.Any())
{
CswNbtObjClassRequest RequestNode = NbtResources.Nodes[Request.CswRequestId];
if (null != RequestNode)
{
CswNbtWebServiceRequesting ws = new CswNbtWebServiceRequesting(NbtResources);
applyCopyLogic SetRequest = (Item) =>
{
Item.Status.Value = CswNbtObjClassRequestItem.Statuses.Pending;
Item.Request.RelatedNodeId = RequestNode.NodeId;
};
Succeeded = ws.copyRequestItems(Request, SetRequest);
}
}
Ret.Data.Succeeded = Succeeded;
}
}//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()
