Ejemplo n.º 1
0
        /// <summary>
        /// Возможность редактирования объекта, если можно true, иначе   false
        /// </summary>
        static bool CanEditObject(ReferenceObject projectElement)
        {
            if (projectElement == null)
            {
                return(false);
            }

            projectElement.Unlock();
            if (projectElement.CanEdit)
            {
                try
                {
                    projectElement.BeginChanges();
                    projectElement.EndChanges();
                }
                catch (ObjectLockErrorException)
                {
                    return(false);
                }
                finally
                {
                    projectElement.Unlock();
                }

                return(true);
            }
            else
            {
                return(false);
            }
        }
Ejemplo n.º 2
0
        /// <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
                                                                                            , Guid?PlanningSpaceForNewRes_Guid = null, Guid?PlanningSpaceForCheck_Guid = null, bool onlyPlanningRes = false)
        {
            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);
        }