예제 #1
0
파일: FileManager.cs 프로젝트: Dahx/bns.spo
        public static void GetUsersFolderSize(string textfilewithids, string report_path)
        {
            MigrationSettigs d   = Init("0", "");
            LogCsvFile       log = new LogCsvFile("parent, size", report_path);

            GetDirecotrySizeFromTextFileList(textfilewithids, d, log);
        }
예제 #2
0
파일: FileManager.cs 프로젝트: Dahx/bns.spo
        public static void GetMissingDirectories(string masterfile_path, string doTransit)
        {
            MigrationSettigs d   = Init(doTransit, "");
            LogCsvFile       log = new LogCsvFile("Directory, Exists", "missing_directories");

            string[] lines = System.IO.File.ReadAllLines(masterfile_path);

            foreach (string id in lines)
            {
                try
                {
                    string folderPath = string.Format(d.SearchPattern, id);
                    if (Directory.Exists(folderPath))
                    {
                        log.WriteToCVS(folderPath, "TRUE");
                    }
                    else
                    {
                        log.WriteToCVS(string.Format(d.SearchPattern, id), "FALSE");
                    }
                }
                catch (Exception ex)
                {
                    log.WriteToCVS(string.Format(d.SearchPattern, id), "ERROR");
                    log.WriteError(id);
                    log.WriteError(ex.Message);
                }
            }
        }
예제 #3
0
        public static void ConvertXlsToXlsxFromFileList(string textfilewithids, string doTransit, string from_lastdate, string report_path)
        {
            ExcelObj.Application excelApp = null;
            LogCsvFile           log      = new LogCsvFile("parent, file, comments", report_path);
            MigrationSettigs     d        = FileManager.Init(doTransit, from_lastdate);

            try
            {
                string[] lines     = System.IO.File.ReadAllLines(textfilewithids);
                string   startedAt = DateTime.Now.ToString();
                long     count     = 1;

                log.WriteInfo("[opening master file]");
                log.WriteInfo(string.Format("[{0} records found]", lines.Length.ToString()));

                excelApp = new ExcelObj.Application();
                excelApp.AutomationSecurity = Microsoft.Office.Core.MsoAutomationSecurity.msoAutomationSecurityForceDisable;
                excelApp.AskToUpdateLinks   = false;
                excelApp.DisplayAlerts      = false;
                excelApp.Visible            = false;


                foreach (string idpair in lines)
                {
                    string[] values = idpair.Split(new char[] { ',' });
                    string   id     = values[0];

                    string folder       = string.Format(d.SearchPattern, id);
                    string parentFolder = folder.Substring(folder.LastIndexOf("\\") + 1);

                    log.WriteInfo("[processing]: " + parentFolder);
                    log.WriteInfo(string.Format("[processing]: {0}/{1}", count.ToString(), lines.Length.ToString()));

                    NewExcelInstance(excelApp, parentFolder, folder, 0, d, log);
                    count++;
                }

                log.WriteInfo("[Started at]: " + startedAt);
                log.WriteInfo("[Finished at]: " + DateTime.Now.ToString());
            }
            catch (Exception ex)
            {
                log.WriteError(ex.Message);
            }
            finally
            {
                try
                {
                    excelApp.Quit();
                    GC.Collect();
                    GC.WaitForPendingFinalizers();
                }
                catch (Exception e)
                {
                    log.WriteError(e.Message);
                }
            }
        }
예제 #4
0
파일: JobManager.cs 프로젝트: Dahx/bns.spo
        public JobManager(string repository)
        {
            job_repository = repository;
            DirectoryInfo currentFolder = new DirectoryInfo(job_repository);

            d              = FileManager.Init("1", "");
            log            = new LogCsvFile("Machine,JobName,Status,Time,Date,Comments", Environment.MachineName);
            log.ReportPath = job_repository + "\\" + Environment.MachineName + ".csv";
        }
예제 #5
0
        public static void CheckXlsToXlsxConversion(string masterfile_path, string doTransit, string from_lastdate)
        {
            MigrationSettigs d   = FileManager.Init(doTransit, from_lastdate);
            LogCsvFile       log = new LogCsvFile("parent, file, comments", "checkxlstoxlsx");

            string[] lines = System.IO.File.ReadAllLines(masterfile_path);

            log.WriteInfo("[Started at]: " + DateTime.Now.ToString());
            log.WriteInfo("[Parent Folders Found]: " + lines.Count().ToString());

            int convertedCount = 0;

            foreach (string idpair in lines)
            {
                string[] values = idpair.Split(new char[] { ',' });
                string   id     = values[0];

                string folderPath       = string.Format(d.SearchPattern, id);
                string parentFolderName = folderPath.Substring(folderPath.LastIndexOf("\\") + 1);
                var    files            = Directory.EnumerateFiles(folderPath, "*xls", SearchOption.AllDirectories);

                log.WriteInfo("[processing]: " + parentFolderName + "...");

                int fileCount = 0;
                foreach (string x in files)
                {
                    try
                    {
                        if (x.Substring(x.LastIndexOf(".")).ToLower() == ".xls")
                        {
                            string converted    = "false";
                            string xlsxFilePath = x.Replace(".xls", ".xlsx");
                            string xlsmFilePath = x.Replace(".xls", ".xlsm");

                            if (File.Exists(xlsxFilePath) || File.Exists(xlsmFilePath))
                            {
                                converted = "true";
                                convertedCount++;
                            }

                            fileCount++;

                            log.WriteToCVS(parentFolderName, x, converted);
                            log.WriteInfo("[" + x + "]" + " ...done ");
                        }
                    }
                    catch (Exception ex)
                    {
                        log.WriteInfo(x);
                        log.WriteInfo(ex.ToString());
                    }
                }
            }

            log.WriteInfo("[xlsx files found]: " + convertedCount.ToString());
            log.WriteInfo("[Finished at]: " + DateTime.Now.ToString());
        }
예제 #6
0
파일: FileManager.cs 프로젝트: Dahx/bns.spo
        static void GetFiles(string sourceDir, string parent, MigrationSettigs d, LogCsvFile log, ProcessFileDelegate FileHandler)
        {
            string[] fileEntries = TryGetDirFiles(sourceDir, log);
            foreach (string x in fileEntries)
            {
                FileHandler(parent, x, d, log);
            }

            string[] subdirEntries = TryGetSubDirs(sourceDir, log);
            foreach (string subdir in subdirEntries)
            {
                GetFiles(subdir, parent, d, log, FileHandler);
            }
        }
예제 #7
0
파일: FileManager.cs 프로젝트: Dahx/bns.spo
        static string[] TryGetSubDirs(string sourceDir, LogCsvFile log)
        {
            try
            {
                return(Directory.GetDirectories(sourceDir));
            }
            catch (Exception ex)
            {
                log.WriteError(sourceDir);
                log.WriteError(ex.Message);

                return(new string[] { });
            }
        }
예제 #8
0
        public static void ListXlsPwd(string textfilewithids, string doTransit, string from_lastdate, string report_path)
        {
            ExcelObj.Application excelApp = null;
            LogCsvFile           log      = new LogCsvFile("parent,file,owner", report_path);
            MigrationSettigs     d        = FileManager.Init(doTransit, from_lastdate);

            try
            {
                string[] lines     = System.IO.File.ReadAllLines(textfilewithids);
                string   startedAt = DateTime.Now.ToString();

                //excelApp = new ExcelObj.Application();
                //excelApp.AutomationSecurity = Microsoft.Office.Core.MsoAutomationSecurity.msoAutomationSecurityForceDisable;
                //excelApp.AskToUpdateLinks = false;
                //excelApp.DisplayAlerts = false;
                //excelApp.Visible = false;

                foreach (string idpair in lines)
                {
                    string[] values = idpair.Split(new char[] { ',' });
                    string   id     = values[0];

                    string folder       = string.Format(d.SearchPattern, id);
                    string parentFolder = folder.Substring(folder.LastIndexOf("\\") + 1);

                    NewExcelInstance(excelApp, parentFolder, folder, 1, d, log);
                }

                log.WriteInfo("[Started]: " + startedAt);
                log.WriteInfo("[Finished]: " + DateTime.Now.ToString());
            }
            catch (Exception ex)
            {
                log.WriteError(ex.Message);
            }
            finally
            {
                try
                {
                    //excelApp.Quit();
                    //GC.Collect();
                    //GC.WaitForPendingFinalizers();
                }
                catch (Exception e)
                {
                    log.WriteError(e.Message);
                }
            }
        }
예제 #9
0
파일: FileManager.cs 프로젝트: Dahx/bns.spo
        public static void GetFiles(string masterfile_path, string doTransit, string from_date, ProcessFileDelegate FileHandler, string report_name)
        {
            MigrationSettigs d   = Init(doTransit, from_date);
            LogCsvFile       log = new LogCsvFile("", report_name);

            string[] lines = System.IO.File.ReadAllLines(masterfile_path);

            foreach (string idpair in lines)
            {
                string[] values = idpair.Split(new char[] { ',' });
                string   id     = values[0];

                string folderPath       = string.Format(d.SearchPattern, id);
                string parentFolderName = folderPath.Substring(folderPath.LastIndexOf("\\") + 1);

                log.WriteInfo("processing " + parentFolderName + "...");
                GetFiles(folderPath, parentFolderName, d, log, FileHandler);
                log.WriteInfo("done...");
            }
        }
예제 #10
0
파일: JobManager.cs 프로젝트: Dahx/bns.spo
        public static void GeneratePsJobs(string master_file, string job_template, string job_repository, string dotransit)
        {
            MigrationSettigs d   = FileManager.Init(dotransit, "");
            LogCsvFile       log = new LogCsvFile("", "job_conversion");

            string[] lines = System.IO.File.ReadAllLines(master_file);
            foreach (string idpair in lines)
            {
                log.WriteInfo("[processing]: " + idpair);
                StringBuilder ps_content = new StringBuilder();
                using (StreamReader ps = File.OpenText(job_template))
                {
                    ps_content.Append(ps.ReadToEnd());
                }

                string[] values = idpair.Split(new char[] { ',' });
                string   id     = values[0];
                string   url    = values[0];
                if (values.Length > 1)
                {
                    url = values[1];
                }

                ps_content.Replace("##source_path##", string.Format(d.JobsSourcePsPathKeyValue, id));
                ps_content.Replace("##source_displayurl##", string.Format(d.JobsSourcePsDisplayUrlKeyValue, id));
                ps_content.Replace("##source_url##", string.Format(d.JobsSourcePsUrlKeyValue, id));

                ps_content.Replace("##target_path##", string.Format(d.JobsTargetPsPathKeyValue, url));
                ps_content.Replace("##target_displayurl##", string.Format(d.JobsTargetPsDisplayUrlKeyValue, url));
                ps_content.Replace("##target_url##", string.Format(d.JobsTargetPsUrlKeyValue, url));

                string ps_file = string.Format("{0}\\{1}.ps1", job_repository, id);
                using (FileStream f = File.Create(ps_file)) f.Close();
                File.AppendAllText(ps_file, ps_content.ToString());
            }
            log.WriteInfo("[done]");
        }
예제 #11
0
파일: FileManager.cs 프로젝트: Dahx/bns.spo
        public static void CheckInvalidFolders(string masterfile_path, string doTransit, string report_name)
        {
            MigrationSettigs d   = Init(doTransit, "");
            LogCsvFile       log = new LogCsvFile("Folder, Name", report_name);

            string[] excludedFolders = d.ExcludeFolders.Split(',');

            string[] lines = System.IO.File.ReadAllLines(masterfile_path);
            foreach (string idpair in lines)
            {
                string[] values = idpair.Split(new char[] { ',' });
                string   id     = values[0];

                try
                {
                    string folderPath = string.Format(d.SearchPattern, id);
                    string parent     = folderPath.Substring(folderPath.LastIndexOf("\\") + 1);
                    foreach (string folder in Directory.GetDirectories(folderPath, "*", SearchOption.AllDirectories))
                    {
                        DirectoryInfo dir   = new DirectoryInfo(folder);
                        var           found = from f in excludedFolders
                                              where f.Equals(dir.Name, StringComparison.CurrentCultureIgnoreCase)
                                              select f;

                        if (found.Count() > 0)
                        {
                            log.WriteToCVS(parent, folder);
                        }
                    }
                }
                catch (Exception ex)
                {
                    log.WriteError(id);
                    log.WriteError(ex.Message);
                }
            }
        }
예제 #12
0
파일: FileManager.cs 프로젝트: Dahx/bns.spo
        public static void ProcessFileValidations(string parent, string x, MigrationSettigs d, LogCsvFile log)
        {
            log.Header = "Folder,File,Length,ErrorType,Owner";

            try
            {  //# % * : < > ? / \ |
                if (x.IndexOf("~") != -1 ||
                    x.IndexOf("#") != -1 ||
                    x.IndexOf("%") != -1 ||
                    x.IndexOf("*") != -1 ||
                    x.IndexOf("<") != -1 ||
                    x.IndexOf(">") != -1 ||
                    x.IndexOf("?") != -1 ||
                    x.IndexOf("|") != -1)
                {
                    log.WriteToCVS(parent, x, x.Length.ToString(), "Invalid Char", LogManager.GetFileOwner(x));
                }

                if (x.Length > 260)
                {
                    log.WriteToCVS(parent, x, x.Length.ToString(), "URL Length", LogManager.GetFileOwner(x));
                }
                else
                {
                    string[] parts = x.Split(new char[] { '\\' });
                    foreach (string part in parts)
                    {
                        if (part.Length > 128)
                        {
                            log.WriteToCVS(parent, x, x.Length.ToString(), "Name Length", LogManager.GetFileOwner(x));
                            break;
                        }

                        if ((part.IndexOf(".") == -1) &&
                            (part.EndsWith("_file", StringComparison.CurrentCultureIgnoreCase) ||
                             part.EndsWith("_files", StringComparison.CurrentCultureIgnoreCase) ||
                             part.EndsWith("-filer", StringComparison.CurrentCultureIgnoreCase) ||
                             part.EndsWith("_fails", StringComparison.CurrentCultureIgnoreCase)))
                        {
                            log.WriteToCVS(parent, x, x.Length.ToString(), "Invalid Name", LogManager.GetFileOwner(x));
                            break;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                log.WriteToCVS(parent, x, ex.Message, "ERROR", LogManager.GetFileOwner(x));
            }
        }
예제 #13
0
파일: FileManager.cs 프로젝트: Dahx/bns.spo
        public static void ProcessFileInfo(string parent, string x, MigrationSettigs d, LogCsvFile log)
        {
            try
            {
                string i        = "blank";
                string end_part = x.Substring(x.LastIndexOf("\\"));
                if (end_part.LastIndexOf(".") != -1)
                {
                    i = end_part.Substring(end_part.LastIndexOf("."));
                }

                if (x.Length < 260)
                {
                    FileInfo f = new FileInfo(x);
                    if (d.DoIncremental)
                    {
                        if (f.LastWriteTime < DateTime.Parse(d.LastDate))
                        {
                            log.WriteWarning("[excluded]: " + x);
                            return;
                        }
                    }
                    log.WriteToCVS(parent, x, i, f.Length.ToString(), LogManager.GetFileOwner(x), f.LastWriteTime.ToShortDateString());
                }
                else
                {
                    log.WriteWarning("[invalid_length]: " + x);
                }
            }
            catch (Exception ex)
            {
                log.WriteError("[" + x + "]:" + ex.Message);
            }
        }
예제 #14
0
        private static void NewExcelInstance(ExcelObj.Application excelApp, string parentFolderPath, string path, int operation, MigrationSettigs d, LogCsvFile log)
        {
            long count                = 0;
            long filesWithPwdCount    = 0;
            long filesConvertedCount  = 0;
            long fileAlreadyConverted = 0;
            long filesNotProcessed    = 0;

            bool     doIncremental = false;
            DateTime from_date     = DateTime.MinValue;

            try
            {
                log.WriteInfo("[processing]: " + parentFolderPath + " (" + DateTime.Now.ToString() + ")");

                var files = Directory.EnumerateFiles(path, "*.xl*", SearchOption.AllDirectories).Where(x => x.Length < 260);
                if (d.DoIncremental)
                {
                    from_date = DateTime.Parse(d.LastDate);
                }

                string status = Constants.NotProcessed;
                foreach (string x in files)
                {
                    if (x.Substring(x.LastIndexOf(".")).ToLower() == ".xls" ||
                        x.Substring(x.LastIndexOf(".")).ToLower() == ".xlt")
                    {
                        if (doIncremental)
                        {
                            FileInfo file = new FileInfo(x);
                            if (file.LastWriteTime < from_date)
                            {
                                continue;
                            }
                        }

                        count++;
                        if (operation == 0)
                        {
                            status = ConvertFile(excelApp, parentFolderPath, x, d, log);
                        }
                        else if (operation == 1)
                        {
                            status = CheckFileForPassword(excelApp, parentFolderPath, x, d, log);
                        }

                        switch (status)
                        {
                        case Constants.NotProcessed:
                            filesNotProcessed++;
                            break;

                        case Constants.Converted:
                            filesConvertedCount++;
                            break;

                        case Constants.PasswordFound:
                            filesWithPwdCount++;
                            break;

                        case Constants.AlreadyConverted:
                            fileAlreadyConverted++;
                            break;

                        default:
                            filesNotProcessed++;
                            break;
                        }
                    }
                }

                log.WriteInfo("[finished]: " + parentFolderPath + " (" + DateTime.Now.ToString() + ")");
            }
            catch (Exception ex)
            {
                log.WriteError(ex.Message);
                Console.WriteLine(ex.ToString());
            }
            finally
            {
                log.WriteInfo("[Total xls files found]: " + count.ToString());
                log.WriteInfo("[Total files converted]: " + filesConvertedCount.ToString());
                log.WriteInfo("[Total files with passwords]: " + filesWithPwdCount.ToString());
                log.WriteInfo("[Total files already converted]: " + fileAlreadyConverted.ToString());

                if (operation == 0)
                {
                    log.WriteInfo("[Total files with errors]: " + filesNotProcessed.ToString());
                }
                else
                {
                    log.WriteInfo("[Total files w/o passwords]: " + filesNotProcessed.ToString());
                }
            }
        }
예제 #15
0
        private static string ConvertFile(ExcelObj.Application excelApp, string parentFolderPath, string inputFile, MigrationSettigs d, LogCsvFile log)
        {
            var      xlsxNewFile = string.Empty;
            string   fname       = inputFile.Substring(inputFile.LastIndexOf("\\") + 1);
            string   status      = Constants.NotProcessed;
            FileInfo i           = new FileInfo(inputFile);

            ExcelObj.Workbook excelWrkBk = null;

            try
            {
                Console.WriteLine("processing: " + fname);
                if (FileHasBeenConverted(i) &&
                    string.IsNullOrEmpty(d.LastDate))
                {
                    return(Constants.AlreadyConverted);
                }

                excelWrkBk = excelApp.Workbooks.Open(
                    inputFile,
                    0,
                    Type.Missing,
                    Type.Missing,
                    "1234567890",
                    Type.Missing,
                    Type.Missing,
                    Type.Missing,
                    Type.Missing,
                    Type.Missing,
                    Type.Missing,
                    Type.Missing,
                    Type.Missing,
                    Type.Missing,
                    Type.Missing);


                ExcelObj.XlFileFormat format =
                    Microsoft.Office.Interop.Excel.XlFileFormat.xlOpenXMLWorkbook;


                if (excelWrkBk.HasVBProject)
                {
                    format      = Microsoft.Office.Interop.Excel.XlFileFormat.xlOpenXMLWorkbookMacroEnabled;
                    xlsxNewFile = inputFile.Replace(".xls", ".xlsm");
                }
                else if (i.Extension == ".xls")
                {
                    format      = Microsoft.Office.Interop.Excel.XlFileFormat.xlOpenXMLWorkbook;
                    xlsxNewFile = inputFile.Replace(".xls", ".xlsx");
                }
                else if (i.Extension == ".xlt")
                {
                    format      = Microsoft.Office.Interop.Excel.XlFileFormat.xlOpenXMLWorkbook;
                    xlsxNewFile = inputFile.Replace(".xlt", "");
                    xlsxNewFile = xlsxNewFile + "_template.xlsx";
                }

                excelWrkBk.SaveAs(xlsxNewFile,
                                  format,
                                  Type.Missing,
                                  Type.Missing,
                                  Type.Missing,
                                  Type.Missing,
                                  ExcelObj.XlSaveAsAccessMode.xlNoChange,
                                  Type.Missing,
                                  Type.Missing,
                                  Type.Missing,
                                  Type.Missing,
                                  Type.Missing);

                status = Constants.Converted;

                log.WriteToCVS(parentFolderPath, inputFile, "converted");
            }
            catch (Exception ex)
            {
                if (ex.HResult == -2146827284)
                {
                    log.WriteInfo("password protected file found...");
                    log.WriteToCVS(parentFolderPath, inputFile, "password protected");
                    status = Constants.PasswordFound;
                }
                else
                {
                    log.WriteToCVS(parentFolderPath, inputFile, "error");
                    status = Constants.NotProcessed;
                }

                log.WriteError(inputFile);
                log.WriteError(ex.Message);
            }
            finally
            {
                try
                {
                    Console.WriteLine("closing: " + fname);
                    if (excelWrkBk != null)
                    {
                        excelWrkBk.Close(false, Type.Missing, Type.Missing);
                    }
                }
                catch (Exception e)
                {
                    log.WriteError(inputFile);
                    log.WriteError(e.Message);
                }
            }

            return(status);
        }
예제 #16
0
        private static string CheckFileForPassword(ExcelObj.Application excelApp, string parentFolderPath, string inputFile, MigrationSettigs d, LogCsvFile log)
        {
            var    missing = System.Reflection.Missing.Value;
            string fname   = inputFile.Substring(inputFile.LastIndexOf("\\") + 1);
            string status  = Constants.NotProcessed;

            ExcelObj.Workbook excelWrkBk = null;

            try
            {
                //Console.WriteLine("[processing]: " + fname);
                //excelWrkBk = excelApp.Workbooks.Open(
                //    inputFile,
                //    0,
                //    true,
                //    missing,
                //    "124567890",
                //    missing,
                //    missing,
                //    missing,
                //    missing,
                //    missing,
                //    missing,
                //    missing,
                //    missing,
                //    missing,
                //    missing);


                if (OfficePasswordHelper.IsPasswordProtected(inputFile))
                {
                    Console.WriteLine("password protected file found...");
                    log.WriteToCVS(parentFolderPath, inputFile, LogManager.GetFileOwner(inputFile));
                    status = Constants.PasswordFound;
                }
                else
                {
                    status = Constants.NotProcessed;
                }
            }
            catch (Exception ex)
            {
                if (ex.HResult == -2146827284)
                {
                    Console.WriteLine("password protected file found...");
                    log.WriteToCVS(parentFolderPath, inputFile, LogManager.GetFileOwner(inputFile));
                    status = Constants.PasswordFound;
                }
                else
                {
                    log.WriteError(inputFile);
                    log.WriteError(ex.Message);
                }
            }
            finally
            {
                try
                {
                    if (excelWrkBk != null)
                    {
                        excelWrkBk.Close(false, missing, missing);
                    }
                }
                catch (Exception e)
                {
                    log.WriteError(inputFile);
                    log.WriteError(e.Message);
                }
            }

            return(status);
        }
예제 #17
0
파일: FileManager.cs 프로젝트: Dahx/bns.spo
 public static void ProcessFileChanges(string parent, string x, MigrationSettigs d, LogCsvFile log)
 {
     if (d.DoIncremental)
     {
         DateTime from_date = DateTime.Parse(d.LastDate);
         FileInfo file      = new FileInfo(x);
         if (file.LastWriteTime >= from_date)
         {
             log.WriteToCVS(parent, x, "object changed");
         }
     }
 }
예제 #18
0
파일: FileManager.cs 프로젝트: Dahx/bns.spo
        private static long DirSize(string sourceDir, bool recurse, MigrationSettigs d, LogCsvFile log)
        {
            long size = 0;

            string[] fileEntries = Directory.GetFiles(sourceDir);

            foreach (string fileName in fileEntries)
            {
                if (fileName.Length < 256)
                {
                    Interlocked.Add(ref size, (new FileInfo(fileName)).Length);
                }
                else
                {
                    log.WriteWarning("[invalid length] :" + fileName);
                }
            }

            if (recurse)
            {
                string[] subdirEntries = Directory.GetDirectories(sourceDir);

                Parallel.For <long>(0, subdirEntries.Length, () => 0, (i, loop, subtotal) =>
                {
                    if (subdirEntries[i].Length < 256)
                    {
                        if ((File.GetAttributes(subdirEntries[i]) & FileAttributes.ReparsePoint) != FileAttributes.ReparsePoint)
                        {
                            subtotal += DirSize(subdirEntries[i], true, d, log);
                            return(subtotal);
                        }
                    }
                    else
                    {
                        log.WriteWarning("[invalid length] :" + subdirEntries[i]);
                    }
                    return(0);
                },
                                    (x) => Interlocked.Add(ref size, x)
                                    );
            }
            return(size);
        }
예제 #19
0
파일: FileManager.cs 프로젝트: Dahx/bns.spo
        static void GetDirecotrySizeFromTextFileList(string textfilewithids, MigrationSettigs d, LogCsvFile log)
        {
            long count = 1;

            log.WriteInfo("[opening file]");
            string[] lines = System.IO.File.ReadAllLines(textfilewithids);
            log.WriteInfo(string.Format("[{0} records found]", lines.Length.ToString()));
            string folder = string.Empty;

            foreach (string idpair in lines)
            {
                try
                {
                    string[] values = idpair.Split(new char[] { ',' });
                    string   id     = values[0];

                    log.WriteInfo(string.Format("[processing {0}/{1}]", count.ToString(), lines.Length.ToString()));
                    folder = string.Format(d.SearchPattern, id);
                    long size = DirSize(folder, true, d, log);
                    log.WriteToCVS(folder, size.ToString());
                    log.WriteInfo("[done]");
                }

                catch (Exception ex)
                {
                    log.WriteToCVS(folder, "error");
                    log.WriteError("[" + folder + "]: " + ex.Message);
                }
                finally
                {
                    count++;
                }
            }
        }
예제 #20
0
파일: FileManager.cs 프로젝트: Dahx/bns.spo
        public static void ProcessDeleteXlsxFiles(string parent, string x, MigrationSettigs d, LogCsvFile log)
        {
            if (x.Length < 260)
            {
                FileInfo file = new FileInfo(x);
                if (file.Extension == "xlsx")
                {
                    file.Delete();
                }

                log.WriteInfo("[deleting]: " + x);
                log.WriteToCVS(parent, x, "deleted");
            }
            else
            {
                if (x.EndsWith(".xlsx"))
                {
                    File.Delete(x);
                }

                log.WriteWarning("[invalid_length]: " + x);
                log.WriteToCVS(parent, x, "invalid url");
            }
        }