GetDataCommandHandler.cs

using ShapeDiver.SDK.GeometryBackend;
using ShapeDiver.SDK.GeometryBackend.DTO;
using ShapeDiver.SDK.Stargate;
using ShapeDiver.SDK.Stargate.Commands.Interfaces;
using ShapeDiver.SDK.Stargate.Dto.Commands;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;

namespace StargateDotNetClientExample
{
    /// <summary>
    /// This handler is called by the ShapeDiver Platform when the user wants to get data for 
    /// a given input (parameter) of the ShapeDiver model. 
    /// </summary>
    internal class GetDataCommandHandler : BaseCommandHandler, IGetDataCommandHandler
    {
        public GetDataCommandHandler(IServices services) : base(services)
        {
        }

        /// <summary>
        /// Supported content types for file parameters.
        /// TODO extend this list as required.
        /// </summary>
        List<string> supportedContentTypes = new List<string>()
        {
            "application/dwg",
            "application/json"
        };

        public async Task<GetDataReplyDto> Handle(GetDataCommandDto data)
        {
            Services.LogMessage("Handling GetDataCommand");

            // get a session context for the model
            IGeometryBackendContext sessionContext = await this.Services.GeometryBackendContextCache.GetContextAsync(data.Model.Id, false, ModelTokenScopes);

            // parameter sanity check
            if (String.IsNullOrEmpty(data?.Parameter?.Id))
            {
                throw new StargateException($"Missing parameter id.");
            }
            if (!sessionContext.ModelData.Parameters.ContainsKey(data.Parameter.Id))
            {
                throw new StargateException($"Could not find parameter with id \"{data.Parameter.Id}\" for model with id \"{data.Model.Id}\".");
            }

            var parameter = sessionContext.ModelData.Parameters[data.Parameter.Id];
            if (parameter.Type != ParameterTypeEnum.File)
            {
                throw new StargateException($"Parameter with id \"{data.Parameter.Id}\" is not of type 'File'.");
            }

            // content type check - get the first matching content type
            var selectedContentType = parameter.Format.Where(format => supportedContentTypes.Contains(format)).FirstOrDefault();
            if (String.IsNullOrEmpty(selectedContentType))
            {
                throw new StargateException($"Could not find a matching content type for parameter with id \"{data.Parameter.Id}\".");
            }

            /// TODO: Get file depending on selectedContentType, read result into a memory stream.

            /// TODO: upload file, and send success result as shown below. Adapt the feedback messages to the user as required.

            /// Dummy example by ShapeDiver: 
            if (selectedContentType == "application/json")
            {
                if (File.Exists("test.json"))
                {
                    using (FileStream fileStream = File.OpenRead("test.json"))
                    {
                        var uploadResult = await sessionContext.GeometryBackendClient.UploadFile(sessionContext, parameter.Id, fileStream, selectedContentType, "test.json");
                        return SuccessResult(uploadResult.FileId, null, 1, GetDataResultEnum.Success, $"Uploaded JSON file for parameter '{parameter.Name}'");
                    }
                }
            }
            else if (selectedContentType == "application/dwg")
            {
                if (File.Exists("test.dwg"))
                {
                    using (FileStream fileStream = File.OpenRead("test.dwg"))
                    {
                        var uploadResult = await sessionContext.GeometryBackendClient.UploadFile(sessionContext, parameter.Id, fileStream, selectedContentType, "test.dwg");
                        return SuccessResult(uploadResult.FileId, null, 1, GetDataResultEnum.Success, $"Uploaded DWG file for parameter '{parameter.Name}'");
                    }
                }
            }

            // TODO Optional feedback message in case the user cancelled the input.
            // return SuccessResult(null, null, 0, GetDataResultEnum.Cancel, $"Handled GetDataCommand for parameter '{parameter.Name}'");

            // TODO Feedback message in case the user did not select any data.
            return SuccessResult(null, null, 0, GetDataResultEnum.Nothing, $"Handled GetDataCommand for parameter '{parameter.Name}'");
        }

        private GetDataReplyDto SuccessResult(string assetId, string chunkId, int count, GetDataResultEnum result, string message)
        {
            var reply = new GetDataReplyDto()
            {
                Info = new GetDataInfoReplyDto()
                {
                    Count = count,
                    Result = result,
                    Message = message
                }
            };

            if (!String.IsNullOrEmpty(assetId))
            {
                reply.Asset = new GetDataAssetReplyDto()
                {
                    Id = assetId,
                    Chunk = chunkId == null ? null : new GetDataAssetChunkReplyDto()
                    {
                        Id = chunkId
                    }
                };
            }

            return reply;
        }
    }
}