internal HansoftEnumValue(HPMUniqueID projectId, EHPMProjectDefaultColumn column, object value, int iValue)
 {
     this.projectId = projectId;
     this.column = column;
     this.value = value;
     this.iValue = iValue;
 }

 /// <summary>
 /// Factory method for creating a Task (subclass of).
 /// </summary>
 /// <param name="uniqueID">The Task ID or TaskRef ID that a Task shuld be created for</param>
 /// <param name="viewType">The view that the task appears in (primarily  important for product backlog items which can appear in mutiple views).</param>
 /// <returns>A concrete task acting as a wrapper to access the Hansoft API for the task in question.</returns>
 internal static Task GetTask(HPMUniqueID uniqueID, EHPMReportViewType viewType)
 {
     if ((viewType == EHPMReportViewType.ScheduleMainProject || viewType == EHPMReportViewType.AgileMainProject) && SdkSession.UtilIsIDTask(uniqueID) && SdkSession.UtilIsIDBacklogProject(SdkSession.TaskGetContainer(uniqueID)))
         return GetTask(SdkSession.TaskGetProxy(uniqueID));
     else
         return GetTask(uniqueID);
 }

 public static HPMReport FindReport(HPMUniqueID projId, HPMUniqueID reportUserId, string reportName)
 {
     HPMReports reports = SessionManager.Instance.Session.ProjectGetReports(projId, reportUserId);
     foreach (HPMReport report in reports.m_Reports)
     {
         if (report.m_Name == reportName)
             return report;
     }
     return null;
 }

 internal static List<HansoftItem> GetChildren(HPMUniqueID uniqueID, bool deep)
 {
     List<HansoftItem> children = new List<HansoftItem>();
     if (HasChildren(uniqueID))
     {
         HPMTaskEnum tasks = Session.TaskRefUtilEnumChildren(uniqueID, deep);
         foreach (HPMUniqueID id in tasks.m_Tasks)
             children.Add(Task.GetTask(id));
     }
     return children;
 }

 private Release(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
     : base(uniqueID, uniqueTaskID)
 {
     if (cachedData.ContainsKey(uniqueTaskID.m_ID))
         cache = cachedData[uniqueTaskID.m_ID];
     else
     {
         cache = new CachedData();
         cachedData.Add(uniqueTaskID.m_ID, cache);
     }
 }

        public static HansoftEnumValue FromString(HPMUniqueID projectId, EHPMProjectDefaultColumn column, string sValue)
        {
            if (!maxColumnValuebyColumn.ContainsKey(column))
                throw new ArgumentException("Unsupported default column in HansoftEnumValue.FromString/3: " + column);

            for (uint i = 0; i <= maxColumnValuebyColumn[column]; i += 1)
            {
                string translated = GetTranslatedString(projectId, column, i);
                if (translated == sValue)
                    return FromInt(projectId, column, (int)i);
            }
            return FromInt(projectId, column, 0);
        }

 internal static HansoftEnumValue FromObject(HPMUniqueID projectId, EHPMProjectDefaultColumn column, object value)
 {
     if (value is HansoftEnumValue)
         return FromInt(projectId, column, ((HansoftEnumValue)value).iValue);
     else
     {
         string sValue = value.ToString();
         int iValue;
         if (Int32.TryParse(sValue, out iValue))
             return FromInt(projectId, column, iValue);
         else
             return FromString(projectId, column, sValue);
     }
 }

        protected void Page_Load(object sender, EventArgs e)
        {
            // The ID of the authenticated user
            FormsIdentity ID = (FormsIdentity)HttpContext.Current.User.Identity;
            m_ResourceID = new HPMUniqueID(Convert.ToInt32(ID.Name));
            m_NoUserID = new HPMUniqueID(-1);
            // Find context is empty but can be set by choosing a report or providing a search string
            m_FindContexts = new Dictionary<string, HPMFindContextData>();
            ErrorLabel.Visible = false;

            try
            {
                InitHansoftVirtualSession();
                m_UpdatedFromWeb = m_VirtSession.LocalizationCreateUntranslatedStringFromString("Updated from web integration sample");
                AddProjectControls();

                // update info contains info from callbacks about changed Hansoft elements
                HPMUpdateInfo update = Session["updateinfo"] as HPMUpdateInfo;

                if (!IsPostBack || update.FullUpdate)
                {
                    AddData();
                    update.FullUpdate = false;
                    // retain selected tab between postbacks (doesn't work for the first tab - TabContainer bug?) Uncomment it if you want to experiment with it
                    //if (Session["ActiveTabIndex"] != null)
                    //{
                    //    int storedIndex = (int)Session["ActiveTabIndex"];
                    //    TabContainer projectTabs = Page.FindControl("ProjectTabs") as TabContainer;
                    //    if (storedIndex <= projectTabs.Tabs.Count)
                    //        projectTabs.ActiveTabIndex = storedIndex;
                    //}
                    BindDataSources();
                }


            }
            catch (HPMSdkException error)
            {
                SetErrorMessage("An error occurred when communicating with the Hansoft server.", error.ErrorAsStr());
            }
            catch (HPMSdkManagedException error)
            {
                SetErrorMessage("An error occurred when communicating with the Hansoft server.", error.ErrorAsStr());
            }
        }

 private static Task CreateTask(HPMUniqueID uniqueID)
 {
     HPMUniqueID refTaskID = SdkSession.TaskRefGetTask(uniqueID);
     EHPMTaskLockedType lockedType = SdkSession.TaskGetLockedType(refTaskID);
     switch (lockedType)
     {
         case EHPMTaskLockedType.BacklogItem:
             if (SdkSession.UtilIsIDBacklogProject(SdkSession.TaskGetContainer(refTaskID)))
             {
                 if (SdkSession.TaskGetMainReference(refTaskID).m_ID == uniqueID.m_ID)
                     return ProductBacklogItem.GetProductBacklogItem(uniqueID, refTaskID);
                 else
                     return ProductBacklogItemInSprint.GetProductBacklogItemInSprint(uniqueID, refTaskID);
             }
             else
                 return SprintBacklogItem.GetSprintBacklogItem(uniqueID, refTaskID);
         case EHPMTaskLockedType.QABug:
             return Bug.GetBug(uniqueID, refTaskID);
         case EHPMTaskLockedType.SprintItem:
             return Sprint.GetSprint(uniqueID, refTaskID);
         case EHPMTaskLockedType.Normal:
         default:
             if (SdkSession.TaskGetForceSubProject(refTaskID))
             {
                 return SubProject.GetSubProject(uniqueID, refTaskID);
             }
             else
             {
                 EHPMTaskType taskType = SdkSession.TaskGetType(refTaskID);
                 switch (taskType)
                 {
                     case EHPMTaskType.Milestone:
                         return Release.GetRelease(uniqueID, refTaskID);
                     case EHPMTaskType.Planned:
                     default:
                         if (SdkSession.UtilIsIDBacklogProject(SdkSession.TaskGetContainer(refTaskID)))
                             return ProductBacklogItemInSchedule.GetProductBacklogItemInSchedule(uniqueID, refTaskID);
                         else
                             return ScheduledTask.GetScheduledTask(uniqueID, refTaskID);
                 }
             }
     }
 }

 internal Resource(HPMUniqueID uniqueID)
     : base(uniqueID)
 {
 }

 internal static Release GetRelease(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
 {
     return new Release(uniqueID, uniqueTaskID);
 }

 internal static ProductBacklogItemInSchedule GetProductBacklogItemInSchedule(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
 {
     return new ProductBacklogItemInSchedule(uniqueID, uniqueTaskID);
 }

 private static string GetTranslatedString(HPMUniqueID projectId, EHPMProjectDefaultColumn column, uint iValue)
 {
     HPMUntranslatedString unTranslated = SessionManager.Session.UtilGetColumnDataItemFormatted(projectId, column, iValue);
     HPMLanguage language = SessionManager.Session.LocalizationGetDefaultLanguage();
     String translated = SessionManager.Session.LocalizationTranslateString(language, unTranslated);
     return translated;
 }

 internal static ProductBacklogItem GetProductBacklogItem(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
 {
     return new ProductBacklogItem(uniqueID, uniqueTaskID);
 }

 private void CloneBugWorkflow(HPMUniqueID sourceQAProjectID, HPMUniqueID targetQAProjectID)
 {
 }

 internal static Project GetProject(HPMUniqueID uniqueID)
 {
     return new Project(uniqueID);
 }

 private Project(HPMUniqueID projID)
     : base(projID)
 {
 }

 private Sprint(HPMUniqueID uniqueID, HPMUniqueID refTaskID)
     : base(uniqueID, refTaskID)
 {
 }

 internal static Sprint GetSprint(HPMUniqueID uniqueID, HPMUniqueID uniqueTaskID)
 {
     return new Sprint(uniqueID, uniqueTaskID);
 }

 private ProductBacklogItemInSchedule(HPMUniqueID uniqueID, HPMUniqueID refTaskID)
     : base(uniqueID, refTaskID)
 {
 }