/// <inheritdoc />
/// <summary>
/// Create a poll template Poll templates define a type of poll and the properties they have. <br><br><b>Permissions Needed:</b> TEMPLATE_ADMIN
/// </summary>
/// <param name="pollTemplateResource">The poll template resource object</param>
public void CreatePollTemplate(TemplateResource pollTemplateResource)
{
mWebCallEvent.WebPath = "/media/polls/templates";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(pollTemplateResource); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mCreatePollTemplateStartTime = DateTime.Now;
mWebCallEvent.Context = mCreatePollTemplateResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.POST;
KnetikLogger.LogRequest(mCreatePollTemplateStartTime, "CreatePollTemplate", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
public static string Render(TemplateResource templateResource, [CanBeNull] object model, ILogger logger = null)
{
var assembly = typeof(IBuildScriptGenerator).Assembly;
using (var stream = assembly.GetManifestResourceStream(templateResource.Name))
{
if (stream == null)
{
logger?.LogError(
"Could not get resource {resourceName}. Available resources: {availableResourceNames}",
templateResource.Name,
string.Join("|", assembly.GetManifestResourceNames()));
}
using (TextReader tplReader = new StreamReader(stream))
using (logger?.LogTimedEvent(
"RenderTemplate",
new Dictionary <string, string> {
{ "templateName", templateResource.Name }
}))
{
return(RenderString(tplReader.ReadToEnd(), model));
}
}
}
public async Task <IActionResult> Export([FromRoute] string templateId, [FromQuery] string version)
{
ApiResponse <TemplateResource> result;
if (!string.IsNullOrWhiteSpace(version))
{
result = await _client.GetTemplateVersion(templateId, version);
}
else
{
result = await _client.GetTemplate(templateId);
}
if (result.StatusCode.IsSuccess())
{
TemplateResource template = result.Content;
string templateJson = result.Content.TemplateJson;
byte[] templateBytes = !string.IsNullOrWhiteSpace(templateJson)
? Encoding.ASCII.GetBytes(templateJson)
: new byte[] { };
string fileName =
$"template-{template.FundingStreamId}-{template.FundingPeriodId}-{template.MajorVersion}-{template.MinorVersion}.json";
Response.Headers[HeaderNames.ContentDisposition] = new ContentDisposition
{
FileName = fileName,
DispositionType = DispositionTypeNames.Inline,
Inline = true
}.ToString();
return(new FileContentResult(templateBytes, "application/json"));
}
return(StatusCode((int)result.StatusCode));
}
public void SetUp()
{
var source1 = new TestSource
{
Name = "-artist-",
GetAllItemsFunc = c => new[]
{
new DynamicItem("beatles", new [] { new ContextItem("artist-id", "1") }),
new DynamicItem("beach-boys", new [] { new ContextItem("artist-id", "2") })
}
};
var source2 = new TestSource
{
Name = "-album-",
GetAllItemsFunc = c =>
{
return(c.Any(i => i.Name == "artist-id" && i.Value == "1")
? new[] { new DynamicItem("revolver") }
: new[] { new DynamicItem("pet-sounds") });
}
};
var dynamicSourceProvider = MockRepository.GenerateMock <IDynamicSourceProvider>();
dynamicSourceProvider.Stub(p => p.Get("-artist-")).Return(source1);
dynamicSourceProvider.Stub(p => p.Get("-album-")).Return(source2);
var pathInstanceBuilder = new PathInstanceBuilder(dynamicSourceProvider);
var template = new Template(new[] { "static", "-artist-", "-album-" });
template.BuildInstancePaths(pathInstanceBuilder);
this.resource = new TemplateResourceBuilder().Build(template) as TemplateResource;
}
public bool DoesBackendReferenceNamedValue(TemplateResource namedValueResource, BackendTemplateResource backendTemplateResource)
{
string namedValue = (namedValueResource as PropertyTemplateResource).properties.value;
return(namedValue == backendTemplateResource.properties.url ||
namedValue == backendTemplateResource.properties.description ||
namedValue == backendTemplateResource.properties.title);
}
public void SetUp()
{
var dynamicSourceProvider = MockRepository.GenerateMock <IDynamicSourceProvider>();
var pathInstanceBuilder = new PathInstanceBuilder(dynamicSourceProvider);
var template = new Template(Enumerable.Empty <string>());
template.BuildInstancePaths(pathInstanceBuilder);
this.resource = new TemplateResourceBuilder().Build(template) as TemplateResource;
}
[DataRow("</sc</script>ript>")] // none of these is somehow special, just want to take a bit more of them
public void TestResources(string forbiddenString)
{
Assert.ThrowsException <Exception>(() => new TemplateResource(forbiddenString));
Assert.ThrowsException <Exception>(() => new InlineScriptResource(forbiddenString));
var template = new TemplateResource("");
Assert.ThrowsException <Exception>(() => template.Template = forbiddenString);
var inlineScript = new InlineScriptResource("");
Assert.ThrowsException <Exception>(() => inlineScript.Code = forbiddenString);
}
private void OnUpdatePollTemplateResponse(KnetikRestResponse response)
{
if (!string.IsNullOrEmpty(response.Error))
{
throw new KnetikException("Error calling UpdatePollTemplate: " + response.Error);
}
UpdatePollTemplateData = (TemplateResource)KnetikClient.Deserialize(response.Content, typeof(TemplateResource), response.Headers);
KnetikLogger.LogResponse(mUpdatePollTemplateStartTime, "UpdatePollTemplate", string.Format("Response received successfully:\n{0}", UpdatePollTemplateData));
if (UpdatePollTemplateComplete != null)
{
UpdatePollTemplateComplete(response.ResponseCode, UpdatePollTemplateData);
}
}
// this function generate apiTemplate for single api with all its revisions
public async Task <Template> GenerateAPIRevisionTemplateAsync(string currentRevision, List <string> revList, string apiName, Extractor exc)
{
// generate apiTemplate
Template armTemplate = GenerateEmptyTemplateWithParameters(exc.policyXMLBaseUrl, exc.policyXMLSasToken);
List <TemplateResource> templateResources = new List <TemplateResource>();
Console.WriteLine("{0} APIs found ...", revList.Count().ToString());
List <TemplateResource> apiResources = await GenerateSingleAPIResourceAsync(apiName, exc.sourceApimName, exc.resourceGroup, exc.fileFolder, exc.policyXMLBaseUrl, exc.policyXMLSasToken);
templateResources.AddRange(apiResources);
foreach (string curApi in revList)
{
// should add current api to dependsOn to those revisions that are not "current"
if (curApi.Equals(currentRevision))
{
// add current API revision resource to template
apiResources = await GenerateCurrentRevisionAPIResourceAsync(curApi, exc.sourceApimName, exc.resourceGroup, exc.fileFolder, exc.policyXMLBaseUrl, exc.policyXMLSasToken);
templateResources.AddRange(apiResources);
}
else
{
// add other API revision resources to template
apiResources = await GenerateSingleAPIResourceAsync(curApi, exc.sourceApimName, exc.resourceGroup, exc.fileFolder, exc.policyXMLBaseUrl, exc.policyXMLSasToken);
// make current API a dependency to other revisions, in case destination apim doesn't have the this API
TemplateResource apiResource = apiResources.FirstOrDefault(resource => resource.type == ResourceTypeConstants.API) as TemplateResource;
List <TemplateResource> newResourcesList = ExtractorUtils.removeResourceType(ResourceTypeConstants.API, apiResources);
List <string> dependsOn = apiResource.dependsOn.ToList();
dependsOn.Add($"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]");
apiResource.dependsOn = dependsOn.ToArray();
newResourcesList.Add(apiResource);
templateResources.AddRange(newResourcesList);
}
}
armTemplate.resources = templateResources.ToArray();
return(armTemplate);
}
public void SetUp()
{
var dynamicSourceProvider = MockRepository.GenerateMock <IDynamicSourceProvider>();
var pathInstanceBuilder = new PathInstanceBuilder(dynamicSourceProvider);
var template = new Template(new[] { "test", "path" }, new IComponent[]
{
new Atom("atom 0", new[]
{
new Property("property 0", "property 0 type", new FixedPropertyValue("property 0 value")),
new Property("property 1", "property 1 type", new InheritedPropertyValue("property 1 key")),
}),
new Container("container 1", components: new[] { new Atom("atom 1.0") }),
new Widget("widget 2", areas: new[] { new Area("area 1", new[] { new Atom("atom 2.0.0") }), })
});
template.BuildInstancePaths(pathInstanceBuilder);
this.resource = new TemplateResourceBuilder().Build(template) as TemplateResource;
}
/// <summary>
/// Loads a set of files that comprise the parts of a single template
/// </summary>
/// <param name="fileNames">The files to load</param>
/// <param name="parser">The parser to use to parse the template files</param>
/// <param name="templatePath">Optional template path registers the template
/// with the Name Manager. Also causes the template to be periodically
/// reloaded</param>
/// <returns>The template that was loaded</returns>
public ITemplate LoadFileSet(string[] fileNames, ITemplateParser parser, string templatePath = null)
{
var resources = new TemplateResource[fileNames.Length];
for (var i = 0; i < fileNames.Length; i++)
{
resources[i] = new TemplateResource
{
Content = LoadFileContents(fileNames[i], out Encoding encoding)
};
resources[i].Encoding = encoding;
resources[i].ContentType = ContentTypeFromExt(Path.GetExtension(fileNames[i]));
}
var template = parser.Parse(resources, Package);
if (!string.IsNullOrEmpty(templatePath))
{
_nameManager.Register(template, templatePath);
var templateInfo = new TemplateInfo
{
FileNames = fileNames,
Parser = parser,
TemplatePath = templatePath,
Checksum = new byte[fileNames.Length][]
};
for (var i = 0; i < fileNames.Length; i++)
{
templateInfo.Checksum[i] = CalculateChecksum(resources[i].Content);
}
Reload(templateInfo);
}
template.IsStatic = !ReloadInterval.HasValue;
return(template);
}
/// <inheritdoc />
/// <summary>
/// Update a poll template <b>Permissions Needed:</b> TEMPLATE_ADMIN
/// </summary>
/// <param name="id">The id of the template</param>
/// <param name="pollTemplateResource">The poll template resource object</param>
public void UpdatePollTemplate(string id, TemplateResource pollTemplateResource)
{
// verify the required parameter 'id' is set
if (id == null)
{
throw new KnetikException(400, "Missing required parameter 'id' when calling UpdatePollTemplate");
}
mWebCallEvent.WebPath = "/media/polls/templates/{id}";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "id" + "}", KnetikClient.ParameterToString(id));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(pollTemplateResource); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mUpdatePollTemplateStartTime = DateTime.Now;
mWebCallEvent.Context = mUpdatePollTemplateResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.PUT;
KnetikLogger.LogRequest(mUpdatePollTemplateStartTime, "UpdatePollTemplate", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
private void Reload(TemplateInfo info)
{
if (!ReloadInterval.HasValue)
{
return;
}
if (_reloadList == null)
{
_reloadList = new List <TemplateInfo> {
info
}
}
;
else
{
lock (_reloadList) _reloadList.Add(info);
}
if (_reloadThread == null)
{
_reloadThread = new Thread(() =>
{
while (true)
{
try
{
var interval = ReloadInterval;
if (!interval.HasValue)
{
Thread.Sleep(1000);
continue;
}
Thread.Sleep(interval.Value);
int count;
lock (_reloadList) count = _reloadList.Count;
Exception exception = null;
for (var i = 0; i < count; i++)
{
TemplateInfo templateInfo;
lock (_reloadList)
templateInfo = _reloadList[i];
try
{
var modified = false;
var resources = new TemplateResource[templateInfo.FileNames.Length];
for (var j = 0; j < templateInfo.FileNames.Length; j++)
{
var fileName = templateInfo.FileNames[j];
resources[j] = new TemplateResource
{
Content = LoadFileContents(fileName, out Encoding encoding),
ContentType = ContentTypeFromExt(Path.GetExtension(fileName))
};
resources[j].Encoding = encoding;
var checksum = CalculateChecksum(resources[j].Content);
if (checksum.Length != templateInfo.Checksum[j].Length)
{
templateInfo.Checksum[j] = checksum;
modified = true;
}
else
{
for (var k = 0; k < checksum.Length; k++)
{
if (checksum[k] != templateInfo.Checksum[j][k])
{
templateInfo.Checksum[j] = checksum;
modified = true;
break;
}
}
}
}
if (modified)
{
var template = templateInfo.Parser.Parse(resources, Package);
_nameManager.Register(template, templateInfo.TemplatePath);
}
}
catch (ThreadAbortException)
{
throw;
}
catch (Exception ex)
{
var message = templateInfo.FileNames.Aggregate("Failed to load template files", (m, f) => m + " '" + f + "'") + ". " + ex.Message;
exception = new Exception(message, ex);
Trace.WriteLine(message);
}
}
if (exception != null)
{
throw exception;
}
}
catch (ThreadAbortException)
{
return;
}
catch (Exception ex)
{
Trace.WriteLine("Excepton thrown reloading templates. " + ex.Message);
Thread.Sleep(1000);
}
}
})
{
Name = "Template file reload",
IsBackground = true,
Priority = ThreadPriority.BelowNormal
};
_reloadThread.Start();
}
}
private void ParseResource(
TemplateResource resource,
ITemplateDefinition templateDefinition,
IPackage package)
{
var encoding = resource.Encoding ?? Encoding.UTF8;
var text = encoding.GetString(resource.Content);
var section = "--html";
var newSection = true;
var blankLineCount = 0;
var lines = text
.Replace("\r", string.Empty)
.Split('\n')
.Select(s => s.Trim());
foreach (var line in lines)
{
if (line.StartsWith("--"))
{
section = line.ToLower().Trim();
newSection = true;
blankLineCount = 0;
continue;
}
if (line.Length == 0)
{
if (!newSection)
{
blankLineCount++;
}
continue;
}
if (section.StartsWith("--javascript"))
{
for (var i = 0; i < blankLineCount; i++)
{
templateDefinition.AddScriptLine(string.Empty);
}
templateDefinition.AddScriptLine(line);
}
else if (section.StartsWith("--css"))
{
for (var i = 0; i < blankLineCount; i++)
{
templateDefinition.AddStyleLine(string.Empty);
}
templateDefinition.AddStyleLine(line);
}
else if (section.StartsWith("--head"))
{
for (var i = 0; i < blankLineCount; i++)
{
templateDefinition.AddHeadLine(string.Empty);
}
templateDefinition.AddHeadLine(line);
}
else if (section.StartsWith("--init"))
{
for (var i = 0; i < blankLineCount; i++)
{
templateDefinition.AddInitializationLine(string.Empty);
}
templateDefinition.AddInitializationLine(line);
}
else if (section.StartsWith("--html"))
{
for (var i = 0; i < blankLineCount; i++)
{
templateDefinition.AddLineBreak();
}
templateDefinition.AddHtml(line);
templateDefinition.AddLineBreak();
}
newSection = false;
blankLineCount = 0;
}
}
