/// <summary>
        /// Получить  нерасходуемые ресурсы
        /// </summary>
        /// <param name="ro"></param>
        /// <returns></returns>
        static public IEnumerable <UsedResource> GetLinkedUsedNonConsumableResources(ReferenceObject ro, bool IsOnlyPlanned)
        {
            List <ReferenceObject> resources = ro.GetObjects(ProjectManagementWork.PM_link_UsedResources_GUID)
                                               .Where(res => (res.Class == References.Class_NonConsumableResources)).ToList();

            List <UsedResource> NonConsumableResources = new List <UsedResource>();

            //Console.WriteLine("IsOnlyPlanned " + IsOnlyPlanned);

            foreach (var res in resources)
            {
                UsedResource usedResource = new UsedResource(res);


                if (IsOnlyPlanned)
                {
                    if (usedResource.IsPlanned)
                    {
                        NonConsumableResources.Add(usedResource);
                    }
                }
                else
                {
                    NonConsumableResources.Add(usedResource);
                }
            }

            return(NonConsumableResources);
        }
        /// <summary>
        /// Метод копирования используемых ресурсов
        /// </summary>
        /// <param name="owner">Элемент проекта в который копируем используемые ресурсы</param>
        /// <param name="whence">Элемент проекта с которого копируем используемые ресурс</param>
        /// <param name="PlanningSpaceForNewRes_Guid">Пространство планирования для новых ресурсов</param>
        /// <param name="PlanningSpaceForCheck_Guid">Копировать ресурсы только из этого пространства планирования</param>
        /// <returns></returns>
        public static bool СкопироватьИспользуемыеРесурсы_изЭлементаПроекта_вЭлементПроекта(ReferenceObject owner, ReferenceObject whence
                                                                                            , bool onlyPlanningRes, Guid?PlanningSpaceForNewRes_Guid = null, Guid?PlanningSpaceForCheck_Guid = null)
        {
            if (owner == null || whence == null)
            {
                return(false);
            }

            //получение списка используемых ресурсов с детализации
            var usedResources = ProjectManagementWork.GetLinkedUsedNonConsumableResources(whence, onlyPlanningRes)
                                .Where(UseRes =>
            {
                var currentGuidPlanningSpaceRes = UsedResource.GetPlanningSpaceUsedResource(UseRes.ReferenceObject);

                if (PlanningSpaceForCheck_Guid != null && PlanningSpaceForCheck_Guid != currentGuidPlanningSpaceRes)
                {
                    return(false);
                }


                ReferenceObject NonExpendableResource = null;

                //Получаем Ресурс из справочника Ресурсы
                NonExpendableResource = UsedResource.GetResourcesLink(UseRes.ReferenceObject);

                if (NonExpendableResource == null)
                {
                    //MessageBox.Show("NonExpendableResource == null");
                    return(false);
                }

                //Проверка ресурса на тип
                switch (NonExpendableResource.Class.Name)
                {
                case "Оборудование и оснастка":
                    { return(false); }

                case "Оснащение":
                    { return(false); }

                case "Комплектующие":
                    { return(false); }

                case "Ресурсы материалов":
                    { return(false); }
                }

                return(true);
            }).ToList();

            if (usedResources.Count() == 0)
            {
                return(true);
            }

            var result = new List <ReferenceObject>(usedResources.Count);

            //цикл копирования используемых ресурсов с детализации, в справочник используемыее ресурсы
            foreach (var usedResource in usedResources)
            {
                //Здесь дописать копирование нужных параметров и связей
                var newResourceUsed = usedResource.ReferenceObject.CreateCopy(usedResource.ReferenceObject.Class);

                // var newResourceUsed = ResourceUsed.CreateReferenceObject(null, ResourceUsed.Classes.Find(Dinamika.Guids.ResourceUsedReference.TypeNonExpendableResourcesUsedReferenceObject_Guid));

                /*
                 * //Получаем Ресурс из справочника Ресурсы
                 * var NonExpendableResource = usedResource.GetObject(Guids.ResourceUsedReference.Links.ResourcesLink_Guid);
                 *
                 * newResourceUsed[Guids.ResourceUsedReference.Name_Guid].Value = usedResource[Guids.ResourceUsedReference.Name_Guid].Value;
                 *
                 * if (NonExpendableResource != null)
                 *  newResourceUsed.SetLinkedObject(Guids.ResourceUsedReference.Links.ResourcesLink_Guid, NonExpendableResource);
                 *
                 * newResourceUsed[Guids.ResourceUsedReference.Number_Guid].Value = usedResource[Guids.ResourceUsedReference.Number_Guid].Value;
                 *
                 *
                 * newResourceUsed[Guids.ResourceUsedReference.BeginDate_Guid].Value = usedResource[Guids.ResourceUsedReference.BeginDate_Guid].Value;
                 * newResourceUsed[Guids.ResourceUsedReference.EndDate_Guid].Value = usedResource[Guids.ResourceUsedReference.EndDate_Guid].Value;
                 *
                 * newResourceUsed[Guids.ResourceUsedReference.FactValue_Guid].Value = usedResource[Guids.ResourceUsedReference.FactValue_Guid].Value;
                 * newResourceUsed[Guids.ResourceUsedReference.FixNumber_Guid].Value = usedResource[Guids.ResourceUsedReference.FixNumber_Guid].Value;
                 */

                if (PlanningSpaceForNewRes_Guid != null && PlanningSpaceForNewRes_Guid != Guid.Empty)
                {
                    if (!newResourceUsed.Changing)
                    {
                        newResourceUsed.BeginChanges();
                    }
                }
                {
                    newResourceUsed[UsedResource.param_PlanningSpace_Guid].Value = PlanningSpaceForNewRes_Guid;
                }
                //else
                //newResourceUsed[Guids.ResourceUsedReference.PlanningSpace_Guid].Value = Project(owner)[Dinamika.Guids.ProjectManagementReference.TypeProjectElement.PlanningSpace_Guid].Value;

                /*
                 *              //в библиотеке TF - isActual
                 *              newResourceUsed[Guids.ResourceUsedReference.FactValue_Guid].Value = usedResource[Guids.ResourceUsedReference.FactValue_Guid].Value;
                 *
                 *              //ResourceGroupLin
                 *              newResourceUsed.SetLinkedObject(Guids.ResourceUsedReference.Links.ResourceGroup_Nto1_Guid, usedResource.GetResourceGroupLink());
                 *
                 *              newResourceUsed[Guids.ResourceUsedReference.Workload_Guid].Value = usedResource[Guids.ResourceUsedReference.Workload_Guid].Value;
                 */
                newResourceUsed.EndChanges();


                //WaitingHelper.SetText(string.Format("Добавление ресурса {0} в элемент проекта {1}", newResourceUsed.ToString(), owner.ToString()));

                // newResourceUsed.Reload();

                result.Add(newResourceUsed);
            }


            //подключаем используемые ресурсы к элемент укрумения
            if (CanEditObject(owner) == false)
            {
                return(false);
            }

            owner.BeginChanges();

            foreach (var newResource in result)
            {
                // if (newResource.Changing)
                //     newResource.EndChanges();
                ProjectManagementWork.AddResource(owner, newResource);
                //owner.AddLinkedObject(Guids.ProjectManagementReference.TypeProjectElement.Links.ProjectElementResLinks_1toN_Guid, newResource);
            }

            owner.EndChanges();

            owner.Unlock();

            //пересчитываем суммарные трудозатраты
            RecalcResourcesWorkLoad(owner);

            return(true);
        }
 static public void AddResource(ReferenceObject projectElement, UsedResource newUsedResource)
 {
     AddResource(projectElement, newUsedResource.ReferenceObject);
 }
 internal void AddResource(UsedResource newUsedResource)
 {
     AddResource(this.ReferenceObject, newUsedResource);
     _PlannedNonConsumableResources = null;
 }