public async Task <IActionResult> Replace(Guid fileUniqId, [FromBody] ReplaceRequest request)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var callerEmail = User.FindFirst(ClaimTypes.NameIdentifier).Value;
await _fileService.ReplaceFileAsync(callerEmail, fileUniqId, request);
if (!_fileService.State.IsValid)
{
return(ServiceResponseDispatcher.ExecuteServiceResponse(this, _fileService.State.TypeOfError,
_fileService.State.ErrorMessage));
}
return(StatusCode(204));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public void Replace_Watermark_Test()
{
var testFile = TestFiles.PdfWithWatermarks;
var options = new ReplaceOptions
{
FileInfo = testFile.ToFileInfo(),
ImageSearchCriteria = new ImageSearchCriteria
{
ImageFileInfo = TestFiles.SampleWatermarkTransparent.ToFileInfo()
},
TextSearchCriteria = new TextSearchCriteria
{
SearchText = "Watermark text"
},
ReplaceTextOptions = new ReplaceTextOptions
{
Text = "New watermark text",
},
ReplaceImageOptions = new ReplaceImageOptions
{
Image = TestFiles.Jpg.ToFileInfo()
}
};
var request = new ReplaceRequest(options);
var result = WatermarkApi.Replace(request);
CheckIfWatermarkExist(result.Path, "Watermark text", TestFiles.Jpg.ToFileInfo());
}
public void Replace_Watermark_Without_Options()
{
var request = new ReplaceRequest(null);
var ex = Assert.Throws <ApiException>(() => { WatermarkApi.Replace(request); });
Assert.AreEqual("Missing required parameter 'options' when calling Replace", ex.Message);
}
/// <summary>
/// Replace watermarks.
/// </summary>
/// <param name="request">Request. <see cref="ReplaceRequest" /></param>
/// <returns><see cref="ReplaceResult"/></returns>
public ReplaceResult Replace(ReplaceRequest request)
{
// verify the required parameter 'options' is set
if (request.options == null)
{
throw new ApiException(400, "Missing required parameter 'options' when calling Replace");
}
// create path and map variables
var resourcePath = this.configuration.GetServerUrl() + "/watermark/replace";
resourcePath = Regex
.Replace(resourcePath, "\\*", string.Empty)
.Replace("&", "&")
.Replace("/?", "?");
var postBody = SerializationHelper.Serialize(request.options); // http body (model) parameter
var response = this.apiInvoker.InvokeApi(
resourcePath,
"POST",
postBody,
null,
null);
if (response != null)
{
return((ReplaceResult)SerializationHelper.Deserialize(response, typeof(ReplaceResult)));
}
return(null);
}
public void Replace_Watermark_Incorrect_Password()
{
var testFile = TestFiles.PasswordProtected;
var options = new ReplaceOptions
{
FileInfo = new FileInfo
{
FilePath = testFile.FullName,
Password = "******"
},
ImageSearchCriteria = new ImageSearchCriteria
{
ImageFileInfo = TestFiles.SampleWatermarkTransparent.ToFileInfo()
},
TextSearchCriteria = new TextSearchCriteria
{
SearchText = "Watermark text"
}
};
var request = new ReplaceRequest(options);
var ex = Assert.Throws <ApiException>(() => { WatermarkApi.Replace(request); });
Assert.AreEqual($"Password provided for file '{testFile.FullName}' is incorrect.", ex.Message);
}
/// <summary>Performs a REPLACE request.</summary>
/// <param name="replaceRequest">The replace request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <typeparam name="T">The class for object mapping.</typeparam>
/// <returns>The <see cref="Task" /> with replaced data as result.</returns>
public async Task <IList <T> > ReplaceAsync <T>(
ReplaceRequest <T> replaceRequest,
CancellationToken cancellationToken)
{
var result = (await RequestAsync(replaceRequest, cancellationToken).ConfigureAwait(false)).AsList();
return(MapCollection <T>(result).ToList());
}
public void PostDocumentsDocumentIdContentTest()
{
// TODO: add unit test for the method 'PostDocumentsDocumentIdContent'
string documentId = null; // TODO: replace null with proper value
ReplaceRequest body = null; // TODO: replace null with proper value
bool? _override = null; // TODO: replace null with proper value
var response = instance.PostDocumentsDocumentIdContent(documentId, body, _override);
Assert.IsInstanceOf <ReplaceResponse> (response, "response is ReplaceResponse");
}
public void Replace_Watermark_No_Search_Criteria()
{
var testFile = TestFiles.Xlsx;
var options = new ReplaceOptions
{
FileInfo = testFile.ToFileInfo(),
OutputFolder = "found_image_watermarks"
};
var request = new ReplaceRequest(options);
var ex = Assert.Throws <ApiException>(() => { WatermarkApi.Replace(request); });
Assert.AreEqual("Request parameters missing or have incorrect format", ex.Message);
}
public static void Run()
{
var configuration = new Configuration(Common.MyAppSid, Common.MyAppKey);
var apiInstance = new WatermarkApi(configuration);
try
{
var fileInfo = new FileInfo
{
FilePath = "with_watermarks/sample.pdf",
StorageName = Common.MyStorage
};
var options = new ReplaceOptions
{
FileInfo = fileInfo,
ImageSearchCriteria = new ImageSearchCriteria
{
ImageFileInfo = new FileInfo {
FilePath = "watermark_images/sample_watermark.png", StorageName = Common.MyStorage
}
},
TextSearchCriteria = new TextSearchCriteria
{
SearchText = "Watermark text"
},
ReplaceTextOptions = new ReplaceTextOptions
{
Text = "New watermark text",
},
ReplaceImageOptions = new ReplaceImageOptions
{
Image = new FileInfo {
FilePath = "images/sample.jpg", StorageName = Common.MyStorage
}
}
};
var request = new ReplaceRequest(options);
var response = apiInstance.Replace(request);
Console.WriteLine("Resultant file path: " + response.Path);
}
catch (Exception e)
{
Console.WriteLine("Exception while calling WatermarkApi: " + e.Message);
}
}
public void Replace_Watermark_File_Not_Supported()
{
var testFile = TestFiles.Zip;
var options = new ReplaceOptions
{
FileInfo = testFile.ToFileInfo(),
ImageSearchCriteria = new ImageSearchCriteria
{
ImageFileInfo = TestFiles.SampleWatermarkTransparent.ToFileInfo()
},
TextSearchCriteria = new TextSearchCriteria
{
SearchText = "Watermark text"
}
};
var request = new ReplaceRequest(options);
var ex = Assert.Throws <ApiException>(() => { WatermarkApi.Replace(request); });
Assert.AreEqual($"The specified file '{testFile.FullName}' has type which is not currently supported.", ex.Message);
}
public void Replace_Watermark_File_Not_Found()
{
var testFile = TestFiles.NotExist;
var options = new ReplaceOptions()
{
FileInfo = testFile.ToFileInfo(),
ImageSearchCriteria = new ImageSearchCriteria
{
ImageFileInfo = TestFiles.SampleWatermarkTransparent.ToFileInfo()
},
TextSearchCriteria = new TextSearchCriteria
{
SearchText = "Watermark text"
}
};
var request = new ReplaceRequest(options);
var ex = Assert.Throws <ApiException>(() => { WatermarkApi.Replace(request); });
Assert.AreEqual($"Can't find file located at '{testFile.FullName}'.", ex.Message);
}
public void TestConstructors()
{
//var annotation = new Annotation (AnnotationEntry.AltSubject);
//annotation.Properties[AnnotationAttribute.PrivateValue] = string.Format ("Alternate subject");
//var annotations = new Annotation[] { annotation };
var keywords = new string[] { "$Forwarded", "$Junk" };
var keywordSet = new HashSet <string> (keywords);
var flags = MessageFlags.Seen | MessageFlags.Draft;
var internalDate = DateTimeOffset.Now;
var message = new MimeMessage();
ReplaceRequest request;
request = new ReplaceRequest(message);
Assert.AreEqual(message, request.Message, "Message #1");
Assert.AreEqual(MessageFlags.None, request.Flags, "Flags #1");
Assert.IsNull(request.Keywords, "Keywords #1");
Assert.IsNull(request.InternalDate, "InternalDate #1");
Assert.IsNull(request.Annotations, "Annotations #1");
request = new ReplaceRequest(message, flags);
Assert.AreEqual(message, request.Message, "Message #2");
Assert.AreEqual(flags, request.Flags, "Flags #2");
Assert.IsNull(request.Keywords, "Keywords #2");
Assert.IsNull(request.InternalDate, "InternalDate #2");
Assert.IsNull(request.Annotations, "Annotations #2");
request = new ReplaceRequest(message, flags, keywords);
Assert.AreEqual(message, request.Message, "Message #3");
Assert.AreEqual(flags, request.Flags, "Flags #3");
Assert.IsInstanceOf <HashSet <string> > (request.Keywords, "Keywords Type #3");
Assert.AreEqual(keywords.Length, request.Keywords.Count, "Keywords #3");
Assert.IsNull(request.InternalDate, "InternalDate #3");
Assert.IsNull(request.Annotations, "Annotations #3");
request = new ReplaceRequest(message, flags, keywordSet);
Assert.AreEqual(message, request.Message, "Message #4");
Assert.AreEqual(flags, request.Flags, "Flags #4");
Assert.IsInstanceOf <HashSet <string> > (request.Keywords, "Keywords Type #4");
Assert.AreEqual(keywordSet, request.Keywords, "Keywords #4");
Assert.IsNull(request.InternalDate, "InternalDate #4");
Assert.IsNull(request.Annotations, "Annotations #4");
request = new ReplaceRequest(message, flags, internalDate);
Assert.AreEqual(message, request.Message, "Message #5");
Assert.AreEqual(flags, request.Flags, "Flags #5");
Assert.IsNull(request.Keywords, "Keywords #5");
Assert.AreEqual(internalDate, request.InternalDate.Value, "InternalDate #5");
Assert.IsNull(request.Annotations, "Annotations #5");
request = new ReplaceRequest(message, flags, keywords, internalDate);
Assert.AreEqual(message, request.Message, "Message #6");
Assert.AreEqual(flags, request.Flags, "Flags #6");
Assert.IsInstanceOf <HashSet <string> > (request.Keywords, "Keywords Type #6");
Assert.AreEqual(keywords.Length, request.Keywords.Count, "Keywords #6");
Assert.AreEqual(internalDate, request.InternalDate.Value, "InternalDate #6");
Assert.IsNull(request.Annotations, "Annotations #6");
request = new ReplaceRequest(message, flags, keywordSet, internalDate);
Assert.AreEqual(message, request.Message, "Message #7");
Assert.AreEqual(flags, request.Flags, "Flags #7");
Assert.IsInstanceOf <HashSet <string> > (request.Keywords, "Keywords Type #7");
Assert.AreEqual(keywordSet, request.Keywords, "Keywords #7");
Assert.AreEqual(internalDate, request.InternalDate.Value, "InternalDate #7");
Assert.IsNull(request.Annotations, "Annotations #7");
}
public async Task <FileDto> ReplaceFileAsync(string callerEmail, Guid fileUniqId, ReplaceRequest model)
{
try
{
var owner = await _unitOfWork.UserRepository.GetUserAsync(callerEmail);
var fileNode = await _unitOfWork.NodeRepository.GetNodeByIdAsync(fileUniqId);
var folderNode = await _unitOfWork.NodeRepository.GetNodeByIdAsync(model.DestanationFolderId);
if (folderNode == null || !folderNode.IsDirectory)
{
State.TypeOfError = TypeOfServiceError.NotFound;
State.ErrorMessage = "Requeset folder not found!";
return(null);
}
// Validate if user have access to file and can edit it
if (!ValidateAccessToFile(State, fileNode, owner))
{
return(null);
}
_unitOfWork.NodeRepository.ReplaceNodeFolder(fileNode, folderNode);
await _unitOfWork.CommitAsync();
return(Mapper.Map <Node, FileDto>(fileNode));
}
catch (Exception ex)
{
State.ErrorMessage = ex.Message;
State.TypeOfError = TypeOfServiceError.ServiceError;
return(null);
}
}
public async Task <FolderDto> ReplaceFolderAsync(string callerEmail, Guid folderId, ReplaceRequest model)
{
try
{
// Make something with permission manager
var owner = await _unitOfWork.UserRepository.GetUserAsync(callerEmail);
var currentFolder = await _unitOfWork.NodeRepository.GetNodeByIdAsync(folderId);
var destFolder = await _unitOfWork.NodeRepository.GetNodeByIdAsync(model.DestanationFolderId);
if (currentFolder == null || !currentFolder.IsDirectory)
{
State.TypeOfError = TypeOfServiceError.NotFound;
State.ErrorMessage = "Source folder not found!";
return(null);
}
if (destFolder == null || !destFolder.IsDirectory)
{
State.TypeOfError = TypeOfServiceError.NotFound;
State.ErrorMessage = "Destination folder not found!";
return(null);
}
if (destFolder.Folder == currentFolder)
{
State.TypeOfError = TypeOfServiceError.BadRequest;
State.ErrorMessage = "Destination folder cannot be inside requested folder";
return(null);
}
currentFolder.Folder = destFolder;
await _unitOfWork.CommitAsync();
return(Mapper.Map <Node, FolderDto>(currentFolder));
}
catch (Exception ex)
{
State.ErrorMessage = ex.Message;
State.TypeOfError = TypeOfServiceError.ServiceError;
return(null);
}
}
public void Init()
{
instance = new ReplaceRequest();
}
/// <summary>Performs a REPLACE request.</summary>
/// <param name="replaceRequest">The replace request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The <see cref="Task" /> with replaced data as result.</returns>
public async Task <IList <MessagePackObject> > ReplaceAsync(
ReplaceRequest replaceRequest,
CancellationToken cancellationToken)
{
return((await RequestAsync(replaceRequest, cancellationToken).ConfigureAwait(false)).AsList());
}
///Note: there is no such method in specification http://tarantool.org/doc/book/box/box_index.html.
///But common sense, and sources https://github.com/tarantool/tarantool/blob/1.7/src/box/lua/index.c says that that method sould be
public async Task <DataResponse <TTuple[]> > Replace <TTuple>(TTuple tuple)
{
var replaceRequest = new ReplaceRequest <TTuple>(SpaceId, tuple);
return(await LogicalConnection.SendRequest <InsertReplaceRequest <TTuple>, TTuple>(replaceRequest).ConfigureAwait(false));
}
