public static async Task <bool> DeleteTrackFollow(string userId, string trackId, bool ownerOverride = false)
{
try
{
TrackAuth track = await TrackRepository.GetTrack(trackId);
if (track.PartitionKey == userId && ownerOverride == false)
{
return(false);
}
UserFollowTableEntity userFollow = await TableStorageRepository.GetUserFollow(userId, trackId);
TrackFollowTableEntity trackFollow = await TableStorageRepository.GetTrackFollow(trackId, userId);
if (userFollow != null)
{
await TableStorageRepository.DeleteUserFollow(userFollow);
}
if (trackFollow != null)
{
await TableStorageRepository.DeleteTrackFollow(trackFollow);
}
return(true);
}
catch
{
return(false);
}
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "track/{trackId}/follow")] HttpRequest req, string trackId, TraceWriter log)
{
try
{
// check postId and trackId provided
if (!Tools.IsValidGuid(trackId))
{
return(new UnauthorizedResult());
}
string authToken = req.Headers["Authorization"];
if (authToken == null)
{
return(new UnauthorizedResult());
}
// validate authKey
AuthClaim authClaim = AuthRepository.ValidateAuthClaim(authToken);
if (authClaim == null)
{
return(new UnauthorizedResult());
}
// get the track
TrackAuth track = await TrackRepository.GetTrack(trackId);
if (track == null || (track.is_private && track.PartitionKey != authClaim.user_id))
{
return(new UnauthorizedResult());
}
// trackFollow body
string requestBody = new StreamReader(req.Body).ReadToEnd();
TrackFollowDTO dto = JsonConvert.DeserializeObject <TrackFollowDTO>(requestBody);
// insert or update the follow
TrackFollow trackFollow = new TrackFollow();
trackFollow.feed_follow_type = dto.feed?.ToLower() == "all" || dto.feed?.ToLower() == "none" ? dto.feed.ToLower() : null;
trackFollow.notifications_follow_type = dto.notifications?.ToLower() == "all" || dto.notifications?.ToLower() == "none" ? dto.notifications.ToLower() : null;
trackFollow.criteria = dto.criteria;
trackFollow.user_id = authClaim.user_id;
trackFollow.track_id = track.RowKey;
FollowRepository.InsertOrReplaceTrackFollow(trackFollow);
return(new OkResult());
}
catch (Exception e)
{
log.Error(e.Message);
return(new UnauthorizedResult());
}
}
private static async void InsertOrReplaceUserFollow(string userId, string trackId)
{
TrackAuth track = await TrackRepository.GetTrack(trackId);
TableStorageRepository.InsertOrReplaceUserFollow(new UserFollowTableEntity(userId, trackId)
{
description = track.description,
has_image = track.has_image,
is_private = track.is_private,
name = track.name
});
}
public static async Task <TrackAuth> CreateTrack(TrackAuth track)
{
if (track.PartitionKey == null || track.name == null)
{
return(null);
}
var extendedUser = await ExtendedUserRepository.GetExtendedUser(track.PartitionKey);
// check private maxed out
if (track.is_private)
{
if (extendedUser.Private_Tracks >= extendedUser.Private_Tracks_Max)
{
return(null);
}
}
// check public maxed out
if (!track.is_private)
{
if (extendedUser.Public_Tracks >= extendedUser.Public_Tracks_Max)
{
return(null);
}
}
track.RowKey = track.RowKey ?? Guid.NewGuid().ToString();
track.subscribers = 0;
track.rate_limit = extendedUser.Rate_Per_Track;
track.track_key = AuthRepository.GenerateRandomString(64);
track.track_secret = AuthRepository.GenerateSHA256(track.RowKey + track.track_key);
// insert into table storage
var newTrack = await TableStorageRepository.InsertTrackAuth(track);
if (newTrack == null)
{
return(null);
}
// insert into Cosmos
await(dynamic) CosmosRepository <Track> .CreateItemAsync(new Track(track));
// increment user's track count
ExtendedUserRepository.IncrementTrackCount(track.PartitionKey, track.is_private);
return(newTrack);
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "track/{trackId}/follow")] HttpRequest req, string trackId, TraceWriter log)
{
try
{
// check postId and trackId provided
if (!Tools.IsValidGuid(trackId))
{
return(new UnauthorizedResult());
}
string authToken = req.Headers["Authorization"];
if (authToken == null)
{
return(new UnauthorizedResult());
}
// validate authKey
AuthClaim authClaim = AuthRepository.ValidateAuthClaim(authToken);
if (authClaim == null)
{
return(new UnauthorizedResult());
}
// get the track
TrackAuth track = await TrackRepository.GetTrack(trackId);
if (track == null || track.is_private)
{
return(new UnauthorizedResult());
}
// insert or update the follow
var result = await FollowRepository.DeleteTrackFollow(authClaim.user_id, track.RowKey);
if (!result)
{
return(new BadRequestResult());
}
return(new OkResult());
}
catch (Exception e)
{
log.Error(e.Message);
return(new UnauthorizedResult());
}
}
internal static async void UpdateTrack(TrackAuth track)
{
try
{
// get the table
CloudTable table = tableClient.GetTableReference(TracksTable);
await table.CreateIfNotExistsAsync();
TableOperation op = TableOperation.InsertOrReplace(track);
await table.ExecuteAsync(op);
}
catch (StorageException e)
{
throw;
}
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "track/{trackId}/post/{postId}")] HttpRequest req, string trackId, string postId, TraceWriter log)
{
try
{
KeySecret keySecret = AuthRepository.DecodeKeyAndSecret(req.Headers["X-Track-Key"]);
// validate authKey
if (!AuthRepository.ValidateSHA256(trackId + keySecret.Key, keySecret.Secret))
{
return(new UnauthorizedResult());
}
// get track
TrackAuth track = await TrackRepository.GetTrack(trackId);
if (track == null || track.track_key != keySecret.Key)
{
return(new UnauthorizedResult());
}
// get post
Post post = await PostRepository.GetPost(trackId, postId);
if (post == null || track.RowKey != post.PartitionKey)
{
return(new UnauthorizedResult());
}
// delete the post
TableStorageRepository.AddMessageToQueue("process-delete-post", $"{trackId}.{postId}");
// return response
return(new OkResult());
}
catch (Exception e)
{
log.Info(e.Message);
return(new UnauthorizedResult());
}
}
/// <summary>
/// Insert track into Table Storage.
/// </summary>
/// <param name="track"></param>
/// <returns>Returns the inserted track.</returns>
internal static async Task <TrackAuth> InsertTrackAuth(TrackAuth track)
{
try
{
// reference track table
CloudTable table = tableClient.GetTableReference(TracksTable);
await table.CreateIfNotExistsAsync();
// insert the track
TableOperation op = TableOperation.Insert(track);
var result = await table.ExecuteAsync(op);
if (result == null)
{
return(null);
}
return(track);
}
catch
{
throw;
}
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
if (!ModelState.IsValid)
{
return(Page());
}
var track = new TrackAuth(user.Id, Guid.NewGuid().ToString())
{
description = Input.Description,
is_private = Input.IsPrivate,
name = Input.Name,
tags = string.IsNullOrWhiteSpace(Input.Tags) ? null : string.Join(",", Tools.ValidateTags(Input.Tags.Split(',').ToList()))
};
// generate small thumb
if (Input.UploadTrackImage != null)
{
using (MemoryStream uploadStream = new MemoryStream())
{
await Input.UploadTrackImage.CopyToAsync(uploadStream);
byte[] data = uploadStream.ToArray();
using (MemoryStream input = new MemoryStream(data))
{
using (MemoryStream output = new MemoryStream())
{
Images.CropSquare(150, input, output);
await BlobRepository.UploadFileAsync(BlobRepository.TracksContainer, output.ToArray(), track.RowKey + "/thumb");
}
}
using (MemoryStream input = new MemoryStream(data))
{
using (MemoryStream output = new MemoryStream())
{
Images.CropSquare(32, input, output);
await BlobRepository.UploadFileAsync(BlobRepository.TracksContainer, output.ToArray(), track.RowKey + "/thumb_mini");
}
}
track.has_image = true;
}
}
// create track
TrackAuth createdTrack = await TrackRepository.CreateTrack(track);
FollowRepository.InsertOrReplaceTrackFollow(new TrackFollow()
{
track_id = createdTrack.RowKey,
user_id = user.Id,
feed_follow_type = "none",
notifications_follow_type = "none"
});
_logger.LogInformation($"Track with ID '{createdTrack.RowKey}' has been created by '{user.Id}'.");
return(RedirectToPage("./Index"));
}
public static void UpdateTrack(TrackAuth track)
{
TableStorageRepository.UpdateTrack(track);
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "track/{trackId}/post")] HttpRequest req, string trackId, TraceWriter log)
{
try
{
KeySecret keySecret = AuthRepository.DecodeKeyAndSecret(req.Headers["X-Track-Key"]);
if (keySecret == null)
{
return(new UnauthorizedResult());
}
// validate authKey
if (!AuthRepository.ValidateSHA256(trackId + keySecret.Key, keySecret.Secret))
{
return(new UnauthorizedResult());
}
// get post from req body
string requestBody = new StreamReader(req.Body).ReadToEnd();
PostSubmitDTO post = JsonConvert.DeserializeObject <PostSubmitDTO>(requestBody);
// validate post
PostValidateDTO validatedPost = PostRepository.ValidatePost(post);
if (validatedPost.invalid_reason != null)
{
return(new BadRequestObjectResult(validatedPost.invalid_reason));
}
// get track
TrackAuth track = await TrackRepository.GetTrack(trackId);
if (track == null || track.track_key != keySecret.Key)
{
return(new UnauthorizedResult());
}
// check rate limit
if (track.rate_limit_exceeded)
{
return(new ForbidResult());
}
// create the post
validatedPost.post.track_id = trackId;
validatedPost.post.track_name = track.name;
Post newPost = await PostRepository.InsertPost(validatedPost.post);
// if didn't create return bad response
if (newPost == null)
{
return(new BadRequestResult());
}
// convert to post DTO
return(new OkObjectResult(new PostQueryDTO()
{
date_created = newPost.date_created,
id = newPost.RowKey,
summary = newPost.summary,
tags = newPost.tags.Split(',').ToList(),
title = newPost.title,
track_id = newPost.PartitionKey,
track_name = newPost.track_name,
type = newPost.type,
url = newPost.url
}));
}
catch (Exception e)
{
log.Info(e.Message);
return(new UnauthorizedResult());
}
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "track/{trackId}/posts")] HttpRequest req, string trackId, TraceWriter log)
{
try
{
// check valid trackId provided
if (!Tools.IsValidGuid(trackId))
{
return(new UnauthorizedResult());
}
// get the track
TrackAuth track = await TrackRepository.GetTrack(trackId);
if (track == null)
{
return(new UnauthorizedResult());
}
// private track so check keys
if (track.is_private)
{
string trackKeyHeader = req.Headers["X-Track-Key"];
string authToken = req.Headers["Authorization"];
if (authToken != null)
{
// validate authKey
AuthClaim authClaim = AuthRepository.ValidateAuthClaim(authToken);
if (authClaim == null)
{
return(new UnauthorizedResult());
}
// check track userID matches authClaim userId
if (track.PartitionKey != authClaim.user_id)
{
return(new UnauthorizedResult());
}
}
else if (trackKeyHeader != null)
{
KeySecret keySecret = AuthRepository.DecodeKeyAndSecret(trackKeyHeader);
// validate authKey
if (!AuthRepository.ValidateSHA256(trackId + keySecret.Key, keySecret.Secret))
{
return(new UnauthorizedResult());
}
// validate track key
if (track.track_key != keySecret.Key)
{
return(new UnauthorizedResult());
}
}
else
{
return(new UnauthorizedResult());
}
}
// get query object from query params
PostQuery query = Tools.GetQueryFromQueryParams(trackId, req.Query["tags"], req.Query["continuation"]);
PostReturnObject posts = query.tags.Count > 0 ? await PostRepository.QueryPosts(query) : await PostRepository.GetPosts(query);
return(new OkObjectResult(posts));
}
catch (Exception e)
{
log.Info(e.Message);
return(new BadRequestObjectResult(e.Message));
}
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "track/{trackId}")] HttpRequest req, string trackId, TraceWriter log)
{
try
{
// check postId and trackId provided
if (!Tools.IsValidGuid(trackId))
{
return(new UnauthorizedResult());
}
// get the track
TrackAuth track = await TrackRepository.GetTrack(trackId);
if (track == null)
{
return(new UnauthorizedResult());
}
// is private
if (track.is_private)
{
string trackKeyHeader = req.Headers["X-Track-Key"];
string authToken = req.Headers["Authorization"];
if (authToken != null)
{
// validate authKey
AuthClaim authClaim = AuthRepository.ValidateAuthClaim(authToken);
if (authClaim == null)
{
return(new UnauthorizedResult());
}
// check track userID matches authClaim userId
if (track.PartitionKey != authClaim.user_id)
{
return(new UnauthorizedResult());
}
}
else if (trackKeyHeader != null)
{
KeySecret keySecret = AuthRepository.DecodeKeyAndSecret(trackKeyHeader);
// validate authKey
if (!AuthRepository.ValidateSHA256(trackId + keySecret.Key, keySecret.Secret))
{
return(new UnauthorizedResult());
}
// validate track key
if (track.track_key != keySecret.Key)
{
return(new UnauthorizedResult());
}
}
else
{
return(new UnauthorizedResult());
}
}
return(new OkObjectResult(new Track(track)));
}
catch (Exception e)
{
log.Error(e.Message);
return(new UnauthorizedResult());
}
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "track/{trackId}/post/{postId}")] HttpRequest req, string trackId, string postId, TraceWriter log)
{
try
{
// check postId and trackId provided
if (!Tools.IsValidGuid(trackId))
{
return(new UnauthorizedResult());
}
// get the track
TrackAuth track = await TrackRepository.GetTrack(trackId);
if (track == null)
{
return(new UnauthorizedResult());
}
if (track.is_private)
{
string trackKeyHeader = req.Headers["X-Track-Key"];
string authToken = req.Headers["Authorization"];
if (authToken != null)
{
// validate authKey
AuthClaim authClaim = AuthRepository.ValidateAuthClaim(authToken);
if (authClaim == null)
{
return(new UnauthorizedResult());
}
// check track userID matches authClaim userId
if (track.PartitionKey != authClaim.user_id)
{
return(new UnauthorizedResult());
}
}
else if (trackKeyHeader != null)
{
KeySecret keySecret = AuthRepository.DecodeKeyAndSecret(trackKeyHeader);
// validate authKey
if (!AuthRepository.ValidateSHA256(trackId + keySecret.Key, keySecret.Secret))
{
return(new UnauthorizedResult());
}
// validate track key
if (track.track_key != keySecret.Key)
{
return(new UnauthorizedResult());
}
}
else
{
return(new UnauthorizedResult());
}
}
// get the post
Post post = await PostRepository.GetPost(trackId, postId);
if (post == null)
{
return(new UnauthorizedResult());
}
// convert to post DTO
return(new OkObjectResult(new PostDTO()
{
body = post.body,
date_created = post.date_created,
id = post.RowKey,
summary = post.summary,
tags = post.tags.Split(',').ToList(),
title = post.title,
track_id = post.PartitionKey,
track_name = post.track_name,
type = post.type,
url = post.url
}));
}
catch (Exception e)
{
log.Info(e.Message);
return(new UnauthorizedResult());
}
}
