예제 #1
0
        public async Task ExecuteAsync(
            UpdateMediaMetadataMessage message,
            CancellationToken cancellationToken)
        {
            var messages = new List <MediaOperationCompletedMessage>();

            foreach (Guid mediaId in message.Ids)
            {
                MediaOperationCompletedMessage msg = await UpdateMetadataAsync(
                    mediaId,
                    message.DateTaken,
                    message.GeoLocation,
                    cancellationToken);

                msg.OperationId = message.OperationId;
                messages.Add(msg);

                await _bus.Publish(msg, cancellationToken);
            }

            var completedmsg = new MediaOperationRequestCompletedMessage
            {
                Type         = MediaOperationType.UpdateMetadata,
                OperationId  = message.OperationId,
                SuccessCount = messages.Where(x => x.IsSuccess).Count(),
                ErrorCount   = messages.Where(x => !x.IsSuccess).Count(),
            };

            await _bus.Publish(completedmsg, cancellationToken);
        }
예제 #2
0
        private async Task <MediaOperationCompletedMessage> DeleteAsync(
            Guid id,
            CancellationToken cancellationToken)
        {
            MediaOperationCompletedMessage msg = new MediaOperationCompletedMessage
            {
                Type    = MediaOperationType.Delete,
                MediaId = id,
            };

            Media media = await _mediaService.GetByIdAsync(id, cancellationToken);

            try
            {
                await _faceService.DeleteByMediaIdAsync(media.Id, cancellationToken);

                await _mediaService.DeleteAsync(media, cancellationToken);

                msg.Message = $"{media.Filename} deleted";

                msg.IsSuccess = true;
            }
            catch (Exception ex)
            {
                msg.IsSuccess = false;
                msg.Message   = ex.Message;
            }

            return(msg);
        }
예제 #3
0
        private async Task <MediaOperationCompletedMessage> UpdateMetadataAsync(
            Guid id,
            DateTimeOffset?dateTaken,
            UpdateMedataGeoLocation?geoLocation,
            CancellationToken cancellationToken)
        {
            MediaOperationCompletedMessage msg = new MediaOperationCompletedMessage
            {
                Type    = MediaOperationType.UpdateMetadata,
                MediaId = id,
            };

            try
            {
                if (dateTaken.HasValue)
                {
                    await _mediaService.UpdateDateTakenAsync(id, dateTaken, cancellationToken);
                }
                if (geoLocation is { } geo&& geo.Latitude.HasValue && geo.Longitude.HasValue)
                {
                    Media media = await _mediaStore.GetByIdAsync(id, cancellationToken);

                    media.GeoLocation = new GeoLocation
                    {
                        Point   = GeoPoint.Create(geo.Latitude.Value, geo.Longitude.Value),
                        Type    = "User",
                        GeoHash = GeoHash.Encode(geo.Latitude.Value, geo.Longitude.Value),
                        Address = GetAddress(geoLocation)
                    };

                    await _mediaStore.UpdateAsync(media, cancellationToken);
                }

                msg.IsSuccess = true;
            }
            catch (Exception ex)
            {
                msg.IsSuccess = false;
                msg.Message   = ex.Message;
            }

            return(msg);
        }
예제 #4
0
        private async Task <MediaOperationCompletedMessage> RecycleAsync(
            Guid id,
            CancellationToken cancellationToken)
        {
            Media media = await _mediaStore.GetByIdAsync(id, cancellationToken);

            MediaOperationCompletedMessage msg = new MediaOperationCompletedMessage
            {
                Type    = MediaOperationType.Recycle,
                MediaId = id,
            };

            try
            {
                await _mediaBlobStore.MoveToSpecialFolderAsync(
                    new MediaBlobData
                {
                    Directory = media.Folder,
                    Filename  = media.Filename,
                    Type      = MediaBlobType.Media
                },
                    MediaBlobType.Recycled,
                    cancellationToken);

                media.Folder = null;
                media.State  = MediaState.Recycled;

                await _mediaStore.UpdateAsync(media, cancellationToken);

                msg.Message = $"{media.Filename} Recycled";

                await RecycleFacesAsync(media.Id, cancellationToken);

                msg.IsSuccess = true;
            }
            catch (Exception ex)
            {
                msg.IsSuccess = false;
                msg.Message   = ex.Message;
            }

            return(msg);
        }