Web Development

[HttpPost]
public Response<Guid> AddRuleDefinition(RuleDefinitionEntity entity)
{
    var response = new Response<Guid>();

    try
    {
        IRulesBL bl = GetBL();
        response.Data = bl.AddRuleDefinition(entity);
    }
    catch (Exception e)
    {
        response.Exception = e;
    }

    return response;
}

[HttpDelete]
public Response DeleteRuleDefinition([FromUri] string id)
{
    var response = new Response();

    try
    {
        IRulesBL bl = GetBL();
        bl.DeleteRuleDefinition(new Guid(id));  // CONVERT THE STRING BACK TO A GUID
    }
    catch (Exception e)
    {
        response.Exception = e;
    }

    return response;
}

[HttpPost]
public Response<List<string>> ExecuteRuleGroup(List<AssayResultEntity> results, string trigger)
{
    var response = new Response<List<string>>();

    try
    {
        IRulesBL bl = GetBL();
        response.Data = bl.ExecuteRuleGroup(trigger, results);
    }
    catch (Exception e)
    {
        response.Exception = e;
    }

    return response;
}

public class WebAPIExecutor
{
    private RestClient client;

<pre>
private RestRequest request;

public string ServerAddress { get; private set; }

public string URL { get; private set; }

public WebAPIExecutor(CredentialsEntity credentials, string ipAddress, string controller, Method method = Method.POST)
{
    ServerAddress = string.Format("<a href="http://{0}/api">http://{0}/api</a>", ipAddress);

    client = new RestClient(ServerAddress);

    client.AddHandler("text/plain", new JsonDeserializer());

    request = new RestRequest(controller, method)
    {
        RequestFormat = DataFormat.Json
    };
}

public void AddParameter(object value, string name = "")
{
    if (value == null)
    {
        throw new ArgumentNullException("value");
    }

    Type type = value.GetType();
    bool isPrimitive = type.IsPrimitive;

    if (isPrimitive || type == typeof(string) || type == typeof(decimal))
    {
        if (string.IsNullOrEmpty(name) && request.Method == Method.GET)
        {
            throw new ArgumentNullException("Parameter 'Name' cannot be empty for Get requests");
        }

        request.AddParameter(name, value);
    }
    else
    {
        request.AddBody(value);
    }
}

public async Task<T> ExecuteAsync<T>() where T : new()

public async Task<Response<Guid>> AddRuleDefinitionAsync(RuleDefinitionEntity entity)
{
    var webAPIExecutor = new WebAPIExecutor(Credentials, ServerUrl, "/Rules/AddRuleDefinition/", Method.POST);
    webAPIExecutor.AddParameter(entity, "entity");
    return await webAPIExecutor.ExecuteAsync<Response<Guid>>();
}

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        config.MapHttpAttributeRoutes();

        config.Routes.MapHttpRoute(
            name: "DefaultApi",
            routeTemplate: "api/{controller}/{action}/{id}",
            defaults: new { id = RouteParameter.Optional });
    }
}

public class WebApiApplication : System.Web.HttpApplication
{
    protected void Application_Start()
    {
        GlobalConfiguration.Configuration.MessageHandlers.Add(new APIKeyHandler());
        GlobalConfiguration.Configuration.MessageHandlers.Add(new AuthHandler());

        GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
        GlobalConfiguration.Configuration.Formatters.Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);

        GlobalConfiguration.Configure(WebApiConfig.Register);
    }
}

[HttpDelete]
public Response DeleteRuleDefinition(Guid id)
{
    var response = new Response();

    try
    {
        IRulesBL bl = GetBL();
        bl.DeleteRuleDefinition(id);
    }
    catch (Exception e)
    {
        response.Exception = e;
    }

    return response;
}

public async Task<Response> DeleteRuleDefinitionAsync(Guid id)
{
    var webAPIExecutor = new WebAPIExecutor(Credentials, ServerUrl, "/Rules/DeleteRuleDefinition/", Method.GET);
    webAPIExecutor.AddParameter(id, "id");
    return await webAPIExecutor.ExecuteAsync<Response>();
}

[HttpDelete]
public Response DeleteRuleDefinition(string id)
{
    var response = new Response();

    try
    {
        IRulesBL bl = GetBL();
        bl.DeleteRuleDefinition(new Guid(id));        // CONVERT STRING TO GUID HERE
    }
    catch (Exception e)
    {
        response.Exception = e;
    }

    return response;
}

public async Task<Response> DeleteRuleDefinitionAsync(Guid id)
{
    var webAPIExecutor = new WebAPIExecutor(Credentials, ServerUrl, "/Rules/DeleteRuleDefinition/", Method.GET);
    webAPIExecutor.AddParameter(id.ToString(), "id");  // < ==========
    return await webAPIExecutor.ExecuteAsync<Response<List<RuleDefintionEntity>>>();
}