public async Task Get()
{
//Arrange
_daySummaryServiceMock.Setup(x => x.Get(It.IsAny <service.DaySummaryGetRequest>())).ReturnsAsync(new service.DaySummary
{
Date = "2013-06-20",
Opening = 262.99999,
Closing = 269.0,
Lowest = 260.00002,
Highest = 269.0,
Volume = 7253.1336356785,
Quantity = 27.11390588,
Amount = 28,
Avg_price = 267.5060416518087
});
var expecteResult = new DaySummary
{
Date = new DateTime(2013, 06, 20),
Opening = 262.99999,
Closing = 269.0,
Lowest = 260.00002,
Highest = 269.0,
Volume = 7253.1336356785,
Quantity = 27.11390588,
Amount = 28,
AvgPrice = 267.5060416518087
};
var request = new DaySummaryGetRequest()
{
Coins = Domain.CoinsEnum.BTC,
Date = DateTime.Now
};
//Act
var result = await _daySummaryController.Get(request);
var okObjectResult = result as OkObjectResult;
var resultObj = okObjectResult.Value as DaySummary;
//Assert
Assert.Equal(200, okObjectResult.StatusCode);
Assert.NotNull(resultObj);
Assert.Equal(expecteResult.Date, resultObj.Date);
Assert.Equal(expecteResult.Opening, resultObj.Opening);
Assert.Equal(expecteResult.Closing, resultObj.Closing);
Assert.Equal(expecteResult.Lowest, resultObj.Lowest);
Assert.Equal(expecteResult.Highest, resultObj.Highest);
Assert.Equal(expecteResult.Volume, resultObj.Volume);
Assert.Equal(expecteResult.Quantity, resultObj.Quantity);
Assert.Equal(expecteResult.Amount, resultObj.Amount);
Assert.Equal(expecteResult.AvgPrice, resultObj.AvgPrice);
}
public async Task Get_StatusOk()
{
//Arrange
var expectedResult = new DaySummary
{
Date = new DateTime(2013, 06, 20),
Opening = 262.99999,
Closing = 269.0,
Lowest = 260.00002,
Highest = 269.0,
Volume = 7253.1336356785,
Quantity = 27.11390588,
Amount = 28,
AvgPrice = 267.5060416518087
};
var httpResponseMessage = new HttpResponseMessageBuilder().StatusOk_DaySummary().Build();
_httpRequestHandlerMock.Setup(p => p.Get(It.IsAny <string>())).ReturnsAsync(httpResponseMessage);
var request = new DaySummaryGetRequest()
{
Coins = Domain.CoinsEnum.BTC,
Date = DateTime.Now
};
//Act
var result = await _daySummaryController.Get(request);
var okObjectResult = result as OkObjectResult;
var resultObj = okObjectResult.Value as DaySummary;
//Assert
Assert.Equal(200, okObjectResult.StatusCode);
Assert.NotNull(resultObj);
Assert.Equal(expectedResult.Date, resultObj.Date);
Assert.Equal(expectedResult.Opening, resultObj.Opening);
Assert.Equal(expectedResult.Closing, resultObj.Closing);
Assert.Equal(expectedResult.Lowest, resultObj.Lowest);
Assert.Equal(expectedResult.Highest, resultObj.Highest);
Assert.Equal(expectedResult.Volume, resultObj.Volume);
Assert.Equal(expectedResult.Quantity, resultObj.Quantity);
Assert.Equal(expectedResult.Amount, resultObj.Amount);
Assert.Equal(expectedResult.AvgPrice, resultObj.AvgPrice);
}
private TimeSpan?CalculateWorkedTime(DaySummary daySummary)
{
daySummary.TotalTimeWorked = daySummary.WorkLeavingTime - daySummary.WorkArrivalTime - daySummary.HolidayTime
- daySummary.Doctor - daySummary.Private - daySummary.Other;
//ak pocet odrobenych hodin je viac ako 4 ma zamestnanec pravo na obed
if (daySummary.TotalTimeWorked > TimeSpan.FromHours(MINHOURSFORLUNCHBREAKTIME))
{
daySummary.TotalTimeWorked -= daySummary.LunchBreak > TimeSpan.FromMinutes(LUNCHBREAKTIME)
? daySummary.LunchBreak
: TimeSpan.FromMinutes(LUNCHBREAKTIME);
}
else
{
daySummary.TotalTimeWorked -= daySummary.LunchBreak;
}
return(daySummary.TotalTimeWorked);
}
public ActionResult GetTodaySummary()
{
var _objects = _unitOfWorkAsync.RepositoryAsync <WorkIssue>()
.Query().Select()
.Where(t => t.IsValid())
.Where(t => t.End.HasValue && t.End.Value.IsToday())
.AsEnumerable();
if (User.Identity.IsAuthenticated)
{
_objects = _objects.Where(t => t.IsOf(User.Identity.Name));
DaySummary summary = new DaySummary(_objects);
if (Request.IsAjaxRequest())
{
return(PartialView("_TodaySummary", summary));
}
}
return(View());
}
public HttpResponseMessage Get(string apiToken, string regularWorkingHoursString, string startDateString, string endDateString)
{
double regularWorkingHours;
DateTime startDate;
DateTime endDate;
try
{
regularWorkingHours = double.Parse(regularWorkingHoursString);
startDate = DateTime.ParseExact(startDateString, WebApiConfig.DateFormat, CultureInfo.InvariantCulture);
endDate = DateTime.ParseExact(endDateString, WebApiConfig.DateFormat, CultureInfo.InvariantCulture);
}
catch (Exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed,
"At least one of the passed parameters was not in the correct format!"));
}
Dictionary <DateTime, List <TimeEntry> > workTimeByDays;
try
{
var timeService = new TimeEntryService(apiToken);
workTimeByDays = timeService.List(new TimeEntryParams {
StartDate = startDate, EndDate = endDate.AddDays(1)
})
.GroupBy(h => DateTime.Parse(h.Start).Date)
.OrderBy(d => d.Key)
.ToDictionary(timeEntriesByDay => timeEntriesByDay.Key,
timeEntriesByDay => timeEntriesByDay.ToList());
}
catch (WebException webEx)
{
var httpWebResponse = ((HttpWebResponse)webEx.Response);
return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed,
$"The toggl server (toggl.com) threw an exception ({(int) httpWebResponse.StatusCode}:" +
$" {httpWebResponse.StatusDescription}) - either your API token is wrong or the servers are down."));
}
double regularWorkDayInSeconds = (regularWorkingHours / 5.0 * 3600);
var togglTimeSummary = new TogglTimeSummary();
foreach (var daysByWeek in workTimeByDays.GroupBy(timeEntriesByDay => GetWeekGroupKey(timeEntriesByDay.Key),
timeEntriesByDay => new { Day = timeEntriesByDay.Key, TimeEntries = timeEntriesByDay.Value }))
{
var weekSummary = new WeekSummary(daysByWeek.Key, regularWorkDayInSeconds);
foreach (var timeEntriesByDay in daysByWeek)
{
var daySummary = new DaySummary(timeEntriesByDay.Day, weekSummary.IsRegularWorkDayLimitReached ? 0 : regularWorkDayInSeconds);
foreach (long timeEntry in timeEntriesByDay.TimeEntries
.Where(t => t.Duration.HasValue && t.Duration > 0)
.Select(t => (long)t.Duration))
{
daySummary.AddTimeEntry(timeEntry);
}
weekSummary.AddDay(daySummary);
}
togglTimeSummary.AddWeek(weekSummary);
}
return(Request.CreateResponse(HttpStatusCode.OK, togglTimeSummary));
}
public static async Task Run(
[QueueTrigger("submissions", Connection = "AzureWebJobsStorage")] string username,
[Table("users", "{queueTrigger}", "{queueTrigger}", Connection = "AzureWebJobsStorage")] UserEntity user,
ILogger log)
{
log.LogInformation($"C# Queue trigger function processed: {username}");
// Check if already run in last x amount of time
if (user?.Timestamp > DateTime.Now.Subtract(Constants.UserExpiry))
{
log.LogInformation($"Username '{username}' was updated in last hour. Exit early.");
return;
}
// Check if we've hit rate limit
string connectionString = Environment.GetEnvironmentVariable("AzureWebJobsStorage", EnvironmentVariableTarget.Process);
var storageAccount = CloudStorageAccount.Parse(connectionString);
var tableClient = storageAccount.CreateCloudTableClient();
var table = tableClient.GetTableReference("rateLimit");
table.CreateIfNotExists();
RateLimitReset rateReset = null;
var utc = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
var query = table.Execute(TableOperation.Retrieve <RateLimitReset>("pk", "rk"));
if (query.Result is RateLimitReset tmp)
{
rateReset = tmp;
if (utc.AddSeconds(rateReset.ResetTime) > DateTime.UtcNow)
{
log.LogInformation($"Have not reached rate limit timestamp of {utc.AddSeconds(rateReset.ResetTime)}. Current: {DateTime.UtcNow}.");
throw new HttpResponseException((HttpStatusCode)429);
}
}
// Lookup data from Twitter
List <Status> result, likes;
TwitterUser userDetails;
try
{
result = await TwitterClient.FetchUserActivityInPastYear(username, log);
likes = await TwitterClient.FetchUserLikesInPastYear(username, log);
userDetails = await TwitterClient.FetchUserDetails(username, log);
}
catch (HttpResponseException e)
{
if (e.Response.StatusCode == (HttpStatusCode)429)
{
if (rateReset == null)
{
rateReset = new RateLimitReset();
rateReset.PartitionKey = "pk";
rateReset.RowKey = "rk";
}
if (e.Response.Headers.TryGetValues("x-rate-limit-reset", out IEnumerable <string> resetTime))
{
var newTime = Double.Parse(resetTime.First());
if (newTime > rateReset.ResetTime)
{
rateReset.ResetTime = newTime;
table.Execute(TableOperation.InsertOrReplace(rateReset));
log.LogInformation("Updated rateLimit to " + newTime);
}
}
}
throw;
}
var hashset = new Dictionary <string, DaySummary>();
foreach (Status status in result)
{
string date = status.CreatedAt.ToString("yyyy-MM-dd");
if (!hashset.TryGetValue(date, out DaySummary summary))
{
summary = new DaySummary {
Date = date
};
}
summary.StatusCount++;
hashset[date] = summary;
}
foreach (Status status in likes)
{
string date = status.CreatedAt.ToString("yyyy-MM-dd");
if (!hashset.TryGetValue(date, out DaySummary summary))
{
summary = new DaySummary {
Date = date
};
}
summary.LikeCount++;
hashset[date] = summary;
}
// Write results to storage. Bindings don't support update, apparently :/
table = tableClient.GetTableReference("users");
table.CreateIfNotExists();
if (user == null)
{
user = new UserEntity();
user.PartitionKey = username;
user.RowKey = username;
}
user.Timestamp = DateTime.Now;
user.Entity = JsonConvert.SerializeObject(new UserSummary
{
Summary = hashset.Values.ToList(),
UserDetails = userDetails
});
table.Execute(TableOperation.InsertOrReplace(user));
}
private List <DaySummary> CreateDaySummary(string monthAndYear, int idEmployee)
{
string month = monthAndYear.Split(' ')[0];
int year = Convert.ToInt32(monthAndYear.Split(' ')[1]);
int numberOfMonth = DateTime.ParseExact(month, "MMMM", CultureInfo.InvariantCulture).Month;
DateTime date = new DateTime(year, numberOfMonth, 1);
List <DailyRecord> dailyRecords = _daySummaryRepository.GetTimeSpendOnDailyResults(date, idEmployee);
List <DaySummary> monthRecords = new List <DaySummary>();
while (date.Month == numberOfMonth)
{
DaySummary daySummary = new DaySummary
{
Date = date.ToString("M/d/yyyy")
};
foreach (var item in dailyRecords)
{
if (item.Start.ToString().Contains(daySummary.Date))
{
switch (item.IdWorktype)
{
case (int)EnumWorkType.Work:
if (daySummary.WorkArrivalTime == null || daySummary.WorkArrivalTime > item.Start)
{
daySummary.WorkArrivalTime = item.Start;
}
daySummary.WorkLeavingTime = item.Finish;
break;
case (int)EnumWorkType.Lunch:
daySummary.LunchBreak += (TimeSpan)(item.Finish - item.Start);
break;
case (int)EnumWorkType.Holiday:
daySummary.HolidayTime += (TimeSpan)(item.Finish - item.Start);
break;
case (int)EnumWorkType.HomeOffice:
daySummary.HomeOffice += (TimeSpan)(item.Finish - item.Start);
break;
case (int)EnumWorkType.BusinessTrip:
daySummary.BusinessTrip += (TimeSpan)(item.Finish - item.Start);
break;
case (int)EnumWorkType.Doctor:
daySummary.Doctor += (TimeSpan)(item.Finish - item.Start);
break;
case (int)EnumWorkType.Private:
daySummary.Private += (TimeSpan)(item.Finish - item.Start);
break;
case (int)EnumWorkType.Other:
daySummary.Other += (TimeSpan)(item.Finish - item.Start);
break;
}
}
}
daySummary.TotalTimeWorked = CalculateWorkedTime(daySummary);
date = date.AddDays(1);
monthRecords.Add(daySummary);
}
return(monthRecords);
}
