public FeedDTO Add(String uri)
{
if (string.IsNullOrEmpty(uri)) // validate not null or empty
{
throw new ArgumentNullException("uri", "The uri parameter cannot be null or empty");
}
Uri feedUri;
if (!Uri.TryCreate(uri, UriKind.Absolute, out feedUri)) // validate is URI
{
throw new ArgumentException("uri", "The uri parameter must be a valid absolute URI path");
}
var feedObj = Load(feedUri);
var feedDTO = new FeedDTO()
{
Name = feedObj.Title.Text,
Description = feedObj.Description.Text,
Feed = feedUri,
Link = feedObj.Links.Any(o => o.RelationshipType.Equals("alternate", StringComparison.InvariantCultureIgnoreCase)) ?
feedObj.Links.First(o => o.RelationshipType.Equals("alternate", StringComparison.InvariantCultureIgnoreCase)).Uri : null
};
var id = _feedRepository.Add(feedDTO);
return(feedDTO);
}
protected void UpdateFeedStatus(IUnitOfWork db,
FeedDTO currentFeed,
IList <WalmartFeedItemDTO> feedItems,
TimeSpan waitTimeOfProcessing)
{
var thresholdDate = waitTimeOfProcessing == TimeSpan.Zero ? _time.GetAppNowTime().AddHours(-8) : _time.GetAppNowTime().Subtract(waitTimeOfProcessing);
_log.Info("thresholdDate=" + thresholdDate);
if (feedItems.All(i => WalmartUtils.ConvertFromFeedItemPublishedStatusToStandard(i.Status)
!= PublishedStatuses.PublishedInProgress) ||
currentFeed.SubmitDate < thresholdDate)
{
var feed = db.Feeds.GetAll().FirstOrDefault(f => f.Id == currentFeed.Id);
if (feed != null)
{
feed.Status = (int)FeedStatus.Processed;
db.Commit();
currentFeed.Status = (int)FeedStatus.Processed;
_log.Info(String.Format("Mark feed, id={0}, marketId={1}, as processed", feed.Id, feed.AmazonIdentifier));
}
}
}
public HttpResponseMessage GetFeedDetail(int lookupID)
{
try
{
FeedDTO feed = null;
bool result = dbDal.ReadFeed(lookupID, out feed);
if (result == false)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "The Feed was not found."));
}
else
{
return(Request.CreateResponse(HttpStatusCode.OK, feed));
}
}
catch (NpgsqlException e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Database error occurred"));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Failed to put get the feeds"));
}
}
public void seedData()
{
FeedDTO f1 = new FeedDTO
{
Id = FeedService.Id,
Title = "Estamos de viaje! 11",
Content = "Estamos yendo de joda."
};
FeedService.Id++;
feeds.Add(f1);
FeedDTO f2 = new FeedDTO
{
Id = FeedService.Id,
Title = "Vuelta al laburo",
Content = "Estamos yendo a laburar. Coso!"
};
FeedService.Id++;
feeds.Add(f2);
FeedDTO f3 = new FeedDTO
{
Id = FeedService.Id,
Title = "Aprendiendo angular.",
Content = "Pa' aprender y volar"
};
FeedService.Id++;
feeds.Add(f3);
}
/// <summary>
/// Get list feed news
/// </summary>
/// <param name="page">number of page, use for paging</param>
/// <returns></returns>
public string GetFeed(string page)
{
string result;
List <FeedDTO> resultDTOs = new List <FeedDTO>();
/*Using Regex to parse html*/
MatchCollection collectionItem;
/*Get Html document*/
string linkRequest = Constant.baoMoiFeedUrl.Replace(Constant.replaceUrlBaoMoi, page);
string htmDocument = Crawler.getResponse(linkRequest);
//Get feed from HTML
collectionItem = Utils.RegexHandle.Matches(Utils.Constant.patternFeedBaoMoi, htmDocument);
FeedDTO item;
foreach (Match matchItem in collectionItem)
{
item = new FeedDTO();
item.href = Constant.baoMoiHost + matchItem.Groups[1].Value;
item.title = matchItem.Groups[2].Value;
item.imageUrl = matchItem.Groups[3].Value;
item.source = matchItem.Groups[4].Value;
item.dateTime = matchItem.Groups[5].Value;
item.shortDescription = matchItem.Groups[6].Value;
resultDTOs.Add(item);
}
result = JsonConvert.SerializeObject(resultDTOs);
return(result);
}
public static Category FeedDtoToFeedMapper(FeedDTO model)
{
return(new Category
{
Name = model.Name,
Description = model.Description
});
}
public IActionResult CreateFeed([FromBody] FeedDTO input)
{
if (ModelState.IsValid)
{
return(Ok(_feedService.AddFeed(input)));
}
return(BadRequest());
}
public long Add(FeedDTO feed)
{
_redisManager.ExecAs <FeedDTO>(o =>
{
feed.Id = o.GetNextSequence();
o.Store(feed);
});
return(feed.Id);
}
public FeedDTO AddFeed(FeedDTO input)
{
input.Id = FeedService.Id;
FeedService.Id++;
feeds.Add(input);
return(input);
}
public async Task <IActionResult> ModifyFeed([FromRoute] string feedId, [FromBody] FeedDTO model)
{
var result = await _feedServices.EditFeed(feedId, model);
if (result.Success)
{
return(NoContent());
}
return(BadRequest(result));
}
public async Task <IActionResult> CreateFeed(FeedDTO model)
{
var result = await _feedServices.AddFeed(model);
if (result.Success)
{
return(Created("", result));
}
return(BadRequest(result));
}
public FeedDTO Get(long id)
{
FeedDTO feed = null;
_redisManager.ExecAs <FeedDTO>(o =>
{
feed = o.GetById(id);
});
return(feed);
}
protected FeedDTO GetExistFeed()
{
FeedDTO currentFeed = null;
using (var db = _dbFactory.GetRWDb())
{
currentFeed = db.Feeds.GetUnprocessedFeed(FeedType, Market, MarketplaceId);
if (currentFeed != null &&
String.IsNullOrEmpty(currentFeed.AmazonIdentifier))
{
currentFeed = null;
}
}
return(currentFeed);
}
public async Task <Response <FeedReadDto> > AddFeed(FeedDTO model)
{
var response = new Response <FeedReadDto>();
var category = FeedProfile.FeedDtoToFeedMapper(model);
if (await _feedRepo.Add(category))
{
var feedDto = FeedProfile.FeedToFeedReadDtoMapper(category);
response.Success = true;
response.Message = "category created successfully";
response.Data = feedDto;
return(response);
}
response.Message = "category failed to add";
return(response);
}
public FeedViewModel(FeedDTO feed)
{
Id = feed.Id;
Type = feed.Type;
Market = feed.Market;
MarketplaceId = feed.MarketplaceId;
AmazonIdentifier = feed.AmazonIdentifier;
Name = feed.Name;
Description = feed.Description;
RequestFilename = feed.RequestFilename;
ResponseFilename = feed.ResponseFilename;
MessageCount = feed.MessageCount;
Status = feed.Status;
SubmitDate = feed.SubmitDate;
}
public HttpResponseMessage Post([FromBody] FeedDTO value)
{
try
{
if (value == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "The request contained no feed data to create."));
}
if (value.LookupID == 0 && value.SourceID != null && value.SourceValue != null)
{
int lookupID = DEUtilities.ComputeHash(new List <string> {
value.SourceID, value.SourceValue
});
value.LookupID = lookupID;
}
//create a new feed
if (dbDal.AddedFeed(value))
{
HttpResponseMessage msg = Request.CreateResponse(HttpStatusCode.Created, value);
string location = HttpContext.Current.Request.Url + "/" + value.LookupID;
msg.Headers.Location = new Uri(location);
return(msg);
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Error getting feed data."));
}
}
catch (NpgsqlException e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Database error occurred"));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Failed to put get the feeds"));
}
}
public async Task ShouldReturnOkResultWhenValidModelPassed()
{
//Arrange
var model = new FeedDTO();
MockFeedService.Setup(x => x.AddFeed(It.IsAny <FeedDTO>()))
.Returns(Task.FromResult(new Response <FeedReadDto>()
{
Success = true
}));
var feedController = new FeedController(_serviceProvider);
var expected = 201;
//ACT
var actual = await feedController.CreateFeed(model) as CreatedResult;
//Assert
Assert.IsNotNull(actual);
Assert.AreEqual(expected, actual.StatusCode);
}
private List <FeedDTO> FeedToFeed(SyndicationFeed feed)
{
List <FeedDTO> lst = new List <FeedDTO>();
foreach (var item in feed.Items)
{
FeedDTO f = new FeedDTO();
if (item.Id != null)
{
f.Id = item.Id;
}
if (item.Title != null)
{
f.Title = item.Title.Text;
}
if (item.Summary != null)
{
f.Description = item.Summary.Text;
}
if (item.Authors != null && item.Authors.Count > 0)
{
f.Author = item.Authors[0].Email;
}
if (item.PublishDate != null)
{
f.PublishDate = item.PublishDate;
}
if (item.ElementExtensions.Where(p => p.OuterName == "faction").Count() > 0)
{
f.Faction = item.ElementExtensions.Where(p => p.OuterName == "faction").First().GetObject <XElement>().Value;
}
if (item.ElementExtensions.Where(p => p.OuterName == "expiry").Count() > 0)
{
f.ExpireDate = DateTimeOffset.Parse(item.ElementExtensions.Where(p => p.OuterName == "expiry").First().GetObject <XElement>().Value);
}
lst.Add(f);
}
return(lst);
}
public async Task ShouldReturnNoContentIfEditSuccessful()
{
//Arrange
var model = new FeedDTO();
var id = Guid.NewGuid().ToString();
MockFeedService.Setup(x => x.EditFeed(It.IsAny <string>(), It.IsAny <FeedDTO>()))
.Returns(Task.FromResult(new Response <string>()
{
Success = true
}));
var feedController = new FeedController(_serviceProvider);
var expected = 204;
//Act
var actual = await feedController.ModifyFeed(id, model) as NoContentResult;
//Assert
Assert.IsNotNull(actual);
Assert.AreEqual(expected, actual.StatusCode);
}
public HttpResponseMessage GetViewDetail(string viewName)
{
try
{
if (viewName == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Must specify a valid view name."));
}
else
{
bool requestedApprovedView = IsApprovedFeedContentView(viewName);
if (requestedApprovedView == false)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, String.Format("The requested view '{0}' is not an approved view.", viewName)));
}
FeedDTO dto = dbDal.GetFeedByViewName(viewName);
if (dto != null)
{
return(Request.CreateResponse(HttpStatusCode.OK, dto));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Error getting feed data."));
}
}
}
catch (NpgsqlException e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Database error occurred"));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Failed to put get the feeds"));
}
}
public async Task <Response <string> > EditFeed(string categoryId, FeedDTO model)
{
var response = new Response <string>();
var category = await _feedRepo.GetById(categoryId);
if (category is null)
{
response.Message = "Invalid feed id provided";
return(response);
}
category.Name = model.Name;
category.Description = model.Description;
if (await _feedRepo.Modify(category))
{
response.Success = true;
response.Message = "category edited successfully";
return(response);
}
response.Message = "could not update category";
return(response);
}
