private string GetSampleData(CProtoMessageField childField)
{
switch (childField.FieldType)
{
case GrpcType.__string:
return($@"""{Guid.NewGuid().ToString()}""");
;
case GrpcType.__int32:
return(new Random().Next().ToString());
case GrpcType.__int64:
return(new Random().Next().ToString());
case GrpcType.__google_protobuf_Timestamp:
return($@"Timestamp.FromDateTime(DateTime.SpecifyKind( DateTime.Parse(""{
DateTime.UtcNow.ToString("o")
}""), DateTimeKind.Utc))");
case GrpcType.__bool:
return($@"true");
}
return("null");
}
public static string GetSampleData(CProtoMessageField childField, COperationIs operationIs)
{
var dataType = SqlMapper.SqlDbTypeToDbType(SqlMapper.GrpcTypeToSqlDbType(childField.FieldType));
var isIdentity = false;
var isForeignKey = false;
if (childField.DerivedFrom is CColumn)
{
var column = childField.DerivedFrom as CColumn;
isIdentity = column.IsIdentity;
dataType = column.ColumnType;
}
else if (childField.DerivedFrom is CStoredProcedureParameter)
{
var parameter = childField.DerivedFrom as CStoredProcedureParameter;
isIdentity = parameter.SourceColumn.IsIdentity;
isForeignKey = parameter.SourceColumn.ForeignKeyColumn.Count > 0;
dataType = parameter.ParameterType;
}
if (isForeignKey && dataType == DbType.Int64)
{
return("_currentDbIdentityValue");
}
if (isForeignKey && dataType == DbType.Int32)
{
return("_currentDbIdentityValue");
}
if (isIdentity)
{
if (operationIs == COperationIs.Update)
{
return("_currentDbIdentityValue");
}
else
{
return("0");
}
}
if (_sampleData.ContainsKey(childField.FieldName))
{
return(LookupSample(childField));
}
var sampleData = GenerateSampleData(dataType);
_sampleData.Add(childField.FieldName, sampleData);
return(sampleData);
}
private static CStoredProcedureParameter InferStoredProcedureParameter(CProtoMessageField parameter)
{
DbType parameterType;
string parameterTypeRaw;
bool isUserDefined = false;
if (parameter.IsTimestampMessage)
{
parameterType = DbType.DateTime2;
parameterTypeRaw = DbType.DateTime2.ToString();
}
else if (parameter.FieldType == GrpcType.__message)
{
isUserDefined = true;
parameterType = SqlMapper.SqlDbTypeToDbType(SqlMapper.GrpcTypeToSqlDbType(parameter.FieldType));
parameterTypeRaw = $"tt{parameter.MessageType}"; //todo: look it up
}
else
{
parameterType = SqlMapper.SqlDbTypeToDbType(SqlMapper.GrpcTypeToSqlDbType(parameter.FieldType));
parameterTypeRaw = SqlMapper.GrpcTypeToSqlRaw(parameter.FieldType);
}
var p = new CStoredProcedureParameter
{
ParameterName = parameter.FieldName,
ParameterType = parameterType,
ParameterTypeRaw = parameterTypeRaw,
ParameterTypeIsUserDefined = isUserDefined,
IsCollection = parameter.Repeated
};
if (p.ParameterType == System.Data.DbType.AnsiString)
{
p.ParameterLength = 255;
}
return(p);
}
private IEnumerable <CColumn> InferColumns(CTable table, CProtoRpc rpc, CProtoMessageField protoField)
{
var columns = new List <CColumn>();
DbType columnType1 = DbType.AnsiString;
string columnType1Raw = null;
var field = protoField;
if (field.IsMap)
{
//todo: don't hard code ast <string, bool>
//loop thru the 2 fields in the map and add columns
columnType1 =
SqlMapper.SqlDbTypeToDbType(SqlMapper.GrpcTypeToSqlDbType(Pass2.CModel.GrpcType.__string));
var col1 = new CColumn(table)
{
ColumnName = $"{field.FieldName}{columnType1.ToString()}",
ColumnType = columnType1,
ColumnTypeRaw = "varchar"
};
columns.Add((col1));
var columnType2 =
SqlMapper.SqlDbTypeToDbType(SqlMapper.GrpcTypeToSqlDbType(Pass2.CModel.GrpcType.__bool));
var col2 = new CColumn(table)
{
ColumnName = $"{field.FieldName}{columnType2.ToString()}",
ColumnType = columnType2,
ColumnTypeRaw = "bit"
};
columns.Add((col2));
}
else
{
if (field.IsTimestampMessage)
{
columnType1 = DbType.DateTime2;
columnType1Raw = DbType.DateTime2.ToString();
}
else
{
if (field.FieldType == GrpcType.__message)
{
//if the inner message is just a single scalar field, lets use that
var m = rpc.ProtoService.ProtoFile.ProtoMessage.FirstOrDefault(pm =>
pm.MessageName == field.MessageType);
if (m.ProtoField.Count == 1)
{
field = m.ProtoField.First();
}
}
columnType1 = SqlMapper.SqlDbTypeToDbType(SqlMapper.GrpcTypeToSqlDbType(field.FieldType));
columnType1Raw = SqlMapper.GrpcTypeToSqlDbType(field.FieldType).ToString();
if (field.FieldName.EndsWith("ExternalId"))
{
columnType1 = System.Data.DbType.AnsiStringFixedLength;
columnType1Raw = "char";
}
}
var col = new CColumn(table)
{
ColumnName = field.FieldName,
ColumnType = columnType1,
ColumnTypeRaw = columnType1Raw
};
if (columnType1 == System.Data.DbType.AnsiStringFixedLength)
{
if (col.ColumnName.EndsWith("ExternalId"))
{
col.ColumnLength = 32;
}
else
{
col.ColumnLength = 255;
}
}
else if (columnType1 == System.Data.DbType.AnsiString)
{
col.ColumnLength = 255;
}
columns.Add(col);
}
return(columns);
}
public CProtoFile Convert(List <CStoredProcedure> storedProcedures, bool addCRUD = false, bool addBulkRpc = true)
{
var protoFile = new CProtoFile();
protoFile.Import.Add("google/protobuf/timestamp.proto");
protoFile.Import.Add("google/protobuf/descriptor.proto");
//protoFile.Import.Add("google/protobuf/duration.proto");
protoFile.CSharpNamespace = NamespaceName;
protoFile.Option.Add($@"csharp_namespace = ""{NamespaceName}"";");
var messagesToAddToBulkRpc = new List <CProtoMessage>();
var protoService = new CProtoService(protoFile)
{
ServiceName = ServiceName
};
protoFile.ProtoService.Add(protoService);
foreach (var storedProcedure in storedProcedures)
{
if (!addCRUD)
{
if (storedProcedure.DataOperationIs.HasFlag(COperationIs.CRUD))
{
continue;
}
}
var rpc = new CProtoRpc(protoService)
{
RpcName = storedProcedure.StoredProcedureName,
RpcDescription = storedProcedure.StoredProcedureDescription,
//DomainModelName = storedProcedure.ResultSetName,
DerivedFrom = storedProcedure
};
rpc.Request = new CProtoMessage(rpc)
{
IsRequest = true,
MessageName = $"{storedProcedure.StoredProcedureName}Request"
};
rpc.Response = new CProtoMessage(rpc)
{
IsResponse = true,
MessageName = $"{storedProcedure.StoredProcedureName}Response"
};
var requestMessage = rpc.Request;
if (!string.IsNullOrEmpty(storedProcedure.ParameterSetName))
{
rpc.Request.ProtoField.Add(new CProtoMessageField(storedProcedure)
{
IsScalar = false,
MessageType = storedProcedure.ParameterSetName,
FieldName = storedProcedure.ParameterSetName
});
requestMessage = new CProtoMessage(rpc)
{
IsRequest = true,
MessageName = storedProcedure.ParameterSetName
};
if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == requestMessage.MessageName))
{
protoFile.ProtoMessage.Add(requestMessage);
if (addBulkRpc)
{
messagesToAddToBulkRpc.Add(requestMessage);
}
}
}
foreach (var parameter in storedProcedure.Parameter)
{
var sqlType = SqlDbType.VarChar;
if (!parameter.ParameterTypeIsUserDefined)
{
sqlType = SqlMapper.ParseValueAsSqlDbType(parameter.ParameterTypeRaw);
}
var field = new CProtoMessageField(parameter)
{
FieldName = parameter.ParameterName, //.SourceColumn.ColumnName,
FieldType = SqlMapper.SqlDbTypeToGrpcType(sqlType)
};
if (parameter.ParameterTypeIsUserDefined)
{
field.Repeated = true;
}
requestMessage.ProtoField.Add(field);
}
var responseMessage = rpc.Response;
if (!string.IsNullOrEmpty(storedProcedure.ResultSetName))
{
rpc.Response.ProtoField.Add(new CProtoMessageField(null)
{
IsScalar = false,
Repeated = true,
MessageType = storedProcedure.ResultSetName,
FieldName = storedProcedure.ResultSetName
});
responseMessage = new CProtoMessage(rpc)
{
IsResponse = true,
MessageName = storedProcedure.ResultSetName
};
if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == responseMessage.MessageName))
{
protoFile.ProtoMessage.Add(responseMessage);
}
}
foreach (var resultColumn in storedProcedure.ResultSet)
{
var field = new CProtoMessageField(resultColumn)
{
FieldName = resultColumn.ColumnName,
FieldType = SqlMapper.SqlDbTypeToGrpcType(resultColumn.ColumnSqlDbType)
};
responseMessage.ProtoField.Add(field);
}
protoService.Rpc.Add(rpc);
}
/*
* if (addBulkRpc)
* {
* var rpc = new SProtoRpc(protoService)
* {
* RpcName = $"{BulkStoreRpcName}",
* OperationIs = SOperationIs.Bulk | SOperationIs.Add | SOperationIs.Update
* };
*
* var request = new SProtoMessage
* {
* IsRequest = true,
* MessageName = $"{rpc.RpcName}Request"
*
* };
*
* rpc.Request = request;
* foreach (var message in messagesToAddToBulkRpc)
* {
* request.ProtoField.Add(new SProtoMessageField (null) { IsScalar = false, Repeated = true, MessageType = message.MessageName, FieldName = $"{message.MessageName}" });
* }
*
* var response = new SProtoMessage
* {
* IsResponse = true,
* MessageName = $"{rpc.RpcName}Response"
* };
* rpc.Response = response;
*
*
* protoService.Rpc.Add(rpc);
* }*/
return(protoFile);
}
private static string LookupSample(CProtoMessageField childField)
{
return(_sampleData[childField.FieldName]);
}
private CProtoRpc BuildRpcFromStoredProc(CProtoFile protoFile, CProtoService protoService, CMethod method,
CStoredProcedure storedProcedure)
{
var rpc = new CProtoRpc(protoService)
{
RpcName = storedProcedure.StoredProcedureName,
RpcDescription = storedProcedure.StoredProcedureDescription,
//DomainModelName = storedProcedure.ResultSetName,
DerivedFrom = storedProcedure
};
rpc.Request = new CProtoMessage(rpc)
{
IsRequest = true,
MessageName = $"{storedProcedure.StoredProcedureName}Request"
};
rpc.Response = new CProtoMessage(rpc)
{
IsResponse = true,
MessageName = $"{storedProcedure.StoredProcedureName}Response"
};
var requestMessage = rpc.Request;
if (!string.IsNullOrEmpty(storedProcedure.ParameterSetName))
{
rpc.Request.ProtoField.Add(new CProtoMessageField(storedProcedure)
{
IsScalar = false,
MessageType = storedProcedure.ParameterSetName,
FieldName = storedProcedure.ParameterSetName
});
requestMessage = new CProtoMessage(rpc)
{
IsRequest = true,
MessageName = storedProcedure.ParameterSetName
};
if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == requestMessage.MessageName))
{
protoFile.ProtoMessage.Add(requestMessage);
}
}
foreach (var parameter in storedProcedure.Parameter)
{
var field = new CProtoMessageField(parameter)
{
FieldName = parameter.ParameterName //.SourceColumn.ColumnName,
};
if (!parameter.ParameterTypeIsUserDefined)
{
var sqlType = SqlMapper.ParseValueAsSqlDbType(parameter.ParameterTypeRaw);
field.FieldType = SqlMapper.SqlDbTypeToGrpcType(sqlType);
}
else
{
//todo: property handle user defined sql types (tables)
//lookup table type
//for now, use the data type of the first column, assumes single column table
var tableType = FindTableType(parameter.ParameterTypeRaw);
var converter = new CTableTypeToCClassConverter();
var @class = converter.Convert(tableType.GeneratedTableType);
field.FieldType = GrpcType.__string;
field.IsScalar = false;
field.Repeated = true;
field.MessageType = $@"{@class.ClassName}";
if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == field.MessageType))
{
//create a message
var tableTypeDerivedMessage = new CProtoMessage(rpc)
{
MessageName = field.MessageType
};
foreach (var property in @class.Property)
{
var field2 = new CProtoMessageField(property)
{
FieldName = property.PropertyName,
FieldType = SqlMapper.ClrTypeToGrpcType(SqlMapper.ClrTypeAliasToClrType(property.Type))
};
tableTypeDerivedMessage.ProtoField.Add(field2);
}
protoFile.ProtoMessage.Add(tableTypeDerivedMessage);
}
}
requestMessage.ProtoField.Add(field);
}
var responseMessage = rpc.Response;
if (!string.IsNullOrEmpty(storedProcedure.ResultSetName))
{
rpc.Response.ProtoField.Add(new CProtoMessageField(null)
{
IsScalar = false,
Repeated = true,
MessageType = storedProcedure.ResultSetName,
FieldName = storedProcedure.ResultSetName
});
responseMessage = new CProtoMessage(rpc)
{
IsResponse = true,
MessageName = storedProcedure.ResultSetName
};
if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == responseMessage.MessageName))
{
protoFile.ProtoMessage.Add(responseMessage);
}
}
foreach (var resultColumn in storedProcedure.ResultSet)
{
var field = new CProtoMessageField(resultColumn)
{
FieldName = resultColumn.ColumnName,
FieldType = SqlMapper.SqlDbTypeToGrpcType(resultColumn.ColumnSqlDbType)
};
responseMessage.ProtoField.Add(field);
}
return(rpc);
}
private CProtoRpc BuildBulkRpcFromStoredProcList(CProtoFile protoFile, CProtoService protoService,
CMethod method, CStoredProcList storedProcedureList)
{
var rpc = new CProtoRpc(protoService)
{
RpcName = method.MethodName,
//DomainModelName = "Junk", // storedProcedure.ResultSetName,,
DerivedFrom = storedProcedureList
};
rpc.Request = new CProtoMessage(rpc)
{
IsRequest = true,
MessageName = $"{method.MethodName}Request"
};
rpc.Response = new CProtoMessage(rpc)
{
IsResponse = true,
MessageName = $"{method.MethodName}Response"
};
var requestMessage = rpc.Request;
foreach (var storedProcedure in storedProcedureList.List)
{
if (!string.IsNullOrEmpty(storedProcedure.ParameterSetName))
{
rpc.Request.ProtoField.Add(new CProtoMessageField(storedProcedure)
{
IsScalar = false,
MessageType = storedProcedure.ParameterSetName,
FieldName = storedProcedure.ParameterSetName,
Repeated = true
});
requestMessage = new CProtoMessage(rpc)
{
IsRequest = true,
MessageName = storedProcedure.ParameterSetName
};
if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == requestMessage.MessageName))
{
protoFile.ProtoMessage.Add(requestMessage);
}
}
foreach (var parameter in storedProcedure.Parameter)
{
var sqlType = SqlDbType.VarChar;
if (!parameter.ParameterTypeIsUserDefined)
{
sqlType = SqlMapper.ParseValueAsSqlDbType(parameter.ParameterTypeRaw);
}
var field = new CProtoMessageField(parameter)
{
FieldName = parameter.ParameterName, //.SourceColumn.ColumnName,
FieldType = SqlMapper.SqlDbTypeToGrpcType(sqlType)
};
if (parameter.ParameterTypeIsUserDefined)
{
field.Repeated = true;
}
requestMessage.ProtoField.Add(field);
}
/*
* var responseMessage = rpc.Response;
* if (!string.IsNullOrEmpty(storedProcedure.ResultSetName))
* {
* rpc.Response.ProtoField.Add(new SProtoMessageField(null)
* {
* IsScalar = false,
* Repeated = true,
* MessageType = storedProcedure.ResultSetName,
* FieldName = storedProcedure.ResultSetName
* });
*
* responseMessage = new SProtoMessage
* {
* IsResponse = true,
* MessageName = storedProcedure.ResultSetName
* };
* if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == responseMessage.MessageName))
* {
* protoFile.ProtoMessage.Add(responseMessage);
*
* }
*
* }
* foreach (var resultColumn in storedProcedure.ResultSet)
* {
* var field = new SProtoMessageField(resultColumn)
* {
* FieldName = resultColumn.ColumnName,
* FieldType = SqlMapper.SqlDbTypeToGrpcType(resultColumn.ColumnSqlDbType)
* };
*
* responseMessage.ProtoField.Add(field);
* }*/
}
return(rpc);
}
