public async Task <ICollection <PostFile> > GetPostImages(AttachmentData attachments, string postId)
{
var fileList = new List <PostFile>();
var arrayOfImages = attachments.Subattachments?.Data ?? new List <SubAttachmentData>();
if (arrayOfImages.Count == 0)
{
var mainImage = attachments.Media?.Image;
if (mainImage != null)
{
arrayOfImages.Add(new SubAttachmentData
{
Media = new Media
{
Image = mainImage
}
});
}
}
foreach (var image in arrayOfImages)
{
var info = await GetFileInfo(image, postId);
if (info != null)
{
fileList.Add(FileMapper.ConvertToPostFile(info));
}
}
return(fileList);
}
public IHttpActionResult PostFile()
{
try
{
ShapeFile shapeFile = null;
DbfReader dbfFile = null;
FileMapper fileMapper = null;
string[] shpFileStr = Directory.GetFiles(@"C:\testFile", "*.shp");
string[] dbfFilesStr = Directory.GetFiles(@"C:\testFile", "*.dbf");
if (shpFileStr != null && dbfFilesStr != null)
{
if (shpFileStr.Length == 1 && dbfFilesStr.Length == 1)
{
shapeFile = new ShapeFile(shpFileStr[0]);
dbfFile = new DbfReader(dbfFilesStr[0]);
fileMapper = new FileMapper(shapeFile, dbfFile);
fileMapper.StartFilter();
}
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void Encrypted_RunSync_IOException()
{
// ARRANGE
byte[] fileMock = new byte[1888];
new Random().NextBytes(fileMock);
Stream s = new MemoryStream(fileMock);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
FileUploadCallbackMock callback = new FileUploadCallbackMock();
ApiCreateFileUpload acfu = FactoryFile.ApiCreateFileUpload;
acfu.Classification = null;
EncFileUpload f = new EncFileUpload(c, "id1", FactoryFile.UploadFileRequest, s, FactoryUser.UserPublicKey, fileMock.Length);
f.AddFileUploadCallback(callback);
Mock.Arrange(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(acfu);
Mock.Arrange(() => c.Builder.PostCreateFileUpload(Arg.IsAny <ApiCreateFileUpload>())).Returns(FactoryRestSharp.PostCreateFileUploadMock());
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiUploadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostUploadToken, 0))
.Returns(FactoryFile.ApiUploadToken);
Mock.Arrange(() => c.Builder.GetGeneralSettings())
.Returns(FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetGeneralConfig, Method.GET)).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiGeneralSettings>(Arg.IsAny <IRestRequest>(), RequestType.GetGeneralSettings, 0))
.Returns(FactoryServerSettings.ApiGeneralSettings).Occurs(1);
Mock.Arrange(() => Crypto.Sdk.Crypto.GenerateFileKey(Arg.AnyString)).Returns(FactoryFile.PlainFileKey);
FileEncryptionCipher cipher = Mock.Create <FileEncryptionCipher>();
Mock.Arrange(() => Crypto.Sdk.Crypto.CreateFileEncryptionCipher(Arg.IsAny <PlainFileKey>())).Returns(cipher);
Mock.Arrange(() => cipher.ProcessBytes(Arg.IsAny <PlainDataContainer>())).Returns(new EncryptedDataContainer(fileMock, fileMock));
Mock.Arrange(() => cipher.DoFinal()).Returns(new EncryptedDataContainer(fileMock, fileMock));
Mock.NonPublic.Arrange <ApiUploadChunkResult>(f, "UploadChunkWebClient", ArgExpr.IsAny <Uri>(), ArgExpr.IsAny <byte[]>(),
ArgExpr.IsAny <long>(), ArgExpr.IsAny <int>()).Throws(new IOException());
// ACT - ASSERT
Assert.Throws <DracoonFileIOException>(() => f.RunSync());
s.Close();
}
internal EncryptedFileKey GetEncryptedFileKey(long nodeId)
{
IRestRequest fileKeyRequest = _client.Builder.GetFileKey(nodeId);
return(FileMapper.FromApiFileKey(
_client.Executor.DoSyncApiCall <ApiFileKey>(fileKeyRequest, RequestType.GetFileKey)));
}
public async Task <FileInfoDTO> CreateAsync(CreateFileRequest file, Stream data)
{
if (!Directory.Exists(StorageFolderPath))
{
Directory.CreateDirectory(StorageFolderPath);
}
var fileInfoDto = FileMapper.ConvertToFileInfoDTO(file);
var fileInfo = await _db.Files.CreateAsync(FileMapper.ConvertToFileInfo(fileInfoDto));
var filePath = GetAbsoluteFilePath(fileInfo);
if (!File.Exists(filePath))
{
using (var fileStream = File.Create(filePath))
{
using (data)
{
if (data.CanSeek)
{
data.Seek(0, SeekOrigin.Begin);
}
await data.CopyToAsync(fileStream);
}
}
await _db.SaveAsync(); // don't move to other place.
}
return(await GetFileInfoAsync(fileInfo.Id));
}
public async Task <PagedResultDTO <PostDTO> > GetPageAsync(int id, int page, int pageSize, bool justMyPosts, string srchStr = null)
{
var pagedResult = await _db.Posts.GetPageAsync(id, page, pageSize, justMyPosts, srchStr);
pagedResult.Data.ForEach(p =>
p.PostFiles = p.PostFiles.Count > 0 ?
new List <PostFile>()
{
p.PostFiles.First()
}
: new List <PostFile>()
);
Func <Post, PostDTO> func = post =>
{
var postDTO = PostMapper.ConvertToPostDTO(post);
postDTO.Files = FileMapper.ConvertToFileInfoDTOCollection(post.PostFiles);
postDTO.UserDTO = UserMapper.ConvertToUserDTO(post.User);
postDTO.CommentsDTO = CommentMapper.ConvertToCommentDTOCollection(post.Comments);
var usersDTOLikes = new List <UserDTO>();
post.PostLikes.ToList().ForEach(pl =>
{
var userDTO = UserMapper.ConvertToUserDTO(pl.User);
userDTO.RoleDTO = RoleMapper.ConvertToRoleDTO(pl.User.Role);
usersDTOLikes.Add(userDTO);
});
postDTO.UsersLikes = usersDTOLikes;
return(postDTO);
};
var pageResultDTO = PagedResultMapper.MapToDTO(pagedResult, func);
return(pageResultDTO);
}
private void HandlePendingMissingFileKeys(ApiMissingFileKeys missingFileKeys, UserPrivateKey thisUserPrivateKey)
{
if (missingFileKeys == null || missingFileKeys.Items.Count == 0)
{
return;
}
Dictionary <long, UserPublicKey> userPublicKeys = UserMapper.ConvertApiUserIdPublicKeys(missingFileKeys.UserPublicKey);
Dictionary <long, PlainFileKey> plainFileKeys = GeneratePlainFileKeyMap(missingFileKeys.FileKeys, thisUserPrivateKey);
ApiSetUserFileKeysRequest setUserFileKeysRequest = new ApiSetUserFileKeysRequest {
Items = new List <ApiSetUserFileKey>(missingFileKeys.UserPublicKey.Count)
};
foreach (ApiUserIdFileId currentMissingFileKey in missingFileKeys.Items)
{
UserPublicKey currentUsersPublicKey = userPublicKeys[currentMissingFileKey.UserId];
PlainFileKey currentPlainFileKey = plainFileKeys[currentMissingFileKey.FileId];
EncryptedFileKey currentEncryptedFileKey = EncryptFileKey(currentPlainFileKey, currentUsersPublicKey, currentMissingFileKey.FileId);
ApiSetUserFileKey newRequestEntry = new ApiSetUserFileKey {
FileId = currentMissingFileKey.FileId,
UserId = currentMissingFileKey.UserId,
FileKey = FileMapper.ToApiFileKey(currentEncryptedFileKey)
};
setUserFileKeysRequest.Items.Add(newRequestEntry);
}
IRestRequest restRequest = _client.Builder.PostMissingFileKeys(setUserFileKeysRequest);
_client.Executor.DoSyncApiCall <VoidResponse>(restRequest, RequestType.PostMissingFileKeys);
}
private void InitializeConfig()
{
if (!Config.IsInitialized)
{
Config.Initialize(FileMapper.MapPath(ApplicationPath), PathVariation);
}
}
static void Main(string[] args)
{
const string filePath = @"U:\TestData\DSS.csv";
var fileReader = new FileReader();
char[] separator = { ',' };
var fieldNames = fileReader.GetHeaderFieldNamesFromFile(0, filePath, separator);
//var userRecords = fileReader.ReadFile(filePath, 1, fieldNames, separator);
var stream = File.OpenText(filePath);
var ignoreLines = 1;
var userRecords = fileReader.ReadStream(stream, ignoreLines, fieldNames, separator);
//These will come from database
var validatorDefs = new List <ValidatorDef>
{
new ValidatorDef("BarcodeId", "IsRequired"),
new ValidatorDef("AnimalID", "IsRequired"),
new ValidatorDef("DamRegistrationNumber", "number"),
new ValidatorDef("SexofAnimal", "Gender", "", "m,F,Male,Female,sire,dam,heifer,steer"),
};
var validationProcessor = new ValidationProcessor(validatorDefs);
if (!validationProcessor.RunValidatorsForAllObjects(fileReader.InputType, userRecords))
{
Console.WriteLine(validationProcessor.ErrorMessages.ToString());
EndProgram();
return;
}
var fileMapper = new FileMapper();
//These will come from database
IList <MapDefinition> mapDefs = new List <MapDefinition>();
mapDefs.Add(new MapDefinition()
{
InputName = "BarcodeId", OutputName = "BarcodeId"
});
mapDefs.Add(new MapDefinition()
{
InputName = "AnimalID", OutputName = "AnimalId"
});
mapDefs.Add(new MapDefinition()
{
InputName = "SexofAnimal", OutputName = "GenderOfAnimal"
});
mapDefs.Add(new MapDefinition()
{
InputName = "DamRegistrationNumber", OutputName = "DamRegistrationNumber"
});
var output = fileMapper.MapFields <OutPutRow>(userRecords, mapDefs, fileReader.InputType);
EndProgram();
}
public Feature Parse(TextReader featureFileReader)
{
var language = this.DetermineLanguage();
var gherkinParser = new Gherkin.Parser();
var dialectProvider = this.GetDialectProvider(language);
try
{
Gherkin.Ast.GherkinDocument gherkinDocument = gherkinParser.Parse(
new Gherkin.TokenScanner(featureFileReader),
new Gherkin.TokenMatcher(dialectProvider));
var languageServices = this.languageServicesRegistry.GetLanguageServicesForLanguage(gherkinDocument.Feature.Language);
Feature result = new FileMapper(this.configuration, languageServices).MapToFeature(gherkinDocument);
result = new FeatureFilter(result, this.configuration.ExcludeTags).ExcludeScenariosByTags();
if (result != null)
{
this.descriptionProcessor.Process(result);
}
return(result);
}
catch (Gherkin.CompositeParserException exception)
{
throw new FeatureParseException("Unable to parse feature", exception);
}
}
public void Encrypted_RunSync_CreateFileKeyError()
{
// ARRANGE
byte[] fileMock = new byte[1888];
new Random().NextBytes(fileMock);
Stream s = new MemoryStream(fileMock);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
FileUploadCallbackMock callback = new FileUploadCallbackMock();
ApiCreateFileUpload acfu = FactoryFile.ApiCreateFileUpload;
acfu.Classification = null;
EncFileUpload f = new EncFileUpload(c, "id1", FactoryFile.UploadFileRequest, s, FactoryUser.UserPublicKey, fileMock.Length);
f.AddFileUploadCallback(callback);
Mock.Arrange(() => c.Builder.GetGeneralSettings())
.Returns(FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetGeneralConfig, Method.GET)).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiGeneralSettings>(Arg.IsAny <IRestRequest>(), RequestType.GetGeneralSettings, 0))
.Returns(FactoryServerSettings.ApiGeneralSettings).Occurs(1);
Mock.Arrange(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(acfu);
Mock.Arrange(() => c.Builder.PostCreateFileUpload(Arg.IsAny <ApiCreateFileUpload>())).Returns(FactoryRestSharp.PostCreateFileUploadMock());
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiUploadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostUploadToken, 0))
.Returns(FactoryFile.ApiUploadToken);
Mock.Arrange(() => Crypto.Sdk.Crypto.GenerateFileKey(Arg.AnyString)).Throws(new CryptoException("Error"));
// ACT - ASSERT
Assert.Throws <DracoonCryptoException>(() => f.RunSync());
s.Close();
}
/// <summary>
/// Creates the default application configuration and assigns the provided user as the primary administrator.
/// </summary>
/// <param name="settings">General and custom application settings.</param>
/// <returns>The application configuration component.</returns>
private AppConfig CreateConfig(Dictionary <string, object> settings)
{
AppConfig config = null;
using (LogGroup logGroup = LogGroup.StartDebug("Creating the default application config."))
{
CheckFileMapper();
CheckPathVariation();
config = ConfigFactory <AppConfig> .NewConfig(FileMapper.MapPath(ApplicationPath + "/" + DataDirectory), "Application", PathVariation);
config.ApplicationPath = ApplicationPath;
config.PhysicalApplicationPath = FileMapper.MapPath(ApplicationPath);
// Add the provided settings to the configuration ifle.
foreach (string key in settings.Keys)
{
config.Settings[key] = settings[key];
}
LogWriter.Debug("Application path: " + config.ApplicationPath);
LogWriter.Debug("Physical application path: " + config.PhysicalApplicationPath);
// TODO: Check if needed
//config.Settings["ApplicationVersion"] = Utilities.GetVersion();
LogWriter.Debug("Version: " + config.Settings["ApplicationVersion"]);
}
return(config);
}
public async Task <IActionResult> GetAsync([FromRoute] int userId,
[FromQuery] int?fileTypeId)
{
var files = await _repositoryManager
.FileRepository.GetAsync(userId, fileTypeId);
return(Ok(files.Select(f => FileMapper.MapWithType(f))));
}
public async Task <List <FileDto> > GetAllFilesAsync()
{
List <File> files = await fileService.GetAllFilesAsync();
List <FileDto> response = FileMapper.MapFilesToDto(files);
return(response);
}
public FileDto GetFileById(int fileId)
{
var file = Session.QueryOver <File>()
.Where(x => x.FileId == fileId)
.SingleOrDefault();
return(FileMapper.MapToDto(file));
}
public ActionResult <IEnumerable <FileViewModel> > GetFiles(int medicalChartId)
{
if (!_medicalChartService.Exist(medicalChartId))
{
return(NotFound());
}
return(_medicalChartService.GetFiles(medicalChartId).Select(f => FileMapper.DTOtoFiileVM(f)).ToList());
}
public void CreateDownloadShare_Success()
{
// ARRANGE
Node node = FactoryNode.Node;
node.IsEncrypted = true;
node.Type = NodeType.File;
CreateDownloadShareRequest req = FactoryShare.CreateDownloadShareRequest;
req.EmailRecipients = new List <string> {
"985678"
};
req.EmailBody = "Any body!";
req.EmailSubject = "Any subject!";
req.SmsRecipients = new List <string> {
"28436054"
};
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonSharesImpl s = new DracoonSharesImpl(c);
Mock.Arrange(() => Arg.IsAny <CreateDownloadShareRequest>().MustNotNull(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => c.NodesImpl.GetNode(Arg.AnyLong)).Returns(node).Occurs(1);
Mock.Arrange(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, Arg.AnyBool)).DoNothing().OccursAtLeast(1);
Mock.Arrange(() => Arg.IsAny <int?>().NullableMustPositive(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => Arg.IsAny <IEnumerable <string> >().EnumerableMustNotNullOrEmpty(Arg.AnyString)).DoNothing();
Mock.Arrange(() => ShareMapper.ToUnencryptedApiCreateDownloadShareRequest(Arg.IsAny <CreateDownloadShareRequest>()))
.Returns(FactoryShare.ApiCreateDownloadShareRequest).Occurs(1);
Mock.Arrange(() => c.AccountImpl.GetAndCheckUserKeyPair()).Returns(FactoryUser.UserKeyPair).Occurs(1);
Mock.Arrange(() => c.NodesImpl.GetEncryptedFileKey(Arg.AnyLong)).Returns(FactoryFile.EncryptedFileKey).Occurs(1);
Mock.Arrange(() => c.NodesImpl.DecryptFileKey(Arg.IsAny <EncryptedFileKey>(), Arg.IsAny <UserPrivateKey>(), Arg.IsAny <long?>())).Returns(FactoryFile.PlainFileKey).Occurs(1);
Mock.Arrange(() => c.AccountImpl.GenerateNewUserKeyPair(Arg.AnyString)).Returns(FactoryUser.UserKeyPair);
Mock.Arrange(() => c.NodesImpl.EncryptFileKey(Arg.IsAny <PlainFileKey>(), Arg.IsAny <UserPublicKey>(), Arg.IsAny <long?>())).Returns(FactoryFile.EncryptedFileKey).Occurs(1);
Mock.Arrange(() => UserMapper.ToApiUserKeyPair(Arg.IsAny <UserKeyPair>())).Returns(FactoryUser.ApiUserKeyPair).Occurs(1);
Mock.Arrange(() => FileMapper.ToApiFileKey(Arg.IsAny <EncryptedFileKey>())).Returns(FactoryFile.ApiFileKey).Occurs(1);
Mock.Arrange(() => c.Builder.PostCreateDownloadShare(Arg.IsAny <ApiCreateDownloadShareRequest>())).Returns(FactoryRestSharp.PostCreateDownloadShareMock()).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiDownloadShare>(Arg.IsAny <IRestRequest>(), RequestType.PostCreateDownloadShare, 0))
.Returns(FactoryShare.ApiDownloadShare).Occurs(1);
Mock.Arrange(() => ShareMapper.FromApiDownloadShare(Arg.IsAny <ApiDownloadShare>())).Returns(FactoryShare.DownloadShare).Occurs(1);
// ACT
DownloadShare actual = s.CreateDownloadShare(req);
// ASSERT
Assert.NotNull(actual);
Mock.Assert(() => Arg.IsAny <CreateDownloadShareRequest>().MustNotNull(Arg.AnyString));
Mock.Assert(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, Arg.AnyBool));
Mock.Assert(() => Arg.IsAny <int?>().NullableMustPositive(Arg.AnyString));
Mock.Assert(() => Arg.IsAny <IEnumerable <string> >().EnumerableMustNotNullOrEmpty(Arg.AnyString));
Mock.Assert(() => ShareMapper.ToUnencryptedApiCreateDownloadShareRequest(Arg.IsAny <CreateDownloadShareRequest>()));
Mock.Assert(() => UserMapper.ToApiUserKeyPair(Arg.IsAny <UserKeyPair>()));
Mock.Assert(() => FileMapper.ToApiFileKey(Arg.IsAny <EncryptedFileKey>()));
Mock.Assert(() => ShareMapper.FromApiDownloadShare(Arg.IsAny <ApiDownloadShare>()));
Mock.Assert(c.NodesImpl);
Mock.Assert(c.AccountImpl);
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
}
public List <FileDTO> GetFiles(int medicalChartId)
{
var filesDTO = _context.Files
.Where(f => f.MedicalChartId.Equals(medicalChartId))
.Select(f => FileMapper.FileToFileDTO(f))
.ToList();
return(filesDTO);
}
public JsonResult GetFileTreeData(string path)
{
var fileProvider = new FileProvider();
var fileMapper = new FileMapper();
var filesList = fileProvider.GetFiles(path);
var rootJsTreeFileDto = fileMapper.From(filesList);
rootJsTreeFileDto.text = "Project files";
return Json(rootJsTreeFileDto, JsonRequestBehavior.AllowGet);
}
private void Initialize()
{
if (ConfigurationManager.AppSettings != null)
{
CheckFileMapper();
LegacyDirectoryPath = FileMapper.MapApplicationRelativePath(ConfigurationUtilities.GetSetting("Legacy.Directory", "Legacy"));
PersonalizationDirectoryPath = FileMapper.MapApplicationRelativePath(DataDirectory + "/Personalization_Data");
}
}
public void RunSync_UnknownFileSize_Success()
{
// ARRANGE
byte[] fileMock = new byte[1888];
new Random().NextBytes(fileMock);
Stream s = new MemoryStream(fileMock);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
FileUploadCallbackMock callback = new FileUploadCallbackMock();
FileUpload f = new FileUpload(c, "id1", FactoryFile.UploadFileRequest, s, -1);
f.AddFileUploadCallback(callback);
ApiCreateFileUpload acfu = FactoryFile.ApiCreateFileUpload;
acfu.Classification = null;
Mock.Arrange(() => c.Builder.PostCreateFileUpload(Arg.IsAny <ApiCreateFileUpload>())).Returns(FactoryRestSharp.PostCreateFileUploadMock())
.Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiUploadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostUploadToken, 0))
.Returns(FactoryFile.ApiUploadToken).Occurs(1);
Mock.Arrange(() => c.Builder.PutCompleteFileUpload(Arg.AnyString, Arg.IsAny <ApiCompleteFileUpload>()))
.Returns(FactoryRestSharp.PutCompleteFileUploadMock("path")).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiNode>(Arg.IsAny <IRestRequest>(), RequestType.PutCompleteUpload, 0))
.Returns(FactoryNode.ApiNode).Occurs(1);
Mock.Arrange(() => c.Builder.GetGeneralSettings())
.Returns(FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetGeneralConfig, Method.GET)).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiGeneralSettings>(Arg.IsAny <IRestRequest>(), RequestType.GetGeneralSettings, 0))
.Returns(FactoryServerSettings.ApiGeneralSettings).Occurs(1);
Mock.Arrange(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(acfu).Occurs(1);
Mock.Arrange(() => NodeMapper.FromApiNode(Arg.IsAny <ApiNode>())).Returns(FactoryNode.Node).Occurs(1);
Mock.Arrange(() => FileHash.CompareFileHashes(Arg.AnyString, Arg.IsAny <byte[]>(), Arg.AnyInt)).Returns(true).OccursAtLeast(1);
DracoonWebClientExtension wc = Mock.Create <DracoonWebClientExtension>();
Mock.Arrange(() => Mock.Create <UploadProgressChangedEventArgs>().BytesSent).IgnoreInstance();
Mock.Arrange(() => c.Executor.ExecuteWebClientChunkUpload(Arg.IsAny <WebClient>(), Arg.IsAny <Uri>(), Arg.IsAny <byte[]>(),
RequestType.PostUploadChunk, Arg.IsAny <Thread>(), Arg.AnyInt)).DoInstead(() => Thread.Sleep(250))
.Raises(() => wc.UploadProgressChanged += null, null, Mock.Create <UploadProgressChangedEventArgs>()).Returns(new byte[13]);
Mock.Arrange(() => c.Builder.ProvideChunkUploadWebClient(Arg.AnyInt, Arg.AnyLong, Arg.AnyString, Arg.AnyString)).Returns(wc);
Mock.Arrange(() => JsonConvert.DeserializeObject <ApiUploadChunkResult>(Arg.AnyString)).Returns(FactoryFile.ApiUploadChunkResult);
Mock.Arrange(() => callback.OnStarted(Arg.AnyString)).Occurs(1);
Mock.Arrange(() => callback.OnRunning(Arg.AnyString, Arg.AnyLong, Arg.AnyLong)).OccursAtLeast(1);
Mock.Arrange(() => callback.OnFinished(Arg.AnyString, Arg.IsAny <Node>())).Occurs(1);
// ACT
Node actual = f.RunSync();
s.Close();
// ASSERT
Assert.Equal(FactoryNode.Node, actual, new NodeComparer());
Mock.Assert(callback);
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
}
public async Task <ICollection <PostFile> > GetPostImages(IList <SharepointPostImages> attachments, int postId)
{
var fileList = new List <PostFile>();
foreach (var image in attachments)
{
var info = await GetFileInfo(image, postId);
fileList.Add(FileMapper.ConvertToPostFile(info));
}
return(fileList);
}
public async Task <IActionResult> CreateAsync([FromBody] InFileDTO fileDTO)
{
var file = FileMapper.Map(fileDTO);
file = _repositoryManager.FileRepository.Create(file);
await _repositoryManager.SaveAsync();
var outFileDTO = FileMapper.Map(file);
return(Ok(outFileDTO));
}
public void RunAsync_IOException()
{
// ARRANGE
byte[] fileMock = new byte[1888];
new Random().NextBytes(fileMock);
Stream s = new MemoryStream(fileMock);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
FileUploadCallbackMock callback = new FileUploadCallbackMock();
FileUpload f = new FileUpload(c, "id1", FactoryFile.UploadFileRequest, s, fileMock.Length);
f.AddFileUploadCallback(callback);
Mock.Arrange(() => c.Builder.PostCreateFileUpload(Arg.IsAny <ApiCreateFileUpload>())).Returns(FactoryRestSharp.PostCreateFileUploadMock())
.OnAllThreads();
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiUploadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostUploadToken, 0))
.Returns(FactoryFile.ApiUploadToken).OnAllThreads();
Mock.Arrange(() => c.Builder.PutCompleteFileUpload(Arg.AnyString, Arg.IsAny <ApiCompleteFileUpload>()))
.Returns(FactoryRestSharp.PutCompleteFileUploadMock("path")).OnAllThreads();
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiNode>(Arg.IsAny <IRestRequest>(), RequestType.PutCompleteUpload, 0))
.Returns(FactoryNode.ApiNode).OnAllThreads();
Mock.Arrange(() => c.Builder.GetGeneralSettings())
.Returns(FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetGeneralConfig, Method.GET)).OnAllThreads();
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiGeneralSettings>(Arg.IsAny <IRestRequest>(), RequestType.GetGeneralSettings, 0))
.Returns(FactoryServerSettings.ApiGeneralSettings).OnAllThreads();
Mock.Arrange(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(FactoryFile.ApiCreateFileUpload)
.OnAllThreads();
Mock.Arrange(() => NodeMapper.FromApiNode(Arg.IsAny <ApiNode>())).Returns(FactoryNode.Node).OnAllThreads();
Mock.Arrange(() => FileHash.CompareFileHashes(Arg.AnyString, Arg.IsAny <byte[]>(), Arg.AnyInt)).Returns(true).OnAllThreads();
DracoonWebClientExtension wc = Mock.Create <DracoonWebClientExtension>();
Mock.Arrange(() => Mock.Create <UploadProgressChangedEventArgs>().BytesSent).IgnoreInstance().OnAllThreads();
Mock.Arrange(() => c.Executor.ExecuteWebClientChunkUpload(Arg.IsAny <WebClient>(), Arg.IsAny <Uri>(), Arg.IsAny <byte[]>(),
RequestType.PostUploadChunk, Arg.IsAny <Thread>(), Arg.AnyInt))
.Raises(() => wc.UploadProgressChanged += null, null, Mock.Create <UploadProgressChangedEventArgs>()).Returns(new byte[13])
.OnAllThreads();
Mock.Arrange(() => c.Builder.ProvideChunkUploadWebClient(Arg.AnyInt, Arg.AnyLong, Arg.AnyString, Arg.AnyString)).Returns(wc)
.OnAllThreads();
Mock.Arrange(() => JsonConvert.DeserializeObject <ApiUploadChunkResult>(Arg.AnyString)).Returns(FactoryFile.ApiUploadChunkResult)
.OnAllThreads();
Mock.Arrange(() => s.Read(Arg.IsAny <byte[]>(), Arg.AnyInt, Arg.AnyInt)).Throws(new IOException()).OnAllThreads();
Mock.Arrange(() => callback.OnStarted(Arg.AnyString)).Occurs(1);
Mock.Arrange(() => callback.OnFailed(Arg.AnyString, Arg.IsAny <DracoonException>())).Occurs(1);
// ACT
f.RunAsync();
while (f.RunningThread.IsAlive)
{
}
s.Close();
// ASSERT
Mock.Assert(callback);
}
private Dictionary <long, PlainFileKey> GeneratePlainFileKeyMap(List <ApiFileIdFileKey> fileIdFileKeys, UserPrivateKey thisUserPrivateKey)
{
Dictionary <long, PlainFileKey> plainFileKeys = new Dictionary <long, PlainFileKey>(fileIdFileKeys.Count);
foreach (ApiFileIdFileKey currentEncryptedFileKey in fileIdFileKeys)
{
EncryptedFileKey encryptedFileKey = FileMapper.FromApiFileKey(currentEncryptedFileKey.FileKeyContainer);
PlainFileKey decryptedFileKey = DecryptFileKey(encryptedFileKey, thisUserPrivateKey, currentEncryptedFileKey.FileId);
plainFileKeys.Add(currentEncryptedFileKey.FileId, decryptedFileKey);
}
return(plainFileKeys);
}
public async Task <IActionResult> GetAsync([FromQuery] int?fileTypeId)
{
var userId = HttpContext.User.GetUserId();
if (!userId.HasValue)
{
return(Unauthorized());
}
var files = await _repositoryManager
.FileRepository.GetAsync(userId.Value, fileTypeId);
return(Ok(files.Select(f => FileMapper.MapWithType(f))));
}
public async Task <PostDTO> CreateAsync(PostDTO post)
{
if (post.EndDateTime <= post.StartDateTime)
{
throw new InvalidOperationException("EndDateTime should be greater than StartDateTime");
}
var currentUser = _userContext.CurrentUser;
if (currentUser.RoleId != (int)Roles.Moderator)
{
var defaultEndDateTime = _postDefaultValuesOptions.Value.DisplayPeriodInDaysForUsers;
post.EndDateTime = post.StartDateTime.AddDays(defaultEndDateTime);
}
if (post.CreatedDate == default(DateTime))
{
post.CreatedDate = DateTime.Now;
}
if (post.PostType == PostType.None)
{
post.PostType = PostType.InTouch;
}
post.IsDeleted = false;
post.UserId = currentUser.Id;
if (post.Priority == PostPriority.High && currentUser.RoleId != Role.ModeratorRoleId)
{
throw new InvalidOperationException("This user has no rights to set high priority for the post");
}
post.IsPublic = false;
var postToSave = PostMapper.ConvertToPost(post);
postToSave.PostFiles = FileMapper.ConvertToPostFileCollection(post.Files);
var createdPost = await _db.Posts.CreateAsync(postToSave);
await _db.SaveAsync();
var createdPostDTO = PostMapper.ConvertToPostDTO(createdPost);
createdPostDTO.UserDTO = currentUser;
return(createdPostDTO);
}
public async Task <IActionResult> CreateAsync([FromBody] PostCreateViewModel postCreateModel)
{
if (postCreateModel == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
List <FileInfoDTO> filesDTO = new List <FileInfoDTO>();
postCreateModel.VideoUrl = string.IsNullOrEmpty(postCreateModel.VideoUrl) ? null : postCreateModel.VideoUrl;
var offset = TimeZoneInfo.Local.GetUtcOffset(DateTime.UtcNow);
postCreateModel.StartDate = postCreateModel.StartDate.AddHours(offset.TotalHours);
postCreateModel.EndDate = postCreateModel.EndDate.AddHours(offset.TotalHours);
foreach (var file in postCreateModel.Files)
{
var createRequestFile = FileMapper.ConvertToCreateFileRequest(file);
using (var stream = _fileManager.GetFileStream(file))
{
var createdPostFileDTO = await _fileService.CreateAsync(createRequestFile, stream);
filesDTO.Add(createdPostFileDTO);
}
}
var post = PostMapper.ConvertToPostDTO(postCreateModel);
post.Files = filesDTO;
var createdPostDTO = await _postService.CreateAsync(post);
var currentUser = _userContext.CurrentUser;
var postViewModel = PostMapper.ConvertToPostViewModel(createdPostDTO);
if (currentUser.RoleId != (int)Roles.Moderator)
{
_emailService.PostCreatedNotificationAsync(postViewModel);
}
return(Ok(createdPostDTO));
}
public async Task <IEnumerable <PostDTO> > GetPostsAsync()
{
var posts = await _db.Posts.GetAllAsync();
var postsDTO = new List <PostDTO>();
//var currentDateTime = DateTime.Now;
posts.ForEach(p =>
{
var postDTO = PostMapper.ConvertToPostDTO(p);
postDTO.Files = FileMapper.ConvertToFileInfoDTOCollection(p.PostFiles);
postsDTO.Add(postDTO);
});
return(postsDTO);
}
public override void PreInitialize()
{
Configuration.Authorization.Providers.Add <CCodeAuthorizationProvider>();
Configuration.Authorization.Providers.Add <ArticleAppAuthorizationProvider>();
Configuration.Authorization.Providers.Add <CategoryAuthorizationProvider>();
Configuration.Authorization.Providers.Add <FileAuthorizationProvider>();
Configuration.Modules.AbpAutoMapper().Configurators.Add(configuration =>
{
CategoryMapper.CreateMappings(configuration);
FileMapper.CreateMappings(configuration);
ArticleDtoMapper.CreateMappings(configuration);
// ....
});
}
public Node UpdateFile(UpdateFileRequest request)
{
_client.Executor.CheckApiServerVersion();
#region Parameter Validation
request.MustNotNull(nameof(request));
request.Id.MustPositive(nameof(request.Id));
request.Name.MustNotNullOrEmptyOrWhitespace(nameof(request.Name), true);
#endregion
ApiUpdateFileRequest apiUpdateFileRequest = FileMapper.ToApiUpdateFileRequest(request);
IRestRequest restRequest = _client.Builder.PutFile(request.Id, apiUpdateFileRequest);
ApiNode result = _client.Executor.DoSyncApiCall <ApiNode>(restRequest, RequestType.PutFile);
return(NodeMapper.FromApiNode(result));
}
