예제 #1
0
        private ExtendedArticleList GetArticles(ExtendedArticleList articlesList, bool onlyExisting)
        {
            ExtendedArticleList existingArticles;

            if (_importSettings.UniqueContentField == null)
            {
                var existingIds = GetExistingArticleIds(articlesList.GetBaseArticleIds());
                existingArticles = articlesList.Filter(a => !onlyExisting ^ existingIds.Contains(a.Id));
            }
            else
            {
                existingArticles = new ExtendedArticleList(articlesList);
                var existingIdsMap = GetExistingArticleIdsMap(_uniqueValuesList, _importSettings.UniqueContentField.Name);
                for (var i = 0; i < articlesList.Count; i++)
                {
                    var article       = articlesList[i];
                    var uniqueValue   = _uniqueValuesList[i];
                    var articleExists = existingIdsMap.ContainsKey(uniqueValue);
                    if (articleExists)
                    {
                        article.BaseArticle.Id = existingIdsMap[uniqueValue];
                    }

                    if (!onlyExisting ^ articleExists)
                    {
                        existingArticles.Add(article);
                    }
                }
            }

            return(existingArticles);
        }
예제 #2
0
        public ExtendedArticleList Filter(Func <Article, bool> predicate)
        {
            var result = new ExtendedArticleList(this);

            result.AddRange(this.Where(article => predicate(article.BaseArticle)));
            return(result);
        }
예제 #3
0
 private void InsertArticles(ExtendedArticleList articlesToInsert)
 {
     if (articlesToInsert.Any())
     {
         var insertingArticles = InsertArticlesToDb(articlesToInsert);
         var insertedArticles  = insertingArticles.GetBaseArticleIds();
         SaveInsertedArticleIdsToSettings(insertedArticles);
     }
 }
예제 #4
0
        private ExtendedArticleList UpdateArticles(ExtendedArticleList articlesToUpdate)
        {
            if (articlesToUpdate.Any())
            {
                var updatingArticles = UpdateArticlesToDb(articlesToUpdate);
                var updatedArticles  = updatingArticles.GetBaseArticleIds();
                SaveUpdatedArticleIdsToSettings(updatedArticles);
                return(updatingArticles);
            }

            return(articlesToUpdate);
        }
예제 #5
0
        private void InitFields()
        {
            _fieldsMap = _importSettings
                         .FieldsList.Select(f => f.Value)
                         .GroupBy(f => f.ContentId)
                         .Select(g => g)
                         .ToDictionary(g => g.Key, g => g.ToList());

            _headersMap            = _importSettings.FieldsList.ToDictionary(f => f.Value, f => _titleHeaders.FindIndex(s => s == f.Key));
            _aggregatedContentsMap = ContentRepository.GetAggregatedContents(_contentId).ToDictionary(c => c.Id, c => c);
            _articlesListFromCsv   = new ExtendedArticleList();
            _uniqueValuesList      = new List <string>();
        }
예제 #6
0
        private ExtendedArticleList InsertArticlesToDb(ExtendedArticleList articleList)
        {
            var baseArticles = articleList.GetBaseArticles();
            var idsList      = InsertArticlesIds(baseArticles, baseArticles.All(a => a.UniqueId.HasValue)).ToArray();

            _notificationRepository.PrepareNotifications(_contentId, idsList, NotificationCode.Create);
            InsertArticleValues(idsList.ToArray(), baseArticles);

            if (_importSettings.ContainsO2MRelationOrM2MRelationFields)
            {
                SaveNewRelationsToFile(baseArticles, idsList);
            }

            for (var i = 0; i < idsList.Length; i++)
            {
                var id      = idsList[i];
                var article = articleList[i];
                foreach (var aggregatedArticle in article.Extensions.Values.Where(ex => ex != null))
                {
                    var parent = aggregatedArticle.FieldValues.Find(fv => fv.Field.Aggregated);
                    parent.Value = id.ToString();
                }
            }

            var aggregatedArticles = articleList.GetAllAggregatedArticles().ToList();

            foreach (var aggregatedArticleList in aggregatedArticles)
            {
                var aggregatedIdsList = InsertArticlesIds(aggregatedArticleList);
                InsertArticleValues(aggregatedIdsList.ToArray(), aggregatedArticleList);
                if (_importSettings.ContainsO2MRelationOrM2MRelationFields)
                {
                    SaveNewRelationsToFile(aggregatedArticleList, aggregatedIdsList);
                }
            }

            _notificationRepository.SendNotifications();
            return(articleList);
        }
예제 #7
0
        private ExtendedArticleList UpdateArticlesToDb(ExtendedArticleList articlesList)
        {
            var existingArticles = GetArticles(articlesList, true);
            var extensionsMap    = ContentRepository.GetAggregatedArticleIdsMap(_contentId, existingArticles.GetBaseArticleIds().ToArray());
            var idsList          = existingArticles.GetBaseArticleIds().ToArray();

            _notificationRepository.PrepareNotifications(_contentId, idsList, NotificationCode.Update);
            InsertArticleValues(idsList, existingArticles.GetBaseArticles(), true);

            var idsToDelete      = new List <int>();
            var articlesToInsert = new List <Article>();
            var idsToUpdate      = new List <int>();
            var articlesToUpdate = new List <Article>();

            foreach (var article in existingArticles)
            {
                foreach (var afv in article.Extensions.Where(ex => ex.Value != null))
                {
                    var aggregatedArticle = afv.Value;
                    var fieldId           = afv.Key.Id;
                    if (extensionsMap.ContainsKey(article.BaseArticle.Id) && extensionsMap[article.BaseArticle.Id].ContainsKey(fieldId))
                    {
                        var currentId = extensionsMap[article.BaseArticle.Id][fieldId];
                        if (currentId != aggregatedArticle.Id)
                        {
                            aggregatedArticle.Id = currentId;
                        }
                        idsToUpdate.Add(aggregatedArticle.Id);
                        articlesToUpdate.Add(aggregatedArticle);
                    }
                    else
                    {
                        articlesToInsert.Add(aggregatedArticle);
                    }

                    var parent = aggregatedArticle.FieldValues.Find(fv => fv.Field.Aggregated);
                    parent.Value = article.BaseArticle.Id.ToString();
                }
            }

            if (idsToDelete.Any())
            {
                ArticleRepository.MultipleDelete(idsToDelete);
            }

            if (articlesToInsert.Any())
            {
                var inserdedIds = InsertArticlesIds(articlesToInsert);
                if (_importSettings.ContainsO2MRelationOrM2MRelationFields)
                {
                    SaveNewRelationsToFile(articlesToInsert, inserdedIds);
                }

                idsToUpdate.AddRange(inserdedIds);
                articlesToUpdate.AddRange(articlesToInsert);
            }

            InsertArticleValues(idsToUpdate.ToArray(), articlesToUpdate, true);
            _notificationRepository.SendNotifications();
            return(existingArticles);
        }
예제 #8
0
 public ExtendedArticleList(ExtendedArticleList articles)
 {
     ExtensionFields = new HashSet <Field>(articles.ExtensionFields);
 }