Exemple #1
0
        public async Task <ActionResultResponse> Update(string tenantId, string lastUpdateUserId,
                                                        string lastUpdateFullName, string lastUpdateAvatar, string newsId,
                                                        NewsMeta newsMeta, bool isSend)
        {
            var apiUrls = _configuration.GetApiUrl();

            if (apiUrls == null)
            {
                return(new ActionResultResponse <string>(-5,
                                                         _sharedResourceService.GetString(
                                                             "Missing some configuration. Please contact with administrator.")));
            }
            var newsTags = new List <TagSubjectViewModel>();

            var info = await _newsRepository.GetInfo(newsId);

            if (info == null)
            {
                return(new ActionResultResponse(-1, _websiteResourceService.GetString("News does not exists.")));
            }

            if (info.TenantId != tenantId)
            {
                return(new ActionResultResponse(-2,
                                                _websiteResourceService.GetString(ErrorMessage.NotHavePermission)));
            }

            if (info.ConcurrencyStamp != newsMeta.ConcurrencyStamp)
            {
                return(new ActionResultResponse(-3,
                                                _websiteResourceService.GetString(
                                                    "The news already updated by other people. you are not allowed to edit the news information.")));
            }

            info.Status             = isSend ? ApproverStatus.Pending : ApproverStatus.Draft;
            info.IsActive           = newsMeta.IsActive;
            info.FeatureImage       = newsMeta.FeatureImage;
            info.BannerImage        = newsMeta.BannerImage;
            info.AltImage           = newsMeta.AltImage;
            info.Source             = newsMeta.Source;
            info.ConcurrencyStamp   = Guid.NewGuid().ToString();
            info.LastUpdate         = DateTime.Now;
            info.LastUpdateUserId   = lastUpdateUserId;
            info.LastUpdateFullName = lastUpdateFullName;
            info.LastUpdateAvatar   = lastUpdateAvatar;
            info.Source             = newsMeta.Source;

            if (newsMeta.IsHot.HasValue)
            {
                info.IsHot           = newsMeta.IsHot.Value;
                info.LastUpdateIsHot = DateTime.Now;
            }

            if (newsMeta.IsHomePage.HasValue)
            {
                info.IsHomePage           = newsMeta.IsHomePage.Value;
                info.LastUpdateIsHomePage = DateTime.Now;
            }

            if (info.Status == ApproverStatus.Approved)
            {
                info.Status = isSend ? ApproverStatus.Pending : ApproverStatus.Draft;
            }

            await _newsRepository.Update(info);

            #region news translation.
            if (newsMeta.NewsTranslations.Count > 0)
            {
                var resultUpdateTranslation = await UpdateNewTranslation();

                if (resultUpdateTranslation.Code <= 0)
                {
                    return(resultUpdateTranslation);
                }
            }
            #endregion

            #region CategoriesNews.
            if (newsMeta.CategoriesNews.Count > 0)
            {
                var resultUpdateCategoriesNews = await UpdateCategoriesNews();

                if (resultUpdateCategoriesNews.Code <= 0)
                {
                    return(resultUpdateCategoriesNews);
                }
            }
            #endregion

            return(new ActionResultResponse(1, _websiteResourceService.GetString("Update news successful.")));

            async Task <ActionResultResponse> UpdateNewTranslation()
            {
                foreach (var newsTranslation in newsMeta.NewsTranslations)
                {
                    var isNameExists = await _newsTranslationRepository.CheckExists(tenantId, info.Id,
                                                                                    newsTranslation.LanguageId, newsTranslation.Title);

                    if (isNameExists)
                    {
                        return(new ActionResultResponse(-4, _websiteResourceService.GetString("News name: \"{0}\" already exists.")));
                    }

                    var newsTranslationInfo =
                        await _newsTranslationRepository.GetInfo(info.Id, newsTranslation.LanguageId);

                    if (newsTranslationInfo != null)
                    {
                        newsTranslationInfo.Title           = newsTranslation.Title.Trim();
                        newsTranslationInfo.MetaTitle       = newsTranslation.MetaTitle?.Trim();
                        newsTranslationInfo.Description     = newsTranslation.Description?.Trim();
                        newsTranslationInfo.MetaDescription = newsTranslation.MetaDescription?.Trim();
                        newsTranslationInfo.MetaKeyword     = newsTranslation.MetaKeyword?.Trim();
                        newsTranslationInfo.UnsignName      = newsTranslation.Title?.StripVietnameseChars().ToUpper();
                        newsTranslationInfo.Content         = newsTranslation.Content?.Trim();

                        if (!string.IsNullOrEmpty(newsTranslation.SeoLink))
                        {
                            newsTranslationInfo.SeoLink = newsTranslation.SeoLink.ToPlainText();
                        }
                        else
                        {
                            newsTranslationInfo.SeoLink = newsTranslation.Title.ToPlainText();
                        }

                        // Check Seolink exists.
                        var isSeolinkExists = await _newsTranslationRepository.CheckSeoLinkExists(tenantId, newsId,
                                                                                                  newsTranslation.LanguageId, newsTranslationInfo.SeoLink);

                        if (isSeolinkExists)
                        {
                            return(new ActionResultResponse(-5,
                                                            _websiteResourceService.GetString("Seo link: \"{0}\" already exists.",
                                                                                              newsTranslationInfo.SeoLink)));
                        }

                        await _newsTranslationRepository.Update(newsTranslationInfo);
                    }
                    else
                    {
                        var newsTranslationInsert = new NewsTranslation
                        {
                            NewsId          = newsId,
                            TenantId        = tenantId,
                            LanguageId      = newsTranslation.LanguageId.Trim(),
                            Title           = newsTranslation.Title.Trim(),
                            MetaTitle       = newsTranslation.MetaTitle?.Trim(),
                            Description     = newsTranslation.Description?.Trim(),
                            MetaDescription = newsTranslation.MetaDescription?.Trim(),
                            MetaKeyword     = newsTranslation.MetaKeyword?.Trim(),
                            Content         = newsTranslation.Content?.Trim(),
                            UnsignName      = newsTranslation.Title?.StripVietnameseChars().ToUpper()
                        };

                        if (!string.IsNullOrEmpty(newsTranslation.SeoLink))
                        {
                            newsTranslationInsert.SeoLink = newsTranslation.SeoLink.ToUrlString();
                        }
                        else
                        {
                            newsTranslationInsert.SeoLink = newsTranslation.Title.ToUrlString();
                        }
                        // Check Seolink exists.
                        var isSeolinkExists = await _newsTranslationRepository.CheckSeoLinkExists(tenantId, newsId,
                                                                                                  newsTranslation.LanguageId, newsTranslationInsert.SeoLink);

                        if (isSeolinkExists)
                        {
                            return(new ActionResultResponse(-6,
                                                            _websiteResourceService.GetString("Seo link: \"{0}\" already exists.",
                                                                                              newsTranslationInsert.SeoLink)));
                        }
                        await _newsTranslationRepository.Insert(newsTranslationInsert);
                    }
                    var videoTagInsert = new TagSubjectViewModel
                    {
                        TenantId        = tenantId,
                        CreatorId       = lastUpdateUserId,
                        CreatorFullName = lastUpdateFullName,
                        CreatorAvata    = lastUpdateAvatar,
                        Type            = TagType.News,
                        SubjectId       = newsId,
                        LanguageId      = newsTranslation.LanguageId.Trim(),
                        Tags            = newsTranslation.Tags
                    };
                    newsTags.Add(videoTagInsert);
                }

                var resultTag = await new HttpClientService()
                                .PostAsync <ActionResultResponse>($"{apiUrls.CoreApiUrl}/tags", newsTags);

                return(new ActionResultResponse(1,
                                                _websiteResourceService.GetString("Update news translation successful.")));
            }

            async Task <ActionResultResponse> UpdateCategoriesNews()
            {
                var resultDelete = await _categoriesNewsRepository.DeleteByNewsId(newsId);

                var categoriesNews = new List <CategoriesNews>();

                foreach (var categories in newsMeta.CategoriesNews)
                {
                    var categoriesInsert = new CategoriesNews
                    {
                        NewsId     = newsId,
                        CategoryId = categories
                    };

                    var iscategoriesExists = await _categoryRepository.CheckExistsById(tenantId, categories);

                    if (iscategoriesExists)
                    {
                        categoriesNews.Add(categoriesInsert);
                    }
                }
                var resultcategories = await _categoriesNewsRepository.Inserts(categoriesNews);

                if (resultcategories > 0)
                {
                    return(new ActionResultResponse(resultcategories,
                                                    _websiteResourceService.GetString("Update categories news successful.")));
                }

                return(new ActionResultResponse(-7,
                                                _websiteResourceService.GetString("Can not update categories news. Please contact with administrator.")));
            }
        }
Exemple #2
0
        public async Task <ActionResultResponse <string> > Insert(string tenantId, string creatorId,
                                                                  string creatorFullName, string creatorAvatar, NewsMeta newsMeta, bool isSend)
        {
            var newsId = Guid.NewGuid().ToString();
            var news   = new News
            {
                Id = newsId,
                ConcurrencyStamp = newsId,
                IsActive         = newsMeta.IsActive,
                FeatureImage     = newsMeta.FeatureImage,
                BannerImage      = newsMeta.BannerImage,
                AltImage         = newsMeta.AltImage,
                Source           = newsMeta.Source,
                Status           = isSend ? ApproverStatus.Pending : ApproverStatus.Draft,
                TenantId         = tenantId,
                CreatorId        = creatorId,
                CreatorFullName  = creatorFullName,
                CreatorAvatar    = creatorAvatar
            };

            if (news.Status == ApproverStatus.Pending)
            {
                news.SentTime = DateTime.Now;
            }

            if (newsMeta.IsHot.HasValue)
            {
                news.IsHot           = newsMeta.IsHot.Value;
                news.LastUpdateIsHot = DateTime.Now;
            }

            if (newsMeta.IsHomePage.HasValue)
            {
                news.IsHomePage           = newsMeta.IsHomePage.Value;
                news.LastUpdateIsHomePage = DateTime.Now;
            }
            var result = await _newsRepository.Insert(news);

            if (result <= 0)
            {
                return(new ActionResultResponse <string>(result,
                                                         _sharedResourceService.GetString(ErrorMessage.SomethingWentWrong)));
            }

            #region insert news Translation.

            if (newsMeta.NewsTranslations.Count > 0)
            {
                var resultInsertTranslation = await InsertNewsTranslation();

                if (resultInsertTranslation.Code <= 0)
                {
                    return(resultInsertTranslation);
                }
            }

            #endregion

            #region insert Categories News.

            if (newsMeta.CategoriesNews.Count > 0)
            {
                var resultInsertCategoriesNews = await InsertCategoriesNews();

                if (resultInsertCategoriesNews.Code <= 0)
                {
                    return(resultInsertCategoriesNews);
                }
            }

            #endregion

            return(new ActionResultResponse <string>(1,
                                                     _websiteResourceService.GetString("Add new news successful."),
                                                     string.Empty, newsId));

            #region Local functions

            async Task <ActionResultResponse <string> > InsertNewsTranslation()
            {
                var apiUrls = _configuration.GetApiUrl();

                if (apiUrls == null)
                {
                    return(new ActionResultResponse <string>(-5,
                                                             _sharedResourceService.GetString(
                                                                 "Missing some configuration. Please contact with administrator.")));
                }
                var newsTranslations = new List <NewsTranslation>();
                var newsTags         = new List <TagSubjectViewModel>();

                foreach (var newsTranslation in newsMeta.NewsTranslations)
                {
                    // Check name exists.
                    var isNameExists = await _newsTranslationRepository.CheckExists(tenantId, newsId,
                                                                                    newsTranslation.LanguageId, newsTranslation.Title);

                    if (isNameExists)
                    {
                        await RollbackInsertNews();

                        return(new ActionResultResponse <string>(-1,
                                                                 _websiteResourceService.GetString("News title: \"{0}\" already exists.",
                                                                                                   newsTranslation.Title)));
                    }

                    var newsTranslationInsert = new NewsTranslation
                    {
                        NewsId          = newsId,
                        TenantId        = tenantId,
                        LanguageId      = newsTranslation.LanguageId.Trim(),
                        Title           = newsTranslation.Title.Trim(),
                        MetaTitle       = newsTranslation.MetaTitle?.Trim(),
                        Description     = newsTranslation.Description?.Trim(),
                        MetaDescription = newsTranslation.MetaDescription?.Trim(),
                        MetaKeyword     = newsTranslation.MetaKeyword?.Trim(),
                        Content         = newsTranslation.Content?.Trim(),
                        SeoLink         = newsTranslation.SeoLink?.Trim(),
                        UnsignName      = newsTranslation.Title.StripVietnameseChars().ToUpper()
                    };

                    if (!string.IsNullOrEmpty(newsTranslation.SeoLink))
                    {
                        newsTranslationInsert.SeoLink = newsTranslation.SeoLink.ToUrlString();
                    }
                    else
                    {
                        newsTranslationInsert.SeoLink = newsTranslation.Title.ToUrlString();
                    }

                    // Check Seolink exists.
                    var isSeolinkExists = await _newsTranslationRepository.CheckSeoLinkExists(tenantId, newsId,
                                                                                              newsTranslation.LanguageId, newsTranslationInsert.SeoLink);

                    if (isSeolinkExists)
                    {
                        await RollbackInsertNews();

                        return(new ActionResultResponse <string>(-2,
                                                                 _websiteResourceService.GetString("Seo link: \"{0}\" already exists.",
                                                                                                   newsTranslationInsert.SeoLink)));
                    }

                    newsTranslations.Add(newsTranslationInsert);

                    var newsTagInsert = new TagSubjectViewModel
                    {
                        TenantId        = tenantId,
                        CreatorId       = creatorId,
                        CreatorFullName = creatorFullName,
                        CreatorAvata    = creatorAvatar,
                        Type            = TagType.News,
                        SubjectId       = newsId,
                        LanguageId      = newsTranslation.LanguageId.Trim(),
                        Tags            = newsTranslation.Tags
                    };
                    newsTags.Add(newsTagInsert);
                }

                var resultTag = await new HttpClientService()
                                .PostAsync <ActionResultResponse>($"{apiUrls.CoreApiUrl}/tags", newsTags);

                var resultTranslation = await _newsTranslationRepository.Inserts(newsTranslations);

                if (resultTranslation > 0)
                {
                    return(new ActionResultResponse <string>(resultTranslation,
                                                             _websiteResourceService.GetString("Add new news translation successful.")));
                }

                await RollbackInsertNewsTranslation();
                await RollbackInsertNews();

                return(new ActionResultResponse <string>(-3,
                                                         _websiteResourceService.GetString(
                                                             "Can not insert news translation. Please contact with administrator.")));
            }

            async Task <ActionResultResponse <string> > InsertCategoriesNews()
            {
                var categoriesNews = new List <CategoriesNews>();

                foreach (var categories in newsMeta.CategoriesNews)
                {
                    var iscategoriesNewExists =
                        await _categoriesNewsRepository.CheckExistsByNewsIdAndCategoryId(newsId,
                                                                                         categories);

                    if (iscategoriesNewExists)
                    {
                        continue;
                    }
                    var categoriesInsert = new CategoriesNews
                    {
                        NewsId     = newsId,
                        CategoryId = categories
                    };

                    var iscategoriesExists = await _categoryRepository.CheckExistsById(tenantId, categories);

                    if (iscategoriesExists)
                    {
                        categoriesNews.Add(categoriesInsert);
                    }
                }
                var resultCategoriesNews = await _categoriesNewsRepository.Inserts(categoriesNews);

                if (resultCategoriesNews > 0)
                {
                    return(new ActionResultResponse <string>(resultCategoriesNews,
                                                             _websiteResourceService.GetString("Add new categories news successful.")));
                }

                await RollbackInsertCategoriesNews();
                await RollbackInsertNewsTranslation();
                await RollbackInsertNews();

                return(new ActionResultResponse <string>(-3,
                                                         _websiteResourceService.GetString(
                                                             "Can not insert categories news. Please contact with administrator.")));
            }

            async Task RollbackInsertNews()
            {
                await _newsRepository.ForceDelete(newsId);
            }

            async Task RollbackInsertNewsTranslation()
            {
                await _newsTranslationRepository.Delete(newsId);
            }

            async Task RollbackInsertCategoriesNews()
            {
                await _categoriesNewsRepository.DeleteByNewsId(newsId);
            }

            #endregion Local functions
        }
Exemple #3
0
 public async Task <int> Insert(CategoriesNews categoriesNews)
 {
     _categoriesNewsRepository.Create(categoriesNews);
     return(await Context.SaveChangesAsync());
 }