// Удаление позиций
        private static void DeletePositions()
        {
            var doc  = AcApp.DocumentManager.MdiActiveDocument;
            var ed   = doc.Editor;
            var db   = HostApplicationServices.WorkingDatabase;
            var opts = new PromptSelectionOptions
            {
                MessageForAdding = $"\n{Language.GetItem(LangItem, "h5")}: "
            };
            var res = ed.GetSelection(opts);

            if (res.Status != PromptStatus.OK)
            {
                return;
            }
            using (var tr = db.TransactionManager.StartTransaction())
            {
                try
                {
                    foreach (var objectId in res.Value.GetObjectIds())
                    {
                        var ent = (Entity)tr.GetObject(objectId, OpenMode.ForWrite);

                        // Расширенные данные в виде спец.класса
                        var productInsert = (MpProductToSave)XDataHelpersForProducts.NewFromEntity(ent);
                        if (productInsert == null)
                        {
                            continue;
                        }

                        // Теперь получаем сам продукт
                        var product = DbProduct.GetProductFromSaved(productInsert);

                        // Если есть данные и нет позиции
                        if (product != null)
                        {
                            product.Position = string.Empty;
                            XDataHelpersForProducts.SaveDataToEntity(product.SetProductToSave(), ent, tr);
                        }
                    }
                }
                catch (Exception ex)
                {
                    ExceptionBox.Show(ex);
                }
                finally
                {
                    // В любом случае убираем подсветку со всех объектов
                    foreach (var objectId in res.Value.GetObjectIds())
                    {
                        var ent = (Entity)tr.GetObject(objectId, OpenMode.ForWrite);
                        ent.Unhighlight();
                    }

                    tr.Commit();
                }
            }
        }
        public void AddPositions()
        {
#if !DEBUG
            Statistic.SendCommandStarting(new ModPlusConnector());
#endif

            var doc = AcApp.DocumentManager.MdiActiveDocument;
            var ed  = doc.Editor;
            var db  = doc.Database;

            var opts = new PromptSelectionOptions();
            opts.Keywords.Add(Language.GetItem(LangItem, "h2"));
            var kws = opts.Keywords.GetDisplayString(true);
            opts.MessageForAdding = $"\n{Language.GetItem(LangItem, "h1")}: {kws}";
            opts.KeywordInput    += (sender, e) =>
            {
                if (e.Input.Equals(Language.GetItem(LangItem, "h2")))
                {
                    DeletePositions();
                }
            };

            var res = ed.GetSelection(opts);
            if (res.Status != PromptStatus.OK)
            {
                return;
            }

            using (var tr = db.TransactionManager.StartTransaction())
            {
                try
                {
                    // Создаем список "элемент + марка" и список позиций
                    var elements      = new List <string>();
                    var elementsExist = new List <string>();
                    var positions     = new List <string>();
                    var markTypes     = new List <int>();

                    // Тип маркировки

                    foreach (var objectId in res.Value.GetObjectIds())
                    {
                        var ent = (Entity)tr.GetObject(objectId, OpenMode.ForWrite);

                        // Расширенные данные в виде спец.класса
                        var productInsert = (MpProductToSave)XDataHelpersForProducts.NewFromEntity(ent);
                        if (productInsert == null)
                        {
                            continue;
                        }

                        // Теперь получаем сам продукт
                        var product = DbProduct.GetProductFromSaved(productInsert);

                        // Если есть данные и нет позиции
                        if (product != null)
                        {
                            int markType;
                            if (string.IsNullOrEmpty(product.Position?.Trim()))
                            {
                                var element = product.GetNameByRule();
                                if (!element.Contains(product.BaseDocument.ShortName))
                                {
                                    element = $"{product.BaseDocument.ShortName} {element}";
                                }

                                // Если еще не было
                                if (!elements.Contains(element))
                                {
                                    // Подсвечиваем
                                    ent.Highlight();

                                    // Запрос пользователю
                                    var pso = new PromptStringOptions(
                                        $"{Language.GetItem(LangItem, "h3")}: {element}. {Language.GetItem(LangItem, "h4")}: ")
                                    {
                                        AllowSpaces = true
                                    };
                                    var pres = ed.GetString(pso);
                                    if (pres.Status != PromptStatus.OK)
                                    {
                                        ent.Unhighlight();
                                        continue;
                                    }

                                    elements.Add(element);
                                    positions.Add(pres.StringResult);
                                    product.Position = pres.StringResult;
                                    XDataHelpersForProducts.SaveDataToEntity(product.SetProductToSave(), ent, tr);

                                    // Маркировка
                                    AddPositionMarker(ent, 0, pres.StringResult, element, out markType);

                                    // Убираем подсветку
                                    ent.Unhighlight();
                                    markTypes.Add(markType);
                                }
                                else //// Если уже был
                                {
                                    product.Position = positions[elements.IndexOf(element)];
                                    XDataHelpersForProducts.SaveDataToEntity(product.SetProductToSave(), ent, tr);

                                    // Маркировка
                                    AddPositionMarker(ent, markTypes[elements.IndexOf(element)], positions[elements.IndexOf(element)], element, out markType);
                                }
                            }

                            // Если позиция уже есть
                            else
                            {
                                // Подсвечиваем
                                ent.Highlight();
                                var element = product.GetNameByRule();

                                // Если еще не было
                                if (!elementsExist.Contains(element))
                                {
                                    // Маркировка
                                    AddPositionMarker(ent, 0, product.Position, element, out markType);
                                    elements.Add(element);
                                    elementsExist.Add(element);
                                    markTypes.Add(markType);
                                }
                                else
                                {
                                    if (markTypes.Count > 0 & elements.Count > 0)
                                    {
                                        AddPositionMarker(ent, markTypes[elements.IndexOf(element)], product.Position, element, out markType);
                                    }
                                    else
                                    {
                                        AddPositionMarker(ent, 0, product.Position, element, out markType);
                                    }
                                }

                                // Убираем подсветку
                                ent.Unhighlight();
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    ExceptionBox.Show(ex);
                }
                finally
                {
                    // В любом случае убираем подсветку со всех объектов
                    foreach (var objectId in res.Value.GetObjectIds())
                    {
                        var ent = (Entity)tr.GetObject(objectId, OpenMode.ForWrite);
                        ent.Unhighlight();
                    }

                    tr.Commit();
                }
            }
        }
Example #3
0
        public static void AddLeaderWithMark()
        {
#if !DEBUG
            Statistic.SendCommandStarting(new ModPlusConnector());
#endif
            var doc = Autodesk.AutoCAD.ApplicationServices.Core.Application.DocumentManager.MdiActiveDocument;
            var ed  = doc.Editor;
            var db  = doc.Database;
            var res = ed.SelectImplied();
            if (res.Status != PromptStatus.OK)
            {
                return;
            }
            using (doc.LockDocument())
            {
                using (var tr = db.TransactionManager.StartTransaction())
                {
                    try
                    {
                        foreach (var objectId in res.Value.GetObjectIds())
                        {
                            var ent = (Entity)tr.GetObject(objectId, OpenMode.ForWrite);

                            // Расширенные данные в виде спец.класса
                            var productInsert = (MpProductToSave)XDataHelpersForProducts.NewFromEntity(ent);
                            if (productInsert == null)
                            {
                                continue;
                            }

                            // Теперь получаем сам продукт
                            var product = DbProduct.GetProductFromSaved(productInsert);

                            // Если есть данные и нет позиции
                            if (product != null)
                            {
                                var mark = product.GetNameByRule();

                                // Если в имени нет ShortName, то добавим
                                if (!mark.Contains(product.BaseDocument.ShortName))
                                {
                                    mark = $"{product.BaseDocument.ShortName} {mark}";
                                }

                                // Если есть длина
                                if (product.Length != null)
                                {
                                    mark += $" L={product.Length}";
                                }
                                AddLeaderMark(ent, mark);
                            }
                        }
                    }
                    catch (System.Exception ex)
                    {
                        ExceptionBox.Show(ex);
                    }
                    finally
                    {
                        tr.Commit();
                    }
                }
            }
        }
        private void FindProducts()
        {
            try
            {
                SpecificationItems = new List <mpProductInt.Specification.SpecificationItem>();

                var products       = new List <DbProduct>();
                var productsByAttr = new List <mpProductInt.Specification.SpecificationItem>();

                var counts       = new List <int>();
                var countsByAttr = new List <int>();

                for (var i = 0; i < _objectIds.Length; i++)
                {
                    // Проверяем - если это блок и он имеет атрибуты для спецификации
                    if (ProductsToTable.HasAttributesForSpecification(_tr, _objectIds[i]))
                    {
                        // post progress
                        _context.Post(
                            _ =>
                        {
                            ProgressBar.Value = i;
                            ProgressText.Text = $"{i}/{_objectIds.Length}";
                        }, null);

                        var specificationItemByBlockAttributes =
                            ProductsToTable.GetProductFromBlockByAttributes(_tr, _objectIds[i]);
                        if (specificationItemByBlockAttributes != null)
                        {
                            if (!productsByAttr.Any(p => p.Equals(specificationItemByBlockAttributes)))
                            {
                                productsByAttr.Add(specificationItemByBlockAttributes);
                                countsByAttr.Add(1);
                            }
                            else
                            {
                                for (var j = 0; j < productsByAttr.Count; j++)
                                {
                                    if (productsByAttr[j].Equals(specificationItemByBlockAttributes))
                                    {
                                        countsByAttr[j]++;
                                    }
                                }
                            }
                        }
                    }
                    else //// Иначе пробуем читать из расширенных данных
                    {
                        var entity = (Entity)_tr.GetObject(_objectIds[i], OpenMode.ForRead);
                        if (!entity.IsModPlusProduct())
                        {
                            continue;
                        }

                        // post progress
                        _context.Post(
                            _ =>
                        {
                            ProgressBar.Value = i;
                            ProgressText.Text = $"{i}/{_objectIds.Length}";
                        }, null);

                        if (XDataHelpersForProducts.NewFromEntity(entity) is MpProductToSave mpProductToSave)
                        {
                            var productFromSaved = DbProduct.GetProductFromSaved(mpProductToSave);
                            if (productFromSaved != null)
                            {
                                if (!products.Contains(productFromSaved))
                                {
                                    products.Add(productFromSaved);
                                    counts.Add(1);
                                }
                                else
                                {
                                    var index = products.IndexOf(productFromSaved);
                                    counts[index]++;
                                }
                            }
                        }
                    }
                }

                if (!products.Any() & !productsByAttr.Any())
                {
                    DialogResult = false;
                    Close();
                }

                // Для продуктов собранных из атрибутов вставляем количество
                for (var i = 0; i < productsByAttr.Count; i++)
                {
                    productsByAttr[i].Count = countsByAttr[i].ToString();
                }

                // Добавляем продукты собранные из расширенных данных
                for (var j = 0; j < products.Count; j++)
                {
                    var specificationItem = products[j].GetSpecificationItem(counts[j]);
                    SpecificationItems.Add(specificationItem);
                }

                // Добавляем продукты, собранные из атрибутов
                foreach (var specificationItem in productsByAttr)
                {
                    SpecificationItems.Add(specificationItem);
                }

                // Сортировка по значению Позиции
                SpecificationItems.Sort(new mpProductInt.Specification.AlphanumComparatorFastToSortByPosition());
            }
            catch (Exception exception)
            {
                ExceptionBox.Show(exception);
            }
        }