protected void Page_Load(object sender, EventArgs e)
        {
            // выбираем значения из post запроса
            Guid[] prods = Request["products"].Split(',').Select(p => new Guid(p)).ToArray(); //120420
               // List<Guid> prods = Request["products"].Split(',').Select(p => new Guid(p)).ToList();
            //Guid srcProductID = new Guid(Request["left_uid"]);
            Guid dstProductID = new Guid(Request["right_uid"]);
               //List<string> qdus_new = Request["qdus_new"].Split(',').ToList<string>(); //120420
            string[] qdus_new = Request["qdus_new"].Split(',').ToArray(); //120420
            string[] pdps = Request["pdps"].Split(',').ToArray(); //120420
            Guid umid = new Guid(Request["umid"]);

            // для каждого продукта в списке [products] выполняем
            // замену исходного продукта на целевой
               // foreach (Guid prod in prods) //120420
             for (int i = 0; i < prods.Length; i++) //120420

            {
                 using (ProductProvider provider = new ProductProvider())
                {

                      // создаём новую версию продукта
                    Guid newprod = provider.CreateNewVersionOfProduct(prods[i], Guid.Empty);

                    // берём все исходные детали для замены
                    // их может быть несколько
              //      List<Aspect.Domain.Configuration> srcConfs, dstConfs;
                    Aspect.Domain.Configuration dstConf;
              //                  srcConfs = provider.Configurations.Where(p => p.ProductOwnerID == newprod && p.ProductID == srcProductID).ToList();
                    //srcConfs = provider.Configurations.Where(p => p.ProductOwnerID == newprod).ToList();
                    dstConf = new Aspect.Domain.Configuration();

                    // создаём на базе исходных деталей - целевые с такими же параметрами
                            dstConf.ID = Guid.NewGuid();
                            dstConf.ProductOwnerID = newprod;
                            dstConf.ProductID = dstProductID;
                            dstConf.Quantity = Convert.ToDecimal(qdus_new[i]);
                            dstConf.Position = pdps[i];
                            dstConf.QuantityInclusive=1;
                            dstConf._dictUMID = umid;

                     provider.Configurations.InsertOnSubmit(dstConf);
                    provider.SubmitChanges();
                      // устанавливаем признак основной версии
                    ProductProperty prop = provider.ProductProperties.Where(
                        p => p.ProductID == newprod &&
                        p.PropertyID == new Guid("BBE170B0-28E4-4738-B365-1038B03F4552")).Single();
                    prop.Value = "1";
                    provider.SubmitChanges();

                 }

            }
        }
Beispiel #2
0
 /// <summary>
 /// Копирование всей спецификации из одного продукта в другой
 /// </summary>
 public void CopyConfiguration(Guid fromProductID, Guid toProductID, Guid UserID)
 {
     // копирование по аналогу вместе с составом
     using (CommonDomain domain = new CommonDomain())
     {
         var confs = from p in domain.Configurations
                     where p.ProductOwnerID == fromProductID
                     select p;
         foreach (Aspect.Domain.Configuration conf in confs)
         {
             Aspect.Domain.Configuration confRow = new Aspect.Domain.Configuration();
             confRow.AutoUpdate = conf.AutoUpdate;
             confRow.Comment = conf.Comment;
             confRow.GroupNumber = conf.GroupNumber;
             confRow.GroupToChange = conf.GroupToChange;
             confRow.Position = conf.Position;
             confRow.Quantity = conf.Quantity;
             confRow.QuantityInclusive = conf.QuantityInclusive;
             confRow.Zone = conf.Zone;
             confRow._dictUMID = conf._dictUMID;
             confRow.dt_upd = conf.dt_upd;
             if (Guid.Empty.Equals(conf.UserID))
             {
                 confRow.UserID = UserID;
             }
             else
             {
                 confRow.UserID = conf.UserID;
             }
             confRow.ID = Guid.NewGuid();
             confRow.ProductOwnerID = toProductID;
             confRow.ProductID = conf.ProductID;
             domain.Configurations.InsertOnSubmit(confRow);
         }
         domain.SubmitChanges();
     }
 }
Beispiel #3
0
        protected void Save_Click(object sender, EventArgs e)
        {
            this.Validate();
            if (this.IsValid)
            {
                // Проверяем, является ли продукт основной версией
                ProductProvider productProvider = new ProductProvider();
                if (productProvider.IsMainVersion(this.ProductID))
                {
                    LabelErrorMessage.Text = "[ ! ] Содержащий данную спецификацию продукт является основной версией. Сохранение отменено.";
                    return;
                }

                JavaScriptSerializer js = new JavaScriptSerializer();
                List<Dictionary<string, string>> rows = js.Deserialize<List<Dictionary<string, string>>>(hiddenStoreData.Value.ToString());
                EditConfigurationProvider provider = new EditConfigurationProvider();
                List<GridColumn> gridColumns = provider.GetGridColumns();

                // Сохраняем данные, полученные от пользователя в списке конфигураций
                List<Aspect.Domain.Configuration> result = new List<Aspect.Domain.Configuration>();
                #region convert Request to list of Configuration
                foreach (Dictionary<string, string> row in rows)
                {
                    Guid productID = new Guid(row["ID"]);
                    Aspect.Domain.Configuration conf = new Aspect.Domain.Configuration();
                    conf.ID = new Guid(row["ConfID"]);
                    conf.ProductID = productID;
                    conf.ProductOwnerID = this.ProductID;
                    conf.UserID = this.User.ID;

                    foreach (GridColumn column in gridColumns)
                    {
                        if (column is EditableGridColumn)
                        {
                            System.Reflection.PropertyInfo prop = typeof(Aspect.Domain.Configuration).GetProperty(column.DataItem);
                            if (prop.PropertyType == typeof(decimal) || prop.PropertyType == typeof(Nullable<decimal>))
                            {
                                prop.SetValue(conf, Convert.ToDecimal(row[column.DataItem]), null);
                            }
                            else if (prop.PropertyType == typeof(int) || prop.PropertyType == typeof(Nullable<int>))
                            {
                                prop.SetValue(conf, Convert.ToInt32(row[column.DataItem]), null);
                            }
                            else if (prop.PropertyType == typeof(Guid) || prop.PropertyType == typeof(Nullable<Guid>))
                            {
                                prop.SetValue(conf, new Guid(row[column.DataItem]), null);
                            }
                            else if (prop.PropertyType == typeof(Boolean) || prop.PropertyType == typeof(Nullable<Boolean>))
                            {
                                prop.SetValue(conf, Convert.ToBoolean(row[column.DataItem]), null);
                            }
                            else
                            {
                                prop.SetValue(conf, row[column.DataItem], null);
                            }
                        }
                    }

                    result.Add(conf);
                }
                #endregion

                using (CommonDomain domain = new CommonDomain())
                {
                    // Проверка на включение материалов
                    #region check_including_material
                    foreach (Aspect.Domain.Configuration conf in result)
                    {
                        Product prod = domain.Products.Single(p => p.ID == conf.ProductID);
                        if (prod._dictNomen.cod >= 1000000)
                        {
                            LabelErrorMessage.Text = "[ ! ] Обнаружены материалы в спецификации. Сохранение отменино.";
                            return;
                        }
                    }
                    #endregion

                    // Проверка на циклы
                    #region check_for_cycles
                    Guid dictNomenID = (Guid) (from p in domain.Products
                                               where p.ID == this.ProductID
                                               select p).Single()._dictNomenID;
                    foreach (Aspect.Domain.Configuration conf in result)
                    {
                        Product prod = domain.Products.Where(p => p.ID == conf.ProductID).Single();
                        if (dictNomenID == prod._dictNomenID)
                        {
                            LabelErrorMessage.Text = "[ ! ] Обнаружены циклические включения продуктов в спецификацию. Сохранение отменино.";
                            return;
                        }
                        if (fnCheckContains(dictNomenID, prod.ID))
                        {
                            LabelErrorMessage.Text = "[ ! ] Обнаружены циклические включения продуктов в спецификацию. Сохранение отменино.";
                            return;
                        }
                    }
                    #endregion
                }

                provider.SaveProductConfiguration(this.ProductID, result, this.User.ID);

                // установка признака "Основная версия"
                if (MadeBasicVersion.Checked)
                {
                    productProvider.SetMainVersion(this.User.ID, new List<Guid>{ProductID});
                }

                // устанавливаем основание изменений
                if (!String.IsNullOrEmpty(ReasonChanges.Text))
                {
                    ProductProperty reasonProperty = productProvider.ProductProperties.SingleOrDefault(
                        pr => pr.PropertyID == new Guid("C266B994-9740-41F6-94DD-07EA5B5FA34A")
                        && pr.ProductID == this.ProductID);

                    if (reasonProperty == null)
                    {
                        reasonProperty = new ProductProperty()
                        {
                            ID = Guid.NewGuid(),
                            PropertyID = new Guid("C266B994-9740-41F6-94DD-07EA5B5FA34A"),
                            ProductID = this.ProductID,
                            Value = ReasonChanges.Text
                        };
                        productProvider.ProductProperties.InsertOnSubmit(reasonProperty);
                    }
                    else
                    {
                        reasonProperty.Value = ReasonChanges.Text;
                    }
                    productProvider.SubmitChanges();
                }

                // Очищаем сообщение об ошибке и обновляем данные о спецификации
                LabelErrorMessage.Text = "";
                this.BindGridColumns2();
                this.BindData(new Dictionary<Guid, Guid>());
            }
        }