public void UserSharedFileCollectionViewModel_ProcessSelectedFileTest_AddAsNewFile()
{
var mockFileUploadService = new Mock <IFileUploadService>();
mockFileUploadService
.Setup(uploader => uploader.ShowFileReplacementPrompt(
It.IsAny <IEnumerable <SharedFileViewModel> >(),
It.IsAny <SharedFileViewModel>(),
It.IsAny <OperationCallback <SharedFileReplaceCommands> >()))
.Callback((IEnumerable <SharedFileViewModel> sharedFileViewModels, SharedFileViewModel sharedFileViewModel, OperationCallback <SharedFileReplaceCommands> callback) =>
{
sharedFileViewModel.Model.OriginalFileName += "_copy";
callback(null, SharedFileReplaceCommands.SaveAs);
});
var sampleVm = new SampleUserSharedFileCollectionViewModel();
sampleVm.FileUploadService = mockFileUploadService.Object;
int initialCount = sampleVm.ViewModels.Count;
var oldSharedFileVm = sampleVm.ViewModels.First();
var sharedFile = new SharedFile()
{
SharedFileId = Guid.NewGuid(), OriginalFileName = oldSharedFileVm.Model.OriginalFileName
};
var newSharedFileVm = viewModelFactory.GetViewModel <SharedFileViewModel>(vm => vm.Model.SharedFileId == sharedFile.SharedFileId);
newSharedFileVm.Model = sharedFile;
sampleVm.ProcessSelectedFile(newSharedFileVm);
Assert.AreEqual(initialCount + 1, sampleVm.ViewModels.Count);
Assert.IsTrue(sampleVm.ViewModels.Contains(newSharedFileVm));
Assert.IsTrue(sampleVm.ViewModels.Contains(oldSharedFileVm));
}
internal void RemoveSharedFile(SharedFile file)
{
lock (_sharedFiles)
{
_sharedFiles.Remove(file.MetaData.FileID);
}
}
public static bool CreateHistory(SharedFile file, IFileSystem fileSystem, string virtualFilePath, string virtualHistoryPath)
{
bool historyCreated = false;
//File.Move(Path.Combine(sourceFilePath, Path.GetFileName(this.serverFileName)), Path.Combine(historyFolderPath, Path.GetFileName(this.serverFileName)));
fileSystem.MoveFile(
VirtualPathUtility.Combine(virtualFilePath, file.ServerFileName),
VirtualPathUtility.Combine(virtualHistoryPath, file.ServerFileName),
true);
historyCreated = SharedFile.AddHistory(
file.ItemGuid,
file.ModuleGuid,
file.UserGuid,
file.ItemId,
file.ModuleId,
file.FriendlyName,
file.OriginalFileName,
file.ServerFileName,
file.SizeInKB,
file.UploadDate,
file.UploadUserId,
file.ViewRoles
);
return(historyCreated);
}
/// <summary>
/// Locks the file
/// </summary>
/// <param name="timeout">The amount of time to try to acquire a lock</param>
public static ISharedFile Lock(string path, int timeout)
{
SharedFile sf;
lock (files)
{
bool b;
if (b = !files.TryGetValue(path, out sf))
{
files[path] = sf = new SharedFile(path);
}
sf.Lock();
if (!b)
{
return(new SharedDisposable(sf));
}
}
if (File.Exists(path))
{
var limit = DateTime.UtcNow.AddMilliseconds(timeout);
do
{
try
{
sf.Stream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);
break;
}
catch (FileNotFoundException)
{
break;
}
catch (Exception e)
{
Util.Logging.Log(e);
}
if (DateTime.UtcNow > limit)
{
break;
}
Thread.Sleep(100);
}while (true);
}
if (sf.Stream == null)
{
lock (files)
{
files.Remove(sf.Path);
return(null);
}
}
return(new SharedDisposable(sf));
}
public override void DeleteSiteContent(int siteId)
{
SharedFile.DeleteBySite(siteId);
if (SharedFilesConfiguration.DeleteFilesOnSiteDelete)
{
try
{
string fileVirtualBasePath = "~/Data/Sites/" + siteId.ToInvariantString() + "/SharedFiles/";
FileSystemProvider p = FileSystemManager.Providers[WebConfigSettings.FileSystemProvider];
if (p != null)
{
IFileSystem fileSystem = p.GetFileSystem();
if (fileSystem != null)
{
fileSystem.DeleteFolder(fileVirtualBasePath);
}
}
}
catch (Exception ex)
{
log.Error(ex);
}
}
}
public void SharedFileStateConverter_ConvertedFileSet_AlreadyShared()
{
var user = new User()
{
UserId = Guid.NewGuid(), UserTag = TestConstants.Facebook1UserId
};
var roomSharedFileCollectionsViewModel = viewModelFactory.GetViewModel <RoomSharedFileCollectionViewModel>();
var sharedFile = new SharedFile()
{
SharedFileId = Guid.NewGuid(),
ConvertedFileLocation = "http://localhost/something",
User = user
};
var sharedFileViewModel = viewModelFactory.GetViewModel <SharedFileViewModel>(vm => vm.Model.SharedFileId == sharedFile.SharedFileId);
sharedFileViewModel.Model = sharedFile;
roomSharedFileCollectionsViewModel.ViewModels.Add(sharedFileViewModel);
var converter = new SharedFileStateConverter()
{
SharedFileViewModels = roomSharedFileCollectionsViewModel.ViewModels
};
string actual = converter.Convert(sharedFileViewModel, typeof(string), null, CultureInfo.CurrentCulture) as string;
Assert.AreEqual(ClientStrings.SharedFileActionRemove, actual);
}
public frmShareFileSelection(BitChatNode node, SharedFile sharedFile)
{
InitializeComponent();
BitChat[] sharedChats = sharedFile.GetChatList();
foreach (BitChat chat in node.GetBitChatList())
{
bool found = false;
foreach (BitChat sharedChat in sharedChats)
{
if (sharedChat == chat)
{
found = true;
break;
}
}
if (!found)
{
checkedListBox1.Items.Add(chat);
}
}
}
private void button3_Click(object sender, EventArgs e)
{
using (var fileDialog = new OpenFileDialog())
{
if (fileDialog.ShowDialog() == DialogResult.OK)
{
SharedFile file = new SharedFile(fileDialog.FileName);
formatter.Serialize(strm, "3");
try
{
try {
formatter.Serialize(strm, file);
MessageBox.Show("File uploaded");
}
catch (Exception exc)
{
MessageBox.Show("Somethings goes wrong" + exc.Message);
}
button1_Click(button1, EventArgs.Empty);
}
catch (Exception exception)
{
MessageBox.Show("Something goes wrong, " + exception.Message);
}
}
}
}
private void btnDeleteFile_Click(object sender, EventArgs e)
{
SharedFile sharedFile = new SharedFile(moduleId, itemId);
if (sharedFile.ModuleId != moduleId)
{
SiteUtils.RedirectToAccessDeniedPage(this);
return;
}
sharedFile.ContentChanged += new ContentChangedEventHandler(sharedFile_ContentChanged);
if (config.EnableVersioning)
{
SharedFilesHelper.CreateHistory(sharedFile, fileSystem, virtualSourcePath, virtualHistoryPath);
}
sharedFile.Delete();
CurrentPage.UpdateLastModifiedTime();
CacheHelper.ClearModuleCache(moduleId);
SiteUtils.QueueIndexing();
if (hdnReturnUrl.Value.Length > 0)
{
WebUtils.SetupRedirect(this, hdnReturnUrl.Value);
return;
}
WebUtils.SetupRedirect(this, SiteUtils.GetCurrentPageUrl());
}
// POST: api/Share
public async Task Post()
{
HttpContext httpContext = HttpContext.Current;
SharedVulnerability sharedVulnerability = new SharedVulnerability();
sharedVulnerability.Comment = httpContext.Request.Form["Comment"];
sharedVulnerability.CommitMessage = httpContext.Request.Form["CommitMessage"];
sharedVulnerability.CweId = int.TryParse(httpContext.Request.Form["CweId"], out int cweId) ? cweId : (int?)null;
foreach (string key in httpContext.Request.Files.AllKeys)
{
SharedFile sharedFile = new SharedFile();
HttpPostedFile file = httpContext.Request.Files[key];
sharedFile.Name = file.FileName;
using (BinaryReader binaryReader = new BinaryReader(file.InputStream))
{
sharedFile.Content = binaryReader.ReadBytes(file.ContentLength);
}
sharedFile.VulnerabilityState = key.StartsWith("currentFile") ? VulnerabilityState.AfterFix : VulnerabilityState.Vulnerable;
sharedVulnerability.SharedFiles.Add(sharedFile);
}
micscanContext.SharedVulnerabilities.Add(sharedVulnerability);
await micscanContext.SaveChangesAsync();
}
protected void dgFile_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName == "ItemClicked")
{
string keys = e.CommandArgument.ToString();
char[] separator = { '~' };
string[] args = keys.Split(separator);
string type = args[1];
dgFile.EditIndex = -1;
if (type == "folder")
{
CurrentFolderId = int.Parse(args[0]);
BindData();
upFiles.Update();
return;
}
// this isn't used since we changed to a link to download.aspx
if (type == "file")
{
int fileID = int.Parse(args[0]);
SharedFile sharedFile = new SharedFile(this.ModuleId, fileID);
sharedFile.ContentChanged += new ContentChangedEventHandler(SharedFile_ContentChanged);
string virtualPath = "~/Data/Sites/" + this.SiteId.ToInvariantString()
+ "/SharedFiles/" + sharedFile.ServerFileName;
string fileType = Path.GetExtension(sharedFile.OriginalFileName).Replace(".", string.Empty);
string mimeType = SiteUtils.GetMimeType(fileType);
Page.Response.ContentType = mimeType;
if (SiteUtils.IsNonAttacmentFileType(fileType))
{
//this will display the pdf right in the browser
Page.Response.AddHeader("Content-Disposition", "filename=\"" + HttpUtility.UrlEncode(sharedFile.FriendlyName.Replace(" ", string.Empty), Encoding.UTF8) + "\"");
}
else
{
// other files just use file save dialog
Page.Response.AddHeader("Content-Disposition", "attachment; filename=\"" + HttpUtility.UrlEncode(sharedFile.FriendlyName.Replace(" ", string.Empty), Encoding.UTF8) + "\"");
}
Page.Response.Buffer = false;
Page.Response.BufferOutput = false;
//Page.Response.TransmitFile(downloadPath);
using (System.IO.Stream stream = fileSystem.GetAsStream(virtualPath))
{
stream.CopyTo(Page.Response.OutputStream);
}
try
{
Page.Response.End();
}
catch (System.Threading.ThreadAbortException) { }
}
}
}
private void DeleteItem(GridViewRow e)
{
string keys = dgFile.DataKeys[e.RowIndex].Value.ToString();
char[] separator = { '~' };
string[] args = keys.Split(separator);
string type = args[1];
if (type == "folder")
{
int folderID = int.Parse(args[0]);
SharedFileFolder folder = new SharedFileFolder(this.ModuleId, folderID);
//folder.DeleteAllFiles(this.filePath);
SharedFilesHelper.DeleteAllFiles(folder, fileSystem, fileVirtualBasePath, config);
SharedFileFolder.DeleteSharedFileFolder(folderID);
//TODO: file content changed event so re-index
}
if (type == "file")
{
int fileID = int.Parse(args[0]);
SharedFile sharedFile = new SharedFile(this.ModuleId, fileID);
if (!config.EnableVersioning)
{
fileSystem.DeleteFile(VirtualPathUtility.Combine(fileVirtualBasePath, sharedFile.ServerFileName));
}
sharedFile.Delete();
sharedFile.ContentChanged += new ContentChangedEventHandler(SharedFile_ContentChanged);
}
}
public override void ContentChangedHandler(
object sender,
ContentChangedEventArgs e)
{
if (WebConfigSettings.DisableSearchIndex)
{
return;
}
SharedFile sharedFile = (SharedFile)sender;
if (e.IsDeleted)
{
// get list of pages where this module is published
List <PageModule> pageModules
= PageModule.GetPageModulesByModule(sharedFile.ModuleId);
foreach (PageModule pageModule in pageModules)
{
mojoPortal.SearchIndex.IndexHelper.RemoveIndexItem(
pageModule.PageId,
sharedFile.ModuleId,
sharedFile.ItemId);
}
}
else
{
IndexItem(sharedFile);
}
}
private void chat_FileRemoved(BitChat chat, SharedFile sharedFile)
{
if (_sharedFile == sharedFile)
{
FileRemoved?.Invoke(this, EventArgs.Empty);
}
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Name,UploadDate,Category,Rating,Size,Uploader")] SharedFile sharedFile)
{
if (id != sharedFile.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(sharedFile);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SharedFileExists(sharedFile.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(sharedFile));
}
private static void Remove(SharedFile sf)
{
lock (files)
{
using (sf.Stream) { }
files.Remove(sf.Path);
}
}
private void _chat_FileAdded(BitChat sender, SharedFile sharedFile)
{
SharedFileItem item = new SharedFileItem(sharedFile, _chat);
item.FileRemoved += OnFileRemoved;
lstFiles.AddItem(item);
}
private void BitChat_FileRemoved(BitChat chat, SharedFile sharedFile)
{
if (_sharedFile == sharedFile)
{
linkAction.Visible = false;
_sharedFile = null;
}
}
private void chat_FileAdded(BitChat.Peer peer, MessageItem message, SharedFile sharedFile)
{
ChatMessageFileItem fileItem = new ChatMessageFileItem(peer, message, sharedFile);
AddMessage(fileItem, true);
fileItem.ShareFile += FileItem_ShareFile;
}
public void SharedFileStateConverter_ConvertedFileNull_UploadCommandNull()
{
var sharedFile = new SharedFile();
var converter = new SharedFileStateConverter();
string actual = converter.Convert(sharedFile, typeof(string), null, CultureInfo.CurrentCulture) as string;
Assert.AreEqual(ClientStrings.SharedFileActionError, actual);
}
public void Insert(SharedFile file)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
_repo.Insert(file);
}
void grdHistory_RowCommand(object sender, GridViewCommandEventArgs e)
{
int archiveID = Convert.ToInt32(e.CommandArgument);
switch (e.CommandName)
{
case "restore":
//SharedFile.RestoreHistoryFile(archiveID, this.upLoadPath, this.historyPath);
SharedFilesHelper.RestoreHistoryFile(archiveID, fileSystem, virtualSourcePath, virtualHistoryPath);
WebUtils.SetupRedirect(this, Request.RawUrl);
break;
case "deletehx":
SharedFilesHelper.DeleteHistoryFile(archiveID, fileSystem, virtualHistoryPath);
SharedFile.DeleteHistory(archiveID);
WebUtils.SetupRedirect(this, Request.RawUrl);
break;
case "download":
SharedFileHistory historyFile = SharedFile.GetHistoryFile(archiveID);
if (historyFile != null)
{
string fileType = Path.GetExtension(historyFile.FriendlyName).Replace(".", string.Empty);
if (string.Equals(fileType, "pdf", StringComparison.InvariantCultureIgnoreCase))
{
//this will display the pdf right in the browser
Page.Response.AddHeader("Content-Disposition", "filename=" + historyFile.FriendlyName);
}
else
{
// other files just use file save dialog
Page.Response.AddHeader("Content-Disposition", "attachment; filename=" + historyFile.FriendlyName);
}
//Page.Response.AddHeader("Content-Length", documentFile.DocumentImage.LongLength.ToString());
Page.Response.ContentType = "application/" + fileType;
Page.Response.Buffer = false;
Page.Response.BufferOutput = false;
//Response.TransmitFile(historyPath + historyFile.ServerFileName);
//Response.End();
using (System.IO.Stream stream = fileSystem.GetAsStream(virtualHistoryPath + historyFile.ServerFileName))
{
stream.CopyTo(Page.Response.OutputStream);
}
try
{
Page.Response.End();
}
catch (System.Threading.ThreadAbortException) { }
}
break;
}
}
private void btnUpdateFile_Click(object sender, EventArgs e)
{
SiteUser siteUser = SiteUtils.GetCurrentSiteUser();
if (siteUser == null)
{
return;
}
SharedFile file = new SharedFile(moduleId, itemId);
file.ContentChanged += new ContentChangedEventHandler(sharedFile_ContentChanged);
if ((file.ItemId > 0) && (file.ModuleId == moduleId))
{
file.FriendlyName = txtFriendlyName.Text;
file.Description = edDescription.Text;
file.FolderId = int.Parse(ddFolders.SelectedValue);
if (file.FolderId > -1)
{
SharedFileFolder folder = new SharedFileFolder(moduleId, file.FolderId);
file.FolderGuid = folder.FolderGuid;
}
if (file.ModuleGuid == Guid.Empty)
{
Module m = new Module(moduleId);
file.ModuleGuid = m.ModuleGuid;
}
file.UploadUserId = siteUser.UserId;
// really last mod date
file.UploadDate = DateTime.UtcNow;
List <ListItem> selectedRoles = cblRolesThatCanViewFile.Items.Cast <ListItem>()
.Where(li => li.Selected)
.ToList();
string viewRoles = String.Join(";", selectedRoles.Select(x => x.Value.ToString()).ToArray());
file.ViewRoles = viewRoles;
file.Save();
}
CurrentPage.UpdateLastModifiedTime();
CacheHelper.ClearModuleCache(moduleId);
SiteUtils.QueueIndexing();
if (hdnReturnUrl.Value.Length > 0)
{
WebUtils.SetupRedirect(this, hdnReturnUrl.Value);
return;
}
WebUtils.SetupRedirect(this, SiteUtils.GetCurrentPageUrl());
}
private void Run()
{
NetworkStream strm = null;
String choosen = null;
do
{
try
{
strm = client.GetStream();
IFormatter formatter = new BinaryFormatter();
choosen = (String)formatter.Deserialize(strm);
switch (choosen)
{
case "1":
Console.WriteLine(choosen);
formatter.Serialize(strm, findAllStoredFiles());
break;
case "2":
Console.WriteLine(choosen);
try
{
String path = (String)formatter.Deserialize(strm);
Console.WriteLine(path);
SharedFile file = new SharedFile(path);
formatter.Serialize(strm, file);
}
catch (SerializationException se)
{
Console.WriteLine("Serialization exception" + se.Message);
}
break;
case "3":
Console.WriteLine(choosen);
try {
SharedFile upload = (SharedFile)formatter.Deserialize(strm);
upload.Save("stored");
}
catch (SerializationException se)
{
Console.WriteLine("Deserialization exception" + se.Message);
}
break;
}
}
catch (Exception e)
{
strm.Close();
Console.WriteLine(e.Message);
break;
}
} while (!choosen.Equals("4"));
}
private void btnUpload_Click(object sender, EventArgs e)
{
if (uploader.HasFile)
{
SiteUser siteUser = SiteUtils.GetCurrentSiteUser();
if (siteUser == null)
{
return;
}
SharedFile sharedFile = new SharedFile(this.moduleId, this.itemId);
sharedFile.ContentChanged += new ContentChangedEventHandler(sharedFile_ContentChanged);
if (config.EnableVersioning)
{
bool historyCreated = SharedFilesHelper.CreateHistory(sharedFile, fileSystem, virtualSourcePath, virtualHistoryPath);
if (historyCreated)
{
sharedFile.ServerFileName = System.Guid.NewGuid().ToString() + ".config";
}
}
sharedFile.ModuleId = this.moduleId;
if (sharedFile.ModuleGuid == Guid.Empty)
{
Module m = GetModule(moduleId, SharedFile.FeatureGuid);
sharedFile.ModuleGuid = m.ModuleGuid;
}
string fileName = Path.GetFileName(uploader.FileName);
sharedFile.OriginalFileName = fileName;
sharedFile.FriendlyName = fileName;
sharedFile.SizeInKB = (int)(uploader.FileBytes.Length / 1024);
sharedFile.UploadUserId = siteUser.UserId;
sharedFile.UploadDate = DateTime.UtcNow;
if (sharedFile.Save())
{
string destPath = virtualSourcePath + sharedFile.ServerFileName;
using (Stream s = uploader.FileContent)
{
//fileSystem.SaveFile(destPath, file1.FileContent, file1.ContentType, true);
fileSystem.SaveFile(destPath, s, IOHelper.GetMimeType(Path.GetExtension(sharedFile.FriendlyName).ToLower()), true);
}
}
CurrentPage.UpdateLastModifiedTime();
CacheHelper.ClearModuleCache(moduleId);
SiteUtils.QueueIndexing();
}
WebUtils.SetupRedirect(this, Request.RawUrl);
}
protected void btnUpload_Click(object sender, EventArgs e)
{
// as long as javascript is available this code should never execute
// because the standard file input ir replaced by javascript and the file upload happens
// at the service url /SharedFiles/upload.ashx
// this is fallback implementation
if (!fileSystem.FolderExists(fileVirtualBasePath))
{
fileSystem.CreateFolder(fileVirtualBasePath);
}
SiteUser siteUser = SiteUtils.GetCurrentSiteUser();
if (siteUser == null)
{
WebUtils.SetupRedirect(this, Request.RawUrl); return;
}
if (uploader.HasFile)
{
SharedFile sharedFile = new SharedFile();
string fileName = Path.GetFileName(uploader.FileName);
sharedFile.ModuleId = ModuleId;
sharedFile.ModuleGuid = ModuleConfiguration.ModuleGuid;
sharedFile.OriginalFileName = fileName;
sharedFile.FriendlyName = fileName;
sharedFile.SizeInKB = (int)(uploader.FileContent.Length / 1024);
sharedFile.FolderId = CurrentFolderId;
if (CurrentFolderId > -1)
{
SharedFileFolder folder = new SharedFileFolder(ModuleId, CurrentFolderId);
sharedFile.FolderGuid = folder.FolderGuid;
}
sharedFile.UploadUserId = siteUser.UserId;
sharedFile.UserGuid = siteUser.UserGuid;
sharedFile.ContentChanged += new ContentChangedEventHandler(SharedFile_ContentChanged);
if (sharedFile.Save())
{
string destPath = VirtualPathUtility.Combine(fileVirtualBasePath, sharedFile.ServerFileName);
using (Stream s = uploader.FileContent)
{
fileSystem.SaveFile(destPath, s, IOHelper.GetMimeType(Path.GetExtension(sharedFile.FriendlyName).ToLower()), true);
}
}
}
WebUtils.SetupRedirect(this, Request.RawUrl);
}
private void PopulateFileControls()
{
Title = SiteUtils.FormatPageTitle(siteSettings, SharedFileResources.SharedFilesEditLabel);
heading.Text = SharedFileResources.SharedFilesEditLabel;
SharedFile file = new SharedFile(moduleId, itemId);
if ((file.ItemId > 0) && (file.ModuleId == moduleId))
{
pnlNotFound.Visible = false;
pnlFolder.Visible = false;
pnlFile.Visible = true;
using (IDataReader reader = SharedFileFolder.GetSharedModuleFolders(file.ModuleId))
{
ddFolders.DataSource = reader;
ddFolders.DataBind();
}
ddFolders.Items.Insert(0, new ListItem("Root", "-1"));
ddFolders.SelectedValue = file.FolderId.ToInvariantString();
hdnCurrentFolderId.Value = file.FolderId.ToInvariantString();
if (timeZone != null)
{
lblUploadDate.Text = file.UploadDate.ToLocalTime(timeZone).ToString();
}
else
{
lblUploadDate.Text = file.UploadDate.AddHours(TimeOffset).ToString();
}
SiteUser uploadUser = new SiteUser(siteSettings, file.UploadUserId);
lblUploadBy.Text = uploadUser.Name;
lblFileSize.Text = file.SizeInKB.ToString();
txtFriendlyName.Text = file.FriendlyName;
edDescription.Text = file.Description;
if (config.EnableVersioning)
{
using (IDataReader reader = file.GetHistory())
{
grdHistory.DataSource = reader;
grdHistory.DataBind();
}
}
PopulateAllowedRolesList(cblRolesThatCanViewFile, file.ViewRoles);
}
else
{
pnlNotFound.Visible = true;
pnlFolder.Visible = false;
pnlFile.Visible = false;
}
}
public static DalSharedFile ToDalSharedFile(this SharedFile sharedFileEntity)
{
return(new DalSharedFile()
{
OwnerId = sharedFileEntity.OwnerId,
RecipientId = sharedFileEntity.RecipientId,
FileId = sharedFileEntity.FileId
});
}
public SharedFile[] GetSharedFileList()
{
lock (_sharedFiles)
{
SharedFile[] sharedFilesList = new SharedFile[_sharedFiles.Count];
_sharedFiles.Values.CopyTo(sharedFilesList, 0);
return(sharedFilesList);
}
}
public IActionResult GetByCarId([FromForm(Name = ("File"))] IFormFile file, [FromForm] SharedFile sharedFile)
{
var result = _sharedFilesService.Update(file, sharedFile);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
private void SharedFileProcessor(SharedFile file)
{
//todo
Console.WriteLine("Receive a file");
}
