示例#1
0
 public static IDictionary<string, object> Copy(this IDictionary<string, object> context)
 {
     var result = new Dictionary<string, object>();
     foreach (var key in context)
     {
         result.Set(key.Key, key.Value);
     }
     return result;
 }
示例#2
0
文件: New.cs 项目: richorama/RaLisp
        public object Execute(IDictionary<string, object> context, params object[] parameters)
        {
            var result = new Dictionary<string, object>();

            for (var i = 0; i < parameters.Length; i += 2)
            {
                result.Set((parameters[i] as Variable).Name, parameters[i + 1].Evaluate(context));
            }

            return result;
        }
示例#3
0
        public void jailPlayer(Client player, int seconds)
        {
            API.setEntityData(player, "Jailed", true);
            API.resetPlayerNametagColor(player);
            API.setEntityPosition(player, JailCenter);

            API.setEntityData(player, "WantedLevel", 0);
            API.setPlayerWantedLevel(player, 0);
            API.resetEntityData(player, "Crimes");
            API.setEntityData(player, "JailTime", seconds);

            API.removeAllPlayerWeapons(player);

            lock (JailTimes) JailTimes.Set(player, API.TickCount + seconds * 1000);
        }
示例#4
0
        public static Dictionary <int, int> GetSectionMergeMappingDic(this List <Section> sections)
        {
            var dic = new Dictionary <int, int>();

            sections.ForEach(x => {
                if (x.SectionMergeMapping != null)
                {
                    foreach (var keyValuePair in x.SectionMergeMapping)
                    {
                        dic.Set(keyValuePair.Key, keyValuePair.Value);
                    }
                }
            });
            return(dic);
        }
示例#5
0
 private static void AddCompositeInstructions(Dictionary <int, ArgumentKind[]> dic2)
 {
     foreach (var pair in CompositeInstructions.ExpandedInstructions)
     {
         Instruction instruction       = (Instruction)pair.Key;
         var         instructions      = pair.Value;
         int         numberOfArguments = ((Instruction)instruction).GetNumberOfWords();
         if (numberOfArguments > 0)
         {
             var argumentKinds = new ArgumentKind[numberOfArguments];
             GetArgumentKinds(instructions, argumentKinds, dic2);
             dic2.Set((int)instruction, argumentKinds);
         }
     }
 }
示例#6
0
        /// <summary>
        ///     Mock HttpContext.QueryString object
        /// </summary>
        /// <param name="values"></param>
        /// <returns></returns>
        public MockController <TController> StubQueryString(object values)
        {
            var dictionary = new Dictionary <string, StringValues>();

            foreach (var keyValuePair in AnonymousHelper.ToDictionary(values))
            {
                dictionary.Set(keyValuePair.Key, keyValuePair.Value.ToString());
            }

            httpContext
            .SetupGet(r => r.Request.Query)
            .Returns(new QueryCollection(dictionary));

            return(this);
        }
        private static void LoadImages <TEmguImageStructure, TSize>(SegmenterImageStackLoadDescription segmenterImageStackLoadDescription, string volumeName, ref Dictionary <VolumeDescription> volumeDescriptions)
            where TEmguImageStructure : struct, IColor
            where TSize : new()
        {
            //
            // load in each source image and copy to client buffer
            //
            var imageDirectory = segmenterImageStackLoadDescription.Directories.Get(volumeName);
            var imageFileNames = from fileInfo in new DirectoryInfo(imageDirectory).GetFiles("*.*") where !fileInfo.Name.Equals("Thumbs.db") select fileInfo.Name;
            var imageFilePaths = from imageFileName in imageFileNames select Path.Combine(imageDirectory, imageFileName);

            Release.Assert(imageFilePaths.Count() > 0);

            int width, height, depth;

            using (var image = new Image <TEmguImageStructure, TSize>(imageFilePaths.First()))
            {
                width  = image.Width;
                height = image.Height;
                depth  = imageFilePaths.Count();
            }

            var volumeDataStream = new DataStream(width * height * depth * segmenterImageStackLoadDescription.NumBytesPerVoxel, true, true);

            foreach (var imageFilePath in imageFilePaths)
            {
                using (var image = new Image <TEmguImageStructure, TSize>(imageFilePath))
                {
                    volumeDataStream.Write(image.Bytes, 0, image.Bytes.Length);

                    Release.Assert(width == image.Width);
                    Release.Assert(height == image.Height);
                }
            }

            volumeDescriptions.Set(volumeName,
                                   new VolumeDescription
            {
                DxgiFormat       = segmenterImageStackLoadDescription.DxgiFormat,
                DataStream       = volumeDataStream,
                Data             = volumeDataStream.DataPointer,
                NumBytesPerVoxel = segmenterImageStackLoadDescription.NumBytesPerVoxel,
                NumVoxelsX       = width,
                NumVoxelsY       = height,
                NumVoxelsZ       = depth,
                IsSigned         = segmenterImageStackLoadDescription.IsSigned
            });
        }
示例#8
0
        /// <summary>
        /// Tries buildding the cache for the specified type.
        /// In case of an issue while building, null will be returned.
        ///
        /// If you want to know more as to why building failed, <see cref="GetBuildError(Type)"/>
        /// </summary>
        public static SerializableTypeCache TryBuild(Type type)
        {
            SerializableTypeCache stc = new SerializableTypeCache();

            try
            {
                stc.Build(type);
            }
            catch (Exception ex)
            {
                buildErrors.Set(type, ex.ToString());
                return(null);
            }

            return(stc);
        }
示例#9
0
        public static Dictionary<string, string> GetParams(object obj)
        {
            var dic = new Dictionary<string, string>();
            var props = obj.GetType().GetProperties().Where(p => p.GetCustomAttributes(typeof(ParamAttribute), true).Length > 0);
            foreach (var p in props) {
                var pa = (ParamAttribute)p.GetCustomAttributes(typeof(ParamAttribute), true).First();
                var pms = pa.GetParams(obj, p);
                if (pms != null) {
                    foreach (var pm in pms) {
                        dic.Set(pm.Key, pm.Value);
                    }
                }
            }

            return dic;
        }
示例#10
0
        /// <summary>
        /// Extract all the user_pref from a firefox file to a dictionary
        /// </summary>
        /// <returns>A <see cref="Dictionary{K, V}"/>containing key-value pairs representing the preferences.</returns>
        /// <remarks>Assumes that we only really care about the preferences, not the comments</remarks>
        static void CopyProfilePrefs(Stream file_stream, ref Dictionary prefs)
        {
            var reader = new StreamReader(file_stream, Encoding.ASCII, false);

            while (!reader.EndOfStream)
            {
                string line = reader.ReadLine();
                if (line.StartsWith("user_pref", StringComparison.OrdinalIgnoreCase))
                {
                    //extract key
                    int    istartKey = line.IndexOf('"') + 1;
                    int    iendKey   = line.IndexOf('"', istartKey);
                    string prefKey   = line.Substring(istartKey, iendKey - istartKey);

                    //extract value
                    int    istartVal = line.IndexOf(',', iendKey) + 1;
                    int    iendVal   = line.LastIndexOf(')');
                    string valueStr  = line.Substring(istartVal, iendVal - istartVal).Trim();

                    //parse value
                    object prefValue;
                    if ("true".Equals(valueStr, StringComparison.OrdinalIgnoreCase))
                    {
                        prefValue = true;
                    }
                    else if ("false".Equals(valueStr, StringComparison.OrdinalIgnoreCase))
                    {
                        prefValue = false;
                    }
                    else if (valueStr.Length == 0 || valueStr[0] == '"')
                    {
                        prefValue = valueStr.Trim('"');
                    }
                    else if ("null".Equals(valueStr, StringComparison.OrdinalIgnoreCase))
                    {
                        prefValue = null;
                    }
                    else
                    {
                        prefValue = int.Parse(valueStr, CultureInfo.InvariantCulture);
                    }

                    //Update dictonary
                    prefs.Set(prefKey, prefValue);
                }
            }
        }
示例#11
0
        private void AddMasterCollectionActions(IModGetter mod)
        {
            switch (_params.MastersListContent)
            {
            case BinaryWriteParameters.MastersListContentOption.NoCheck:
                _modKeys.Set(mod.MasterReferences.Select(m => new KeyValuePair <ModKey, FormKey>(m.Master, FormKey.Null)));
                break;

            case BinaryWriteParameters.MastersListContentOption.Iterate:
                _recordIterationActions.Add(maj => _modKeys[maj.FormKey.ModKey] = maj.FormKey);
                _formLinkIterationActions.Add((maj, formLink) => _modKeys[formLink.FormKey.ModKey] = maj);
                break;

            default:
                throw new NotImplementedException();
            }
        }
示例#12
0
    private AudioHolder CreateAudioHolder(string name, AudioClip clip, bool play, int type)
    {
        AudioHolder holder = null;

        while (m_cachedAudioSources.Count > 0 && !holder)
        {
            holder = m_cachedAudioSources.Dequeue();
        }
        if (!holder)
        {
            holder = AudioHolder.Create(name);
        }

        holder.id   = ++m_cachedID;
        holder.type = (AudioTypes)type;

        if (!holder.source)
        {
            holder.source = holder.GetComponentDefault <AudioSource>();
        }

        var source = holder.source;

        source.playOnAwake = false;
        source.enabled     = true;
        source.name        = name;
        source.transform.SetParent(m_playing);
        source.spatialBlend = 0;
        source.loop         = false;

        source.clip   = clip;
        source.volume = holder.volume;

        if (play)
        {
            source.Play();
        }

        m_playList.Add(holder);
        m_hashList.Set(holder.id, holder);

        AddRemoveTypeList(holder, type);

        return(holder);
    }
示例#13
0
    public void Initialize()
    {
        m_spriteMap.Clear();
        foreach (var s in m_sprites)
        {
            if (!s)
            {
                continue;
            }

            if (m_spriteMap.Get(s.name))
            {
                Logger.LogWarning("Atlas::Awake: Atlas {0} has duplicated sprite name, override.", name);
            }

            m_spriteMap.Set(s.name, s);
        }
    }
示例#14
0
        /// <summary>
        /// 获取成员初始化表达式的属性名称和属性值的键值对集合。
        /// (如 ()=>new A { Id = 3, Name = "test" } 表达式调用此方法 , 结果为 { { "Id", 3 }, { "Name", "test" } })
        /// </summary>
        /// <param name="memberInitLambda">成员初始化表达式(如 ()=>new A() { Id = 4, Name = "test" },表达式类型不符合将抛出异常,
        /// 只支持简单属性赋值常量的初始化表达式,其他类型表达式将忽略)</param>
        /// <returns></returns>
        public static IDictionary <string, object> GetMembersAndValues <T>(Expression <Func <T> > memberInitLambda)
        {
            Guard.ArgumentNotNull(memberInitLambda, nameof(memberInitLambda));
            if (!(memberInitLambda.Body is MemberInitExpression initExpression))
            {
                throw new ArgumentException("memberInitLambda 不是有效的成员初始化表达式。", nameof(memberInitLambda));
            }
            IDictionary <string, object> dic = new Dictionary <string, object>();

            foreach (var binder in initExpression.Bindings)
            {
                if (binder is MemberAssignment assigment && assigment.Expression is ConstantExpression valueExpression)
                {
                    dic.Set(assigment.Member.Name, valueExpression.Value);
                }
            }
            return(dic);
        }
示例#15
0
        public void SubscribeToServerEvent(string eventName, ServerEventHandle serverEventHandle)
        {
            ConsoleOutput.WriteLine(ConsoleType.Event,
                                    "Listen event ~#85a7dd~" + eventName + "~;~ in ~#85a7dd~" +
                                    (serverEventHandle.Cab.Method.DeclaringType != null
                    ? serverEventHandle.Cab.Method.DeclaringType.FullName
                    : "?." + serverEventHandle.Cab.Method.Name));

            List <ServerEventHandle> list = new List <ServerEventHandle>();

            if (_subscriberList.ContainsKey(eventName))
            {
                list = _subscriberList.Get(eventName);
            }

            list.Add(serverEventHandle);
            _subscriberList.Set(eventName, list);
        }
示例#16
0
    private static void AddMaterialsToPool(List <Material> orgMaterials)
    {
        foreach (var m in orgMaterials)
        {
            if (!m)
            {
                continue;
            }

            var c = m_materialPool.Get(m.GetInstanceID());
            if (c == null)
            {
                var s     = m.shader.name;
                var awake = s == normalAwakeShader.name || s == invertAwakeShader.name;

                c = new Material[8];
                for (var i = 0; i < 4; ++i)
                {
                    var mn = i == 0 ? m : Instantiate(m);
                    var mi = Instantiate(m);

                    mn.shader = awake ? normalAwakeShader : normalShader;
                    mi.shader = awake ? invertAwakeShader : invertShader;

                    mn.SetKeyWord("_RIM_LIGHT", i != 0);
                    mi.SetKeyWord("_RIM_LIGHT", i != 0);

                    if (i > 0)
                    {
                        mn.SetColor(m_rimColorID, rimColors[i]);
                        mn.SetFloat(m_rimIntensityID, rimIntensity[i]);

                        mi.SetColor(m_rimColorID, rimColors[i]);
                        mi.SetFloat(m_rimIntensityID, rimIntensity[i]);
                    }

                    c[i]     = mn;
                    c[i + 4] = mi;
                }

                m_materialPool.Set(m.GetInstanceID(), c);
            }
        }
    }
示例#17
0
        /// <summary>
        /// GetOrAdd
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <typeparam name="TValue"></typeparam>
        /// <param name="that"></param>
        /// <param name="key"></param>
        /// <param name="func"></param>
        /// <returns></returns>
        public static TValue GetOrAdd <TKey, TValue>(this Dictionary <TKey, TValue> that, TKey key, Func <TKey, TValue> func = null)
        {
            TValue value;

            if (that.ContainsKey(key))
            {
                value = that[key];
            }
            else if (func != null)
            {
                value = func(key);
                that.Set(key, value);
            }
            else
            {
                value = default(TValue);
            }
            return(value);
        }
示例#18
0
        public static void AddOutgoingToPayDay(Client player, double amount, Category category)
        {
            Dictionary <string, double> outgoings = (Dictionary <string, double>)player.getData("PayDayOutgoings");

            if (amount < 0)
            {
                amount = -amount;
                TTRPG.Api.consoleOutput(LogCat.Warn, "Tried to add negative amount to income of payday in category '" + category.ToString() + "' . Used positive amount instead.");
            }

            if (outgoings.ContainsKey(category.ToString()))
            {
                outgoings.Set(category.ToString(), outgoings.Get(category.ToString()) + amount);
            }
            else
            {
                outgoings.Add(category.ToString(), amount);
            }
        }
示例#19
0
    public void SetAssetsInAssetMap(GameLevelItemAssetData assetData)
    {
        Vector3 pos = assetData.position_data.GetVector3();

        if (pos.x > gridWidth - 1)
        {
            pos.x = gridWidth - 1;
        }

        if (pos.y > gridHeight - 1)
        {
            pos.y = gridHeight - 1;
        }

        if (pos.z > gridDepth - 1)
        {
            pos.z = gridDepth - 1;
        }

        string keyLayout =
            string.Format(
                "{0}-{1}-{2}",
                (int)pos.x,
                (int)pos.y,
                (int)pos.z);

        assetData.position_data.FromVector3(pos);

        if (!assetLayoutData.ContainsKey(keyLayout))
        {
            if (assetData.code != BaseDataObjectKeys.empty)
            {
                if (assetData.type == BaseDataObjectKeys.character)
                {
                    Debug.Log("SetAssetsIntoMap:keyLayout:" + keyLayout);
                    Debug.Log("SetAssetsIntoMap:assetData:" + assetData.ToJson());
                }
            }

            assetLayoutData.Set(keyLayout, assetData);
        }
    }
示例#20
0
        public static Dictionary <string, string> GetParams(object obj)
        {
            var dic   = new Dictionary <string, string>();
            var props = obj.GetType().GetProperties().Where(p => p.GetCustomAttributes(typeof(ParamAttribute), true).Length > 0);

            foreach (var p in props)
            {
                var pa  = (ParamAttribute)p.GetCustomAttributes(typeof(ParamAttribute), true).First();
                var pms = pa.GetParams(obj, p);
                if (pms != null)
                {
                    foreach (var pm in pms)
                    {
                        dic.Set(pm.Key, pm.Value);
                    }
                }
            }

            return(dic);
        }
        private void Sync(Client player, int vehicle, bool status)
        {
            var packet = Program.ServerInstance.Server.CreateMessage();

            packet.Write((byte)PacketType.UnoccupiedVehStartStopSync);
            packet.Write(vehicle);
            packet.Write(status);

            Program.ServerInstance.Server.SendMessage(packet, player.NetConnection, NetDeliveryMethod.ReliableOrdered, (int)ConnectionChannel.SyncEvent);
            //Console.WriteLine("[DEBUG MESSAGE] [+] Setting veh sync + " + status + " for: " + player.Name + " | Vehicle: " + vehicle);

            if (status)
            {
                Syncer.Set(vehicle, player);
            }
            else
            {
                Syncer.Remove(vehicle);
            }
        }
示例#22
0
        public void SetTest()
        {
            var initialDict = new Dictionary <string, int>
            {
                { "a", 0 },
                { "b", 0 },
                { "c", 0 }
            };
            var newDict = new Dictionary <string, int>
            {
                { "a", 2 },
                { "b", 3 },
                { "c", 4 }
            };

            initialDict.Set(newDict);
            initialDict["a"].ShouldEqual(2);
            initialDict["b"].ShouldEqual(3);
            initialDict["c"].ShouldEqual(4);
        }
示例#23
0
        void IDisposable.Dispose()
        {
            if (dictionary != null)
            {
                dictionary.Set();
            }
            if (events != null)
            {
                foreach (IEvent ev in events)
                {
                    ev.IsEnabled = false;
                    ev.Event    -= actions[ev];
                }
                foreach (IEvent ev in events)
                {
                    if (ev.IsEnabled)
                    {
                        ev.IsEnabled = false;
                    }
                }
            }
            foreach (IEventReader r in readers)
            {
                if (r.IsEnabled)
                {
                    r.IsEnabled = false;
                }
            }
            return;

            collection.ForEach <IEvent>((IEvent ev) => { ev.IsEnabled = false; });
            foreach (IEvent ev in actions.Keys)
            {
                if (!lno.Contains(ev))
                {
                    ev.IsEnabled = false;
                }
                ev.Event -= actions[ev];
            }
        }
示例#24
0
    private void SetInputState()
    {
        m_keyState.Set(KeyCode.W, Input.GetKey(KeyCode.W));
        m_keyState.Set(KeyCode.S, Input.GetKey(KeyCode.S));
        m_keyState.Set(KeyCode.A, Input.GetKey(KeyCode.A));
        m_keyState.Set(KeyCode.D, Input.GetKey(KeyCode.D));
        m_keyState.Set(KeyCode.Q, Input.GetKey(KeyCode.Q));
        m_keyState.Set(KeyCode.E, Input.GetKey(KeyCode.E));

        m_axisState.Set("x", Input.GetAxis("x"));
        m_axisState.Set("y", Input.GetAxis("y"));
        m_axisState.Set("ScrollWheel", Input.GetAxis("ScrollWheel"));

        m_mouseState.Set(1, Input.GetMouseButton(1));
        m_mouseState.Set(2, Input.GetMouseButton(2));
    }
示例#25
0
    private void Initialize()
    {
        m_materials.Clear();

        if (m_renderers == null)
        {
            m_renderers = new Dictionary <Renderer, Material[][]>();
        }
        else
        {
            m_renderers.Clear();
        }

        if (m_uvRenderers == null)
        {
            m_uvRenderers = new List <Renderer>();
        }
        else
        {
            m_uvRenderers.Clear();
        }

        var rs = GetComponentsInChildren <Renderer>(true);

        foreach (var r in rs)
        {
            var uvanim = r.GetComponent <UVAnimation>();
            if (uvanim)
            {
                m_uvRenderers.Add(r);
                continue;
            }

            var ms = r.sharedMaterials;
            m_materials.AddRange(ms);
            m_renderers.Set(r, new Material[2][] { ms, null });
        }
        m_materials.Distinct();
    }
示例#26
0
    public static Dictionary <string, string> ParseAssetHashListData(string data)
    {
        var list = new Dictionary <string, string>();

        if (string.IsNullOrEmpty(data))
        {
            return(list);
        }

        var ll = Util.ParseString <string>(data, false, '\n');

        foreach (var l in ll)
        {
            var pair = Util.ParseString <string>(l, false, '|');
            if (pair.Length != 2)
            {
                continue;
            }
            list.Set(pair[1], pair[0]);
        }
        return(list);
    }
示例#27
0
        /// <summary>
        /// 获取成员初始化表达式的属性名称和属性值的键值对集合。
        /// (如 ()=>new A { Id = 3, Name = "test" } 表达式调用此方法 , 结果为 { { "Id", 3 }, { "Name", "test" } })
        /// </summary>
        /// <param name="memberInitLambda">成员初始化表达式(如 ()=>new A() { Id = 4, Name = "test" },表达式类型不符合将抛出异常,
        /// 只支持简单属性赋值常量的初始化表达式,其他类型表达式将忽略)</param>
        /// <returns></returns>
        public static IDictionary <String, object> GetMembersAndValues <T>(Expression <Func <T> > memberInitLambda)
        {
            Guard.ArgumentNotNull(memberInitLambda, nameof(memberInitLambda));
            var initExpression = memberInitLambda.Body as MemberInitExpression;

            if (initExpression == null)
            {
                throw new ArgumentException("memberInitLambda 不是有效的成员初始化表达式。", nameof(memberInitLambda));
            }
            IDictionary <String, Object> dic = new Dictionary <String, Object>();

            foreach (var binder in initExpression.Bindings)
            {
                MemberAssignment   assigment       = binder as MemberAssignment;
                ConstantExpression valueExpression = assigment?.Expression as ConstantExpression;
                if (assigment != null && valueExpression != null)
                {
                    dic.Set(assigment.Member.Name, valueExpression.Value);
                }
            }
            return(dic);
        }
示例#28
0
        public void jailPlayer(Client player, int seconds)
        {
            API.setEntityData(player, "Jailed", true);
            API.resetPlayerNametagColor(player);
            API.setEntityPosition(player, JailCenter);
            API.setEntityData(player, "WantedLevel", 0);
            API.setPlayerWantedLevel(player, 0);
            API.resetEntityData(player, "Crimes");
            API.setEntityData(player, "JailTime", seconds);
            API.removeAllPlayerWeapons(player);
            CopUtil.UnCuff(player);
            if (player.model == (int)PedHash.FreemodeMale01)
            {
                CharacterCreator.setSpecialOutfit(player, "MPrisoner.xml");
            }
            if (player.model == (int)PedHash.FreemodeFemale01)
            {
                CharacterCreator.setSpecialOutfit(player, "FPrisoner.xml");
            }

            lock (JailTimes) JailTimes.Set(player, API.TickCount + seconds * 1000);
        }
示例#29
0
        public void SetHeader(string name, string value)
        {
            string nl = name.ToLower();

            if (nl != "content-type" &&
                nl != "content-length" &&
                nl != "host")
            {
                if (value == null)
                {
                    headers.Remove(name);
                }
                else
                {
#if dotNETMF
                    headers.Set(name, value);
#else
                    headers[name] = value;
#endif
                }
            }
        }
        public static HeaderDictionary Parse(string headers, System.Text.Encoding encoding)
        {
            headers = Utilities.DecodeWords(headers, encoding);
            var    temp = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
            var    lines = headers.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
            string key = null, value;

            foreach (var line in lines)
            {
                if (key != null && (line[0] == '\t' || line[0] == ' '))
                {
                    temp[key] += line.TrimStartOnce();
                }
                else
                {
                    if (key != null)
                    {
                        temp[key] = temp[key].TrimEndOnce(); // It trims the last line of the previous key
                    }
                    var index = line.IndexOf(':');
                    if (index > -1)
                    {
                        key   = line.Substring(0, index).TrimStartOnce();
                        value = line.Substring(index + 1).TrimStartOnce();
                        temp.Set(key, value);
                    }
                }
            }

            var result = new HeaderDictionary();

            foreach (var item in temp)
            {
                result.Add(item.Key, new HeaderValue(item.Value));
            }

            return(result);
        }
示例#31
0
        internal static bool StartDownload(int id, string path, FileType type, int len, string md5hash, string resource)
        {
            if (CurrentFile != null)
            {
                LogManager.DebugLog("CurrentFile isn't null -- " + CurrentFile.Type + " " + CurrentFile.Filename);
                return(false);
            }

            if ((type == FileType.Normal || type == FileType.Script) && Directory.Exists(FileTransferId._DOWNLOADFOLDER_ + path.Replace(Path.GetFileName(path), "")) &&
                File.Exists(FileTransferId._DOWNLOADFOLDER_ + path))
            {
                byte[] myData;

                using (var md5 = MD5.Create())
                    using (var stream = File.OpenRead(FileTransferId._DOWNLOADFOLDER_ + path))
                    {
                        myData = md5.ComputeHash(stream);
                    }

                string hash = myData.Select(byt => byt.ToString("x2")).Aggregate((left, right) => left + right);

                FileIntegrity.Set(path, md5hash);

                if (hash == md5hash)
                {
                    if (type == FileType.Script)
                    {
                        PendingScripts.ClientsideScripts.Add(LoadScript(path, resource, File.ReadAllText(FileTransferId._DOWNLOADFOLDER_ + path)));
                    }

                    LogManager.DebugLog("HASH MATCHES, RETURNING FALSE");
                    return(false);
                }
            }

            CurrentFile = new FileTransferId(id, path, type, len, resource);
            return(true);
        }
        public void TestHappyPath()
        {
            /* Creating the message and sending it to Camunda */
            var message = new CorrelationMessage()
            {
                MessageName = "MessagePaymentRequested",
                BusinessKey = Guid.NewGuid().ToString()
            };

            message.ProcessVariables
            .Set("paymentAmount", 10000)
            .Set("error", false)
            .Set("fail", false)
            .Set("resolvable", true);

            testHelper.CorrelateMessage(message);

            List <LockedExternalTask> chargeCreditTasks = testHelper.FetchAndLockTasks("charge-credit");

            Assert.AreEqual(chargeCreditTasks.Count, 1);

            Dictionary <string, VariableValue> variables = new Dictionary <string, VariableValue>();

            variables.Set("remainingAmount", 0);

            testHelper.RunExternalTasks(chargeCreditTasks, variables);

            List <LockedExternalTask> paymentFinishedTasks = testHelper.FetchAndLockTasks("payment-finished");

            testHelper.RunExternalTasks(paymentFinishedTasks, null);

            List <ProcessInstanceInfo> runningInstances = testHelper.QueryProcessInstances(new ProcessInstanceQuery()
            {
                ProcessDefinitionKey = "PaymentProcess"
            });

            Assert.AreEqual(runningInstances.Count, 0);
        }
        internal static Dictionary <string, string> GetErrors(System.Data.Entity.DbContext db)
        {
            Dictionary <string, string>            datas      = new Dictionary <string, string>();
            IEnumerable <DbEntityValidationResult> enumerable = from e in db.GetValidationErrors() select e;

            using (IEnumerator <DbEntityValidationResult> enumerator = enumerable.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    Action <DbValidationError> action = null;
                    DbEntityValidationResult   e      = enumerator.Current;
                    if (action == null)
                    {
                        action = delegate(DbValidationError ee)
                        {
                            datas.Set <string, string>(string.Format("{0} {1}", e.Entry.Entity.GetType(), ee.PropertyName), ee.ErrorMessage);
                        };
                    }
                    (from ee in e.ValidationErrors select ee).ToList <DbValidationError>().ForEach(action);
                }
            }
            return(datas);
        }
 public void SetTest()
 {
     var initialDict = new Dictionary<string, int>
         {
             {"a", 0},
             {"b", 0},
             {"c", 0}
         };
     var newDict = new Dictionary<string, int>
         {
             {"a", 2},
             {"b", 3},
             {"c", 4}
         };
     initialDict.Set(newDict);
     initialDict["a"].ShouldEqual(2);
     initialDict["b"].ShouldEqual(3);
     initialDict["c"].ShouldEqual(4);
 }
示例#35
0
        /// <summary>
        /// Metoda napelniajaca klase AlreadySetLetters literami znajdujacymi sie na planszy.
        /// </summary>
        /// <param name="ASL"></param>
        /// <param name="ConsideredContainer"></param>
        /// <param name="FirstIndex"></param>
        public void FillAlreadySetLetters(Dictionary.Dictionary.AlreadySetLetters ASL, Container ConsideredContainer, int FirstIndex)
        {
            int LettersLeft = Configuration.MaxLetterNumber;

            for(int i = 0; LettersLeft != 0; ++i)
            {
                Cell TempCell = ConsideredContainer.Get(FirstIndex + i);

                if(TempCell == null)
                {
                    return;
                }

                if(TempCell.IsVisited())
                {
                    ASL.Set(i, TempCell.GetTile().GetLetter());
                }
                else
                {
                    --LettersLeft;
                }
            }
        }