public static async void Run([QueueTrigger("delete-tracktags-from-track", Connection = "QUEUESTORAGE_CONNECTION")] CloudQueueMessage trackId, TraceWriter log)
        {
            List <TrackTag> listOfTrackTagsToDelete = await TrackTagRepository.GetTagsByTrack(trackId.AsString);

            foreach (TrackTag trackTag in listOfTrackTagsToDelete)
            {
                TrackTagRepository.DeleteTrackTag(trackTag);
            }

            log.Info($"C# Queue trigger function deleted track tags: {trackId.AsString}");
        }
        public static void Run([QueueTrigger("process-new-post-increment-track-tags", Connection = "QUEUESTORAGE_CONNECTION")] CloudQueueMessage myQueueItem, TraceWriter log)
        {
            Post post = JsonConvert.DeserializeObject <Post>(myQueueItem.AsString);

            string[] tags = post.tags.Split(',');

            // add tags to tracktag list
            foreach (var tag in tags)
            {
                TrackTagRepository.InsertOrIncrementTrackTag(new TrackTag(post.PartitionKey, tag));
            }

            log.Info($"Tags incremented for post: {post.RowKey}");
        }
Esempio n. 3
0
        public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "track/{trackId}/tags")] 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());
                }

                // track 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());
                    }
                }

                List <TrackTagDTO> tags = await TrackTagRepository.GetTagsDTOByTrack(trackId);

                return(new OkObjectResult(tags));
            }
            catch (Exception e)
            {
                log.Info(e.Message);
                return(new UnauthorizedResult());
            }
        }