Inheritance: java.lang.Object
        public WrapperRepository(Assembly targetAssembly)
        {
            this.translations = new Dictionary<string, string>
            {
                { "com.gargoylesoftware.htmlunit.", "" },
                { "org.w3c.dom.", "W3C.Dom." },
            };

            Settings.Default.Whaat = new Random().Next().ToString();
            Settings.Default.Save();

            UsedTypes = new HashSet<Type>();
            CompleteTypes = new Dictionary<Type, WrapperClassInfo>();
            TargetAssembly = targetAssembly;

            if (Settings.Default.ListTypes != null)
            {
                ListTypes =
                    Settings.Default.ListTypes.Cast<string>()
                        .Where(s => s.Contains(':'))
                        .ToDictionary(
                            s => s.Substring(0, s.IndexOf(':')),
                            s => s.Substring(s.IndexOf(':') + 1));
            }
            else
            {
                ListTypes = new Dictionary<string, string>();
                Settings.Default.ListTypes = new StringCollection();
            }
        }
        /// <summary>
        /// Loads the instrument list from the instruments.txt file
        /// </summary>
        /// <returns></returns>
        private void LoadInstruments()
        {
            if (!File.Exists(InstrumentsFileName))
                throw new FileNotFoundException(InstrumentsFileName + " file not found.");

            _instruments = new Dictionary<string, LeanInstrument>();

            var lines = File.ReadAllLines(InstrumentsFileName);
            foreach (var line in lines)
            {
                var tokens = line.Split(',');
                if (tokens.Length >= 3)
                {
                    var fxcmSymbol = tokens[0];
                    var securityType = (SecurityType)Enum.Parse(typeof(SecurityType), tokens[2]);
                    var symbol = ConvertFxcmSymbolToLeanSymbol(fxcmSymbol, securityType);
                    _instruments.Add(symbol.Value, new LeanInstrument
                    {
                        Symbol = symbol.Value,
                        Name = tokens[1],
                        Type = securityType
                    });

                    _mapInstrumentSymbols[symbol] = fxcmSymbol;
                }
            }
        }
 public Dictionary<string, string> CheckPostcode(string postcode)
 {
     Dictionary<string, string> dictionary = new Dictionary<string, string>();
     if (!string.IsNullOrEmpty(postcode))
     {
         GoogleMapsMarker marker = this._storelocatorrepository.GetMarkerForPostcode(postcode, "")[0];
         if (marker != null)
         {
             this._locationLat = marker.lat.ToString();
             dictionary.Add("lat", this._locationLat);
             this._locationLong = marker.lng.ToString();
             dictionary.Add("long", this._locationLong);
         }
     }
     return dictionary;
 }
        /// <summary>
        /// Gets the relevant terms.
        /// </summary>
        /// <param name="text">The text.</param>
        /// <returns>
        /// IDictionary of types of tokens and values
        /// </returns>
        IDictionary<string, IEnumerable<string>> INlpProvider.GetRelevantTerms(string text)
        {
            IDictionary<string, IEnumerable<string>> returnDictionary = new Dictionary<string, IEnumerable<string>>();
            var annotation = new Annotation(text);
            NlpProvider.pipeline.annotate(annotation);

            var sentences = annotation.get(new CoreAnnotations.SentencesAnnotation().getClass()) as ArrayList;
            foreach (CoreMap sentence in sentences)
            {
                var tokens = sentence.get(new CoreAnnotations.TokensAnnotation().getClass()) as ArrayList;
                foreach (CoreLabel token in tokens)
                {
                    string pos = token.get(new CoreAnnotations.PartOfSpeechAnnotation().getClass()).ToString().ToUpper();
                    if (NlpProvider.relevantPos.Contains(pos))
                    {
                        List<string> listOfValues;
                        if (returnDictionary.ContainsKey(pos))
                        {
                            listOfValues = returnDictionary[pos] as List<string>;
                        }
                        else
                        {
                            listOfValues = new List<string>();
                            returnDictionary.Add(pos, listOfValues);
                        }

                        string word = token.get(new CoreAnnotations.TextAnnotation().getClass()).ToString();
                        listOfValues.Add(word);
                        ////var ner = token.get(new CoreAnnotations.NamedEntityTagAnnotation().getClass());
                        ////var normalizedner = token.get(new CoreAnnotations.NormalizedNamedEntityTagAnnotation().getClass());
                    }
                }
            }

            return returnDictionary;
        }
 public ActionResult Index(ComponentPresentation componentPresentation, UserProfile model)
 {
     this.Logger.DebugFormat("Called Update Profile >>>> ", new object[0]);
     try
     {
         ((dynamic) base.ViewBag).Title = componentPresentation.Component.Fields["title"].Value;
     }
     catch (Exception)
     {
     }
     string email = string.Empty;
     if (base.User.Identity.IsAuthenticated)
     {
         email = base.User.Identity.Name;
     }
     bool flag = this.IsEditModelValid(model);
     if (flag)
     {
         try
         {
             MembershipUser user = Membership.GetUser();
             if (user == null)
             {
                 flag = false;
                 this.Logger.DebugFormat("Update Profile mUser null", new object[0]);
             }
             if (model.AddressDetails.Postcode != null)
             {
                 this.FindPostcode(model);
             }
             if (model.RegistrationStatus == "postcode invalid")
             {
                 flag = false;
             }
             if (flag)
             {
                 this.Logger.DebugFormat("User profile start  >>>>", new object[0]);
                 CoatsUserProfile userProfile = CoatsUserProfile.GetProfile(user.Email);
                 if (userProfile != null)
                 {
                     string selectedKeywords = base.Request["CraftType"];
                     string str3 = base.Request["email-newsletter"];
                     string str4 = base.Request["visibile-profile"];
                     PublicasterServiceRequest request = new PublicasterServiceRequest();
                     string newsletter = "No";
                     if (str3.Trim() == WebConfiguration.Current.EmailNewsletterYes.Trim())
                     {
                         newsletter = "yes";
                     }
                     if (((selectedKeywords != null) || (str3 != null)) || (str4 != null))
                     {
                         List<TridionTcmUri> keywordsSelectListItems = GetKeywordsSelectListItems(selectedKeywords);
                         List<TridionTcmUri> second = GetKeywordsSelectListItems(str3);
                         List<TridionTcmUri> list3 = GetKeywordsSelectListItems(str4);
                         IEnumerable<TridionTcmUri> enumerable = keywordsSelectListItems.Union<TridionTcmUri>(second).Union<TridionTcmUri>(list3);
                         Dictionary<string, string> dictionary = new Dictionary<string, string>();
                         foreach (TridionTcmUri uri in enumerable)
                         {
                             dictionary.Add(uri.TcmId, "tcm");
                         }
                         userProfile.Keywords = dictionary;
                         model.Keywords = dictionary;
                     }
                     if (!string.IsNullOrEmpty(model.NewPassword))
                     {
                         if (model.NewPassword == model.VerifyNewPassword)
                         {
                             if (!string.IsNullOrEmpty(model.CurrentPassword))
                             {
                                 CoatsUserProfile profile = CoatsUserProfile.GetProfile(email);
                                 if (model.CurrentPassword == profile.PASSWORD)
                                 {
                                     model.CustomerDetails.Password = model.NewPassword;
                                 }
                                 else
                                 {
                                     flag = false;
                                     base.ModelState.AddModelError("CurrentPasswordIncorrect", Helper.GetResource("CurrentPasswordIncorrect"));
                                 }
                             }
                             else
                             {
                                 flag = false;
                             }
                         }
                         else
                         {
                             flag = false;
                             base.ModelState.AddModelError("NewPasswordsNotMatch", Helper.GetResource("NewPasswordsNotMatch"));
                         }
                     }
                     if (flag)
                     {
                         this.MapUserProfileForUpdate(model, userProfile);
                         userProfile.Save();
                         if ((str3 != null) && WebConfiguration.Current.CheckEmailNewsletterOption)
                         {
                             if (str3.Trim() == WebConfiguration.Current.EmailNewsletterYes.Trim())
                             {
                                 EmailUtility utility = new EmailUtility();
                                 string fromEmailAddress = ConfigurationManager.AppSettings["PasswordReminderEmailFrom"];
                                 string emailTemplate = ConfigurationManager.AppSettings["RegisterConfirmationEmailTemplate"];
                                 string registerThankYou = this._settings.RegisterThankYou;
                                 string str9 = HttpUtility.UrlEncode(General.Encrypt(userProfile.MAIL.Trim()));
                                 registerThankYou = registerThankYou + "?UserEmail=" + str9;
                                 model.CustomerDetails.SiteUrl = registerThankYou;
                                 model.CustomerDetails.DisplayName = userProfile.DISPLAYNAME;
                                 model.CustomerDetails.EmailAddress = userProfile.MAIL;
                                 string str10 = utility.SendEmail(model.CustomerDetails, emailTemplate, fromEmailAddress, userProfile.MAIL);
                                 this.Logger.DebugFormat("ProfileController : Register Confirmation Email > result {0}", new object[] { str10 });
                                 request.createJsonPublicasterRequest(userProfile.MAIL, userProfile.NAME, userProfile.SURNAME, selectedKeywords, userProfile.DISPLAYNAME, newsletter);
                             }
                             else
                             {
                                 request.UnSubscripePublicaster(userProfile.MAIL);
                             }
                         }
                         CoatsUserProfile profile3 = CoatsUserProfile.GetProfile(userProfile.MAIL);
                         CookieHelper.WriteFormsCookie(userProfile.MAIL, userProfile.DISPLAYNAME, userProfile.NAME, userProfile.SURNAME, userProfile.LONG, userProfile.LAT, "");
                         ((dynamic) base.ViewBag).profileStatus = "saved";
                         if (profile3 == null)
                         {
                             flag = false;
                             base.ModelState.AddModelError(string.Empty, "");
                             this.Logger.DebugFormat("Update Profile newUser null", new object[0]);
                         }
                     }
                 }
             }
         }
         catch (Exception exception)
         {
             this.Logger.DebugFormat("Update Profile exception {0} {1}", new object[] { exception.Message, exception.InnerException });
             flag = false;
         }
     }
     if (base.ModelState.ContainsKey("CustomerDetails.DisplayName"))
     {
         base.ModelState["CustomerDetails.DisplayName"].Errors.Clear();
     }
     if (base.ModelState.ContainsKey("CustomerDetails.EmailAddress"))
     {
         base.ModelState["CustomerDetails.EmailAddress"].Errors.Clear();
     }
     if (!flag)
     {
         UserProfile profile4 = this.GetModel();
         base.ModelState.AddModelError(string.Empty, "");
         var typeArray = (from x in base.ModelState
             where x.Value.Errors.Count > 0
             select new { 
                 Key = x.Key,
                 Errors = x.Value.Errors
             }).ToArray();
         foreach (var type in typeArray)
         {
             this.Logger.DebugFormat("Update Profile error {0}", new object[] { type });
         }
         this.GetModelData(profile4);
         base.Session["feedback"] = Helper.GetResource("ProfileError");
         ((dynamic) base.ViewBag).profileStatus = "error";
         return base.View(profile4);
     }
     UserProfile profile5 = this.GetModel();
     base.Session["feedback"] = Helper.GetResource("ProfileChangesSaved");
     return base.View(profile5);
 }
 private ViewResult FindPostcode(UserProfile model)
 {
     Dictionary<string, string> dictionary = new Dictionary<string, string>();
     if (!string.IsNullOrEmpty(model.AddressDetails.Postcode))
     {
         float num;
         float num2;
         string s = base.Request["lat"];
         string str2 = base.Request["long"];
         bool flag = float.TryParse(s, out num2);
         bool flag2 = float.TryParse(str2, out num);
         if (flag && flag2)
         {
             model.CustomerDetails.Lat = s;
             model.CustomerDetails.Long = str2;
         }
         else
         {
             dictionary = this.CheckPostcode(model.AddressDetails.Postcode);
             if (dictionary.Count > 0)
             {
                 model.CustomerDetails.Lat = dictionary["lat"];
                 model.CustomerDetails.Long = dictionary["long"];
             }
             else
             {
                 model.RegistrationStatus = "postcode invalid";
                 base.ModelState.AddModelError(string.Empty, Helper.GetResource("PostcodeError"));
             }
         }
     }
     return base.View(model);
 }
        public bool GenerateForAllUsedIncomplete()
        {
            var allAssemblyTypes = new Dictionary<string, Type>();

            foreach (Type t in TargetAssembly.GetTypes().Where(t => t.IsPublic))
            {
                if (!allAssemblyTypes.ContainsKey(t.Name))
                    allAssemblyTypes.Add(t.Name, t);
            }

            bool added = false;

            foreach (Type type in UsedTypes.ToArray())
            {
                if (!TypeIsWrapped(type))
                    throw new InvalidOperationException();

                if (!CompleteTypes.ContainsKey(type))
                {
                    var wci = new WrapperClassInfo(type, this);
                    CompleteTypes.Add(type, wci);

                    foreach (
                        Type inheritedType in
                            allAssemblyTypes.Values.Where(t => t.IsSubclassOf(wci.WrappedType) && t.IsPublic)
                                .Where(TypeIsWrapped))
                    {
                        if (inheritedType.GetCustomAttributes(typeof(ObsoleteAttribute), true).Count() == 0
                            && !UsedTypes.Contains(inheritedType))
                            UsedTypes.Add(inheritedType);
                    }

                    var sb = new StringBuilder();

                    if (wci.IsInterface)
                        wci.GenerateInterfaceCode(sb);
                    else
                        wci.GenerateClassCode(sb);

                    if (wci.FilePathBase.IndexOfAny(new[] { '\\', '/' }) != -1)
                        Directory.CreateDirectory(Path.GetDirectoryName(wci.FilePathBase));

                    WriteTextToFile(wci.FilePathBase + ".cs", sb.ToString(), true);

                    wci.GenerateUserClassFile();

                    added = true;
                }
            }

            return added;
        }