/// <summary>
/// Moves the folder and files at the specified folder path to the new folder path.
/// </summary>
public virtual void MoveFolder(string folderPath, string newFolderPath, FolderMappingInfo folderMapping)
{
Requires.NotNullOrEmpty("folderPath", folderPath);
Requires.NotNullOrEmpty("newFolderPath", newFolderPath);
Requires.NotNull("folderMapping", folderMapping);
var folderProvider = Instance(folderMapping.FolderProviderType);
AddFolderAndMoveFiles(folderPath, newFolderPath, folderMapping);
var folderManager = new FolderManager();
var subFolders = folderManager.GetFolderMappingFoldersRecursive(folderMapping, folderPath).Skip(1).Reverse();
foreach (var subFolderPath in subFolders.Select(s => s.Key))
{
var newSubFolderPath = newFolderPath + subFolderPath.Substring(folderPath.Length);
AddFolderAndMoveFiles(subFolderPath, newSubFolderPath, folderMapping);
folderProvider.DeleteFolder(new FolderInfo {
FolderPath = subFolderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.FolderMappingID
});
}
folderProvider.DeleteFolder(new FolderInfo {
FolderPath = folderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID
});
}
public HomeView(TextFileProcessor textFileProcessor, FolderManager folderManager)
{
InitializeComponent();
this.textFileProcessor = textFileProcessor;
this.folderManager = folderManager;
ChangeView(Properties.Settings.Default.View);
ChangeSortAttribute(Properties.Settings.Default.SortAttribute);
ChangeSortOrder(Properties.Settings.Default.SortOrder);
reportLabels = new List <Label> {
totalWordsIndexedTitle, totalWordsIndexedLabel,
totalUniqueWordsIndexedTitle, totalUniqueWordsIndexedLabel,
longestWordIndexedTitle, longestWordIndexedLabel,
shortestWordIndexedTitle, shortestWordIndexedLabel,
mostFrequentWordIndexedTitle, mostFrequentWordIndexedLabel,
leastFrequentWordIndexedTitle, leastFrequentWordIndexedLabel
};
textFileProcessor.OnIdle += (s, e) =>
{
if (InvokeRequired)
{
Invoke((MethodInvoker)refreshStatsButton.PerformClick);
}
};
LayoutReportLabels();
FillWatchedFoldersListView();
refreshStatsButton.PerformClick();
}
private Serilog.LoggerConfiguration Configure(LoggerConfiguration settings, EmailSettings emailSettings)
{
FolderManager.CheckAndCreateDirectory($@"{_path}\logs");
var seriLogConfig = new Serilog.LoggerConfiguration()
.Enrich
.WithExceptionDetails();
if (settings.EnableSerilogDebugger)
{
var file = File.CreateText($@"{_path}\logs\serilog.txt");
Serilog.Debugging.SelfLog.Enable(TextWriter.Synchronized(file));
}
if (settings.EnableFile)
{
seriLogConfig.WriteTo.RollingFile($@"{_path}\logs\log-{{Date}}.txt");
}
if (settings.EnableEmail && emailSettings != null && !string.IsNullOrEmpty(settings.LoggingFromEmail) && !string.IsNullOrEmpty(settings.LoggingToEmail))
{
seriLogConfig.WriteTo.Email(fromEmail: settings.LoggingFromEmail,
toEmail: settings.LoggingToEmail,
mailServer: emailSettings.Server,
networkCredential: new NetworkCredential
{
Domain = emailSettings.Domain,
UserName = emailSettings.Username,
Password = emailSettings.Password
},
restrictedToMinimumLevel: LogEventLevel.Error);
}
return(seriLogConfig);
}
public JsonResult Get([FromQuery] string path)
{
if (path == null)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(null);
}
try
{
// Get files and folders for path
var currentFolderItems = FolderManager.GetAllItemsForFolder(path);
FolderFilesVariations countFilesVariationsForFolder;
// If path - drive check cache
if (path.Length == 3)
{
countFilesVariationsForFolder = SetGetCache(path);
}
else
{
countFilesVariationsForFolder = GlobalFilesCalculation.GetFilesCount(path);
}
Response.StatusCode = (int)HttpStatusCode.OK;
return(Json(new { files = currentFolderItems, countFiles = countFilesVariationsForFolder }));
}
catch
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(null);
}
}
private void btReadAll_Click(object sender, RoutedEventArgs e)
{
try
{
string data = null;
tbData.Text = null;
string path = tbPath.Text;
if (!new DirectoryInfo(path).Exists)
{
throw new InvalidDataException("无效的视频路径");
}
var packets = FolderManager.GetIndexesPackets(path);
foreach (var packet in packets)
{
writeLine(string.Format(packet.BeginTime.TimeOfDay + " - " + packet.EndTime.TimeOfDay + " " + packet.StartIndex), ref data);
var streams = FolderManager.GetVideoStreamsPacket(path, packet.BeginTime);
foreach (var stream in streams.VideoStreams)
{
writeLine($"{stream.Time.TimeOfDay}\t{stream.Buffer.Length}\t{BitConverter.ToString(stream.Buffer.Take(20).ToArray())}", ref data);
}
}
tbData.Text = data;
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(ex.Message);
}
}
public VideoTimePeriodsPacket GetCompletedTimePeriods()
{
IndexesPacket[] indexesPackets = FolderManager.GetIndexesPackets(_path);
var downloadedTPPs = TimePeriodManager.GetIntersections(indexesPackets, GetVideoTimePeriods()?.TimePeriods);
return(new VideoTimePeriodsPacket(_loadInfo.Info, downloadedTPPs));
}
public ShellForm(TextFileProcessor textFileProcessor, FolderManager folderManager, IncrementalIdentityStore identityStore)
{
InitializeComponent();
this.identityStore = identityStore;
this.folderManager = folderManager;
this.textFileProcessor = textFileProcessor;
Load += (s, e) =>
{
searchBar_middle_image.Width = searchBar_right_image.Left - searchBar_middle_image.Left + 3;
urlNsearchTextbox.Width = searchBar_middle_image.Width - 3;
};
Resize += (s, e) =>
{
searchBar_middle_image.Width = searchBar_right_image.Left - searchBar_middle_image.Left + 3;
urlNsearchTextbox.Width = searchBar_middle_image.Width - 3;
};
homeButton.MouseEnter += (s, e) => homeButton.BackgroundImage = Properties.Resources.Home_Enter;
homeButton.MouseLeave += (s, e) => homeButton.BackgroundImage = Properties.Resources.Home_Leave;
homeButton.MouseDown += (s, e) => homeButton.BackgroundImage = Properties.Resources.Home_Press;
homeButton.MouseUp += (s, e) => homeButton.BackgroundImage = Properties.Resources.Home_Leave;
goButton.MouseEnter += (s, e) => goButton.BackgroundImage = Properties.Resources.Search_Enter;
goButton.MouseLeave += (s, e) => goButton.BackgroundImage = Properties.Resources.Search_Leave;
goButton.MouseDown += (s, e) => goButton.BackgroundImage = Properties.Resources.Search_Press;
goButton.MouseUp += (s, e) => goButton.BackgroundImage = Properties.Resources.Search_Leave;
}
private void onLocalDownloadPath(string path)
{
Logger.Default.Trace("获取本地视频信息，Path：{0}", path);
LocalVideosInfoPacket packet = FolderManager.GetLocalVideoInfoPacket(path);
send(ParamCode.LocalDownSource, LocalVideosInfoPacket.Encode(packet));
}
public void TestVideoPackageRecorder()
{
FolderManager.DeleteDirectoryInfo(path);
TimePeriodPacket[] tisAll = new TimePeriodPacket[] { new TimePeriodPacket(begin, end) };
TimePeriodPacket[] tisCompleted = null;
using (VideoPackageRecorder recorder = new VideoPackageRecorder(path, TimeSpan.FromMinutes(1), tisAll, tisCompleted))
{
recorder.ProbeTime = end;
check(recorder, false, false, 0, 0);
recorder.SetVideoBaseInfo(new VideoBasePacket(new byte[5], begin, 10000));
check(recorder, true, false, 0, 0);
recorder.Set(null);
for (int i = 0; i < 23; i++)
{
recorder.Set(getVideoStreamsPacket(begin.AddSeconds(5 * i)));
check(recorder, true, false, 5 * (i + 1), 1);
}
recorder.Set(getVideoStreamsPacket(begin.AddSeconds(5 * 23)));
check(recorder, true, true, 120, 1);
recorder.Set(getVideoStreamsPacket(begin.AddSeconds(120)));
check(recorder, true, true, 120, 1);
recorder.Stop();
recorder.Set(getVideoStreamsPacket(begin.AddSeconds(120)));
check(recorder, true, true, 120, 1);
}
FolderManager.DeleteDirectoryInfo(path);
}
void FileSystemObjectInfo_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (this.FileSystemInfo is DirectoryInfo)
{
if (string.Equals(e.PropertyName, "IsExpanded", StringComparison.CurrentCultureIgnoreCase))
{
RaiseBeforeExpand();
if (this.IsExpanded)
{
this.ImageSource = FolderManager.GetImageSource(this.FileSystemInfo.FullName, ItemState.Open);
if (this.HasDummy())
{
RaiseBeforeExplore();
this.RemoveDummy();
this.ExploreDirectories();
this.ExploreFiles();
RaiseAfterExplore();
}
}
else
{
this.ImageSource = FolderManager.GetImageSource(this.FileSystemInfo.FullName, ItemState.Close);
}
RaiseAfterExpand();
}
}
}
static void Main(string[] args)
{
List <Drive> listAll = DriveManager.GetAllDrives();
string path = "C:\\";
string pathRec = "C:\\";
var currentFolderItems = FolderManager.GetAllItemsForFolder(path);
foreach (var item in listAll)
{
Console.WriteLine(item.Name);
}
Console.WriteLine("----------------------------------------------------------");
foreach (var item in currentFolderItems)
{
Console.WriteLine(item.Name);
}
Console.WriteLine("----------------------------------------------------------");
var items = GlobalFilesCalculation.GetFilesCount(pathRec);
Console.WriteLine($"{items.FilesThatLessThan10Mb} -- " +
$"{items.FilesBetween10ANd50Mb} --" +
$"errors - {items.Errors} --" +
$"{items.FilesMoreThan100Mb}");
Console.ReadKey();
}
private void moveTo(string oldPath, string newPath, string oldFileName)
{
string oldName = Path.Combine(oldPath, oldFileName);
string newName = Path.Combine(newPath, Name);
if (new DirectoryInfo(newName).Exists)
{
throw new IOException(string.Format("指定路径已存在下载任务！{0}", newName));
}
new DirectoryInfo(newPath).Create();
DirectoryInfo oldDir = new DirectoryInfo(oldName);
if (oldDir.Root == new DirectoryInfo(newPath).Root)
{
oldDir.MoveTo(newName);//相同根路径移动
}
else
{
new DirectoryInfo(newName).Create();
foreach (var file in oldDir.EnumerateFiles())
{
string newFile = Path.Combine(newName, file.Name);
file.CopyTo(newFile);
}
FolderManager.DeleteDirectoryInfo(oldDir.FullName);
}
}
public void Test_CreateUpdateDeleteThread()
{
Inbox inbox = Test_Inboxs.Create(this.DataStore, Workmate.Components.InstanceContainer.ApplicationSettings, this.Application, this.Random);
FolderManager manager = new FolderManager(this.DataStore);
Folder record = Create(this.DataStore, Workmate.Components.InstanceContainer.ApplicationSettings, this.Application, inbox, this.Random);
Folder recordToCompare;
for (int i = 0; i < this.DefaultUpdateTestIterations; i++)
{
PopulateWithRandomValues(record, this.DummyDataManager, this.Random);
recordToCompare = record;
manager.Update(record);
record = manager.GetFolder(record.FolderId);
string errors = string.Empty;
// TODO (Roman): relax datetime comparisons
Assert.IsTrue(DebugUtility.ArePropertyValuesEqual(record, recordToCompare, out errors), errors);
Trace.WriteLine("Update test successfull.");
}
Delete(this.DataStore, record);
Test_Inboxs.Delete(this.DataStore, inbox);
}
public FileSystemObjectInfo(FileSystemInfo info)
{
if (this is DummyFileSystemObjectInfo)
{
return;
}
Children = new ObservableCollection <FileSystemObjectInfo>();
FileSystemInfo = info;
if (info is DirectoryInfo)
{
ImageSource = FolderManager.GetImageSource(
info.FullName, ItemState.Close);
AddDummy();
}
else if (info is FileInfo)
{
ImageSource = FileManager.GetImageSource(info.FullName);
}
PropertyChanged += new PropertyChangedEventHandler(
FileSystemObjectInfo_PropertyChanged);
CmdDelete = new DelegateCommand(p => OnDeleteEvent());
}
public void Setup()
{
_sfp = new StandardFolderProvider();
_folderInfo = new Mock <IFolderInfo>();
_fileInfo = new Mock <IFileInfo>();
_fileWrapper = new Mock <IFile>();
_directoryWrapper = new Mock <IDirectory>();
_folderManager = new Mock <IFolderManager>();
_fileManager = new Mock <IFileManager>();
_pathUtils = new Mock <IPathUtils>();
_portalControllerMock = new Mock <IPortalController>();
_portalControllerMock.Setup(p => p.GetPortalSettings(Constants.CONTENT_ValidPortalId))
.Returns(GetPortalSettingsDictionaryMock());
_portalControllerMock.Setup(p => p.GetCurrentPortalSettings()).Returns(GetPortalSettingsMock());
_cryptographyProviderMock = new Mock <CryptographyProvider>();
_cryptographyProviderMock.Setup(c => c.EncryptParameter(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Guid.NewGuid().ToString("N"));
_localeControllerMock = new Mock <ILocaleController>();
_localeControllerMock.Setup(l => l.GetLocales(Constants.CONTENT_ValidPortalId)).Returns(new Dictionary <string, Locale>
{
{ "en-us", new Locale() }
});
FileWrapper.RegisterInstance(_fileWrapper.Object);
DirectoryWrapper.RegisterInstance(_directoryWrapper.Object);
FolderManager.RegisterInstance(_folderManager.Object);
FileManager.RegisterInstance(_fileManager.Object);
PathUtils.RegisterInstance(_pathUtils.Object);
PortalController.SetTestableInstance(_portalControllerMock.Object);
ComponentFactory.RegisterComponentInstance <CryptographyProvider>("CryptographyProviderMock", _cryptographyProviderMock.Object);
LocaleController.RegisterInstance(_localeControllerMock.Object);
}
void FileSystemObjectInfo_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (FileSystemInfo is DirectoryInfo)
{
if (string.Equals(e.PropertyName, nameof(IsExpanded), StringComparison.CurrentCultureIgnoreCase))
{
RaiseBeforeExpand();
if (IsExpanded)
{
ImageSource = FolderManager.GetImageSource(FileSystemInfo.FullName, ItemState.Open);
if (HasDummy())
{
RaiseBeforeExplore();
if (!(Drive?.IsReady == false))
{
RemoveDummy();
ExploreDirectories();
ExploreFiles();
}
RaiseAfterExplore();
}
}
else
{
ImageSource = FolderManager.GetImageSource(FileSystemInfo.FullName, ItemState.Close);
}
RaiseAfterExpand();
}
}
}
public DocumentController(ILogger <DocumentController> logger, DocumentManager documentManager, FolderManager folderManager, IWebHostEnvironment environment)
{
_logger = logger;
_documentManager = documentManager;
_folderManager = folderManager;
_hostingEnvironment = environment;
}
public void TestVideoBaseFileRecorder()
{
string path = @"D:\读写测试\VideoBaseFileRecorder";
FolderManager.DeleteDirectoryInfo(path);
var downloadInfo = new DownloadInfoParam("ip", 10001, beginTime, beginTime.AddMinutes(30), "videoId", 0, path, "test");
VideoBaseFileRecorder recorder = new VideoBaseFileRecorder(path);
recorder.UpdateDownloadInfo(downloadInfo);
Assert.IsNull(recorder.TimePeriods);
Assert.IsNull(recorder.VideoBase);
recorder.UpdateTimePeriods(packet);
Assert.AreEqual(packet, recorder.TimePeriods);
recorder.UpdateVideoBase(basePacket);
Assert.AreEqual(basePacket, recorder.VideoBase);
DownloadInfoParamTest.AssertAreEqual(downloadInfo, recorder.DownloadInfo);
VideoBaseFileRecorder recorder1 = new VideoBaseFileRecorder(path);
VideoBasePacketTest.AssertAreEqual(recorder.VideoBase, recorder1.VideoBase);
VideoTimePeriodsPacketTest.AssertAreEqual(recorder.TimePeriods, recorder1.TimePeriods);
FolderManager.DeleteDirectoryInfo(path);
}
public VideoTimePeriodsPacket Search(DateTime beginTime, DateTime endTime, IVideoInfo videoInfo)
{
string path = GlobalData.VideoPath(videoInfo.VideoId, videoInfo.StreamId);
DateTime[] dates = VideoStoragerManager.GetFolderPaths(videoInfo.VideoId, videoInfo.StreamId, beginTime, endTime);
List <TimePeriodPacket> tis = new List <TimePeriodPacket>();
Parallel.ForEach(dates, date =>
{
string folder = Path.Combine(path, GlobalProcess.FolderPath(date));
var array = FolderManager.GetTimePeriods(folder);
if (array.Length > 0)
{
lock (tis)
tis.AddRange(array);
}
});
if (endTime > DateTime.Now.Date)
{
tis.AddRange(findTodayLastest(path, endTime));
}
var timeCombines = TimePeriodManager.Combine(tis.ToArray());
var validArray = TimePeriodManager.GetIntersections(timeCombines, new TimePeriodPacket(beginTime, endTime));
return(new VideoTimePeriodsPacket(videoInfo, validArray));
}
public void Folder_Does_Not_Exists_For_Deletion()
{
var path = @"C:\SourceFiles\file.txt";
var mockFileSystem = new MockFileSystem();
var sut = new FolderManager(mockFileSystem);
Assert.That(() => sut.DeleteFolder(path), Throws.TypeOf <ArgumentException>());
}
public void Folder_Is_Null_For_Creation()
{
string path = null;
var mockFileSystem = new MockFileSystem();
var sut = new FolderManager(mockFileSystem);
Assert.That(() => sut.CreateFolder(path), Throws.TypeOf <ArgumentNullException>());
}
public void Folder_Path_Is_Null_For_Check_Existence()
{
string path = null;
var mockFileSystem = new MockFileSystem();
var sut = new FolderManager(mockFileSystem);
Assert.That(() => sut.IsFolderExists(path), Throws.TypeOf <ArgumentNullException>());
}
public void GetItemsWhenNullPath()
{
List <Item> filesAndFolders = new List <Item>();
filesAndFolders = FolderManager.GetAllItemsForFolder(null);
Assert.That(filesAndFolders, Is.Null);
}
/// <summary>EDITOR ONLY: Imports level assets from Assets/Levels.</summary>
public void EDITOR_Import()
{
//get levels
levels = FolderManager.GetAssetsAtPath <Level>("Levels");
//save assets
EditorUtility.SetDirty(this);
AssetDatabase.SaveAssets();
}
public JsonResult UploadToFolder(string id, HttpPostedFileBase file)
{
var node = GetNodeById(id);
FolderManager.UploadTo(file.InputStream, node.path + @"\" + file.FileName);
return(Json(new { file = file.FileName, folder = node.path }));
}
public void TestFolderManager_InvalidPath()
{
Assert.IsFalse(FolderManager.ClearDirectoryInfoAll("i:\\"));
Assert.IsFalse(FolderManager.ClearDirectoryInfoAll("abc"));
string path = @"D:\视频录像\invalid position";
Assert.IsFalse(FolderManager.DeleteDirectoryInfo(path));
Assert.IsFalse(FolderManager.ClearDirectoryInfoAll(path));
}
public void TestFolderManager_GetVideoHeader()
{
Assert.IsNull(FolderManager.GetVideoHeader("", DateTime.MinValue, DateTime.MaxValue));
Assert.IsNull(FolderManager.GetVideoHeader(@"D:\视频录像\videoId_2\", DateTime.MinValue, DateTime.MaxValue));
DateTime start = new DateTime(2016, 3, 22, 23, 51, 01, 156);
Assert.IsNull(FolderManager.GetVideoHeader(@"D:\视频录像\videoId_2\2016\03\22", start.Subtract(TimeSpan.FromMinutes(5)), start));
Assert.IsNotNull(FolderManager.GetVideoHeader(@"D:\视频录像\videoId_2\2016\03\22", start, start.AddMinutes(3)));
}
public void TestFolderManager_GetLocalVideoInfoPacket()
{
ExceptionManager.CheckException(() => FolderManager.GetLocalVideoInfoPacket(""));
ExceptionManager.CheckException(() => FolderManager.GetLocalVideoInfoPacket(@"d:\"));
var packet = FolderManager.GetLocalVideoInfoPacket(@"D:\读写测试\Time_201607190900_201607191000");
Assert.AreEqual(new DateTime(2016, 7, 19, 9, 0, 0), packet.TimePeriod.BeginTime);
Assert.AreEqual(2, packet.ValidTimePeriods.Length);
}
public JsonResult RenameFolder(string path, string name)
{
FolderManager.Rename(path, name);
var res = new TreeViewModel {
status = true, prompt = string.Empty
};
return(Json(res, JsonRequestBehavior.AllowGet));
}
public JsonResult CopyFolder(string path)
{
FolderManager.Copy(path);
var res = new TreeViewModel {
status = true, prompt = string.Empty
};
return(Json(res, JsonRequestBehavior.AllowGet));
}
public FolderData GetFolderData(string folderPath)
{
Log.InfoFormat("Getting folder with path '{0}'", folderPath);
FolderManager fm = new FolderManager();
FolderCriteria folderCrit = new FolderCriteria();
folderCrit.AddFilter(
FolderProperty.FolderPath,
CriteriaFilterOperator.EqualTo,
folderPath);
FolderData folder = fm.GetList(folderCrit).FirstOrDefault();
return folder;
}
public void Setup()
{
_mockFolder = MockComponentProvider.CreateFolderProvider(Constants.FOLDER_ValidFolderProviderType);
_mockData = MockComponentProvider.CreateDataProvider();
_folderMappingController = new Mock<IFolderMappingController>();
_directory = new Mock<IDirectory>();
_cbo = new Mock<ICBO>();
_pathUtils = new Mock<IPathUtils>();
FolderMappingController.RegisterInstance(_folderMappingController.Object);
DirectoryWrapper.RegisterInstance(_directory.Object);
CBOWrapper.RegisterInstance(_cbo.Object);
PathUtils.RegisterInstance(_pathUtils.Object);
_mockFolderManager = new Mock<FolderManager> { CallBase = true };
_folderManager = new FolderManager();
_folderInfo = new Mock<IFolderInfo>();
}
public static void AddUserFolder(PortalSettings portalSettings, string parentFolder, int storageLocation, int userID)
{
var user = UserController.GetUserById(portalSettings.PortalId, userID);
var folderManager = new FolderManager();
folderManager.AddUserFolder(user);
}
internal static FolderData GetFolderData(string folderPath)
{
FolderManager fm = new FolderManager();
FolderCriteria folderCrit = new FolderCriteria();
folderCrit.AddFilter(
FolderProperty.FolderPath,
CriteriaFilterOperator.EqualTo,
folderPath);
FolderData folder = fm.GetList(folderCrit).FirstOrDefault();
return folder;
}
void Awake()
{
folderManager = this.gameObject.GetComponent<FolderManager>();
}
public void CleanWLMailApiReferences()
{
_wlmailApiCore = null;
_folderManager = null;
_accountManager = null;
}
/// <summary>
/// Moves the folder and files at the specified folder path to the new folder path.
/// </summary>
public virtual void MoveFolder(string folderPath, string newFolderPath, FolderMappingInfo folderMapping)
{
Requires.NotNullOrEmpty("folderPath", folderPath);
Requires.NotNullOrEmpty("newFolderPath", newFolderPath);
Requires.NotNull("folderMapping", folderMapping);
var folderProvider = Instance(folderMapping.FolderProviderType);
AddFolderAndMoveFiles(folderPath, newFolderPath, folderMapping);
var folder = FolderManager.Instance.GetFolder(folderMapping.PortalID, folderPath);
var folderManager = new FolderManager();
var subFolders = folderManager.GetFolderMappingFoldersRecursive(folderMapping, folder).Skip(1).Reverse();
foreach (var subFolderPath in subFolders.Select(s => s.Key))
{
var newSubFolderPath = newFolderPath + subFolderPath.Substring(folderPath.Length);
AddFolderAndMoveFiles(subFolderPath, newSubFolderPath, folderMapping);
folderProvider.DeleteFolder(new FolderInfo { FolderPath = subFolderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.FolderMappingID });
}
folderProvider.DeleteFolder(new FolderInfo { FolderPath = folderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID });
}
// Use this for initialization
void Start()
{
instance = this;
folderManager = this.GetComponent<FolderManager>();
MainCamera = GameObject.Find("Main Camera").camera;
exampleProjects = new List<DirectoryInfo>();
exampleProjects.Add(CreateFolder);
foreach(DirectoryInfo folder in folderManager.GetExamples())
exampleProjects.Add(folder);
}
public Utils(WLMailApi wlmailApiCore, FolderManager folderManager, MailAccountManager accountManager)
{
_wlmailApiCore = wlmailApiCore;
_folderManager = folderManager;
_accountManager = accountManager;
}
