Example #1
0
 public override int GetHashCode()
 {
     return(HashTool.Compute(ProjectId,
                             TaskId,
                             StartTime,
                             EndTime));
 }
Example #2
0
        // helper function to set cookies
        private void SetCookie(string cookieName, string cookieValue)
        {
            var cookieOption = new CookieOptions();

            cookieOption.Expires = DateTime.Now.AddDays(1);
            Response.Cookies.Append(cookieName, HashTool.HashString(cookieValue), cookieOption);
        }
    /// <summary>
    /// Create a transition which represent the state switch to another state,and add it to the transition list.
    /// </summary>
    /// <param name="fsmStateName">The state name</param>
    /// <param name="nextFSMStateName">The name of the next state</param>
    /// <param name="fsmTransitionConditionArray">Some transition conditions</param>
    public FSMTransition CreateFSMStateToAnotherFSMStateTransition(string fsmStateName, string nextFSMStateName, IFSMTransitionCondition[] fsmTransitionConditionArray)
    {
        //convert the state name to hash value,to improve performance
        string fsmStateNameHash = HashTool.StringToHash(fsmStateName);

        FSMState fsmState = null;

        bool fsmStateExist = m_FSMStateDic.TryGetValue(fsmStateNameHash, out fsmState);

        if (fsmStateExist == false)
        {
            Debug.LogErrorFormat("The fsmStateName:{0} is not exist", fsmStateName);

            return(null);
        }

        //convert the state name to hash value,to improve performance
        string nextFSMStateNameHash = HashTool.StringToHash(nextFSMStateName);

        FSMState nextFSMState = null;

        bool nextFSMStateExist = m_FSMStateDic.TryGetValue(nextFSMStateNameHash, out nextFSMState);

        if (nextFSMStateExist == false)
        {
            Debug.LogErrorFormat("The nextFSMStateName:{0} is not exist", nextFSMStateName);

            return(null);
        }

        return(fsmState.AddTransition(nextFSMState, fsmTransitionConditionArray));
    }
    /// <summary>
    ///  Create each state switch to the given state's transition ,and add them to the transition list.
    /// </summary>
    /// <param name="nextFsmStateName">the state which them will switch to</param>
    /// <param name="fsmTransitionConditionArray">Some transition conditions</param>
    public void CreateAnyFSMStateToFSMStateTransition(string nextFsmStateName, IFSMTransitionCondition[] fsmTransitionConditionArray)
    {
        string nextFSMStateNameHash = HashTool.StringToHash(nextFsmStateName);

        FSMState nextFSMState = null;

        bool nextFSMStateExist = m_FSMStateDic.TryGetValue(nextFSMStateNameHash, out nextFSMState);

        if (nextFSMStateExist == false)
        {
            Debug.LogErrorFormat("The nextFSMStateName:{0} is not exist", nextFsmStateName);

            return;
        }


        foreach (KeyValuePair <string, FSMState> kv in m_FSMStateDic)
        {
            FSMState fsmState = kv.Value;

            if (fsmState != m_Entry &&
                fsmState != m_Exit &&
                fsmState != m_EndFSMState &&
                fsmState != nextFSMState)
            {
                fsmState.AddTransition(nextFSMState, fsmTransitionConditionArray);
            }
        }
    }
    /// <summary>
    /// Set the default state
    /// </summary>
    /// <param name="fsmStateName">The state name</param>
    public void SetDefaultState(string fsmStateName)
    {
        if (fsmStateName == null || fsmStateName == "")
        {
            Debug.LogError("the fsmStateName can not be null or Empty");

            return;
        }

        FSMState fsmState = null;

        //convert the state name to hash value,to improve performance
        string fsmStateNameHash = HashTool.StringToHash(fsmStateName);

        bool exist = m_FSMStateDic.TryGetValue(fsmStateNameHash, out fsmState);

        if (exist == true)
        {
            this.m_DefaultFSMState = fsmState;
        }
        else
        {
            Debug.LogErrorFormat("The {0} is not exist", fsmStateName);
        }
    }
    /// <summary>
    /// Set the end state
    /// </summary>
    /// <param name="fsmStateName">The state name</param>
    /// <param name="endStateToExitStateFSMTransitionConditionArray">Some conditions of endState switch to the exitState</param>
    public void SetEndState(string fsmStateName, IFSMTransitionCondition[] endStateToExitStateFSMTransitionConditionArray)
    {
        if (fsmStateName == null || fsmStateName == "")
        {
            Debug.LogError("the fsmStateName can not be null or Empty");

            return;
        }

        FSMState fsmState = null;

        //convert the state name to hash value,to improve performance
        string fsmStateNameHash = HashTool.StringToHash(fsmStateName);

        bool exist = m_FSMStateDic.TryGetValue(fsmStateNameHash, out fsmState);

        if (exist == true)
        {
            this.m_EndFSMState = fsmState;

            m_Exit = new FSMExit("FSMExit");

            AddState(m_Exit);

            this.m_EndFSMState.AddTransition(m_Exit, endStateToExitStateFSMTransitionConditionArray);
        }
        else
        {
            Debug.LogErrorFormat("The {0} is not exist", fsmStateName);
        }
    }
Example #7
0
        }         // IsEqual

        // ----------------------------------------------------------------------
        protected override int ComputeHashCode()
        {
            int hash = base.ComputeHashCode();

            hash = HashTool.AddHashCode(hash, fullName);
            return(hash);
        }         // ComputeHashCode
Example #8
0
        public void DateRange_HashCode_Test()
        {
            DateTime now = DateTime.Now;

            var ranges = new[]
            {
                new TimeRange(null, null),
                new TimeRange(null, now),
                new TimeRange(now, null),
                new TimeRange(now, now)
            };

            foreach (var range in ranges)
            {
                var hash1 = HashTool.Compute(range.Start, range.End);
                var hash2 = HashTool.Compute(range.End, range.Start);

                Console.WriteLine("Range=[{0}], hash1=[{1}], hash2=[{2}]", range, hash1, hash2);

                if (Equals(range.Start, range.End) == false)
                {
                    Assert.AreNotEqual(hash1, hash2);
                }
                else
                {
                    Assert.AreEqual(hash1, hash2);
                    Assert.AreNotEqual(0, hash1, "TimeRange=" + range);
                }
            }
        }
Example #9
0
        public void HashCode_Compute_Objects()
        {
            var now = DateTime.Now;

            var ranges = new[]
            {
                new TimeRange(null, null),
                new TimeRange(null, now),
                new TimeRange(now, null),
                new TimeRange(now, now)
            };

            foreach (var range in ranges)
            {
                var hash1 = HashTool.Compute(range.Start, range.End);
                var hash2 = HashTool.Compute(range.End, range.Start);

                if (Equals(range.Start, range.End))
                {
                    hash1.Should().Be(hash2);
                    hash1.Should().Not.Be(0);
                }
                else
                {
                    hash1.Should().Not.Be.EqualTo(hash2);
                }
            }
        }
        private static void QuickHashFile(DupItem file, int quickHashSize, ref long totalFileBytes, ref long totalReadBytes)
        {
            Interlocked.Add(ref totalFileBytes, file.Size);
            var hashSize = (int)Math.Min(file.Size, quickHashSize);

            using (var stream = File.Open(file.FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                file.Tags = new byte[hashSize];
                for (var i = 0; i < 3; i++)
                {
                    var  sectionSize = hashSize / 3;
                    long position;
                    if (i == 0)
                    {
                        position = 0;
                    }
                    else if (i == 1)
                    {
                        position = file.Size / 2 - sectionSize / 2;
                    }
                    else
                    {
                        position = file.Size - sectionSize;
                    }
                    stream.Seek(position, SeekOrigin.Begin);
                    stream.Read(file.Tags, i * sectionSize, sectionSize);
                }
                file.QuickHash = HashTool.HashBytesText(file.Tags);
                if (file.Size <= hashSize)
                {
                    file.Status = CompareStatus.Matched;
                }
                Interlocked.Add(ref totalReadBytes, hashSize);
            }
        }
Example #11
0
 public override int GetHashCode()
 {
     return(HashTool.Compute(Culture,
                             WeekOfYearRule,
                             StartOffset,
                             EndOffset));
 }
Example #12
0
        private void IncrementalHash(IGrouping <string, DupItem> quickHashGroup)
        {
            var groups = quickHashGroup.ToArray();
            var first  = groups.First();
            var length = first.Size / BufferSize;

            if (length == 0)
            {
                length = 1;
            }
            var position = 0;

            for (var i = 0; i < length; i++)
            {
                position += BufferSize;
                foreach (var group in groups.GroupBy(g => i == 0 ? string.Empty : g.HashSections[i - 1]))
                {
                    foreach (var groupFile in group)
                    {
                        if (groupFile.HashSections == null)
                        {
                            groupFile.HashSections = new List <string>();
                        }
                        groupFile.HashSections.Add(HashTool.HashFile(groupFile.FileName, position, BufferSize));
                    }
                }
            }

            foreach (var groupFile in groups)
            {
                groupFile.FullHash = string.Join(string.Empty, groupFile.HashSections);
            }
        }
Example #13
0
        public dynamic resetPassword(int userID, string hashed)
        {
            if (!HashTool.VerifyMd5Hash(userID.ToString(), hashed))
            {
                var err = new { err = "verify url format invalid" };
                return(JsonTool.toJson(err));
            }

            var user =
                (from p in db.users
                 where p.userID.Equals(userID)
                 select p).SingleOrDefault();

            int status = (int)user.status;

            String baseURL  = Request.RequestUri.GetLeftPart(UriPartial.Authority);
            String url      = baseURL + "/front/showMsg.html";
            String msgToken = "";
            String htmlStr  = "";

            if (status.Equals(-1))
            {
                msgToken = "userBanned";
            }
            msgToken = "redirectToResetPasswordPage";

            htmlStr =
                @"
<!DOCTYPE html>
<html lang='en'>
<head>
<title>plz w8</title>
<meta charset = 'utf-8'>
<meta name = 'viewport' content = 'width=device-width, initial-scale=1'>
<link rel = 'stylesheet' href = 'https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css'>
<script src = 'https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js'></script>
<script src = 'https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js'></script>
</head>
<body>
<div class='container'>
</div>
<script>
"
                + "sessionStorage.setItem('msgToken'," + "'" + msgToken + "'" + ");"
                + "sessionStorage.setItem('userID'," + "'" + user.userID + "'" + ");"
                + "sessionStorage.setItem('userEmail'," + "'" + user.email + "'" + ");"
                + "sessionStorage.setItem('userNickname'," + "'" + user.nickname + "'" + ");"
                + "window.location='" + url + "';"

                + @"
</script>
</body>
</html>";

            var response = new HttpResponseMessage();

            response.Content = new StringContent(htmlStr);
            response.Content.Headers.ContentType = new MediaTypeHeaderValue("text/html");
            return(response);
        }
Example #14
0
        } // IsEqual

        private int ComputeHashCode()
        {
            var hash = Red;

            hash = HashTool.AddHashCode(hash, Green);
            hash = HashTool.AddHashCode(hash, Blue);
            return(hash);
        } // ComputeHashCode
Example #15
0
        }         // IsEqual

        // ----------------------------------------------------------------------
        protected override int ComputeHashCode()
        {
            int hash = base.ComputeHashCode();

            hash = HashTool.AddHashCode(hash, this.text);
            hash = HashTool.AddHashCode(hash, this.format);
            return(hash);
        }         // ComputeHashCode
Example #16
0
        public void HashCode_Compute()
        {
            HashToolFixture.Entity entity = null;
            HashTool.Compute(entity).Should().Be(0);

            entity = new HashToolFixture.Entity(Guid.NewGuid(), "abc");
            HashTool.Compute(entity).Should().Not.Be.EqualTo(0).And.Be(entity.GetHashCode());
        }
Example #17
0
        public UserService()
        {
            currencyService   = new CurrencyService();
            roleService       = new SiteRoleService();
            userIncomeService = new UserIncomeService();

            hashTool = new HashTool();
        }
Example #18
0
        }         // IsEqual

        // ----------------------------------------------------------------------
        private int ComputeHashCode()
        {
            int hash = this.red;

            hash = HashTool.AddHashCode(hash, this.green);
            hash = HashTool.AddHashCode(hash, this.blue);
            return(hash);
        }         // ComputeHashCode
Example #19
0
        } // IsEqual

        protected override int ComputeHashCode()
        {
            var hash = base.ComputeHashCode();

            hash = HashTool.AddHashCode(hash, Text);
            hash = HashTool.AddHashCode(hash, _format);
            return(hash);
        } // ComputeHashCode
Example #20
0
 public UserService()
 {
     currencyService = new CurrencyService();
     roleService = new SiteRoleService();
     userIncomeService = new UserIncomeService();
     ntService = new NotificationService();
     hashTool = new HashTool();
 }
 private static void ProgressiveHashSection(long position, DupItem dupItem, int bufferSize, ref long totalReadBytes)
 {
     if (dupItem.HashSections == null)
     {
         dupItem.HashSections = new List <string>();
     }
     dupItem.HashSections.Add(HashTool.HashFile(dupItem.FileName, position, bufferSize, bufferSize, out var readSize));
     Interlocked.Add(ref totalReadBytes, readSize);
 }
Example #22
0
        public void md5()
        {
            string pwd = "1234";

            HashTool hashTool = new HashTool();

            Console.WriteLine( hashTool.Get( pwd, HashType.MD5_16 ) );
            Console.WriteLine( hashTool.Get( pwd, HashType.MD5 ) );
        }
Example #23
0
        public void md5()
        {
            string pwd = "1234";

            HashTool hashTool = new HashTool();

            Console.WriteLine(hashTool.Get(pwd, HashType.MD5_16));
            Console.WriteLine(hashTool.Get(pwd, HashType.MD5));
        }
Example #24
0
        public override int GetHashCode()
        {
            if (IsSaved)
            {
                return(base.GetHashCode());
            }

            return(HashTool.Compute(Department, User));
        }
Example #25
0
 public override int GetHashCode()
 {
     return(HashTool.Compute(Calendar,
                             YearBaseMonth,
                             FirstDayOfWeek,
                             Date1,
                             Date2,
                             Difference));
 }
Example #26
0
        public override int GetHashCode()
        {
            if (IsSaved)
            {
                return(base.GetHashCode());
            }

            return(HashTool.Compute(TimeRange, IsException));
        }
Example #27
0
        } // IsEqual

        private int ComputeHashCode()
        {
            var hash = ForegroundColor.GetHashCode();

            hash = HashTool.AddHashCode(hash, BackgroundColor);
            hash = HashTool.AddHashCode(hash, FontFamily);
            hash = HashTool.AddHashCode(hash, FontSize);
            return(hash);
        } // ComputeHashCode
Example #28
0
        public override int GetHashCode()
        {
            if (IsSaved)
            {
                return(base.GetHashCode());
            }

            return(HashTool.Compute(Id, Name, GetType().FullName));
        }
Example #29
0
        public override int GetHashCode()
        {
            if (IsSaved)
            {
                return(base.GetHashCode());
            }

            return(HashTool.Compute(GetType(), ReporterId, ReportDate));
        }
Example #30
0
        /// <summary>
        /// Hash Code를 계산합니다.
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            if (IsSaved)
            {
                return(base.GetHashCode());
            }

            return(HashTool.Compute(AssemblyName, Section, ResourceKey));
        }
Example #31
0
        public override int GetHashCode()
        {
            if (IsSaved)
            {
                return(base.GetHashCode());
            }

            return(HashTool.Compute(Name));
        }
Example #32
0
        }         // IsEqual

        // ----------------------------------------------------------------------
        private int ComputeHashCode()
        {
            int hash = foregroundColor.GetHashCode();

            hash = HashTool.AddHashCode(hash, backgroundColor);
            hash = HashTool.AddHashCode(hash, fontFamily);
            hash = HashTool.AddHashCode(hash, fontSize);
            return(hash);
        }         // ComputeHashCode
Example #33
0
        public void sha2()
        {
            string pwd = "1234";

            HashTool hashTool = new HashTool();

            Console.WriteLine( hashTool.Get( pwd, HashType.SHA384 ) );
            // 9198EAB4
            Console.WriteLine( hashTool.Get( pwd + "9198EAB4", HashType.SHA384 ) );
            //Console.WriteLine( HashTool.GetSalt( 4 ) );

            Console.WriteLine(  );

            Console.WriteLine( hashTool.GetBySalt( pwd, "9198EAB4", HashType.SHA384 ) );
        }
Example #34
0
        public void getSalt()
        {
            string pwd = "aaa";

            HashTool hashTool = new HashTool();

            Console.WriteLine( "myMd5=" + hashTool.Get( pwd, HashType.MD5_16 ) );
            Console.WriteLine( "myMd5=" + hashTool.Get( pwd, HashType.MD5 ) );
            Console.WriteLine( "mySHA1=" + hashTool.Get( pwd, HashType.SHA1 ) );
            Console.WriteLine( "mySHA2=" + hashTool.Get( pwd, HashType.SHA384 ) );
            Console.WriteLine( "mySHA5=" + hashTool.Get( pwd, HashType.SHA512 ) );

            Console.WriteLine( "GetRandomPassword="******"GetRandomPassword="******"GetSalt=" + hashTool.GetSalt( i ) );
            }
        }
Example #35
0
 public UserService()
 {
     hashTool = new HashTool();
     userIncomeService = new UserIncomeService();
 }