private static T GetResultTypeRef <T>(ServiceTypeInfo type) where T : ISwaggerSchema, new()
{
return(new T
{
Ref = "#/definitions/" + GetTypeAsDtoName(type),
});
}
public static List <ServiceTypeInfo> GetList_ServiceType(string ServiceTypeID, string ServiceTypeName, bool IsActive)
{
using (DBHelper dbhlper = new DBHelper("[spMSTServiceTypeGet]"))
{
DBHelper.AddPparameter("@ServiceTypeId", ServiceTypeID);
DBHelper.AddPparameter("@ServiceTypeName", ServiceTypeName);
using (DataSet ds = DBHelper.Execute_Query())
{
if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
List <ServiceTypeInfo> list = new List <ServiceTypeInfo>();
ServiceTypeInfo obj = null;
foreach (DataRow dr in ds.Tables[0].Rows)
{
obj = new ServiceTypeInfo();
obj.ServiceTypeId = dr["ServiceTypeID"].ToString();
obj.ServiceTypeName = dr["ServiceTypeName"].ToString();
obj.LastModifiedOn = Convert.ToDateTime(dr["LastModifiedOn"]);
obj.LastModifiedBy = dr["LastModifiedBy"].ToString();
obj.ActivityType = dr["ActivityType"].ToString();
obj.IsActive = dr["IsActive"].ToString().Trim().ToUpper() == "Y";
obj.DatauniqueID = dr["DatauniqueID"].ToString();
list.Add(obj);
}
return(list);
}
}
}
return(null);
}
public void Register_WithExistingServiceType()
{
// Arrange
var urmServiceType = ServiceTypeInfo.Create(Resources.ServiceType_URMService);
var serviceTypeSettings = new Mock <ServiceTypeSettings>();
serviceTypeSettings
.SetupGet(i => i.ClassName)
.Returns(urmServiceType.Class);
var serviceTypeCreator = new Mock <ServiceTypeManager>(serviceTypeSettings.Object);
var registerableServices = new Dictionary <string, string>();
MockWrapperFactory.Instance.ServiceManagementServer
.Setup(i => i.GetRegisterableServices())
.Returns(registerableServices);
var serviceTypeInfoCollection = new List <ServiceTypeInfo>
{
urmServiceType
};
MockWrapperFactory.Instance.ServiceManagementServer
.Setup(i => i.GetServiceTypes())
.Returns(serviceTypeInfoCollection);
// Action
serviceTypeCreator.Object.Register();
}
private IEnumerable <ServiceDtoInfo> GetDtosForType(ServiceTypeInfo type)
{
switch (type.Kind)
{
case ServiceTypeKind.Error:
yield return(GetErrorDto());
break;
case ServiceTypeKind.Dto:
yield return(type.Dto);
break;
case ServiceTypeKind.Result:
yield return(GetResultDto(type));
break;
}
if (type.ValueType != null)
{
foreach (var dto in GetDtosForType(type.ValueType))
{
yield return(dto);
}
}
}
/// <summary>
/// Serializes the object to JSON.
/// </summary>
/// <param name="writer">The <see cref="T: Newtonsoft.Json.JsonWriter" /> to write to.</param>
/// <param name="obj">The object to serialize to JSON.</param>
internal static void Serialize(JsonWriter writer, ServiceTypeInfo obj)
{
// Required properties are always serialized, optional properties are serialized when not null.
writer.WriteStartObject();
if (obj.ServiceTypeDescription != null)
{
writer.WriteProperty(obj.ServiceTypeDescription, "ServiceTypeDescription", ServiceTypeDescriptionConverter.Serialize);
}
if (obj.ServiceManifestName != null)
{
writer.WriteProperty(obj.ServiceManifestName, "ServiceManifestName", JsonWriterExtensions.WriteStringValue);
}
if (obj.ServiceManifestVersion != null)
{
writer.WriteProperty(obj.ServiceManifestVersion, "ServiceManifestVersion", JsonWriterExtensions.WriteStringValue);
}
if (obj.IsServiceGroup != null)
{
writer.WriteProperty(obj.IsServiceGroup, "IsServiceGroup", JsonWriterExtensions.WriteBoolValue);
}
writer.WriteEndObject();
}
public static bool Save_ServiceType(bool isOnlyDelete, ServiceTypeInfo obj, UserInfo objUserInfo, out string errormsg)
{
errormsg = "";
#region Validations
if (!Validations.ValidateDataType(obj.ServiceTypeId, Validations.ValueType.Integer, true, "ServiceType Id", out errormsg))
{
return(false);
}
if (!Validations.ValidateDataType(obj.ServiceTypeName, Validations.ValueType.AlphaNumericSpecialChar, true, "ServiceType Name", out errormsg))
{
return(false);
}
#endregion
using (DBHelper dbhlper = new DBHelper("[spMSTServiceTypeSave]", true))
{
DBHelper.AddPparameter("@ServiceTypeId", obj.ServiceTypeId, DBHelper.param_types.Varchar);
DBHelper.AddPparameter("@ServiceTypeName", obj.ServiceTypeName, DBHelper.param_types.Varchar);
DBHelper.AddPparameter("@IsActive", (obj.IsActive ? "Y" : "N"), DBHelper.param_types.Varchar);
DBHelper.AddPparameter("@UserCode", objUserInfo.UserCode.ToString().Trim(), DBHelper.param_types.Varchar);
DBHelper.AddPparameter("@isOnlyDelete", (isOnlyDelete ? 'Y' : 'N'), DBHelper.param_types.Varchar);
DBHelper.AddPparameter("@NewDatauniqueID", 0, DBHelper.param_types.BigInt, 50, DBHelper.param_direction.Output);
DBHelper.AddPparameter("@ErrorMessage", errormsg, DBHelper.param_types.Varchar, 500, DBHelper.param_direction.Output);
return(DBHelper.Execute_NonQuery(out errormsg));
}
}
private static SwaggerSchema GetMapOfSchema(ServiceTypeInfo type)
{
return(new SwaggerSchema
{
Type = SwaggerSchemaType.Object,
AdditionalProperties = GetTypeSchema <SwaggerSchema>(type),
});
}
private static T GetArrayOfSchema <T>(ServiceTypeInfo type) where T : ISwaggerSchema, new()
{
return(new T
{
Type = SwaggerSchemaType.Array,
Items = GetTypeSchema <SwaggerSchema>(type),
});
}
private static SwaggerResponse CreateSwaggerResponse(ServiceTypeInfo type = null, string identifier = null, string description = null)
{
return(new SwaggerResponse
{
Description = description ?? "",
Schema = type != null && type.Kind != ServiceTypeKind.Boolean ? GetTypeSchema <SwaggerSchema>(type) : null,
Identifier = identifier,
});
}
public static ServiceTypeInfo GetServiceTypeInfo(Guid serviceTypeGuid)
{
var connection = WrapperFactory.Instance.GetServiceManagementServerWrapper(null);
using (connection.BaseAPIServer?.Connection)
{
string serviceTypeInfoXml = connection.GetServiceType(serviceTypeGuid);
return(ServiceTypeInfo.Create(serviceTypeInfoXml));
}
}
private static ServiceDtoInfo GetResultDto(ServiceTypeInfo type)
{
return(new ServiceDtoInfo(name: GetTypeAsDtoName(type),
fields: new[]
{
new ServiceFieldInfo(name: "value", typeName: type.ValueType.ToString(), summary: "The value."),
new ServiceFieldInfo(name: "error", typeName: "error", summary: "The error."),
},
summary: "A result value or error."));
}
private static SwaggerParameter CreateSwaggerRequestBodyParameter(ServiceTypeInfo type, string name, string description = null)
{
return(new SwaggerParameter
{
In = SwaggerParameterKind.Body,
Name = name,
Description = description,
Required = true,
Schema = GetTypeSchema <SwaggerSchema>(type),
});
}
private static ServiceTypeInfo TryCreateMethodResponseBodyType(HttpMethodInfo httpMethodInfo, HttpResponseInfo httpResponseInfo)
{
if (httpResponseInfo.NormalFields == null || httpResponseInfo.NormalFields.Count == 0)
{
return(null);
}
return(ServiceTypeInfo.CreateDto(new ServiceDtoInfo(
name: $"{CodeGenUtility.ToPascalCase(httpMethodInfo.ServiceMethod.Name)}Response",
fields: httpResponseInfo.NormalFields.Select(x => x.ServiceField))));
}
internal ServiceInfo(Type serviceType, Type implementationType, ServiceScope scope, object instance, Func <IDependencyResolver, object> creationFunction, InjectionMode injectionMode)
{
ServiceType = serviceType;
if (implementationType != null)
{
ImplementationTypeInfo = ServiceTypeInfo.Get(implementationType);
}
Scope = scope;
Instance = instance;
CreationFunction = creationFunction;
InjectionMode = injectionMode;
}
internal static TObject CreateObject <TObject>(IDependencyResolver dependencyResolver)
where TObject : class, new()
{
var info = ServiceTypeInfo.Get(typeof(TObject));
var dependencies = info.DependencyProperties.Select(x => dependencyResolver.Get(x.PropertyType)).ToArray();
var instance = new TObject();
for (var i = 0; i < dependencies.Length; i++)
{
info.DependencyProperties[i].SetValue(instance, dependencies[i]);
}
return(instance);
}
public override void AddChild(IConfigurationFileElement child)
{
base.AddChild(child);
if (child is IServiceToProxyImplementationElement serviceToProxyImplementation)
{
if (ServiceTypeInfo.Type == serviceToProxyImplementation.ValueTypeInfo.Type)
{
throw new ConfigurationParseException(serviceToProxyImplementation,
$"The types specified in elements '{ConfigurationFileElementNames.ProxyService}' and '{ConfigurationFileElementNames.ServiceToProxy}' cannot be the same. Both elements use specify the type '{ServiceTypeInfo.Type.GetTypeNameInCSharpClass()}'.", this);
}
if (!ServiceTypeInfo.Type.IsAssignableFrom(serviceToProxyImplementation.ValueTypeInfo.Type))
{
throw new ConfigurationParseException(serviceToProxyImplementation,
string.Format("The type specified element '{0}' for service to proxy should be assignable from the type specified element '{1}' for proxy service.",
ConfigurationFileElementNames.ServiceToProxy,
ConfigurationFileElementNames.ProxyService), this);
}
var pluginTypesUsedInProxyService = ServiceTypeInfo.GetUniquePluginTypes();
var pluginTypesUsedInProxiedService = serviceToProxyImplementation.ValueTypeInfo.GetUniquePluginTypes();
if (pluginTypesUsedInProxyService.Count == 0)
{
if (pluginTypesUsedInProxiedService.Count > 0)
{
throw new ConfigurationParseException(serviceToProxyImplementation,
string.Format("Non plugin proxy service '{0}' cannot proxy a plugin service '{1}' which belongs to plugin '{2}'.",
ServiceTypeInfo.TypeCSharpFullName,
serviceToProxyImplementation.ValueTypeInfo,
pluginTypesUsedInProxiedService[0].Assembly.Plugin.Name),
this);
}
}
else
{
if (pluginTypesUsedInProxiedService.Count == 0)
{
throw new ConfigurationParseException(serviceToProxyImplementation,
string.Format("Proxy service '{0}' belongs to plugin '{1}' and cannot proxy a non-plugin service '{1}'.",
ServiceTypeInfo.TypeCSharpFullName,
pluginTypesUsedInProxiedService[0].Assembly.Plugin.Name, serviceToProxyImplementation.ValueTypeInfo),
this);
}
}
_implementations.Add(serviceToProxyImplementation);
}
}
public ActionResult Save_ServiceType(string isOnlyDelete, string ServiceTypeId, string ServiceTypeName, string IsActive)
{
using (Master_Svc.MasterServiceClient iGstSvc = new Master_Svc.MasterServiceClient())
{
ServiceTypeInfo objServiceType = new ServiceTypeInfo();
objServiceType.ServiceTypeId = ServiceTypeId;
objServiceType.ServiceTypeName = ServiceTypeName;
objServiceType.IsActive = IsActive.Trim().ToUpper() == "Y";
if (iGstSvc.Save_ServiceType(isOnlyDelete.Trim().ToUpper() == "Y", objServiceType, ((UserInfo)Session["UserDetails"]), out ErrorMessage))
{
return(Json("Ok", JsonRequestBehavior.AllowGet));
}
return(Json(ErrorMessage, JsonRequestBehavior.AllowGet));
}
}
public static ServiceTypeInfo GetServiceType(Guid guid)
{
var serviceManagementServer = WrapperFactory.Instance.GetServiceManagementServerWrapper(null);
using (serviceManagementServer.BaseAPIServer?.Connection)
{
var serviceTypeXml = serviceManagementServer.GetServiceType(guid);
if (string.IsNullOrEmpty(serviceTypeXml))
{
return(null);
}
else
{
return(ServiceTypeInfo.Create(serviceTypeXml));
}
}
}
private static string GetMemberTypeName(this ServiceTypeInfo type)
{
switch (type.Kind)
{
case ServiceTypeKind.Dto:
return(type.Dto.Name);
case ServiceTypeKind.Enum:
return(type.Enum.Name);
case ServiceTypeKind.Array:
case ServiceTypeKind.Result:
case ServiceTypeKind.Map:
return(type.ValueType.GetMemberTypeName());
}
return(null);
}
private static string GetTypeAsDtoName(ServiceTypeInfo type)
{
var typeKind = type.Kind;
switch (typeKind)
{
case ServiceTypeKind.Dto:
return(type.Dto.Name);
case ServiceTypeKind.Enum:
return(type.Enum.Name);
case ServiceTypeKind.Result:
case ServiceTypeKind.Array:
case ServiceTypeKind.Map:
return(GetTypeAsDtoName(type.ValueType) + typeKind);
default:
return(typeKind.ToString());
}
}
private string RenderFieldType(ServiceTypeInfo fieldType)
{
switch (fieldType.Kind)
{
case ServiceTypeKind.String:
case ServiceTypeKind.Bytes:
case ServiceTypeKind.Enum:
return("string");
case ServiceTypeKind.Boolean:
return("boolean");
case ServiceTypeKind.Double:
case ServiceTypeKind.Int32:
case ServiceTypeKind.Int64:
case ServiceTypeKind.Decimal:
return("number");
case ServiceTypeKind.Object:
return("{ [name: string]: any }");
case ServiceTypeKind.Error:
return("IServiceError");
case ServiceTypeKind.Dto:
return($"I{CodeGenUtility.Capitalize(fieldType.Dto.Name)}");
case ServiceTypeKind.Result:
return($"IServiceResult<{RenderFieldType(fieldType.ValueType)}>");
case ServiceTypeKind.Array:
return($"{RenderFieldType(fieldType.ValueType)}[]");
case ServiceTypeKind.Map:
return($"{{ [name: string]: {RenderFieldType(fieldType.ValueType)} }}");
default:
throw new NotSupportedException("Unknown field type " + fieldType.Kind);
}
}
public static string RenderFieldTypeClass(ServiceTypeInfo typeInfo) =>
typeInfo.Kind switch
{
public bool Save_ServiceType(bool isOnlyDelete, ServiceTypeInfo obj, UserInfo objUserInfo, out string errormsg)
{
return(wscalls.Save_ServiceType(isOnlyDelete, obj, objUserInfo, out errormsg));
}
private static T GetTypeSchema <T>(ServiceTypeInfo type) where T : ISwaggerSchema, new()
{
switch (type.Kind)
{
case ServiceTypeKind.String:
return(new T {
Type = SwaggerSchemaType.String
});
case ServiceTypeKind.Boolean:
return(new T {
Type = SwaggerSchemaType.Boolean
});
case ServiceTypeKind.Double:
return(new T {
Type = SwaggerSchemaType.Number, Format = SwaggerSchemaTypeFormat.Double
});
case ServiceTypeKind.Int32:
return(new T {
Type = SwaggerSchemaType.Integer, Format = SwaggerSchemaTypeFormat.Int32
});
case ServiceTypeKind.Int64:
return(new T {
Type = SwaggerSchemaType.Integer, Format = SwaggerSchemaTypeFormat.Int64
});
case ServiceTypeKind.Decimal:
return(new T {
Type = SwaggerSchemaType.Number, Format = SwaggerSchemaTypeFormat.Decimal
});
case ServiceTypeKind.Bytes:
return(new T {
Type = SwaggerSchemaType.String, Format = SwaggerSchemaTypeFormat.Byte
});
case ServiceTypeKind.Object:
return(new T {
Type = SwaggerSchemaType.Object
});
case ServiceTypeKind.Error:
return(GetErrorSchemaRef <T>());
case ServiceTypeKind.Dto:
return(GetDtoSchemaRef <T>(type.Dto));
case ServiceTypeKind.Enum:
return(GetEnumSchema <T>(type.Enum));
case ServiceTypeKind.Result:
return(GetResultTypeRef <T>(type));
case ServiceTypeKind.Array:
return(GetArrayOfSchema <T>(type.ValueType));
case ServiceTypeKind.Map:
return((T)(object)GetMapOfSchema(type.ValueType));
default:
throw new InvalidOperationException("Unexpected field type kind: " + type.Kind);
}
}
