public AsyncObservableCollection <T> ToCollection()
        {
            AsyncObservableCollection <T> newList = new AsyncObservableCollection <T>();

            lock (SyncObject)
            {
                int index = 0;
                while (index < _list.Count)
                {
                    newList.Add(_list[index]);
                    index++;
                }
            }

            return(newList);
        }
Example #2
0
        public virtual void SetFieldAllowedValues(string propName, AllowedValue value)
        {
            if (FieldAllowedValues == null)
            {
                FieldAllowedValues = new Dictionary <string, AsyncObservableCollection <AllowedValue> >();
            }

            if (!FieldAllowedValues.ContainsKey(propName))
            {
                FieldAllowedValues.Add(propName, new AsyncObservableCollection <AllowedValue>());
            }

            AsyncObservableCollection <AllowedValue> propValues = FieldAllowedValues[propName];

            propValues.Add(value);
        }
Example #3
0
        //------------------------------------------------------------------------------------
        /// <summary>
        /// Returns an array of strings representing all the values in the specified enum
        /// type.
        /// </summary>
        //------------------------------------------------------------------------------------
        public static AsyncObservableCollection <string> GetEnumValues <T>(bool excludeWildcardValues = false)
        {
            Array enumValues = typeof(T).GetEnumValues();
            AsyncObservableCollection <string> values = new AsyncObservableCollection <string>();

            foreach (T enumVal in enumValues)
            {
                string enumText = EnumToString <T>(enumVal);
                if (!excludeWildcardValues || (!enumText.StartsWith("<") && !enumText.StartsWith("aa")))
                {
                    values.Add(enumText);
                }
            }

            return(values);
        }
Example #4
0
        public AsyncObservableCollection <FileAttachment> GetAttachedFiles(StoreItem storeItem)
        {
            AsyncObservableCollection <FileAttachment> files = new AsyncObservableCollection <FileAttachment>();
            DatastoreItem dsItem = storeItem.DSItem;

            OpenForRead(dsItem);
            foreach (ProductStudio.File file in dsItem.Files)
            {
                if (!IsInternalAttachedFile(file.FileName))
                {
                    files.Add(new FileAttachment(file));
                }
            }

            return(files);
        }
Example #5
0
        //------------------------------------------------------------------------------------
        /// <summary>
        /// Returns the file names of all the attached files for this item.
        /// </summary>
        //------------------------------------------------------------------------------------
        public AsyncObservableCollection <string> GetAttachedFileNames(StoreItem storeItem)
        {
            AsyncObservableCollection <string> filenames = new AsyncObservableCollection <string>();
            DatastoreItem dsItem = storeItem.DSItem;

            OpenForRead(dsItem);
            foreach (ProductStudio.File file in dsItem.Files)
            {
                // Exclude internal-use-only attached files.
                if (!IsInternalAttachedFile(file.FileName))
                {
                    filenames.Add(file.FileName);
                }
            }

            return(filenames);
        }
Example #6
0
        public AsyncObservableCollection <string> GetAllBugAssignedToValues()
        {
            AsyncObservableCollection <string> assignedToValues = new AsyncObservableCollection <string>();

            assignedToValues.Add(Constants.c_All);

            AsyncObservableCollection <PlannerBugItem> bugs = new AsyncObservableCollection <PlannerBugItem>();

            foreach (PlannerBugItem bug in bugs)
            {
                if (!assignedToValues.Contains(bug.BugAssignedTo))
                {
                    assignedToValues.Add(bug.BugAssignedTo);
                }
            }

            return(assignedToValues);
        }
Example #7
0
        //------------------------------------------------------------------------------------
        /// <summary>
        /// Returns a list of all the allowed values for the given Product Studio field.  This
        /// assumes that this property does not depend on the value of any other property for
        /// its state.
        /// </summary>
        //------------------------------------------------------------------------------------
        public virtual AsyncObservableCollection <AllowedValue> GetFieldAllowedValues(string propName, AllowedValue firstValue = null)
        {
            AsyncObservableCollection <AllowedValue> allowedValues = GetFieldAllowedValues(CreateDSItem(), propName);

            if (allowedValues.Count == 0)
            {
                if (FieldAllowedValues.ContainsKey(propName))
                {
                    allowedValues = FieldAllowedValues[propName];
                }
            }

            if (firstValue != null)
            {
                allowedValues.Insert(0, firstValue);
            }

            return(allowedValues);
        }
Example #8
0
        public StoreItem()
        {
            m_id = 0;
            SyncLockItemProperties  = new object();
            SyncLockLocalProperties = new object();
            ItemProperties          = new Dictionary <string, ItemProperty>();
            m_changedProperties     = new AsyncObservableCollection <ItemProperty>();

            ItemDocuments = new DocumentAttachmentCollection(this);
            ItemImages    = new ImageAttachmentCollection(this);
            SelfList      = new StoreItemCollection <StoreItem>();
            SelfList.Add(this);

            AttachedFileNamesToCommit = null;

            UncommittedGuid   = Guid.NewGuid();
            PersistState      = PersistStates.Dummy;
            IsInImmediateSave = false;
            CommitErrorState  = CommitErrorStates.NoError;
        }
Example #9
0
        //------------------------------------------------------------------------------------
        /// <summary>
        /// Returns a list of all the allowed values for the given Product Studio field, given
        /// the current state of the given item.
        /// </summary>
        //------------------------------------------------------------------------------------
        private AsyncObservableCollection <AllowedValue> GetFieldAllowedValues(DatastoreItem dsItem, string propName)
        {
            AsyncObservableCollection <AllowedValue> valueList = new AsyncObservableCollection <AllowedValue>();

            if (dsItem != null)
            {
                ProductStudio.Field  field  = dsItem.Fields[propName];
                ProductStudio.Values values = field.ValidValues;
                foreach (object value in values)
                {
                    valueList.Add(new AllowedValue {
                        Value = value
                    });
                }

                ResetDSItem(dsItem);
            }

            return(valueList);
        }
Example #10
0
        public static bool IsWorkDay(DateTime date, AsyncObservableCollection <OffTimeItem> offTimeItems)
        {
            if (IsWorkDay(date))
            {
                if (offTimeItems.Count > 0)
                {
                    foreach (OffTimeItem offTimeItem in offTimeItems)
                    {
                        if (date >= offTimeItem.StartDate && date <= offTimeItem.EndDate)
                        {
                            return(false);
                        }
                    }
                }

                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #11
0
        //------------------------------------------------------------------------------------
        /// <summary>
        /// GetNetWorkingHours - Returns the total number of working hours available between
        /// the two given days, taking into account weekends and company holidays.
        ///
        /// </summary>
        //------------------------------------------------------------------------------------
        public static int GetNetWorkingHours(DateTime startDate, DateTime endDate, AsyncObservableCollection <OffTimeItem> offTimeItems)
        {
            int netWorkingDays = GetNetWorkingDays(startDate, endDate, offTimeItems);

            return(netWorkingDays * WorkHoursPerDay);
        }
Example #12
0
 public void RefreshAttachedFileInfo()
 {
     m_attachedFiles = null;
     NotifyPropertyChanged(() => AttachedFiles);
     NotifyPropertyChanged(() => AttachedFilesCount);
 }
Example #13
0
        void UpdateTimer_Tick(object sender, System.EventArgs e)
        {
            if (!CreateProductGroupOperationInProgress)
            {
                // Show ProductGroupEditor with a newly created product group
                if (ProductGroupStage == ProductGroupStages.ShowCreateProductGroupDialog)
                {
                    CreateProductGroupOperationInProgress = true;
                    ProductGroupStage = ProductGroupStages.CreateProductGroupDialogActive;

                    if (NewProductGroupItem == null)
                    {
                        NewProductGroupItem = ScheduleStore.Instance.CreateStoreItem <ProductGroupItem>(ItemTypeID.ProductGroup);
                    }

                    //ProductGroupEditor dialog = new ProductGroupEditor(this, NewProductGroupItem);
                    //dialog.ShowDialog();

                    //if (dialog.WelcomeState == PlannerNameSpace.WelcomeState.Ok)
                    //{
                    //    Planner.Instance.ItemRepository.DiscoverGroupMembers(NewProductGroupItem);
                    //}
                }

                // Show ProductGroupEditor to edit an existing group
                else if (ProductGroupStage == ProductGroupStages.ShowEditProductGroupDialog)
                {
                    CreateProductGroupOperationInProgress = true;
                    ProductGroupStage = ProductGroupStages.EditProductGroupDialogActive;

                    //ProductGroupEditor dialog = new ProductGroupEditor(this, SelectedProductGroupItem);
                    //dialog.ShowDialog();

                    //if (dialog.WelcomeState == PlannerNameSpace.WelcomeState.Ok)
                    //{
                    //    SelectedProductGroupItem.BeginSaveImmediate();
                    //    ExistingProductGroupAliasesChanged = dialog.AliasesChanged;
                    //    SelectedProductGroupItem.SaveImmediate();
                    //}
                    //else
                    //{
                    //    CreateProductGroupOperationInProgress = false;
                    //}
                }

                // The discovery of members for a new product group has completed
                else if (ProductGroupStage == ProductGroupStages.GroupMemberDiscoveryCompleted)
                {
                    AsyncObservableCollection <MemberDescriptor> discoveredGroupMembers = Planner.Instance.ItemRepository.DiscoveredGroupMembers;
                    //ConfirmNewProductGroupDialog dialog = new ConfirmNewProductGroupDialog(this, NewProductGroupItem, discoveredGroupMembers);
                    //dialog.ShowDialog();

                    //if (dialog.DialogConfirmed)
                    //{
                    //    CreateProductGroupOperationInProgress = true;
                    //    NewProductGroupItem.HostItemStoreName = HostItemStore.Instance.StoreName;
                    //    NewProductGroupItem.SaveNewItem();
                    //    ProductGroupStage = ProductGroupStages.CreatingProductGroupItem;
                    //    Planner.Instance.ItemRepository.CommitChanges(true);
                    //}
                    //else
                    //{
                    //    ProductGroupStage = ProductGroupStages.ShowCreateProductGroupDialog;
                    //    CreateProductGroupOperationInProgress = false;
                    //}
                }

                // The commit of the new ProductGroupItem has completed.
                else if (ProductGroupStage == ProductGroupStages.CreatingProductGroupItemCompleted)
                {
                    NewProductGroupItem.ParentProductGroupKey = NewProductGroupItem.StoreKey;
                    EnsureProductGroupGridItems();
                    Planner.Instance.ItemRepository.CreateDiscoveredGroupMembers(NewProductGroupItem.StoreKey);
                }

                // The creation of previously discovered members for a new product group has completed.
                else if (ProductGroupStage == ProductGroupStages.CreateDiscoveredGroupMembersCompleted)
                {
                    // Now commit all the newly discovered members
                    CreateProductGroupOperationInProgress = true;
                    ProductGroupStage = ProductGroupStages.CommittingDiscoveredGroupMembers;
                    Planner.Instance.ItemRepository.CommitChanges(true);
                }

                // The creation of a new product group is fully completed
                else if (ProductGroupStage == ProductGroupStages.CommittingDiscoveredGroupMembersCompleted)
                {
                    CreateProductGroupOperationInProgress = true;
                    ProductGroupStage = ProductGroupStages.EndOfCycle;

                    //NewProductGroupSuccessfulDialog dialog = new NewProductGroupSuccessfulDialog(this, NewProductGroupItem);
                    //dialog.ShowDialog();

                    //if (dialog.SuccessResult == SuccessResult.Open)
                    //{
                    //    SelectedProductGroupItem = NewProductGroupItem;
                    //    WelcomeState = PlannerNameSpace.WelcomeState.Open;
                    //    Dialog.Close();
                    //}
                }

                else if (ProductGroupStage == ProductGroupStages.UpdateExistingProductGroupCompleted)
                {
                    ProductGroupStage = ProductGroupStages.RebuildingProductGroupMembership;
                    if (ExistingProductGroupAliasesChanged)
                    {
                        CreateProductGroupOperationInProgress = true;
                        Planner.Instance.ItemRepository.RebuildProductGroupMembership(SelectedProductGroupItem);
                    }
                    else
                    {
                        ProductGroupStage = ProductGroupStages.EditProductGroupCompleted;
                    }
                }

                else if (ProductGroupStage == ProductGroupStages.ProductGroupMembershipRebuildComplete)
                {
                    CreateProductGroupOperationInProgress = true;
                    Planner.Instance.ItemRepository.CommitChanges(true);
                }

                else if (ProductGroupStage == ProductGroupStages.EditProductGroupCompleted)
                {
                    ProductGroupStage = ProductGroupStages.EndOfCycle;
                    if (ExistingProductGroupAliasesChanged && SelectedProductGroupItem == Planner.Instance.ItemRepository.CurrentProductGroup && Planner.Instance.IsStartupComplete)
                    {
                        Result = DialogResult.Restart;
                        Dialog.Close();
                    }
                }
            }
        }
Example #14
0
 public static T GetItem <T>(this AsyncObservableCollection <T> collection, int idx)
 {
     return(collection[idx]);
 }