/// <summary>
/// Private method to create a content object from a DocumentDto, which is used by Get and GetByVersion.
/// </summary>
/// <param name="dto"></param>
/// <param name="contentType"></param>
/// <param name="template"></param>
/// <param name="propCollection"></param>
/// <returns></returns>
private IContent CreateContentFromDto(DocumentDto dto,
IContentType contentType,
ITemplate template,
Models.PropertyCollection propCollection)
{
var factory = new ContentFactory(contentType, NodeObjectTypeId, dto.NodeId);
var content = factory.BuildEntity(dto);
//Check if template id is set on DocumentDto, and get ITemplate if it is.
if (dto.TemplateId.HasValue && dto.TemplateId.Value > 0)
{
content.Template = template ?? _templateRepository.Get(dto.TemplateId.Value);
}
else
{
//ensure there isn't one set.
content.Template = null;
}
content.Properties = propCollection;
//on initial construction we don't want to have dirty properties tracked
// http://issues.umbraco.org/issue/U4-1946
((Entity)content).ResetDirtyProperties(false);
return(content);
}
/// <summary>
/// Gets a <see cref="ITemplate"/> object by its alias.
/// </summary>
/// <param name="alias">The alias of the template.</param>
/// <returns>The <see cref="ITemplate"/> object matching the alias, or null.</returns>
public ITemplate GetTemplate(string alias)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
{
return(_templateRepository.Get(alias));
}
}
public void Can_Perform_Delete_View()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
ITemplateRepository repository = CreateRepository(provider);
var template = new Template(ShortStringHelper, "test", "test")
{
Content = "mock-content"
};
repository.Save(template);
// Act
ITemplate templates = repository.Get("test");
Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True);
repository.Delete(templates);
// Assert
Assert.IsNull(repository.Get("test"));
Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.False);
}
}
public List <Template> GetTemplates(string clientID)
{
try
{
return(_repository.Get(t => t.ClientID == clientID)
.ToList());
}
catch (Exception ex)
{ throw ex; }
}
public ActionResult <Result <bool> > UpdateModel([FromBody] UpdateTemplateModelRQ body)
{
var templateEntity = _templateRepo.Get(body.Id);
var scriptExeRes = _microsoftSQLService.ExecuteSQLAsAdmin(body.SqlScript, templateEntity.NameOnServer);
if (scriptExeRes.Messages.Any())
{
return(Result <bool> .Fail(scriptExeRes.Messages));
}
return(Result <bool> .Success(true));
}
public IActionResult Model(int templateId)
{
var templateEntity = _templateRepo.Get(templateId);
var vm = new TemplateModelVM() //AutoMapper
{
Id = templateEntity.Id,
TimeStamp = Convert.ToBase64String(templateEntity.TimeStamp),
TemplateName = templateEntity.Name,
DatabaseName = templateEntity.NameOnServer
};
return(View(vm));
}
public ActionResult <Result <bool> > CreateInstance([FromBody] CreateExerciseInstanceRQ body)
{
#region Map_User
var isUserMapped = _userRepo.IsMapped(UserId);
if (!isUserMapped)
{
var sqlUsername = NameHelper.GenerateSqlUserName(UserId);
var sqlPass = NameHelper.GenerateRandomSqlPassowrd();
var mapSaveSuccess = _userRepo.CreateMapping(UserId, sqlUsername, sqlPass, UserId);
if (!mapSaveSuccess)
{
return(Result <bool> .Fail("Error mapping user."));
}
}
var userMapEntity = _userRepo.Get(UserId);
#endregion
#region Check_Name
var exerciseExists = _exerciseRepo.NameExists(body.Name, UserId);
if (exerciseExists)
{
return(Result <bool> .Fail($"Instance '{body.Name}' already exists."));
}
#endregion
#region Clone_DB
var nameOnServer = NameHelper.ExerciseName();
var templateEntity = _templateRepo.Get(body.TemplateId);
var cloneSuccess = _msSqlService.CloneDatabase(templateEntity.NameOnServer, nameOnServer, false, true);
if (!cloneSuccess)
{
return(Result <bool> .Fail("Failed to clone database."));
}
#endregion
#region Create_DB_User
var createSuccess = _msSqlService.CreateDbUserContained(userMapEntity.SqlUsername, userMapEntity.SqlPassword, nameOnServer);
if (!createSuccess)
{
return(Result <bool> .Fail("Failed to create database user."));
}
var assignSuccess = _msSqlService.AssignCRUD(userMapEntity.SqlUsername, nameOnServer);
if (!assignSuccess)
{
return(Result <bool> .Fail("Failed to assign database user permissions."));
}
#endregion
#region Save_Record
var saveSuccess = _exerciseRepo.Create(body.TemplateId, UserId, body.Name, nameOnServer, UserId);
if (!saveSuccess)
{
return(Result <bool> .Fail("Failed to save record."));
}
#endregion
return(Result <bool> .Success(true));
}
public void Can_Perform_Update_View()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
ITemplateRepository repository = CreateRepository(provider);
// Act
var template = new Template(ShortStringHelper, "test", "test")
{
Content = "mock-content"
};
repository.Save(template);
template.Content += "<html></html>";
repository.Save(template);
ITemplate updated = repository.Get("test");
// Assert
Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True);
Assert.That(updated.Content, Is.EqualTo("mock-content" + "<html></html>"));
}
}
public void SendActivationRequest(ActivationRequest activationRequest)
{
Template activationTemplate = _templateRepository.Get("ActivationTemplate.html");
string notification = activationTemplate.Apply(activationRequest.ToDictionary());
_notificationSender.SendNotification(notification, activationRequest.Email.Value);
}
public async Task <IActionResult> OnPostCreateTemplateVersion()
{
// TODO: Error handling
TemplateTbl?template = (await _templateTbl.Get(x => x.Id.Equals(CreateTemplateVersion.TemplateId), null, nameof(TemplateTbl.Versions))).FirstOrDefault();
if (template == null)
{
throw new NullReferenceException();
}
CreateTemplateVersion.Name = "Untitled name";
CreateTemplateVersion.Subject = "Default subject";
CreateTemplateVersion.Html = string.Empty;
CreateTemplateVersion.TestData = "{}";
if (!template.Versions?.Any() ?? true)
{
CreateTemplateVersion.IsActive = true;
}
TemplateVersionTbl result = await _templateVersionTbl.Add(CreateTemplateVersion);
await _projectTbl.UpdateFromQuery(x => x.Id.Equals(MarkAsActive.ProjectId), _ => new ProjectTbl
{
DateModified = DateTime.Now
});
TempData["toastStatus"] = "success";
TempData["toastMessage"] = "Template version created";
TempData["scrollToId"] = $"version-{result.Id}";
return(RedirectToPage("/Project/Details", new { id = template.ProjectId }));
}
public void Can_Perform_Add_View_With_Default_Content_With_Parent()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
ITemplateRepository repository = CreateRepository(provider);
// NOTE: This has to be persisted first
var template = new Template(ShortStringHelper, "test", "test");
repository.Save(template);
// Act
var template2 = new Template(ShortStringHelper, "test2", "test2");
template2.SetMasterTemplate(template);
repository.Save(template2);
// Assert
Assert.That(repository.Get("test2"), Is.Not.Null);
Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test2.cshtml"), Is.True);
Assert.AreEqual(
"@usingUmbraco.Cms.Web.Common.PublishedModels;@inherits Umbraco.Cms.Web.Common.Views.UmbracoViewPage @{ Layout = \"test.cshtml\";}".StripWhitespace(),
template2.Content.StripWhitespace());
}
}
private string CreateDefaultMasterPageContent(ITemplate template, ITemplateRepository templateRepo)
{
var design = new StringBuilder();
design.Append(GetMasterPageHeader(template) + Environment.NewLine);
if (template.MasterTemplateAlias.IsNullOrWhiteSpace() == false)
{
var master = templateRepo.Get(template.MasterTemplateAlias);
if (master != null)
{
foreach (var cpId in GetContentPlaceholderIds(master))
{
design.Append("<asp:content ContentPlaceHolderId=\"" + cpId + "\" runat=\"server\">" +
Environment.NewLine +
Environment.NewLine +
"</asp:content>" +
Environment.NewLine +
Environment.NewLine);
}
return(design.ToString());
}
}
design.Append(GetMasterContentElement(template) + Environment.NewLine);
design.Append(template.Content + Environment.NewLine);
design.Append("</asp:Content>" + Environment.NewLine);
return(design.ToString());
}
public void Can_Perform_Delete_When_Assigned_To_Doc()
{
// Arrange
IScopeProvider provider = ScopeProvider;
var scopeAccessor = (IScopeAccessor)provider;
IDataTypeService dataTypeService = GetRequiredService <IDataTypeService>();
IFileService fileService = GetRequiredService <IFileService>();
using (provider.CreateScope())
{
ITemplateRepository templateRepository = CreateRepository(provider);
var globalSettings = new GlobalSettings();
var serializer = new JsonNetSerializer();
var tagRepository = new TagRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <TagRepository>());
var commonRepository = new ContentTypeCommonRepository(scopeAccessor, templateRepository, AppCaches, ShortStringHelper);
var languageRepository = new LanguageRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <LanguageRepository>(), Microsoft.Extensions.Options.Options.Create(globalSettings));
var contentTypeRepository = new ContentTypeRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <ContentTypeRepository>(), commonRepository, languageRepository, ShortStringHelper);
var relationTypeRepository = new RelationTypeRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <RelationTypeRepository>());
var entityRepository = new EntityRepository(scopeAccessor, AppCaches.Disabled);
var relationRepository = new RelationRepository(scopeAccessor, LoggerFactory.CreateLogger <RelationRepository>(), relationTypeRepository, entityRepository);
var propertyEditors = new PropertyEditorCollection(new DataEditorCollection(() => Enumerable.Empty <IDataEditor>()));
var dataValueReferences = new DataValueReferenceFactoryCollection(() => Enumerable.Empty <IDataValueReferenceFactory>());
var contentRepo = new DocumentRepository(scopeAccessor, AppCaches.Disabled, LoggerFactory.CreateLogger <DocumentRepository>(), LoggerFactory, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditors, dataValueReferences, dataTypeService, serializer, Mock.Of <IEventAggregator>());
Template template = TemplateBuilder.CreateTextPageTemplate();
fileService.SaveTemplate(template); // else, FK violation on contentType!
ContentType contentType = ContentTypeBuilder.CreateSimpleContentType("umbTextpage2", "Textpage", defaultTemplateId: template.Id);
contentTypeRepository.Save(contentType);
Content textpage = ContentBuilder.CreateSimpleContent(contentType);
contentRepo.Save(textpage);
textpage.TemplateId = template.Id;
contentRepo.Save(textpage);
// Act
ITemplate templates = templateRepository.Get("textPage");
templateRepository.Delete(templates);
// Assert
Assert.IsNull(templateRepository.Get("textPage"));
}
}
public ActionResult <Result <bool> > CreateTask([FromBody] CreateTaskRQ body)
{
if (string.IsNullOrEmpty(body.Name))
{
return(Result <bool> .Fail("Name cannot be empty."));
}
if (body.TemplateId <= 0)
{
return(Result <bool> .Fail("A template must be selected."));
}
var taskExists = _taskRepo.TaskExists(body.Name);
if (taskExists)
{
return(Result <bool> .Fail($"Task '{body.Name}' already exists."));
}
var newDbName = NameHelper.TaskName();
var alreadyRegistered = _taskRepo.DatabaseRegisteredAsTask(newDbName);
if (alreadyRegistered)
{
return(Result <bool> .Fail($"Generated name is already used for another task. Please try again."));
}
var existsOnSqlServer = _microsoftSQLService.DatabaseExists(newDbName);
if (existsOnSqlServer)
{
return(Result <bool> .Fail($"Generated name is not unique. Please try again."));
}
var templateEntity = _templateRepo.Get(body.TemplateId);
var cloneSuccess = _microsoftSQLService.CloneDatabase(templateEntity.NameOnServer, newDbName, true, true);
if (!cloneSuccess)
{
return(Result <bool> .Fail($"Failed to clone database '{templateEntity.NameOnServer}' into '{newDbName}'."));
}
var success = _taskRepo.Create(body, newDbName, UserId);
if (success)
{
return(Result <bool> .Success(true));
}
else
{
return(Result <bool> .Fail("Failed to save changes."));
}
}
public void Can_Perform_Delete_On_Nested_Templates()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
ITemplateRepository repository = CreateRepository(provider);
var parent = new Template(ShortStringHelper, "parent", "parent")
{
Content = @"<%@ Master Language=""C#"" %>"
};
var child = new Template(ShortStringHelper, "child", "child")
{
Content = @"<%@ Master Language=""C#"" %>"
};
var baby = new Template(ShortStringHelper, "baby", "baby")
{
Content = @"<%@ Master Language=""C#"" %>"
};
child.MasterTemplateAlias = parent.Alias;
child.MasterTemplateId = new Lazy <int>(() => parent.Id);
baby.MasterTemplateAlias = child.Alias;
baby.MasterTemplateId = new Lazy <int>(() => child.Id);
repository.Save(parent);
repository.Save(child);
repository.Save(baby);
// Act
ITemplate templates = repository.Get("parent");
repository.Delete(templates);
// Assert
Assert.IsNull(repository.Get("test"));
}
}
public void Can_Perform_Add_View()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
ITemplateRepository repository = CreateRepository(provider);
// Act
var template = new Template(ShortStringHelper, "test", "test");
repository.Save(template);
// Assert
Assert.That(repository.Get("test"), Is.Not.Null);
Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True);
}
}
/// <summary>
/// Private method to create a content object from a DocumentDto, which is used by Get and GetByVersion.
/// </summary>
/// <param name="dto"></param>
/// <param name="versionId"></param>
/// <returns></returns>
private IContent CreateContentFromDto(DocumentDto dto, Guid versionId)
{
var contentType = _contentTypeRepository.Get(dto.ContentVersionDto.ContentDto.ContentTypeId);
var factory = new ContentFactory(contentType, NodeObjectTypeId, dto.NodeId);
var content = factory.BuildEntity(dto);
//Check if template id is set on DocumentDto, and get ITemplate if it is.
if (dto.TemplateId.HasValue && dto.TemplateId.Value > 0)
{
content.Template = _templateRepository.Get(dto.TemplateId.Value);
}
content.Properties = GetPropertyCollection(dto.NodeId, versionId, contentType, content.CreateDate, content.UpdateDate);
((ICanBeDirty)content).ResetDirtyProperties();
return(content);
}
protected override IContentType PerformGet(int id)
{
var contentTypeSql = GetBaseQuery(false);
contentTypeSql.Where(GetBaseWhereClause(), new { Id = id });
// The SQL will contain one record for each allowed template, so order to put the default one
// at the top to populate the default template property correctly.
contentTypeSql.OrderByDescending <DocumentTypeDto>(x => x.IsDefault);
var dto = Database.Fetch <DocumentTypeDto, ContentTypeDto, NodeDto>(contentTypeSql).FirstOrDefault();
if (dto == null)
{
return(null);
}
var factory = new ContentTypeFactory(NodeObjectTypeId);
var contentType = factory.BuildEntity(dto);
contentType.AllowedContentTypes = GetAllowedContentTypeIds(id);
contentType.PropertyGroups = GetPropertyGroupCollection(id, contentType.CreateDate, contentType.UpdateDate);
((ContentType)contentType).PropertyTypes = GetPropertyTypeCollection(id, contentType.CreateDate, contentType.UpdateDate);
var templates = Database.Fetch <DocumentTypeDto>("WHERE contentTypeNodeId = @Id", new { Id = id });
if (templates.Any())
{
contentType.AllowedTemplates = templates.Select(template => _templateRepository.Get(template.TemplateNodeId)).ToList();
}
var list = Database.Fetch <ContentType2ContentTypeDto>("WHERE childContentTypeId = @Id", new { Id = id });
foreach (var contentTypeDto in list)
{
bool result = contentType.AddContentType(Get(contentTypeDto.ParentId));
//Do something if adding fails? (Should hopefully not be possible unless someone created a circular reference)
}
//on initial construction we don't want to have dirty properties tracked
// http://issues.umbraco.org/issue/U4-1946
((Entity)contentType).ResetDirtyProperties(false);
return(contentType);
}
/// <summary>
/// Private method to create a content object from a DocumentDto, which is used by Get and GetByVersion.
/// </summary>
/// <param name="dto"></param>
/// <param name="versionId"></param>
/// <returns></returns>
private IContent CreateContentFromDto(DocumentDto dto, Guid versionId)
{
var contentType = _contentTypeRepository.Get(dto.ContentVersionDto.ContentDto.ContentTypeId);
var factory = new ContentFactory(contentType, NodeObjectTypeId, dto.NodeId);
var content = factory.BuildEntity(dto);
//Check if template id is set on DocumentDto, and get ITemplate if it is.
if (dto.TemplateId.HasValue && dto.TemplateId.Value > 0)
{
content.Template = _templateRepository.Get(dto.TemplateId.Value);
}
content.Properties = GetPropertyCollection(dto.NodeId, versionId, contentType, content.CreateDate, content.UpdateDate);
//on initial construction we don't want to have dirty properties tracked
// http://issues.umbraco.org/issue/U4-1946
((Entity)content).ResetDirtyProperties(false);
return(content);
}
public async Task <IActionResult> Get(string type, string year)
{
if (!ReportType.Values().Contains(type))
{
return(new BadRequestObjectResult(new ErrorResponse($"Invalid ReportType '{type}'.")));
}
var template = await Task.Run(() => _templates.Get(ReportType.FromString(type), year));
if (template == null)
{
return(NotFound());
}
var stream = new MemoryStream(template.Content);
return(new FileStreamResult(stream, ContentTypes.XLSX)
{
FileDownloadName = template.Name,
});
}
public void Can_Perform_Add_View_With_Default_Content()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
ITemplateRepository repository = CreateRepository(provider);
// Act
var template = new Template(ShortStringHelper, "test", "test")
{
Content = "mock-content"
};
repository.Save(template);
// Assert
Assert.That(repository.Get("test"), Is.Not.Null);
Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True);
Assert.AreEqual("mock-content", template.Content.StripWhitespace());
}
}
public void Can_Perform_Add_View_With_Default_Content()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
ITemplateRepository repository = CreateRepository(provider);
// Act
var template = new Template(ShortStringHelper, "test", "test")
{
Content = ViewHelper.GetDefaultFileContent()
};
repository.Save(template);
// Assert
Assert.That(repository.Get("test"), Is.Not.Null);
Assert.That(FileSystems.MvcViewsFileSystem.FileExists("test.cshtml"), Is.True);
Assert.AreEqual(
@"@usingUmbraco.Cms.Web.Common.PublishedModels;@inheritsUmbraco.Cms.Web.Common.Views.UmbracoViewPage@{Layout=null;}".StripWhitespace(),
template.Content.StripWhitespace());
}
}
public T Get(Guid id)
{
return(_repo.Get(id));
}
public async Task <Template> Get(string id) => await _templates.Get(id);
public async Task <Result <IList <Tuple <string, string> > > > Execute(string userId, Guid templateId)
{
var template = await _templateRepository.Get(templateId);
if (template.UserId != userId)
{
return(Result <IList <Tuple <string, string> > > .Fail($"Attempt to execute non-existing template '{templateId}'"));
}
var dataSource = await _dataSourceRepository.FindAsync(template.DataSourceId, true);
var samples = new[]
{
template.KeySelector.ReturnValue,
template.DataSourceFilter.LeftVal,
template.MapFunction.ReturnValue
};
var commonPrefix = new string(
samples.First().Substring(0, samples.Min(s => s.Length))
.TakeWhile((c, i) => samples.All(s => s[i] == c)).ToArray());
var leftValWithoutPrefix = template.DataSourceFilter.LeftVal.Substring(commonPrefix.Length);
var keySelectorWithoutPrefix = template.KeySelector.ReturnValue.Substring(commonPrefix.Length);
var mapFunctionWithoutPrefix = template.MapFunction.ReturnValue.Substring(commonPrefix.Length);
var leftValComponents = leftValWithoutPrefix.Split('.');
var finalComponent = leftValComponents.Last();
var leftValComponentsWithoutFinalComponent = leftValComponents.Take(leftValComponents.Length - 1).ToList();
var rightVal = template.DataSourceFilter.RightVal;
var dataType = dataSource.Schema.Single(x => x.FullName == template.DataSourceFilter.LeftVal);
if (dataType.Origin == DataTypeOrigin.Attribute)
{
finalComponent = $"@{finalComponent}";
}
if (dataType.DataType == "string")
{
rightVal = $"'{rightVal}'";
}
var dataSourceFilterQueryBuilder =
new StringBuilder()
.Append("/")
.Append(string.Join("/", commonPrefix.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries)))
.Append("[")
.Append(string.Join("/", leftValComponentsWithoutFinalComponent));
if (leftValComponentsWithoutFinalComponent.Any())
{
dataSourceFilterQueryBuilder.Append("/");
}
var dataSourceFilterQuery = dataSourceFilterQueryBuilder
.Append(finalComponent)
.Append(template.DataSourceFilter.Comparator)
.Append(rightVal)
.Append("]")
.ToString();
var keySelectorQuery = new StringBuilder()
.Append("./")
.Append(string.Join("/", keySelectorWithoutPrefix.Split('.')))
.ToString();
var mapFunctionQuery = new StringBuilder()
.Append("./")
.Append(string.Join("/", mapFunctionWithoutPrefix.Split('.')))
.ToString();
var ms = new MemoryStream(dataSource.Value, 0, dataSource.Value.Length);
var xDoc = new XmlDocument();
xDoc.Load(ms);
var xRoot = xDoc.DocumentElement;
var toReturn = new List <Tuple <string, string> >();
if (xRoot is null)
{
return(toReturn);
}
// ReSharper disable once PossibleNullReferenceException
foreach (var node in xRoot.SelectNodes(dataSourceFilterQuery))
{
var xmlNode = (XmlElement)node;
var key = xmlNode.SelectSingleNode(keySelectorQuery);
var value = xmlNode.SelectSingleNode(mapFunctionQuery);
if (key != null && value != null)
{
toReturn.Add(new Tuple <string, string>(key.InnerText, value.InnerText));
}
}
return(toReturn);
}
