private XmlHelper loadXml(String fileName, _ImportFlags flags = _ImportFlags.UseFlagsFromXml)
{
XmlHelper tmp = new XmlHelper(fileName);
if (TemplateFactory == null)
{
String factoryClass = tmp.ReadStr("@templatefactory", typeof(TemplateFactory).FullName);
TemplateFactory = CreateObject <ITemplateFactory>(factoryClass, this, tmp);
}
_ImportFlags flagsFromXml = tmp.ReadEnum("@importflags", (_ImportFlags)0);
if (((ImportFlags | flagsFromXml) & _ImportFlags.DebugTemplate) != 0)
{
TemplateFactory.AutoWriteGenerated = true;
}
ImportLog.Log("Flags before load={0}", ImportFlags);
XmlHelper xml = new XmlHelper();
ITemplateEngine eng = TemplateFactory.CreateEngine();
eng.Variables.Set("IMPORT_ROOT", Path.GetDirectoryName(tmp.FileName));
tmp = null;
eng.LoadFromFile(fileName);
MainVariables = eng.Variables;
FileVariables = eng.FileVariables;
TemplateFactory.InitialVariables = FileVariables;
xml.Load(eng.ResultAsReader(), fileName);
return(xml);
}
public ProjectGenerator(ITemplateEngine templateEngine, IFileSystem fileSystem)
: base(command, description)
{
scaffoldingHome = Environment.GetEnvironmentVariable("scaffold_home");
this.templateEngine = templateEngine;
this.fileSystem = fileSystem;
}
public void Init()
{
var cmsRegistry = new CmsIocModule();
var dataRegistry = new DataNinectModule();
_container.Register(new List <IRegistry>
{
cmsRegistry,
new ServicesNinjectModule(),
dataRegistry
});
MenuGen.MenuGen.Init(x => x.Container.Register(new List <IRegistry>
{
//dataRegistry
}));
//IocConfig.Configure(_container);
AutoMapperConfiguration.Configure();
RazorViewEngineConfig.Configure();
RouteConfig.RegisterRoutes(RouteTable.Routes); //TODO: need to think more about what routes to add to a user's MVC project
_templateEngine = (ITemplateEngine)_container.Resolve <ITemplateEngine>();
_templateEngine.GenerateTemplates(Assembly.GetCallingAssembly());
ControllerBuilder.Current.SetControllerFactory(new IocControllerFactory(_container));
}
public MessageFactory(
ICommonServices services,
ITemplateEngine templateEngine,
ITemplateManager templateManager,
IMessageModelProvider modelProvider,
IMessageTemplateService messageTemplateService,
IQueuedEmailService queuedEmailService,
ILanguageService languageService,
IEmailAccountService emailAccountService,
EmailAccountSettings emailAccountSettings,
IDownloadService downloadService)
{
_services = services;
_templateEngine = templateEngine;
_templateManager = templateManager;
_modelProvider = modelProvider;
_messageTemplateService = messageTemplateService;
_queuedEmailService = queuedEmailService;
_languageService = languageService;
_emailAccountService = emailAccountService;
_emailAccountSettings = emailAccountSettings;
_downloadService = downloadService;
T = NullLocalizer.Instance;
Logger = NullLogger.Instance;
}
public EmailTemplate(IEmailSender emailSender, ITemplateEngine templateEngine, string from)
{
this.emailSender = emailSender;
this.templateEngine = templateEngine;
this.From = from;
}
public SolrInitializer(OutputContext context, ISolrCoreAdmin admin, ISolrOperations <Dictionary <string, object> > solr, ITemplateEngine engine)
{
_context = context;
_admin = admin;
_solr = solr;
_engine = engine;
}
protected override void ApplyTemplate(ITemplateEngine templateEngine, ICryptoCodeGenerationTaskModel model, Project project,
FileInfo file)
{
var ns = ProjectHelpers.GetFileNameSpace(project, file.FullName);
templateEngine.AddReplacementValue(CodeGenerationTemplateKeys.Namespace, ns);
}
public MessageFactory(
SmartDbContext db,
ICommonServices services,
ITemplateEngine templateEngine,
ITemplateManager templateManager,
IMessageModelProvider modelProvider,
IQueuedEmailService queuedEmailService,
ILanguageService languageService,
IEmailAccountService emailAccountService,
EmailAccountSettings emailAccountSettings,
IMediaService mediaService,
IEventPublisher eventPublisher,
IStoreContext storeContext,
IWorkContext workContext)
{
_db = db;
_services = services;
_templateEngine = templateEngine;
_templateManager = templateManager;
_modelProvider = modelProvider;
_queuedEmailService = queuedEmailService;
_languageService = languageService;
_emailAccountService = emailAccountService;
_emailAccountSettings = emailAccountSettings;
_mediaService = mediaService;
_eventPublisher = eventPublisher;
_storeContext = storeContext;
_workContext = workContext;
}
public string CreateFunctionScriptBlock(StreamReader reader, string partialViewName, string methodName,
IServiceProvider provider, ITemplateEngine engine, params String[] parameters)
{
XmlTextReader xmlReader = new XmlTextReader(reader);
xmlReader.Namespaces = false;
xmlReader.WhitespaceHandling = WhitespaceHandling.All;
DefaultContext context = new DefaultContext(partialViewName, xmlReader, provider, engine);
context.Script.Append("def ");
context.Script.Append(methodName);
context.Script.Append('(');
context.Script.Append("controller, context, request, response, session, output, flash, siteroot");
// context.Script.Append("output");
foreach(String param in parameters)
{
context.Script.Append(',');
context.Script.Append(param);
}
context.Script.Append(')');
context.Script.AppendLine(":");
context.IncreaseIndentation();
// context.AppendLineIndented("print 'hello'");
ProcessReader(context, 0);
context.DecreaseIndentation();
context.Script.AppendLine();
return context.Script.ToString();
}
public void SetUp()
{
mocks = new MockRepository();
fileSystemMock = mocks.DynamicMock<IFileSystem>();
templateEngine = new TemplateEngine(fileSystemMock);
}
private void GenerateWorker(GenerationParameter parameter, AsyncOperation asyncOp)
{
if (IsTaskCanceled(asyncOp.UserSuppliedState))
{
return;
}
int genratedCount = 0;
int errorCount = 0;
int progressCount = 0;
try
{
string adapterTypeName = ConfigManager.SettingsSection.TemplateEngines[parameter.Settings.TemplateEngine].Adapter;
ITemplateEngine templateEngine = (ITemplateEngine)Activator.CreateInstance(Type.GetType(adapterTypeName));
foreach (string templateName in parameter.Settings.TemplatesNames)
{
this.GenerateCode(parameter, templateEngine, templateName, ref genratedCount, ref errorCount, ref progressCount, asyncOp);
}
}
catch (Exception ex)
{
logger.Error("", ex);
}
this.CompletionMethod(null, IsTaskCanceled(asyncOp.UserSuppliedState), asyncOp);
}
private void GenerateCode(GenerationParameter parameter, ITemplateEngine templateEngine, string templateName,
ref int genratedCount, ref int errorCount, ref int progressCount, AsyncOperation asyncOp)
{
foreach (string modelId in parameter.GenerationObjects.Keys)
{
string codeFileNamePath = PathHelper.GetCodeFileNamePath(ConfigManager.GenerationCodeOuputPath,
ConfigManager.SettingsSection.Languages[parameter.Settings.Language].Alias,
ConfigManager.SettingsSection.TemplateEngines[parameter.Settings.TemplateEngine].Name,
ConfigManager.TemplateSection.Templates[templateName].DisplayName, parameter.Settings.Package, modelId);
PathHelper.CreateCodeFileNamePath(codeFileNamePath);
foreach (string objId in parameter.GenerationObjects[modelId])
{
IMetaData modelObject = ModelManager.GetModelObject(parameter.Models[modelId], objId);
TemplateData templateData = TemplateDataBuilder.Build(modelObject, parameter.Settings,
templateName, parameter.Models[modelId].Database, modelId);
if (templateData == null || !templateEngine.Run(templateData))
{
errorCount++;
}
else
{
genratedCount++;
}
string currentCodeFileName = templateData == null ? string.Empty : templateData.CodeFileName;
var args = new GenerationProgressChangedEventArgs(genratedCount,
errorCount, currentCodeFileName, ++progressCount, asyncOp.UserSuppliedState);
asyncOp.Post(this.onProgressReportDelegate, args);
}
}
}
public EmailTemplateTest()
{
_templateEngine = new RazorTemplateEngineBuilder()
.FindTemplatesInDirectory("Templates")
.UseInstanceCache()
.Build();
}
public UsuarioService(
IAuthentication authentication,
IApplication application,
IParametroService parametroService,
IUsuarioRepository <Usuario> repositoryUsuario,
AspUserManager <Rol, Usuario, Modulo> userManager,
AspRoleManager <Rol, Usuario> roleManager,
BaseModuleManager <Modulo, Usuario> moduleManager,
IdentityEmailMessageService emailService,
ITemplateEngine templateEngine,
IRolRepository <Rol> rolRepository,
IRolService rolService) : base(repositoryUsuario)
{
this.authentication = authentication;
this.application = application;
this.ParametroService = parametroService;
this.RepositoryUsuario = repositoryUsuario;
this.UserManager = userManager;
this.RoleManager = roleManager;
this.ModuleManager = moduleManager;
this.EmailService = emailService;
this.TemplateEngine = templateEngine;
this.RepositoryRol = rolRepository;
RolService = rolService;
}
/// <summary>
/// Initializes a new instance of the <see cref="Parser"/> class.
/// </summary>
/// <param name="tokens">
/// tokens a serem processados
/// </param>
/// <param name="engine">engine a ser utilizada no processamento do template</param>
public Parser(TokenList tokens, ITemplateEngine engine)
{
this.tokens = tokens;
this.output = new StringBuilder(tokens.Count);
this.templateEngine = engine;
engine.Parser = this;
}
public EmailsCommand(
ISettingsQuery settingsQuery,
ISettingsCommand settingsCommand,
ICommunicationEngine communicationEngine,
ITemplateEngine templateEngine,
IAffiliateEmailsQuery affiliateEmailsQuery,
IUserEmailsQuery userEmailsQuery,
string memberServicesAddress,
string employerServicesAddress,
string systemAddress,
string returnAddress,
string servicesDisplayName,
string allStaffAddress,
string allStaffDisplayName,
string redStarResumeAddress,
string redStarResumeDisplayName)
{
_settingsQuery = settingsQuery;
_settingsCommand = settingsCommand;
_communicationEngine = communicationEngine;
_templateEngine = templateEngine;
_affiliateEmailsQuery = affiliateEmailsQuery;
_userEmailsQuery = userEmailsQuery;
_memberServicesUser = new EmailUser(memberServicesAddress, servicesDisplayName, null);
_employerServicesUser = new EmailUser(employerServicesAddress, servicesDisplayName, null);
_systemUser = new EmailUser(systemAddress, servicesDisplayName, null);
_allStaffUser = new EmailUser(allStaffAddress, allStaffDisplayName, null);
_redStarResume = new EmailUser(redStarResumeAddress, redStarResumeDisplayName, null);
_returnUser = new EmailUser(returnAddress, servicesDisplayName, null);
}
public EmailTemplateTest()
{
_templateEngine = new RazorTemplateEngineBuilder()
.FindTemplatesInDirectory("Templates")
.UseInstanceCache()
.Build();
}
private void SetMethods(ITemplateEngine templateEngine, SymmetricEncryptionCryptoTaskModel cryptoModel)
{
if (cryptoModel.UsePassword)
{
string macSuffix = string.Empty;
if (cryptoModel.UseMac)
{
macSuffix = "Mac";
}
var passwordMethodsTemplate = new SimpleTemplateEngine(
GetTemplateStream($"Resources.CodeTemplates.SymmetricEncryption.PasswordMethods{macSuffix}.txt"));
string sha = "SHA256";
switch (cryptoModel.SelectedSecurityLevel)
{
case SecurityLevel.Default:
break;
case SecurityLevel.VerySecure:
sha = "SHA512";
break;
}
//passwordMethodsTemplate.AddReplacementValue(SymmetricCryptoProviderTemplateKeys.ShaImplementation, sha);
templateEngine.AddReplacementValue(SymmetricCryptoProviderTemplateKeys.PasswordMethods, passwordMethodsTemplate.GetResult());
}
}
public static string Render(RenderFunc func)
{
string content = string.Empty;
using (MemoryStream ms = new MemoryStream())
{
using (HtmlTextWriter htmlWriter = new HtmlTextWriter(new StreamWriter(ms)))
{
func(htmlWriter);
htmlWriter.Flush();
}
using (StreamReader rdr = new StreamReader(ms))
{
rdr.BaseStream.Position = 0;
content = rdr.ReadToEnd();
}
}
ITemplateEngine te = ServiceLocator.Instance.Resolve <ITemplateEngine>();
using (StringWriter sw = new StringWriter())
{
te.Process(JContext.Current.ViewData, string.Empty, sw, content);
return(sw.GetStringBuilder().ToString());
}
}
public EntityGenerator(ITemplateEngine templateEngine, IConfiguration configuration, IProjectFileManager projectFileManager)
: base(command, description)
{
this.templateEngine = templateEngine;
this.configuration = configuration;
this.projectFileManager = projectFileManager;
}
public EmailTemplate(IEmailSender emailSender, ITemplateEngine templateEngine, string from)
{
this.emailSender = emailSender;
this.templateEngine = templateEngine;
this.From = from;
}
templates_use_an_abstraction()
{
var server = new Dictionary <string, string> {
["Site:PhysicalFullPath"] = new DirectoryInfo(Directory.GetCurrentDirectory()).Parent.Parent.Parent.FullName
};
var headers = new Dictionary <string, string[]> {
["accept"] = new [] { "text/html" }
};
var testContext = Defaults.Context.With(
requestHeaders: headers,
path: "/hello/world/42",
type: GET,
server: server);
var sampleObject = new { name = "world" };
ITemplateEngine engine = liquidEngineForTest;
Check.ThatCode(() => {
string renderTemplate = engine.RenderTemplate(testContext, "simpleLiquid");
string renderTemplateWithModel = engine.RenderTemplate(testContext, "simpleliquid", sampleObject);
Check.That(renderTemplateWithModel).IsEqualTo("hello world");
}).DoesNotThrow();
}
public RuleEventFormatter(IJsonSerializer jsonSerializer, IEnumerable <IRuleEventFormatter> formatters, ITemplateEngine templateEngine, IScriptEngine scriptEngine)
{
this.jsonSerializer = jsonSerializer;
this.formatters = formatters;
this.templateEngine = templateEngine;
this.scriptEngine = scriptEngine;
}
public SimpleNewsletterService(Type sometype, IEmailSender sender, ITemplateEngine templateEngine)
{
if (sometype == null) throw new ArgumentNullException("sometype");
_sender = sender;
_templateEngine = templateEngine;
}
public static void RegisterEngine(ITemplateEngine engine)
{
lock (engines)
{
engines.Add(engine);
}
}
/// <summary>
/// 根据模板Id 和 doc 获得标题和内容
/// </summary>
public static bool ResolverTemplate(string channel, string templateId, Dictionary <string, object> param, out string title, out string content, out string category)
{
title = content = category = string.Empty;
DictSchema schema = (from q in DictSchema.CreateContext(true)
where q.Type == "msg" && q.Name == "template" && q.Title == templateId
select q).FirstOrDefault();
if (schema == null)
{
LogManager.GetLogger <NoticeFactory>().ErrorFormat("指定的模板：{0} 不存在。", templateId);
return(false);
}
category = schema.Category;
ITemplateEngine te = ServiceLocator.Instance.Resolve <ITemplateEngine>();
using (StringWriter sw = new StringWriter())
{
string template = schema[channel + "_title"];
if (string.IsNullOrEmpty(template))
{
template = schema["default_title"];
}
if (string.IsNullOrWhiteSpace(template))
{
title = string.Empty;
}
else
{
te.Process(param, string.Empty, sw, template);
title = sw.GetStringBuilder().ToString();
}
}
using (StringWriter sw = new StringWriter())
{
string template = schema[channel + "_content"];
if (string.IsNullOrEmpty(template))
{
template = schema["default_content"];
}
if (string.IsNullOrWhiteSpace(template))
{
content = string.Empty;
}
else
{
te.Process(param, string.Empty, sw, template);
content = sw.GetStringBuilder().ToString();
}
}
return(true);
}
public EmailServiceProcessor(IPgDataClient pgDataClient,
ITemplateEngine templateEngine,
IEmailProviderService emailProviderFactory)
{
this.pgDataClient = pgDataClient;
this.templateEngine = templateEngine;
this.emailProviderFactory = emailProviderFactory;
}
public EmailService(EmailProvider provider, ITemplateEngine templateEngine, ISubtextContext context)
{
EmailProvider = provider;
TemplateEngine = templateEngine;
Url = context.UrlHelper;
Blog = context.Blog;
Context = context;
}
public CommerceService(IExtCommonDao commonDao, ICommerceDao dao, IPaymentProvider provider, IBasketRules rules, IOrderProcessorFactory processorFactory, ITemplateEngine templateEngine, IChargeService chargeService) {
_commonDao = commonDao;
_dao = dao;
_provider = provider;
_rules = rules;
_chargeService = chargeService;
_processorFactory = processorFactory;
}
public void SetUp()
{
mailServiceMock = MockRepository.GenerateMock<IMailService>();
templateEngineMock = MockRepository.GenerateMock<ITemplateEngine>();
templateSourceMock = MockRepository.GenerateMock<ITemplateSource>();
listener = new SendWelcomeEmailUserRegisteredEventListener(mailServiceMock, templateEngineMock,
templateSourceMock);
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultContext"/> class.
/// </summary>
/// <param name="rootViewName">Name of the root view.</param>
/// <param name="reader">The reader.</param>
/// <param name="serviceProvider">The service provider.</param>
public DefaultContext(String rootViewName, XmlReader reader,
IServiceProvider serviceProvider, ITemplateEngine engine)
{
this.rootViewName = rootViewName;
this.reader = reader;
this.serviceProvider = serviceProvider;
this.engine = engine;
}
public CodeGenerator(IRepository <CodeTemplate> templateRepository, ITemplateEngine templateEngine)
{
Ensure.That(templateRepository).IsNotNull();
Ensure.That(templateEngine).IsNotNull();
_templateRepository = templateRepository;
_templateEngine = templateEngine;
}
public SqlScriptProvider(ITemplateEngine templateEngine)
{
if (templateEngine == null)
{
throw new ArgumentNullException(nameof(templateEngine));
}
_templateEngine = templateEngine;
}
private static string Render(ITemplateEngine templateEngine, string templateFile, object values)
{
using (var writer = new StringWriter())
{
templateEngine.Render(templateFile, values, writer);
return(writer.GetStringBuilder().ToString());
}
}
public void SetUp()
{
mailServiceMock = MockRepository.GenerateMock<IMailService>();
templateEngineMock = MockRepository.GenerateMock<ITemplateEngine>();
templateSourceMock = MockRepository.GenerateMock<ITemplateSource>();
listener = new SendMailPasswordResettedEventListener(mailServiceMock, templateEngineMock,
templateSourceMock);
}
public EmailService(EmailProvider provider, ITemplateEngine templateEngine, ISubtextContext context)
{
EmailProvider = provider;
TemplateEngine = templateEngine;
Url = context.UrlHelper;
Blog = context.Blog;
Context = context;
}
public PublishingService(string sourceFolder, ITemplateEngine[] templateEngines)
{
this._templateEngines = templateEngines;
this._fileSystem = new FileSystem();
// Now lets build the context
this._context = this.BuildSiteContext(sourceFolder);
}
public ProjectBuilder(
IOptionsSnapshot <Project> p
, ILogger <ProjectBuilder> logger,
AddNewBussinessHelper addNewBussinessHelper, ITemplateEngine templateEngine)
{
_project = p.Value;
_templateEngine = templateEngine;
}
public IndexModel(IOptionsSnapshot <Project> p, IProjectBuilder projectBuilder, ITemplateEngine templateEngine, AddNewBussinessHelper addNewBussinessHelper, IMapper mapper, IHostingEnvironment hostingEnvironment)
{
_projectBuilder = projectBuilder;
_templateEngine = templateEngine;
_addNewBussinessHelper = addNewBussinessHelper;
Project = p.Value;
_mapper = mapper;
_hostingEnvironment = hostingEnvironment;
}
public NotificationsController(
INotificationsService notificationsService,
ITemplateEngine templateEngine,
ILocalizationService localizationService)
{
_notificationsService = notificationsService;
_templateEngine = templateEngine;
_localizationService = localizationService;
}
public ListGenerator(IEntityManager entityManager, IConfiguration configuration, ITemplateEngine templateEngine, IProjectFileManager projectFileManager, IFileSystem fileSystem)
: base(command, description)
{
this.entityManager = entityManager;
this.configuration = configuration;
this.templateEngine = templateEngine;
this.projectFileManager = projectFileManager;
this.fileSystem = fileSystem;
}
protected void InitDefault()
{
if (!Directory.Exists(Config.Output.Path))
{
Directory.CreateDirectory(Config.Output.Path);
}
TemplateEngine = new OfficialRazorTemplateEngine();
TemplateEngine.Initialize();
}
public ExecutionContext(ITemplateEngine templateEngine, IPatternMatcher patternMatcher, object values)
{
TemplateEngine = templateEngine;
PatternMatcher = patternMatcher;
Indent = 0;
Path = "/";
Values = values;
StartedUtc = DateTimeOffset.UtcNow;
}
public static Task <MailMessage> RenderEmailAsync(this ITemplateEngine templateEngine, string path, object viewBag = null,
CultureInfo culture = null)
{
Contract.Requires <ArgumentNullException>(templateEngine != null);
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(path));
Contract.Requires <NotSupportedException>(templateEngine.GetType() == typeof(RazorTemplateEngine), "Only razor engine is supported.");
return(templateEngine.RenderAsync(path, renderer: new EmailRenderer(), viewBag: viewBag, culture: culture));
}
public ConfiguredModule(ILogger logger, IRouteProvider provider, ITemplateEngine engine)
{
_logger = logger;
_engine = engine;
var routes = provider.GetRoutes();
foreach (var route in routes)
{
RouteBuilder builder;
switch (route.Type)
{
case RequestType.Get:
builder = Get;
break;
case RequestType.Post:
builder = Post;
break;
case RequestType.Put:
builder = Put;
break;
case RequestType.Delete:
builder = Delete;
break;
case RequestType.Head:
builder = Head;
break;
case RequestType.Options:
builder = Options;
break;
case RequestType.Patch:
builder = Patch;
break;
default:
builder = null;
break;
}
if (builder != null)
{
builder[route.Path] = _ =>
{
Func <Response> function = () => GetResponse(route, Context);
return(ExecuteWithDelay(function, route.CurrentDelayInMilliseconds));
};
}
}
}
public void SetUp()
{
configurationMock = MockRepository.GenerateMock<IConfiguration>();
projectFileManagerMock = MockRepository.GenerateMock<IProjectFileManager>();
fileSystemMock = MockRepository.GenerateMock<IFileSystem>();
templateEngineMock = new TemplateEngine(fileSystemMock);
entityGenerator = new EntityGenerator(templateEngineMock, configurationMock, projectFileManagerMock);
}
public FormGenerator(IEntityManager entityManager, IConfiguration configuration, ITemplateEngine templateEngine, IProjectFileManager projectFileManager, IFileSystem fileSystem, IAutoMapperHelper autoMapperHelper)
: base(command, description)
{
this.entityManager = entityManager;
this.configuration = configuration;
this.templateEngine = templateEngine;
this.projectFileManager = projectFileManager;
this.fileSystem = fileSystem;
this.autoMapperHelper = autoMapperHelper;
}
public ServiceGenerator(ITemplateEngine templateEngine,
IConfiguration configuration,
IProjectFileManager projectFileManager, IDepencyInjectionManager depencyInjectionManager)
: base(command, description)
{
this.templateEngine = templateEngine;
this.configuration = configuration;
this.projectFileManager = projectFileManager;
this.depencyInjectionManager = depencyInjectionManager;
}
public SecurityGenerator(IConfiguration configuration, ITemplateEngine templateEngine, IProjectFileManager projectFileManager, IDepencyInjectionManager depencyInjectionManager, IFileSystem fileSystem, IWebConfigHelper webConfigHelper)
: base(command, description)
{
this.configuration = configuration;
this.templateEngine = templateEngine;
this.projectFileManager = projectFileManager;
this.depencyInjectionManager = depencyInjectionManager;
this.fileSystem = fileSystem;
this.webConfigHelper = webConfigHelper;
}
public void SetUp()
{
entityManagerMock = MockRepository.GenerateMock<IEntityManager>();
configurationMock = MockRepository.GenerateMock<IConfiguration>();
projectFileManagerMock = MockRepository.GenerateMock<IProjectFileManager>();
fileSystemMock = MockRepository.GenerateMock<IFileSystem>();
templateEngine = new TemplateEngine(fileSystemMock);
listGenerator = new ListGenerator(entityManagerMock, configurationMock, templateEngine, projectFileManagerMock, fileSystemMock);
}
public void GivenASqlScriptProvider()
{
_templateEngine = TemplateEngine.Default;
_scriptProvider = new SqlScriptProvider(_templateEngine);
_schemaSettings = new EventStoreDatabaseSchemaSettings(
"UnitTesting",
false,
"Events_Test",
"ProjectionIndex_Test",
"ProjectionCheckpoint_Test");
}
/// <summary>
/// Initializes a new instance of the <see cref="AbstractScaffoldAction"/> class.
/// </summary>
/// <param name="modelType">Type of the model.</param>
/// <param name="templateEngine">The template engine.</param>
/// <param name="useModelName">Indicates that we should use the model name on urls</param>
/// <param name="useDefaultLayout">Whether we should use our layout.</param>
public AbstractScaffoldAction(Type modelType, ITemplateEngine templateEngine,
bool useModelName, bool useDefaultLayout)
{
this.modelType = modelType;
this.templateEngine = templateEngine;
this.useModelName = useModelName;
this.useDefaultLayout = useDefaultLayout;
// Configures the binder
binder.AutoLoad = AutoLoadBehavior.OnlyNested;
}
public void SetUp()
{
entityManagerMock = MockRepository.GenerateMock<IEntityManager>();
configurationMock = MockRepository.GenerateMock<IConfiguration>();
projectFileManagerMock = MockRepository.GenerateMock<IProjectFileManager>();
depencyInjectionManagerMock = MockRepository.GenerateMock<IDepencyInjectionManager>();
fileSystemMock = MockRepository.GenerateMock<IFileSystem>();
templateEngineMock = new TemplateEngine(fileSystemMock);
repositoryGenerator = new RepositoryGenerator(entityManagerMock, templateEngineMock, configurationMock, projectFileManagerMock, depencyInjectionManagerMock);
}
public void SetUp()
{
templateEngineMock = MockRepository.GenerateMock<ITemplateEngine>();
fileSystemMock = MockRepository.GenerateMock<IFileSystem>();
projectGenerator = new ProjectGenerator(templateEngineMock, fileSystemMock);
scaffoldingHome = Environment.GetEnvironmentVariable("scaffold_home");
if(scaffoldingHome ==null)
{
throw new Exception("scaffold_home is not set");
}
}
public String CreateScriptBlock(TextReader reader, String viewName,
IServiceProvider serviceProvider, ITemplateEngine engine)
{
XmlTextReader xmlReader = new XmlTextReader(reader);
xmlReader.Namespaces = false;
xmlReader.WhitespaceHandling = WhitespaceHandling.All;
DefaultContext context = new DefaultContext(viewName, xmlReader, serviceProvider, engine);
ProcessReader(context, 0);
return context.Script.ToString();
}
public RepositoryGenerator(IEntityManager entityManager,
ITemplateEngine templateEngine,
IConfiguration configuration,
IProjectFileManager projectFileManager,
IDepencyInjectionManager depencyInjectionManager)
: base(command, description)
{
this.entityManager = entityManager;
this.templateEngine = templateEngine;
this.configuration = configuration;
this.projectFileManager = projectFileManager;
this.depencyInjectionManager = depencyInjectionManager;
}
public Engine(ITemplateEngine templateEngine)
{
_humanizeMethod = typeof (string).GetExtensionMethod("Humanize");
ParamNameFilter = HumanizeIfAvail;
_templateEngine = templateEngine;
DbTypeDictionary = new Dictionary<DbType, string>
{
{DbType.DateTime, EmbeddedResource.Get("DateTime.html")}
};
TypeTemplateDictionary = new Dictionary<Type, string>
{
{typeof(string), EmbeddedResource.Get("String.html")},
{typeof(DateTime), EmbeddedResource.Get("DateTime.html")}
};
}
public TemplateEngineTest()
{
var fileSystemConfig = new RazorTemplateEngineConfiguration
{
ResourceProvider = new FileSystemResourceProvider("Templates"),
CachePolicy = CachePolicy.Instance
};
var embeddedResourceConfig = new RazorTemplateEngineConfiguration
{
ResourceProvider = new EmbeddedResourceProvider(
Assembly.GetExecutingAssembly(),
"Essential.Templating.Razor.Tests.Templates.Embedded"),
CachePolicy = CachePolicy.Instance
};
_fileSystemTemplateEngine = new RazorTemplateEngine(fileSystemConfig);
_embeddedResourceTemplateEngine = new RazorTemplateEngine(embeddedResourceConfig);
}
public MembershipService(IUserService userService,
ITemplateEngine templateEngine,
IMessageDeliveryService mailService,
IWebConfiguration webConfiguration,
IPasswordHasher passwordHasher,
ILocaleProvider localeProvider,
ITimeZonesProvider timeZonesProvider,
IConnectionProvider connectionProvider)
{
_userService = userService;
_templateEngine = templateEngine;
_mailService = mailService;
_webConfiguration = webConfiguration;
_passwordHasher = passwordHasher;
_localeProvider = localeProvider;
_timeZonesProvider = timeZonesProvider;
_connectionProvider = connectionProvider;
}
public NHamlViewEngineFixture()
{
nHamlEngine = A.Fake<ITemplateEngine>();
engine = new NHamlViewEngine(nHamlEngine);
A.CallTo(() => nHamlEngine.GetCompiledTemplate(A<ViewSource>.Ignored, A<Type>.Ignored))
.Returns(new TemplateFactory(typeof(DummyNHamlTemplate)));
var cache = A.Fake<IViewCache>();
A.CallTo(() => cache.GetOrAdd(A<ViewLocationResult>.Ignored, A<Func<ViewLocationResult, TemplateFactory>>.Ignored))
.ReturnsLazily(x =>
{
var result = x.GetArgument<ViewLocationResult>(0);
return x.GetArgument<Func<ViewLocationResult, TemplateFactory>>(1).Invoke(result);
});
this.renderContext = A.Fake<IRenderContext>();
A.CallTo(() => this.renderContext.ViewCache).Returns(cache);
}
