public IHttpActionResult DeleteNews(int newsId)
{
NewsRequest request = new NewsRequest
{
NewsDto = new NewsDto {
NewsId = newsId
}
};
List <string> errors = ValidateDeleteNews(request);
NewsMessage message = new NewsMessage();
if (errors != null && errors.Any())
{
message.ErrorMessage = NewsMessageResource.ValidationErrors;
message.ErrorType = ErrorType.ValidationError;
message.Errors = new List <string>();
message.OperationSuccess = false;
message.Errors.AddRange(errors);
}
else
{
message = _serviceNewsClient.DeleteNews(request);
}
return(Json(message));
}
public async Task <ActionResult> Delete(int id)
{
try
{
InitializeServiceClient();
bool result = false;
NewsRequest request = new NewsRequest();
request.ClientInfo = req.ClientInfo;
request.ID = id;
HttpResponseMessage deleteResponse = await client.PostAsJsonAsync("News/DeleteNews", request);
result = await deleteResponse.Content.ReadAsAsync <bool>();
if (result)
{
TempData["DeleteNewsSuccess"] = "Yes";
}
else
{
TempData["DeleteNewsFailed"] = "No";
}
}
catch (Exception ex)
{
// LogHelper.AddLog("NewsController", ex.Message, ex.StackTrace, "HCL.Academy.Web", user.EmailID);
TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackException(ex);
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Create(News news)
{
InitializeServiceClient();
try
{
NewsRequest request = new NewsRequest();
request.ClientInfo = req.ClientInfo;
request.body = news.body.ToString();
request.imageURL = news.imageURL.ToString();
request.header = news.header.ToString();
HttpResponseMessage response = await client.PostAsJsonAsync("News/AddNewsEvents", request);
bool result = await response.Content.ReadAsAsync <bool>();
if (result)
{
return(RedirectToAction("Index"));
}
else
{
return(View(news));
}
}
catch (Exception ex)
{
//UserManager user = (UserManager)Session["CurrentUser"];
//LogHelper.AddLog("NewsController", ex.Message, ex.StackTrace, "HCL.Academy.Web", user.EmailID);
TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackException(ex);
return(View(news));
}
}
public NewsResponse UpcomingNews(NewsRequest newsRequest)
{
NewsResponse newsResponse = new NewsResponse();
string requestParameter = string.Format("{0}q={1}&language={2}&sortby={3}&apikey={4}",
BaseURL,
newsRequest.queryString,
newsRequest.language,
newsRequest.sortby,
newsRequest.APiKey);
string jsonString = new WebClient().DownloadString(requestParameter);
newsResponse = JsonConvert.DeserializeObject <NewsResponse>(jsonString);
var filteredArticles = newsResponse.Articles.Where(y => y.UrlToImage != null && y.UrlToImage.OriginalString.Contains("https:") && y.Title.Length <= 60).Select(x => new Article()
{
Author = x.Author,
Title = x.Title,
PublishedAt = x.PublishedAt,
UrlToImage = x.UrlToImage,
//Description = x.Description,
Url = x.Url,
Source = x.Source
}).ToList().Take(4);
NewsResponse updatedNewsResponse = new NewsResponse()
{
Status = newsResponse.Status,
Articles = filteredArticles
};
//persons.Where(x => !exclusionKeys.Contains(x.compositeKey));
return(updatedNewsResponse);
}
/// <summary>
/// From News Request to News Request pivot.
/// </summary>
/// <param name="request"></param>
/// <returns>News Request pivot result.</returns>
public static NewsRequestPivot ToPivot(this NewsRequest request)
{
return(new NewsRequestPivot()
{
NewsPivot = request.NewsDto?.ToPivot(),
FindNewsPivot = Utility.EnumToEnum <FindNewsDto, FindNewsPivot>(request.FindNewsDto)
});
}
public async Task <bool> Create(NewsRequest model)
{
var json = JsonConvert.SerializeObject(model);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var response = await getClient().PostAsync($"/api/news", httpContent);
return(response.IsSuccessStatusCode);
}
public NewsRequestBuilder()
{
_instance = new CreateNewsRequest
{
Title = "Breaking News",
Content = "Any thing intresting",
Author = new AuthorRequestBuilder().Build()
};
}
public IList <News> Find(NewsRequest request)
{
var query = Where(t => t.NewsType == request.NewsType);
if (string.IsNullOrEmpty(request.Keyword))
{
return(query.OrderByDescending(t => t.ID).Page(request).ToList());
}
return(query.Where(t => t.Title.Contains(request.Keyword)).OrderByDescending(t => t.ID).Page(request).ToList());
}
public NewsRequestBuilder(Guid id)
{
_instance = new UpdateNewsRequest
{
Id = id,
Title = "Breaking News",
Content = "Any thing intresting",
Author = new AuthorRequestBuilder().Build()
};
}
public async Task <IActionResult> Update([FromBody] NewsRequest request)
{
var data = await _newsRepository.Update(request);
if (data < 0)
{
return(BadRequest());
}
return(Ok());
}
/// <summary>
/// Validation delete news.
/// </summary>
/// <param name="request">the request to validate.</param>
/// <returns>errors validation</returns>
private List <string> ValidateDeleteNews(NewsRequest request)
{
var errors = new List <string>();
if (request?.NewsDto == null)
{
errors.Add(NewsMessageResource.NullRequest);
}
else
{
errors.AddRange(GenericValidationAttribute <NewsDto> .ValidateAttributes("NewsId", request.NewsDto.NewsId.ToString()));
}
return(errors);
}
public async Task <IActionResult> Create(NewsRequest model)
{
var userId = User.Claims.First(c => c.Type == SystemConstants.UserClaim.Id).Value;
model.UserId = Guid.Parse(userId);
var data = await _newsApiClient.Create(model);
if (data == false)
{
return(BadRequest("cap nhat khong thanh cong"));
}
return(RedirectToAction("Index", "News"));
}
/// <summary>
/// Delete News
/// </summary>
/// <param name="request">news request.</param>
/// <returns>News message.</returns>
public NewsMessage DeleteNews(NewsRequest request)
{
NewsMessage message = new NewsMessage();
try
{
_serviceNews.DeleteNews(request.ToPivot());
message.OperationSuccess = true;
}
catch (Exception e)
{
message.ErrorType = ErrorType.TechnicalError;
message.ErrorMessage = e.Message;
}
return(message);
}
//public override Task<NewsReply> FindNews(NewsRequest request, ServerCallContext context)
//{
// //load settings drom db
// foreach(string site in db.GetUserSettings(request.Userid, "site")){
// RSSReader.ReadUserFeed(site, db.GetUserSettings(request.Userid, "tag"));
// }
// //streaming
// return Task.FromResult(ConvertToRssItem(RSSReader.ReadFeed2(request.Url)[0]));
//}
public override async Task FindNews(NewsRequest request, Grpc.Core.IServerStreamWriter <NewsReply> responseStream, ServerCallContext context)
{
//load settings drom db
foreach (string site in db.GetUserSettings(request.Userid, "site"))
{
//streaming
foreach (SyndicationItem item in RSSReader.ReadUserFeed(site, db.GetUserSettings(request.Userid, "tag")))
{
await responseStream.WriteAsync(ConvertToRssItem(item));
}
}
Console.WriteLine("\nNews sent to client. Userid: " + request.Userid);
//return ; <NewsReply>
}
public async Task <ActionResult> Edit(int id)
{
InitializeServiceClient();
NewsRequest request = new NewsRequest();
request.ClientInfo = req.ClientInfo;
HttpResponseMessage response = await client.PostAsJsonAsync("News/GetNewsEventByID?id=" + id, request);
List <News> news = await response.Content.ReadAsAsync <List <News> >();
News item = new News();
item = news[0];
Session["NewsID"] = id;
return(View(item));
}
public async Task <bool> OpenNewsRequestAsync(NewsRequest newsRequest)
{
try
{
newsRequest.IsClosed = false;
Context.Set <NewsRequest>().Update(newsRequest);
await Context.SaveChangesAsync();
return(true);
}
catch
{
return(false);
}
}
public async Task <PagedResponse <List <NewsByTypeIdResponse> > > GetNews(NewsRequest request)
{
var response = new List <NewsByTypeIdResponse>();
var news = await _unitOfWork.NewsRepository.GetPagedReponseAsync(request.PageNumber, request.PageSize,
filter : x => (request.TypeId == null || x.TypeId == request.TypeId.Value) &&
(request.SearchValue == null || x.Title.Contains(request.SearchValue)) &&
x.DelFlag == false,
orderBy : x => x.OrderByDescending(o => o.CreatedTime), includeProperties : "Type");
response = _mapper.Map <List <NewsByTypeIdResponse> >(news);
var totalCount = await _unitOfWork.NewsRepository.CountAsync(x => (request.TypeId == null || x.TypeId == request.TypeId.Value) &&
(request.SearchValue == null || x.Title.Contains(request.SearchValue)) &&
x.DelFlag == false);
return(new PagedResponse <List <NewsByTypeIdResponse> >(response, request.PageNumber, request.PageSize, totalCount));
}
public bool UpdateNewsEvent(NewsRequest request)
{
bool result = false;
try
{
SqlSvrDAL dal = new SqlSvrDAL(request.ClientInfo);
result = dal.UpdateNewsEvent(request.ID, request.imageURL, request.header, request.body, request.trimmedBody);
}
catch (Exception ex)
{
// LogHelper.AddLog("NewsController,UpdateNewsEvent", ex.Message, ex.StackTrace, "HCL.Academy.Service", request.ClientInfo.emailId);
TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackException(ex);
}
return(result);
}
public bool DeleteNews(NewsRequest request)
{
bool result = false;
try
{
SqlSvrDAL dal = new SqlSvrDAL(request.ClientInfo);
result = dal.DeleteNews(request.ID);
}
catch (Exception ex)
{
//LogHelper.AddLog("NewsController,DeleteNews", ex.Message, ex.StackTrace, "HCL.Academy.Service", request.ClientInfo.emailId);
TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackException(ex);
}
return(result);
}
public async Task <bool> ChangeNewsRequestCategoryAsync(NewsRequest newsRequest, Category category)
{
try
{
newsRequest.Category = category;
Context.Set <NewsRequest>().Update(newsRequest);
await Context.SaveChangesAsync();
return(true);
}
catch
{
return(false);
}
}
public ActionResult Create(NewsRequest model)
{
var ketqua = _newsDa.Create(model);
if (ketqua > 0)
{
return(Json(new
{
Status = true,
Message = "Tạo tin mới thành công"
}));
}
return(Json(new
{
Status = false,
Message = "Tạo tin mới thất bại"
}));
}
public async Task <int> Create(NewsRequest request)
{
using (var conn = new SqlConnection(_connectStrings))
{
if (conn.State == System.Data.ConnectionState.Closed)
{
conn.Open();
}
var paramaters = new DynamicParameters();
paramaters.Add("@Title", request.Title);
paramaters.Add("@Theme", request.Theme);
paramaters.Add("@Content", request.Content);
paramaters.Add("@UserId", request.UserId);
var result = await conn.ExecuteAsync("Create_News", paramaters, null, null, CommandType.StoredProcedure);
return(result);
}
}
public IHttpActionResult FindNews(NewsRequest request)
{
List <string> errors = ValidateFindNews(request);
NewsMessage message = new NewsMessage();
if (errors != null && errors.Any())
{
message.ErrorMessage = NewsMessageResource.ValidationErrors;
message.ErrorType = ErrorType.ValidationError;
message.Errors = new List <string>();
message.OperationSuccess = false;
message.Errors.AddRange(errors);
}
else
{
message = _serviceNewsClient.FindNews(request);
}
return(Json(message));
}
public IActionResult Index()
{
IndexViewModel indexViewModel = new IndexViewModel();
NewsRequest newsRequest = new NewsRequest();
var newsResponse = new NewsResponse();
// Session Check for the user to consume the News API. If already retrieved, Get from session else call the API
if (!string.IsNullOrEmpty(HttpContext.Session.GetString("News")))
{
newsResponse = JsonConvert.DeserializeObject <NewsResponse>(_session.GetString("News"));
}
else
{
newsRequest.queryString = HttpUtility.UrlEncode("greenhouse-gas+climate-change");
newsRequest.language = "en";
newsRequest.sortby = "publishedAt";
try
{
newsResponse = _newsApi.UpcomingNews(newsRequest);
string output = JsonConvert.SerializeObject(newsResponse);
_session.SetString("News", output);
}
catch (Exception ex)
{
_logger.LogError(ex.StackTrace);
}
}
// If the newsAPI is retrieves, status will be ok
if (newsResponse != null && newsResponse.Status.ToLower() == "ok" && newsResponse.Articles != null && newsResponse.Articles.Count() > 0)
{
indexViewModel.ArticleList = newsResponse.Articles.Select(x => new Models.Article()
{
Title = x.Title,
ImageUrl = x.UrlToImage != null ? x.UrlToImage.OriginalString : string.Empty,
PublishedDate = TimeCalculator(DateTime.Now, x.PublishedAt.DateTime),
Source = x.Source.Name,
Url = x.Url.AbsoluteUri
}).ToList();
}
return(View(indexViewModel.ArticleList));
}
public async Task <ServiceResponse <NewsResponseCollection> > GetNewsAsync(
NewsType newsType, NewsPriority newsPriority,
NewsContentOrigin newsContentOrigin, int count,
Name name = Name.Undefined)
{
var newsRequest = new NewsRequest()
{
Count = count,
Filter = new NewsRequestFilter()
};
newsRequest.Filter.Type = newsType switch
{
NewsType.HomePage => "homepage",
NewsType.SectionName => "section-name",
_ => throw new Exception($"Unknown {nameof(newsType)}: {newsType}")
};
newsRequest.Filter.Name = name switch
{
Name.Undefined => null,
Name.Football => "football",
Name.Hockey => "hockey",
Name.Basketball => "basketball",
_ => throw new Exception($"Unknown {nameof(name)}: {name}"),
};
switch (newsPriority)
{
case NewsPriority.Main:
newsRequest.Filter.NewsPriority = "main";
break;
}
switch (newsContentOrigin)
{
case NewsContentOrigin.Mixed:
newsRequest.Filter.ContentOrigin = "mixed";
break;
}
string args = HttpHelper.UrlEncodeJson(newsRequest);
var uri = new Uri($"core/news/list?args={args}", UriKind.Relative);
return(await GetResponseFromSportsAsync <NewsResponseCollection>(uri).ConfigureAwait(false));
}
public async Task InsertNews(NewsRequest request)
{
try
{
var new_response = new News
{
Id = Guid.NewGuid(),
Context = request.Context,
Title = request.Title,
PublishTime = DateTime.Now
};
_saUow.GetRepository <News>().Insert(new_response);
await _saUow.SaveChangesAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
private static async void GetNews()
{
using (var db = DbFactory.GetDbSource())
{
var tickers = db.GetTickers();
foreach (var ticker in tickers)
{
var x = new NewsRequest(new List <string> {
ticker
});
var articles = await x.Execute();
Console.WriteLine(new string('-', ticker.Length));
Console.WriteLine(ticker);
Console.WriteLine(new string('-', ticker.Length));
Console.WriteLine(string.Join("\n\n", articles.Select(a => a.Headline)));
}
}
}
public async Task <ActionResult> Edit(News news)
{
try
{
InitializeServiceClient();
NewsRequest request = new NewsRequest();
request.ClientInfo = req.ClientInfo;
request.ID = Convert.ToInt32(Session["NewsID"]);
request.imageURL = news.imageURL;
request.body = news.body;
request.header = news.header;
HttpResponseMessage response = await client.PostAsJsonAsync("News/UpdateNewsEvent", request);
bool result = await response.Content.ReadAsAsync <bool>();
if (result)
{
TempData["EditNews"] = "Yes";
return(RedirectToAction("Index"));
}
else
{
TempData["EditNewsFailed"] = "No";
return(View(news));
}
}
catch (Exception ex)
{
// UserManager user = (UserManager)Session["CurrentUser"];
//LogHelper.AddLog("NewsController", ex.Message, ex.StackTrace, "HCL.Academy.Web", user.EmailID);
TelemetryClient telemetry = new TelemetryClient();
telemetry.TrackException(ex);
TempData["EditNewsFailed"] = "No";
return(View(news));
}
}
public void GivenNewsRequest_SetUp()
{
this.Request = new NewsRequest();
}
public decimal Create(NewsRequest request)
{
try
{
var spParameter = new SqlParameter[10];
#region Set param
var parameter = new SqlParameter("@P_Title", SqlDbType.NVarChar)
{
Direction = ParameterDirection.Input,
Value = request.Title
};
spParameter[0] = parameter;
parameter = new SqlParameter("@P_Content", SqlDbType.NVarChar)
{
Direction = ParameterDirection.Input,
Value = request.Content
};
spParameter[1] = parameter;
parameter = new SqlParameter("@P_Description", SqlDbType.NVarChar)
{
Direction = ParameterDirection.Input,
Value = request.Description
};
spParameter[2] = parameter;
parameter = new SqlParameter("@P_FeatureImage", SqlDbType.NVarChar)
{
Direction = ParameterDirection.Input,
Value = request.FeatureImage
};
spParameter[3] = parameter;
parameter = new SqlParameter("@P_Tag", SqlDbType.NVarChar)
{
Direction = ParameterDirection.Input,
Value = request.Tag
};
spParameter[4] = parameter;
parameter = new SqlParameter("@P_CategoryType", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input,
Value = 0
};
spParameter[5] = parameter;
parameter = new SqlParameter("@P_CreateDate", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input,
Value = DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss")
};
spParameter[6] = parameter;
parameter = new SqlParameter("@P_CreateBy", SqlDbType.NVarChar)
{
Direction = ParameterDirection.Input,
Value = request.CreateBy
};
spParameter[7] = parameter;
parameter = new SqlParameter("@P_Special", SqlDbType.VarChar)
{
Direction = ParameterDirection.Input,
Value = request.Special
};
spParameter[8] = parameter;
parameter = new SqlParameter("@P_Return", SqlDbType.Int)
{
Direction = ParameterDirection.Output,
Value = -1
};
spParameter[9] = parameter;
#endregion
SqlHelper.ExecuteNonQuery(ConfigInfo.ConnectString, CommandType.StoredProcedure, "PROC_PAGE_INSERT",
spParameter);
return(Convert.ToDecimal(spParameter[9].Value));
}
catch (Exception ex)
{
Logger.Log.Error(ex.ToString());
return(-1);
}
}
public async Task <IActionResult> GetNews([FromQuery] NewsRequest request)
{
return(Ok(await _newsService.GetNews(request)));
}
