private void btnLoad_Click(object sender, EventArgs e)
{
OpenFileDialog fileDialog = new OpenFileDialog();
// Default to the directory which contains our content files.
string assemblyLocation = Assembly.GetExecutingAssembly().Location;
string relativePath = Path.Combine(assemblyLocation, "../../../../Content");
string contentPath = Path.GetFullPath(relativePath);
fileDialog.InitialDirectory = contentPath;
fileDialog.Title = "Load workspace";
fileDialog.Filter = "XML Files (*.xml)" +
"All Files (*.*)|*.*";
if (fileDialog.ShowDialog() == DialogResult.OK)
{
GenericParserAdapter parser = new GenericParserAdapter(fileDialog.FileName);
parser.FirstRowHasHeader = true;
parser.ColumnDelimiter = ",".ToCharArray()[0];
parser.SkipStartingDataRows = 2;
table = parser.GetDataTable();
DataTable dtCloned = table.Clone();
dtCloned.Columns["TIME_StartTime"].DataType = typeof(Int32);
foreach (DataRow row in table.Rows)
{
dtCloned.ImportRow(row);
}
table = dtCloned;
startTime = Convert.ToDouble(table.Rows[0]["TIME_StartTime"]);
}
}
private void loadQueriesToolStripMenuItem_Click(object sender, EventArgs e)
{
openFileDialog1.InitialDirectory = AppDomain.CurrentDomain.BaseDirectory;
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
try
{
GenericParserAdapter parser = new GenericParserAdapter(openFileDialog1.FileName);
parser.FirstRowHasHeader = true;
DataTable table = parser.GetDataTable();
table.TableName = Path.GetFileNameWithoutExtension(openFileDialog1.FileName);
lvwQueries.Tag = table;
foreach (DataRow row in table.Rows)
{
ListViewItem lvi = new ListViewItem(row["Query"].ToString());
lvi.SubItems.Add(row["User"].ToString());
lvi.SubItems.Add(row["Role"].ToString());
lvi.Tag = row;
lvwQueries.Items.Add(lvi);
}
splitContainerBase.Panel1Collapsed = false;
}
catch
{
MessageBox.Show("Error! This operation accepts a csv file with 3 columns 'Instance', 'Query', 'User', 'Role'. The first row expected is header.",
"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
private static void GetCityId(string connStr)
{
var parser = new GenericParserAdapter("c:\\temp\\ny.csv");
parser.FirstRowHasHeader = true;
DataTable t = parser.GetDataTable();
DataTable newT = new DataTable();
newT.Columns.Add("ZipCode");
newT.Columns.Add("CityId");
using (SqlConnection connection = new SqlConnection(connStr))
{
connection.Open();
foreach (DataRow r in t.Rows)
{
DataRow newr = newT.NewRow();
SqlCommand tCommand = new SqlCommand(string.Format("select CityId from City where Name = '{0}' and StateId = 35", r["City"]), connection);
SqlDataReader tReader = tCommand.ExecuteReader();
tReader.Read();
newr[0] = r[0];
newr[1] = tReader[0];
tReader.Close();
newT.Rows.Add(newr);
}
connection.Close();
}
newT.ToCsv("c:\\temp\\ny_zc.csv");
}
public IActionResult MetricToDimension([FromQuery] int fileId, [FromQuery] string colName, [FromQuery] int colId)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier); // will give the user's userId
CsvFile file = _context.CsvFile.Where(f => f.UserId == userId && f.CsvFileId == fileId).FirstOrDefault();
if (file == null)
{
return(NotFound());
}
string filePath = Path.Combine(_targetFilePath, Path.Combine(userId, file.FileNameStorage, file.FileNameStorage));
DataTable data = new DataTable();
using (GenericParserAdapter parser = new GenericParserAdapter())
{
parser.SetDataSource(filePath);
parser.ColumnDelimiter = ';';
parser.FirstRowHasHeader = true;
data = parser.GetDataTable();
}
if (colId > data.Columns.Count - 1)
{
return(StatusCode(500, "index of column out of bounds"));
}
CsvColumn csvColumn = new CsvColumn(file, colName, colId, _context);
csvColumn.AnalyseDimension(data.Rows);
return(Ok(new MD_Dimensao(csvColumn)));
}
/// <inheritdoc />
public Task <DataTable> ReadFromCsv(string fileName)
{
using var parser = new GenericParserAdapter(fileName)
{
FirstRowHasHeader = true
};
return(Task.FromResult(parser.GetDataTable()));
}
private DataTable FileToDataTable(GenericParserAdapter parser, char columnDelimiter)
{
parser.ColumnDelimiter = columnDelimiter;
parser.FirstRowHasHeader = true;
parser.MaxBufferSize = 4096;
parser.MaxRows = Int32.MaxValue;
parser.TextQualifier = '\"';
return(parser.GetDataTable());
}
/// <summary>
/// Creates a data
/// </summary>
/// <param name="CsvContents">A stream containing the CsvContents</param>
/// <returns></returns>
public static DataTable ParseFromCsv(string CsvContents)
{
var textReader = new StringReader(CsvContents);
using (var adapter = new GenericParserAdapter(textReader))
{
adapter.FirstRowHasHeader = true;
var table = adapter.GetDataTable();
return(table);
}
}
public static System.Data.DataTable FlatToDt(string filepath, char delimiter = ',', int maxrownumber = 0)
{
//READS FLAT FILES INTO DATATABLE
GenericParserAdapter parserAdapter = new GenericParserAdapter();
parserAdapter.ColumnDelimiter = delimiter;
parserAdapter.SkipEmptyRows = true;
parserAdapter.SetDataSource(filepath);
parserAdapter.FirstRowHasHeader = true;
parserAdapter.MaxRows = maxrownumber > 0 ? maxrownumber : 1000000;
return(parserAdapter.GetDataTable());
}
public static DataTable CsvToDataTable(this string csv)
{
DataTable table;
using (var parser = new GenericParserAdapter(new StringReader(csv)))
{
parser.FirstRowHasHeader = true;
table = parser.GetDataTable();
}
return(table);
}
private void Work(string message)
{
int fileId = int.Parse(message.Split("|")[0]);
string filePath = message.Split("|")[1];
Metadata metadata;
DataAnnotationDBContext _context;
var optionsBuilder = new DbContextOptionsBuilder <DataAnnotationDBContext>();
optionsBuilder.UseSqlServer(options.DefaultConnection);
using (_context = new DataAnnotationDBContext(optionsBuilder.Options))
{
CsvFile file = _context.CsvFile.Where(f => f.CsvFileId == fileId).FirstOrDefault();
if (file.CsvFileId == 0)
{
_logger.LogInformation("Message {0} - File not found in database", message);
return;
}
DateTime timeInit = DateTime.Now;
DataTable data = new DataTable();
using (GenericParserAdapter parser = new GenericParserAdapter())
{
parser.SetDataSource(filePath);
parser.ColumnDelimiter = ';';
parser.FirstRowHasHeader = true;
data = parser.GetDataTable();
}
file.ColumnsCount = data.Columns.Count;
file.RowsCount = data.Rows.Count;
_context.CsvFile.Update(file);
_context.SaveChanges();
CsvFileEx fileEx = new CsvFileEx(data, file, _context);
fileEx.InitIntraAnalysis();
fileEx.InitDivisoesCompare();
fileEx.CheckMetricsRelations();
metadata = new Metadata(file, fileEx, timeInit, _context);
}
var json = JsonSerializer.Serialize(metadata);
string fileFolderPath = Directory.GetParent(filePath).FullName;
string fileName = Path.GetFileName(filePath);
fileFolderPath = Path.Combine(fileFolderPath, "analysis");
Directory.CreateDirectory(fileFolderPath);
filePath = Path.Combine(fileFolderPath, "analysis_v1");
System.IO.File.WriteAllText(filePath, json);
_logger.LogInformation("Message {0} - Work Complete", message);
}
public void LoadDataFromFile(string path)
{
using (var parser = new GenericParserAdapter(path)
{
FirstRowHasHeader = true,
ColumnDelimiter = '\t',
FirstRowSetsExpectedColumnCount = true,
SkipEmptyRows = true,
})
{
Data = parser.GetDataTable();
}
}
private static async Task <DataTable> GetCSV(string filepath)
{
DataTable retval = await Task.Run(() => {
var adapter = new GenericParserAdapter(filepath)
{
FirstRowHasHeader = true
};
DataTable dt = adapter.GetDataTable();
return(dt);
});
return(retval);
}
/// <summary>
/// Gets data from csv database and saves it in a data dictionary
/// </summary>
private void InitializeData()
{
using (var parser = new GenericParserAdapter(_systemDataFilePath))
{
parser.ColumnDelimiter = ',';
parser.FirstRowHasHeader = true;
parser.SkipStartingDataRows = 0;
parser.SkipEmptyRows = true;
parser.MaxBufferSize = 4096;
parser.MaxRows = 8000;
_dictofdata = parser.GetDataTable();
}
for (int index = 0; index < _dictofdata.Rows.Count; index++)
{
var row = _dictofdata.Rows[index];
System = row["Sistema"].ToString();
License = row["Licencia"].ToString();
ExchangeRate = decimal.Parse(row["TipoCambio"].ToString());
LastCashierAmountMxn = decimal.Parse(row["CantidadPesosCaja"].ToString());
LastCashierAmountUsd = decimal.Parse(row["CantidadDolarCaja"].ToString());
LastReceiptNumber = Int32.Parse(row["UltimoReciboNumero"].ToString());
LastCorteZNumber = Int32.Parse(row["UltimoCorteZNumero"].ToString());
LastTransactionNumber = Int32.Parse(row["UltimoTransaccionNumero"].ToString());
LastInternalNumber = Int32.Parse(row["UltimoNumeroInterno"].ToString());
LastOrderNumber = Int32.Parse(row["UltimoNumeroPedido"].ToString());
PrinterName = row["NombreImpresora"].ToString();
BusinessName = row["NombreNegocio"].ToString();
FiscalStreetAddress = row["DireccionCalleFiscal"].ToString();
FiscalCityAndZipCode = row["CiudadCodigoFiscal"].ToString();
FiscalNumber = row["RFC"].ToString();
FiscalName = row["NombreFiscal"].ToString();
FiscalPhoneNumber = row["NumeroTelefono"].ToString();
FiscalEmail = row["Email"].ToString();
FiscalType = row["RazonSocial"].ToString();
Facebook = row["Facebook"].ToString();
Instagram = row["Instagram"].ToString();
Twitter = row["Twitter"].ToString();
Website = row["PaginaInternet"].ToString();
Comments = row["Comentarios"].ToString();
FooterMessage = row["MensajePie"].ToString();
LogoName = row["LogoImagen"].ToString();
EmailSender = row["EmailSaliente"].ToString();
EmailSenderPassword = row["EmailSalientePassword"].ToString();
EmailReports = row["EmailReportes"].ToString();
EmailOrders = row["EmailPedidos"].ToString();
DiscountPercent = decimal.Parse(row["DescuentoPorcentaje"].ToString());
PointsPercent = decimal.Parse(row["PuntosPorcentaje"].ToString());
}
}
/// <summary>
/// Load CSV database into a datatable object
/// </summary>
public static DataTable LoadCsvToDataTable(string csvFilePath)
{
using (var parser = new GenericParserAdapter(csvFilePath))
{
parser.ColumnDelimiter = ',';
parser.FirstRowHasHeader = true;
parser.SkipStartingDataRows = 0;
parser.SkipEmptyRows = true;
parser.MaxBufferSize = 4096;
parser.MaxRows = 8000;
return(parser.GetDataTable());
}
}
public static System.Data.DataTable LoadCSVFile(string file, char ColumnDelimiter = ',', char TextQualifier = '"', int MaxRows = 15000)
{
using (GenericParserAdapter parser = new GenericParserAdapter(file))
{
parser.SetDataSource(file);
parser.ColumnDelimiter = ColumnDelimiter;
parser.FirstRowHasHeader = true;
//parser.SkipStartingDataRows = 10;
parser.MaxBufferSize = 8096;
parser.MaxRows = MaxRows;
parser.TextQualifier = TextQualifier;
return(parser.GetDataTable());
}
}
/// <summary>
/// Load CSV database into a datatable object
/// </summary>
public void LoadCsvToDataTable()
{
using (var parser = new GenericParserAdapter(FilePath))
{
parser.ColumnDelimiter = ',';
parser.FirstRowHasHeader = true;
parser.SkipStartingDataRows = 0;
parser.SkipEmptyRows = true;
parser.MaxBufferSize = 4096;
parser.MaxRows = 8000;
DataTable = parser.GetDataTable();
}
}
public static DataTable CsvToDataTable(String filepath)
{
using (GenericParserAdapter parser = new GenericParserAdapter(filepath))
{
parser.ColumnDelimiter = ',';
parser.FirstRowHasHeader = true;
parser.TextQualifier = '\"';
DataTable dt = parser.GetDataTable();
foreach (DataColumn column in dt.Columns)
{
TranslateColumnName(column);
}
return(dt);
}
}
/// <summary>
/// Starts this instance. In derived class you have to execute this base before your overrided code.
/// </summary>
public override void Start()
{
base.Start();
try
{
using (var transaction = uow.BeginTransaction())
{
var storageService = ((Common)ParentEngineModule).StorageService;
// Get parameters
//var sourceFilePath = GetDataValue(EngineDataDirection.Input, "SourceFilePath").Get<string>();
var sourceFilePath = GetDataValue(EngineDataDirection.Input, "SourceFilePath").Get <VirtualPath>();
var skipStartingDataRows = GetDataValue(EngineDataDirection.Input, "SkipStartingDataRows").GetNullable <int>();
var firstRowHasHeader = GetDataValue(EngineDataDirection.Input, "FirstRowHasHeader").Get <bool>();
var columnDelimiter = GetDataValue(EngineDataDirection.Input, "ColumnDelimiter").Get <char>();
var limitToRows = GetDataValue(EngineDataDirection.Input, "LimitToRows").GetNullable <int>();
//Start parsing file
AddMessage("Configuring parser to read file", MessageSeverity.Debug);
var parser = new GenericParserAdapter(storageService.FileOpenTextReader(sourceFilePath));
parser.SkipStartingDataRows = skipStartingDataRows ?? 0;
parser.FirstRowHasHeader = firstRowHasHeader;
parser.ColumnDelimiter = columnDelimiter;
parser.MaxRows = limitToRows ?? 0;
var table = new TableValue();
AddMessage($"Begin parsing file: '{sourceFilePath}'.", MessageSeverity.Debug);
table.Set(parser.GetDataTable());
AddMessage($"Setting output value in element.", MessageSeverity.Debug);
SetDataValue(EngineDataDirection.Output, "Table", table);
AddMessage($"Releasing unnecessary resources.", MessageSeverity.Debug);
parser.Dispose();
AddMessage($"Parsing file completed. {table.RowCount} read.", MessageSeverity.Debug);
}
}
catch (Exception e)
{
AddMessage($"Error reading flat file. {e.Message}", MessageSeverity.Error);
}
}
/// <summary>
/// Auxiliar method for threading.
/// Parses the CSV file into an in-memory database (DataTable).
/// </summary>
void LoadDataTable()
{
parsingCompleted = false;
if (timeCtrl != null)
{
timeCtrl.ShowLoadingIcon(true);
}
Stopwatch diagnosticTime = new Stopwatch();
diagnosticTime.Start();
try
{
UnityEngine.Debug.Log("Parsing...");
vVisParser = new GenericParserAdapter(csvFilePath);
vVisParser.FirstRowHasHeader = true;
vVisDataTable.Clear();
vVisDataTable = vVisParser.GetDataTable();
UnityEngine.Debug.Log("Parsing process completed");
}
catch (System.Exception e)
{
UnityEngine.Debug.LogError("Error parsing the CSV file: " + e.Message);
}
finally
{
vVisParser.Close();
diagnosticTime.Stop();
UnityEngine.Debug.Log("Time needed to parse (s): " + diagnosticTime.Elapsed.TotalSeconds);
if (timeCtrl != null)
{
timeCtrl.ShowLoadingIcon(false);
}
parsingCompleted = true;
}
}
public IActionResult GetFirstValues([FromQuery] int fileId, [FromQuery] int colId) //gets first values of a specified column
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier); // will give the user's userId
CsvFile file = _context.CsvFile.Where(f => f.UserId == userId && f.CsvFileId == fileId).FirstOrDefault();
if (file == null)
{
return(NotFound());
}
string filePath = Path.Combine(_targetFilePath, Path.Combine(userId, file.FileNameStorage, file.FileNameStorage));
DataTable data = new DataTable();
using (GenericParserAdapter parser = new GenericParserAdapter())
{
parser.SetDataSource(filePath);
parser.ColumnDelimiter = ';';
parser.FirstRowHasHeader = true;
data = parser.GetDataTable();
}
if (colId > data.Columns.Count - 1)
{
return(StatusCode(500, "index of column out of bounds"));
}
int rowcount = data.Rows.Count;
if (rowcount > 10)
{
rowcount = 10;
}
List <string> values = new List <string>(rowcount);
foreach (DataRow row in data.Rows)
{
values.Add((string)row[colId]);
if (--rowcount == 0)
{
break;
}
}
return(Ok(values.ToArray()));
}
private void btnBrowseForDataFile_Click(object sender, EventArgs e)
{
diagOpenFile.ShowDialog();
if (!String.IsNullOrEmpty(diagOpenFile.FileName))
{
txtDataFile.Text = diagOpenFile.FileName;
using (GenericParserAdapter parser = new GenericParserAdapter(diagOpenFile.FileName))
{
parser.FirstRowHasHeader = true;
parser.Read();
sourceData = parser.GetDataTable();
}
foreach (DataColumn column in sourceData.Columns)
{
cboColumnNames.Items.Add(column.ColumnName);
}
}
}
public void Setup()
{
Rbac rbac = new Rbac();
rbac = rbac.CreateNew("books", "books description",
@"Data Source=LPT-03084856325\SQLEXPRESS;Initial Catalog=books;Integrated Security=True",
File.ReadAllText(Path.Combine(_rootDir, "Books", "entitlement.xml")));
InsertRoles(rbac);
GenericParserAdapter parser = new GenericParserAdapter(Path.Combine(_rootDir, "Books", "BooksUsers.csv"));
parser.FirstRowHasHeader = true;
DataTable table = parser.GetDataTable();
if (table.Rows.Count > 0)
{
foreach (DataRow dataRow in table.Rows)
{
RbacRole role = roles.Where(r => r.Name == dataRow["Role"].ToString()).SingleOrDefault();
if (role == null)
{
throw new Exception(dataRow["Role"].ToString() + " is not defined!");
}
RbacUser user = Rbac.CreateUser(dataRow[0].ToString(), dataRow[1].ToString(), dataRow[2].ToString(), "password", role);
if (role.Name == "role_city_mgr")
{
user.AddParameter("{CityNames}", "('New York','Charlotte')");
}
else if (role.Name == "role_state_mgr")
{
user.AddParameter("{ShortNames}", "('NY','NC')");
}
else if (role.Name == "role_country_mgr")
{
user.AddParameter("{CountryCodes}", "('IN','US')");
}
}
}
}
public static DataTable Read(string filePath, bool hasHeader = true, int skipStartingRows = 0, int skipEndingRows = 0)
{
_log.Debug(string.Format("CSVReader.Read({0}, {1}, {2}, {3})", filePath, hasHeader, skipStartingRows, skipStartingRows));
DataTable dt;
_log.Info("Attempting to parse " + filePath);
try
{
// Read in CSV to DataTable with Generic Parser library
using (GenericParserAdapter parser = new GenericParserAdapter(filePath))
{
// Parser settings
parser.SkipEmptyRows = true;
parser.TrimResults = true;
parser.FirstRowHasHeader = hasHeader;
parser.SkipStartingDataRows = skipStartingRows;
parser.SkipEndingDataRows = skipEndingRows;
_log.Debug("Skip Empty Rows : " + parser.SkipEmptyRows);
_log.Debug("Trim Results : " + parser.TrimResults);
_log.Debug("Has Header : " + parser.FirstRowHasHeader);
_log.Debug("Skip Starting Data: " + parser.SkipStartingDataRows);
_log.Debug("Skip Ending Data : " + parser.SkipEndingDataRows);
// Store CSV into DataTable
dt = parser.GetDataTable();
_log.Info("Successfully parsed " + filePath);
}
}
catch (System.IO.IOException e)
{
_log.Info("Failed to parse " + filePath);
_log.Error(e);
throw new CSVSharpException("File in use.");
}
return(dt);
}
public DataTable ToDataTable()
{
DataTable output;
var lines = _csv.Split('\n');
var columnNums = lines.AsEnumerable().Select(l => l.Split(';')).ToList();
var header = lines.First();
var columnCount = header.Split(';').Count();
Console.Out.WriteLine(header);
var wrongLines = new List <string>();
for (int i = 0; i < columnNums.Count(); i++)
{
if (columnNums[i].Count() < columnCount && lines[i].Length > 0)
{
wrongLines.Add(string.Format("{0}: line misses fields: {1}", i, lines[i]));
}
}
if (wrongLines.Any())
{
throw new Exception(wrongLines.JoinStr("\n"));
}
using (GenericParserAdapter parserAdapter = new GenericParserAdapter(new StringReader(_csv))) {
parserAdapter.ColumnDelimiter = _columnSeparator;
parserAdapter.FirstRowHasHeader = true;
parserAdapter.FirstRowSetsExpectedColumnCount = true;
parserAdapter.StripControlChars = true;
parserAdapter.SkipEmptyRows = true;
parserAdapter.TextQualifier = '\"';
parserAdapter.MaxBufferSize = 1048500;
//parserAdapter.MaxRows = 10000;
output = parserAdapter.GetDataTable();
}
return(output);
}
private ScanSummary DetectScannerSummary(string fileName)
{
ScanSummary summary = new ScanSummary();
try
{
if (System.IO.File.Exists(fileName))
{
using (GenericParserAdapter parser = new GenericParserAdapter(fileName))
{
parser.FirstRowHasHeader = true;
parser.ColumnDelimiter = DetectUsedDelimiter(fileName);
var baseTable = parser.GetDataTable();
List <object> data = new List <object>();
if (!string.IsNullOrEmpty(baseTable.Rows[0][0].ToString()) && string.IsNullOrEmpty(baseTable.Rows[0][1].ToString()))
{
// all might be pushed to first column
string[] columns = baseTable.Rows[0][0].ToString().Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
if (columns.Length < 3)
{
columns = baseTable.Rows[0][0].ToString().Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
}
foreach (string column in columns)
{
data.Add(column);
}
}
else
{
foreach (DataColumn column in baseTable.Columns)
{
data.Add(baseTable.Rows[0][column]);
}
}
// move the data into the object instance
if (int.TryParse(data[0].ToString(), out int sitecollections))
{
summary.SiteCollections = sitecollections;
}
if (int.TryParse(data[1].ToString(), out int webs))
{
summary.Webs = webs;
}
if (int.TryParse(data[2].ToString(), out int lists))
{
summary.Lists = lists;
}
if (!string.IsNullOrEmpty(data[3].ToString()))
{
summary.Duration = data[3].ToString();
}
if (!string.IsNullOrEmpty(data[4].ToString()))
{
summary.Version = data[4].ToString();
}
}
}
}
catch (Exception ex)
{
// eat all exceptions here as this is not critical
}
return(summary);
}
/// <summary>
/// Create the groupify dashboard
/// </summary>
/// <param name="exportPaths">Paths to read data from</param>
public void CreateGroupifyReport(IList <string> exportPaths)
{
DataTable readyForGroupifyTable = null;
DataTable blockersTable = null;
DataTable warningsTable = null;
DataTable modernUIWarningsTable = null;
DataTable permissionWarningsTable = null;
ScanSummary scanSummary = null;
var outputfolder = ".";
DateTime dateCreationTime = DateTime.MinValue;
if (exportPaths.Count == 1)
{
outputfolder = new DirectoryInfo(exportPaths[0]).FullName;
var pathToUse = exportPaths[0].TrimEnd(new char[] { '\\' });
dateCreationTime = File.GetCreationTime($"{pathToUse}\\{GroupifyCSV}");
}
// import the data and "clean" it
foreach (var path in exportPaths)
{
var pathToUse = path.TrimEnd(new char[] { '\\' });
string csvToLoad = $"{pathToUse}\\{GroupifyCSV}";
if (!File.Exists(csvToLoad))
{
throw new Exception($"File {csvToLoad} does not exist.");
}
Console.WriteLine($"Generating Group Connection Readiness report based upon data coming from {path}");
using (GenericParserAdapter parser = new GenericParserAdapter(csvToLoad))
{
parser.FirstRowHasHeader = true;
parser.MaxBufferSize = 200000;
parser.ColumnDelimiter = DetectUsedDelimiter(csvToLoad);
// Read the file
var baseTable = parser.GetDataTable();
// Table 1: Ready for Groupify
var readyForGroupifyTable1 = baseTable.Copy();
// clean table
string[] columnsToKeep = new string[] { "SiteUrl", "ReadyForGroupify", "GroupMode", "ModernHomePage", "WebTemplate", "MasterPage", "AlternateCSS", "UserCustomActions", "SubSites", "SubSitesWithBrokenPermissionInheritance", "ModernPageWebFeatureDisabled", "ModernPageFeatureWasEnabledBySPO", "ModernListSiteBlockingFeatureEnabled", "ModernListWebBlockingFeatureEnabled", "SitePublishingFeatureEnabled", "WebPublishingFeatureEnabled", "Everyone(ExceptExternalUsers)Claim", "UsesADGroups", "ExternalSharing" };
readyForGroupifyTable1 = DropTableColumns(readyForGroupifyTable1, columnsToKeep);
if (readyForGroupifyTable == null)
{
readyForGroupifyTable = readyForGroupifyTable1;
}
else
{
readyForGroupifyTable.Merge(readyForGroupifyTable1);
}
// Table 2: Groupify blockers
var blockersTable1 = baseTable.Copy();
// clean table
columnsToKeep = new string[] { "SiteUrl", "ReadyForGroupify", "GroupifyBlockers" };
blockersTable1 = DropTableColumns(blockersTable1, columnsToKeep);
// expand rows
blockersTable1 = ExpandRows(blockersTable1, "GroupifyBlockers");
if (blockersTable == null)
{
blockersTable = blockersTable1;
}
else
{
blockersTable.Merge(blockersTable1);
}
// Table 3: Groupify warnings
var warningsTable1 = baseTable.Copy();
// clean table
columnsToKeep = new string[] { "SiteUrl", "ReadyForGroupify", "GroupifyWarnings" };
warningsTable1 = DropTableColumns(warningsTable1, columnsToKeep);
// expand rows
warningsTable1 = ExpandRows(warningsTable1, "GroupifyWarnings");
if (warningsTable == null)
{
warningsTable = warningsTable1;
}
else
{
warningsTable.Merge(warningsTable1);
}
// Table 4: modern ui warnings
var modernUIWarningsTable1 = baseTable.Copy();
// clean table
columnsToKeep = new string[] { "SiteUrl", "ReadyForGroupify", "ModernUIWarnings" };
modernUIWarningsTable1 = DropTableColumns(modernUIWarningsTable1, columnsToKeep);
// expand rows
modernUIWarningsTable1 = ExpandRows(modernUIWarningsTable1, "ModernUIWarnings");
if (modernUIWarningsTable == null)
{
modernUIWarningsTable = modernUIWarningsTable1;
}
else
{
modernUIWarningsTable.Merge(modernUIWarningsTable1);
}
// Table 5: Groupify warnings
var permissionWarningsTable1 = baseTable.Copy();
// clean table
columnsToKeep = new string[] { "SiteUrl", "ReadyForGroupify", "PermissionWarnings" };
permissionWarningsTable1 = DropTableColumns(permissionWarningsTable1, columnsToKeep);
// expand rows
permissionWarningsTable1 = ExpandRows(permissionWarningsTable1, "PermissionWarnings");
if (permissionWarningsTable == null)
{
permissionWarningsTable = permissionWarningsTable1;
}
else
{
permissionWarningsTable.Merge(permissionWarningsTable1);
}
// Read scanner summary data
var scanSummary1 = DetectScannerSummary($"{pathToUse}\\{ScannerSummaryCSV}");
if (scanSummary == null)
{
scanSummary = scanSummary1;
}
else
{
MergeScanSummaries(scanSummary, scanSummary1);
}
}
}
// Get the template Excel file
using (Stream stream = typeof(Generator).Assembly.GetManifestResourceStream($"SharePoint.Modernization.Scanner.Reports.{GroupifyMasterFile}"))
{
if (File.Exists($"{outputfolder}\\{GroupifyMasterFile}"))
{
File.Delete($"{outputfolder}\\{GroupifyMasterFile}");
}
using (var fileStream = File.Create($"{outputfolder}\\{GroupifyMasterFile}"))
{
stream.Seek(0, SeekOrigin.Begin);
stream.CopyTo(fileStream);
}
}
// Push the data to Excel, starting from an Excel template
using (var excel = new ExcelPackage(new FileInfo($"{outputfolder}\\{GroupifyMasterFile}"), false))
{
var dashboardSheet = excel.Workbook.Worksheets["Dashboard"];
if (scanSummary != null)
{
if (scanSummary.SiteCollections.HasValue)
{
dashboardSheet.SetValue("U7", scanSummary.SiteCollections.Value);
}
if (scanSummary.Webs.HasValue)
{
dashboardSheet.SetValue("W7", scanSummary.Webs.Value);
}
if (scanSummary.Lists.HasValue)
{
dashboardSheet.SetValue("Y7", scanSummary.Lists.Value);
}
if (scanSummary.Duration != null)
{
dashboardSheet.SetValue("U8", scanSummary.Duration);
}
if (scanSummary.Version != null)
{
dashboardSheet.SetValue("U9", scanSummary.Version);
}
}
if (dateCreationTime > DateTime.Now.Subtract(new TimeSpan(5 * 365, 0, 0, 0, 0)))
{
dashboardSheet.SetValue("U6", dateCreationTime.ToString("G", DateTimeFormatInfo.InvariantInfo));
}
else
{
dashboardSheet.SetValue("U6", "-");
}
var readyForGroupifySheet = excel.Workbook.Worksheets["ReadyForGroupify"];
InsertTableData(readyForGroupifySheet.Tables[0], readyForGroupifyTable);
var blockersSheet = excel.Workbook.Worksheets["Blockers"];
InsertTableData(blockersSheet.Tables[0], blockersTable);
var warningsSheet = excel.Workbook.Worksheets["Warnings"];
InsertTableData(warningsSheet.Tables[0], warningsTable);
var modernUIWarningsSheet = excel.Workbook.Worksheets["ModernUIWarnings"];
InsertTableData(modernUIWarningsSheet.Tables[0], modernUIWarningsTable);
var permissionsWarningsSheet = excel.Workbook.Worksheets["PermissionsWarnings"];
InsertTableData(permissionsWarningsSheet.Tables[0], permissionWarningsTable);
// Save the resulting file
if (File.Exists($"{outputfolder}\\{GroupifyReport}"))
{
File.Delete($"{outputfolder}\\{GroupifyReport}");
}
excel.SaveAs(new FileInfo($"{outputfolder}\\{GroupifyReport}"));
}
// Clean the template file
if (File.Exists($"{outputfolder}\\{GroupifyMasterFile}"))
{
Task.Delay(2000).Wait();
File.Delete($"{outputfolder}\\{GroupifyMasterFile}");
}
}
/// <summary>
/// Create the list dashboard
/// </summary>
/// <param name="exportPaths">Paths to read data from</param>
public void CreateListReport(IList <string> exportPaths)
{
DataTable blockedListsTable = null;
ScanSummary scanSummary = null;
var outputfolder = ".";
DateTime dateCreationTime = DateTime.MinValue;
if (exportPaths.Count == 1)
{
outputfolder = new DirectoryInfo(exportPaths[0]).FullName;
var pathToUse = exportPaths[0].TrimEnd(new char[] { '\\' });
dateCreationTime = File.GetCreationTime($"{pathToUse}\\{ListCSV}");
}
// import the data and "clean" it
foreach (var path in exportPaths)
{
var pathToUse = path.TrimEnd(new char[] { '\\' });
string csvToLoad = $"{pathToUse}\\{ListCSV}";
if (!File.Exists(csvToLoad))
{
// Skipping as one does not always have this report
continue;
}
Console.WriteLine($"Generating Modern UI List Readiness report based upon data coming from {path}");
using (GenericParserAdapter parser = new GenericParserAdapter(csvToLoad))
{
parser.FirstRowHasHeader = true;
parser.MaxBufferSize = 200000;
parser.ColumnDelimiter = DetectUsedDelimiter(csvToLoad);
// Read the file
var baseTable = parser.GetDataTable();
// Handle "wrong" column name used in older versions
if (baseTable.Columns.Contains("Only blocked by OOB reaons"))
{
baseTable.Columns["Only blocked by OOB reaons"].ColumnName = "Only blocked by OOB reasons";
}
// Table 1
var blockedListsTable1 = baseTable.Copy();
// clean table
string[] columnsToKeep = new string[] { "Url", "Site Url", "Site Collection Url", "List Title", "Only blocked by OOB reasons", "Blocked at site level", "Blocked at web level", "Blocked at list level", "List page render type", "List experience", "Blocked by not being able to load Page", "Blocked by view type", "View type", "Blocked by list base template", "List base template", "Blocked by zero or multiple web parts", "Blocked by JSLink", "Blocked by XslLink", "Blocked by Xsl", "Blocked by JSLink field", "Blocked by business data field", "Blocked by task outcome field", "Blocked by publishingField", "Blocked by geo location field", "Blocked by list custom action" };
blockedListsTable1 = DropTableColumns(blockedListsTable1, columnsToKeep);
if (blockedListsTable == null)
{
blockedListsTable = blockedListsTable1;
}
else
{
blockedListsTable.Merge(blockedListsTable1);
}
// Read scanner summary data
var scanSummary1 = DetectScannerSummary($"{pathToUse}\\{ScannerSummaryCSV}");
if (scanSummary == null)
{
scanSummary = scanSummary1;
}
else
{
MergeScanSummaries(scanSummary, scanSummary1);
}
}
}
if (blockedListsTable.Rows.Count == 0)
{
Console.WriteLine($"No blocked lists found...skipping report generation");
return;
}
// Get the template Excel file
using (Stream stream = typeof(Generator).Assembly.GetManifestResourceStream($"SharePoint.Modernization.Scanner.Reports.{ListMasterFile}"))
{
if (File.Exists($"{outputfolder}\\{ListMasterFile}"))
{
File.Delete($"{outputfolder}\\{ListMasterFile}");
}
using (var fileStream = File.Create($"{outputfolder}\\{ListMasterFile}"))
{
stream.Seek(0, SeekOrigin.Begin);
stream.CopyTo(fileStream);
}
}
// Push the data to Excel, starting from an Excel template
using (var excel = new ExcelPackage(new FileInfo($"{outputfolder}\\{ListMasterFile}"), false))
//using (var excel = new ExcelPackage())
{
var dashboardSheet = excel.Workbook.Worksheets["Dashboard"];
if (scanSummary != null)
{
if (scanSummary.SiteCollections.HasValue)
{
dashboardSheet.SetValue("AA7", scanSummary.SiteCollections.Value);
}
if (scanSummary.Webs.HasValue)
{
dashboardSheet.SetValue("AC7", scanSummary.Webs.Value);
}
if (scanSummary.Lists.HasValue)
{
dashboardSheet.SetValue("AE7", scanSummary.Lists.Value);
}
if (scanSummary.Duration != null)
{
dashboardSheet.SetValue("AA8", scanSummary.Duration);
}
if (scanSummary.Version != null)
{
dashboardSheet.SetValue("AA9", scanSummary.Version);
}
}
if (dateCreationTime != DateTime.MinValue)
{
dashboardSheet.SetValue("AA6", dateCreationTime.ToString("G", DateTimeFormatInfo.InvariantInfo));
}
else
{
dashboardSheet.SetValue("AA6", "-");
}
var blockedListsSheet = excel.Workbook.Worksheets["BlockedLists"];
//var blockedListsSheet = excel.Workbook.Worksheets.Add("BlockedLists");
InsertTableData(blockedListsSheet.Tables[0], blockedListsTable);
//blockedListsSheet.Cells["A1"].LoadFromDataTable(blockedListsTable, true);
// Save the resulting file $"{outputfolder}\\{ListMasterFile}"
if (File.Exists($"{outputfolder}\\{ListReport}"))
{
File.Delete($"{outputfolder}\\{ListReport}");
}
excel.SaveAs(new FileInfo($"{outputfolder}\\{ListReport}"));
//excel.SaveAs(new FileInfo(ListMasterFile));
}
// Clean the template file
if (File.Exists($"{outputfolder}\\{ListMasterFile}"))
{
Task.Delay(2000).Wait();
File.Delete($"{outputfolder}\\{ListMasterFile}");
}
}
/// <summary>
/// Create the site page dashboard
/// </summary>
/// <param name="exportPaths">Paths to read data from</param>
public void CreatePageReport(IList <string> exportPaths)
{
DataTable readyForPageTransformationTable = null;
DataTable unmappedWebPartsTable = null;
ScanSummary scanSummary = null;
var outputfolder = ".";
DateTime dateCreationTime = DateTime.MinValue;
if (exportPaths.Count == 1)
{
outputfolder = new DirectoryInfo(exportPaths[0]).FullName;
var pathToUse = exportPaths[0].TrimEnd(new char[] { '\\' });
dateCreationTime = File.GetCreationTime($"{pathToUse}\\{PageCSV}");
}
// import the data and "clean" it
foreach (var path in exportPaths)
{
var pathToUse = path.TrimEnd(new char[] { '\\' });
string csvToLoad = $"{pathToUse}\\{PageCSV}";
if (!File.Exists(csvToLoad))
{
// Skipping as one does not always have this report
continue;
}
Console.WriteLine($"Generating Page Transformation Readiness report based upon data coming from {path}");
using (GenericParserAdapter parser = new GenericParserAdapter(csvToLoad))
{
parser.FirstRowHasHeader = true;
parser.MaxBufferSize = 200000;
parser.ColumnDelimiter = DetectUsedDelimiter(csvToLoad);
// Read the file
var baseTable = parser.GetDataTable();
// Table 1
var readyForPageTransformationTable1 = baseTable.Copy();
// clean table
string[] columnsToKeep = new string[] { "SiteUrl", "PageUrl", "HomePage", "Type", "Layout", "Mapping %" };
readyForPageTransformationTable1 = DropTableColumns(readyForPageTransformationTable1, columnsToKeep);
if (readyForPageTransformationTable == null)
{
readyForPageTransformationTable = readyForPageTransformationTable1;
}
else
{
readyForPageTransformationTable.Merge(readyForPageTransformationTable1);
}
// Table 2
var unmappedWebPartsTable1 = baseTable.Copy();
// clean table
columnsToKeep = new string[] { "SiteUrl", "PageUrl", "Unmapped web parts" };
unmappedWebPartsTable1 = DropTableColumns(unmappedWebPartsTable1, columnsToKeep);
// expand rows
unmappedWebPartsTable1 = ExpandRows(unmappedWebPartsTable1, "Unmapped web parts");
// delete "unneeded" rows
for (int i = unmappedWebPartsTable1.Rows.Count - 1; i >= 0; i--)
{
DataRow dr = unmappedWebPartsTable1.Rows[i];
if (string.IsNullOrEmpty(dr["Unmapped web parts"].ToString()))
{
dr.Delete();
}
}
if (unmappedWebPartsTable == null)
{
unmappedWebPartsTable = unmappedWebPartsTable1;
}
else
{
unmappedWebPartsTable.Merge(unmappedWebPartsTable1);
}
// Read scanner summary data
var scanSummary1 = DetectScannerSummary($"{pathToUse}\\{ScannerSummaryCSV}");
if (scanSummary == null)
{
scanSummary = scanSummary1;
}
else
{
MergeScanSummaries(scanSummary, scanSummary1);
}
}
}
// Get the template Excel file
using (Stream stream = typeof(Generator).Assembly.GetManifestResourceStream($"SharePoint.Modernization.Scanner.Reports.{PageMasterFile}"))
{
if (File.Exists($"{outputfolder}\\{PageMasterFile}"))
{
File.Delete($"{outputfolder}\\{PageMasterFile}");
}
using (var fileStream = File.Create($"{outputfolder}\\{PageMasterFile}"))
{
stream.Seek(0, SeekOrigin.Begin);
stream.CopyTo(fileStream);
}
}
// Push the data to Excel, starting from an Excel template
//using (var excel = new ExcelPackage(new FileInfo(PageMasterFile)))
using (var excel = new ExcelPackage(new FileInfo($"{outputfolder}\\{PageMasterFile}"), false))
{
var dashboardSheet = excel.Workbook.Worksheets["Dashboard"];
if (scanSummary != null)
{
if (scanSummary.SiteCollections.HasValue)
{
dashboardSheet.SetValue("X7", scanSummary.SiteCollections.Value);
}
if (scanSummary.Webs.HasValue)
{
dashboardSheet.SetValue("Z7", scanSummary.Webs.Value);
}
if (scanSummary.Lists.HasValue)
{
dashboardSheet.SetValue("AB7", scanSummary.Lists.Value);
}
if (scanSummary.Duration != null)
{
dashboardSheet.SetValue("X8", scanSummary.Duration);
}
if (scanSummary.Version != null)
{
dashboardSheet.SetValue("X9", scanSummary.Version);
}
}
if (dateCreationTime > DateTime.Now.Subtract(new TimeSpan(5 * 365, 0, 0, 0, 0)))
{
dashboardSheet.SetValue("X6", dateCreationTime.ToString("G", DateTimeFormatInfo.InvariantInfo));
}
else
{
dashboardSheet.SetValue("X6", "-");
}
//var readyForPageTransformationSheet = excel.Workbook.Worksheets.Add("ReadyForPageTransformation");
//var insertedRange = readyForPageTransformationSheet.Cells["A1"].LoadFromDataTable(readyForPageTransformationTable, true);
//var unmappedWebPartsSheet = excel.Workbook.Worksheets.Add("UnmappedWebParts");
//insertedRange = unmappedWebPartsSheet.Cells["A1"].LoadFromDataTable(unmappedWebPartsTable, true);
var readyForPageTransformationSheet = excel.Workbook.Worksheets["ReadyForPageTransformation"];
InsertTableData(readyForPageTransformationSheet.Tables[0], readyForPageTransformationTable);
var unmappedWebPartsSheet = excel.Workbook.Worksheets["UnmappedWebParts"];
InsertTableData(unmappedWebPartsSheet.Tables[0], unmappedWebPartsTable);
// Save the resulting file
if (File.Exists($"{outputfolder}\\{PageReport}"))
{
File.Delete($"{outputfolder}\\{PageReport}");
}
excel.SaveAs(new FileInfo($"{outputfolder}\\{PageReport}"));
}
// Clean the template file
if (File.Exists($"{outputfolder}\\{PageMasterFile}"))
{
Task.Delay(2000).Wait();
File.Delete($"{outputfolder}\\{PageMasterFile}");
}
}
/// <summary>
/// Create the publishing dashboard
/// </summary>
/// <param name="exportPaths">Paths to read data from</param>
public void CreatePublishingReport(IList <string> exportPaths)
{
DataTable pubWebsBaseTable = null;
DataTable pubPagesBaseTable = null;
DataTable pubWebsTable = null;
DataTable pubPagesTable = null;
ScanSummary scanSummary = null;
var outputfolder = ".";
DateTime dateCreationTime = DateTime.MinValue;
if (exportPaths.Count == 1)
{
outputfolder = new DirectoryInfo(exportPaths[0]).FullName;
var pathToUse = exportPaths[0].TrimEnd(new char[] { '\\' });
dateCreationTime = File.GetCreationTime($"{pathToUse}\\{PublishingWebCSV}");
}
// import the data and "clean" it
foreach (var path in exportPaths)
{
var pathToUse = path.TrimEnd(new char[] { '\\' });
// Load the webs CSV file
string csvToLoad = $"{pathToUse}\\{PublishingWebCSV}";
if (!File.Exists(csvToLoad))
{
// Skipping as one does not always have this report
continue;
}
Console.WriteLine($"Generating Publishing transformation report based upon data coming from {path}");
using (GenericParserAdapter parser = new GenericParserAdapter(csvToLoad))
{
parser.FirstRowHasHeader = true;
parser.MaxBufferSize = 200000;
parser.ColumnDelimiter = DetectUsedDelimiter(csvToLoad);
// Read the file
pubWebsBaseTable = parser.GetDataTable();
var pubWebsTable1 = pubWebsBaseTable.Copy();
// clean table
string[] columnsToKeep = new string[] { "SiteCollectionUrl", "SiteUrl", "WebRelativeUrl", "SiteCollectionComplexity", "WebTemplate", "Level", "PageCount", "Language", "VariationLabels", "VariationSourceLabel", "SiteMasterPage", "SystemMasterPage", "AlternateCSS", "HasIncompatibleUserCustomActions", "AllowedPageLayouts", "PageLayoutsConfiguration", "DefaultPageLayout", "GlobalNavigationType", "GlobalStructuralNavigationShowSubSites", "GlobalStructuralNavigationShowPages", "GlobalStructuralNavigationShowSiblings", "GlobalStructuralNavigationMaxCount", "GlobalManagedNavigationTermSetId", "CurrentNavigationType", "CurrentStructuralNavigationShowSubSites", "CurrentStructuralNavigationShowPages", "CurrentStructuralNavigationShowSiblings", "CurrentStructuralNavigationMaxCount", "CurrentManagedNavigationTermSetId", "ManagedNavigationAddNewPages", "ManagedNavigationCreateFriendlyUrls", "LibraryItemScheduling", "LibraryEnableModeration", "LibraryEnableVersioning", "LibraryEnableMinorVersions", "LibraryApprovalWorkflowDefined", "BrokenPermissionInheritance" };
pubWebsTable1 = DropTableColumns(pubWebsTable1, columnsToKeep);
if (pubWebsTable == null)
{
pubWebsTable = pubWebsTable1;
}
else
{
pubWebsTable.Merge(pubWebsTable1);
}
// Read scanner summary data
var scanSummary1 = DetectScannerSummary($"{pathToUse}\\{ScannerSummaryCSV}");
if (scanSummary == null)
{
scanSummary = scanSummary1;
}
else
{
MergeScanSummaries(scanSummary, scanSummary1);
}
}
// Load the site CSV file to count the site collection rows
csvToLoad = $"{pathToUse}\\{PublishingSiteCSV}";
if (File.Exists(csvToLoad))
{
using (GenericParserAdapter parser = new GenericParserAdapter(csvToLoad))
{
parser.FirstRowHasHeader = true;
parser.MaxBufferSize = 200000;
parser.ColumnDelimiter = DetectUsedDelimiter(csvToLoad);
var siteData = parser.GetDataTable();
if (siteData != null)
{
scanSummary.SiteCollections = siteData.Rows.Count;
}
}
}
// Load the pages CSV file, if available
csvToLoad = $"{pathToUse}\\{PublishingPageCSV}";
if (File.Exists(csvToLoad))
{
using (GenericParserAdapter parser = new GenericParserAdapter(csvToLoad))
{
parser.FirstRowHasHeader = true;
parser.MaxBufferSize = 200000;
parser.ColumnDelimiter = DetectUsedDelimiter(csvToLoad);
// Read the file
pubPagesBaseTable = parser.GetDataTable();
var pubPagesTable1 = pubPagesBaseTable.Copy();
// clean table
string[] columnsToKeep = new string[] { "SiteCollectionUrl", "SiteUrl", "WebRelativeUrl", "PageRelativeUrl", "PageName", "ContentType", "ContentTypeId", "PageLayout", "PageLayoutFile", "PageLayoutWasCustomized", "GlobalAudiences", "SecurityGroupAudiences", "SharePointGroupAudiences", "ModifiedAt", "Mapping %" };
pubPagesTable1 = DropTableColumns(pubPagesTable1, columnsToKeep);
if (pubPagesTable == null)
{
pubPagesTable = pubPagesTable1;
}
else
{
pubPagesTable.Merge(pubPagesTable1);
}
}
}
// Get the template Excel file
using (Stream stream = typeof(Generator).Assembly.GetManifestResourceStream($"SharePoint.Modernization.Scanner.Reports.{PublishingMasterFile}"))
{
if (File.Exists($"{outputfolder}\\{PublishingMasterFile}"))
{
File.Delete($"{outputfolder}\\{PublishingMasterFile}");
}
using (var fileStream = File.Create($"{outputfolder}\\{PublishingMasterFile}"))
{
stream.Seek(0, SeekOrigin.Begin);
stream.CopyTo(fileStream);
}
}
// Push the data to Excel, starting from an Excel template
using (var excel = new ExcelPackage(new FileInfo($"{outputfolder}\\{PublishingMasterFile}"), false))
{
var dashboardSheet = excel.Workbook.Worksheets["Dashboard"];
if (scanSummary != null)
{
if (scanSummary.SiteCollections.HasValue)
{
dashboardSheet.SetValue("U7", scanSummary.SiteCollections.Value);
}
if (scanSummary.Duration != null)
{
dashboardSheet.SetValue("U8", scanSummary.Duration);
}
if (scanSummary.Version != null)
{
dashboardSheet.SetValue("U9", scanSummary.Version);
}
}
if (dateCreationTime > DateTime.Now.Subtract(new TimeSpan(5 * 365, 0, 0, 0, 0)))
{
dashboardSheet.SetValue("U6", dateCreationTime.ToString("G", DateTimeFormatInfo.InvariantInfo));
}
else
{
dashboardSheet.SetValue("U6", "-");
}
var pubWebsSheet = excel.Workbook.Worksheets["PubWebs"];
InsertTableData(pubWebsSheet.Tables[0], pubWebsTable);
var pubPagesSheet = excel.Workbook.Worksheets["PubPages"];
if (pubPagesTable != null)
{
InsertTableData(pubPagesSheet.Tables[0], pubPagesTable);
}
// Save the resulting file
if (File.Exists($"{outputfolder}\\{PublishingReport}"))
{
File.Delete($"{outputfolder}\\{PublishingReport}");
}
excel.SaveAs(new FileInfo($"{outputfolder}\\{PublishingReport}"));
}
// Clean the template file
if (File.Exists($"{outputfolder}\\{PublishingMasterFile}"))
{
Task.Delay(2000).Wait();
File.Delete($"{outputfolder}\\{PublishingMasterFile}");
}
}
}
public void Setup(Options options)
{
if (string.IsNullOrEmpty(options.ConnectionString))
{
WriteErrorLine("Connection string is required. Please use -x <connection string>");
return;
}
Rbac rbac = new Rbac();
rbac = rbac.CreateNew("books", "books description",
options.ConnectionString,
File.ReadAllText(Path.Combine(_rootDir, "Books", "entitlement.xml")));
Console.Write(".");
InsertRoles(rbac);
GenericParserAdapter parser = new GenericParserAdapter(Path.Combine(_rootDir, "Books", "BooksUsers.csv"));
parser.FirstRowHasHeader = true;
DataTable table = parser.GetDataTable();
if (table.Rows.Count > 0)
{
foreach (DataRow dataRow in table.Rows)
{
RbacRole role = roles.Where(r => r.Name == dataRow["Role"].ToString()).SingleOrDefault();
if (role == null)
{
throw new Exception(dataRow["Role"].ToString() + " is not defined!");
}
RbacUser user = Rbac.CreateUser(dataRow[0].ToString(), dataRow[1].ToString(), dataRow[2].ToString(), "password", role);
if (role.Name == "role_city_mgr")
{
user.AddParameter("{CityNames}", "('New York','Charlotte')");
}
else if (role.Name == "role_state_mgr")
{
user.AddParameter("{ShortNames}", "('NY','NC')");
}
else if (role.Name == "role_country_mgr")
{
user.AddParameter("{CountryCodes}", "('IN','US')");
}
if (role.Name == "role_guest_user")
{
user.AddParameter("{CityNames}", "('New York')");
}
Console.Write(".");
}
}
Console.WriteLine();
var rbacs = Rbac.GetRbacs();
if (rbacs != null)
{
WriteColor(ConsoleColor.Green, rbacs.Count + " rbac instance(s) created." + Environment.NewLine);
}
else
{
WriteErrorLine("rbac creation failed!");
}
var vroles = Rbac.GetRoles();
if (vroles != null)
{
WriteColor(ConsoleColor.Green, vroles.Count + " role(s) created." + Environment.NewLine);
}
else
{
WriteErrorLine("role(s) creation failed!");
}
var users = Rbac.GetUsers();
if (users != null)
{
WriteColor(ConsoleColor.Green, users.Count + " user(s) created." + Environment.NewLine);
}
else
{
WriteErrorLine("user(s) creation failed!");
}
}
