private static string compareConnectionStrings(ref XmlDocument doc, DTO.RolloutInfo rollout)
        {
            var    connNode   = doc.SelectSingleNode("//ConnectionInfo");
            string connString = "";

            if (connNode != null && !string.IsNullOrEmpty(rollout.Connection.ConnectionString) && rollout.Connection.DateSet != null)
            {
                try
                {
                    string   currentString     = connNode.Attributes.GetNamedItem("ConnectionString").Value;
                    DateTime currentStringDate = DateTime.Parse(connNode.Attributes.GetNamedItem("ConnectionDateSet").Value);
                    if (DateTime.Compare(currentStringDate, rollout.Connection.DateSet.Value) < 0 || String.IsNullOrEmpty(currentString))
                    {
                        connString = connNode.Attributes.GetNamedItem("ConnectionString").Value = rollout.Connection.ConnectionString;
                        connNode.Attributes.GetNamedItem("ConnectionDateSet").Value = rollout.Connection.DateSet.ToString();
                    }
                    else
                    {
                        connString = currentString;
                    }
                }
                catch (Exception)
                {
                    connString = connNode.Attributes.GetNamedItem("ConnectionString").Value = rollout.Connection.ConnectionString;
                    connNode.Attributes.GetNamedItem("ConnectionDateSet").Value = rollout.Connection.DateSet.ToString();
                }
            }
            else
            {
                connString = "";
            }
            return(connString);
        }
示例#2
0
        private void reconstructBackEndFromRolloutsFolder(object sender, DoWorkEventArgs e)
        {
            //1. Create back end xml file to be updated.
            CreateXmlFile.CreateBackEndXmlFileInRolloutDirectory();
            var directory          = new DirectoryInfo(this.RollOutDirectory + "Rollouts\\");
            var fileCount          = directory.EnumerateFiles("FE-*.zip").Count();
            int progressPercentage = Convert.ToInt32(((double)1 / (fileCount + 1)) * 100);

            (sender as BackgroundWorker).ReportProgress(progressPercentage, e.Argument);
            int progress = 1;

            //2. Loop through the zipped files in the rollouts folder
            foreach (var file in directory.EnumerateFiles("FE-*.zip"))
            {
                //For each file, read the file into a ZipArchive object
                ZipArchive zipfile = ZipFile.OpenRead(file.FullName);
                //Find the only .xml file in the zip file and extract it to the reconstruction path.
                zipfile.Entries.FirstOrDefault(p => p.Name.Contains(".xml")).ExtractToFile(this.ReconstructionPath, true);
                //Release the object reference in memory to the zip file.
                zipfile.Dispose();
                //Create a rolloutInfo file (which is plain object with only properties and not methods) out of
                //the newly extracted xml file.
                DTO.RolloutInfo rollout = GetDataFromXml.GetReconstructedInfo(this.ReconstructionPath);
                //Add a rollout record with the info in the rollout record.
                UpdateXmlFile.AddRolloutRecord(rollout);
                progressPercentage = Convert.ToInt32(((double)++progress / fileCount) * 100);
                (sender as BackgroundWorker).ReportProgress(progressPercentage, "Reconstructed " + file.Name);
            }
        }
示例#3
0
        private static void addLatestRolloutToCache(ObjectCache cache, DTO.Enums.UserTypeEnum userType, DTO.Enums.BackEndOrFrontEndEnum whichEnd)
        {
            CacheItemPolicy policy = new CacheItemPolicy()
            {
                SlidingExpiration = TimeSpan.FromSeconds(10)
            };
            var rollout = new DTO.RolloutInfo();

            rollout.UserType = userType;
            var    doc            = GetXmlDoc.GetBackEndXmlDoc(DTO.Enums.BackEndOrFrontEndEnum.FrontEnd);
            string currentVersion = doc.SelectSingleNode("//CurrentVersions").Attributes.GetNamedItem(rollout.UserTypeName).Value;

            rollout.Connection.ConnectionString = GetData.GetCurrentConnectionString(whichEnd);
            rollout.Connection.DateSet          = DateTime.Parse(doc.SelectSingleNode("//ConnectionInfo").Attributes.GetNamedItem("ConnectionDateSet").Value);
            rollout.DateTimeStamp = rollout.Connection.DateSet.Value;
            XmlNode rolloutNode = doc.SelectSingleNode("//Version[@value='" + currentVersion + "']/" + Enum.GetName(typeof(DTO.Enums.UserTypeEnum), userType));

            try
            {
                string launchFile = rolloutNode.Attributes.GetNamedItem("LaunchFile").Value;
                rollout.LaunchFile = launchFile;
                string zipPath = rolloutNode.Attributes.GetNamedItem("FullZipPath").Value;
                rollout.ZipPath = zipPath;
            }
            catch (NullReferenceException)
            {
                throw new DTO.Exceptions.CouldNotFindValueException();
            }
            rollout.RolloutVersionString = currentVersion;

            cache.Set("LatestRollout", rollout, policy);
        }
 public static bool CompareUserInfo(DTO.User user)
 {
     try
     {
         DTO.RolloutInfo currentRollout = GetDataFromXml.GetFrontEndSettings();
         if (user.UserType != currentRollout.UserType)
         {
             return(true);
         }
         if (currentRollout.RolloutVersionNumber !=
             GetDataFromXml.GetCurrentRolloutVersionNumber(DTO.Enums.BackEndOrFrontEndEnum.FrontEnd, user.UserType))
         {
             return(true);
         }
     }
     catch (DTO.Exceptions.CouldNotFindValueException)
     {
         throw;
     }
     //This exception is raised when the front end has yet to be set up (i.e. first launch after install).
     catch (DTO.Exceptions.FrontEndNeedsUpdateException)
     {
         return(true);
     }
     return(false);
 }
        //This is an important method for the FrontEnd. A DTO.RolloutInfo object is passed in and then this will
        //update the frontend.xml file for the user with that info.
        public static void UpdateFrontEndXml(DTO.RolloutInfo rollout)
        {
            var doc = GetXmlDoc.GetFrontEndXmlDoc();

            doc.SelectSingleNode("//LaunchFile").InnerText      = rollout.LaunchFile;
            doc.SelectSingleNode("//CurrentUserType").InnerText = rollout.UserTypeName;
            doc.SelectSingleNode("//CurrentVersion").InnerText  = rollout.RolloutVersionString;
            doc.SelectSingleNode("//CurrentZipPath").InnerText  = rollout.ZipPath;
            SaveXmlDoc.saveFrontEndDoc(doc);
        }
        //This will set the necessary rollout node attributes with the neccesary info from the RolloutInfo object
        //Passed into it.
        private static XmlNode setRolloutAttributes(XmlDocument doc, XmlNode node, DTO.RolloutInfo rollout)
        {
            XmlAttribute datestamp = doc.CreateAttribute("DateTimeStamp");

            datestamp.Value = rollout.DateTimeStamp.ToString();
            XmlAttribute zipPath = doc.CreateAttribute("FullZipPath");

            zipPath.Value = rollout.ZipPath;
            XmlAttribute launch = doc.CreateAttribute("LaunchFile");

            launch.Value = rollout.LaunchFile;
            node.Attributes.Append(launch);
            node.Attributes.Append(datestamp);
            node.Attributes.Append(zipPath);
            return(node);
        }
        //This is a main function in the Back End tool. It takes a RolloutInfo object and with that info,
        //it creates a new rollout record.
        public static void AddRolloutRecord(DTO.RolloutInfo rollout)
        {
            var doc = GetXmlDoc.GetBackEndXmlDoc(DTO.Enums.BackEndOrFrontEndEnum.BackEnd);
            //Compare current connection string and date and resolve for latest string
            string  latestConnectionString = compareConnectionStrings(ref doc, rollout);
            XmlNode versionNode            = doc.SelectSingleNode("//Version[@value='" + rollout.RolloutVersionString + "']");

            //Check to see if a node for the current version exists
            if (versionNode != null)
            {
                //If a node for the current version exists, then check if a rollout node exists for the specified userType
                XmlNode rolloutNode = versionNode.SelectSingleNode("./" + rollout.UserTypeName);
                if (rolloutNode != null)
                {
                    //If a rollout node exists for the userType, then modify the values with the most up-to-date info.
                    rolloutNode = setRolloutAttributes(doc, rolloutNode, rollout);
                }
                else
                {
                    //If a rollout node does NOT exist for the userType, then create one.
                    versionNode.AppendChild(createRolloutNode(doc, rollout));
                }
            }
            //If a version node for the current version number does NOT exist, then create one with attributes set
            else
            {
                XmlNode    rolloutsNode   = doc.SelectSingleNode("//BackEnd/RollOuts");
                XmlElement newVersionNode = doc.CreateElement("Version");
                newVersionNode.SetAttribute("value", rollout.RolloutVersionString);
                newVersionNode.AppendChild(createRolloutNode(doc, rollout));
                rolloutsNode.AppendChild(newVersionNode);
            }
            //Compare current version number with highest listed version number. If current is less than highest, update current.
            ensureHighestVersionNumber(doc, rollout.UserTypeName);
            ensureLatestRolloutDate(doc, rollout.DateTimeStamp);
            //Create backup rollout document within zip folder
            XmlNode newRolloutNode = doc.SelectSingleNode("//Version[@value='" + rollout.RolloutVersionString + "']").SelectSingleNode("./" + rollout.UserTypeName);

            CreateXmlDoc.createBackupRolloutDocument(newRolloutNode, rollout.RolloutVersionNumber, latestConnectionString);
            SaveXmlDoc.saveBackEndDoc(doc);
        }
示例#8
0
        internal static DTO.RolloutInfo PullLatestRolloutFromCache(DTO.Enums.UserTypeEnum userType, DTO.Enums.BackEndOrFrontEndEnum whichEnd)
        {
            ObjectCache cache = MemoryCache.Default;

TryAgain:
            DTO.RolloutInfo rollout = cache["LatestRollout"] as DTO.RolloutInfo;
            try
            {
                if (rollout == null)
                {
                    addLatestRolloutToCache(cache, userType, whichEnd);
                    goto TryAgain;
                }
            }
            catch (Exception)
            {
                throw;
            }

            return(rollout);
        }
示例#9
0
        private void reconstructBackEndFromRolloutsFolder()
        {
            //1. Create back end xml file to be updated.
            CreateXmlFile.CreateBackEndXmlFileInRolloutDirectory();
            var directory = new DirectoryInfo(this.RollOutDirectory + "Rollouts\\");

            //2. Loop through the zipped files in the rollouts folder
            foreach (var file in directory.EnumerateFiles("FE-*.zip"))
            {
                //For each file, read the file into a ZipArchive object
                ZipArchive zipfile = ZipFile.OpenRead(file.FullName);
                //Find the only .xml file in the zip file and extract it to the reconstruction path.
                zipfile.Entries.FirstOrDefault(p => p.Name.Contains(".xml")).ExtractToFile(this.ReconstructionPath, true);
                //Release the object reference in memory to the zip file.
                zipfile.Dispose();
                //Create a rolloutInfo file (which is plain object with only properties and not methods) out of
                //the newly extracted xml file.
                DTO.RolloutInfo rollout = GetDataFromXml.GetReconstructedInfo(this.ReconstructionPath);
                //Add a rollout record with the info in the rollout record.
                UpdateXmlFile.AddRolloutRecord(rollout);
            }
        }
示例#10
0
        //This creates and returns a rollout node after setting rollout attributes.
        private static XmlNode createRolloutNode(XmlDocument doc, DTO.RolloutInfo rollout)
        {
            XmlElement newNode = doc.CreateElement(rollout.UserTypeName);

            return(setRolloutAttributes(doc, newNode, rollout));
        }
示例#11
0
 private static void updateFrontEndXML(DTO.Enums.UserTypeEnum userType)
 {
     DTO.RolloutInfo rollout = GetDataFromXml.GetLatestRollout(userType, DTO.Enums.BackEndOrFrontEndEnum.FrontEnd);
     UpdateXmlFile.UpdateFrontEndXml(rollout);
 }
 internal static void AddRolloutRecord(DTO.RolloutInfo rollout)
 {
     XML.UpdateData.AddRolloutRecord(rollout);
 }