static void Main(string[] args)
{
string apiKey = ConfigurationManager.AppSettings["56ac439a92694577a2779f3d0ee0cd85"];
Console.WriteLine("Enter your search query");
var search = new SearchRequest()
{
apiKey = apiKey
};
search.query = Console.ReadLine();
var searchResponse = ApiCall.Send <SearchResponse>(search);
// var item1 = response.items[0];
//var itemRequest = new ItemRequest() {apiKey = search.apiKey, itemId = item1.itemId};
//var response2 = ApiCall.Send<ItemResponse>(itemRequest);
var feedRequest = new FeedRequest()
{
apiKey = apiKey,
feed = FeedType.bestsellers
};
var feedResponse = ApiCall.Send <FeedResponse>(feedRequest);
Console.ReadLine();
}
public Response DoTask(FeedRequest feedRequest)
{
try
{
var request = feedRequest.Request;
Logger.GetLogger(baseUrl).Info("do task -> request address " + request.Uri);
var response = NodeVisitor.Crawler.Request(request);
if (response != null)
{
Logger.GetLogger(baseUrl).Info("request " + request.Uri + " response code is " + response.StatusCode);
}
if (response == null)
{
Logger.GetLogger(baseUrl).Error("request " + request.Uri + " response is null");
}
return(response);
}
catch (Exception ex)
{
Logger.GetLogger(baseUrl).Info("do task -> request address failed " + ex.Message);
}
return(null);
}
protected void Save(FeedRequest feedRequest, Response response)
{
if (response == null)
{
Logger.GetLogger(baseUrl).Error(feedRequest.Request.Uri + " response save response is null.");
return;
}
var request = feedRequest.Request;
var content = Convert(response.Data.ToString(), Encoding.GetEncoding(response.Charset), Encoding.UTF8);
var snap = new FeedSnapshot
{
Url = request.Uri.ToString(),
Content = content,
RuiJiExpression = feedRequest.Expression
};
var json = JsonConvert.SerializeObject(snap, Formatting.Indented);
var fileName = Path.Combine(snapshotPath, feedRequest.Setting.Id + "_" + DateTime.Now.Ticks + ".json");
if (feedRequest.Setting.Delay > 0)
{
fileName = Path.Combine(delayPath, feedRequest.Setting.Id + "_" + DateTime.Now.AddMinutes(feedRequest.Setting.Delay).Ticks + ".json");
}
Logger.GetLogger(baseUrl).Info(request.Uri + " response save to " + fileName);
File.WriteAllText(fileName, json, Encoding.UTF8);
}
public static FeedResponse GetFeed(Session session, FeedRequest feedRequest)
{
return(Consume <FeedResponse>(session, "api/items/get",
(request) =>
{
request.AddParameter("flags", (int)feedRequest.Flags);
if (feedRequest.PromotedOnly)
{
request.AddParameter("promoted", 1);
}
if (feedRequest.OlderThan != null)
{
request.AddParameter("older", feedRequest.OlderThan.Id);
}
if (feedRequest.NewerThan != null)
{
request.AddParameter("newer", feedRequest.NewerThan.Id);
}
if (!string.IsNullOrEmpty(feedRequest.Tags))
{
request.AddParameter("tags", feedRequest.Tags);
}
if (!string.IsNullOrEmpty(feedRequest.ByUser))
{
request.AddParameter("user", feedRequest.ByUser);
}
},
null));
}
public HttpResponseMessage Update(HttpRequestMessage request, FeedRequest <Customer> data)
{
try
{
Customer currentCustomer = _unitOfWork.Customers.Get(data.Item.ID);
currentCustomer.DateOfBirth = data.Item.DateOfBirth;
currentCustomer.Email = data.Item.Email;
currentCustomer.FirstName = data.Item.FirstName;
currentCustomer.LastName = data.Item.LastName;
currentCustomer.Mobile = data.Item.Mobile;
currentCustomer.Notes = data.Item.Notes;
currentCustomer.PassportData = data.Item.PassportData;
_unitOfWork.Customers.Update(currentCustomer);
_unitOfWork.Save();
string filterKey = GetCookieValue(request, AppConstants.LOGIN);
if (FilteredCustomers.ContainsKey(filterKey))
{
FilteredCustomers.Remove(filterKey);
}
return(GetRange(request, new RangeRequest <Customer>()
{
PageNum = data.PageNum,
PageSize = data.PageSize,
FieldName = data.FieldName,
Direction = data.Direction
}));
}
catch (Exception ex) { return(ProcessError(ex, request)); }
}
public async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "POST", Route = nameof(Feed))] HttpRequest request, ILogger log)
{
try
{
log.LogInformation("Requesting ESPN Feed!");
//Deserialize request to hard typed FeedRequest
string requestBody = await new StreamReader(request.Body).ReadToEndAsync();
FeedRequest feedRequest = JsonConvert.DeserializeObject <FeedRequest>(requestBody);
if (feedRequest.Feed == 0)
{
throw new ArgumentNullException();
}
log.LogInformation("Deserialized " + nameof(FeedRequest) + ".");
List <FeedResponse> feedResponses = await _feedLogic.GetFeed(feedRequest, log);
return(new OkObjectResult(feedResponses));
}
catch (ArgumentNullException argsNullEx)
{
log.LogError(argsNullEx, argsNullEx.Message);
return(new BadRequestObjectResult("Please enter a valid feed!"));
}
catch (CosmosException cosmosEx)
{
log.LogError(cosmosEx, cosmosEx.Message);
return(new BadRequestObjectResult("Unable to archive data: " + cosmosEx.Message));
}
catch (JsonReaderException jsonReaderEx)
{
log.LogError(jsonReaderEx, jsonReaderEx.Message);
return(new BadRequestObjectResult("Unable to read the malformed request!"));
}
catch (JsonSerializationException jsonSerializationEx)
{
log.LogError(jsonSerializationEx, jsonSerializationEx.Message);
return(new BadRequestObjectResult("Unable to deserialize the request!"));
}
catch (Exception ex) //unhandled exception, return 400 with message instead of vague 500 server error.
{
log.LogError(ex, ex.Message);
return(new BadRequestObjectResult("An unexpected error occured: " + ex.Message));
}
}
public async Task <IActionResult> Post([FromBody] FeedRequest feedReq)
{
if (!ModelState.IsValid)
{
return(HttpBadRequest(ModelState));
}
var result = await repository.Insert(new Feed(feedReq.Url, feedReq.Name, feedReq.Type));
CloudQueueMessage message = new CloudQueueMessage(JsonConvert.SerializeObject(result.Result));
await feedQueue.AddMessageAsync(message);
return(new CreatedResult("/Feed", result.Result));
}
public void SetUp()
{
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, "username"),
new Claim(ClaimTypes.NameIdentifier, "userId"),
new Claim("name", "John Doe")
};
var identity = new ClaimsIdentity(claims, "TestAuthType");
var claimsPrincipal = new ClaimsPrincipal(identity);
_hearingServicesMock = new Mock <IBookingsApiClient>();
_userAccountServiceMock = new Mock <IUserAccountService>();
_userManagerMock = new Mock <UserManager>(_userAccountServiceMock.Object);
_userIdentity = new Mock <IUserIdentity>();
var context = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = claimsPrincipal
}
};
_hearingServicesMock.Setup(x => x.CreateHearingAsync(It.IsAny <HearingRequest>())).ReturnsAsync(1);
_controller = new HearingsController(_hearingServicesMock.Object, _userManagerMock.Object, _userIdentity.Object)
{
ControllerContext = context
};
var participantRequest = new ParticipantRequest()
{
Display_name = "displayname",
Email = "*****@*****.**",
First_name = "firstname",
Last_name = "lastname",
Phone = "1234567890",
Role = "administrator",
Title = "ms",
Username = "******"
};
feedRequest = new FeedRequest {
Location = "Administrator", Participants = new List <ParticipantRequest>()
};
feedRequest.Participants.Add(participantRequest);
}
/// <summary>
/// Get & map the feed responses based on the given feed request. Archive feeds only if requested.
/// </summary>
/// <param name="feedRequest">the feed request</param>
/// <param name="log">logger instance</param>
/// <returns>feed responses for given feed request</returns>
public async Task <List <FeedResponse> > GetFeed(FeedRequest feedRequest, ILogger log)
{
string feedURL = GetFeedURL(feedRequest.Feed, log);
SyndicationFeed feed = _feedData.GetFeedData(feedURL, log);
List <FeedResponse> feedResponses = MapSyndicationFeedToFeedResponses(feed, feedRequest, log);
if (feedRequest.Archive && feedResponses.Count > 0)
{
await _feedData.ArchiveFeedData(feedResponses, log);
}
return(feedResponses);
}
public async Task GettingFeedWithArchiveCallsDataAndLogsInformation()
{
//Arrange
FeedRequest feedRequest = new FeedRequest()
{
Feed = FeedEnum.MLB,
MaxNumberOfResults = 1,
Archive = true
};
//Act
List <FeedResponse> feedResponses = await _feedLogic.GetFeed(feedRequest, _loggerMock.Object);
//Assert & Verify
VerifyLoggerMockLoggedInformation(2);
_feedDataMock.Verify(fdm => fdm.GetFeedData(It.IsAny <string>(), _loggerMock.Object), Times.Once);
_feedDataMock.Verify(fdm => fdm.ArchiveFeedData(feedResponses, _loggerMock.Object), Times.Once);
}
public HttpResponseMessage Create(HttpRequestMessage request, FeedRequest <Customer> data)
{
try
{
_unitOfWork.Customers.Create(data.Item);
_unitOfWork.Save();
string filterKey = GetCookieValue(request, AppConstants.LOGIN);
if (FilteredCustomers.ContainsKey(filterKey))
{
FilteredCustomers.Remove(filterKey);
}
return(GetRange(request, new RangeRequest <Customer>()
{
PageNum = data.PageNum,
PageSize = data.PageSize,
FieldName = data.FieldName,
Direction = data.Direction
}));
}
catch (Exception ex) { return(ProcessError(ex, request)); }
}
public async Task GettingFeedCallsDataMapsSyndicationFeedAndLogsInformation()
{
//Arrange
FeedRequest feedRequest = new FeedRequest()
{
Feed = FeedEnum.MLB,
MaxNumberOfResults = 1
};
//Act
List <FeedResponse> feedResponses = await _feedLogic.GetFeed(feedRequest, _loggerMock.Object);
//Assert & Verify
Assert.AreEqual(1, feedResponses.Count);
Assert.AreEqual("title", feedResponses[0].id);
Assert.AreEqual("title", feedResponses[0].Title);
Assert.AreEqual("summary", feedResponses[0].Description);
Assert.AreEqual(FeedEnum.MLB, feedResponses[0].Feed);
VerifyLoggerMockLoggedInformation(2);
_feedDataMock.Verify(fdm => fdm.GetFeedData("someRssFeedUrl", _loggerMock.Object), Times.Once);
}
/// <summary>
/// Map the SyndicationFeed Items to a list of FeedResponses. Only map the maximum requested.
/// </summary>
/// <param name="feed">syndication feed to map</param>
/// <param name="maxResults">requested max results to map</param>
/// <param name="log">logger instance</param>
/// <returns>mapped feed responses</returns>
public List <FeedResponse> MapSyndicationFeedToFeedResponses(SyndicationFeed feed, FeedRequest feedRequest, ILogger log)
{
List <FeedResponse> feedResponses = new List <FeedResponse>();
foreach (SyndicationItem item in feed.Items.Take(feedRequest.MaxNumberOfResults))
{
feedResponses.Add(new FeedResponse()
{
Title = item.Title.Text,
Description = item.Summary.Text,
Link = item.Links.Count == 0 ? string.Empty : item.Links[0].Uri.AbsoluteUri, //only first url needed (often only one entry anyway)
id = item.Title.Text,
Feed = feedRequest.Feed
});
}
log.LogInformation("Mapped {0} to {1} {2}s.", nameof(SyndicationFeed), feedResponses.Count, nameof(FeedResponse));
return(feedResponses);
}
