public Int32 ValidateCreate(TEMPLATE item, USUARIO usuario)
{
try
{
// Verifica existencia prévia
if (_baseService.CheckExist(item, usuario.ASSI_CD_ID) != null)
{
return(1);
}
// Completa objeto
item.ASSI_CD_ID = usuario.ASSI_CD_ID;
item.TEMP_IN_ATIVO = 1;
// Monta Log
LOG log = new LOG
{
LOG_DT_DATA = DateTime.Now,
USUA_CD_ID = usuario.USUA_CD_ID,
ASSI_CD_ID = usuario.ASSI_CD_ID,
LOG_NM_OPERACAO = "AddTEMP",
LOG_IN_ATIVO = 1,
LOG_TX_REGISTRO = Serialization.SerializeJSON <TEMPLATE>(item)
};
// Persiste
Int32 volta = _baseService.Create(item, log);
return(volta);
}
catch (Exception ex)
{
throw;
}
}
public async Task <ActionResult <Template> > CreateAsync(Template template)
{
template.Creator = User.Identity.Name;
var created = await _templateService.Create(template);
return(Ok(created));
}
public async Task <IActionResult> Create([FromBody] TemplateCreateRequestModel request)
{
if (!ModelState.IsValid)
{
var errorMessage = string.Join(string.Empty,
ModelState.SelectMany(x => x.Value.Errors)
.Select(err => err.ErrorMessage));
return(this.Result(Result.Fail(errorMessage)));
}
var newTemplate = new global::Template.Entities.Template(
Guid.NewGuid(),
request.DataSourceId,
User.Identity.Name,
request.TemplateChartType,
request.TemplateAggregateFunction,
SystemDateTime.Now,
request.Name,
new UserDefinedReturnQueryStatement(request.TemplateKeySelector),
new UserDefinedWhereQueryStatement(
request.DataSourceFilter.LeftValue,
request.DataSourceFilter.Comparator,
request.DataSourceFilter.RightValue),
new UserDefinedReturnQueryStatement(request.TemplateMapFunction));
await _templateService.Create(newTemplate);
return(this.Result(Result <Guid> .Ok(newTemplate.Id)));
}
public async Task <File> Convert(PrintFormModel printFormModel)
{
var template = await _dbRepository
.Get <TemplateFile>()
.Include(x => x.File)
.FirstOrDefaultAsync(x => x.Link == printFormModel.Template.Link)
?? await _templateService.Create(printFormModel.Template);
var renderedFile = await _renderService.Render(printFormModel, template);
var targetFileName = printFormModel.Template.FullName;
var file = new File
{
Type = FileType.Converted,
FullName = targetFileName,
Content = renderedFile
};
if (file.Content == null)
{
//log
return(null);
}
await _dbRepository.Add(file);
await _dbRepository.SaveChanges();
return(file);
}
public Int32 ValidateCreate(TEMPLATE item, USUARIO usuario, Int32?idAss)
{
try
{
// Verifica existencia prévia
// Completa objeto
item.COND_CD_ID = idAss.Value;
item.TEMP_IN_ATIVO = 1;
// Monta Log
LOG log = new LOG
{
LOG_DT_DATA = DateTime.Now,
USUA_CD_ID = usuario.USUA_CD_ID,
COND_CD_ID = idAss.Value,
LOG_NM_OPERACAO = "AddTEMP",
LOG_IN_ATIVO = 1,
LOG_TX_REGISTRO = Serialization.SerializeJSON <TEMPLATE>(item)
};
// Persiste
Int32 volta = _baseService.Create(item, log, idAss);
return(volta);
}
catch (Exception ex)
{
throw;
}
}
public void TemplateService_Create_CallInsertsTemplateAndCallsSaveChanges()
{
#region Arrange
var dateTimeNow = DateTime.Now;
var template = new Template
{
Id = 4,
Filename = "TemplateFour.xls",
TemplateData = new byte[] { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 },
InsertedBy = UserNameOne,
InsertedDate = dateTimeNow,
UpdatedBy = UserNameOne,
UpdatedDate = dateTimeNow,
};
#endregion
#region Act
var response = _templateService.Create(template);
#endregion
#region Assert
_mockTemplateRepository.Verify(x => x.Insert(It.IsAny <Template>()), Times.Once());
_mockUnitOfWork.Verify(x => x.Save(), Times.Exactly(1));
Assert.IsNotNull(response);
Assert.AreEqual(4, response);
#endregion
}
public ActionResult Create([Bind(Include = "ID,Description")] Template template)
{
if (ModelState.IsValid)
{
templateService.Create(template);
return(RedirectToAction("Index"));
}
return(View(template));
}
public void Execute(string serviceDecompositionFilePath, string filename, int templateType)
{
// Set the license for Aspose
var license = new License();
license.SetLicense("Aspose.Total.lic");
if (serviceDecompositionFilePath == null)
{
throw new ArgumentNullException(nameof(serviceDecompositionFilePath));
}
if (filename == null)
{
throw new ArgumentNullException(nameof(filename));
}
if (!Enum.IsDefined(typeof(TemplateType), templateType))
{
throw new ArgumentException(nameof(templateType));
}
if (!FileExists(serviceDecompositionFilePath))
{
throw new FileNotFoundException(serviceDecompositionFilePath);
}
if (templateType == TemplateTypeNames.SORT.GetEnumIntFromText <TemplateType>() && _templateService.All().Any(x => x.TemplateType == TemplateTypeNames.SORT.GetEnumIntFromText <TemplateType>()))
{
throw new DataImportException("A SORT Service Decomposition Template already exists, please delete before importing a new SORT spreadsheet.");
}
// Read the contents of Service Decomposition spreadsheet (This will have been uploaded via the Web UI)
var importResults = _serviceDecompositionTemplateImporter.ImportSpreadsheet(serviceDecompositionFilePath);
if (importResults.ValidationResults.Count > 0)
{
throw new DataImportException(
$"Error reading Service Decomposition Template spreadsheet ({filename}) - ", importResults.ValidationResults);
}
if (importResults.Results.Count == 0)
{
throw new DataImportException(
$"Error reading Service Decomposition Template spreadsheet ({filename}) - Spreadsheet does not contain any valid data.");
}
var template = CreateTemplate(serviceDecompositionFilePath, filename, templateType);
_transformSpreadsheetToTemplate.Transform(template, importResults.AsTemplateRows());
_templateService.Create(template);
}
public async Task <ActionResult <Guid> > Create(TemplateFileModel templateFileModel)
{
if (templateFileModel == null)
{
return(BadRequest("Template was empty"));
}
var templateFile = await _templateService.Create(templateFileModel);
return(Ok(templateFile?.Id));
}
public async Task <ActionResult> CreateTemplate()
{
try
{
await _templateService.Create()
.ConfigureAwait(false);
return(Ok());
}
catch (Exception ex)
{
_logger.LogError(ex, "POST:/create-template");
return(StatusCode(500));
}
}
public IActionResult Create([FromBody] TemplateDto templateDto)
{
_logger.LogInformation("New template id: " + templateDto.Id);
try
{
// map dto to entity
var template = _mapper.Map <Template>(templateDto);
// save
template.Id = Guid.NewGuid().ToString();
template.Timestamp = DateTime.Now;
_templateService.Create(template);
return(Ok(template));
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <IActionResult> Create([FromBody] TemplateModel model)
{
await _templateService.Create(model);
return(NoContent());
}
public async Task <ActionResult> Post([FromBody] Template template)
{
var result = await _service.Create(template);
return(Created(nameof(Get), result));
}
public async Task Create([FromBody] AddTemplateViewModel model)
{
await _service.Create(model);
}
public static void Add(string text, long protParmId)
{
templateService.Create(text, protParmId);
}
public Task Create(Template.Entities.Template template)
{
return(_templateService.Create(template));
}
