This commit is contained in:
913
PROMS/DataLoader/SecObj.cs
Normal file
913
PROMS/DataLoader/SecObj.cs
Normal file
@@ -0,0 +1,913 @@
|
||||
// ========================================================================
|
||||
// Copyright 2006 - Volian Enterprises, Inc. All rights reserved.
|
||||
// Volian Enterprises - Proprietary Information - DO NOT COPY OR DISTRIBUTE
|
||||
// ------------------------------------------------------------------------
|
||||
// $Workfile: $ $Revision: $
|
||||
// $Author: $ $Date: $
|
||||
//
|
||||
// $History: $
|
||||
// ========================================================================
|
||||
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.Collections.Specialized;
|
||||
using System.Windows.Forms;
|
||||
using System.Text;
|
||||
using Volian.CSLA.Library;
|
||||
using Config;
|
||||
|
||||
namespace DataLoader
|
||||
{
|
||||
/// <summary>
|
||||
/// Summary description for Security.
|
||||
/// </summary>
|
||||
///
|
||||
#region OldVeSamClasses
|
||||
// do a temp plant - we may keep this for loading in data. It will be migrated
|
||||
// to a folders record.
|
||||
#region Options
|
||||
public class PlantOptions
|
||||
{
|
||||
private UInt16 _id;
|
||||
private UInt32 _plopts;
|
||||
public List<ProcOptions> poList = new List<ProcOptions>();
|
||||
|
||||
public UInt16 Id
|
||||
{
|
||||
get {return _id;}
|
||||
set {if (_id != value) _id = value;}
|
||||
}
|
||||
|
||||
public UInt32 Options
|
||||
{
|
||||
get {return _plopts;}
|
||||
set {if (_plopts != value) _plopts = value;}
|
||||
}
|
||||
}
|
||||
public class ProcOptions
|
||||
{
|
||||
private UInt16 _id;
|
||||
private UInt16 _selected;
|
||||
public UInt32 [] Options = new UInt32[4];
|
||||
|
||||
public UInt16 Id
|
||||
{
|
||||
get {return _id;}
|
||||
set {if (_id != value)_id = value;}
|
||||
}
|
||||
public UInt16 Selected
|
||||
{
|
||||
get {return _selected;}
|
||||
set {if (_selected != value)_selected = value;}
|
||||
}
|
||||
}
|
||||
#endregion
|
||||
#region OldFolders
|
||||
public class Plant
|
||||
{
|
||||
private string _name;
|
||||
private string _path;
|
||||
private UInt16 _id;
|
||||
public Dictionary<ushort, ProcSet> psDic = new Dictionary<ushort,ProcSet>();
|
||||
|
||||
public string Name
|
||||
{
|
||||
get {return _name;}
|
||||
set
|
||||
{
|
||||
if (value == null) value = string.Empty;
|
||||
if (_name != value) _name = value;
|
||||
}
|
||||
}
|
||||
public string Path
|
||||
{
|
||||
get {return _path;}
|
||||
set
|
||||
{
|
||||
if (value == null) value = string.Empty;
|
||||
if (_path != value)_path = value;
|
||||
}
|
||||
}
|
||||
public UInt16 Id
|
||||
{
|
||||
get {return _id;}
|
||||
set {if (_id != value) _id = value;}
|
||||
}
|
||||
|
||||
public Plant() { }
|
||||
public Plant(string nm, string pth, UInt16 idn)
|
||||
{
|
||||
_name = nm;
|
||||
_path = pth;
|
||||
_id = idn;
|
||||
}
|
||||
}
|
||||
|
||||
public class ProcSet
|
||||
{
|
||||
private string _name;
|
||||
private string _path;
|
||||
private UInt16 _id;
|
||||
public string Name
|
||||
{
|
||||
get {return _name;}
|
||||
set
|
||||
{
|
||||
if (value == null) value = string.Empty;
|
||||
if (_name != value)_name = value;
|
||||
}
|
||||
}
|
||||
public string Path
|
||||
{
|
||||
get {return _path;}
|
||||
set
|
||||
{
|
||||
if (value == null) value = string.Empty;
|
||||
if (_path != value)_path = value;
|
||||
}
|
||||
}
|
||||
public UInt16 Id
|
||||
{
|
||||
get {return _id;}
|
||||
set {if (_id != value) _id = value;}
|
||||
}
|
||||
public ProcSet() { }
|
||||
|
||||
public ProcSet(string nm, string pth, UInt16 idn)
|
||||
{
|
||||
_name = nm;
|
||||
_path = pth;
|
||||
_id = idn;
|
||||
}
|
||||
}
|
||||
#endregion
|
||||
#region OldUser
|
||||
// The OldUser class stores data from the vesam input. The User class migrates
|
||||
// and saves data to the new sql database.
|
||||
public class OldUser
|
||||
{
|
||||
private UInt32 _systemopts;
|
||||
private string _username;
|
||||
private bool _blockaccessflag = false;
|
||||
public List<PlantOptions> PlantOpts = new List<PlantOptions>();
|
||||
|
||||
public UInt32 SystemOpts
|
||||
{
|
||||
get { return _systemopts; }
|
||||
set { if (_systemopts != value) _systemopts = value; }
|
||||
}
|
||||
public string UserName
|
||||
{
|
||||
get { return _username; }
|
||||
set
|
||||
{
|
||||
if (value == null) value = string.Empty;
|
||||
if (_username != value) _username = value;
|
||||
}
|
||||
}
|
||||
|
||||
public bool BlockAccessFlag
|
||||
{
|
||||
get { return _blockaccessflag; }
|
||||
set { if (_blockaccessflag != value) _blockaccessflag = value; }
|
||||
}
|
||||
|
||||
public bool PermissionToManageFlag
|
||||
{
|
||||
get { return (_systemopts & VESamOpt.DOCMAINT)==0?false:true; }
|
||||
//set { if (_permissiontomanageflag != value) _permissiontomanageflag = value; }
|
||||
}
|
||||
|
||||
public bool SystemAdminFlag
|
||||
{
|
||||
get { return (_systemopts & VESamOpt.SYSADMIN)==0 ? false:true; }
|
||||
//set { if (_systemadminflag != value) _systemadminflag = value; }
|
||||
}
|
||||
|
||||
public bool PermissionToLockFlag
|
||||
{
|
||||
get { return (_systemopts & VESamOpt.LOCKSYSTEM)==0 ? false:true; }
|
||||
//set { if (_permissiontolockflag != value) _permissiontolockflag = value; }
|
||||
}
|
||||
|
||||
public bool RoEditorFlag
|
||||
{
|
||||
get { return (_systemopts & VESamOpt.ROEDITOR) == 0 ? false : true; }
|
||||
}
|
||||
|
||||
public OldUser(string nm)
|
||||
{
|
||||
_username = nm;
|
||||
}
|
||||
}
|
||||
#endregion
|
||||
#region VESam
|
||||
public class VESamOpt
|
||||
{
|
||||
#region Log4Net
|
||||
private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
||||
#endregion
|
||||
public const long VIEW = 0x00000001L;
|
||||
public const long PRINT = 0x00000002L;
|
||||
public const long PRINTDRAFT = 0x00000004L;
|
||||
public const long PRINTCHANGES = 0x00000008L;
|
||||
public const long EDIT = 0x00000010L;
|
||||
public const long SEARCH = 0x00000020L;
|
||||
public const long STANDARDSTEPS = 0x00000040L;
|
||||
public const long APPROVE = 0x00000080L;
|
||||
public const long APPROVESINGLE = 0x00000100L;
|
||||
public const long LIBRARYDOCS = 0x00000200L;
|
||||
public const long ADDMODDEL = 0x00000400L;
|
||||
public const long CLEAN = 0x00000800L;
|
||||
public const long LOCKPROC = 0x00001000L;
|
||||
public const long LOCKSET = 0x00000001L;
|
||||
public const long UCF = 0x00000002L;
|
||||
public const long LOCKSYSTEM = 0x00000001L;
|
||||
public const long DOCMAINT = 0x00000002L;
|
||||
public const long ROEDITOR = 0x00000004L;
|
||||
public const long SYSADMIN = 0x00000008L;
|
||||
|
||||
public const int SUPERUSER = 1000;
|
||||
public const long SUPERACCESS = 0xFFFFFFFFL;
|
||||
|
||||
private bool _blockAccess;
|
||||
public int userid = -1;
|
||||
public string initials;
|
||||
private const string samoptname = "vesam.opt";
|
||||
public FileStream fs;
|
||||
public BinaryReader bw;
|
||||
public bool isDemoMode = false;
|
||||
List<Plant> plntList = new List<Plant>();
|
||||
List<OldUser> userList = new List<OldUser>();
|
||||
Dictionary<ushort, Plant> plntDic = new Dictionary<ushort, Plant>();
|
||||
|
||||
public bool BlockAccess
|
||||
{
|
||||
get { return _blockAccess; }
|
||||
set { if (_blockAccess != value) _blockAccess = value; }
|
||||
}
|
||||
|
||||
public bool OpenFile(string oname)
|
||||
{
|
||||
try
|
||||
{
|
||||
fs = new FileStream(oname, FileMode.Open, FileAccess.Read, FileShare.Read, 1, false);
|
||||
bw = new BinaryReader(fs);
|
||||
return true;
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
MessageBox.Show(e.Message, "Security File");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public void CloseFile()
|
||||
{
|
||||
bw.Close();
|
||||
fs.Close();
|
||||
bw = null;
|
||||
fs = null;
|
||||
}
|
||||
public Dictionary<ushort, Plant> LoadPlants()
|
||||
{
|
||||
UInt16 ui16;
|
||||
UInt32 ui32;
|
||||
|
||||
try
|
||||
{
|
||||
byte x;
|
||||
|
||||
// read past some header stuff.
|
||||
for (int jj = 0; jj < 8; jj++) x = bw.ReadByte();
|
||||
|
||||
long nxtPl = bw.ReadUInt32();
|
||||
uint nmPlant = bw.ReadUInt16();
|
||||
ui16 = bw.ReadUInt16();
|
||||
|
||||
// not needed here, but need to read past this...
|
||||
long nxtUs = bw.ReadUInt32();
|
||||
uint nmUser = bw.ReadUInt16();
|
||||
ui16 = bw.ReadUInt16();
|
||||
long nxtGr = bw.ReadUInt32();
|
||||
uint nmGrp = bw.ReadUInt16();
|
||||
ui16 = bw.ReadUInt16();
|
||||
|
||||
BlockAccess = bw.ReadUInt16()==0?false:true;
|
||||
|
||||
string pname, ppth;
|
||||
for (int i = 0; i < nmPlant; i++)
|
||||
{
|
||||
if (nxtPl == 0xFFFFFFFEL)
|
||||
{
|
||||
log.Error("Reading in VESAM options file - cannot find next plant in list");
|
||||
break;
|
||||
}
|
||||
fs.Seek(nxtPl, SeekOrigin.Begin);
|
||||
nxtPl = bw.ReadUInt32();
|
||||
|
||||
Plant pl = new Plant();
|
||||
pl.Id = bw.ReadUInt16();
|
||||
ui16 = bw.ReadUInt16();
|
||||
|
||||
byte[] stmp = new byte[256];
|
||||
stmp = bw.ReadBytes(ui16);
|
||||
pname = Encoding.ASCII.GetString(stmp, 0, ui16);
|
||||
pl.Name = pname;
|
||||
ui16 = bw.ReadUInt16();
|
||||
stmp = bw.ReadBytes(ui16);
|
||||
ppth = Encoding.ASCII.GetString(stmp, 0, ui16);
|
||||
pl.Path = ppth;
|
||||
|
||||
// read in any sets within this plant.
|
||||
UInt16 nmPrcDr = bw.ReadUInt16();
|
||||
ui32 = bw.ReadUInt32();
|
||||
UInt32 nxtPr = bw.ReadUInt32();
|
||||
|
||||
for (int j = 0; j < nmPrcDr; j++)
|
||||
{
|
||||
ProcSet ps = new ProcSet();
|
||||
ps.Id = bw.ReadUInt16();
|
||||
ui16 = bw.ReadUInt16();
|
||||
stmp = bw.ReadBytes(ui16);
|
||||
pname = Encoding.ASCII.GetString(stmp, 0, ui16);
|
||||
ps.Name = pname;
|
||||
ui16 = bw.ReadUInt16();
|
||||
stmp = bw.ReadBytes(ui16);
|
||||
ppth = Encoding.ASCII.GetString(stmp, 0, ui16);
|
||||
ps.Path = ppth;
|
||||
ui32 = bw.ReadUInt32();
|
||||
if (nxtPr == 0xFFFFFFFDL && j + 1 < nmPrcDr)
|
||||
{
|
||||
log.ErrorFormat("Loading vesam.opt - procedure sets for {0}", ps.Name);
|
||||
return null;
|
||||
}
|
||||
try
|
||||
{
|
||||
pl.psDic.Add(ps.Id, ps);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log.ErrorFormat("Adding to set dictionary - {0}. Error: {1}" + ps.Path, ex.Message);
|
||||
}
|
||||
if (nxtPr != 0xFFFFFFFDL)
|
||||
{
|
||||
fs.Seek(nxtPr, SeekOrigin.Begin);
|
||||
nxtPr = bw.ReadUInt32();
|
||||
}
|
||||
}
|
||||
try
|
||||
{
|
||||
if (!plntDic.ContainsKey(pl.Id))plntDic.Add(pl.Id, pl);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log.ErrorFormat("Adding to plant dictionary - {0}. Error: {1}", pl.Path, ex.Message);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log.ErrorFormat("Loading plants from vesam.opt: {0}", ex.Message);
|
||||
return null;
|
||||
}
|
||||
return plntDic;
|
||||
}
|
||||
public List<OldUser> LoadUserList()
|
||||
{
|
||||
UInt16 ui16;
|
||||
UInt32 ui32;
|
||||
try
|
||||
{
|
||||
byte x;
|
||||
|
||||
fs.Seek(0, SeekOrigin.Begin);
|
||||
// read past some header stuff.
|
||||
for (int jj = 0; jj < 8; jj++) x = bw.ReadByte();
|
||||
long nxtPl = bw.ReadUInt32();
|
||||
uint nmPlant = bw.ReadUInt16();
|
||||
ui16 = bw.ReadUInt16();
|
||||
|
||||
// get info in header for users
|
||||
long nxtUs = bw.ReadUInt32();
|
||||
uint nmUser = bw.ReadUInt16();
|
||||
ui16 = bw.ReadUInt16();
|
||||
long nxtGr = bw.ReadUInt32();
|
||||
uint nmGrp = bw.ReadUInt16();
|
||||
ui16 = bw.ReadUInt16();
|
||||
|
||||
bool localblockAccess = bw.ReadUInt16()==0?false:true;
|
||||
// Now read in all of the user information
|
||||
UInt16 uid;
|
||||
string fName, fPass;
|
||||
for (int i = 0; i < nmUser; i++)
|
||||
{
|
||||
if (nxtUs == 0xFFFFFFFCL && i + 1 < nmUser)
|
||||
{
|
||||
log.Error("Loading vesam.opt - reading in user list.");
|
||||
return null;
|
||||
}
|
||||
|
||||
fs.Seek((long)nxtUs, SeekOrigin.Begin);
|
||||
nxtUs = bw.ReadUInt32();
|
||||
uid = bw.ReadUInt16();
|
||||
ui16 = bw.ReadUInt16(); // user's group?
|
||||
|
||||
byte[] test = new byte[10];
|
||||
test = bw.ReadBytes(10);
|
||||
|
||||
// get ve-proms (vesam) username & password
|
||||
fName = Encoding.ASCII.GetString(test, 0, 10);
|
||||
int indx = fName.IndexOf("\0");
|
||||
string fNameTrim = fName.Substring(0, indx);
|
||||
test = bw.ReadBytes(10);
|
||||
fPass = Encoding.ASCII.GetString(test, 0, 10);
|
||||
indx = fPass.IndexOf("\0");
|
||||
string fPassTrim = fPass.Substring(0, indx);
|
||||
OldUser usr = new OldUser(fNameTrim);
|
||||
usr.SystemOpts = bw.ReadUInt32();
|
||||
usr.BlockAccessFlag = localblockAccess;
|
||||
ui32 = bw.ReadUInt32();
|
||||
|
||||
// now get plant & proc set options.
|
||||
nmPlant = bw.ReadUInt16();
|
||||
for (int j = 0; j < nmPlant; j++)
|
||||
{
|
||||
PlantOptions plO = new PlantOptions();
|
||||
plO.Id = bw.ReadUInt16();
|
||||
plO.Options = bw.ReadUInt32();
|
||||
ui32 = bw.ReadUInt32();
|
||||
UInt16 nmPrcDr = bw.ReadUInt16();
|
||||
for (int k = 0; k < nmPrcDr; k++)
|
||||
{
|
||||
ProcOptions prO = new ProcOptions();
|
||||
prO.Id = bw.ReadUInt16();
|
||||
prO.Selected = bw.ReadUInt16();
|
||||
for (int kk = 0; kk < 4; kk++) prO.Options[kk] = bw.ReadUInt32();
|
||||
plO.poList.Add(prO);
|
||||
}
|
||||
usr.PlantOpts.Add(plO);
|
||||
}
|
||||
userList.Add(usr);
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log.ErrorFormat("Error Loading (old) User info from vesam.opt: {0}", ex.Message);
|
||||
return null ;
|
||||
}
|
||||
return userList;
|
||||
}
|
||||
}
|
||||
#endregion
|
||||
#endregion
|
||||
|
||||
#region SecurityMigration
|
||||
public class Security
|
||||
{
|
||||
#region Log4Net
|
||||
private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
||||
#endregion
|
||||
Dictionary<ushort, Plant> plntDic = new Dictionary<ushort, Plant>();
|
||||
List<OldUser> userList = new List<OldUser>();
|
||||
private string optfilename;
|
||||
private string[] prflags ={ "Vfw", "Prnt", "Prnt Drft", "Prnt Chgs", "Edit", "Srch", "St Stp", "App", "App Sel", "Lib", "AMD", "Clean", "Lock" };
|
||||
private string[] sysflags ={ "NetworkLock", "SysMaint", "ROEditor", "SysAdmin" };
|
||||
#region NewMig
|
||||
public Security(string pathname)
|
||||
{
|
||||
if (File.Exists(pathname) == false)
|
||||
{
|
||||
MessageBox.Show("Could not locate the Security Options file:\n\n" + pathname, "Security Access Error");
|
||||
optfilename = null;
|
||||
return;
|
||||
}
|
||||
optfilename = pathname;
|
||||
}
|
||||
public bool Migrate()
|
||||
{
|
||||
VESamOpt vso = new VESamOpt();
|
||||
bool suc = vso.OpenFile(optfilename);
|
||||
if (!suc) return false;
|
||||
plntDic = vso.LoadPlants();
|
||||
if (plntDic == null) return false;
|
||||
suc = VerifyFolders(plntDic);
|
||||
if (!suc) return suc;
|
||||
userList = vso.LoadUserList();
|
||||
if (userList == null) return false;
|
||||
vso.CloseFile();
|
||||
vso = null;
|
||||
log.Info("Original vesam.opt loaded successfully - next step is to migrate security information to new database");
|
||||
//WriteOutSummary(plntDic, userList);
|
||||
suc = TranslateToNew(vso, plntDic, userList);
|
||||
log.Info("Migrated vesam successfully");
|
||||
return suc ;
|
||||
}
|
||||
#endregion
|
||||
#region WriteVESamSummary
|
||||
private void WriteOutSummary(Dictionary<ushort, Plant> plntDic, List<OldUser> userList)
|
||||
{
|
||||
foreach (OldUser usr in userList)
|
||||
{
|
||||
log.InfoFormat("User = {0}", usr.UserName);
|
||||
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
if ((usr.SystemOpts & (1L << i)) != 0) sb.Append(sysflags[i] + " ");
|
||||
}
|
||||
if (sb.Length > 0) log.InfoFormat(" System Options = {0}", sb.ToString());
|
||||
|
||||
// for now, don't worry about system options.
|
||||
// for each plant, list any permissions of the plant or its proc sets. If
|
||||
// none set, nothing will be listed.
|
||||
foreach (PlantOptions po in usr.PlantOpts)
|
||||
{
|
||||
bool plntout = false;
|
||||
Plant pl = (Plant)plntDic[po.Id];
|
||||
if (po.Options != 0)
|
||||
{
|
||||
plntout = true;
|
||||
log.InfoFormat(" Plant = {0}. Options = {1}", pl.Name, po.Options);
|
||||
}
|
||||
foreach (ProcOptions psO in po.poList)
|
||||
{
|
||||
ProcSet ps = (ProcSet)pl.psDic[psO.Id];
|
||||
if (psO.Options[0] != 0 || psO.Options[1] != 0 || psO.Options[2] != 0 || psO.Options[3] != 0)
|
||||
{
|
||||
if (!plntout) log.InfoFormat(" Plant = {0}.", pl.Name);
|
||||
log.InfoFormat(" Procedure Set = {0}", ps.Name);
|
||||
sb.Length = 0;
|
||||
int nm = 0;
|
||||
for (int i1 = 0; i1 < 4; i1++)
|
||||
{
|
||||
for (int j1 = 0; j1 < 16; j1++)
|
||||
{
|
||||
if ((psO.Options[i1] & (1L << j1)) != 0) sb.Append(prflags[nm] + " ");
|
||||
nm++;
|
||||
}
|
||||
}
|
||||
if (sb.Length > 0) log.InfoFormat(" {0}", sb.ToString());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
#endregion
|
||||
#region MigrateCode
|
||||
private string[] defaultRole ={ "Administrator", "User Administrator", "RO Manager", "Writer", "Reviewer", "Guest" };
|
||||
private string[] defaultRoleTitle = { "Manages Data - Backups, Approval etc.", "Maintains User Security", "Maintains Referenced Objects", "Can Edit", "Can potentially add comments", "Read-Only access to approved procedures" };
|
||||
// defaultPermData sets the permission data (Permissions table) - columns are
|
||||
// PermLevel, VersionType, PermValue (Note for vesam migration, PermAD is always allow, i.e. 0)
|
||||
private int[,] defaultPermData = {
|
||||
{2, 3, 15}, // Administrator
|
||||
{1, 3, 15}, // User Administrator
|
||||
{3, 3, 15}, // RO Manager
|
||||
{5, 1, 15}, // Writer
|
||||
{7, 3, 15}, // Reviewer
|
||||
{2, 2, 1}}; // Guest
|
||||
|
||||
private int[] accessLevelSetup = { -1, 5, 4, 3, 0, 0, 2, 1 };
|
||||
private int[] accessLevelTrans;
|
||||
|
||||
private Dictionary<int, Role> AddDefaultRoles()
|
||||
{
|
||||
Dictionary<int, Role> rdic = new Dictionary<int, Role>();
|
||||
try
|
||||
{
|
||||
accessLevelTrans = new int[accessLevelSetup.Length];
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
Role role = Role.New();
|
||||
role.Name = defaultRole[i];
|
||||
role.Title = defaultRoleTitle[i];
|
||||
role.Save();
|
||||
Permission perm = Permission.New();
|
||||
perm.RID = role.RID;
|
||||
perm.PermLevel = defaultPermData[i, 0];
|
||||
perm.VersionType = defaultPermData[i, 1];
|
||||
perm.PermValue = defaultPermData[i, 2];
|
||||
perm.Save();
|
||||
rdic.Add(role.RID, role);
|
||||
for (int j = 1; j < accessLevelSetup.Length; j++)
|
||||
{
|
||||
if (accessLevelSetup[j] == i) accessLevelTrans[j] = role.RID;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log.ErrorFormat("Error setting default roles & permissions: {0}", ex.Message);
|
||||
return null;
|
||||
}
|
||||
return rdic;
|
||||
}
|
||||
|
||||
public bool VerifyFolders(Dictionary<ushort, Plant> dicPlants)
|
||||
{
|
||||
try
|
||||
{
|
||||
// For each folder from vesam, see if there is a matching folder already
|
||||
// migrated...
|
||||
|
||||
FolderInfoList fil = FolderInfoList.Get();
|
||||
// add the titles to a dictionary for quick checking
|
||||
List<string> folderlist = new List<string>();
|
||||
foreach (FolderInfo fi in fil)
|
||||
{
|
||||
folderlist.Add(fi.Title.ToUpper());
|
||||
}
|
||||
|
||||
foreach (ushort u in dicPlants.Keys)
|
||||
{
|
||||
Plant pl = dicPlants[u];
|
||||
bool foundplant = false;
|
||||
if (folderlist.Contains(pl.Path.ToUpper())) foundplant=true;
|
||||
|
||||
if (!foundplant)
|
||||
log.InfoFormat("Plant from vesam.opt not found in folder data: {0}", pl.Path);
|
||||
else // if found, check for sets
|
||||
{
|
||||
foreach (ushort uu in pl.psDic.Keys)
|
||||
{
|
||||
ProcSet pr = pl.psDic[uu];
|
||||
bool foundprocset = false;
|
||||
foreach (FolderInfo fi in fil)
|
||||
{
|
||||
string tstpath = pl.Path.ToUpper() + "\\" + pr.Path.ToUpper();
|
||||
if (tstpath == fi.Title.ToUpper())
|
||||
{
|
||||
foundprocset = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!foundprocset) log.InfoFormat("Procedure Set from vesam.opt not found in folder data: {0}\\{1}", pl.Path, pr.Path);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
log.ErrorFormat("error mapping vesam directories to data directories, error = {0}", ex.Message);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
private Dictionary<string, int> LoadFolders()
|
||||
{
|
||||
FolderInfoList fldlist = FolderInfoList.Get();
|
||||
Dictionary<string, int> fdic = new Dictionary<string, int>();
|
||||
foreach (FolderInfo fi in fldlist)
|
||||
{
|
||||
fdic.Add(fi.Title.ToUpper(), fi.FolderID);
|
||||
}
|
||||
return fdic;
|
||||
}
|
||||
|
||||
private bool TranslateToNew(VESamOpt vso, Dictionary<ushort, Plant> plntDic, List<OldUser> userList)
|
||||
{
|
||||
Dictionary<int, Role> rlpdic = AddDefaultRoles();
|
||||
AddUsrGrpAsgnRecs(plntDic, userList);
|
||||
return true;
|
||||
}
|
||||
private string VersionName(string s)
|
||||
{
|
||||
return s.Substring(s.LastIndexOf(" - ") + 3);
|
||||
}
|
||||
private string SetName(string s)
|
||||
{
|
||||
return s.Substring(0, s.LastIndexOf(" - "));
|
||||
}
|
||||
private string FixName(string s)
|
||||
{
|
||||
s = s.Replace(" - Working Draft (Unit 1)", " (Unit 1) - Working Draft");
|
||||
s = s.Replace(" - Working Draft (Unit 2)", " (Unit 2) - Working Draft");
|
||||
s = s.Replace(" - Current Approved Version", " - Approved Version");
|
||||
return s.Replace(" - Working Draft", " - Working Draft");
|
||||
}
|
||||
private int CalcAccessLevel(int iBase, uint options, string sVersion)
|
||||
{
|
||||
if (sVersion == "Working Draft")
|
||||
{
|
||||
if (options == 0) return 0;
|
||||
if ((options & 6528) != 0) return 5;
|
||||
if ((options & 1024) != 0) return 4;
|
||||
if ((options & 528) != 0) return 3;
|
||||
return 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (iBase != 0) return iBase;
|
||||
else if (options != 0) return 1;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
private string SystemOption(uint options)
|
||||
{
|
||||
if ((options & 11) != 0) return "\"Admin\"";
|
||||
if (options == 4) return "\"RO\"";
|
||||
return "";
|
||||
}
|
||||
private void AddAccessRights(Dictionary<int, List<int>> dic, int folderId, int roleId)
|
||||
{
|
||||
if (!dic.ContainsKey(folderId)) dic[folderId] = new List<int>();
|
||||
dic[folderId].Add(roleId);
|
||||
}
|
||||
private void AddUsrGrpAsgnRecs(Dictionary<ushort, Plant> plntDic, List<OldUser> userList)
|
||||
{
|
||||
Dictionary<string, List<string>> dicGroups = new Dictionary<string, List<string>>();
|
||||
Dictionary<string, int> dicGroupIds = new Dictionary<string, int>();
|
||||
Dictionary<string, int> dicOldFolders = new Dictionary<string, int>();
|
||||
int oldFolderCount = 1;
|
||||
dicOldFolders.Add("system", oldFolderCount++);
|
||||
Dictionary<string, int> dicNewFolders = LoadFolders();
|
||||
List<string> lstVersions = new List<string>();
|
||||
StringBuilder sb;
|
||||
OldUser frst = userList[0];
|
||||
|
||||
string[] accessLevel = { "", "\"Guest\"", "\"Reviewer\"", "\"Writer\"", "\"Admin\"", "\"Admin\"" };
|
||||
foreach (OldUser usr in userList)
|
||||
{
|
||||
int sysAccess = 5;
|
||||
Dictionary<PlantOptions, int> plantAccess = new Dictionary<PlantOptions, int>();
|
||||
|
||||
if ((usr.SystemOpts & 11) == 0)
|
||||
{
|
||||
foreach (PlantOptions po in usr.PlantOpts)
|
||||
{
|
||||
plantAccess[po] = 5;
|
||||
Plant pl = (Plant)plntDic[po.Id];
|
||||
if (!dicOldFolders.ContainsKey(pl.Path.ToUpper()))dicOldFolders.Add(pl.Path.ToUpper(), oldFolderCount++);
|
||||
string sSetLast = "";
|
||||
int iAccessLevel = 0;
|
||||
|
||||
foreach (ProcOptions psO in po.poList)
|
||||
{
|
||||
ProcSet ps = null;
|
||||
try
|
||||
{
|
||||
ps = (ProcSet)pl.psDic[psO.Id];
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
MessageBox.Show("here");
|
||||
}
|
||||
if (!dicOldFolders.ContainsKey(pl.Path.ToUpper()+"\\"+ps.Path.ToUpper()))dicOldFolders.Add(pl.Path.ToUpper()+"\\"+ps.Path.ToUpper(), oldFolderCount++);
|
||||
string sName = FixName(ps.Name);
|
||||
string sVersion = VersionName(sName);
|
||||
string sSet = SetName(sName);
|
||||
if (sSet != sSetLast)
|
||||
{
|
||||
if (sSetLast != "")
|
||||
{
|
||||
// if the proc access is lower than the plant, reset plant level.
|
||||
if (iAccessLevel < plantAccess[po]) plantAccess[po] = iAccessLevel;
|
||||
iAccessLevel = 0;
|
||||
}
|
||||
sSetLast = sSet;
|
||||
}
|
||||
iAccessLevel = CalcAccessLevel(iAccessLevel, psO.Options[0], sVersion);
|
||||
}
|
||||
// do one last check to see if plant level should be lowered. Also
|
||||
// check if the system level should be lowered.
|
||||
if (iAccessLevel < plantAccess[po]) plantAccess[po] = iAccessLevel;
|
||||
if (plantAccess[po] < sysAccess) sysAccess = plantAccess[po];
|
||||
}
|
||||
}
|
||||
|
||||
// set the system level access, i.e. User Admin, System Admin & RO Editor roles if
|
||||
// necessary.
|
||||
int systemid = dicOldFolders["system"];
|
||||
|
||||
Dictionary<int, List<int>> accessRights = new Dictionary<int, List<int>>();
|
||||
if (usr.SystemOpts != 0) AddAccessRights(accessRights, systemid, accessLevelTrans[6]); // add ro editor
|
||||
if ((usr.SystemOpts & 11) != 0)
|
||||
{
|
||||
AddAccessRights(accessRights, systemid, accessLevelTrans[5]); // add sys admin rights
|
||||
AddAccessRights(accessRights, systemid, accessLevelTrans[7]); // and add user admin rights
|
||||
}
|
||||
else
|
||||
{
|
||||
// the user has a role at the system level that is not an admin,
|
||||
// such as reviewer or guest - add it in.
|
||||
if (sysAccess > 0) AddAccessRights(accessRights, systemid, accessLevelTrans[sysAccess]);
|
||||
}
|
||||
|
||||
sb = new StringBuilder(string.Format("{0},{1}", (usr.SystemOpts == 0 ? "" : "Admin"), accessLevel[sysAccess]));
|
||||
|
||||
if ((usr.SystemOpts & 11) == 0)
|
||||
{
|
||||
foreach (PlantOptions po in usr.PlantOpts)
|
||||
{
|
||||
Plant pl = plntDic[po.Id];
|
||||
// Need logic for po.Options in combination with PlantAccess[po]
|
||||
//sb.Append(string.Format(",{0}", po.Options));
|
||||
|
||||
if (plantAccess[po] > sysAccess)
|
||||
{
|
||||
AddAccessRights(accessRights, dicOldFolders[pl.Path.ToUpper()], accessLevelTrans[plantAccess[po]]);
|
||||
sb.Append(string.Format(",{0}", accessLevel[plantAccess[po]]));
|
||||
}
|
||||
else
|
||||
sb.Append(",");
|
||||
string sSetLast = "";
|
||||
string sPathLast = "";
|
||||
int iAccessLevel = 0;
|
||||
string sPath = "";
|
||||
foreach (ProcOptions psO in po.poList)
|
||||
{
|
||||
ProcSet ps = pl.psDic[psO.Id];
|
||||
string sName = FixName(ps.Name);
|
||||
string sVersion = VersionName(sName);
|
||||
if (sVersion == "Working Draft") sPath = pl.Path + "\\" + ps.Path;
|
||||
string sSet = SetName(sName);
|
||||
|
||||
if (sSet != sSetLast)
|
||||
{
|
||||
if (sSetLast != "")
|
||||
{
|
||||
if (iAccessLevel > plantAccess[po])
|
||||
{
|
||||
AddAccessRights(accessRights, dicOldFolders[sPathLast.ToUpper()], accessLevelTrans[iAccessLevel]);
|
||||
sb.Append(string.Format(",{0}", accessLevel[iAccessLevel]));
|
||||
}
|
||||
else
|
||||
sb.Append(",");
|
||||
iAccessLevel = 0;
|
||||
}
|
||||
sSetLast = sSet;
|
||||
sPathLast = sPath;
|
||||
}
|
||||
iAccessLevel = CalcAccessLevel(iAccessLevel, psO.Options[0], sVersion);
|
||||
}
|
||||
|
||||
if (iAccessLevel > plantAccess[po])
|
||||
{
|
||||
AddAccessRights(accessRights, dicOldFolders[sPathLast.ToUpper()], accessLevelTrans[iAccessLevel]);
|
||||
sb.Append(string.Format(",{0}", accessLevel[iAccessLevel]));
|
||||
}
|
||||
else
|
||||
sb.Append(",");
|
||||
}
|
||||
}
|
||||
string s = sb.ToString();
|
||||
|
||||
if (!dicGroups.ContainsKey(s))
|
||||
{
|
||||
dicGroups[s] = new List<string>();
|
||||
Group grp = Group.New();
|
||||
grp.GroupName = "Group " + dicGroups.Count.ToString();
|
||||
int pathInData = -1;
|
||||
foreach (int folderId in accessRights.Keys)
|
||||
{
|
||||
// see if this folderId exists in the data (rather
|
||||
// than the list from vesam). If not, don't do an
|
||||
// assignments record
|
||||
pathInData = 0;
|
||||
foreach (KeyValuePair<string, int> kvp in dicOldFolders)
|
||||
{
|
||||
if (kvp.Value == folderId)
|
||||
{
|
||||
string path = kvp.Key;
|
||||
if (dicNewFolders.ContainsKey(path.ToUpper()))
|
||||
pathInData = dicNewFolders[path.ToUpper()];
|
||||
}
|
||||
}
|
||||
if (pathInData>0)
|
||||
{
|
||||
foreach (int roleId in accessRights[folderId])
|
||||
{
|
||||
grp.GroupAssignments.Add(roleId, pathInData);
|
||||
}
|
||||
}
|
||||
}
|
||||
grp.Save();
|
||||
dicGroupIds[s] = grp.GID;
|
||||
}
|
||||
dicGroups[s].Add(usr.UserName);
|
||||
}
|
||||
|
||||
foreach (string s in dicGroups.Keys)
|
||||
{
|
||||
foreach (string sUser in dicGroups[s])
|
||||
{
|
||||
// add user record & membership record.
|
||||
User newusr = User.New();
|
||||
newusr.UserID = sUser;
|
||||
ConfigFile cfg = new ConfigFile();
|
||||
cfg.LoadUsrCfg(newusr);
|
||||
newusr.UserMemberships.Add(dicGroupIds[s]);
|
||||
newusr.Save();
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
#endregion
|
||||
}
|
||||
#endregion
|
||||
}
|
||||
Reference in New Issue
Block a user