GrpcPortal.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="GrpcPortal.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Exposes server-side DataPortal functionality</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Principal;
using System.Text;
using System.Threading.Tasks;
using Csla.Core;
using Csla.Serialization;
using Csla.Serialization.Mobile;
using Csla.Server;
using Csla.Server.Hosts.DataPortalChannel;
using Google.Protobuf;
using Grpc.Core;
 
namespace Csla.Channels.Grpc
{
  public class GrpcPortal : Csla.Channels.Grpc.GrpcService.GrpcServiceBase
  {
    private IDataPortalServer dataPortalServer;
    private ApplicationContext ApplicationContext { get; set; }
 
    public GrpcPortal(IDataPortalServer dataPortal, ApplicationContext applicationContext)
    {
      dataPortalServer = dataPortal;
      ApplicationContext = applicationContext;
    }
 
    public override async Task<ResponseMessage> Invoke(RequestMessage request, ServerCallContext context)
    {
      var operation = request.Operation;
      if (operation.Contains("/"))
      {
        var temp = operation.Split('/');
        return await RouteMessage(temp[0], temp[1], request);
      }
      else
      {
        return await InvokePortal(operation, request.Body).ConfigureAwait(false);
      }
    }
 
    protected static Dictionary<string, string> RoutingTagUrls = new Dictionary<string, string>();
 
    protected virtual async Task<ResponseMessage> RouteMessage(string operation, string routingTag, RequestMessage request)
    {
      if (RoutingTagUrls.TryGetValue(routingTag, out string route) && route != "localhost")
      {
        var options = new GrpcProxyOptions { DataPortalUrl = $"{route}?operation={operation}" };
        var channel = ApplicationContext.CreateInstanceDI<global::Grpc.Net.Client.GrpcChannel>();
        var proxy = new GrpcProxy(ApplicationContext, channel, options);
        var clientRequest = new RequestMessage
        {
          Body = request.Body,
          Operation = operation
        };
        var clientResponse = await proxy.RouteMessage(clientRequest);
        return new ResponseMessage { Body = clientResponse.Body };
      }
      else
      {
        return await InvokePortal(operation, request.Body).ConfigureAwait(false);
      }
    }
 
    private async Task<ResponseMessage> InvokePortal(string operation, ByteString requestData)
    {
      var result = ApplicationContext.CreateInstanceDI<DataPortalResponse>();
      DataPortalErrorInfo errorData = null;
      try
      {
        var request = SerializationFormatterFactory.GetFormatter(ApplicationContext).Deserialize(requestData.ToByteArray());
        result = await CallPortal(operation, request);
      }
      catch (Exception ex)
      {
        errorData = ApplicationContext.CreateInstanceDI<DataPortalErrorInfo>(ex);
      }
      var portalResult = ApplicationContext.CreateInstanceDI<DataPortalResponse>();
      portalResult.ErrorData = errorData;
      portalResult.ObjectData = result.ObjectData;
      var buffer = SerializationFormatterFactory.GetFormatter(ApplicationContext).Serialize(portalResult);
      return new ResponseMessage { Body = ByteString.CopyFrom(buffer) };
    }
 
    private async Task<DataPortalResponse> CallPortal(string operation, object request)
    {
      DataPortalResponse result;
      switch (operation)
      {
        case "create":
          result = await Create((CriteriaRequest)request).ConfigureAwait(false);
          break;
 
        case "fetch":
          result = await Fetch((CriteriaRequest)request).ConfigureAwait(false);
          break;
 
        case "update":
          result = await Update((UpdateRequest)request).ConfigureAwait(false);
          break;
 
        case "delete":
          result = await Delete((CriteriaRequest)request).ConfigureAwait(false);
          break;
 
        default:
          throw new InvalidOperationException(operation);
      }
      return result;
    }
 
    public async Task<DataPortalResponse> Create(CriteriaRequest request)
    {
      var result = ApplicationContext.CreateInstanceDI<DataPortalResponse>();
      try
      {
        request = ConvertRequest(request);
 
        // unpack criteria data into object
        object criteria = GetCriteria(ApplicationContext, request.CriteriaData);
        if (criteria is Csla.DataPortalClient.PrimitiveCriteria)
        {
          criteria = ((Csla.DataPortalClient.PrimitiveCriteria)criteria).Value;
        }
 
        var objectType = Csla.Reflection.MethodCaller.GetType(AssemblyNameTranslator.GetAssemblyQualifiedName(request.TypeName), true);
        var context = new DataPortalContext(
          ApplicationContext, (IPrincipal)SerializationFormatterFactory.GetFormatter(ApplicationContext).Deserialize(request.Principal),
          true,
          request.ClientCulture,
          request.ClientUICulture,
          (ContextDictionary)SerializationFormatterFactory.GetFormatter(ApplicationContext).Deserialize(request.ClientContext));
 
        var dpr = await dataPortalServer.Create(objectType, criteria, context, true);
 
        if (dpr.Error != null)
          result.ErrorData = ApplicationContext.CreateInstanceDI<DataPortalErrorInfo>(dpr.Error);
        result.ObjectData = SerializationFormatterFactory.GetFormatter(ApplicationContext).Serialize(dpr.ReturnObject);
      }
      catch (Exception ex)
      {
        result.ErrorData = ApplicationContext.CreateInstanceDI<DataPortalErrorInfo>(ex);
        throw;
      }
      finally
      {
        result = ConvertResponse(result);
      }
      return result;
    }
 
    public async Task<DataPortalResponse> Fetch(CriteriaRequest request)
    {
      var result = ApplicationContext.CreateInstanceDI<DataPortalResponse>();
      try
      {
        request = ConvertRequest(request);
 
        // unpack criteria data into object
        object criteria = GetCriteria(ApplicationContext, request.CriteriaData);
        if (criteria is Csla.DataPortalClient.PrimitiveCriteria)
        {
          criteria = ((Csla.DataPortalClient.PrimitiveCriteria)criteria).Value;
        }
 
        var objectType = Csla.Reflection.MethodCaller.GetType(AssemblyNameTranslator.GetAssemblyQualifiedName(request.TypeName), true);
        var context = new DataPortalContext(
          ApplicationContext, (IPrincipal)SerializationFormatterFactory.GetFormatter(ApplicationContext).Deserialize(request.Principal),
          true,
          request.ClientCulture,
          request.ClientUICulture,
          (ContextDictionary)SerializationFormatterFactory.GetFormatter(ApplicationContext).Deserialize(request.ClientContext));
 
        var dpr = await dataPortalServer.Fetch(objectType, criteria, context, true);
 
        if (dpr.Error != null)
          result.ErrorData = ApplicationContext.CreateInstanceDI<DataPortalErrorInfo>(dpr.Error);
        result.ObjectData = SerializationFormatterFactory.GetFormatter(ApplicationContext).Serialize(dpr.ReturnObject);
      }
      catch (Exception ex)
      {
        result.ErrorData = ApplicationContext.CreateInstanceDI<DataPortalErrorInfo>(ex);
        throw;
      }
      finally
      {
        result = ConvertResponse(result);
      }
      return result;
    }
 
    public async Task<DataPortalResponse> Update(UpdateRequest request)
    {
      var result = ApplicationContext.CreateInstanceDI<DataPortalResponse>();
      try
      {
        request = ConvertRequest(request);
        // unpack object
        object obj = GetCriteria(ApplicationContext, request.ObjectData);
 
        var context = new DataPortalContext(
          ApplicationContext, (IPrincipal)SerializationFormatterFactory.GetFormatter(ApplicationContext).Deserialize(request.Principal),
          true,
          request.ClientCulture,
          request.ClientUICulture,
          (ContextDictionary)SerializationFormatterFactory.GetFormatter(ApplicationContext).Deserialize(request.ClientContext));
 
        var dpr = await dataPortalServer.Update(obj, context, true);
 
        if (dpr.Error != null)
          result.ErrorData = ApplicationContext.CreateInstanceDI<DataPortalErrorInfo>(dpr.Error);
 
        result.ObjectData = SerializationFormatterFactory.GetFormatter(ApplicationContext).Serialize(dpr.ReturnObject);
      }
      catch (Exception ex)
      {
        result.ErrorData = ApplicationContext.CreateInstanceDI<DataPortalErrorInfo>(ex);
        throw;
      }
      finally
      {
        result = ConvertResponse(result);
      }
      return result;
    }
 
    public async Task<DataPortalResponse> Delete(CriteriaRequest request)
    {
      var result = ApplicationContext.CreateInstanceDI<DataPortalResponse>();
      try
      {
        request = ConvertRequest(request);
 
        // unpack criteria data into object
        object criteria = GetCriteria(ApplicationContext, request.CriteriaData);
        if (criteria is Csla.DataPortalClient.PrimitiveCriteria)
        {
          criteria = ((Csla.DataPortalClient.PrimitiveCriteria)criteria).Value;
        }
 
        var objectType = Csla.Reflection.MethodCaller.GetType(AssemblyNameTranslator.GetAssemblyQualifiedName(request.TypeName), true);
        var context = new DataPortalContext(
          ApplicationContext, (IPrincipal)SerializationFormatterFactory.GetFormatter(ApplicationContext).Deserialize(request.Principal),
          true,
          request.ClientCulture,
          request.ClientUICulture,
          (ContextDictionary)SerializationFormatterFactory.GetFormatter(ApplicationContext).Deserialize(request.ClientContext));
 
        var dpr = await dataPortalServer.Delete(objectType, criteria, context, true);
 
        if (dpr.Error != null)
          result.ErrorData = ApplicationContext.CreateInstanceDI<DataPortalErrorInfo>(dpr.Error);
        result.ObjectData = SerializationFormatterFactory.GetFormatter(ApplicationContext).Serialize(dpr.ReturnObject);
      }
      catch (Exception ex)
      {
        result.ErrorData = ApplicationContext.CreateInstanceDI<DataPortalErrorInfo>(ex);
        throw;
      }
      finally
      {
        result = ConvertResponse(result);
      }
      return result;
    }
 
    #region Criteria
 
    private static object GetCriteria(ApplicationContext applicationContext, byte[] criteriaData)
    {
      object criteria = null;
      if (criteriaData != null)
        criteria = SerializationFormatterFactory.GetFormatter(applicationContext).Deserialize(criteriaData);
      return criteria;
    }
 
    #endregion Criteria
 
    #region Extention Method for Requests
 
    protected virtual UpdateRequest ConvertRequest(UpdateRequest request)
    {
      return request;
    }
 
    protected virtual CriteriaRequest ConvertRequest(CriteriaRequest request)
    {
      return request;
    }
 
    protected virtual DataPortalResponse ConvertResponse(DataPortalResponse response)
    {
      return response;
    }
 
    #endregion Extention Method for Requests
  }
}