Пример #1
0
        public void UpdateImageFile(ImageInformation imgInfo)
        {
            ImageFile imgData = database.ImageFiles.FirstOrDefault(i => i.ImageID == imgInfo.ImageID);

            if (imgData == null)
            {
                throw new Exception("Cannot find Image record.");
            }

            imgData.Caption              = imgInfo.Caption;
            imgData.HasPeople            = imgInfo.HasPeople;
            imgData.ImageType            = imgInfo.ImageType;
            imgData.Keyword              = imgInfo.Keywords;
            imgData.FeaturedEdge         = imgInfo.FeaturedEdge;
            imgData.FeaturedPull         = imgInfo.FeaturedPull;
            imgData.ImageContent         = imgInfo.ImageContent;
            imgData.FeaturedFinish       = imgInfo.FeaturedFinish;
            imgData.FinishType           = imgInfo.FinishType;
            imgData.FinishCode           = imgInfo.FinishCode;
            imgData.LaminatePattern      = imgInfo.LaminatePattern;
            imgData.LaminateIsTFL        = imgInfo.LaminateIsTFL;
            imgData.LaminateIsHPL        = imgInfo.LaminateIsHPL;
            imgData.VeneerGrade          = imgInfo.VeneerGrade;
            imgData.VeneerSpecies        = imgInfo.VeneerSpecies;
            imgData.SeatingGrade         = imgInfo.SeatingGrade;
            imgData.TableBase            = imgInfo.FeaturedTableBase;
            imgData.TableShape           = imgInfo.FeaturedTableShape;
            imgData.ControlMechanism     = imgInfo.ControlMechanism;
            imgData.ControlDescription   = imgInfo.ControlDescription;
            imgData.GoToGuidePage        = imgInfo.GoToGuidePageNum;
            imgData.ImageApplicationList = imgInfo.ImageApplication;

            imgData.ImageFileSerieses.ToList().ForEach(st => database.ImageFileSerieses.Remove(st));

            var rSeries = database.Serieses.FirstOrDefault(s => s.Name == imgInfo.FeaturedSeries);

            if (rSeries != null)
            {
                ImageFileSeries ifsData = new ImageFileSeries();
                ifsData.IsFeatured = true;
                ifsData.Series     = rSeries;
                ifsData.ImageFile  = imgData;
                database.ImageFileSerieses.Add(ifsData);
                imgData.FeaturedSeries = rSeries.Name;
            }
            else
            {
                imgData.FeaturedSeries = null;
            }

            if ((imgInfo.SeriesList ?? "").Any())
            {
                foreach (var indVal in imgInfo.SeriesList.Split(',').Select(s => s.Trim()))
                {
                    var oSeries = database.Serieses.FirstOrDefault(s => s.Name == indVal);
                    if (oSeries != null)
                    {
                        ImageFileSeries ifsData = new ImageFileSeries();
                        ifsData.IsFeatured = false;
                        ifsData.Series     = oSeries;
                        ifsData.ImageFile  = imgData;
                        database.ImageFileSerieses.Add(ifsData);
                    }
                }
                imgData.SeriesList = string.Join(", ", imgData.ImageFileSerieses.Where(st => !st.IsFeatured).Select(st => st.Series.Name));
            }
            else
            {
                imgData.SeriesList = null;
            }

            imgData.DBKeywords = SearchText.GetKeywordList(new List <string>()
            {
                imgData.Name, imgData.Caption, imgData.Keyword, imgData.FeaturedSeries, imgData.SeriesList
            });

            database.SaveChanges();
        }
Пример #2
0
        public void ImportFileData(Stream fStream, int fileLength)
        {
            var csvReader = new CsvReader(new StreamReader(fStream), true);

            DeleteAllObjects("[SeriesOptionAttributes]");
            DeleteAllObjects("[SeriesTextAttributes]");
            DeleteAllObjects("[SeriesIntAttributes]");
            DeleteAllObjects("[AttributeOptions]");
            DeleteAllObjects("[Attributes]");
            DeleteAllObjects("[SeriesImageFiles]");
            DeleteAllObjects("[RelatedSeries]");
            DeleteAllObjects("[SeriesTypicals]");
            DeleteAllObjects("[ImageFileSerieses]");
            DeleteAllObjects("[Serieses]");
            DeleteAllObjects("[Categories]");

            Dictionary <int, string> mapRelatedSeries = new Dictionary <int, string>();

            while (csvReader.ReadNextRecord())
            {
                if (!csvReader["Series Name"].Any())
                {
                    continue;
                }

                Series sData = new Series();
                sData.CreatedDate = DateTime.Now;
                sData.IsActive    = true;

                string        relatedSeries  = "";
                List <string> arrKeywordList = new List <string>();

                foreach (var header in csvReader.GetFieldHeaders())
                {
                    string val = csvReader[header];
                    switch (header.ToLower())
                    {
                    case "combo":
                    case "image-1":
                    case "image-2":
                    case "image-3":
                        // fields to skip
                        break;

                    case "category":
                    {
                        var cat = database.Categories.FirstOrDefault(c => c.Name == val);
                        if (cat == null)
                        {
                            cat      = new Category();
                            cat.Name = val;
                            database.Categories.Add(cat);
                        }
                        sData.Category = cat;
                    }
                    break;

                    case "series name":
                        sData.Name = val;
                        break;

                    case "active":
                    case "status":
                        switch (val.ToLower())
                        {
                        case "active":
                        case "yes":
                        case "true":
                        case "1":
                            sData.IsActive = true;
                            break;

                        default:
                            sData.IsActive = false;
                            break;
                        }
                        break;

                    case "value statement headline":
                    case "marketing statement subheadline":
                    case "marketing description":
                    {
                        var attData = database.Attributes.FirstOrDefault(a => a.Name == header);
                        if (attData == null)
                        {
                            attData      = new PDWDBContext.Attribute(false);
                            attData.Name = header;
                            database.Attributes.Add(attData);
                        }

                        var attForSeries = new SeriesTextAttribute();
                        attForSeries.Attribute = attData;
                        attForSeries.Value     = val ?? "";
                        attForSeries.Series    = sData;
                        database.SeriesTextAttributes.Add(attForSeries);
                    }
                    break;

                    case "image - featured":
                    case "image":
                        if ((val ?? "").Any())
                        {
                            var values       = val.Split(',');
                            int displayOrder = 1;
                            foreach (var indVal in values.Select(s => s.Trim()))
                            {
                                var img = database.ImageFiles.FirstOrDefault(i => i.Name == indVal);
                                if (img != null)
                                {
                                    SeriesImageFile sif = new SeriesImageFile();
                                    sif.IsFeatured   = (header.ToLower() == "image - featured");
                                    sif.ImageFile    = img;
                                    sif.Series       = sData;
                                    sif.DisplayOrder = sif.IsFeatured ? 0 : displayOrder;
                                    database.SeriesImageFiles.Add(sif);

                                    displayOrder++;
                                }
                            }
                        }
                        break;

                    case "winning assortment":
                        if ((val ?? "").Any())
                        {
                            var attData = database.Attributes.FirstOrDefault(a => a.Name == "ranking");
                            if (attData == null)
                            {
                                attData      = new PDWDBContext.Attribute(false);
                                attData.Name = "Ranking";
                                database.Attributes.Add(attData);
                            }

                            var attForSeries = new SeriesIntAttribute();
                            attForSeries.Attribute = attData;
                            attForSeries.Value     = val.ToLower() == "yes" ? 2 : 1;
                            attForSeries.Series    = sData;
                            database.SeriesIntAttributes.Add(attForSeries);
                        }
                        break;

                    case "related series":
                        if ((val ?? "").Any())
                        {
                            relatedSeries = val;
                        }
                        break;

                    case "price list":
                    case "product technical spec sheet":
                    case "spec guide":
                    case "gsa spec sheet":
                    case "installation guide":
                    case "eds sheet":
                    case "leed sheet":
                    case "control guide":
                    case "brochure file name":
                    case "keywords":
                    case "in2 price list":
                    case "interactive price list":
                    case "government price list":
                        if ((val ?? "").Any())
                        {
                            var attData = database.Attributes.FirstOrDefault(a => a.Name == header);
                            if (attData == null)
                            {
                                attData      = new PDWDBContext.Attribute(false);
                                attData.Name = header;
                                database.Attributes.Add(attData);
                            }

                            var attForSeries = new SeriesTextAttribute();
                            attForSeries.Attribute = attData;
                            attForSeries.Value     = val;
                            attForSeries.Series    = sData;
                            database.SeriesTextAttributes.Add(attForSeries);
                        }
                        break;

                    case "pricing range":
                        if ((val ?? "").Any())
                        {
                            var attData = database.Attributes.FirstOrDefault(a => a.Name == header);
                            if (attData == null)
                            {
                                attData      = new PDWDBContext.Attribute(false);
                                attData.Name = header;
                                database.Attributes.Add(attData);
                            }

                            var attForSeries = new SeriesTextAttribute();
                            attForSeries.Attribute = attData;
                            attForSeries.Value     = val;
                            attForSeries.Series    = sData;
                            database.SeriesTextAttributes.Add(attForSeries);

                            var startingPrice = string.Join("", val.Where(c => Char.IsDigit(c)));
                            int price         = 0;
                            if (startingPrice.Any() && int.TryParse(startingPrice, out price))
                            {
                                var priceData = database.Attributes.FirstOrDefault(a => a.Name == "Starting Price");
                                if (priceData == null)
                                {
                                    priceData      = new PDWDBContext.Attribute(false);
                                    priceData.Name = "Starting Price";
                                    database.Attributes.Add(priceData);
                                }

                                var priceForSeries = new SeriesIntAttribute();
                                priceForSeries.Attribute = priceData;
                                priceForSeries.Value     = price;
                                priceForSeries.Series    = sData;
                                database.SeriesIntAttributes.Add(priceForSeries);
                            }
                        }
                        break;

                    case "claires 5 favorites":
                        if ((val ?? "").Any())
                        {
                            var attData = database.Attributes.FirstOrDefault(a => a.Name == header);
                            if (attData == null)
                            {
                                attData      = new PDWDBContext.Attribute(true);
                                attData.Name = header;
                                database.Attributes.Add(attData);
                            }
                            var values = val.Split('\r', '\n');
                            foreach (var indVal in values.Select(s => s.Trim()))
                            {
                                if (indVal.Length > 0)
                                {
                                    var optVal = attData.AttributeOptions.FirstOrDefault(ao => ao.Name == indVal);
                                    if (optVal == null)
                                    {
                                        if (indVal.Length > 500)
                                        {
                                            throw new Exception(string.Format("Cannot add option value {0} for {1}", indVal, header));
                                        }
                                        optVal      = new AttributeOption();
                                        optVal.Name = indVal;
                                        database.AttributeOptions.Add(optVal);
                                        attData.AttributeOptions.Add(optVal);
                                    }

                                    var attForSeries = new SeriesOptionAttribute();
                                    attForSeries.Attribute       = attData;
                                    attForSeries.AttributeOption = optVal;
                                    attForSeries.Series          = sData;
                                    database.SeriesOptionAttributes.Add(attForSeries);
                                }
                            }
                        }
                        break;

                    default:
                        if ((val ?? "").Any())
                        {
                            var attData = database.Attributes.FirstOrDefault(a => a.Name == header);
                            if (attData == null)
                            {
                                attData      = new PDWDBContext.Attribute(true);
                                attData.Name = header;
                                database.Attributes.Add(attData);
                            }
                            var values = val.Split(',');
                            foreach (var indVal in values.Select(s => s.Trim()).Where(s => s.Any()))
                            {
                                var optVal = attData.AttributeOptions.FirstOrDefault(ao => ao.Name == indVal);
                                if (optVal == null)
                                {
                                    if (indVal.Length > 500)
                                    {
                                        throw new Exception(string.Format("Cannot add option value {0} for {1}", indVal, header));
                                    }
                                    optVal      = new AttributeOption();
                                    optVal.Name = indVal;
                                    database.AttributeOptions.Add(optVal);
                                    attData.AttributeOptions.Add(optVal);
                                }

                                var attForSeries = new SeriesOptionAttribute();
                                attForSeries.Attribute       = attData;
                                attForSeries.AttributeOption = optVal;
                                attForSeries.Series          = sData;
                                database.SeriesOptionAttributes.Add(attForSeries);
                            }
                        }
                        break;
                    }

                    switch (header.ToLower())
                    {
                    case "series name":
                    case "category":
                    case "style":
                    case "value statement headline":
                    case "marketing statement subheadline":
                    case "claire 5 favorites":
                    case "iaq":
                    case "finish":
                    case "drawer options - configuration":
                    case "edge options - profile":
                    case "pull options - style":
                    case "seating option - back":
                    case "shape":
                    case "casegood application":
                    case "table application":
                    case "seating application":
                    case "keywords":
                        arrKeywordList.Add(val.ToLower());
                        break;
                    }
                }

                sData.DBKeywords = SearchText.GetKeywordList(arrKeywordList);

                database.Serieses.Add(sData);
                database.SaveChanges();
                database.Entry(sData).Reload();

                if (relatedSeries.Any())
                {
                    mapRelatedSeries.Add(sData.SeriesID, relatedSeries);
                }
            }

            foreach (int seriesId in mapRelatedSeries.Keys)
            {
                var parentSeries = database.Serieses.FirstOrDefault(s => s.SeriesID == seriesId);
                if (parentSeries != null)
                {
                    var otherSeries = mapRelatedSeries[seriesId].Split(',');
                    foreach (var seriesName in otherSeries.Select(o => o.Trim()))
                    {
                        var rSeries = database.Serieses.FirstOrDefault(s => s.Name == seriesName);
                        if (rSeries != null)
                        {
                            rSeries.ParentSerieses.Add(parentSeries);
                        }
                        else
                        {
                            Debug.WriteLine(format: "Unable to find series: {0}", args: seriesName);
                        }
                    }
                }
            }

            foreach (var tData in database.Typicals)
            {
                var rSeries = database.Serieses.FirstOrDefault(s => s.Name == tData.FeaturedSeries);
                if (rSeries != null)
                {
                    SeriesTypical stData = new SeriesTypical();
                    stData.IsPrimary = true;
                    stData.Series    = rSeries;
                    stData.Typical   = tData;
                    database.SeriesTypicals.Add(stData);

                    tData.FeaturedSeries = rSeries.Name;
                }

                if (tData.SeriesList != null)
                {
                    foreach (var indVal in tData.SeriesList.Split(',').Select(s => s.Trim()))
                    {
                        var oSeries = database.Serieses.FirstOrDefault(s => s.Name == indVal);
                        if (oSeries != null)
                        {
                            SeriesTypical stData = new SeriesTypical();
                            stData.IsPrimary = false;
                            stData.Series    = oSeries;
                            stData.Typical   = tData;
                            database.SeriesTypicals.Add(stData);
                        }
                    }
                }
                tData.SeriesList = string.Join(", ", tData.SeriesTypicals.Where(st => !st.IsPrimary).Select(st => st.Series.Name));

                tData.DBKeywords = SearchText.GetKeywordList(new List <string>()
                {
                    tData.Name, tData.FeaturedSeries, tData.Notes, tData.SeriesList
                });
            }

            foreach (var imgData in database.ImageFiles)
            {
                var rSeries = database.Serieses.FirstOrDefault(s => s.Name == imgData.FeaturedSeries);
                if (rSeries != null)
                {
                    ImageFileSeries stData = new ImageFileSeries();
                    stData.IsFeatured = true;
                    stData.Series     = rSeries;
                    stData.ImageFile  = imgData;
                    database.ImageFileSerieses.Add(stData);

                    imgData.FeaturedSeries = rSeries.Name;
                }

                if (imgData.SeriesList != null)
                {
                    foreach (var indVal in imgData.SeriesList.Split(',').Select(s => s.Trim()))
                    {
                        var oSeries = database.Serieses.FirstOrDefault(s => s.Name == indVal);
                        if (oSeries != null)
                        {
                            ImageFileSeries stData = new ImageFileSeries();
                            stData.IsFeatured = false;
                            stData.Series     = oSeries;
                            stData.ImageFile  = imgData;
                            database.ImageFileSerieses.Add(stData);
                        }
                    }
                }
                imgData.SeriesList = string.Join(", ", imgData.ImageFileSerieses.Where(st => !st.IsFeatured).Select(st => st.Series.Name));

                imgData.DBKeywords = SearchText.GetKeywordList(new List <string>()
                {
                    imgData.Name, imgData.Caption, imgData.Keyword, imgData.FeaturedSeries, imgData.SeriesList
                });
            }

            database.SaveChanges();
        }
Пример #3
0
        public void ImportImageFileData(ImageInformation imgInfo, Stream fStream, int fileLength, string origFileName, string mimeType)
        {
            if (database.ImageFiles.Any(i => i.Name == imgInfo.ImageName))
            {
                throw new Exception("Image with this name already exists.");
            }

            ImageFile imgData = new ImageFile();

            imgData.Name = imgInfo.ImageName;
            imgData.OriginalExtension    = Path.GetExtension(origFileName);
            imgData.Caption              = imgInfo.Caption;
            imgData.HasPeople            = imgInfo.HasPeople;
            imgData.ImageType            = imgInfo.ImageType;
            imgData.Keyword              = imgInfo.Keywords;
            imgData.CreatedDate          = DateTime.Now;
            imgData.MIMEType             = mimeType;
            imgData.FeaturedEdge         = imgInfo.FeaturedEdge;
            imgData.FeaturedPull         = imgInfo.FeaturedPull;
            imgData.ImageContent         = imgInfo.ImageContent;
            imgData.FeaturedFinish       = imgInfo.FeaturedFinish;
            imgData.FinishType           = imgInfo.FinishType;
            imgData.FinishCode           = imgInfo.FinishCode;
            imgData.LaminatePattern      = imgInfo.LaminatePattern;
            imgData.LaminateIsTFL        = imgInfo.LaminateIsTFL;
            imgData.LaminateIsHPL        = imgInfo.LaminateIsHPL;
            imgData.VeneerGrade          = imgInfo.VeneerGrade;
            imgData.VeneerSpecies        = imgInfo.VeneerSpecies;
            imgData.SeatingGrade         = imgInfo.SeatingGrade;
            imgData.TableBase            = imgInfo.FeaturedTableBase;
            imgData.TableShape           = imgInfo.FeaturedTableShape;
            imgData.ControlMechanism     = imgInfo.ControlMechanism;
            imgData.ControlDescription   = imgInfo.ControlDescription;
            imgData.GoToGuidePage        = imgInfo.GoToGuidePageNum;
            imgData.ImageApplicationList = imgInfo.ImageApplication;

            if (!string.IsNullOrEmpty(imgInfo.FeaturedSeries))
            {
                var rSeries = database.Serieses.FirstOrDefault(s => s.Name == imgInfo.FeaturedSeries);
                if (rSeries != null)
                {
                    ImageFileSeries ifsData = new ImageFileSeries();
                    ifsData.IsFeatured = true;
                    ifsData.Series     = rSeries;
                    ifsData.ImageFile  = imgData;
                    database.ImageFileSerieses.Add(ifsData);
                }
                else
                {
                    throw new Exception("Unable to find Featured Series");
                }
                imgData.FeaturedSeries = rSeries.Name;
            }

            if ((imgInfo.SeriesList ?? "").Any())
            {
                foreach (var indVal in imgInfo.SeriesList.Split(',').Select(s => s.Trim()))
                {
                    var oSeries = database.Serieses.FirstOrDefault(s => s.Name == indVal);
                    if (oSeries != null)
                    {
                        ImageFileSeries ifsData = new ImageFileSeries();
                        ifsData.IsFeatured = false;
                        ifsData.Series     = oSeries;
                        ifsData.ImageFile  = imgData;
                        database.ImageFileSerieses.Add(ifsData);
                    }
                }
                imgData.SeriesList = string.Join(", ", imgData.ImageFileSerieses.Where(st => !st.IsFeatured).Select(st => st.Series.Name));
            }

            imgData.DBKeywords = SearchText.GetKeywordList(new List <string>()
            {
                imgData.Name, imgData.Caption, imgData.Keyword, imgData.FeaturedSeries, imgData.SeriesList
            });

            database.ImageFiles.Add(imgData);

            database.SaveChanges();

            UploadImage(imgInfo.ImageName, fStream, fileLength, origFileName);
        }