public StatisticsResult Statistics(StatisticsParameter parameter, string securityToken)
{
var request = new StatisticsRequest {
Parameters = parameter
};
HttpClientHandler clientHandler = new HttpClientHandler();
clientHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => { return(true); };
using (var httpClient = new HttpClient(clientHandler)
{
BaseAddress = new Uri(url)
})
{
try
{
httpClient.DefaultRequestHeaders.Add("Authorization", securityToken);
httpClient.Timeout = TimeSpan.FromMinutes(30);
var httpResponseMessage = httpClient.PostAsJsonAsync("textProcess/Statistics", request).Result;
var response = httpResponseMessage.Content.ReadAsAsync <StatisticsResponse>().Result;
if (response.State.HasError)
{
throw new Exception(response.State.ErrorMessage);
}
return(response.Result);
}
catch (Exception ex)
{
throw ex;
}
}
}
public void ShouldGetWorkspaceStatisticsAsynchronously()
{
IRestRequest savedRequest = null;
mockClient.Setup(trc => trc.ExecuteAsync <WorkspaceStatistics>(It.IsAny <IRestRequest>(), It.IsAny <Action <WorkspaceStatistics> >()))
.Callback <IRestRequest, Action <WorkspaceStatistics> >((request, action) => savedRequest = request);
var client = mockClient.Object;
manualResetEvent = new ManualResetEvent(false);
var options = new StatisticsRequest();
options.Minutes = 10;
client.GetWorkspaceStatistics(WORKSPACE_SID, options, stats =>
{
manualResetEvent.Set();
});
manualResetEvent.WaitOne(1);
mockClient.Verify(trc => trc.ExecuteAsync <WorkspaceStatistics>(It.IsAny <IRestRequest>(), It.IsAny <Action <WorkspaceStatistics> >()), Times.Once);
Assert.IsNotNull(savedRequest);
Assert.AreEqual("Workspaces/{WorkspaceSid}/Statistics", savedRequest.Resource);
Assert.AreEqual(Method.GET, savedRequest.Method);
Assert.AreEqual(2, savedRequest.Parameters.Count);
var workspaceSidParam = savedRequest.Parameters.Find(x => x.Name == "WorkspaceSid");
Assert.IsNotNull(workspaceSidParam);
Assert.AreEqual(WORKSPACE_SID, workspaceSidParam.Value);
var minutesParam = savedRequest.Parameters.Find(x => x.Name == "Minutes");
Assert.IsNotNull(minutesParam);
Assert.AreEqual(10, minutesParam.Value);
}
public async System.Threading.Tasks.Task ShouldGetWorkspaceStatistics()
{
RestRequest savedRequest = null;
var tcs = new TaskCompletionSource <WorkspaceStatistics>();
tcs.SetResult(new WorkspaceStatistics());
mockClient.Setup(trc => trc.Execute <WorkspaceStatistics>(It.IsAny <RestRequest>()))
.Callback <RestRequest>((request) => savedRequest = request)
.Returns(tcs.Task);
var client = mockClient.Object;
var options = new StatisticsRequest();
options.Minutes = 10;
await client.GetWorkspaceStatisticsAsync(WORKSPACE_SID, options);
mockClient.Verify(trc => trc.Execute <WorkspaceStatistics>(It.IsAny <RestRequest>()), Times.Once);
Assert.IsNotNull(savedRequest);
Assert.AreEqual("Workspaces/{WorkspaceSid}/Statistics", savedRequest.Resource);
Assert.AreEqual("GET", savedRequest.Method);
Assert.AreEqual(2, savedRequest.Parameters.Count);
var workspaceSidParam = savedRequest.Parameters.Find(x => x.Name == "WorkspaceSid");
Assert.IsNotNull(workspaceSidParam);
Assert.AreEqual(WORKSPACE_SID, workspaceSidParam.Value);
var minutesParam = savedRequest.Parameters.Find(x => x.Name == "Minutes");
Assert.IsNotNull(minutesParam);
Assert.AreEqual(10, minutesParam.Value);
}
public void ShouldGetTaskQueueStatisticsAsynchronously()
{
IRestRequest savedRequest = null;
mockClient.Setup(trc => trc.ExecuteAsync<TaskQueueStatistics>(It.IsAny<IRestRequest>(), It.IsAny<Action<TaskQueueStatistics>>()))
.Callback<IRestRequest, Action<TaskQueueStatistics>>((request, action) => savedRequest = request);
var client = mockClient.Object;
manualResetEvent = new ManualResetEvent(false);
var options = new StatisticsRequest();
options.Minutes = 10;
client.GetTaskQueueStatistics(WORKSPACE_SID, TASK_QUEUE_SID, options, stats =>
{
manualResetEvent.Set();
});
manualResetEvent.WaitOne(1);
mockClient.Verify(trc => trc.ExecuteAsync<TaskQueueStatistics>(It.IsAny<IRestRequest>(), It.IsAny<Action<TaskQueueStatistics>>()), Times.Once);
Assert.IsNotNull(savedRequest);
Assert.AreEqual("Workspaces/{WorkspaceSid}/TaskQueues/{TaskQueueSid}/Statistics", savedRequest.Resource);
Assert.AreEqual(Method.GET, savedRequest.Method);
Assert.AreEqual(3, savedRequest.Parameters.Count);
var workspaceSidParam = savedRequest.Parameters.Find(x => x.Name == "WorkspaceSid");
Assert.IsNotNull (workspaceSidParam);
Assert.AreEqual (WORKSPACE_SID, workspaceSidParam.Value);
var taskQueueSidParam = savedRequest.Parameters.Find(x => x.Name == "TaskQueueSid");
Assert.IsNotNull(taskQueueSidParam);
Assert.AreEqual(TASK_QUEUE_SID, taskQueueSidParam.Value);
var minutesParam = savedRequest.Parameters.Find(x => x.Name == "Minutes");
Assert.IsNotNull(minutesParam);
Assert.AreEqual(10, minutesParam.Value);
}
public void ShouldGetTaskQueueStatistics()
{
IRestRequest savedRequest = null;
mockClient.Setup(trc => trc.Execute<TaskQueueStatistics>(It.IsAny<IRestRequest>()))
.Callback<IRestRequest>((request) => savedRequest = request)
.Returns(new TaskQueueStatistics());
var client = mockClient.Object;
var options = new StatisticsRequest();
options.Minutes = 10;
client.GetTaskQueueStatistics(WORKSPACE_SID, TASK_QUEUE_SID, options);
mockClient.Verify(trc => trc.Execute<TaskQueueStatistics>(It.IsAny<IRestRequest>()), Times.Once);
Assert.IsNotNull(savedRequest);
Assert.AreEqual("Workspaces/{WorkspaceSid}/TaskQueues/{TaskQueueSid}/Statistics", savedRequest.Resource);
Assert.AreEqual(Method.GET, savedRequest.Method);
Assert.AreEqual(3, savedRequest.Parameters.Count);
var workspaceSidParam = savedRequest.Parameters.Find(x => x.Name == "WorkspaceSid");
Assert.IsNotNull(workspaceSidParam);
Assert.AreEqual(WORKSPACE_SID, workspaceSidParam.Value);
var taskQueueSidParam = savedRequest.Parameters.Find(x => x.Name == "TaskQueueSid");
Assert.IsNotNull(taskQueueSidParam);
Assert.AreEqual(TASK_QUEUE_SID, taskQueueSidParam.Value);
var minutesParam = savedRequest.Parameters.Find(x => x.Name == "Minutes");
Assert.IsNotNull(minutesParam);
Assert.AreEqual(10, minutesParam.Value);
}
public void ShouldGetWorkspaceStatistics()
{
IRestRequest savedRequest = null;
mockClient.Setup(trc => trc.Execute <WorkspaceStatistics>(It.IsAny <IRestRequest>()))
.Callback <IRestRequest>((request) => savedRequest = request)
.Returns(new WorkspaceStatistics());
var client = mockClient.Object;
var options = new StatisticsRequest();
options.Minutes = 10;
client.GetWorkspaceStatistics(WORKSPACE_SID, options);
mockClient.Verify(trc => trc.Execute <WorkspaceStatistics>(It.IsAny <IRestRequest>()), Times.Once);
Assert.IsNotNull(savedRequest);
Assert.AreEqual("Workspaces/{WorkspaceSid}/Statistics", savedRequest.Resource);
Assert.AreEqual(Method.GET, savedRequest.Method);
Assert.AreEqual(2, savedRequest.Parameters.Count);
var workspaceSidParam = savedRequest.Parameters.Find(x => x.Name == "WorkspaceSid");
Assert.IsNotNull(workspaceSidParam);
Assert.AreEqual(WORKSPACE_SID, workspaceSidParam.Value);
var minutesParam = savedRequest.Parameters.Find(x => x.Name == "Minutes");
Assert.IsNotNull(minutesParam);
Assert.AreEqual(10, minutesParam.Value);
}
public Task <(Stream Chart, ResultMessage Message)> PerQuarter(StatisticsRequest request)
{
var today = DateTime.Today;
today = new DateTime(today.Year, today.Month, today.Day, 0, 0, 0, DateTimeKind.Local);
return(this.GetResult(request, DetailedPeriod.Quarter, today));
}
private Task <(Stream Chart, ResultMessage Message)> GetStatisticsPerMinute(StatsCommand command, Contexts contexts)
{
var time = this._configurationService.GetConfigurationItem <TimeBehindStatisticsPerMinute>(contexts.Server.Id).Value;
var request = new StatisticsRequest(contexts.Server.Id, time, command.User, command.Channel);
return(this._periodStatisticsService.PerMinute(request));
}
public async Task <IActionResult> GetRevenue(StatisticsRequest request)
{
var Revenue = await _orderService.RevenueStatistic(request);
//var json = JsonConvert.SerializeObject(Revenue);
ViewBag.dataSource = Revenue;
return(View(Revenue));
}
public override void OnReceive(object[] packet)
{
if (packet == null || packet.Length == 0)
{
return;
}
_statisticsRequest = packet[0] as StatisticsRequest;
}
public async Task <IActionResult> CreateStatistic([FromBody] StatisticsRequest request)
{
var res = await _context.Statistics.AddAsync(_mapper.Map <Statistic>(request));
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(CreateStatistic),
await _context.Statistics.ProjectTo <StatisticsResponse>(_mapper.ConfigurationProvider)
.FirstOrDefaultAsync(x => x.Id == res.Entity.Id)));
}
public async Task <IActionResult> Post(StatisticsRequest request)
{
if (DNT)
{
return(NoContent());
}
await _mediator.Send(new UpdateStatisticCommand(request.PostId, request.IsLike));
return(NoContent());
}
public void CalculateAllData(StatisticsRequest sReq)
{
foreach (var sVar in sReq.StatisticsData)
{
sVar.Values = new List <int>();
foreach (var dataPointQuery in sVar.LuceneQueries)
{
sVar.Values.Add(_statCalc.CalculateDataPointValue(_searcher.Search(dataPointQuery), sVar.CalculationType));
}
}
}
public IEnumerable <Core.Models.StatisticsResult> GetStatistics(
int statisticsId,
[FromBody] StatisticsRequest reqobj)
{
return(this.GetStatistics(
reqobj.years,
statisticsId,
reqobj.group,
reqobj.filter,
reqobj.area_year));
}
public async Task <List <RevenueStatisticViewModel> > RevenueStatistic(StatisticsRequest request)
{
//add Data
request.FromDate = "01-01-2020";
request.ToDate = "01-01-2022";
var result = await GetListAsync <RevenueStatisticViewModel>("/api/Orders/getrevenue?fromDate="
+ $"{request.FromDate}&toDate={request.ToDate}");
return(result);
}
public Task <StatisticsResponse> PostStatisticsAsync(StatisticsRequest stats, DateTime startDate, DateTime endDate, CancellationToken ct)
{
this.SetHeaders();
this.ValidateDates(ref startDate, ref endDate);
var dic = new Dictionary <string, object>();
dic.Add("startDate", this.FormatDate(startDate));
dic.Add("endDate", this.FormatDate(endDate));
StringContent content = new StringContent(JsonConvert.SerializeObject(stats));
return(this.PostAsync <StatisticsResponse>("/v2/users/self/calibrations" + dic.ToQueryString(), ct, content));
}
public override Task <StatisticsReply> GetStatistics(StatisticsRequest request, ServerCallContext context)
{
var result = _mediator.Send(new StatisticsQuery()).Result;
return(Task.FromResult(new StatisticsReply
{
Courses = result.Courses.ToString(),
Departments = result.Departments.ToString(),
Instructors = result.Instructors.ToString(),
Students = result.Students.ToString()
}));
}
public string FormHistResponse(StatisticsRequest request)
{
var response = new StatisticsResponse
{
Labels = GetLabels(request.Year, request.StartMonth, request.EndMonth),
VacationAbsenceData = GetTotalAbsenceValues(request, Reason.V),
SickAbsenceData = GetTotalAbsenceValues(request, Reason.S),
PersonalAbsenceData = GetTotalAbsenceValues(request, Reason.P)
};
return(JsonConvert.SerializeObject(response));
}
public Task <StatisticsResponse> Statistics(StatisticsRequest request)
{
StatisticsResponse response = new StatisticsResponse();
string alphaPart = Regex.Match(request.Parameters.TextToAnalyze, @"[a-zA-Z].*").Value;
response.Result.TextStatistics.HyphensQuantity = alphaPart.Length;
response.Result.TextStatistics.WordQuantity = request.Parameters.TextToAnalyze.Length;
response.Result.TextStatistics.SpacesQuantity = request.Parameters.TextToAnalyze.Split(" ").Length;
return(Task.FromResult(response));
}
public Task <StatisticsResponse> PostStatisticsAsync(StatisticsRequest stats, DateTime endDate, int hours, CancellationToken ct)
{
// Ensure that hours is negative
if (hours > 0)
{
hours = -hours;
}
else if (hours == 0)
{
hours = -3;
}
return(this.PostStatisticsAsync(stats, endDate.AddHours(hours), endDate, ct));
}
private IEnumerable <int> GetTotalAbsenceValues(StatisticsRequest request, Reason reason)
{
var employees = request.ProjectId == null
? employeeService.GetAllViewModels()
: projectService.GetSingle((int)request.ProjectId).CurrentEmployees;
var totalList = new List <int>();
for (var currentMonth = request.StartMonth; currentMonth < request.EndMonth + 1; currentMonth++)
{
totalList.Add(GetAbsenceValuesInSingleMonth(employees, reason, currentMonth, request.Year,
request.ProjectId));
}
return(totalList);
}
public void TestMethod3()
{
//Arrange
StatisticsRequest request = new StatisticsRequest();
request.Parameters = new StatisticsParameter();
request.Parameters.TextToAnalyze = "ESTO ES UNA PRUEBA";
int resultToCompare = 18;
//Act
var result = _textProcessApplicationService.Statistics(request).Result;
//Assert
Assert.AreEqual(result.Result.TextStatistics.WordQuantity, resultToCompare);
}
public async Task <Response> GetStatistics(string urlBase,
string servicePrefix,
string controller,
string tokenType,
string accessToken,
StatisticsRequest request)
{
try
{
string requestString = JsonConvert.SerializeObject(request);
StringContent content = new StringContent(requestString, Encoding.UTF8, "application/json");
HttpClient client = new HttpClient
{
BaseAddress = new Uri(urlBase)
};
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(tokenType, accessToken);
string url = $"{servicePrefix}{controller}";
HttpResponseMessage response = await client.PostAsync(url, content);
string result = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
return(new Response
{
IsSuccess = false,
Message = result,
});
}
ToShowChart statisticsResponse = JsonConvert.DeserializeObject <ToShowChart>(result);
return(new Response
{
IsSuccess = true,
Result = statisticsResponse
});
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = ex.Message
});
}
}
private StatisticRecord[] getAllRecords(StatisticsRequest request)
{
List <StatisticRecord> records = new List <StatisticRecord>();
using (var db = DbConnectionFactory.OpenDbConnection())
{
List <SMS> messages = db.Select <SMS>().Where(x => x.EntryTime >= request.DateFrom &&
x.EntryTime <= request.DateTo).ToList();
foreach (SMS m in messages)
{
records.Add(getRecord(m, db, messages));
}
}
return(records.ToArray());
}
static void Main(string[] args)
{
// Find your Account Sid and Auth Token at twilio.com/user/account
string AccountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
string AuthToken = "your_auth_token";
string WorkspaceSid = "WSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
string TaskQueueSid = "WQXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
var client = new TaskRouterClient(AccountSid, AuthToken);
StatisticsRequest request = new StatisticsRequest();
request.Minutes = 500;
request.EndDate = DateTime.Now;
TaskQueueStatistics stats = client.GetTaskQueueStatistics(WorkspaceSid, TaskQueueSid, request);
Console.WriteLine(stats.Cumulative.ReservationsAccepted);
}
private StatisticRecord[] getThisMccRecord(StatisticsRequest request)
{
List <StatisticRecord> records = new List <StatisticRecord>();
using (var db = DbConnectionFactory.OpenDbConnection())
{
Country c = db.Select <Country>().Where(x => x.MCC == Convert.ToInt16(request.MccList)).First();
List <SMS> messages = db.Select <SMS>().Where(x => x.EntryTime >= request.DateFrom &&
x.EntryTime <= request.DateTo && x.CountryId == c.Id).ToList();
foreach (SMS m in messages)
{
records.Add(getRecord(m, db, messages));
}
}
return(records.ToArray());
}
private StatisticRecord[] getTheseMccRecords(StatisticsRequest request, List <int> lsMcc)
{
List <int> countryIDs = getCountryIDs(lsMcc);
List <StatisticRecord> records = new List <StatisticRecord>();
using (var db = DbConnectionFactory.OpenDbConnection())
{
List <SMS> messages = db.Select <SMS>().Where(x => x.EntryTime >= request.DateFrom &&
x.EntryTime <= request.DateTo && countryIDs.Contains(x.CountryId)).ToList();
foreach (SMS m in messages)
{
records.Add(getRecord(m, db, messages));
}
}
return(records.ToArray());
}
public async Task <IActionResult> GetMyStatistics([FromBody] StatisticsRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
UserEntity user = _userHelper.GetUserByCodeAsync(request.UserCode);
List <ContactStatistics> statistics = await _dataContext.ContactStatistics
.FromSql($"SELECT DAY(c.StartDate) AS Day, CONVERT(FLOAT,ROUND(((COUNT(c.CustomerId)*1.0/tab.Total_Contacto)*100),0)) AS PercentContact FROM Calls AS c INNER JOIN Codifications AS cod ON cod.Id = c.CodificationId INNER JOIN (SELECT DAY(c.StartDate) AS Dia, COUNT(c.CustomerId) AS Total_Contacto FROM Calls AS c WHERE c.UserId = {user.Id} AND MONTH(c.StartDate) = {request.Month} GROUP BY DAY(c.StartDate)) AS tab ON tab.Dia = DAY(c.StartDate) WHERE cod.ContactType = 0 AND c.UserId = {user.Id} AND MONTH(c.StartDate) = {request.Month} GROUP BY DAY(c.StartDate),tab.Total_Contacto ORDER BY DAY(c.StartDate) ASC").ToListAsync();
List <EffectivityStatistics> statistics2 = await _dataContext.EffectivityStatistics
.FromSql($"SELECT DAY(c.StartDate) AS Day, CONVERT(FLOAT,ROUND(((COUNT(c.CustomerId)*1.0/tab.Total_Contacto)*100),0)) AS PercentEffectivity FROM Calls AS c INNER JOIN Codifications AS cod ON cod.Id = c.CodificationId INNER JOIN (SELECT DAY(c.StartDate) AS Dia, COUNT(c.CustomerId) AS Total_Contacto FROM Calls AS c WHERE c.UserId = {user.Id} AND MONTH(c.StartDate) = {request.Month} GROUP BY DAY(c.StartDate)) AS tab ON tab.Dia = DAY(c.StartDate) WHERE cod.EffectivityType = 0 AND c.UserId = {user.Id} AND MONTH(c.StartDate) = {request.Month} GROUP BY DAY(c.StartDate),tab.Total_Contacto ORDER BY DAY(c.StartDate) ASC").ToListAsync();
ToShowChart response = new ToShowChart
{
ContactStatistics = statistics,
EffectivityStatistics = statistics2
};
return(Ok(response));
}
public async Task <IEnumerable <RevenueStatistic> > GetRevenueStatistic(StatisticsRequest request)
{
var parameters = new SqlParameter[] {
new SqlParameter("@fromDate", request.FromDate),
new SqlParameter("@toDate", request.ToDate)
};
//Store
string StoredProc = "exec GetRevenueStatistic @fromDate,@toDate";
var result = await _context.RevenueStatistics.FromSql(StoredProc, parameters).ToListAsync();
List <RevenueStatistic> lst = result.Select(x => new RevenueStatistic
{
Benefit = x.Benefit,
Revenues = x.Revenues,
Date = x.Date
}).ToList();
return(result);
}
private StatisticRecord[] GetStatisticRecords(StatisticsRequest request)
{
List <Items> ls = new List <Items>();
if (String.IsNullOrEmpty(request.MccList))
//get all messages
{
return(getAllRecords(request));
}
else
{
if (!request.MccList.Contains(','))
{
return(getThisMccRecord(request));
}
else
{
List <int> lsMcc = request.MccList.Split(',').Select(int.Parse).ToList();
return(getTheseMccRecords(request, lsMcc));
}
}
}
private async Task <(Stream Chart, ResultMessage Message)> GetResult(StatisticsRequest request, DetailedPeriod period, DateTime startTimeRangeTimeOfDay)
{
var timeRange = TimeRange.ToNow(startTimeRangeTimeOfDay.Add(-request.TimeBehind));
var statistics = period switch
{
public Task <(Stream Chart, ResultMessage Message)> PerHour(StatisticsRequest request)
{
return(this.GetResult(request, DetailedPeriod.Hour, DateTime.Now));
}
