/*-----------------------------------------------------*/
public cEGUser EGUser_From_ModuleConfig(String aModuleConfig, out cXMLDoc aModuleDoc) {
aModuleDoc = new cXMLDoc(CurrentPage.Server.MapPath(aModuleConfig));
if (aModuleDoc.DocElement == null) {
aModuleDoc = base.LoadModuleConfigXmlFromDB(aModuleConfig.Substring(aModuleConfig.LastIndexOf("/")+1));
}
return EGUser_From_ModuleDoc(aModuleDoc);
}
/*-----------------------------------------------------*/
///<summary>
///Method to let a user login with just a loginid. Should be used only by gateway or other places where
///there is a way to check for authorization and authentication of the user. See GatewayPage.cs and pgGateway.aspx
///for cookie encryption and decryption details.
///</summary>
public cEGUser LoginUserFromCookie(String aLoginID) {
cEGUser aUser = null;
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));
cDataObject aDataObject = DataObjectFactory.GetDataObject(aDataObjectNode);
if (aDataObject!=null){
aUser = EGUser_From_UserDataobject(aDataObject, out aModuleDoc);
}
aModuleDoc = null;
return aUser;
// if (aUser != null) {
// return true;
//LogLoginHistory(aUser.UserID);
//((cModulePage)CurrentPage).ModulePage_RedirectToModule(aModuleDoc);
// }
// else
// return false;
}
/*-----------------------------------------------------*/
public XmlNode CreateArgumentRelatedPropertyNode(cXMLDoc aXmlDoc, String aPropertyKey, XmlNode aArgumentNode)
{
XmlNode aArgRelatedPropertyNode = CreateArgumentRelatedPropertyNode(aXmlDoc, aPropertyKey, "");
aArgumentNode.AppendChild(aArgRelatedPropertyNode);
return(aArgumentNode);
}
/*-----------------------------------------------------*/
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 void XMLNavElement_Load(String aFileName)
{
cXMLDoc aXMLDoc = new cXMLDoc(aFileName);
XMLNavElement_Load(aXMLDoc);
aXMLDoc = null;
}
/*----------------------------------------------------*/
public void ModulePage_RedirectToModule(cXMLDoc aModuleDoc)
{
XmlNode aModuleNode;
aModuleNode = aModuleDoc.DocElement.SelectSingleNode("Module");
ModulePage_RedirectToModule(aModuleNode);
}
/*----------------------------------------------------*/
public void ModulePage_RedirectToModule(cXMLDoc aModuleDoc, String aPageKey, String aQueryString)
{
XmlNode aModuleNode;
aModuleNode = aModuleDoc.DocElement.SelectSingleNode("Module");
ModulePage_RedirectToModule(aModuleNode, aPageKey, aQueryString);
}
/*====================================================*/
protected virtual bool WfTaskOutcome_CreateNewTaskAssignments(XmlNodeList aTaskNodeList)
{
foreach (XmlNode aTaskNode in aTaskNodeList) {
//check if WfTaskAssignment already exists for GranteeProjectID, PersonID, WfTaskID
int aNewTaskID = cXMLDoc.AttributeToInt(aTaskNode, "TaskKey", 0);
string aUpdateExistingWFTA = cXMLDoc.AttributeToString(aTaskNode, "UpdateExistingWFTA", "True");
String aNewPersonProperty;
int aNewPersonID = -1;
int aDefaultWorkgroupID = -1;
if (!cXMLDoc.AttributeToBool(aTaskNode, "NoPersonID", false)) {
aNewPersonProperty = cXMLDoc.AttributeToString(aTaskNode, "PersonID");
if (aNewPersonProperty == "")
aNewPersonProperty = "PersonID";
aNewPersonID = this.GetRelatedPropertyInt(aNewPersonProperty, -1);
if (aNewPersonID == 0 || aNewPersonID == -1) {
aNewPersonID = -1;
aDefaultWorkgroupID = cXMLDoc.AttributeToInt(aTaskNode, "DefaultWorkgroupID", -1);
}
}
XmlNode aDataObjectNode;
XmlNode aFiltersNode;
cXMLDoc aXmlDoc = this.DataObjectList.DataObjectFactory.CreateDataObjectNode("WfTaskAssignment", out aDataObjectNode, out aFiltersNode);
aFiltersNode.AppendChild(this.DataObjectList.DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data", "GranteeProjectID", this.GetPropertyString("GranteeProjectID")));
if (aNewPersonID != -1)
aFiltersNode.AppendChild(this.DataObjectList.DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data", "PersonID", aNewPersonID.ToString()));
aFiltersNode.AppendChild(this.DataObjectList.DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data", "WfTaskID", aNewTaskID.ToString()));
aFiltersNode.AppendChild(this.DataObjectList.DataObjectFactory.CreateArgumentNode(aXmlDoc, "Data", "AppWftaID", this.GetPropertyString("WfTaskAssignmentID")));
XmlNodeList aExistingFiltersList = aTaskNode.SelectNodes("ExistingWfTAFilters/Argument");
foreach (XmlNode aExistingFilterNode in aExistingFiltersList) {
WfTaskOutcome_SetRelatedDataObjectArgValues(null, aExistingFilterNode);
aFiltersNode.InnerXml += aExistingFilterNode.OuterXml;
}
cWfTaskAssignment aWfTaskAssgDataObject = (cWfTaskAssignment)this.DataObjectList.DataObjectFactory.GetDataObject(aDataObjectNode);
if (aWfTaskAssgDataObject == null){ //create new WfTaskAssignment object
aWfTaskAssgDataObject = (cWfTaskAssignment)DataObjectFactory.CreateNewDataObjectFromKey("WfTaskAssignment");
aWfTaskAssgDataObject["WfTaskID"] = aNewTaskID;
if (aNewPersonID != -1)
aWfTaskAssgDataObject["PersonID"] = aNewPersonID;
else if (aDefaultWorkgroupID != -1)
aWfTaskAssgDataObject["WorkgroupID"] = aDefaultWorkgroupID;
WfTaskOutcome_SaveNewTaskAssignment(aWfTaskAssgDataObject, aTaskNode);
}
else
if (aUpdateExistingWFTA == "True")
{
WfTaskOutcome_SaveNewTaskAssignment(aWfTaskAssgDataObject, aTaskNode);
}
if (!aWfTaskAssgDataObject.ContinueProcessing)
return false;
//create related data objects
XmlNodeList aRelatedDOList = aTaskNode.SelectNodes("RelatedDataObject");
foreach (XmlNode aRelatedDONode in aRelatedDOList)
WfTaskOutcome_CreateTARelatedDataObject(aWfTaskAssgDataObject, aRelatedDONode);
}
return true;
}
/*-----------------------------------------------------*/
public cEGUser EGUser_From_EGUserType(String aEGUserType, out cXMLDoc aModuleDoc) {
XmlNode aApplModuleNode;
String aModuleConfig;
aApplModuleNode = cXMLDoc.FindNodeWithChildNode(EGAppl.Get_ApplNode(), "Modules/Module", "EGUserTypes", "Type", aEGUserType);
aModuleConfig = cXMLDoc.AttributeToString(aApplModuleNode, "ConfigFile");
return EGUser_From_ModuleConfig(aModuleConfig, out aModuleDoc);
}
/*====================================================*/
public cXMLDoc CreateDataObjectNode(String aDefinitionKey, out XmlNode aDataObjectNode, out XmlNode aFiltersNode)
{
cXMLDoc aXmlDoc = CreateDataObjectNode(aDefinitionKey, out aDataObjectNode);
aFiltersNode = aXmlDoc.XMLDocument.CreateNode(XmlNodeType.Element, "Filters", "");
aDataObjectNode.AppendChild(aFiltersNode);
return(aXmlDoc);
}
/*-----------------------------------------------------*/
public XmlNode CreateGroupArgumentNode(cXMLDoc aXmlDoc, String aGroup, String aBool)
{
//construct Filter node
XmlNode aArgumentNode = aXmlDoc.XMLDocument.CreateNode(XmlNodeType.Element, "Argument", "");
aXmlDoc.AddAttribute(aArgumentNode, "Group", aGroup);
aXmlDoc.AddAttribute(aArgumentNode, "Bool", aBool);
return(aArgumentNode);
}
/*-----------------------------------------------------*/
public XmlNode CreateArgumentNode(cXMLDoc aXmlDoc, String aType, String aPropertyKey, String aValue,
String aBool, String aOperator)
{
//construct Filter node
XmlNode aArgumentNode = CreateArgumentNode(aXmlDoc, aType, aPropertyKey, aValue, aBool);
aXmlDoc.AddAttribute(aArgumentNode, "Operator", aOperator);
return(aArgumentNode);
}
/*-----------------------------------------------------*/
public cEGUser EGUser_From_UserDataobject(cDataObject aUserDO, out cXMLDoc aModuleDoc) {
cEGUser aUser = EGUser_From_EGUserType(aUserDO.GetRelatedPropertyString("UserType.UserType_Abbr"), out aModuleDoc);
aUser.UserID = aUserDO.GetPropertyInt("UserID");
aUser.PersonID = aUserDO.GetPropertyInt("PersonID");
aUser.AccessLevel = aUserDO.GetRelatedPropertyInt("UserType.AccessLevel");
//aUser.SetPersonRoles(); //call after PersonID is set
return aUser;
}
/*-----------------------------------------------------*/
public void XMLNavElement_Load(cXMLDoc aXMLDoc)
{
XmlNode aMainNavNode;
aMainNavNode = aXMLDoc.DocElement.SelectSingleNode(NavigationNodeName);
if (aMainNavNode != null)
{
XMLNavElement_Load(aMainNavNode);
}
}
/*----------------------------------------------------*/
private String ReturnHomeModuleDefaultPageKey()
{
XmlNode aApplNode = WebAppl.Get_ApplNode();
XmlNode aModulesNode = cXMLDoc.FindNode(aApplNode, "Modules/Module", "Key", "Home");
String aModuleConfigName = cXMLDoc.AttributeToString(aModulesNode, "ConfigFile");
cXMLDoc aModuleConfigDoc = new cXMLDoc();
aModuleConfigDoc.Load(Server.MapPath(Get_ConfigurationPath(aModuleConfigName) + aModuleConfigName));
XmlNode ModuleNode = aModuleConfigDoc.DocElement.SelectSingleNode("Module");
String aDefaultPageKey = cXMLDoc.AttributeToString(ModuleNode, "DefaultPageKey");
return(aDefaultPageKey);
}
/*-----------------------------------------------------*/
public XmlNode CreateArgumentRelatedPropertyNode(cXMLDoc aXmlDoc, String aPropertyKey, String aJoin)
{
//construct Filter node
XmlNode aArgRelatedPropNode = aXmlDoc.XMLDocument.CreateNode(XmlNodeType.Element, "RelatedProperty", "");
aXmlDoc.AddAttribute(aArgRelatedPropNode, "PropertyKey", aPropertyKey);
if (aJoin != "")
{
aXmlDoc.AddAttribute(aArgRelatedPropNode, "Join", aJoin);
}
return(aArgRelatedPropNode);
}
/*====================================================*/
protected static XmlNode Get_EventClassNode(cEventData aEventData) {
cXMLDoc aClassNodeDoc;
aClassNodeDoc = new cXMLDoc();
//check for ClassNodeXml null, and if it is, return a class node for the cEmailEvent
if (aEventData.GetPropertyString("ClassNodeXml", "") == "")
{
aClassNodeDoc.LoadFromXML("<EventElement><Class Name='cEmailEvent' Assembly='EasyGrants' FullName='EasyGrants.Event.cEmailEvent'/></EventElement>");
return aClassNodeDoc.DocElement.SelectSingleNode("Class");
}
if (!aClassNodeDoc.LoadFromXML(aEventData.GetPropertyString("ClassNodeXml")))
return null;
return aClassNodeDoc.DocElement.SelectSingleNode("Class");
}
/*-----------------------------------------------------*/
public void HideInactiveLookupValues(XmlNode aControlNode, XmlNode aFilterNode, string aDefinitionKey, bool aHideInactiveItems)
{
XmlNode aOldFilters = null;
XmlNode aNewFilters = null;
String aBaseDataType = cXMLDoc.AttributeToString(aControlNode, "DataObjectDefinitionKey", aDefinitionKey);
if (aHideInactiveItems && aBaseDataType != "")
{
XmlNode aBaseObjDefNode = WebSession.DataObjectFactory.DataDefinitionDoc.DocElement.SelectSingleNode("DataObjectDefinitions/Definition[@Key='" + aBaseDataType + "']");
XmlNode aPropKeyNode = cXMLDoc.FindNode(aBaseObjDefNode, "Properties/Property", "Key", "EndDate");
cDataObject aCodeTableDO = WebSession.DataObjectFactory.GetDataObjectListWithFilter("IDGen", "TableName", cXMLDoc.AttributeToString(aBaseObjDefNode, "RowSource", "IDGen"))[0];
bool aCodeTable = false;
if (aCodeTableDO != null)
{
if (aCodeTableDO.GetPropertyValue("IsCodeTable") != System.DBNull.Value)
{
aCodeTable = aCodeTableDO.GetPropertyBool("IsCodeTable");
}
}
if (aPropKeyNode != null && aCodeTable)
{
cXMLDoc aXmlDoc = new cXMLDoc();
aXmlDoc.LoadFromXML(aControlNode.OuterXml);
if (aFilterNode == null)
{
aFilterNode = aXmlDoc.XMLDocument.CreateNode(XmlNodeType.Element, "Filters", "");
aXmlDoc.DocElement.AppendChild(aFilterNode);
aFilterNode.AppendChild(WebSession.DataObjectFactory.CreateGroupArgumentNode(aXmlDoc, "(", ""));
}
else
{
aOldFilters = aControlNode.SelectSingleNode("Filters");
aFilterNode = aXmlDoc.DocElement.SelectSingleNode("Filters");
aFilterNode.AppendChild(WebSession.DataObjectFactory.CreateGroupArgumentNode(aXmlDoc, "("));
}
aFilterNode.AppendChild(WebSession.DataObjectFactory.CreateArgumentNode(aXmlDoc, "CurrentDateTime", "EndDate", "", "", "GreaterThan"));
aFilterNode.AppendChild(WebSession.DataObjectFactory.CreateArgumentNode(aXmlDoc, "", "EndDate", "", "Or"));
aFilterNode.AppendChild(WebSession.DataObjectFactory.CreateGroupArgumentNode(aXmlDoc, ")", ""));
if (aOldFilters != null)
{
aControlNode.RemoveChild(aOldFilters);
}
aNewFilters = aControlNode.OwnerDocument.CreateNode(XmlNodeType.Element, "Filters", "");
aNewFilters.InnerXml = aFilterNode.InnerXml;
aControlNode.AppendChild(aNewFilters);
}
}
}
/*-----------------------------------------------------*/
public cXMLDoc CreateDataObjectNode(String aDefinitionKey, out XmlNode aDataObjectNode)
{
cXMLDoc aXmlDoc = new cXMLDoc();
aXmlDoc.LoadFromXML("<DataObject Key='Base' Updatable='True'></DataObject>");
//assign value to the output parameter
aDataObjectNode = aXmlDoc.XMLDocument.FirstChild;
//add DataObjectDefinitionKey to the node
//obtain DataObjectDefinitionKey from a Relationship node in DataDefinition.xml
aXmlDoc.AddAttribute(aDataObjectNode, "DataObjectDefinitionKey", aDefinitionKey);
return(aXmlDoc);
}
/*-----------------------------------------------------*/
public cEGUser EGUser_From_ModuleDoc(cXMLDoc aModuleDoc) {
XmlNode aClassNode,
aModuleNode;
cEGUser aUser = null;
String aCopyUser;
aModuleNode = aModuleDoc.DocElement.SelectSingleNode("Module");
aClassNode = cXMLDoc.FindNode(aModuleNode, "descendant::Class", "Name", cXMLDoc.AttributeToString(aModuleNode, "UserClass"));
aCopyUser = cXMLDoc.AttributeToString(aClassNode, "CopyUser");
if (aCopyUser!= "") {
aUser = EGUser_From_User(aCopyUser, aClassNode);
}
else {
aUser = EGUser_From_ClassNode(aClassNode);
}
return aUser;
}
/*-----------------------------------------------------*/
public virtual void Submit_UpdateData(cXMLDoc aOutcomeConfigDoc)
{
cWfTaskAssignment aWfTaskAssignment = (cWfTaskAssignment)WebSession.DataObjectFactory.GetDataObjectFromPrimaryKey("WfTaskAssignment", WfTaskAssignmentID);
aWfTaskAssignment.RaiseProcessEvents = true; //flag to raise pre and post submission processing events
cDataObject aSubmissionHistory = null;
if (WebAppl.CreateSubmissionHistory)
{
aSubmissionHistory = WebSession.DataObjectFactory.CreateNewDataObjectFromKey("SubmissionHistory");
aSubmissionHistory["WfTaskAssignmentID"] = WfTaskAssignmentID;
aSubmissionHistory["WfTaskID"] = aWfTaskAssignment.GetPropertyInt("WfTaskID");
aSubmissionHistory["PersonID"] = aWfTaskAssignment.GetPropertyInt("PersonID");
//aSubmissionHistory["StartDate"] = (System.DateTime)aWfTaskAssignment.GetPropertyValue("StartDate");
aSubmissionHistory["OpenDate"] = aWfTaskAssignment.GetPropertyValue("OpenDate");
aSubmissionHistory["DueDate"] = aWfTaskAssignment.GetPropertyValue("DueDate");
aSubmissionHistory["CloseDate"] = aWfTaskAssignment.GetPropertyValue("CloseDate");
//aSubmissionHistory["EndDate"] = (System.DateTime)aWfTaskAssignment.GetPropertyValue("EndDate");
aSubmissionHistory["PreWfTaskStatusID"] = aWfTaskAssignment.GetPropertyValue("WfTaskStatusID");
aSubmissionHistory.SaveData();
}
aWfTaskAssignment["WfTaskStatusID"] = 2;
aWfTaskAssignment["SubmittedDate"] = System.DateTime.Now;
aWfTaskAssignment["SubmittedBy"] = WebSession.DataObjectFactory.User.UserID;
aWfTaskAssignment["ModifyUser"] = WebSession.DataObjectFactory.User.UserID;
aWfTaskAssignment["ModifyDate"] = System.DateTime.Now;
WebSession.DataObjectFactory.SaveDataObject(aWfTaskAssignment);
aWfTaskAssignment.RaiseProcessEvents = false;
//Continue processing the post submission workflow tasks only if the ContinueProcessing is still true
if (aWfTaskAssignment.ContinueProcessing)
{
aWfTaskAssignment.SetWfTaskOutcome(aOutcomeConfigDoc);
}
if (WebAppl.CreateSubmissionHistory)
{
aSubmissionHistory["SubmittedDate"] = aWfTaskAssignment.GetPropertyValue("SubmittedDate");
aSubmissionHistory["WfTaskOutcomeID"] = aWfTaskAssignment.GetPropertyValue("WfTaskOutcomeID");
aSubmissionHistory["PostWfTaskStatusID"] = aWfTaskAssignment.GetPropertyValue("WfTaskStatusID");
aSubmissionHistory.SaveData();
}
WebSession.DataObjectFactory.CopyDataObject(aWfTaskAssignment, ((cEGUser)ModuleUser).WfTaskAssignmentObject);
}
/*-----------------------------------------------------*/
/*This overload of the DeleteData method was written to be called by the
* DataList control. It takes a data object definition key and the primary key
* value of a single row to be deleted.*/
public void DeleteData(String aDefinitionKey, String aPrimaryKeyValue)
{
//Based on object definition key, get name of primary key field
String aPrimaryKeyPropertyName = GetDataObjectDefPrimaryKey(aDefinitionKey);
//Build new data object node with empty filter node
XmlNode aDataObjectNode;
XmlNode aFiltersNode;
cXMLDoc aXMLDoc = CreateDataObjectNode(aDefinitionKey, out aDataObjectNode, out aFiltersNode);
//Add argument to filters node designating the primary key value of the row to be deleted
XmlNode aArgumentsNode = aXMLDoc.XMLDocument.CreateElement("Argument");
aFiltersNode.AppendChild(aArgumentsNode);
aXMLDoc.AddAttribute(aArgumentsNode, "PropertyKey", aPrimaryKeyPropertyName);
aXMLDoc.AddAttribute(aArgumentsNode, "Value", aPrimaryKeyValue);
//Pass newly created data object node to base DeleteData method
DeleteData(aDataObjectNode);
}
public void LoadDataSources(cXMLDoc aBaselineDD, cXMLDoc aDataSourceConfigDoc)
{
XmlNode aDataSourcesNode = aDataSourceConfigDoc.DocElement.SelectSingleNode("//DataSources");
XmlNode aReleaseBuildNode = aDataSourceConfigDoc.XMLDocument.CreateNode(XmlNodeType.Element, "ReleaseBuild", "");
aDataSourceConfigDoc.AddAttribute(aReleaseBuildNode, "BuildKey", BuildKey);
aDataSourcesNode.ChildNodes[0].AppendChild(aReleaseBuildNode);
XmlNode aBaselineDataSourcesNode = aBaselineDD.DocElement.SelectSingleNode("//EGData").SelectSingleNode("//DataSources");
XmlNode aNodeToBeCopied = aBaselineDD.XMLDocument.ImportNode(aDataSourcesNode, true);
if (aBaselineDataSourcesNode != null)
{
aBaselineDD.DocElement.ReplaceChild(aNodeToBeCopied, aBaselineDataSourcesNode);
}
else
{
aBaselineDD.DocElement.AppendChild(aNodeToBeCopied);
}
}
/*====================================================*/
protected String Get_ConfigurationPath(String aConfigKey)
{
cXMLDoc aPageConfigDoc = PageConfigDoc;
String aPath = "";
//code works for this page, but fails if trying to load config w/ only:
//* config key
if (aPageConfigDoc != null)
{
XmlNode aConfigurationNode;
aConfigurationNode = cXMLDoc.FindNode(aPageConfigDoc.DocElement,
"Configurations/Configuration", "Key",
aConfigKey);
if (aConfigurationNode != null)
{
aPath = cXMLDoc.AttributeToString(aConfigurationNode, "Path", "");
}
}
return(aPath);
}
/*====================================================*/
protected String EvaluateOutcome_EvaluateData(cXMLDoc aOutcomeConfigDoc) {
/*This method evaluates outcomes using the EvaluateData functionality in cDataObject.
It is more flexible than the original EvaluateOutcome method and was developed for the
HHMI International competition.
Peter Larsen 3/25/04
*/
String aDefaultOutcomeID;
XmlNodeList aOutcomeNodeList;
String aOutcomeKey = "";
XmlNodeList aEvalNodeList;
String aDataObjKey;
cDataObject aDataObject;
String aResult = "";
aDefaultOutcomeID = cXMLDoc.AttributeToString(aOutcomeConfigDoc.DocElement.SelectSingleNode("Outcomes"), "DefaultOutcomeKey");
aOutcomeKey = aDefaultOutcomeID;
aOutcomeNodeList = aOutcomeConfigDoc.DocElement.SelectNodes("Outcomes/Outcome");
foreach (XmlNode aOutcomeNode in aOutcomeNodeList) {
aOutcomeKey = cXMLDoc.AttributeToString(aOutcomeNode, "OutcomeKey");
aDataObjKey = cXMLDoc.AttributeToString(aOutcomeNode, "DataObjectKey");
if (aDataObjKey == "WfTaskAssignment")
aDataObject = this;
else
aDataObject = this.GetRelatedPropertyDataObject(aDataObjKey);
//get list of evaluation nodes
aEvalNodeList = aOutcomeNode.SelectNodes("Evaluation");
foreach (XmlElement aEvalEl in aEvalNodeList) {
aResult = aDataObject.EvaluateData_Item(aEvalEl);
if (aResult != "1")
break;
}
if (aResult == "1") {
return cXMLDoc.AttributeToString(aOutcomeNode, "OutcomeKey");
}
}
return aDefaultOutcomeID;
}
/*-----------------------------------------------------*/
public XmlNode CreateArgumentNode(cXMLDoc aXmlDoc, String aType, String aPropertyKey, String aValue,
String aBool)
{
//parse PropertyKey
String aArgPropertyKey, aRelatedPropertyKey;
int aLastIndex;
aLastIndex = aPropertyKey.LastIndexOf(".");
if (aLastIndex != -1)
{
aArgPropertyKey = aPropertyKey.Substring(aLastIndex + 1);
aRelatedPropertyKey = aPropertyKey.Substring(0, aLastIndex);
}
else
{
aArgPropertyKey = aPropertyKey;
aRelatedPropertyKey = "";
}
//construct Filter node
XmlNode aArgumentNode = aXmlDoc.XMLDocument.CreateNode(XmlNodeType.Element, "Argument", "");
aXmlDoc.AddAttribute(aArgumentNode, "Type", aType);
aXmlDoc.AddAttribute(aArgumentNode, "PropertyKey", aArgPropertyKey);
aXmlDoc.AddAttribute(aArgumentNode, "Value", aValue);
aXmlDoc.AddAttribute(aArgumentNode, "Bool", aBool);
//add RelatedProperty node if necessary
if (aRelatedPropertyKey != "")
{
XmlNode aRelatedPropertyNode = CreateArgumentRelatedPropertyNode(aXmlDoc, aRelatedPropertyKey);
//XmlNode aRelatedPropertyNode = aXmlDoc.XMLDocument.CreateNode(XmlNodeType.Element, "RelatedProperty", "");
//aXmlDoc.AddAttribute(aRelatedPropertyNode, "PropertyKey", aRelatedPropertyKey);
aArgumentNode.AppendChild(aRelatedPropertyNode);
}
return(aArgumentNode);
}
/* --------------------------------------------------------*/
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;
}
/*-----------------------------------------------------*/
private void LoadDataSources(cXMLDoc aBaselineDD, HttpApplication aHttpApp)
{
//Check for Developer.config
FileInfo aDeveloperConfigFI = new FileInfo(aHttpApp.Server.MapPath(ConfigRoot + "Developer.config"));
cXMLDoc aDataSourceConfigDoc = null;
if (aDeveloperConfigFI.Exists && BuildKey == "Debug")
{
aDataSourceConfigDoc = new cXMLDoc(aHttpApp.Server.MapPath(ConfigRoot + "Developer.config"));
}
else
{
string aBuildKeyDSFileName = BuildKey + ".config";
FileInfo aBuildKeyConfigFI = new FileInfo(aHttpApp.Server.MapPath(ConfigRoot + aBuildKeyDSFileName));
if (aBuildKeyConfigFI.Exists)
{
aDataSourceConfigDoc = new cXMLDoc(aHttpApp.Server.MapPath(ConfigRoot + aBuildKeyDSFileName));
}
}
if (aDataSourceConfigDoc != null)
{
base.LoadDataSources(aBaselineDD, aDataSourceConfigDoc);
}
}
/// <summary>
/// This method merges the client module config into that of baseline.
/// Any client module config that needs to be merged should be named "Client[baseline module config name]"
/// and present in the same path. Ex: ClientModuleConfig.config for a client version of staff module config
/// </summary>
/// <param name="mModuleConfigDoc"></param>
/// <param name="mClientModuleConfigDoc"></param>
public void MergeConfigDocs(cXMLDoc aClientModuleConfigDoc, string aParentNodeName)
{
//Get the Navigation Node or the Pages Node
XmlNode aClientModuleNode = aClientModuleConfigDoc.XMLDocument.SelectSingleNode("//Module");
XmlNode aBaselineModuleNode = mModuleConfigDoc.XMLDocument.SelectSingleNode("//Module");
XmlNode aClientParentNode = aClientModuleNode.SelectSingleNode("//" + aParentNodeName);
XmlNode aBaselineParentNode = aBaselineModuleNode.SelectSingleNode("//" + aParentNodeName);
string aParentBaselineRelation = cXMLDoc.AttributeToString(aClientParentNode, "Baseline", "Append");
if (aParentBaselineRelation == "Override")
{
XmlNode aClientParentNodeToBeCopied = mModuleConfigDoc.XMLDocument.ImportNode(aClientParentNode, true);
aBaselineModuleNode.ReplaceChild(aClientParentNodeToBeCopied, aBaselineModuleNode.SelectSingleNode("//" + aParentNodeName));
}
else
{
//loop thru the NavElement or the Page nodes
foreach (XmlNode aChildNode in aClientParentNode.ChildNodes)
{
string aChildBaselineRelation = cXMLDoc.AttributeToString(aChildNode, "Baseline", "Override");
string aChildNodeName = aChildNode.Name;
string aChildNodeKeyValue = cXMLDoc.AttributeToString(aChildNode, "Key");
XmlNode aClientChildNodeToBeCopied = mModuleConfigDoc.XMLDocument.ImportNode(aChildNode, true);
//Here if the NavElement contains Child NavElement , then if block will be executed. Some of the examples are Administration and Reviews
//and the else block will be executed when the Navelement doesn;t contains any further child elements.
if (aChildNode.HasChildNodes)
{
if (aChildBaselineRelation == "Append" || (aChildBaselineRelation == "Override" && cXMLDoc.FindNode(aBaselineParentNode, aChildNodeName, "Key", aChildNodeKeyValue) == null))
{
//Here we are looping the GrandChilNavelements.
foreach (XmlNode aGrandChildNode in aChildNode.ChildNodes)
{
String aGrandChildRelation = cXMLDoc.AttributeToString(aGrandChildNode, "Baseline", "Override");
String aGrandChildNodeName = aGrandChildNode.Name;
String aGrandChildNodeKeyValue = cXMLDoc.AttributeToString(aGrandChildNode, "Key");
XmlNode aGrandClientChildNodeToBeCopied = mModuleConfigDoc.XMLDocument.ImportNode(aGrandChildNode, true);
String aGrandChildInsertAfter = cXMLDoc.AttributeToString(aGrandChildNode, "InsertAfter");
XmlNode aBasParentNode = aBaselineParentNode.SelectSingleNode("//Navigation/" + aChildNodeName + "[@Key" + "='" + aChildNodeKeyValue + "']");
XmlNode aBaselineNodeToBeCopiedAfter = aBaselineParentNode.SelectSingleNode("//" + aChildNodeName + "[@Key" + "='" + aGrandChildInsertAfter + "']");
if (aGrandChildRelation == "Append" || (aGrandChildRelation == "Override" && cXMLDoc.FindNode(aBasParentNode, aGrandChildNodeName, "Key", aGrandChildNodeKeyValue) == null))
{
aBasParentNode.InsertAfter(aGrandClientChildNodeToBeCopied, aBaselineNodeToBeCopiedAfter);
}
else if (aGrandChildRelation == "Override")
{
aBasParentNode.ReplaceChild(aGrandClientChildNodeToBeCopied, cXMLDoc.FindNode(aBasParentNode, aGrandChildNodeName, "Key", aGrandChildNodeKeyValue));
}
}
}
else
{
aBaselineParentNode.ReplaceChild(aClientChildNodeToBeCopied, cXMLDoc.FindNode(aBaselineParentNode, aChildNodeName, "Key", aChildNodeKeyValue));
}
}
else
{
string aChildInsertAfter = cXMLDoc.AttributeToString(aChildNode, "InsertAfter");
XmlNode aBaselineNodeToBeCopiedAfter = aBaselineParentNode.SelectSingleNode("//" + aChildNodeName + "[@Key" + "='" + aChildInsertAfter + "']");
if (aChildBaselineRelation == "Append" || (aChildBaselineRelation == "Override" && cXMLDoc.FindNode(aBaselineParentNode, aChildNodeName, "Key", aChildNodeKeyValue) == null))
{
aBaselineParentNode.InsertAfter(aClientChildNodeToBeCopied, aBaselineNodeToBeCopiedAfter);
}
else if (aChildBaselineRelation == "Override")
{
aBaselineParentNode.ReplaceChild(aClientChildNodeToBeCopied, cXMLDoc.FindNode(aBaselineParentNode, aChildNodeName, "Key", aChildNodeKeyValue));
}
}
}
}
}
/*-----------------------------------------------------*/
public XmlNode CreateArgumentRelatedPropertyNode(cXMLDoc aXmlDoc, String aPropertyKey)
{
return(CreateArgumentRelatedPropertyNode(aXmlDoc, aPropertyKey, ""));
}
