public async Task <IActionResult> SignIn([FromBody] ProfileSaveRequestModel model)
{
try
{
var user = await _context.Users.SingleOrDefaultAsync(a => a.UserId == UserId);
if (user == null)
{
user = new AppUser {
UserId = this.UserId
};
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Email = model.Email;
user.Gender = model.Gender;
user.City = model.City;
user.Region = model.Region;
user.Country = model.Country;
user.PhotoUrl = model.PhotoUrl;
user.DefaultActivityTypeId = (byte)Enum.Parse <ActivityTypeEnum>(model.DefaultActivityType ?? "Ski", true);
_context.Users.Add(user);
await _context.SaveChangesAsync();
}
var response = Responses.Profile(user, Enumerable.Empty <Activity>());
return(Ok(response));
}
catch (Exception e)
{
Console.WriteLine("Error signing in", e);
_logger.LogError(e, "Error siging in");
return(ErrorResponse.AsStatusCodeResult(HttpStatusCode.InternalServerError, "Error siging in"));
}
}
public async Task <IActionResult> GetActivity(Guid activityId)
{
try
{
var activity = await _context
.Activities
.Include(a => a.Segments)
.Include(a => a.Locations)
.Where(a => a.ActivityId == activityId)
.FirstOrDefaultAsync();
if (activity == null)
{
return(NotFound());
}
var user = await _context.Users.FindAsync(activity.UserId);
return(Ok(Responses.Activity(activity, user)));
}
catch (Exception e)
{
Console.WriteLine("Error retrieving activity", e);
_logger.LogError(e, "Error retrieving activity");
return(ErrorResponse.AsStatusCodeResult(HttpStatusCode.InternalServerError, "Error retrieving activity"));
}
}
public async Task <IActionResult> GetProfile(string userId)
{
//todo: privacy?
try
{
var user = await _context.Users.SingleAsync(a => a.UserId == userId);
var activities = await _context.Activities.Where(a => a.UserId == userId).Include(a => a.Segments).ToListAsync();
var response = Responses.Profile(user, activities);
return(Ok(response));
}
catch (Exception e)
{
Console.WriteLine("Error fetching profile", e);
_logger.LogError(e, "Error fetching profile");
return(ErrorResponse.AsStatusCodeResult(HttpStatusCode.InternalServerError, "Error fetching profile"));
}
}
public async Task <IActionResult> GetNearby([FromQuery] double latitude, [FromQuery] double longitude)
{
try
{
var rect = Geometry.GetRect(latitude, longitude, 10000);
var lifts = await _context
.Lifts
.Where(l => !l.IsHidden && l.Point1Latitude >= rect.StartLatitude && l.Point1Latitude <= rect.EndLatitude && l.Point1Longitude >= rect.StartLongitude && l.Point1Longitude <= rect.EndLongitude)
.Select(l => Responses.Lift(l))
.ToListAsync();
return(Ok(lifts));
}
catch (Exception e)
{
Console.WriteLine("Error retrieving lifts", e);
_logger.LogError(e, "Error retrieving lifts");
return(ErrorResponse.AsStatusCodeResult(HttpStatusCode.InternalServerError, "Error retrieving lifts"));
}
}
public async Task <IActionResult> DeleteActivity(Guid activityId)
{
try
{
var activity = await _context.Activities
.Include(a => a.Segments)
.Include(a => a.Locations)
.Include(a => a.Batches)
.SingleAsync(a => a.ActivityId == activityId);
_context.Activities.Remove(activity);
await _context.SaveChangesAsync();
return(Ok(new SuccessResponse()));
}
catch (Exception e)
{
Console.WriteLine("Error deleting activity", e);
_logger.LogError(e, "Error deleting activity");
return(ErrorResponse.AsStatusCodeResult(HttpStatusCode.InternalServerError, "Error deleting activity"));
}
}
public async Task <IActionResult> GetFeed()
{
try
{
var activities = await _context.Activities
.Where(a => a.UserId == UserId)
.OrderByDescending(a => a.Timestamp)
.ToListAsync();
var userIds = activities.Select(a => a.UserId).Distinct();
var users = await _context.Users.Where(u => userIds.Contains(u.UserId)).ToDictionaryAsync(u => u.UserId);
var response = activities.Select(a => Responses.Activity(a, users[a.UserId]));
return(Ok(response));
}
catch (Exception e)
{
Console.WriteLine("Error retrieving feed", e);
_logger.LogError(e, "Error retrieving feed");
return(ErrorResponse.AsStatusCodeResult(HttpStatusCode.InternalServerError, "Error retrieving feed"));
}
}
public async Task <IActionResult> SaveActivity(Guid activityId, [FromBody] ActivitySaveRequestModel model)
{
try
{
var activity = await _context.Activities
.Include(a => a.Locations)
.SingleAsync(a => a.ActivityId == activityId);
activity.Name = model.Name;
activity.TypeId = (byte)Enum.Parse <ActivityTypeEnum>(model.ActivityType, true);
activity.StartDateTime = model.StartDateTime;
activity.EndDateTime = model.EndDateTime;
activity.TotalTimeSeconds = Convert.ToInt32(model.TotalTimeSeconds);
activity.TotalDistanceMeters = Convert.ToSingle(model.TotalDistanceMeters);
activity.SkiTimeSeconds = Convert.ToInt32(model.SkiTimeSeconds);
activity.SkiDistanceMeters = Convert.ToSingle(model.SkiDistanceMeters);
activity.SkiVerticalMeters = Convert.ToInt32(model.SkiVerticalMeters);
activity.AscentTimeSeconds = Convert.ToInt32(model.AscentTimeSeconds);
activity.AscentDistanceMeters = Convert.ToSingle(model.AscentDistanceMeters);
activity.AscentVerticalMeters = Convert.ToInt32(model.AscentVerticalMeters);
activity.MaxSpeedMps = Convert.ToSingle(model.MaxSpeedMps);
activity.AverageSpeedMps = Convert.ToSingle(model.AverageSpeedMps);
activity.MaxAltitudeMeters = Convert.ToInt32(model.MaxAltitudeMeters);
activity.MaxGradeDegrees = Convert.ToSingle(model.MaxGradeDegrees);
activity.RunsCount = model.RunsCount ?? 0;
activity.UserId = this.UserId;
activity.SourceTypeId = (byte)Enum.Parse <ActivitySourceTypeEnum>(model.Source, true);
activity.Timestamp = model.Timestamp;
activity.Segments = model.Segments?
.Select(s => new ActivitySegment
{
Name = s.Name,
StartTimestamp = s.StartTimestamp ?? 0,
EndTimestamp = s.EndTimestamp ?? 0,
TotalTimeSeconds = Convert.ToInt32(s.TotalTimeSeconds),
MovingTimeSeconds = Convert.ToInt32(s.MovingTimeSeconds),
VerticalMeters = Convert.ToInt32(s.VerticalMeters),
StartAltitude = Convert.ToSingle(s.StartAltitude),
EndAltitude = Convert.ToSingle(s.EndAltitude),
DistanceMeters = Convert.ToSingle(s.DistanceMeters),
MaxSpeedMps = Convert.ToSingle(s.MaxSpeedMps),
AverageSpeedMps = Convert.ToSingle(s.AverageSpeedMps),
MaxGradeDegrees = Convert.ToSingle(s.MaxGradeDegrees),
IsRun = s.IsRun ?? false
})
.ToList();
var locations = TrackSimplifier.Simplify(activity.Locations.OrderBy(l => l.Timestamp).ToList(), 0.00005);
var polyline = WebUtility.UrlEncode(Geometry.Encode(locations));
activity.Polyline = polyline;
await _context.SaveChangesAsync();
return(Ok(new SuccessResponse()));
}
catch (Exception e)
{
Console.WriteLine("Error saving activity", e);
_logger.LogError(e, "Error saving activity");
return(ErrorResponse.AsStatusCodeResult(HttpStatusCode.InternalServerError, "Error saving activity"));
}
}
public async Task <IActionResult> SaveActivityData(Guid activityId, [FromBody] ActivitySaveDataRequestModel model)
{
try
{
var sourceTypeID = Enum.Parse <ActivitySourceTypeEnum>(model.Source, true);
//get or create activity
var activity = await _context.Activities.SingleOrDefaultAsync(a => a.ActivityId == activityId);
if (activity == null)
{
activity = new WaitTime.Entities.Activity
{
ActivityId = activityId,
UserId = this.UserId,
SourceTypeId = (byte)sourceTypeID,
};
_context.Activities.Add(activity);
}
var batch = await _context.ActivitySyncBatches.SingleOrDefaultAsync(b => b.ActivitySyncBatchId == model.ActivitySyncBatchId);
if (batch != null)
{
//batch already saved
return(Ok(new SuccessResponse()));
}
var array = model.LocationsArray;
if (array.GetLength(1) != 10)
{
var error = $"Activity {activityId}, Batch {model.BatchNbr} for User {UserId}: Locations array has the wrong number of columns. Expected 10 columns, found {array.GetLength(1)}.";
Console.WriteLine(error);
throw new ArgumentOutOfRangeException(nameof(model), error);
}
foreach (var location in Enumerable
.Range(0, array.GetLength(0))
.Select(row => new ActivityLocation
{
Latitude = (double)(array[row, 0] ?? 0),
Longitude = (double)(array[row, 1] ?? 0),
Accuracy = (float)(array[row, 2] ?? 0),
Altitude = (float)(array[row, 3] ?? 0),
AltitudeAccuracy = (float)(array[row, 4]),
Bearing = (float)(array[row, 5] ?? 0),
BearingAccuracy = (float)(array[row, 6]),
Speed = (float)(array[row, 7] ?? 0),
SpeedAccuracy = (float)(array[row, 8] ?? 0),
Timestamp = (double)(array[row, 9] ?? 0),
}))
{
activity.Locations.Add(location);
}
batch = new ActivitySyncBatch
{
ActivitySyncBatchId = model.ActivitySyncBatchId,
BatchNbr = model.BatchNbr,
};
activity.Batches.Add(batch);
await _context.SaveChangesAsync();
return(Ok(new SuccessResponse()));
}
catch (Exception e)
{
Console.WriteLine("Error processing batch", e);
_logger.LogError(e, "Error processing batch");
return(ErrorResponse.AsStatusCodeResult(HttpStatusCode.InternalServerError, "Error processing batch"));
}
}
