/// <summary>
/// This method selects the appropriate node and creates a Body content.
/// </summary>
/// <param name="context">The current context.</param>
public override void OutputPrepare(ContentCompilerContext context)
{
try
{
string path = context.Request.Settings.OutputColl[0].Output;
string outputType = context.Request.Settings.OutputColl[0].OutputType;
string data;
if (path == null || outputType == "xslt")
data = context.ModelData.Payload.InnerXml;
else
{
data = context.ModelData.ExtractPathData(path);
}
if (data == null)
{
context.Response.Status = CH.HTTPCodes.ExpectationFailed_417;
context.Response.Substatus = "Node resolution error -> " + context.Request.Data.ResponseOutput;
return;
}
context.Response.Body = PrepareBody(context, data);
context.Response.Body.ContentType = context.Request.Settings.OutputColl[0].OutputMIMEType;
context.Response.Status = CH.HTTPCodes.OK_200;
}
catch (Exception ex)
{
context.Response.Body = null;
context.Response.Status = CH.HTTPCodes.InternalServerError_500;
context.Response.Substatus = ex.Message;
}
}
public override void Finish(ContentCompilerContext context)
{
if (context.Response.Status == CH.HTTPCodes.Continue_100)
context.Response.Status = CH.HTTPCodes.BadRequest_400;
}
/// <summary>
///
/// </summary>
/// <param name="context">The current context.</param>
public override void ModelTemplateCompile(ContentCompilerContext context)
{
byte[] blob = context.Template.Transform(context.Request.Data);
Model contentModel = context.ContextSettings.PoolManager.GetPoolManager<Model>().Get();
contentModel.Load(blob, 0, blob.Length);
contentModel.IDContent = Guid.NewGuid();
contentModel.IDVersion = Guid.NewGuid();
context.ModelData = contentModel;
}
/// <summary>
/// This method loads and validates the script.
/// </summary>
/// <param name="context">The current context.</param>
public override void ModelTemplateLoad(ContentCompilerContext context)
{
string status=CH.HTTPCodes.OK_200;
string templateRef = context.Request.Settings.Template;
ModelTemplate template = context.TemplateGet("name", templateRef);
if (template != null)
status = CH.HTTPCodes.OK_200;
if (status != CH.HTTPCodes.OK_200)
throw new InvalidTemplateCCException(templateRef + " could not be found.");
context.Template = template;
}
/// <summary>
/// This method prepares the HTTP body based on the browser content encoding settings.
/// </summary>
/// <param name="context">The current compile context.</param>
/// <param name="blob">The UTF-8 formatted byte array.</param>
/// <returns>Returns a ContentCompilerMessageFragmentBody object containing the prepared output binary data.</returns>
protected virtual ContentCompilerMessageFragmentBody PrepareBody(ContentCompilerContext context, byte[] blob)
{
ContentCompilerMessageFragmentBody
body = context.GetObjectPool<ContentCompilerMessageFragmentBody>().Get();
switch (context.Request.Data.RequestPreferredCompression)
{
case "gzip":
using (MemoryStream ms = new MemoryStream())
{
using (Stream gz = new GZipStream(ms, CompressionMode.Compress, true))
{
gz.Write(blob, 0, blob.Length);
gz.Close();
}
ms.Position = 0;
body.Load(ms);
}
body.ContentEncoding = "gzip";
break;
case "deflate":
using (MemoryStream ms = new MemoryStream())
{
using (Stream gz = new DeflateStream(ms, CompressionMode.Compress, true))
{
gz.Write(blob, 0, blob.Length);
gz.Close();
}
ms.Position = 0;
body.Load(ms);
}
body.ContentEncoding = "deflate";
break;
default:
body.Load(blob, 0, blob.Length);
break;
}
blob = null;
body.ContentType = context.Request.Data.ResponseOutputMIMEType;
return body;
}
/// <summary>
/// This method selects the appropriate output style.
/// </summary>
/// <param name="context">The current context.</param>
public override void OutputSelect(ContentCompilerContext context)
{
//string id = context.Request.Data.ResponseOutputType.ToLower();
string id = context.Request.Settings.OutputColl[0].OutputType;
switch (id)
{
case "xpath":
context.ChangeState("OutputXPath");
break;
case "xslt":
context.ChangeState("OutputTransform");
break;
case "mime":
context.ChangeState("OutputMime");
break;
default:
throw new InvalidOutputCCException(@"Output format """ + id + @""" not recognised.");
}
}
public override void Initialize(ContentCompilerContext context)
{
//base.Initialize(context);
}
public override void RequestValidate(ContentCompilerContext context)
{
context.ChangeState("ModelDataCompiler");
}
public virtual void OutputComplete(ContentCompilerContext context)
{
throw new NotImplementedException("ContentCompilerState->OutputPrepare is not implemented: " + this.ToString());
}
public virtual void Finish(ContentCompilerContext context)
{
throw new NotImplementedException("ContentCompilerState->Finalize is not implemented " + this.ToString());
}
public virtual void ModelTemplateCompile(ContentCompilerContext context)
{
throw new NotImplementedException("ContentCompilerState->ModelTemplateCompile is not implemented: " + this.ToString());
}
public virtual void ModelDataLoadInserts(ContentCompilerContext context)
{
throw new NotImplementedException("ContentCompilerState->ModelDataLoadInserts is not implemented: " + this.ToString());
}
public virtual void RequestValidate(ContentCompilerContext context)
{
throw new NotImplementedException("ContentCompilerState->RequestValidate is not implemented: " + this.ToString());
}
public virtual void Initialize(ContentCompilerContext context)
{
throw new NotImplementedException("ContentCompilerState->Initialize is not implemented: " + this.ToString());
}
/// <summary>
/// This method inserts incoming data in to the model.
/// </summary>
/// <param name="context">The current context.</param>
public override void ModelDataLoadInserts(ContentCompilerContext context)
{
Insert insert = null;
try
{
insert = context.GetObjectPool<Insert>().Get();
foreach (XmlElement element in context.ModelData.DataNodes())
{
insert.Reset(element);
string status;
if (insert.ReferenceValue != null && insert.ReferenceValue != "")
{
Content outData = null;
try
{
throw new NotImplementedException();
//status = context.CDSHelper.Execute(insert.EntityType,
// CDSData.Get(CDSAction.Read, insert.ReferenceType, insert.ReferenceValue),
// out outData);
if (status != CH.HTTPCodes.OK_200 && !insert.PermitError)
throw new ContentCompilerException(
string.Format("Data load error: {0}/{1}", insert.ReferenceType, insert.ReferenceValue));
insert.ResponseStatus = status;
if (outData != null)
{
XmlDocumentFragment frag = element.OwnerDocument.CreateDocumentFragment();
frag.InnerXml = ((XmlDocumentContentBase)outData).Payload.LastChild.OuterXml;
element.AppendChild(frag);
}
else if (!insert.PermitError)
throw new ArgumentNullException("CDS data is null.");
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (outData != null && outData.ObjectPoolCanReturn)
outData.ObjectPoolReturn();
}
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (insert != null && insert.ObjectPoolCanReturn)
insert.ObjectPoolReturn();
}
}
public override void OutputComplete(ContentCompilerContext context)
{
//Nothing set
}
/// <summary>
/// This method prepares the HTTP body based on the browser content encoding settings.
/// </summary>
/// <param name="context">The current compile context.</param>
/// <param name="data">The transformed data.</param>
/// <returns>Returns a ContentCompilerMessageFragmentBody object containing the prepared output binary data.</returns>
protected virtual ContentCompilerMessageFragmentBody PrepareBody(ContentCompilerContext context, string data)
{
byte[] blob = Encoding.UTF8.GetBytes(data);
return PrepareBody(context, blob);
}
