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); } }