public ParserNodeContext(TextWriter TextWriter, TemplateFactory TemplateFactory)
{
this.TextWriter = TextWriter;
this.TemplateFactory = TemplateFactory;
this.IndentationLevel = 0;
this.ShouldWriteIndentation = true;
}
public void CreateTemplate_SimpleType_CreatesInstanceOfType()
{
Type t = typeof(DummyTemplate);
var factory = new TemplateFactory(t);
var actual = factory.CreateTemplate();
Assert.IsInstanceOf<DummyTemplate>(actual);
}
private static void RenderTemplateFromTemplateFactory(TemplateFactory templateFactory, Stream stream,
dynamic model, NancyContext context)
{
var streamWriter = new StreamWriter(stream);
var template = (NancyNHamlTemplateBase)templateFactory.CreateTemplate();
template.Model = model;
template.Context = context;
template.Render(streamWriter);
streamWriter.Flush();
}
public TemplateContext(TextWriter Output, TemplateScope Scope = null, TemplateFactory TemplateFactory = null)
{
if (Scope == null) Scope = new TemplateScope();
this.Output = Output;
this.Scope = Scope;
this.TemplateFactory = TemplateFactory;
Filters = new Dictionary<string, Tuple<Type, string>>();
AddFilterLibrary(typeof(CoreFilters));
}
public void GetCompiledTemplateIViewSource_NormalUse_ReturnsCompiledTemplateFactory()
{
// Arrange
var viewSource = ViewSourceBuilder.Create();
var expectedTemplateFactory = new TemplateFactory(typeof(DummyTemplate));
_templateFactoryFactoryMock.Setup(x => x.CompileTemplateFactory(It.IsAny<string>(), It.IsAny<IViewSource>()))
.Returns(expectedTemplateFactory);
// Act
var templateFactory = _templateEngine.GetCompiledTemplate(viewSource);
// Assert
Assert.That(templateFactory, Is.SameAs(expectedTemplateFactory));
}
public void GetCompiledTemplate_MockHamlCacheProvider_CreatesTemplateOnce()
{
// Arrange
var viewSource = ViewSourceBuilder.Create();
var expectedTemplateFactory = new TemplateFactory(typeof(DummyTemplate));
_templateFactoryFactoryMock.Setup(x => x.CompileTemplateFactory(It.IsAny<string>(), It.IsAny<ViewSourceCollection>(), It.IsAny<Type>()))
.Returns(expectedTemplateFactory);
// Act
var templateFactory = _templateEngine.GetCompiledTemplate(viewSource, typeof(object));
// Assert
Assert.That(templateFactory, Is.SameAs(expectedTemplateFactory));
}
public void GetCompiledTemplateITemplateContentProvider_NormalUse_ReturnsCorrectTemplateFactory()
{
// Arrange
const string templatePath = "test.haml";
var contentProviderMock = new Mock<ITemplateContentProvider>();
contentProviderMock.Setup(x => x.GetViewSource(It.IsAny<string>())).Returns(ViewSourceBuilder.Create());
var expectedTemplateFactory = new TemplateFactory(typeof(DummyTemplate));
_templateFactoryFactoryMock.Setup(x => x.CompileTemplateFactory(It.IsAny<string>(), It.IsAny<IViewSource>()))
.Returns(expectedTemplateFactory);
// Act
var templateFactory = _templateEngine.GetCompiledTemplate(contentProviderMock.Object, templatePath, typeof(DummyTemplate));
// Assert
Assert.That(templateFactory, Is.SameAs(expectedTemplateFactory));
}
public void ShouldCreateBasicXmlElement()
{
// arrange
var doc = new XmlDocument();
var snf = new Mock <IStalkNodeFactory>();
var template = new Mock <ITemplate>();
template.Setup(x => x.SearchTree).Returns("<false />");
template.Setup(x => x.Identifier).Returns("testflag");
template.Setup(x => x.StalkIsEnabled).Returns(true);
template.Setup(x => x.TemplateIsEnabled).Returns(false);
template.Setup(x => x.WatchChannel).Returns("#foo");
var sf = new TemplateFactory(this.LoggerMock.Object, snf.Object, this.AppConfigMock.Object);
// act
var xmlElement = sf.ToXmlElement(template.Object, doc);
// assert
Assert.AreEqual("<template flag=\"testflag\" stalkenabled=\"true\" templateenabled=\"false\" watchchannel=\"#foo\"><searchtree><![CDATA[<false />]]></searchtree></template>", xmlElement.OuterXml);
}
private void NewTemplateButton_Click(object sender, RoutedEventArgs e)
{
using (var dlg = new CommonSaveFileDialog())
{
dlg.Title = "Create new template file";
dlg.InitialDirectory = (string)TemplatesDirSelection.SelectedItem;
dlg.AddToMostRecentlyUsedList = false;
dlg.DefaultDirectory = TemplateFactory.GetInstance().TemplatesDirectory;
dlg.EnsurePathExists = true;
dlg.EnsureReadOnly = false;
dlg.EnsureValidNames = true;
dlg.ShowPlacesList = true;
dlg.DefaultExtension = ".json";
dlg.Filters.Add(new CommonFileDialogFilter("json", ".json"));
if (dlg.ShowDialog() == CommonFileDialogResult.Ok)
{
string path = dlg.FileName;
TemplateFactory.GetInstance().CreateNewTemplate(path);
SelectedTemplate = path;
FilesList.Focus();
}
}
}
private void BindTemplate(OneNote.IApplication application)
{
var template = PageTemplate;
if (template != null)
{
UnbindTemplate(template);
}
var model = PageSettings;
template = TemplateFactory.CreatePageTemplate(application);
model.ColorChanged += template.ChangeColor;
model.RuleLinesHorizontalColorChanged +=
template.ChangeRuleLinesHorizontalColor;
model.RuleLinesHorizontalSpacingChanged +=
template.ChangeRuleLinesHorizontalSpacing;
model.RuleLinesMarginColorChanged +=
template.ChangeRuleLinesMarginColor;
model.RuleLinesVisibleChanged += template.ChangeRuleLinesVisible;
model.TitleChanged += template.ChangeTitle;
PageTemplate = template;
Tracer.WriteTraceMethodLine();
}
public void computePrice(IRequest request)
{
request.Response.FeedEntry = TemplateFactory.GetTemplate <ComputePriceFeedEntryTemplate>(request);
}
public void GetTemplate(IRequest request)
{
request.Response.ContentType = MediaType.AtomEntry;
request.Response.FeedEntry = TemplateFactory.GetTemplate <CommodityGroupFeedEntry>(request);
}
public void ItExists()
{
TemplateFactory factory = new TemplateFactory(_options);
}
public CodeGenerator(Generator generator, IDbContextFilter filter)
{
#pragma warning disable IDE0016 // Use 'throw' expression
if (generator == null)
{
throw new ArgumentNullException(nameof(generator));
}
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
#pragma warning restore IDE0016 // Use 'throw' expression
var isEfCore = Settings.GeneratorType == GeneratorType.EfCore;
var isEfCore3Plus = Settings.IsEfCore3Plus();
_generator = generator;
_filter = filter;
_tables = filter.Tables
.Where(t => !t.IsMapping && (t.HasPrimaryKey || (t.IsView && isEfCore3Plus)))
.OrderBy(x => x.NameHumanCase)
.Select(tbl => new TableTemplateData(tbl))
.ToList();
if (filter.IncludeStoredProcedures)
{
_storedProcs = filter.StoredProcs
.Where(s => s.IsStoredProcedure)
.OrderBy(x => x.NameHumanCase)
.Select(sp => new StoredProcTemplateData(
sp.ReturnModels.Count > 0,
sp.ReturnModels.Count == 1,
sp.ReturnModels.Count > 1,
sp.WriteStoredProcReturnType(_filter),
sp.WriteStoredProcReturnModelName(filter),
sp.WriteStoredProcFunctionName(filter),
sp.WriteStoredProcFunctionParams(false),
sp.WriteStoredProcFunctionParams(true),
sp.StoredProcHasOutParams() || sp.ReturnModels.Count == 0,
sp.WriteStoredProcFunctionOverloadCall(),
sp.WriteStoredProcFunctionSetSqlParameters(false),
sp.WriteStoredProcFunctionSetSqlParameters(true),
sp.ReturnModels.Count == 1
? // exec
string.Format("EXEC @procResult = [{0}].[{1}] {2}", sp.Schema.DbName, sp.DbName, sp.WriteStoredProcFunctionSqlAtParams()).Trim()
: string.Format("[{0}].[{1}]", sp.Schema.DbName, sp.DbName),
sp.ReturnModels.Count == 1
? // Async exec
string.Format("EXEC [{0}].[{1}] {2}", sp.Schema.DbName, sp.DbName, sp.WriteStoredProcFunctionSqlAtParams()).Trim()
: string.Format("[{0}].[{1}]", sp.Schema.DbName, sp.DbName),
sp.WriteStoredProcReturnModelName(_filter),
sp.WriteStoredProcFunctionSqlParameterAnonymousArray(true, true),
sp.WriteStoredProcFunctionSqlParameterAnonymousArray(false, true),
sp.WriteStoredProcFunctionDeclareSqlParameter(true),
sp.WriteStoredProcFunctionDeclareSqlParameter(false),
sp.Parameters.OrderBy(x => x.Ordinal).Select(sp.WriteStoredProcSqlParameterName).ToList(),
sp.ReturnModels.Count,
string.Format("EXEC @procResult = [{0}].[{1}] {2}", sp.Schema.DbName, sp.DbName, sp.WriteStoredProcFunctionSqlAtParams())
))
.ToList();
}
else
{
_storedProcs = new List <StoredProcTemplateData>();
}
if (filter.IncludeTableValuedFunctions)
{
_tableValuedFunctions = filter.StoredProcs
.Where(s => s.IsTableValuedFunction)
.OrderBy(x => x.NameHumanCase)
.Select(tvf => new TableValuedFunctionsTemplateData(
tvf.ReturnModels.Count == 1 && tvf.ReturnModels[0].Count == 1,
tvf.ReturnModels.Count == 1 && tvf.ReturnModels[0].Count == 1 ? tvf.ReturnModels[0][0].ColumnName : null,
tvf.WriteStoredProcFunctionName(_filter),
tvf.WriteStoredProcReturnModelName(_filter),
tvf.WriteStoredProcFunctionParams(false),
tvf.DbName,
tvf.Schema.DbName,
isEfCore ? tvf.WriteStoredProcFunctionDeclareSqlParameter(false) : tvf.WriteTableValuedFunctionDeclareSqlParameter(),
isEfCore
? tvf.WriteStoredProcFunctionSqlParameterAnonymousArray(false, false)
: tvf.WriteTableValuedFunctionSqlParameterAnonymousArray(),
isEfCore ? tvf.WriteNetCoreTableValuedFunctionsSqlAtParams() : tvf.WriteStoredProcFunctionSqlAtParams(),
isEfCore3Plus ? "FromSqlRaw" : "FromSql",
isEfCore3Plus ? "Set" : "Query",
isEfCore3Plus ? "Entity" : "Query",
isEfCore3Plus ? ".HasNoKey()" : string.Empty
))
.ToList();
_tableValuedFunctionComplexTypes = filter.StoredProcs
.Where(s => s.IsTableValuedFunction &&
!Settings.StoredProcedureReturnTypes.ContainsKey(s.NameHumanCase) &&
!Settings.StoredProcedureReturnTypes.ContainsKey(s.DbName))
.OrderBy(x => x.NameHumanCase)
.Select(x => x.WriteStoredProcReturnModelName(_filter))
.ToList();
}
else
{
_tableValuedFunctions = new List <TableValuedFunctionsTemplateData>();
_tableValuedFunctionComplexTypes = new List <string>();
}
if (filter.IncludeScalarValuedFunctions)
{
_scalarValuedFunctions = filter.StoredProcs
.Where(s => s.IsScalarValuedFunction &&
s.Parameters.Any(x => x.Mode == StoredProcedureParameterMode.Out))
.OrderBy(x => x.NameHumanCase)
.Select(svf => new ScalarValuedFunctionsTemplateData(
svf.WriteStoredProcFunctionName(_filter),
svf.Parameters.Where(x => x.Mode == StoredProcedureParameterMode.Out).OrderBy(x => x.Ordinal).FirstOrDefault()?.PropertyType,
svf.WriteStoredProcFunctionParams(false),
svf.DbName,
svf.Schema.DbName
))
.ToList();
}
else
{
_scalarValuedFunctions = new List <ScalarValuedFunctionsTemplateData>();
}
var returnModelsUsed = new List <string>();
foreach (var sp in _storedProcs)
{
if (returnModelsUsed.Contains(sp.ReturnModelName))
{
sp.CreateDbSetForReturnModel = false;
}
else
{
returnModelsUsed.Add(sp.ReturnModelName);
}
}
_hasTables = _tables.Any();
_hasStoredProcs = _storedProcs.Any();
_hasTableValuedFunctions = _tableValuedFunctions.Any();
_hasScalarValuedFunctions = _scalarValuedFunctions.Any();
_hasTableValuedFunctionComplexTypes = _tableValuedFunctionComplexTypes.Any();
_hasEnums = filter.Enums.Any();
_globalUsings = new List <string>();
_template = TemplateFactory.Create();
CalcGlobalUsings();
}
public override async Task <ControllerResponse> Invoke()
{
return(Context.Context.Authentication.User == null
? new InlineTpl("LoginPanel", await TemplateFactory.LoadAsync("Shared/LoginPanel/GuestPanel"))
: new InlineTpl("LoginPanel", await GetView <LoggedUserPanelView>().Get(Context.Context.Authentication.User.Identity.Name)));
}
public void Setup()
{
TemplateDalContainer = TemplateFactory.CreateTemplateDalContainer();
TemplateDalLogic = TemplateFactory.CreateTemplateDALLogic();
TemplateLogic = new TemplateLogic();
}
protected override void PersistNewItem(ITemplate entity)
{
EnsureValidAlias(entity);
//Save to db
var template = (Template)entity;
template.AddingEntity();
var factory = new TemplateFactory(NodeObjectTypeId);
var dto = factory.BuildDto(template);
//Create the (base) node data - umbracoNode
var nodeDto = dto.NodeDto;
nodeDto.Path = "-1," + dto.NodeDto.NodeId;
var o = Database.IsNew(nodeDto) ? Convert.ToInt32(Database.Insert(nodeDto)) : Database.Update(nodeDto);
//Update with new correct path
var parent = Get(template.MasterTemplateId.Value);
if (parent != null)
{
nodeDto.Path = string.Concat(parent.Path, ",", nodeDto.NodeId);
}
else
{
nodeDto.Path = "-1," + dto.NodeDto.NodeId;
}
Database.Update(nodeDto);
//Insert template dto
dto.NodeId = nodeDto.NodeId;
Database.Insert(dto);
//Update entity with correct values
template.Id = nodeDto.NodeId; //Set Id on entity to ensure an Id is set
template.Path = nodeDto.Path;
//now do the file work
if (DetermineTemplateRenderingEngine(entity) == RenderingEngine.Mvc)
{
var result = _viewHelper.CreateView(template, true);
if (result != entity.Content)
{
entity.Content = result;
//re-persist it... though we don't really care about the templates in the db do we??!!
dto.Design = result;
Database.Update(dto);
}
}
else
{
var result = _masterPageHelper.CreateMasterPage(template, this, true);
if (result != entity.Content)
{
entity.Content = result;
//re-persist it... though we don't really care about the templates in the db do we??!!
dto.Design = result;
Database.Update(dto);
}
}
template.ResetDirtyProperties();
// ensure that from now on, content is lazy-loaded
if (template.GetFileContent == null)
{
template.GetFileContent = file => GetFileContent((Template)file, false);
}
}
public TemplateCodeGenRoslyn(String TemplateString, TemplateFactory TemplateFactory = null)
: base(TemplateString, TemplateFactory)
{
}
public void GetTemplate(IRequest request)
{
request.Response.ContentType = MediaType.AtomEntry;
request.Response.FeedEntry = TemplateFactory.GetTemplate <PostalAddressFeedEntry>(request);
}
public static async Task <IActionResult> GetTrain(
[HttpTrigger(AuthorizationLevel.Anonymous, "GET", Route = "train/{profileName}/{typeName?}")] HttpRequest req,
string profileName,
string typeName,
ILogger logger)
{
var templateUrlOrName = req.Query.ContainsKey("template") ? req.Query["template"].ToString() : String.Empty;
var requestUrl = Functions.GetCurrentURL(req);
ProfileFactory.SetEnvironmentManager(Functions.EnvironmentManager);
TemplateFactory.SetEnvironmentManager(Functions.EnvironmentManager);
// Parse target parser type
IProfileParser targetProfileParser = ParserFactory.GetParser(typeName ?? "", logger, Functions.Downloader);
if (targetProfileParser == null)
{
var userAgent = req.Headers["user-agent"];
var probableType = Functions.GuessTypeFromUserAgent(userAgent);
targetProfileParser = ParserFactory.GetParser(probableType, logger, Functions.Downloader);
logger.LogInformation("Attempt to guess target type from user agent, UserAgent={userAgent}, Result={targetType}", userAgent, targetProfileParser.GetType());
}
// Get profile chain
var profileChain = new List <Profile>();
var nextProfileName = Misc.KebabCase2PascalCase(profileName);
while (true)
{
var profile = ProfileFactory.Get(nextProfileName, logger);
if (profile == null)
{
var chainString = Functions.ProfileChainToString(profileChain);
if (!string.IsNullOrEmpty(chainString))
{
chainString += "->";
}
chainString += nextProfileName;
logger.LogError($"Profile `{chainString}` is not found.");
return(new NotFoundResult());
}
if (profileChain.Contains(profile))
{
return(new ForbidResult());
}
profileChain.Add(profile);
if (profile.Type != ProfileType.Alias)
{
break;
}
nextProfileName = profile.Source;
}
var sourceProfile = profileChain.Last();
var profileParser = ParserFactory.GetParser(sourceProfile.Type, logger, Functions.Downloader);
if (profileParser == null)
{
logger.LogError($"Profile parser for {sourceProfile.Type} is not implemented! Complete profile alias chain is `{Functions.ProfileChainToString(profileChain)}`");
return(new ForbidResult());
}
// Download content and determine if original profile should be returned
var profileContent = await sourceProfile.Download(logger, Functions.Downloader);
if (targetProfileParser is NullParser)
{
if (!sourceProfile.AllowDirectAccess)
{
logger.LogError($"Original profile access is denied for profile `{Functions.ProfileChainToString(profileChain)}`.");
return(new ForbidResult());
}
logger.LogInformation("Return original profile");
return(new FileContentResult(Encoding.UTF8.GetBytes(profileContent), "text/plain; charset=UTF-8")
{
FileDownloadName = profileChain.First().Name + profileParser.ExtName(),
});
}
// Download template, parse profile and apply filters
var template = await Functions.GetTemplate(logger, templateUrlOrName);
var servers = profileParser.Parse(profileContent);
logger.LogInformation($"Download profile `{Functions.ProfileChainToString(profileChain)}` and get {servers.Length} servers");
foreach (var profile in profileChain.AsEnumerable().Reverse())
{
foreach (var filter in profile.Filters)
{
servers = filter.Do(servers, logger);
logger.LogInformation($"Apply filter `{filter.GetType()} from profile `{profile.Name}` and get {servers.Length} servers");
if (servers.Length == 0)
{
break;
}
}
if (servers.Length == 0)
{
break;
}
}
if (servers.Length == 0)
{
logger.LogError($"There are no available servers left. Complete profile alias chain is `{Functions.ProfileChainToString(profileChain)}`");
return(new NoContentResult());
}
// Encode profile
logger.LogInformation($"{servers.Length} will be encoded");
var options = targetProfileParser switch
{
SurgeParser _ => new SurgeEncodeOptions()
{
ProfileURL = requestUrl + (string.IsNullOrEmpty(template) ? "" : $"?template={HttpUtility.UrlEncode(templateUrlOrName)}")
},
QuantumultXParser _ => new QuantumultXEncodeOptions()
{
QuantumultXListUrl = Functions.GetCurrentURL(req) + "-list",
},
ClashParser _ => new ClashEncodeOptions()
{
ClashProxyProviderUrl = Functions.GetCurrentURL(req) + "-proxy-provider",
},
_ => new EncodeOptions(),
};
options.Template = template;
options.ProfileName = profileChain.First().Name;
try
{
var newProfile = targetProfileParser.Encode(options, servers, out Server[] encodedServer);
if (encodedServer.Length == 0)
{
return(new NoContentResult());
}
return(new FileContentResult(Encoding.UTF8.GetBytes(newProfile), "text/plain; charset=UTF-8")
{
FileDownloadName = profileChain.First().Name + targetProfileParser.ExtName(),
});
}
catch (InvalidTemplateException)
{
return(new BadRequestResult());
}
}
public TemplateContainer()
{
TemplateDalLogic = TemplateFactory.CreateTemplateDALLogic();
}
public TemplateCode(TemplateFactory TemplateFactory = null)
{
this.TemplateFactory = TemplateFactory;
this.Init();
}
private void SaveStateResume_WithHistory_UsesHistoryStateAfterResume(bool executeEntryActions)
#endif
{
ActionRecorder recorder = new ActionRecorder();
TemplateFactory createTemplate = delegate()
{
StateMachineTemplate t = new StateMachineTemplate(StateMachineOptions.UseDoActions);
//## Begin StateMachineTemplateSaveStateResumeWithHistory
// Generated from <file:S:\StaMa_State_Machine_Controller_Library\StaMaShapesMaster.vst> page "UT_SaveStateResumeTests"
// at 07-25-2015 16:55:36 using StaMaShapes Version 2300
t.Region("StateA", false);
t.State("StateA", recorder.CreateAction("EnterA"), recorder.CreateAction("ExitA"), recorder.CreateDoAction("DoA"));
t.Region("StateA1A", true);
t.State("StateA1A", recorder.CreateAction("EnterA1A"), recorder.CreateAction("ExitA1A"), recorder.CreateDoAction("DoA1A"));
t.Transition("T1", "StateA1B", null, null, null);
t.EndState();
t.State("StateA1B", recorder.CreateAction("EnterA1B"), recorder.CreateAction("ExitA1B"), recorder.CreateDoAction("DoA1B"));
t.Transition("T2", "StateB1A", "Event1", null, null);
t.EndState();
t.EndRegion();
t.EndState();
t.State("StateB", recorder.CreateAction("EnterB"), recorder.CreateAction("ExitB"), recorder.CreateDoAction("DoB"));
t.Transition("T4", "StateA", "Event2", null, null);
t.Region("StateB1A", true);
t.State("StateB1A", recorder.CreateAction("EnterB1A"), recorder.CreateAction("ExitB1A"), recorder.CreateDoAction("DoB1A"));
t.Transition("T3", "StateB1B", null, null, null);
t.EndState();
t.State("StateB1B", recorder.CreateAction("EnterB1B"), recorder.CreateAction("ExitB1B"), recorder.CreateDoAction("DoB1B"));
t.EndState();
t.EndRegion();
t.EndState();
t.EndRegion();
//## End StateMachineTemplateSaveStateResumeWithHistory
return(t);
};
StateMachineTemplate t1 = createTemplate();
t1.SerializationSignatureGenerator = TestSignatureGenerator;
StateMachine s1 = t1.CreateStateMachine();
s1.Startup();
s1.SendTriggerEvent(null);
s1.SendTriggerEvent("Event1");
StateConfiguration expectedActiveStateS1 = t1.CreateStateConfiguration("StateB1B");
Assert.That(s1.ActiveStateConfiguration.ToString(), Is.EqualTo(expectedActiveStateS1.ToString()), "Precondition not met: Unexpected state save state.");
Assert.That(recorder.RecordedActions, Is.EqualTo(new String[] { "EnterA", "EnterA1A", "DoA", "DoA1A", "ExitA1A", "EnterA1B", "DoA", "DoA1B", "ExitA1B", "ExitA", "EnterB", "EnterB1A", "DoB", "DoB1A", "ExitB1A", "EnterB1B", "DoB", "DoB1B" }), "Precondition not met: Unexpected action execution sequence.");
recorder.Clear();
// Act
MemoryStream memoryStream = new MemoryStream();
s1.SaveState(memoryStream);
memoryStream.Flush();
memoryStream.Position = 0;
StateMachine s2 = t1.CreateStateMachine();
s2.Resume(memoryStream, executeEntryActions);
// Assert
Assert.That(s2.ActiveStateConfiguration.ToString(), Is.EqualTo(s1.ActiveStateConfiguration.ToString()), "State mismatch after Resume.");
String[] expectedActions = executeEntryActions ? new String[] { "EnterB", "EnterB1B", "DoB", "DoB1B" } : new String[] { };
Assert.That(recorder.RecordedActions, Is.EqualTo(expectedActions), "Unexpected entry or do actions during state machine resume with history.");
recorder.Clear();
s2.SendTriggerEvent("Event2");
Assert.That(s2.ActiveStateConfiguration.ToString(), Is.EqualTo(t1.CreateStateConfiguration("StateA1B").ToString()), "Unexpected state machine behavior after Resume.");
Assert.That(recorder.RecordedActions, Is.EqualTo(new String[] { "ExitB1B", "ExitB", "EnterA", "EnterA1B", "DoA", "DoA1B" }), "Unexpected entry or do actions during state machine resume.");
// Compatibility test assertions
// Data obtained from
// FileStream fileStream = new FileStream("TestData.dat", FileMode.Create);
// s1.SaveState(fileStream);
// fileStream.Close();
// PowerShell> gc -encoding byte "TestData.dat" |% {write-host ("0x{0:X2}," -f $_) -noNewline ""}; write-host
StringBuilder sb = new StringBuilder();
Byte[] actualBytes = memoryStream.ToArray();
for (int i = 0; i < actualBytes.Length; i++)
{
sb.Append("0x" + actualBytes[i].ToString("X2") + ", ");
}
#if !MF_FRAMEWORK
Console.WriteLine("Actual bytes:");
Console.WriteLine(sb.ToString());
#else
Debug.Print("Actual bytes:");
Debug.Print(sb.ToString());
#endif
Byte[] compatibilityTestData2300 = new Byte[] { 0xAA, 0x00, 0x23, 0xA1, 0x47, 0x28, 0x7E, 0x31, 0x2D, 0x7B, 0x53, 0x74, 0x61, 0x74, 0x65, 0x41, 0x28, 0x7E, 0x31, 0x23, 0x7B, 0x53, 0x74, 0x61, 0x74, 0x65, 0x41, 0x31, 0x41, 0x2C, 0x53, 0x74, 0x61, 0x74, 0x65, 0x41, 0x31, 0x42, 0x2C, 0x7D, 0x29, 0x2C, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x28, 0x7E, 0x31, 0x23, 0x7B, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x31, 0x41, 0x2C, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x31, 0x42, 0x2C, 0x7D, 0x29, 0x2C, 0x7D, 0x29, 0xA2, 0x01, 0x00, 0xA4, 0x01, 0x00, 0xA5, 0x08, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x31, 0x42, 0xA3, 0x02, 0x00, 0xA4, 0x01, 0x00, 0xA5, 0x08, 0x53, 0x74, 0x61, 0x74, 0x65, 0x41, 0x31, 0x42, 0xA4, 0x01, 0x00, 0xA5, 0x08, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x31, 0x42, };
Assert.That(memoryStream.ToArray(), Is.EqualTo(compatibilityTestData2300), "Compatibility test failed. Written data different from version 2300.");
MemoryStream memoryStream2300 = new MemoryStream(compatibilityTestData2300);
StateMachineTemplate t3 = createTemplate();
t3.SerializationSignatureGenerator = null;
StateMachine s3 = t3.CreateStateMachine();
s3.Resume(memoryStream2300, false);
Assert.That(s3.ActiveStateConfiguration.ToString(), Is.EqualTo(expectedActiveStateS1.ToString()), "State mismatch after Resume.");
}
/// <summary>
/// Initializes a new instance of the <see cref="RazorContext"/> class.
/// </summary>
public RazorContext(RazorConfig config = null)
{
Config = (config ?? new RazorConfig().Initializer.TryInitializeFromConfig().CastTo <RazorConfig>()).AsReadonly();
TemplateFactory = new TemplateFactory(this);
}
public void RegisterTemplate_NullTemplate_Throws()
{
string name = "foobar";
Assert.Throws <ArgumentNullException> (() => TemplateFactory.Register(name, null));
}
protected override void PersistUpdatedItem(ITemplate entity)
{
EnsureValidAlias(entity);
//store the changed alias if there is one for use with updating files later
var originalAlias = entity.Alias;
if (entity.IsPropertyDirty("Alias"))
{
//we need to check what it currently is before saving and remove that file
var current = Get(entity.Id);
originalAlias = current.Alias;
}
var template = (Template)entity;
if (entity.IsPropertyDirty("MasterTemplateId"))
{
var parent = Get(template.MasterTemplateId.Value);
if (parent != null)
{
entity.Path = string.Concat(parent.Path, ",", entity.Id);
}
}
//Get TemplateDto from db to get the Primary key of the entity
var templateDto = Database.SingleOrDefault <TemplateDto>("WHERE nodeId = @Id", new { Id = entity.Id });
//Save updated entity to db
template.UpdateDate = DateTime.Now;
var factory = new TemplateFactory(templateDto.PrimaryKey, NodeObjectTypeId);
var dto = factory.BuildDto(template);
Database.Update(dto.NodeDto);
Database.Update(dto);
//re-update if this is a master template, since it could have changed!
var axisDefs = GetAxisDefinitions(dto);
template.IsMasterTemplate = axisDefs.Any(x => x.ParentId == dto.NodeId);
//now do the file work
if (DetermineTemplateRenderingEngine(entity) == RenderingEngine.Mvc)
{
var result = _viewHelper.UpdateViewFile(entity, originalAlias);
if (result != entity.Content)
{
entity.Content = result;
//re-persist it... though we don't really care about the templates in the db do we??!!
dto.Design = result;
Database.Update(dto);
}
}
else
{
var result = _masterPageHelper.UpdateMasterPageFile(entity, originalAlias, this);
if (result != entity.Content)
{
entity.Content = result;
//re-persist it... though we don't really care about the templates in the db do we??!!
dto.Design = result;
Database.Update(dto);
}
}
entity.ResetDirtyProperties();
// ensure that from now on, content is lazy-loaded
if (template.GetFileContent == null)
{
template.GetFileContent = file => GetFileContent((Template)file, false);
}
}
public void Get_NullName_Throws()
{
Assert.Throws <ArgumentNullException> (() => TemplateFactory.Get(null));
}
/// <summary>
/// Initializes a new instance of the <see cref="RazorContext"/> class.
/// </summary>
public RazorContext(RazorConfig config = null)
{
Config = config ?? new RazorConfig();
TemplateFactory = new TemplateFactory(this);
}
public void WriteTo(TextWriter tw)
{
var expressions = Expressions.ToList();
var reverseExpressions = expressions
.Select(e =>
{
try
{
if (e is CreateConstraintExpression)
{
return(null);
}
return((MigrationExpressionBase)e.Reverse());
}
catch (NotSupportedException)
{
return(null);
}
}).Where(x => x != null).ToList();
reverseExpressions.Reverse();
tw.WriteLine("using System;");
tw.WriteLine("using System.Collections.Generic;");
tw.WriteLine("using System.Data;");
tw.WriteLine("using System.Linq;");
tw.WriteLine("using System.Web;");
tw.WriteLine("using System.Linq.Expressions;");
tw.WriteLine("using FluentMigrator;");
tw.WriteLine();
tw.WriteLine("namespace");
tw.Write(Namespace);
tw.WriteLine();
tw.WriteLine("{");
tw.Write("\t[Migration({0:00000000})]", Version);
tw.WriteLine();
tw.WriteLine("\tpublic class " + Name + " : Migration");
tw.WriteLine("\t{");
tw.WriteLine();
tw.Write("\tpublic const string ConfigurationData = \"");
tw.Write(SerializedConfiguration);
tw.Write("\";");
tw.WriteLine();
tw.WriteLine();
tw.WriteLine("\t\tpublic override void Up()");
tw.WriteLine("\t\t\t{");
foreach (var templ in expressions.Select(e => TemplateFactory.GetTemplate(e)))
{
templ.WriteTo(tw);
tw.Write(";\r\n\r\n");
}
tw.WriteLine("\t\t\t}");
tw.WriteLine("\t\tpublic override void Down()");
tw.WriteLine("\t\t\t{");
foreach (var templ in reverseExpressions.Select(e => TemplateFactory.GetTemplate(e)))
{
templ.WriteTo(tw);
tw.Write(";\r\n\r\n");
}
tw.WriteLine("\t\t}");
tw.WriteLine("\t}");
tw.WriteLine("}");
tw.WriteLine();
}
private Template GetTemplate(TrainerLevelType level, DaysType days, string templateType)
{
Template template = null;
TemplateFactory templateFactory = new TemplateFactory(level);
if (templateType != "DecideForMe")
{
template = templateFactory.CreateBasicTemplate(Enum.Parse <TemplateType>(templateType));
}
else
{
Random random;
if (days <= DaysType.TwoDays)
{
//FBW
template = templateFactory.CreateBasicTemplate(TemplateType.FBW);
}
if (days == DaysType.ThreeDays)
{
if (level == TrainerLevelType.Novice)
{
//FBW
template = templateFactory.CreateBasicTemplate(TemplateType.FBW);
}
if (level == TrainerLevelType.Intermediate)
{
//FBW/AB (random)
var list = new TemplateType[] { TemplateType.AB };
random = new Random();
template = templateFactory.CreateBasicTemplate(list[random.Next(list.Length)]);
}
if (level >= TrainerLevelType.Advanced)
{
//AB
template = templateFactory.CreateBasicTemplate(TemplateType.AB);
}
}
if (days == DaysType.FourDays)
{
if (level <= TrainerLevelType.Intermediate)
{
//AB
template = templateFactory.CreateBasicTemplate(TemplateType.AB);
}
if (level >= TrainerLevelType.Advanced)
{
// AB, ABC, ABCD (random)
var list = new TemplateType[] { TemplateType.ABCD, TemplateType.AB, TemplateType.ABC };
random = new Random();
template = templateFactory.CreateBasicTemplate(list[random.Next(list.Length)]);
}
}
if (days == DaysType.FiveDays)
{
if (level <= TrainerLevelType.Advanced)
{
//ABC
template = templateFactory.CreateBasicTemplate(TemplateType.ABC);
}
else
{
//ABC, ABCD, ABCDE
var list = new TemplateType[] { TemplateType.ABCD, TemplateType.ABC };
random = new Random(list.Length);
template = templateFactory.CreateBasicTemplate(list[random.Next(list.Length)]);
}
}
if (days == DaysType.SixDays || days == DaysType.SevenDays)
{
if (level <= TrainerLevelType.Advanced)
{
//ABC
template = templateFactory.CreateBasicTemplate(TemplateType.ABC);
}
else
{
//ABC, ABCD, ABCDE, ABCDEF
var list = new[] { TemplateType.AB, TemplateType.ABC, TemplateType.ABCD };
random = new Random(list.Length);
template = templateFactory.CreateBasicTemplate(list[random.Next(list.Length)]);
}
}
if (template == null)
{
throw new Exception("could not instantiate template");
}
}
template.DaysType = days;
template.TrainerLevelType = level;
foreach (Workout templateWorkout in template.Workouts)
{
foreach (MuscleExercises templateWorkoutMuscleExercise in templateWorkout.WorkoutHistories.First()
.MuscleExercises)
{
var exercisesOfMuscle = _db.Exercises.Where(x =>
x.MuscleType == templateWorkoutMuscleExercise.MuscleType).ToList();
for (int i = 0; i < templateWorkoutMuscleExercise.Exercises.Count; i++)
{
Random r = new Random();
var exerciseSetting =
_programService.PickExerciseSetting(
_programService.GetRelevantExerciseData(i, level,
templateWorkoutMuscleExercise.MuscleType));
var workoutExercise = templateWorkoutMuscleExercise.Exercises[i];
var exerciseChose = _programService.PickExercise(i, exerciseSetting, exercisesOfMuscle);
workoutExercise.Name = exerciseChose.Name;
var numOfSets = exerciseSetting.Sets[r.Next(exerciseSetting.Sets.Length)];
var reps = _programService.PickReps(exerciseSetting);
var rest = _programService.PickRest(exerciseSetting);
for (int j = 0; j < numOfSets; j++)
{
var set = new Set()
{
Reps = reps, Rest = rest
};
workoutExercise.Sets.Add(set);
}
exercisesOfMuscle.Remove(exerciseChose);
}
}
}
return(template);
}
public string Get(string message)
{
return(TemplateFactory.Load("MessageBox").Set("Message", message).Get());
}
public override ControllerResponse Invoke()
{
return(new InlineTpl("Navbar", TemplateFactory.Load("Navbar")));
}
public void GetTemplate(IRequest request)
{
request.Response.ContentType = MediaType.AtomEntry;
request.Response.FeedEntry = TemplateFactory.GetTemplate <SalesOrderFeedEntry>(request);
}
public void RegisterTemplate_NullName_Throws()
{
IManosTemplate template = new ManosTemplateStub();
Assert.Throws <ArgumentNullException> (() => TemplateFactory.Register(null, template));
}
public void GetTemplate(IRequest request)
{
request.Response.ContentType = MediaType.AtomEntry;
request.Response.FeedEntry = TemplateFactory.GetTemplate <TradingAccountFeedEntry>(request);
}
public void TryGet_NullName_Throws()
{
IManosTemplate template;
Assert.Throws <ArgumentNullException> (() => TemplateFactory.TryGet(null, out template));
}
protected override void PersistUpdatedItem(ITemplate entity)
{
EnsureValidAlias(entity);
//store the changed alias if there is one for use with updating files later
var originalAlias = entity.Alias;
if (entity.IsPropertyDirty("Alias"))
{
//we need to check what it currently is before saving and remove that file
ITemplate?current = Get(entity.Id);
originalAlias = current?.Alias;
}
var template = (Template)entity;
if (entity.IsPropertyDirty("MasterTemplateId"))
{
ITemplate?parent = Get(template.MasterTemplateId !.Value);
if (parent != null)
{
entity.Path = string.Concat(parent.Path, ",", entity.Id);
}
else
{
//this means that the master template has been removed, so we need to reset the template's
//path to be at the root
entity.Path = string.Concat("-1,", entity.Id);
}
}
//Get TemplateDto from db to get the Primary key of the entity
TemplateDto templateDto = Database.SingleOrDefault <TemplateDto>("WHERE nodeId = @Id", new { entity.Id });
//Save updated entity to db
template.UpdateDate = DateTime.Now;
TemplateDto dto = TemplateFactory.BuildDto(template, NodeObjectTypeId, templateDto.PrimaryKey);
Database.Update(dto.NodeDto);
Database.Update(dto);
//re-update if this is a master template, since it could have changed!
IEnumerable <IUmbracoEntity> axisDefs = GetAxisDefinitions(dto);
template.IsMasterTemplate = axisDefs.Any(x => x.ParentId == dto.NodeId);
// Only save file when not in production runtime mode
if (_runtimeSettings.CurrentValue.Mode != RuntimeMode.Production)
{
//now do the file work
SaveFile((Template)entity, originalAlias);
}
entity.ResetDirtyProperties();
// ensure that from now on, content is lazy-loaded
if (template.GetFileContent == null)
{
template.GetFileContent = file => GetFileContent((Template)file, false);
}
}
public TemplateCode(TemplateFactory TemplateFactory = null)
{
this.TemplateFactory = TemplateFactory;
this.Init();
}
public TemplateCodeGenRoslyn(String TemplateString, TemplateFactory TemplateFactory = null)
: base(TemplateString, TemplateFactory)
{
}
