/*====================================================*/
///<summary>
//This method returns the workflow task assignment ID corresponding to the review assignment of the
//grantee project to the specified review committee member in the request/conflict stage of the project
///</summary>
public cDataObject GetRequestConflictDO(cReviewCommitteeMember aRevCommMember)
{
cXMLDoc aXMLDoc;
XmlNode aDataObjectNode;
XmlNode aFiltersNode;
cDataObject aRCDO = null;
cDataObjectList aWfTAList;
//Get workflow task assignment ID matching grantee and reviewer in this stage
aXMLDoc = DataObjectFactory.CreateDataObjectNode("WfTaskAssignment", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "PersonID", aRevCommMember.GetPropertyString("PersonID")));
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "GranteeProjectID", GetPropertyString("GranteeProjectID")));
aWfTAList = DataObjectFactory.GetDataObjectList(aDataObjectNode);
if (aWfTAList != null)
{
foreach (cDataObject aWfTA in aWfTAList)
{
//Get request/conflict data object based on workflow task assignment ID
aXMLDoc = DataObjectFactory.CreateDataObjectNode("WfTaskAssignmentRequestConflict", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "WfTaskAssignmentID", aWfTA.GetPropertyString("WfTaskAssignmentID")));
aRCDO = DataObjectFactory.GetDataObject(aDataObjectNode);
if (aRCDO != null)
{
break;
}
}
}
return(aRCDO);
}
/*----------------------------------------------------*/
public cBudget Get_Budget(bool aCreateNew)
{
cXMLDoc aXmlDoc;
XmlNode aDataObjectNode, aFiltersNode, aArgNode;
cDataObjectList aDataObjectList;
cBudget aBudget;
aXmlDoc = this.DataObjectFactory.CreateDataObjectNode("Budget", out aDataObjectNode, out aFiltersNode);
aArgNode = aFiltersNode.AppendChild(this.DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data",
"GranteeProjectID", GetPropertyString("GranteeProjectID")));
aDataObjectList = DataObjectFactory.GetDataObjectList(aDataObjectNode);
if (aDataObjectList != null && aDataObjectList.Count > 0)
{
return((cBudget)aDataObjectList[0]);
}
else
{
//new BudgetItem
if (!aCreateNew)
{
return(null);
}
aBudget = (cBudget)DataObjectFactory.CreateNewDataObjectFromKey("Budget");
aBudget["GranteeProjectID"] = GetPropertyString("GranteeProjectID");
return(aBudget);
}
}
/*----------------------------------------------------*/
///<summary>
///This method checks to see if any assignments exist for a given grantee project review stage object.
///If not, the grantee project review stage object is deleted.
///</summary>
public void DeleteGPRSIfNecessary(int aWfProjectTaskID)
{
cXMLDoc aXMLDoc;
XmlNode aDataObjectNode;
XmlNode aFiltersNode;
cDataObjectList aRemainingAssignments;
cDataObject aWfProjectTaskDO;
cDataObject aGPRSDataObject;
aWfProjectTaskDO = DataObjectFactory.GetDataObjectFromPrimaryKey("WfProjectTask", aWfProjectTaskID.ToString());
aXMLDoc = DataObjectFactory.CreateDataObjectNode("WfTaskAssignment", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", "WfTaskID", aWfProjectTaskDO.GetPropertyString("WfTaskID")));
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", "GranteeProjectID", GetPropertyString("GranteeProjectID")));
aRemainingAssignments = DataObjectFactory.GetDataObjectList(aDataObjectNode);
if (aRemainingAssignments.Count == 0)
{
//Delete GranteeProjectReviewStage object
///First, get ReviewStageID based on current stage WfTaskID
int aReviewStageID = cReviewStage.GetReviewStageIDFromWfProjectTaskID(aWfProjectTaskID, DataObjectFactory);
///Next, build data object node to retrieve GranteeProjectReviewStage
aXMLDoc = DataObjectFactory.CreateDataObjectNode("GranteeProjectReviewStage", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", "ReviewStageID", aReviewStageID.ToString()));
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", "GranteeProjectID", GetPropertyString("GranteeProjectID")));
aGPRSDataObject = DataObjectFactory.GetDataObject(aDataObjectNode);
if (aGPRSDataObject != null)
{
DataObjectFactory.DeleteData(aGPRSDataObject);
}
}
}
/*----------------------------------------------------*/
public cBudgetItem Get_BudgetItem(String aCategoryID, bool aCreateNew) {
cXMLDoc aXmlDoc;
XmlNode aDataObjectNode, aFiltersNode, aArgNode;
cDataObjectList aDataObjectList;
cBudgetItem aBudgetItem;
aXmlDoc = this.DataObjectFactory.CreateDataObjectNode("BudgetItem", out aDataObjectNode, out aFiltersNode);
aArgNode = aFiltersNode.AppendChild(this.DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data",
"BudgetPeriodID", BudgetPeriodID.ToString()));
aArgNode = aFiltersNode.AppendChild(this.DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data",
"BudgetCategoryID", aCategoryID, "And"));
aDataObjectList = DataObjectFactory.GetDataObjectList(aDataObjectNode);
if (aDataObjectList != null && aDataObjectList.Count > 0)
return (cBudgetItem)aDataObjectList[0];
else {
//new BudgetItem
if (!aCreateNew) return null;
aBudgetItem = (cBudgetItem)DataObjectFactory.CreateNewDataObjectFromKey("BudgetItem");
aBudgetItem["BudgetCategoryID"] = aCategoryID;
return aBudgetItem;
}
}
/*-----------------------------------------------------*/
public cDataObjectList Person_Updated_WorkgroupTaskList() {
cXMLDoc aXmlDoc;
XmlNode aDataObjectNode, aFiltersNode, aArgNode;
cDataObjectList aWorkGroupList, aWorkGroupTaskListL;
cDataObjectList aWFTAList = new cDataObjectList(DataObjectFactory);
aXmlDoc = DataObjectFactory.CreateDataObjectNode("WorkGroup", out aDataObjectNode, out aFiltersNode);
aArgNode = aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data",
"PersonID", this.GetPropertyString("PersonID")));
aArgNode = aArgNode.AppendChild(DataObjectFactory.CreateArgumentRelatedPropertyNode(aXmlDoc,
"WorkGroupMembers"));
aWorkGroupList = DataObjectFactory.GetDataObjectList(aDataObjectNode);
foreach (cDataObject aWorkGroup in aWorkGroupList) {
aWorkGroupTaskListL = DataObjectFactory.GetDataObjectListWithFilter("WorkGroupTaskList", "WorkGroupID", aWorkGroup.GetPropertyString("WorkGroupID"));
foreach (cDataObject aWorkGroupTaskLst in aWorkGroupTaskListL) {
cDataObjectList aCurWFTAList;
aCurWFTAList = aWorkGroupTaskLst.GetRelatedPropertyDataObjectList("WfTaskAssignments");
aWFTAList.AddList(aCurWFTAList);
}
}
return aWFTAList;
}
/*-----------------------------------------------------*/
public cEGUser ValidateLoginCredentials(String aLoginID, String aPassword, bool aEnforceUserNameCase, bool aEnforcePasswordCase,
out cXMLDoc aModuleDoc) {
XmlNode aDataObjectNode;
XmlNode aFiltersNode;
//Construct User data object node
cXMLDoc aXmlDoc = DataObjectFactory.CreateDataObjectNode("User", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data", "UserName", aLoginID));
cDataObjectList aDOL = DataObjectFactory.GetDataObjectList(aDataObjectNode);
cDataObject aDataObject = null;
foreach (cDataObject aDO in aDOL) {
if (aDO.GetPropertyString("Password").ToLower() == aPassword.ToLower()) {
aDataObject = aDO;
break;
}
}
if (aDataObject!=null &&
(!aEnforceUserNameCase || aDataObject.GetPropertyString("UserName") == aLoginID) &&
(!aEnforcePasswordCase || aDataObject.GetPropertyString("Password") == aPassword)){
cEGUser aUser = EGUser_From_UserDataobject(aDataObject, out aModuleDoc);
return aUser;
}
aModuleDoc = null;
return null;
}
/*----------------------------------------------------*/
public cDataObject Get_BudgetItemExpense(String aCategoryID, bool aCreateNew, int aTaskID)
{
cXMLDoc aXmlDoc;
XmlNode aDataObjectNode, aFiltersNode, aArgNode;
cDataObjectList aDataObjectList;
cDataObject aBudgetItem;
aXmlDoc = this.DataObjectFactory.CreateDataObjectNode("BudgetItemExpense", out aDataObjectNode, out aFiltersNode);
aArgNode = aFiltersNode.AppendChild(this.DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data",
"BudgetItemID", Get_BudgetItem(aCategoryID, true).GetPropertyString("BudgetItemID")));
aArgNode = aFiltersNode.AppendChild(this.DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data",
"TaskID", aTaskID.ToString(), "And"));
aDataObjectList = DataObjectFactory.GetDataObjectList(aDataObjectNode);
if (aDataObjectList != null && aDataObjectList.Count > 0)
return aDataObjectList[0];
else
{
//new BudgetItem
if (!aCreateNew) return null;
aBudgetItem = DataObjectFactory.CreateNewDataObjectFromKey("BudgetItemExpense");
aBudgetItem["BudgetItemID"] = Get_BudgetItem(aCategoryID, true).GetPropertyString("BudgetItemID");
aBudgetItem["TaskID"] = aTaskID;
return aBudgetItem;
}
}
/*-----------------------------------------------------*/
public cDataObjectList Person_Updated_WorkgroupTaskList(XmlElement aDataObjectElement) {
cXMLDoc aXmlDoc;
XmlNode aDataObjectNode, aFiltersNode, aArgNode;
cDataObjectList aWorkGroupList, aWorkGroupTaskListL;
cDataObjectList aWFTAList = DataObjectFactory.CreateDataObjectList(aDataObjectElement); //This is the object that will be returned.
aXmlDoc = DataObjectFactory.CreateDataObjectNode("WorkGroup", out aDataObjectNode, out aFiltersNode);
aArgNode = aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data",
"PersonID", this.GetPropertyString("PersonID")));
aArgNode = aArgNode.AppendChild(DataObjectFactory.CreateArgumentRelatedPropertyNode(aXmlDoc,
"WorkGroupMembers"));
aWorkGroupList = DataObjectFactory.GetDataObjectList(aDataObjectNode);
ArrayList wgArrayL = new ArrayList();
int wfALIdx = 0;
foreach (cDataObject aWorkGroup in aWorkGroupList) {
aWorkGroupTaskListL = DataObjectFactory.GetDataObjectListWithFilter("WorkGroupTaskList", "WorkGroupID", aWorkGroup.GetPropertyString("WorkGroupID"));
if (aWorkGroupTaskListL.Count == 0)
continue;
foreach (cDataObject aWorkGroupTaskLst in aWorkGroupTaskListL)
{
cDataObjectList aCurWFTAList;
aCurWFTAList = aWorkGroupTaskLst.GetRelatedPropertyDataObjectList("WfTaskAssignments");
if (aCurWFTAList.Count == 0)
continue;
foreach (cDataObject aCurWFTA in aCurWFTAList) {
wfALIdx = wgArrayL.BinarySearch(aCurWFTA.GetPropertyInt("WfTaskAssignmentID"));
if (wfALIdx >= 0)
break;
if (aCurWFTA.GetPropertyInt("WfTaskStatusID") == 1 && aCurWFTA.GetPropertyString("PersonID") == "") {
aWFTAList.Add(aCurWFTA);
wgArrayL.Insert(~wfALIdx, aCurWFTA.GetPropertyInt("WfTaskAssignmentID"));
aCurWFTA.DataObjectList = aWFTAList;
}
}
}
}
XmlElement aSortEl = (XmlElement)aDataObjectElement.SelectSingleNode("Sort");
if(aSortEl != null) {
aWFTAList.SortEl = aSortEl;
aWFTAList.Sort();
}
return aWFTAList;
}
/*----------------------------------------------------*/
public cDataObjectList Get_WfProjectTasks_All()
{
cXMLDoc aXMLDoc;
XmlNode aDataObjectNode;
XmlNode aFiltersNode;
XmlNode aArgNode;
XmlNode aSortNode;
aXMLDoc = DataObjectFactory.CreateDataObjectNode("WfProjectTask", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "WfProjectID", this.GetPropertyString("WfProjectID")));
aSortNode = aXMLDoc.XMLDocument.CreateNode(XmlNodeType.Element, "Sort", "");
aArgNode = DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "SortOrder", "");
aSortNode.AppendChild(aArgNode);
aDataObjectNode.AppendChild(aSortNode);
return(DataObjectFactory.GetDataObjectList(aDataObjectNode));
}
/*----------------------------------------------------*/
public void CalculateAverageScores()
{
cXMLDoc aXMLDoc;
XmlNode aDataObjectNode;
XmlNode aFiltersNode;
XmlNode aArgNode;
cDataObjectList aReviewWFTAList;
cDataObject aWfProjectTask = GetRelatedPropertyDataObject("WfProjectTask");
foreach (cGranteeProject aGPDO in GranteeProjectList)
{
//Get all review WfTaskAssignment objects for this grantee project and review stage.
aXMLDoc = DataObjectFactory.CreateDataObjectNode("WfTaskAssignment", out aDataObjectNode, out aFiltersNode);
aArgNode = DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "WfTaskID", aWfProjectTask.GetPropertyString("WfTaskID"));
aFiltersNode.AppendChild(aArgNode);
aArgNode = DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "GranteeProjectID", aGPDO.GetPropertyString("GranteeProjectID"));
aFiltersNode.AppendChild(aArgNode);
aReviewWFTAList = DataObjectFactory.GetDataObjectList(aDataObjectNode);
//Loop through list, getting sum and count of ReviewRating property.
int aCount = 0;
double aTotalRating = 0;
foreach (cDataObject aReviewWFTADO in aReviewWFTAList)
{
if (aReviewWFTADO["ReviewRating"] != System.DBNull.Value)
{
aCount += 1;
aTotalRating += aReviewWFTADO.GetPropertyDouble("ReviewRating");
}
}
//Calculate mean and save to GranteeProjectReviewStage data object.
if (aCount > 0)
{
cDataObject aGPRSDO = aGPDO.GetGranteeProjectReviewStageDO(aWfProjectTask.GetPropertyInt("WfProjectTaskID"));
aGPRSDO["AverageRating"] = aTotalRating / aCount;
aGPRSDO.SaveData();
}
}
}
/*----------------------------------------------------*/
protected cDataObjectList Get_WfProjectTasks(cDataObject aWfProjectTaskCur, string aFilterCriteria)
{
cXMLDoc aXMLDoc;
XmlNode aDataObjectNode;
XmlNode aFiltersNode;
XmlNode aArgNode;
XmlNode aSortNode;
aXMLDoc = DataObjectFactory.CreateDataObjectNode("WfProjectTask", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "WfProjectID", aWfProjectTaskCur.GetPropertyString("WfProjectID")));
if (aFilterCriteria.Length > 0)
{
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "SortOrder", aWfProjectTaskCur.GetPropertyString("SortOrder"), "and", aFilterCriteria));
}
aSortNode = aXMLDoc.XMLDocument.CreateNode(XmlNodeType.Element, "Sort", "");
aArgNode = DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "SortOrder", "");
aSortNode.AppendChild(aArgNode);
aDataObjectNode.AppendChild(aSortNode);
return(DataObjectFactory.GetDataObjectList(aDataObjectNode));
}
/*----------------------------------------------------*/
/// <summary>
/// removes workflow task assignments and deletes GranteeProjectReviewStage objects
/// </summary>
public void DeleteAssignments()
{
cDataObject aWfProjectTask;
cXMLDoc aXmlDoc;
XmlNode aFiltersNode;
XmlNode aArgNode;
XmlNode aDataObjectNode;
String aProjectID;
String aTaskID;
cDataObjectList aWFTARList;
aWfProjectTask = DataObjectFactory.GetDataObjectFromPrimaryKey("WfProjectTask", GetPropertyInt("WfProjectTaskID"));
aTaskID = aWfProjectTask.GetPropertyString("WfTaskID");
aProjectID = aWfProjectTask.GetPropertyString("WfProjectID");
//Get all workflow task assignments for this project task
aXmlDoc = DataObjectFactory.CreateDataObjectNode("WfTaskAssignment", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data", "WfTaskID", aTaskID.ToString()));
aArgNode = aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data", "WfProjectID", aProjectID.ToString()));
aArgNode.AppendChild(DataObjectFactory.CreateArgumentRelatedPropertyNode(aXmlDoc, "GranteeProject"));
cDataObjectList aWFTAList = DataObjectFactory.GetDataObjectList(aDataObjectNode);
//Delete all related WfTaskAssignmentReview objects
foreach (cDataObject aWFTADO in aWFTAList)
{
aWFTARList = DataObjectFactory.GetDataObjectListWithFilter("WfTaskAssignmentReview", "WfTaskAssignmentID", aWFTADO.GetPropertyString("WfTaskAssignmentID"));
DataObjectFactory.DeleteData(aWFTARList);
}
//Delete WfTaskAssignment objects
DataObjectFactory.DeleteData(aWFTAList);
//Get and delete all GranteeProjectReviewStage objects for this stage
aXmlDoc = DataObjectFactory.CreateDataObjectNode("GranteeProjectReviewStage", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data", "ReviewStageID", GetPropertyString("ReviewStageID")));
cDataObjectList aGPRSList = DataObjectFactory.GetDataObjectList(aDataObjectNode);
DataObjectFactory.DeleteData(aGPRSList);
}
/*----------------------------------------------------*/
protected void Update_Next_Outcomes(int aOutcomeID)
{
cDataObject aWfTaskCur;
cDataObject aGranteeProject;
int aGranteeProjectIDCur;
cDataObjectList aWfTaskList;
cXMLDoc aXMLDoc;
XmlNode aDataObjectNode;
XmlNode aFiltersNode;
XmlNode aSortNode;
XmlNode aArgNode;
//this is the WfTask for our record in GranteeProjectOutcomes
aWfTaskCur = this.GetRelatedPropertyDataObject("WfTask");
aGranteeProjectIDCur = this.GetPropertyInt("GranteeProjectID");
aGranteeProject = this.GetRelatedPropertyDataObject("GranteeProject");
//select all tasks after the current one
aXMLDoc = DataObjectFactory.CreateDataObjectNode("WfProjectTask", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "WfProjectID", aGranteeProject.GetPropertyString("WfProjectID")));
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "WfTaskID", aWfTaskCur.GetPropertyString("WfTaskID")));
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "SortOrder", aWfTaskCur.GetPropertyString("SortOrder"), "and", "GreaterThan"));
aSortNode = aXMLDoc.XMLDocument.CreateNode(XmlNodeType.Element, "Sort", "");
aArgNode = DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "SortOrder", "");
aSortNode.AppendChild(aArgNode);
aDataObjectNode.AppendChild(aSortNode);
aWfTaskList = DataObjectFactory.GetDataObjectList(aDataObjectNode);
foreach (cDataObject aWfTask in aWfTaskList)
{
Create_Outcome(this.DataObjectFactory, aGranteeProjectIDCur, aWfTask.GetPropertyInt("WfTaskID"), 0, false, false, false);
}
if (aOutcomeID > 0)
{
this["OutcomeID"] = aOutcomeID;
}
this.SaveData();
}
/* --------------------------------------------------------*/
public bool Locked(int aUserID)
{
XmlNode aDataObjectNode;
XmlNode aFiltersNode;
//Construct User data object node
cXMLDoc aXmlDoc = DataObjectFactory.CreateDataObjectNode("User", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data", "UserID", aUserID.ToString()));
cDataObjectList aDOL = DataObjectFactory.GetDataObjectList(aDataObjectNode);
foreach (cDataObject aDO in aDOL)
{
if (aDO.GetPropertyValue("FailedAttempts") != System.DBNull.Value)
{
if (aDO.GetPropertyInt("FailedAttempts")>= WebAppl.MaxFailedLoginAttempts)
{
return true;
}
}
}
return false;
}
/*====================================================*/
///<summary>
///gets budget period from ID, if aCreateNew=true creates new period
///</summary>
public cBudgetPeriod Get_BudgetPeriod(String aBudgetPeriodID, bool aCreateNew)
{
cXMLDoc aXmlDoc;
XmlNode aDataObjectNode, aFiltersNode, aArgNode;
cDataObjectList aDataObjectList;
cBudgetPeriod aBudgetPeriod;
aXmlDoc = this.DataObjectFactory.CreateDataObjectNode("BudgetPeriod", out aDataObjectNode, out aFiltersNode);
aArgNode = aFiltersNode.AppendChild(this.DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data",
"BudgetPeriodID", aBudgetPeriodID));
aDataObjectList = DataObjectFactory.GetDataObjectList(aDataObjectNode);
if (aDataObjectList != null && aDataObjectList.Count > 0)
return (cBudgetPeriod)aDataObjectList[0];
else {
//new BudgetItem
if (!aCreateNew) return null;
aBudgetPeriod = (cBudgetPeriod)DataObjectFactory.CreateNewDataObjectFromKey("BudgetPeriod");
aBudgetPeriod["BudgetID"] = this["BudgetID"];
return aBudgetPeriod;
}
}
/*====================================================*/
/*----------------------------------------------------*/
public cDataObjectList GetWfTaskAssignmentList()
{
//returns a list of WfTaskAssignment data objects that meet the criteria for receiving an e-mail reminder (WfProjectTask,
//WfTaskStatus, and interval before or after a key project date)
int aWfProjectID;
int aWfTaskID;
XmlNode aDataObjectNode;
XmlNode aFiltersNode;
XmlNode aArgNode;
bool aOverridableDateType = false;
//Get filter values
//Project and task IDs (We cannot currently filter directly on WfTaskAssignment.WfProjectTask for technical reasons)
if (GetPropertyValue("ProjectTaskID") != System.DBNull.Value)
{
cDataObject aWfProjectTask = DataObjectFactory.GetDataObjectFromPrimaryKey("WfProjectTask", GetPropertyInt("ProjectTaskID"));
aWfProjectID = aWfProjectTask.GetPropertyInt("WfProjectID");
aWfTaskID = aWfProjectTask.GetPropertyInt("WfTaskID");
}
else
{
aWfProjectID = GetPropertyInt("WfProjectID");
aWfTaskID = GetPropertyInt("WfTaskID");
}
//Get date value against which to compare dates in database (today's date offset by the interval defined in the reminder object)
int aInterval = GetPropertyInt("DaysToRemind");
if (GetPropertyInt("BeforeAfterID") == 2)
{
aInterval = -1 * aInterval;
}
DateTime aCompareDate = DateTime.Today.Add(new TimeSpan(aInterval, 0, 0, 0));
String aCompareDateStr = String.Format("{0:yyyy/M/d}", aCompareDate);
DateTime aCompareDateNext = aCompareDate.Add(new TimeSpan(1, 0, 0, 0));
String aCompareDateStrNext = String.Format("{0:yyyy/M/d}", aCompareDateNext);
//Check to see if the date type is one that is overridable by the individual WfTaskAssignment
String aReminderTargetType = GetRelatedPropertyString("ReminderTarget.Abbr");
if (aReminderTargetType == "OpenDate" || aReminderTargetType == "DueDate" || aReminderTargetType == "CloseDate")
{
aOverridableDateType = true;
}
//Build filter nodes
cXMLDoc aXMLDoc = DataObjectFactory.CreateDataObjectNode("WfTaskAssignment", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", "WfTaskID", aWfTaskID.ToString()));
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", "WfTaskStatusID", "1"));
aArgNode = aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", "WfProjectID", aWfProjectID.ToString()));
DataObjectFactory.CreateArgumentRelatedPropertyNode(aXMLDoc, "GranteeProject", aArgNode);
//If the date type is not overridable, we just have to filter on the appropriate date from the WfProjectTask. Otherwise,
//we have to filter on (WfProjectTask date meets criteria AND WfTaskAssignment date is null) OR (WfTaskAssignment date meets criteria)
if (aOverridableDateType)
{
aFiltersNode.AppendChild(DataObjectFactory.CreateGroupArgumentNode(aXMLDoc, "(", "And"));
aFiltersNode.AppendChild(DataObjectFactory.CreateGroupArgumentNode(aXMLDoc, "(", ""));
}
//aArgNode = aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", aReminderTargetType, aCompareDateStr, ""));
//DataObjectFactory.CreateArgumentRelatedPropertyNode(aXMLDoc, "WfProjectTask", aArgNode);
aArgNode = aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", aReminderTargetType, aCompareDateStr, "", "GreaterThanEqual"));
DataObjectFactory.CreateArgumentRelatedPropertyNode(aXMLDoc, "WfProjectTask", aArgNode);
aArgNode = aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", aReminderTargetType, aCompareDateStrNext, "And", "LessThan"));
DataObjectFactory.CreateArgumentRelatedPropertyNode(aXMLDoc, "WfProjectTask", aArgNode);
if (aOverridableDateType)
{
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", aReminderTargetType, "null"));
aFiltersNode.AppendChild(DataObjectFactory.CreateGroupArgumentNode(aXMLDoc, ")", ""));
//aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", aReminderTargetType, aCompareDateStr, "Or"));
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", aReminderTargetType, aCompareDateStr, "Or", "GreaterThanEqual"));
aFiltersNode.AppendChild(DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", aReminderTargetType, aCompareDateStrNext, "And", "LessThan"));
aFiltersNode.AppendChild(DataObjectFactory.CreateGroupArgumentNode(aXMLDoc, ")", ""));
}
//Get data object list
return(DataObjectFactory.GetDataObjectList(aDataObjectNode));
}
/*----------------------------------------------------*/
public void CalculateAverageScores_WFTAReview()
{
/* This method, formerly called CalculateAverageScores(), is based on the older model of collecting a "primary"
* rating for each review assignment, which was stored in a WfTaskAssignmentReview data object with a RatingTypeID
* of 4. The new CalculateAverageScores() method reflects the new model of collecting multiple scores per review assignment
* and calculating a weighted average, which is stored in the WfTaskAssignment.ReviewRating property.
* Peter Larsen 7/6/2004
*/
//cDataObjectList aGPRSDOList;
cDataObjectList aReviewRatingsList;
int aWfProjectTaskID;
int aGranteeProjectID;
cXMLDoc aXMLDoc;
XmlNode aDataObjectNode;
XmlNode aFiltersNode;
XmlNode aArgNode;
XmlNode aRPNode;
cDataObject aGranteeProjectReviewStage;
aWfProjectTaskID = GetPropertyInt("WfProjectTaskID");
//aGPRSDOList = GetRelatedPropertyDataObjectList("GranteeProjectReviewStages");
//foreach(cDataObject aGPRSDO in aGPRSDOList) {
foreach (cGranteeProject aGPRSDO in GranteeProjectList)
{
aGranteeProjectID = aGPRSDO.GetPropertyInt("GranteeProjectID");
aXMLDoc = DataObjectFactory.CreateDataObjectNode("WfTaskAssignmentReview", out aDataObjectNode, out aFiltersNode);
aArgNode = DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "WfTaskID", aWfProjectTaskID.ToString());
aRPNode = DataObjectFactory.CreateArgumentRelatedPropertyNode(aXMLDoc, "WfTaskAssignment", aArgNode);
aFiltersNode.AppendChild(aRPNode);
aArgNode = DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "GranteeProjectID", aGranteeProjectID.ToString());
aRPNode = DataObjectFactory.CreateArgumentRelatedPropertyNode(aXMLDoc, "WfTaskAssignment", aArgNode);
aFiltersNode.AppendChild(aRPNode);
aArgNode = DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "RatingTypeID", "4");
aFiltersNode.AppendChild(aArgNode);
aArgNode = DataObjectFactory.CreateArgumentNode(aXMLDoc, "", "Rating", "not null");
aFiltersNode.AppendChild(aArgNode);
aReviewRatingsList = DataObjectFactory.GetDataObjectList(aDataObjectNode);
int aCount = 0;
double aTotalRating = 0;
foreach (cDataObject aReviewRatingDO in aReviewRatingsList)
{
aCount += 1;
aTotalRating += aReviewRatingDO.GetPropertyDouble("Rating");
}
if (aCount > 0)
{
//aGPRSDO["AverageRating"] = aTotalRating/aCount;
//DataObjectFactory.SaveDataObject(aGPRSDO);
aGranteeProjectReviewStage = aGPRSDO.GetGranteeProjectReviewStageDO(aWfProjectTaskID);
aGranteeProjectReviewStage["AverageRating"] = aTotalRating / aCount;
DataObjectFactory.SaveDataObject(aGranteeProjectReviewStage);
}
}
//DataObjectFactory.SaveDataObject(aGPRSDOList);
}
/*----------------------------------------------------*/
public void GenerateAutomaticRequestsConflicts(XmlNodeList aRCTypeNodeList)
{
//In this method, the string "RC" within a variable name refers to "Request/Conflict" (e.g., aRCTypeNodeList)
int aWfTaskID = GetRelatedPropertyDataObject("WfProjectTask").GetPropertyInt("WfTaskID");
//Delete all existing requests and/or conflicts for this stage
XmlNode aRCDONode;
XmlNode aFiltersNode;
XmlNode aArgumentNode;
XmlNode aRelatedPropertyNode;
cXMLDoc aXMLDoc = DataObjectFactory.CreateDataObjectNode("WfTaskAssignmentRequestConflict", out aRCDONode, out aFiltersNode);
aArgumentNode = DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", "WfTaskID", aWfTaskID.ToString());
aRelatedPropertyNode = DataObjectFactory.CreateArgumentRelatedPropertyNode(aXMLDoc, "WfTaskAssignment", aArgumentNode);
aFiltersNode.AppendChild(aArgumentNode);
aArgumentNode = DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", "Automatic", "True");
aFiltersNode.AppendChild(aArgumentNode);
cDataObjectList aRCDOList = DataObjectFactory.GetDataObjectList(aRCDONode);
DataObjectFactory.DeleteData(aRCDOList);
//Get DOList of all review assignment WFTAs for request/conflict stage
XmlNode aWFTADONode;
aXMLDoc = DataObjectFactory.CreateDataObjectNode("WfTaskAssignment", out aWFTADONode, out aFiltersNode);
aArgumentNode = DataObjectFactory.CreateArgumentNode(aXMLDoc, "Data", "WfTaskID", aWfTaskID.ToString());
aFiltersNode.AppendChild(aArgumentNode);
cDataObjectList aWFTADOList = DataObjectFactory.GetDataObjectList(aWFTADONode);
int aIndex;
String aRevFullKey;
String aRevRelatedKey;
String aRevPropertyKey;
cDataObjectList aRevDOList;
String aAppFullKey;
String aAppRelatedKey;
String aAppPropertyKey;
cDataObjectList aAppDOList;
XmlNode aReviewerNode;
XmlNodeList aRevFiltersNodeList;
XmlNode aApplicantNode;
XmlNodeList aAppFiltersNodeList;
int aRCID = 0;
int i;
//foreach(cDataObject aWFTADO in aWFTADOList) {
for (i = 0; i < aWFTADOList.Count; i++)
{
cDataObject aWFTADO = aWFTADOList[i];
Debug.WriteLine("Checking " + i.ToString() + " of " + aWFTADOList.Count.ToString());
bool aRC = false;
foreach (XmlNode aRCTypeNode in aRCTypeNodeList)
{
//Get reviewer property data object list
aReviewerNode = aRCTypeNode.SelectSingleNode("Reviewer");
aRevFiltersNodeList = aReviewerNode.SelectNodes("Filters/Argument");
aRevFullKey = cXMLDoc.AttributeToString(aReviewerNode, "PropertyKey");
aIndex = aRevFullKey.LastIndexOf(".");
if (aIndex == -1)
{
aRevDOList = this.DataObjectList;
aRevPropertyKey = aRevFullKey;
}
else
{
aRevRelatedKey = aRevFullKey.Substring(0, aIndex);
aRevDOList = aWFTADO.GetRelatedPropertyDataObjectList(aRevRelatedKey);
aRevPropertyKey = aRevFullKey.Substring(aIndex + 1);
}
//Get applicant property data object list
aApplicantNode = aRCTypeNode.SelectSingleNode("Applicant");
aAppFiltersNodeList = aApplicantNode.SelectNodes("Filters/Argument");
aAppFullKey = cXMLDoc.AttributeToString(aApplicantNode, "PropertyKey");
aIndex = aAppFullKey.LastIndexOf(".");
if (aIndex == -1)
{
aAppDOList = this.DataObjectList;
aAppPropertyKey = aAppFullKey;
}
else
{
aAppRelatedKey = aAppFullKey.Substring(0, aIndex);
aAppDOList = aWFTADO.GetRelatedPropertyDataObjectList(aAppRelatedKey);
aAppPropertyKey = aAppFullKey.Substring(aIndex + 1);
}
//Loop through both lists; return true if any values are equal
foreach (cDataObject aRevDO in aRevDOList)
{
if (aRevDO.MeetsFilterCriteria(aRevFiltersNodeList))
{
foreach (cDataObject aAppDO in aAppDOList)
{
if (aAppDO.MeetsFilterCriteria(aAppFiltersNodeList))
{
if (aRevDO.GetPropertyString(aRevPropertyKey) == aAppDO.GetPropertyString(aAppPropertyKey))
{
aRC = true;
aRCID = Convert.ToInt32(cXMLDoc.AttributeToString(aRCTypeNode, "ID"));
break;
}
}
} //foreach(cDataObject aAppDO in aAppDOList)
}
if (aRC)
{
break;
}
} //foreach(cDataObject aRevDO in aRevDOList)
if (aRC)
{
break;
}
} //foreach(XmlNode aRCTypeNode in aRCTypeNodeList)
if (aRC)
{
//Get request/conflict definition to find out whether this is a request or a conflict
cDataObject aRCDefDO = DataObjectFactory.GetDataObjectFromPrimaryKey("Conflict", aRCID.ToString());
int aRequestConflictID = aRCDefDO.GetPropertyInt("RequestConflictID");
//Write request/conflict row
cDataObject aRCDO;
aRCDO = DataObjectFactory.CreateNewDataObjectFromKey("WfTaskAssignmentRequestConflict");
aRCDO["ConflictID"] = aRCID;
aRCDO["WfTaskAssignmentID"] = aWFTADO.GetPropertyInt("WfTaskAssignmentID");
aRCDO["RequestConflictID"] = aRequestConflictID;
aRCDO["Automatic"] = true;
DataObjectFactory.SaveDataObject(aRCDO);
}
} //foreach(cDataObject aWFTADO in aWFTADOList)
}
/*====================================================*/
public void SetWfTaskOutcome(cXMLDoc aOutcomeConfigDoc, bool aUseEvaluateData, bool aRaiseSingleEvent, bool aRaiseEvents, string aRcptPersonIDPropertyKey) {
/*This override of the SetWfTaskOutcome method exists so that both the
old (EvaluateOutcome) and new (EvaluateOutcome_EvaluateData) models of
outcome configuration file processing can be used at the same time. Existing
pages that call SetWfTaskOutcome with no parameters will use the old model to
which they were written. The old model may or may not eventually be done away with.
Peter Larsen 3/25/04.
*/
XmlNodeList aTaskNodeList;
XmlNodeList aUpdateDataList;
XmlNodeList aEventNodeList;
XmlNode aOutcomeNode;
String aOutcomeID = "";
int aUserID;
aUserID = ((cPerson) this.GetRelatedPropertyDataObject("Person")).Get_EG_User();
if (aUseEvaluateData) {
aOutcomeID = EvaluateOutcome_EvaluateData(aOutcomeConfigDoc);
aOutcomeNode = cXMLDoc.FindNode(aOutcomeConfigDoc.DocElement.SelectSingleNode("Outcomes"),
"Outcome", "OutcomeKey", aOutcomeID.ToString());
} else
aOutcomeNode = EvaluateOutcome(aOutcomeConfigDoc);
if (aOutcomeNode == null) {
aOutcomeID = cXMLDoc.AttributeToString(aOutcomeConfigDoc.DocElement.SelectSingleNode("Outcomes"), "DefaultOutcomeKey");
if (aOutcomeID != "") {
this["WfTaskOutcomeID"] = aOutcomeID;
}
this.DataObjectList.DataObjectFactory.SaveDataObject(this);
} else {
String aOutcomeValue = OutcomeValue_GetArgumentValue(GetOutcomeNode(aOutcomeNode));
if (aOutcomeValue != "")
aOutcomeID = aOutcomeValue;
else
aOutcomeID = cXMLDoc.AttributeToString(aOutcomeNode, "OutcomeKey");
if (Convert.ToInt32(aOutcomeID) > 0) {
this["WfTaskOutcomeID"] = aOutcomeID;
this.DataObjectList.DataObjectFactory.SaveDataObject(this);
}
XmlNode aProcessingEventsNode = aOutcomeNode.SelectSingleNode("ProcessingEvents");
if (ContinueProcessing && aProcessingEventsNode != null) {
XmlNodeList aDataObjectNodeList = aProcessingEventsNode.SelectNodes("DataObject");
if (aDataObjectNodeList != null && aDataObjectNodeList.Count > 0) {
foreach (XmlNode aDataObjectNode in aDataObjectNodeList) {
XmlNodeList aFilterArgsList = aDataObjectNode.SelectNodes("Filters/Argument");
foreach (XmlNode aArgNode in aFilterArgsList) {
WfTaskOutcome_SetRelatedDataObjectArgValues(null, aArgNode);
}
cProcessingEvent aProcessingEvent;
aProcessingEvent = cProcessingEvent.CreateProcessingEventInstance(cXMLDoc.AttributeToString(aDataObjectNode, "DataObjectDefinitionKey"), this.DataObjectFactory);
aProcessingEvent.ProcessEvent(aDataObjectNode);
if (aProcessingEvent.StatusID < 1) {
ContinueProcessing = false;
break;
}
}
}
}
if (!ContinueProcessing) return; //if the event processing failed, stopping continuing the process of creating the tasks or sending emails
cDataObjectList aWftaReopenRequestDOL=DataObjectFactory.GetDataObjectListWithFilter("WftaReopenRequest","ReopenWfTaskAssignmentID",this.GetPropertyString("WfTaskAssignmentID"),"Active","True");
if (aWftaReopenRequestDOL.Count > 0){
cDataObject aRequestingWfTaskAssignmentDo = aWftaReopenRequestDOL[0].GetRelatedPropertyDataObject("RequestingWfTaskAssignment");
aRequestingWfTaskAssignmentDo["WfTaskStatusID"] = "1"; //Incomplete
aRequestingWfTaskAssignmentDo.SaveData();
aWftaReopenRequestDOL[0]["Active"]="False";
aWftaReopenRequestDOL[0].SaveData();
}
else {
XmlNode aTasksNode = aOutcomeNode.SelectSingleNode("Tasks");
if (aTasksNode != null) {
IndexNewWfTAs = cXMLDoc.AttributeToBool(aTasksNode, "Index", false);
aTaskNodeList = aTasksNode.SelectNodes("Task");
if (aTaskNodeList != null)
//assign tasks associated with outcome
ContinueProcessing = WfTaskOutcome_CreateNewTaskAssignments(aTaskNodeList);
}
}
if (!ContinueProcessing) return; //if the pre and post assignment event processing failed, stopping continuing the process of updating and sending emails
aUpdateDataList = aOutcomeNode.SelectNodes("UpdateData/Argument");
if (aUpdateDataList != null)
//update data related to the submitted WfTaskAssignment
WfTaskOutcome_UpdateData(aUpdateDataList);
if (aRaiseEvents)
{
aEventNodeList = aOutcomeNode.SelectNodes("Events/Event");
if (aEventNodeList != null) {
//raise events associated with task outcome
foreach (XmlNode aEventNode in aEventNodeList) {
XmlNode aEventDataObjectListNode = aEventNode.SelectSingleNode("EventDataObjectList");
if (aEventDataObjectListNode == null) {
if (aRaiseSingleEvent) {
if (aRcptPersonIDPropertyKey != "") {
RaiseSingleEvent(cXMLDoc.AttributeToInt(aEventNode, "EventKey"), aUserID, aRcptPersonIDPropertyKey);
} else {
RaiseSingleEvent(cXMLDoc.AttributeToInt(aEventNode, "EventKey"), aUserID);
}
} else
RaiseEvent(cXMLDoc.AttributeToInt(aEventNode, "EventKey"), aUserID);
}
else {
//Get the PersonID attribute of the EventDataObjectList node set in case this event is assigned to Grant Primary Staff, etc
String aPersonPropertyKey = cXMLDoc.AttributeToString(aEventDataObjectListNode, "PersonID", "");
if (aPersonPropertyKey != "") {
String aPersonID = "";
aPersonID = this.GetRelatedPropertyString(aPersonPropertyKey);
if (aPersonID == "")
continue;
}
XmlNodeList aFilterArgsList = aEventDataObjectListNode.SelectNodes("Filters/Argument");
foreach (XmlNode aArgNode in aFilterArgsList) {
WfTaskOutcome_SetRelatedDataObjectArgValues(null, aArgNode);
//if email is assigned to a grant primary staff person and there is no primary staff person assigned
//if (cXMLDoc.AttributeToBool(aArgNode, "Null", false) && cXMLDoc.AttributeToString(aArgNode, "TypeKey", "") == "GranteeProject.GranteeProjectPrimaryStaffAffiliation.StaffPersonID" ) {
if (cXMLDoc.AttributeToBool(aArgNode, "Null", false)) {
cDataObject aDefaultWorkgroupDO = DataObjectFactory.GetDataObjectListWithFilter("WorkGroup", "IsPrimary", "True")[0];
if (aDefaultWorkgroupDO != null) {
aEventDataObjectListNode.Attributes["DataObjectDefinitionKey"].Value = "WorkGroupMember";
aArgNode.Attributes["TypeKey"].Value = "WorkGroupID";
aArgNode.Attributes["PropertyKey"].Value = "WorkGroupID";
aArgNode.Attributes["Value"].Value = aDefaultWorkgroupDO.GetPropertyString("WorkGroupID");
}
}
}
cDataObjectList aEventDataObjectList = DataObjectFactory.GetDataObjectList(aEventDataObjectListNode);
if (aRaiseSingleEvent) {
if (aRcptPersonIDPropertyKey != "") {
RaiseSingleEvent(cXMLDoc.AttributeToInt(aEventNode, "EventKey"), aUserID, aEventDataObjectList, aRcptPersonIDPropertyKey);
} else {
RaiseSingleEvent(cXMLDoc.AttributeToInt(aEventNode, "EventKey"), aUserID, aEventDataObjectList);
}
}
else
RaiseEvent(cXMLDoc.AttributeToInt(aEventNode, "EventKey"), aUserID, aEventDataObjectList);
}
}
}
}
}
}
