public async Task <Result> DeleteAsync(Guid templateId, DeleteTemplate request, Guid userId)
{
var template = await _templates
.Find(x => x.Id == templateId)
.FirstOrDefaultAsync();
if (template is null)
{
return(Result.NotFound);
}
if (template.Deleted > 0)
{
return(Result.Gone);
}
_logger.LogInformation($"Trying to delete template {template.Id}");
var templateDeleted = template.On(request, userId);
await _templates.ReplaceOneAsync(x => x.Id == templateId, template);
await _eventService.PublishAsync(templateDeleted);
_logger.LogInformation($"Template {template.Id} deleted");
return(Result.Successful);
}
public async Task Execute(DeleteTemplate command)
{
var item = writeContext.ElrSearchTemplates.Where(l => l.Id.Equals(command.Id)).FirstOrDefault();
writeContext.ElrSearchTemplates.Remove(item);
await writeContext.SaveChangesAsync();
}
public async Task <IActionResult> DeleteTemplate([FromRoute] DeleteTemplate command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await elrService.Execute(command);
return(Ok());
}
public void DeleteView_Template_Test()
{
var template = new DeleteTemplate(new EntityInfo()
{
Id = _entityId
}, ApplicationId);
var output = template.TransformText();
Assert.NotNull(output);
Assert.NotEmpty(output);
Assert.Contains($"@model {ApplicationId}.Backend.DataModels.{_entityId}", output);
}
public async Task <DeleteTemplateResponse> Delete(DeleteTemplate model)
{
VerifyPermission(Permissions.Delete, Modules.BonusTemplateManager);
var template = await _bonusApiProxy.GetTemplateOrNull(model.TemplateId);
if (template != null)
{
CheckBrand(template.Info.BrandId);
}
return(await _bonusApiProxy.DeleteBonusTemplateAsync(model));
}
public void TestMethod1()
{
DbConnection dbConn = new DbConnection();
dbConn.connect();
Admin admin = new Admin();
admin.Id = 51;
DeleteTemplate dltTem = new DeleteTemplate();
int resp = dltTem.deleteData(dbConn.getConn(), admin);
Assert.IsNotNull(resp);
}
public void Should_throw_exception_when_template_is_not_found()
{
var command = new DeleteTemplate
{
Id = Guid.NewGuid()
};
var repositoryMock = new Mock<ITemplateRepository>();
repositoryMock.Setup(x => x.GetById(command.Id)).Returns((Template)null);
var deleteTemplateHandler = new DeleteTemplateHandler(repositoryMock.Object);
Assert.Throws<Exception>(() => deleteTemplateHandler.Handle(command));
}
public DeleteTemplateResponse Delete(DeleteTemplate model)
{
var validationResult = _bonusQueries.GetValidationResult(model);
if (!validationResult.IsValid)
{
return(ValidationErrorResponse <DeleteTemplateResponse>(validationResult));
}
_bonusCommands.DeleteTemplate(model);
return(new DeleteTemplateResponse {
Success = true
});
}
public override void StaticSqlStringCache(SqlModel model, Type type)
{
GsOperator gs = new GsOperator(typeof(SqlEntity <>), type);
gs["SetPrimary"] = MebOperator.Setter(type, model.PrimaryKey);
gs["Table"] = model.TableName;
gs["Primary"] = model.PrimaryKey;
CountTemplate count = new CountTemplate();
gs["SelectCount"] = count.SelectCount(model);
gs["SelectCountWhere"] = count.SelectCountWhere(model);
SelectTemplate select = new SelectTemplate();
gs["SelectAll"] = select.SelectAll(model);
gs["SelectAllWhere"] = select.SelectAllWhere(model);
gs["SelectAllByPrimary"] = select.SelectAllByPrimary(model);
gs["SelectAllIn"] = select.SelectAllIn(model);
UpdateTemplate update = new UpdateTemplate();
gs["UpdateAllWhere"] = update.UpdateWhere(model);
gs["UpdateAllByPrimary"] = update.UpdateByPrimary(model);
InsertTemplate insert = new InsertTemplate();
gs["InsertAll"] = insert.Insert(model);
DeleteTemplate delete = new DeleteTemplate();
gs["DeleteWhere"] = delete.DeleteWhere(model);
gs["DeleteByPrimary"] = delete.DeleteByPrimary(model);
RepeateTemplate repeate = new RepeateTemplate();
var repeateModel = model.ModelWithAttr <NoRepeateAttribute>();
gs["RepeateCount"] = repeate.RepeateCount(repeateModel);
gs["RepeateId"] = repeate.RepeateId(repeateModel);
gs["RepeateEntities"] = repeate.RepeateEntities(repeateModel);
}
public void Should_update_template()
{
var command = new DeleteTemplate
{
Id = Guid.NewGuid()
};
var templateMock = new Mock<Template>();
var repositoryMock = new Mock<ITemplateRepository>();
repositoryMock.Setup(x => x.GetById(command.Id)).Returns(templateMock.Object);
var deleteTemplateHandler = new DeleteTemplateHandler(repositoryMock.Object);
deleteTemplateHandler.Handle(command);
repositoryMock.Verify(x => x.Update(It.IsAny<Template>()));
}
public void DeleteTemplate(DeleteTemplate model)
{
var validationResult = _bonusQueries.GetValidationResult(model);
if (validationResult.IsValid == false)
{
throw new RegoException(validationResult.Errors.First().ErrorMessage);
}
var templates = _repository.Templates.Where(t => t.Id == model.TemplateId);
templates.ToList().ForEach(template => template.Status = TemplateStatus.Deleted);
var lastVersion = templates.Max(t => t.Version);
var lastTemplate = templates.Single(t => t.Version == lastVersion);
lastTemplate.UpdatedOn = DateTimeOffset.Now.ToBrandOffset(lastTemplate.Info.Brand.TimezoneId);
lastTemplate.UpdatedBy = _actorInfoProvider.Actor.UserName;
_repository.SaveChanges();
}
private void TransformViews(SmartAppInfo manifest)
{
var enabledEntities = manifest.DataModel.Entities.Where(e => !e.IsAbstract);
foreach (var entity in enabledEntities)
{
var applicationId = manifest.Id;
var createTemplate = new CreateTemplate(entity, applicationId);
var editTemplate = new EditTemplate(entity, applicationId);
var detailTemplate = new DetailsTemplate(entity, applicationId);
var deleteTemplate = new DeleteTemplate(entity, applicationId);
var indexTemplate = new IndexTemplate(entity, applicationId);
_writingService.WriteFile(Path.Combine(_context.BasePath, createTemplate.OutputPath, entity.Id, "Create.cshtml"), createTemplate.TransformText());
_writingService.WriteFile(Path.Combine(_context.BasePath, editTemplate.OutputPath, entity.Id, "Edit.cshtml"), editTemplate.TransformText());
_writingService.WriteFile(Path.Combine(_context.BasePath, deleteTemplate.OutputPath, entity.Id, "Delete.cshtml"), deleteTemplate.TransformText());
_writingService.WriteFile(Path.Combine(_context.BasePath, detailTemplate.OutputPath, entity.Id, "Details.cshtml"), detailTemplate.TransformText());
_writingService.WriteFile(Path.Combine(_context.BasePath, indexTemplate.OutputPath, entity.Id, "Index.cshtml"), indexTemplate.TransformText());
}
}
public ValidationResult GetValidationResult(DeleteTemplate model)
{
return(new TemplateDeletionValidator(this).Validate(model));
}
public void DeleteView_Template_NullParameter_Test()
{
var template = new DeleteTemplate(null, null);
Assert.Throws <ArgumentNullException>(() => template.TransformText());
}
public DeleteTemplateResponse DeleteBonusTemplate(DeleteTemplate request)
{
return(WebClient.SecurePostAsJson <DeleteTemplate, DeleteTemplateResponse>(Token, _url + AdminApiRoutes.DeleteBonusTemplate, request));
}
public Task <DeleteTemplateResponse> DeleteBonusTemplateAsync(DeleteTemplate request)
{
return(SecurePostAsJson <DeleteTemplate, DeleteTemplateResponse>(Routes.DeleteBonusTemplate, request));
}
protected override void Execute(CodeActivityContext executionContext)
{
EntityReference DocumentTemplateIdValue = DocumentTemplateId.Get(executionContext);
Boolean EnableLoggingValue = EnableLogging.Get(executionContext);
string ProductUriValue = ProductUri.Get(executionContext);
string AppSIDValue = AppSID.Get(executionContext);
string AppKeyValue = AppKey.Get(executionContext);
Boolean DeleteTemplateValue = DeleteTemplate.Get(executionContext);
Boolean DeleteDocumentValue = DeleteDocument.Get(executionContext);
OutputAttachmentId.Set(executionContext, new EntityReference("annotation", Guid.Empty));
CloudAppConfig config = new CloudAppConfig();
config.ProductUri = ProductUriValue;
config.AppSID = AppSIDValue;
config.AppKey = AppKeyValue;
IWorkflowContext context = executionContext.GetExtension <IWorkflowContext>();
IOrganizationServiceFactory serviceFactory = executionContext.GetExtension <IOrganizationServiceFactory>();
IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);
try
{
if (EnableLoggingValue)
{
Log("WorkFlow Started", service);
}
string PrimaryEntityName = context.PrimaryEntityName;
Guid PrimaryEntityId = context.PrimaryEntityId;
if (EnableLoggingValue)
{
Log("Retrieving Attachment From Template", service);
}
QueryExpression RetrieveNoteQuery = new QueryExpression("annotation");
RetrieveNoteQuery.ColumnSet = new ColumnSet(new string[] { "filename", "documentbody", "mimetype" });
RetrieveNoteQuery.Criteria.AddCondition(new ConditionExpression("objectid", ConditionOperator.Equal, DocumentTemplateIdValue.Id));
EntityCollection TemplateAttachments = service.RetrieveMultiple(RetrieveNoteQuery);
if (EnableLoggingValue)
{
Log("Attachment Retrieved Successfully", service);
}
if (TemplateAttachments != null && TemplateAttachments.Entities.Count > 0)
{
Entity AttachmentTemplate = TemplateAttachments.Entities[0];
if (AttachmentTemplate.Contains("mimetype") && AttachmentTemplate.Contains("documentbody"))
{
string FileName = "";
if (AttachmentTemplate.Contains("filename"))
{
FileName = AttachmentTemplate["filename"].ToString();
}
config.FileName = FileName;
byte[] DocumentBody = Convert.FromBase64String(AttachmentTemplate["documentbody"].ToString());
MemoryStream fileStream = new MemoryStream(DocumentBody);
if (EnableLoggingValue)
{
Log("Upload Template on Storage", service);
}
UploadFileOnStorage(config, fileStream);
if (EnableLoggingValue)
{
Log("Get Fields List", service);
}
string[] Fields = GetFieldsName(config).ToArray();
if (EnableLoggingValue)
{
Log("Retrieving Fields Values From CRM", service);
}
Entity PrimaryEntity = service.Retrieve(PrimaryEntityName, PrimaryEntityId, new ColumnSet(Fields));
string[] Values = new string[Fields.Length];
if (PrimaryEntity != null)
{
for (int i = 0; i < Fields.Length; i++)
{
if (PrimaryEntity.Contains(Fields[i]))
{
if (PrimaryEntity[Fields[i]].GetType() == typeof(OptionSetValue))
{
Values[i] = PrimaryEntity.FormattedValues[Fields[i]].ToString();
}
else if (PrimaryEntity[Fields[i]].GetType() == typeof(EntityReference))
{
Values[i] = ((EntityReference)PrimaryEntity[Fields[i]]).Name;
}
else
{
Values[i] = PrimaryEntity[Fields[i]].ToString();
}
}
else
{
Values[i] = "";
}
}
}
if (EnableLoggingValue)
{
Log("Generating Xml", service);
}
string Xml = GenerateXML(Fields, Values);
if (EnableLoggingValue)
{
Log("Executing MailMerge", service);
}
string OutputFileName = ExecuteMailMerge(config, Xml);
if (EnableLoggingValue)
{
Log("Downloading File From Cloud", service);
}
MemoryStream OutputFile = DownloadFile(config, OutputFileName);
if (EnableLoggingValue)
{
Log("Generating CRM Attachment", service);
}
byte[] byteData = OutputFile.ToArray();
string encodedData = System.Convert.ToBase64String(byteData);
Entity NewNote = new Entity("annotation");
NewNote.Attributes.Add("objectid", new EntityReference(PrimaryEntityName, PrimaryEntityId));
NewNote.Attributes.Add("subject", FileName);
NewNote.Attributes.Add("documentbody", encodedData);
NewNote.Attributes.Add("mimetype", @"application/vnd.openxmlformats-officedocument.wordprocessingml.document");
NewNote.Attributes.Add("notetext", "Document Created using Aspose Cloud");
NewNote.Attributes.Add("filename", FileName);
Guid NewNoteId = service.Create(NewNote);
if (EnableLoggingValue)
{
Log("Removing Documents from Storage", service);
}
if (DeleteTemplateValue)
{
DeleteDocumentFromStorage(config, FileName);
}
if (DeleteDocumentValue)
{
DeleteDocumentFromStorage(config, OutputFileName);
}
OutputAttachmentId.Set(executionContext, new EntityReference("annotation", NewNoteId));
}
else
{
if (EnableLoggingValue)
{
Log("Attachment Doesnot contain any document", service);
}
}
}
else
{
if (EnableLoggingValue)
{
Log("No Attachments in the Template Provided", service);
}
}
if (EnableLoggingValue)
{
Log("Workflow Executed Successfully", service);
}
}
catch (Exception ex)
{
Log(ex.Message, service);
throw ex;
}
}
