// ========================================================================
// 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 VEPROMS.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 _VePromsPath = null;
        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, string vepromspath)
        {
            if (File.Exists(pathname) == false)
            {
                MessageBox.Show("Could not locate the Security Options file:\n\n" + pathname, "Security Access Error");
                optfilename = null;
                return;
            }
			_VePromsPath = vepromspath;
            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];
					if (!role.IsSavable) ErrorRpt.ErrorReport(role);
					role.Save();
                    Permission perm = Permission.New();
                    perm.MyRole = role;
                    perm.PermLevel = defaultPermData[i, 0];
                    perm.VersionType = defaultPermData[i, 1];
                    perm.PermValue = defaultPermData[i, 2];
					if (!perm.IsSavable) ErrorRpt.ErrorReport(perm);
					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: " + ex.Message);
                            }
                            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)
                        {
							if (!grp.IsSavable) ErrorRpt.ErrorReport(grp);
                            grp.Save();
                            Folder tmpfld = Folder.Get(pathInData);
                            foreach (int roleId in accessRights[folderId])
                            {
                                Role tmprole = Role.Get(roleId);
                                grp.GroupAssignments.Add(tmprole, tmpfld);
                            }
                        }
                    }
					if (!grp.IsSavable) ErrorRpt.ErrorReport(grp);
                    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, _VePromsPath);
                    Group tmpgrp = Group.Get(dicGroupIds[s]);
                    newusr.UserMemberships.Add(tmpgrp);
					if (!newusr.IsSavable) ErrorRpt.ErrorReport(newusr);
					newusr.Save();
                }

            }
        }
        #endregion
    }
#endregion
}