private void BuildJsonArrayResponse(App app, HttpContext context, BaseRestServiceMethod method, DataCommand command, DataTable dt, JsonWriter json, DataColumnCollection commandColumns)
{
if (app.RestServiceResponseMode == RestServiceResponseMode.IncludeMetaAndError)
{
json.WriteStartObject(); //root
json.WritePropertyName("Data");
}
json.WriteStartArray();
int offset = 0;
int limit = 0;
List <DataRow> rows = GetRowsForResponse(context, method, dt, ref offset, ref limit);
foreach (DataRow row in rows)
{
json.WriteStartObject();
List <DataColumn> columns = GetColumnsForResponse(context, method, commandColumns);
foreach (DataColumn col in columns)
{
json.WritePropertyName(col.ColumnName);
WriteJsonValue(command, json, row, col);
}
json.WriteEndObject();
}
json.WriteEndArray();
if (app.RestServiceResponseMode == RestServiceResponseMode.IncludeMetaAndError)
{
//now write meta
json.WritePropertyName("Meta");
json.WriteStartObject();
json.WritePropertyName("Status");
json.WriteValue("Success");
if (method.EnablePaging)
{
json.WritePropertyName("Limit");
json.WriteValue(limit);
json.WritePropertyName("Offset");
json.WriteValue(offset);
}
json.WritePropertyName("TotalResults");
json.WriteValue(dt.Rows.Count);
json.WriteEndObject();
json.WriteEndObject(); //end root
}
}
private static List <DataColumn> GetColumnsForResponse(HttpContext context, BaseRestServiceMethod method, DataColumnCollection commandColumns)
{
List <DataColumn> columns = new List <DataColumn>();
if (method.EnablePartialResponse)
{
string fieldsValue = null;
//if we have a parameter we can use for partial response
if (!String.IsNullOrEmpty(method.PartialResponseParameter))
{
//set fields for partial response from request
fieldsValue = context.Request[method.PartialResponseParameter];
}
if (String.IsNullOrEmpty(fieldsValue))
{
//this means either we dont have parameter enabled for partial response
//or no partial response fields were passed in
//so lets see if we have any defaults
fieldsValue = method.PartialResponseDefaultFields;
}
if (String.IsNullOrEmpty(fieldsValue))
{
//we still don't have any fields to use for partial response
//so return all fields from data source
columns = commandColumns.Cast <DataColumn>().ToList <DataColumn>();
}
else
{
//we do have fields to use for partial response
//lets split them by commas
//and return only those fields
string[] fields = fieldsValue.Split(',');
for (int i = 0; i < fields.Length; i++)
{
string columnName = fields[i];
if (commandColumns.Contains(columnName))
{
DataColumn col = commandColumns[columnName];
columns.Add(col);
}
}
}
}
else
{
//partial response not supported - return all fields from data source
columns = commandColumns.Cast <DataColumn>().ToList <DataColumn>();
}
return(columns);
}
protected override string GetDisplayText(object value)
{
BaseRestServiceMethod method = (BaseRestServiceMethod)value;
string retVal = String.Empty;
retVal = String.Format("{0} - {1}", method.Action, method.RequestDataCommand);
return(base.GetDisplayText(retVal));
}
private void BuildJsonObjectResponse(App app, HttpContext context, BaseRestServiceMethod method, DataCommand command, DataTable dt, JsonWriter json, DataColumnCollection commandColumns)
{
if (app.RestServiceResponseMode == RestServiceResponseMode.IncludeMetaAndError)
{
json.WriteStartObject(); //root
json.WritePropertyName("Data");
}
if (dt.Rows.Count > 0)
{
DataRow record = dt.Rows[0];
json.WriteStartObject();
List <DataColumn> columns = GetColumnsForResponse(context, method, commandColumns);
foreach (DataColumn col in columns)
{
json.WritePropertyName(col.ColumnName);
WriteJsonValue(command, json, record, col);
}
json.WriteEndObject();
}
else
{
//no value to write
if (app.RestServiceResponseMode == RestServiceResponseMode.IncludeMetaAndError)
{
json.WriteNull(); //end data if no value present
}
}
if (app.RestServiceResponseMode == RestServiceResponseMode.IncludeMetaAndError)
{
//now write meta
json.WritePropertyName("Meta");
json.WriteStartObject();
json.WritePropertyName("Status");
json.WriteValue("Success");
json.WriteEndObject();
json.WriteEndObject(); //end root
}
}
private void BuildXmlItemResponse(App app, HttpContext context, BaseRestServiceMethod method, DataCommand command, DataTable dt, XmlWriter xml, DataColumnCollection commandColumns)
{
if (app.RestServiceResponseMode == RestServiceResponseMode.IncludeMetaAndError)
{
xml.WriteStartElement("Response");
xml.WriteStartElement("Data");
}
if (dt.Rows.Count > 0)
{
DataRow record = dt.Rows[0];
xml.WriteStartElement(Me.EntityName);
List <DataColumn> columns = GetColumnsForResponse(context, method, commandColumns);
foreach (DataColumn col in columns)
{
xml.WriteStartElement(col.ColumnName);
WriteXmlValue(command, xml, record, col);
xml.WriteEndElement();
}
xml.WriteEndElement();
}
else
{
}
if (app.RestServiceResponseMode == RestServiceResponseMode.IncludeMetaAndError)
{
xml.WriteEndElement(); //data
//now write meta
xml.WriteStartElement("Meta");
xml.WriteStartElement("Status");
xml.WriteValue("Success");
xml.WriteEndElement();
xml.WriteEndElement(); //meta
xml.WriteEndElement(); //response
}
}
private void BuildXmlObjectResponse(App app, BaseRestServiceMethod method, XmlDocument doc, XmlWriter xml)
{
if (app.RestServiceResponseMode == RestServiceResponseMode.IncludeMetaAndError)
{
string xmlStructure = @"<Response><Data/><Meta><Status>Success</Status></Meta></Response>";
XmlDocument structure = new XmlDocument();
structure.LoadXml(xmlStructure);
XmlElement data = (XmlElement)structure.SelectSingleNode("/Response/Data");
data.AppendChild(structure.ImportNode(doc.DocumentElement, true));
data.WriteTo(xml);
}
else
{
doc.WriteTo(xml);
}
}
private void BuildJsonXmlObjectResponse(App app, BaseRestServiceMethod method, StringBuilder builder, XmlDocument doc)
{
if (app.RestServiceResponseMode == RestServiceResponseMode.IncludeMetaAndError)
{
string xmlStructure = @"<Response><Data/><Meta><Status>Success</Status></Meta></Response>";
XmlDocument structure = new XmlDocument();
structure.LoadXml(xmlStructure);
XmlElement data = (XmlElement)structure.SelectSingleNode("/Response/Data");
data.AppendChild(structure.ImportNode(doc.DocumentElement, true));
builder.Append(JsonConvert.SerializeXmlNode(data));
}
else
{
builder.Append(JsonConvert.SerializeXmlNode(doc));
}
}
private static List <DataRow> GetRowsForResponse(HttpContext context, BaseRestServiceMethod method, DataTable dt, ref int offset, ref int limit)
{
List <DataRow> rows = new List <DataRow>();
if (method.EnablePaging)
{
offset = 0;
limit = dt.Rows.Count;
if (method.EnableDefaultLimit)
{
limit = method.PagingLimitDefault;
}
//if we have a parameter we can use for offset
if (!String.IsNullOrEmpty(method.PagingOffsetParameter))
{
//set offset from request
string offsetValue = context.Request[method.PagingOffsetParameter];
if (!String.IsNullOrEmpty(offsetValue))
{
int.TryParse(offsetValue, out offset);
}
}
string limitValue = null;
//if we have a parameter we can use for limit
if (!String.IsNullOrEmpty(method.PagingLimitParameter))
{
//set limit from request
limitValue = context.Request[method.PagingLimitParameter];
if (!String.IsNullOrEmpty(limitValue))
{
int.TryParse(limitValue, out limit);
}
}
if (offset < 0)
{
offset = 0;
}
if (limit < 0)
{
limit = dt.Rows.Count - offset;
}
if ((limit + offset) > dt.Rows.Count)
{
limit = dt.Rows.Count - offset;
if (limit < 0)
{
limit = 0;
}
}
//now that we have limits and offsets
rows = dt.Select().ToList <DataRow>().Skip(offset).Take(limit).ToList <DataRow>();
}
else
{
rows = dt.Rows.Cast <DataRow>().ToList <DataRow>();
}
return(rows);
}
private void BuildXmlListResponse(App app, HttpContext context, BaseRestServiceMethod method, DataCommand command, DataTable dt, XmlWriter xml, DataColumnCollection commandColumns)
{
if (app.RestServiceResponseMode == RestServiceResponseMode.IncludeMetaAndError)
{
xml.WriteStartElement("Response");
xml.WriteStartElement("Data");
}
xml.WriteStartElement(Me.EntityCollectionName);
int offset = 0; int limit = 0;
List <DataRow> rows = GetRowsForResponse(context, method, dt, ref offset, ref limit);
foreach (DataRow row in rows)
{
xml.WriteStartElement(Me.EntityName);
List <DataColumn> columns = GetColumnsForResponse(context, method, commandColumns);
foreach (DataColumn col in columns)
{
xml.WriteStartElement(col.ColumnName);
WriteXmlValue(command, xml, row, col);
xml.WriteEndElement();
}
xml.WriteEndElement();
}
xml.WriteEndElement();
if (app.RestServiceResponseMode == RestServiceResponseMode.IncludeMetaAndError)
{
xml.WriteEndElement(); //data
//now write meta
xml.WriteStartElement("Meta");
xml.WriteStartElement("Status");
xml.WriteValue("Success");
xml.WriteEndElement();
if (method.EnablePaging)
{
xml.WriteStartElement("Limit");
xml.WriteValue(limit);
xml.WriteEndElement();
xml.WriteStartElement("Offset");
xml.WriteValue(offset);
xml.WriteEndElement();
}
xml.WriteStartElement("TotalResults");
xml.WriteValue(dt.Rows.Count);
xml.WriteEndElement();
xml.WriteEndElement(); //meta
xml.WriteEndElement(); //response
}
}
public void ProcessRequest(HttpContext context)
{
App app = CodeTorch.Core.Configuration.GetInstance().App;
StringBuilder builder = new StringBuilder();
StringWriter writer = new StringWriter(builder);
try
{
if (Me == null)
{
if (context.Request.Path.ToLower().EndsWith("xml"))
{
Format = "xml";
}
throw new ApplicationException("No service has been configured for this path");
}
DataCommand command = null;
RestServiceMethodReturnTypeEnum returnType = RestServiceMethodReturnTypeEnum.None;
//collect parameters
DataTable dt = null;
XmlDocument doc = null;
context.Response.TrySkipIisCustomErrors = true;
if (Format.ToLower() == "json")
{
context.Response.ContentType = "application/json";
}
else
{
context.Response.ContentType = "text/xml";
}
BaseRestServiceMethod method = Me.Methods.Where(i => (i.Action.ToString() == HttpContext.Current.Request.HttpMethod)).SingleOrDefault();
if (method != null)
{
//pass parameters - minus dbcommand parameters to datacommand
DataCommandService dataCommandDB = DataCommandService.GetInstance();
if (String.IsNullOrEmpty(method.RequestDataCommand))
{
throw new ApplicationException(String.Format("Request Data Command has not been configured for this service - {0}", Me.Name));
}
command = DataCommand.GetDataCommand(method.RequestDataCommand);
if (command == null)
{
throw new ApplicationException(String.Format("Request Data Command - {0} - could not be found in configuration", method.RequestDataCommand));
}
List <ScreenDataCommandParameter> parameters = GetPopulatedCommandParameters(method.RequestDataCommand, method.DataCommands, null);
returnType = method.ReturnType;
//execute request datacommand and return data if applicable
switch (command.ReturnType)
{
case DataCommandReturnType.Integer:
object newID = dataCommandDB.ExecuteDataCommand(method.RequestDataCommand, parameters);
if (method is PostRestServiceMethod)
{
DataCommand postCommand = null;
PostRestServiceMethod postMethod = (PostRestServiceMethod)method;
returnType = postMethod.ReturnType;
if (!String.IsNullOrEmpty(postMethod.ResponseDataCommand))
{
postCommand = DataCommand.GetDataCommand(postMethod.ResponseDataCommand);
if (postCommand == null)
{
throw new ApplicationException(String.Format("Response Data Command - {0} - could not be found in configuration", postMethod.ResponseDataCommand));
}
parameters = GetPopulatedCommandParameters(postMethod.ResponseDataCommand, method.DataCommands, newID);
switch (returnType)
{
case RestServiceMethodReturnTypeEnum.DataRow:
case RestServiceMethodReturnTypeEnum.DataTable:
dt = dataCommandDB.GetDataForDataCommand(postMethod.ResponseDataCommand, parameters);
break;
case RestServiceMethodReturnTypeEnum.Xml:
doc = dataCommandDB.GetXmlDataForDataCommand(postMethod.ResponseDataCommand, parameters);
break;
}
}
}
if (method is PutRestServiceMethod)
{
PutRestServiceMethod putMethod = (PutRestServiceMethod)method;
returnType = putMethod.ReturnType;
if (!String.IsNullOrEmpty(putMethod.ResponseDataCommand))
{
parameters = GetPopulatedCommandParameters(putMethod.ResponseDataCommand, method.DataCommands, newID);
dt = dataCommandDB.GetDataForDataCommand(putMethod.ResponseDataCommand, parameters);
}
}
break;
case DataCommandReturnType.Xml:
doc = dataCommandDB.GetXmlDataForDataCommand(method.RequestDataCommand, parameters);
break;
default:
dt = dataCommandDB.GetDataForDataCommand(method.RequestDataCommand, parameters);
break;
}
//in certain cases execute response datacommand
}
else
{
throw new NotSupportedException();
}
//get data if any
if (
((dt != null) && (returnType == RestServiceMethodReturnTypeEnum.DataTable)) ||
((dt != null) && (returnType == RestServiceMethodReturnTypeEnum.DataRow)) ||
((doc != null) && (returnType == RestServiceMethodReturnTypeEnum.Xml))
)
{
if (Format.ToLower() == "json")
{
using (JsonWriter json = new JsonTextWriter(writer))
{
DataColumnCollection columns = null;
switch (returnType)
{
case RestServiceMethodReturnTypeEnum.DataTable:
columns = dt.Columns;
BuildJsonArrayResponse(app, context, method, command, dt, json, columns);
break;
case RestServiceMethodReturnTypeEnum.DataRow:
columns = dt.Columns;
BuildJsonObjectResponse(app, context, method, command, dt, json, columns);
break;
case RestServiceMethodReturnTypeEnum.Xml:
BuildJsonXmlObjectResponse(app, method, builder, doc);
break;
}
}
}
else
{
//xml
using (XmlWriter xml = new XmlTextWriter(writer))
{
DataColumnCollection columns = null;
switch (method.ReturnType)
{
case RestServiceMethodReturnTypeEnum.DataTable:
columns = dt.Columns;
BuildXmlListResponse(app, context, method, command, dt, xml, columns);
break;
case RestServiceMethodReturnTypeEnum.DataRow:
columns = dt.Columns;
BuildXmlItemResponse(app, context, method, command, dt, xml, columns);
break;
case RestServiceMethodReturnTypeEnum.Xml:
BuildXmlObjectResponse(app, method, doc, xml);
break;
}
}
}
}
//perform any special post processing
//string url = ((System.Web.Routing.Route)(RouteData.Route)).Url;
//context.Response.Write("From the handler at " + DateTime.Now + " - " + Me.Name + " - " + url + " - " + HttpContext.Current.Request.HttpMethod);
//context.Response.ContentType = "text/xml";
//context.Response.Write(dt.DataSet.GetXml());
context.Response.StatusCode = (int)HttpStatusCode.OK;
context.Response.Write(builder.ToString());
}
catch (CodeTorchException cex)
{
builder = new StringBuilder();
RestServiceException exception = new RestServiceException();
exception.Status = (int)HttpStatusCode.InternalServerError;
exception.Message = cex.Message;
exception.MoreInfo = cex.MoreInfo;
exception.ErrorCode = cex.ErrorCode;
context.Response.TrySkipIisCustomErrors = true;
context.Response.StatusCode = exception.Status;
SerializeRestException(app, context, builder, writer, exception);
}
catch (Exception ex)
{
builder = new StringBuilder();
RestServiceException exception = new RestServiceException();
exception.Status = (int)HttpStatusCode.InternalServerError;
exception.Message = ex.Message;
context.Response.TrySkipIisCustomErrors = true;
context.Response.StatusCode = exception.Status;
SerializeRestException(app, context, builder, writer, exception);
}
}
