public EventsResponse GetEvents(EventSearchRequest searchRequest)
{
var validator = new EventSearchVallidator().Validate(searchRequest).ToResponse();
if (!validator.Result)
{
return new EventsResponse {
Result = false, Errors = validator.Errors
}
}
;
var response = new EventsResponse();
try
{
response = _eventsRepository.GetEvents(searchRequest);
}
catch (Exception ex)
{
_logger.Error(ExceptionMessages.GetEventsException, ex);
response.Result = false;
response.Errors.Add(new ResponseError {
Name = "GetEventsException", Error = ExceptionMessages.GetEventsException
});
return(response);
}
return(response);
}
public async Task <IActionResult> Events(string link, int page)
{
EventsResponse events = new EventsResponse()
{
Events = new List <Event>(),
Favorites = new List <string>()
};
foreach (var favorite in _context.Favorites)
{
events.Favorites.Add(favorite.EventId);
}
var client = new HttpClient();
client.BaseAddress = new Uri("https://app.ticketmaster.com/discovery/v2/");
client.DefaultRequestHeaders.UserAgent.ParseAdd("Mozilla/5.0 (compatible; GrandCircus/1.0)");
string newLink = string.Concat(link + "&page=" + page.ToString());
var response = await client.GetStringAsync(newLink);
var result = JsonConvert.DeserializeObject <SearchEventsResponse>(response);
events.Events.AddRange(result._embedded.Events);
events.Page = result.Page.Number;
events.PageLink = link;
return(View("~/Views/Home/Events.cshtml", events));
}
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems)
{
AmazonRDSConfig config = new AmazonRDSConfig();
config.RegionEndpoint = region;
ConfigureClient(config);
AmazonRDSClient client = new AmazonRDSClient(creds, config);
EventsResponse resp = new EventsResponse();
do
{
DescribeEventsRequest req = new DescribeEventsRequest
{
Marker = resp.Marker
,
MaxRecords = maxItems
};
resp = client.DescribeEvents(req);
CheckError(resp.HttpStatusCode, "200");
foreach (var obj in resp.Events)
{
AddObject(obj);
}
}while (!string.IsNullOrEmpty(resp.Marker));
}
public async Task <ServiceResponse <EventsResponse> > GetEventsById(int?characterId)
{
ServiceResponse <EventsResponse> serviceResponse = new ServiceResponse <EventsResponse>();
DataResponse <EventsResponse> dataResponse = new DataResponse <EventsResponse>();
try
{
this.QueryDataId(Convert.ToInt32(characterId));
List <EventsResponse> eventResponses = new List <EventsResponse>();
foreach (var itemEvent in this.events)
{
EventsResponse eventResponse = new EventsResponse();
eventResponse.id = itemEvent.Id;
eventResponse.title = itemEvent.Title;
eventResponse.description = itemEvent.Description;
eventResponse.resourceURI = itemEvent.ResourceUri;
eventResponse.modified = Convert.ToString(itemEvent.Modified);
eventResponse.start = Convert.ToString(itemEvent.StartDate);
eventResponse.end = Convert.ToString(itemEvent.EndDate);
eventResponses.Add(eventResponse);
}
dataResponse.Results = eventResponses;
serviceResponse.data = dataResponse;
return(serviceResponse);
}
catch (Exception)
{
return(serviceResponse);
}
}
/// <summary>
/// Answer with an AccessSafely which
/// writes the respondWith call count using "count" every time respondWith(...) is called, and
/// reads the respondWith call count using "count".
/// </summary>
/// <param name="n">Number of times respondWith must be called before readFrom will return.</param>
/// <returns>Access safely instance</returns>
public AccessSafely ExpectRespondWith(int n)
{
_respondWithSafely = AccessSafely.AfterCompleting(n)
.WritingWith <Response>("events", response => { RespondWithCount.IncrementAndGet(); EventsResponse.Set(response); })
.ReadingWith("count", () => RespondWithCount.Get())
.ReadingWith("eventsResponse", () => EventsResponse.Get());
return(_respondWithSafely);
}
public async Task <IEnumerable <DkpEvent> > GetEvents(string name = null)
{
EventsResponse response = await client.GetEvents();
if (!string.IsNullOrWhiteSpace(name))
{
return(response?.Events?.Where(x => x?.Name?.Contains(name, StringComparison.OrdinalIgnoreCase) == true));
}
else
{
return(response?.Events?.Where(x => config.FavoriteEvents?.Contains(x.Id) == true));
}
}
public async Task <EventsResponse> GetEvents(string type)
{
string url = $"{HttpClientBuilder.BaseUrl}events";
if (type != null && !type.Equals(""))
{
url += $"?type={type}"; //filter events (upcoming or finished)
}
var httpRequestMessage = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri(url),
Headers =
{
{ HttpRequestHeader.Authorization.ToString(), $"Bearer {token}" }
}
};
var response = await HttpClientBuilder.HttpClient.SendAsync(httpRequestMessage);
if (response.IsSuccessStatusCode)
{
if (response.Content == null)
{
return(new EventsResponse()
{
Error = true,
Message = "Content null",
Events = null
});
}
EventsResponse eventResponse =
await response.Content.ReadAsAsync <EventsResponse>();
return(eventResponse);
}
else
{
return(new EventsResponse()
{
Error = true,
Message = response.ReasonPhrase,
Events = null
});
}
}
public void Process(EventsResponse events)
{
long timestamp = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds;
HashSet <EventState> contestedLocationEvents = new HashSet <EventState>(events.Events.Where(es => ContestedLocationDefinitions.EventList.Contains(es.EventId)));
IList <ContestedLocationStatus> changedStatuses = new List <ContestedLocationStatus>();
foreach (ContestedLocation loc in ContestedLocationDefinitions.ContestedLocations)
{
changedStatuses.Add(loc.GetStatus(contestedLocationEvents));
}
if (changedStatuses.Count > 0)
{
LOGGER.Debug("Saving updated contested location status(es)");
IDbTransaction tx = m_DbConn.BeginTransaction();
try
{
DbSetProperty("timestamp", timestamp.ToString(), tx);
foreach (ContestedLocationStatus status in changedStatuses)
{
DbSetContestedLocationStatus(status, tx);
}
tx.Commit();
}
catch (Exception e)
{
LOGGER.Error("Exception thrown when attempting to update contested location status", e);
try
{
tx.Rollback();
}
catch (Exception ex)
{
LOGGER.Error("Exception thrown when attempting to roll back contested location status update", ex);
}
}
}
}
public async Task <IActionResult> Events(string city, string stateCode)
{
EventsResponse events = new EventsResponse()
{
Events = new List <Event>(),
Favorites = new List <string>()
};
foreach (var favorite in _context.Favorites)
{
events.Favorites.Add(favorite.EventId);
}
events.PageLink = "events?apikey=2kVlEu5eTcizQZ73bkzcleUGRaFcJhxp"
+ "&locale=*&city=" + city + "&statecode=" + stateCode;
var client = new HttpClient();
client.BaseAddress = new Uri("https://app.ticketmaster.com/discovery/v2/");
client.DefaultRequestHeaders.UserAgent.ParseAdd("Mozilla/5.0 (compatible; GrandCircus/1.0)");
var response = await client.GetStringAsync(events.PageLink);
var result = JsonConvert.DeserializeObject <SearchEventsResponse>(response);
events.Events.AddRange(result._embedded.Events);
events.Page = result.Page.Number;
return(View(events));
/*Previous method below using ticketmaster library.
*
* var request = new SearchEventsRequest();
* EventsResponse result = new EventsResponse();
* List<Event> events = new List<Event>();
* request.AddQueryParameter(SearchEventsQueryParameters.city, city);
* request.AddQueryParameter(SearchEventsQueryParameters.stateCode, statecode);
* for (int i = 0; i < 3; i++)
* {
* request.AddQueryParameter(SearchEventsQueryParameters.page, i.ToString());
* var response = await _discovery.Events.SearchEventsAsync(request);
* events.AddRange(response._embedded.Events);
*
* }*/
}
private static async Task ClustersApi(DatabricksClient client)
{
Console.WriteLine("Listing node types (take 10)");
var nodeTypes = await client.Clusters.ListNodeTypes();
foreach (var nodeType in nodeTypes.Take(10))
{
Console.WriteLine($"\t{nodeType.NodeTypeId}\tMemory: {nodeType.MemoryMb} MB\tCores: {nodeType.NumCores}\tAvailable Quota: {nodeType.ClusterCloudProviderNodeInfo.AvailableCoreQuota}");
}
Console.WriteLine("Listing Databricks runtime versions");
var sparkVersions = await client.Clusters.ListSparkVersions();
foreach (var(key, name) in sparkVersions)
{
Console.WriteLine($"\t{key}\t\t{name}");
}
Console.WriteLine("Creating standard cluster");
var clusterConfig = ClusterInfo.GetNewClusterConfiguration("Sample cluster")
.WithRuntimeVersion(RuntimeVersions.Runtime_6_4_ESR)
.WithAutoTermination(30)
.WithClusterLogConf("dbfs:/logs/")
.WithNodeType(NodeTypes.Standard_D3_v2)
.WithClusterMode(ClusterMode.SingleNode);
clusterConfig.DockerImage = new DockerImage {
Url = "databricksruntime/standard:latest"
};
var clusterId = await client.Clusters.Create(clusterConfig);
var createdCluster = await client.Clusters.Get(clusterId);
var createdClusterConfig = JsonConvert.SerializeObject(createdCluster, Formatting.Indented);
Console.WriteLine("Created cluster config: ");
Console.WriteLine(createdClusterConfig);
while (true)
{
var state = await client.Clusters.Get(clusterId);
Console.WriteLine("[{0:s}] Cluster {1}\tState {2}\tMessage {3}", DateTime.UtcNow, clusterId,
state.State, state.StateMessage);
if (state.State == ClusterState.RUNNING || state.State == ClusterState.ERROR || state.State == ClusterState.TERMINATED)
{
break;
}
await Task.Delay(TimeSpan.FromSeconds(15));
}
Console.WriteLine("Deleting cluster {0}", clusterId);
await client.Clusters.Delete(clusterId);
Console.WriteLine("Creating HighConcurrency cluster");
clusterConfig = ClusterInfo.GetNewClusterConfiguration("Sample cluster")
.WithRuntimeVersion(RuntimeVersions.Runtime_6_4_ESR)
.WithAutoScale(3, 7)
.WithAutoTermination(30)
.WithClusterLogConf("dbfs:/logs/")
.WithNodeType(NodeTypes.Standard_D3_v2)
.WithClusterMode(ClusterMode.HighConcurrency)
.WithTableAccessControl(true);
clusterId = await client.Clusters.Create(clusterConfig);
createdCluster = await client.Clusters.Get(clusterId);
createdClusterConfig = JsonConvert.SerializeObject(createdCluster, Formatting.Indented);
Console.WriteLine("Created cluster config: ");
Console.WriteLine(createdClusterConfig);
while (true)
{
var state = await client.Clusters.Get(clusterId);
Console.WriteLine("[{0:s}] Cluster {1}\tState {2}\tMessage {3}", DateTime.UtcNow, clusterId,
state.State, state.StateMessage);
if (state.State == ClusterState.RUNNING || state.State == ClusterState.ERROR || state.State == ClusterState.TERMINATED)
{
break;
}
await Task.Delay(TimeSpan.FromSeconds(15));
}
Console.WriteLine("Deleting cluster {0}", clusterId);
await client.Clusters.Delete(clusterId);
Console.WriteLine("Getting all events from a test cluster");
const string testClusterId = "0530-210517-viced348";
EventsResponse eventsResponse = null;
var events = new List <ClusterEvent>();
do
{
var nextPage = eventsResponse?.NextPage;
eventsResponse = await client.Clusters.Events(
testClusterId,
nextPage?.StartTime,
nextPage?.EndTime,
nextPage?.Order,
nextPage?.EventTypes,
nextPage?.Offset,
nextPage?.Limit
);
events.AddRange(eventsResponse.Events);
} while (eventsResponse.HasNextPage);
Console.WriteLine("{0} events retrieved from cluster {1}.", events.Count, testClusterId);
Console.WriteLine("Top 10 events: ");
foreach (var e in events.Take(10))
{
Console.WriteLine("\t[{0:s}] {1}\t{2}", e.Timestamp, e.Type, e.Details.User);
}
}
private void Handle(EventsResponse response)
{
_events.Handle(response.Events);
}
public void Process(EventsResponse events)
{
long timestamp = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds;
HashSet <EventState> metaEvents = new HashSet <EventState>(events.Events.Where(es => es.WorldId == WORLD_ID && MetaEventDefinitions.EventList.Contains(es.EventId)));
HashSet <MetaEventStatus> changedStatuses = new HashSet <MetaEventStatus>();
// discover meta-event states
foreach (MetaEvent meta in MetaEventDefinitions.MetaEvents)
{
MetaEventStatus oldStatus = DbGetMetaEventStatus(meta.Id);
int stageId = meta.GetStageId(metaEvents, oldStatus.StageId);
// stock state
MetaEventStatus status = new MetaEventStatus()
{
Id = meta.Id,
Name = meta.Name,
MinCountdown = meta.MinSpawn,
MaxCountdown = meta.MaxSpawn,
StageId = stageId,
StageType = null,
StageName = null,
Timestamp = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds
};
// we're in a stage
if (stageId >= 0)
{
MetaEventStage stage = meta.Stages.ElementAt(stageId);
if (stage.Countdown > 0 && stage.Countdown != uint.MaxValue)
{
status.Countdown = stage.Countdown;
}
else
{
status.Countdown = 0;
}
status.StageName = stage.Name;
status.StageTypeEnum = stage.Type;
}
// has the status changed?
if (oldStatus.StageId != status.StageId || (stageId >= 0 && oldStatus.StageName != status.StageName))
{
// if the actual stage hasn't changed (multiline scenareo) then don't update the timestamp
if (oldStatus.StageId == status.StageId)
{
status.Timestamp = oldStatus.Timestamp;
}
changedStatuses.Add(status);
}
}
if (changedStatuses.Count > 0)
{
LOGGER.DebugFormat("Saving {0} updated event status(es)", changedStatuses.Count);
IDbTransaction tx = m_DbConn.BeginTransaction();
try
{
DbSetProperty("timestamp", timestamp.ToString(), tx);
foreach (MetaEventStatus status in changedStatuses)
{
DbSetMetaEventStatus(status, tx);
}
tx.Commit();
}
catch (Exception e)
{
LOGGER.Error("Exception thrown when attempting to update event status", e);
try
{
tx.Rollback();
}
catch (Exception ex)
{
LOGGER.Error("Exception thrown when attempting to roll back event status update", ex);
}
}
}
}
