Convert() public static method

public static Convert ( object obj, defaultValue ) : T
obj object
return T
        /// <summary>
        /// 将value转换为目标类型
        /// 并将转换所得的值放到result
        /// 如果不支持转换,则返回false
        /// </summary>
        /// <param name="converter">转换器实例</param>
        /// <param name="value">要转换的值</param>
        /// <param name="targetType">转换的目标类型</param>
        /// <param name="result">转换结果</param>
        /// <returns>如果不支持转换,则返回false</returns>
        public virtual bool Convert(Converter converter, object value, Type targetType, out object result)
        {
            var dynamicObject = value as DynamicObject;
            if (dynamicObject == null)
            {
                result = null;
                return false;
            }

            var instance = Activator.CreateInstance(targetType);
            var setters = PropertySetter.GetPropertySetters(targetType);

            foreach (var set in setters)
            {
                object targetValue;
                if (this.TryGetValue(dynamicObject, set.Name, out targetValue) == true)
                {
                    targetValue = converter.Convert(targetValue, set.Type);
                    set.SetValue(instance, targetValue);
                }
            }

            result = instance;
            return true;
        }
        /// <summary>
        /// 将value转换为目标类型
        /// 并将转换所得的值放到result
        /// 如果不支持转换,则返回false
        /// </summary>
        /// <param name="converter">转换器实例</param>
        /// <param name="value">要转换的值</param>
        /// <param name="targetType">转换的目标类型</param>
        /// <param name="result">转换结果</param>
        /// <returns>如果不支持转换,则返回false</returns>
        public virtual bool Convert(Converter converter, object value, Type targetType, out object result)
        {
            var dic = value as IDictionary<string, object>;
            if (dic == null)
            {
                result = null;
                return false;
            }

            var instance = Activator.CreateInstance(targetType);
            var setters = PropertySetter.GetPropertySetters(targetType);

            foreach (var set in setters)
            {
                var key = dic.Keys.FirstOrDefault(k => string.Equals(k, set.Name, StringComparison.OrdinalIgnoreCase));
                if (key != null)
                {
                    var targetValue = converter.Convert(dic[key], set.Type);
                    set.SetValue(instance, targetValue);
                }
            }

            result = instance;
            return true;
        }
Exemplo n.º 3
0
        public object ProvideValue(IServiceProvider serviceProvider)
        {
            if (Text == null)
            {
                return("");
            }

            ResourceManager resmgr = new ResourceManager(ResourceId, typeof(LocalizeExtension).GetTypeInfo().Assembly);

            var translation = resmgr.GetString(Text, ci);

            if (translation == null)
            {
#if DEBUG
                throw new ArgumentException(
                          String.Format("Key '{0}' was not found in resources '{1}' for culture '{2}'.", Text, ResourceId, ci.Name),
                          "Text");
#else
                translation = Text; // HACK: returns the key, which GETS DISPLAYED TO THE USER
#endif
            }

            var convertTranslation = Converter?.Convert(translation, typeof(string), ConverterParameter, ci);

            return(convertTranslation ?? translation);
        }
        public void Converts()
        {
            Converter converter = new Converter(new MarkdownWriter());

            string result = converter.Convert(Input);

            Approvals.Verify(result);
        }
Exemplo n.º 5
0
        public void CanConvert_Borek01_To_NiceHtml()
        {
            var source = TestResources.Borek01;

            var converter = new Converter();

            var result = converter.Convert(source);

            Assert.Inconclusive();
        }
Exemplo n.º 6
0
        public void CanConvert_Heading_And_Formating_To_NiceHtml()
        {
            var source = TestResources.Headings_And_Formating;

            var converter = new Converter();

            var result = converter.Convert(source);

            Assert.Inconclusive();
        }
Exemplo n.º 7
0
        public void CanConvert_JustHeading_To_NiceHtml()
        {
            var source = TestResources.JustHeadings;

            var converter = new Converter();

            var result = converter.Convert(source);

            Assert.Inconclusive();
        }
Exemplo n.º 8
0
        /// <summary>
        /// 将value转换为目标类型
        /// 并将转换所得的值放到result
        /// 如果不支持转换,则返回false
        /// </summary>
        /// <param name="converter">转换器实例</param>
        /// <param name="value">要转换的值</param>
        /// <param name="targetType">转换的目标类型</param>
        /// <param name="result">转换结果</param>
        /// <returns>如果不支持转换,则返回false</returns>
        public virtual bool Convert(Converter converter, object value, Type targetType, out object result)
        {
            if (targetType.IsGenericType && targetType.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                var genericArgument = targetType.GetGenericArguments().First();
                result = converter.Convert(value, genericArgument);
                return true;
            }

            result = null;
            return false;
        }
        // This gets called on every change of the dynamic resource, for every object it's been applied to
        // either when applied directly, or via a style
        private object?WrapperConvert(object?[] values, Type?targetType, object?parameter, CultureInfo?culture)
        {
            object?dynamicResourceBindingResult = values[0]; // This is the result of the DynamicResourceBinding**
            var    bindingTargetObject          = values[1]; // The ultimate target of the binding

            // We can ignore the bogus third value (in 'values[2]') as that's the dummy result
            // of the BindingTrigger's value which will always be 'null'

            // ** Note: This value has not yet been passed through the converter, nor been coalesced
            // against TargetNullValue, or, if applicable, formatted, both of which we have to do here.
            if (Converter != null)
            {
                // We pass in the TargetType we're handed here as that's the real target. Child bindings
                // would've normally been handed 'object' since their target is the MultiBinding.
                dynamicResourceBindingResult = Converter?.Convert(dynamicResourceBindingResult, targetType, ConverterParameter, ConverterCulture);
            }
            // Check the results for null. If so, assign it to TargetNullValue
            // Otherwise, check if the target type is a string, and that there's a StringFormat
            // if so, format the string.
            // Note: You can't simply put those properties on the MultiBinding as it handles things differently
            // than a single binding (i.e. StringFormat is always applied, even when null.
            if (dynamicResourceBindingResult is null)
            {
                dynamicResourceBindingResult = TargetNullValue;
            }
            else if (targetType == typeof(string) && StringFormat != null)
            {
                dynamicResourceBindingResult = String.Format(CultureInfo.InvariantCulture, StringFormat, dynamicResourceBindingResult);
            }

            // If the binding target object is a FrameworkElement, ensure the BindingSource is added
            // to its Resources collection so it will be part of the lookup relative to the FrameworkElement
            if (bindingTargetObject is FrameworkElement targetFrameworkElement &&
                !targetFrameworkElement.Resources.Contains(_bindingSource))
            {
                // Add the resource to the target object's Resources collection
                targetFrameworkElement.Resources[_bindingSource] = _bindingSource;

                // Since we just added the source to the visual tree, we have to re-evaluate the value
                // relative to where we are.  However, since there's no way to get a binding expression,
                // to trigger the binding refresh, here's where we use that BindingTrigger created above
                // to trigger a change notification, thus having it refresh the binding with the (possibly)
                // new value.
                // Note: since we're currently in the Convert method from the current operation,
                // we must make the change via a 'Post' call or else we will get results returned
                // out of order and the UI won't refresh properly.
                SynchronizationContext.Current?.Post(_ => _bindingTrigger?.Refresh(), null);
            }

            // Return the now-properly-resolved result of the child binding
            return(dynamicResourceBindingResult);
        }
Exemplo n.º 10
0
        public void Convert_NestedObject_ShouldSucced(Converter sut)
        {
            //Setup
            var columns = new List<string>() {
                "id",
                "city.name",
                "city.country.isoCode"
            };
            var matrix = new List<List<object>>()
            {
                new List<object>() { 1, "cityName1", "countryIsoCode1" },
                new List<object>() { 2, "cityName2", "countryIsoCode2" }
            };

            //Exercise
            var actual = sut.Convert(columns, matrix);

            //Verify
            actual.Should().NotBeEmpty()
                .And.HaveSameCount(matrix)
                .And.DeepContain(new Dictionary<string, object>()
                {
                    { "id", 1 },
                    { "city", new Dictionary<string, object>()
                        {
                            { "name", "cityName1" },
                            { "country", new Dictionary<string, object>()
                                {
                                    { "isoCode", "countryIsoCode1" }
                                }
                           }
                        }
                    }
                })
                .And.DeepContain(new Dictionary<string, object>()
                {
                    { "id", 2 },
                    { "city", new Dictionary<string, object>()
                        {
                            { "name", "cityName2" },
                            { "country", new Dictionary<string, object>()
                                {
                                    { "isoCode", "countryIsoCode2" }
                                }
                            }
                        }
                    }
                });
        }
Exemplo n.º 11
0
        /// <summary>
        /// 将value转换为目标类型
        /// 并将转换所得的值放到result
        /// 如果不支持转换,则返回false
        /// </summary>
        /// <param name="converter">转换器实例</param>
        /// <param name="value">要转换的值</param>
        /// <param name="targetType">转换的目标类型</param>
        /// <param name="result">转换结果</param>
        /// <returns>如果不支持转换,则返回false</returns>
        public virtual bool Convert(Converter converter, object value, Type targetType, out object result)
        {
            if (targetType.IsArray == false)
            {
                result = null;
                return false;
            }

            var items = value as IEnumerable;
            var elementType = targetType.GetElementType();

            if (items == null)
            {
                result = Array.CreateInstance(elementType, 0);
                return true;
            }

            var length = 0;
            var list = items as IList;
            if (list != null)
            {
                length = list.Count;
            }
            else
            {
                var enumerator = items.GetEnumerator();
                while (enumerator.MoveNext())
                {
                    length = length + 1;
                }
            }

            var index = 0;
            var array = Array.CreateInstance(elementType, length);
            foreach (var item in items)
            {
                var itemCast = converter.Convert(item, elementType);
                array.SetValue(itemCast, index);
                index = index + 1;
            }

            result = array;
            return true;
        }
        public static string Convert(string input)
        {
            Dictionary<string, Converter.Tag> tagDict = new Dictionary<string, Converter.Tag>();

            tagDict.Add("stats", new Converter.NodeTag("stats", new Converter.Style(@"<Run FontWeight=""Bold"">", @"</Run>")));
            tagDict.Add("unique", new Converter.NodeTag("unique", new Converter.Style(@"<Run FontWeight=""Bold"" Foreground=""DarkBlue"">", @"</Run>")));
            tagDict.Add("i", new Converter.NodeTag("i", new Converter.Style(@"<Run FontStyle=""Italic"">", @"</Run>")));
            tagDict.Add("consumable", new Converter.NodeTag("consumable", new Converter.Style(@"<Run FontWeight=""Bold"" Foreground=""DarkOrange"">", @"</Run>")));
            tagDict.Add("active", new Converter.NodeTag("active", new Converter.Style(@"<Run FontWeight=""Bold"" Foreground=""DarkRed"">", @"</Run>")));
            tagDict.Add("passive", new Converter.NodeTag("passive", new Converter.Style(@"<Run FontWeight=""Bold"" Foreground=""DarkBlue"">", @"</Run>")));
            tagDict.Add("aura", new Converter.NodeTag("aura", new Converter.Style(@"<Run FontWeight=""Bold"" Foreground=""DarkGreen"">", @"</Run>")));
            tagDict.Add("br", new Converter.SingleTag("br", new Converter.Style("<LineBreak/>")));
            tagDict.Add("start", new Converter.SingleTag("start", new Converter.Style(@"<Paragraph FontFamily=""Global User Interface"">")));
            tagDict.Add("end", new Converter.SingleTag("end", new Converter.Style(@"</Paragraph>")));
            tagDict.Add("body", new Converter.NodeTag("body", new Converter.Style(@"<Run Text=""", @"""></Run>")));
            Converter c = new Converter(tagDict);

            return c.Convert(input);
        }
Exemplo n.º 13
0
        private void button1_Click(object sender, EventArgs e)
        {
            Converter converter = new Converter();
            // Authentication
            converter.Username = "";
            converter.Password = "";
            converter.Domain = "";
            // Authentication
            string cType="";
            if (this.comboBox1.SelectedIndex==0) { cType="ObjCFiles";}
            if (this.comboBox1.SelectedIndex==1) { cType="ObjCARCFiles";}
            if (this.comboBox1.SelectedIndex==2) { cType="Javascript";}
            if (this.comboBox1.SelectedIndex==3) { cType="ActionScript";}

            converter.Type = cType ;
            converter.WsdlPaths = textBox1.Text;
            converter.Convert();
            FileInfo zf=converter.CreateArchive();
            MessageBox.Show(zf.FullName,"Code Generated");
        }
Exemplo n.º 14
0
        public void Convert_SimpleObject_ShouldSucced(Converter sut)
        {
            //Setup
            var columns = new List<string>() {
                "id",
                "name"
            };
            var matrix = new List<List<object>>()
            {
                new List<object>() { 1, "name1" },
                new List<object>() { 2, "name2" },
                new List<object>() { 3, "name3" }
            };

            //Exercise
            var actual = sut.Convert(columns, matrix);

            //Verify
            actual.Should().NotBeEmpty()
                .And.HaveSameCount(matrix)
                .And.DeepContain(new Dictionary<string, object>() { { "id", 1 }, { "name", "name1" } })
                .And.DeepContain(new Dictionary<string, object>() { { "id", 2 }, { "name", "name2" } })
                .And.DeepContain(new Dictionary<string, object>() { { "id", 3 }, { "name", "name3" } });
        }
Exemplo n.º 15
0
		private static void CheckConversion(string html, string expected)
		{
			var converter = new Converter();

			var result = converter.Convert(html);

			Assert.That(result, Is.EqualTo(expected));
		}
Exemplo n.º 16
0
 public void ConvertFromSingle()
 {
     TestHelper.AreEqual(9223372000000000000, Converter.Convert <long>((float)long.MaxValue));
     TestHelper.AreEqual(-9223372000000000000, Converter.Convert <long>((float)long.MinValue));
 }
Exemplo n.º 17
0
 public void ConvertFromString()
 {
     TestHelper.AreEqual(2147483647, Converter.Convert <long>(int.MaxValue.ToString()));
     TestHelper.AreEqual(-2147483648, Converter.Convert <long>(int.MinValue.ToString()));
 }
Exemplo n.º 18
0
        public void ConvertCodeBlock()
        {
            var codeText = @"
public function addItem($sku, $name, $price, $category = null, $quantity = 1) {
 $product = array();
 foreach (array('sku', 'name', 'category', 'price', 'quantity') as $arg) {
  if ($$arg !== null) {
   $product[$arg] = $$arg;
  }
 }

 if (empty($this->transaction['transactionProducts'])) {
  $this->transaction['transactionProducts'] = array();
 }
 $this->transaction['transactionProducts'][] = $product;
 return $this;
}
";
            var wikiText = "<code php>" + codeText + "</code>";

            Assert.AreEqual("<pre><code class=\"php\">" + codeText + "</code></pre>\n", Converter.Convert(wikiText));
        }
Exemplo n.º 19
0
 // static kstatus_t KonohaSpace_eval(CTX, kKonohaSpace *ks, const char *script, kline_t uline)
 public dynamic Eval(string script)
 {
     var tokens = tokenize(script);
     var parser = new Parser(ctx, this);
     var converter = new Converter(ctx, this);
     var block = parser.CreateBlock(null, tokens, 0, tokens.Count(), ';');
     dynamic ast = converter.Convert(block);
     string dbv = typeof(Expression).InvokeMember("DebugView", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetProperty, null, ast, null);
     Console.WriteLine("### DLR AST Dump ###");
     Console.WriteLine(dbv);
     var f = ast.Compile();
     return f();
 }
 public void VerifyComplete(Converter converter, Task<bool> res)
 {
     if (this.HandleFaultedTask(res))
     {
         EnableUi = true;
         converter.Dispose();
         return;
     }
     if (res.Result)
     {
         converter.Convert().ContinueWith(x => this.ConvertComplete(converter, x));
     }
 }
Exemplo n.º 21
0
        public void Process(ISemanticProcessor proc, IMembrane membrane, Route route)
        {
            IAuthenticatingRouterService routerService = proc.ServiceManager.Get <IAuthenticatingRouterService>();
            IContext context = route.Context;
            HttpVerb verb    = context.Verb();
            UriPath  path    = context.Path();

            string    searchRoute = GetSearchRoute(verb, path);
            string    data        = route.Data;
            RouteInfo routeInfo;

            IPAddress addr = context.Request.RemoteEndPoint.Address;
            string    ip   = addr.ToString();

            // Handle localhost format.
            if (ip == "::1")
            {
                addr = new IPAddress(new byte[] { 127, 0, 0, 1 });
            }

            Console.WriteLine(DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss tt ") + "IP: " + addr.ToString() + "    URL: " + route.Context.Request.Url);

            // TODO: Session manager may not exist.  How do we handle services that are missing?
            IWebSessionService session = proc.ServiceManager.Get <IWebSessionService>();

            // Semantic routes can be either public or authenticated.
            if (routerService.Routes.TryGetValue(searchRoute, out routeInfo))
            {
                // Public routes always authenticate.
                bool authenticatedRoute = true;
                bool authorizedRoute    = true;

                if (routeInfo.RouteType == RouteType.AuthenticatedRoute)
                {
                    session.UpdateState(context);
                    authenticatedRoute = session.IsAuthenticated(context);
                }

                if (routeInfo.RouteType == RouteType.RoleRoute)
                {
                    session.UpdateState(context);
                    authenticatedRoute = session.IsAuthenticated(context);

                    // User must be authenticated and have the correct role setting.
                    if (authenticatedRoute)
                    {
                        // Any bits that are set with a binary "and" of the route's role mask and the current role passes the authorization test.
                        uint mask = session.GetSessionObject <uint>(context, "RoleMask");
                        authorizedRoute = (mask & routeInfo.RoleMask) != 0;
                    }
                }

                if (authenticatedRoute)                     // user is authenticated
                {
                    session.UpdateLastTransaction(context);
                }

                if (authenticatedRoute && authorizedRoute)
                {
                    Type          receptorSemanticType = routeInfo.ReceptorSemanticType;
                    SemanticRoute semanticRoute        = (SemanticRoute)Activator.CreateInstance(receptorSemanticType);
                    semanticRoute.PostData = data;

                    if (!String.IsNullOrEmpty(data))
                    {
                        // Is it JSON?
                        // NOTE: "JSON" is passed in as a string, not object.  So this is what it looks like in the Javascript:
                        // $.post("/geeks/createProfile", '{ "profileName": "foobar" }'
                        // Note the surrounding ' marks
                        if (data[0] == '{')
                        {
                            JsonConvert.PopulateObject(data, semanticRoute);
                            SetUrlParameters(context.Request.Url.ToString(), semanticRoute, receptorSemanticType);
                        }
                        else if (MultiPartParser.IsMultiPart(data))
                        {
                            MultiPartParser.ContentType ct = MultiPartParser.GetContentType(data);
                            string content = MultiPartParser.GetContent(data);

                            if (!(semanticRoute is IFileUpload))
                            {
                                throw new RouterException("Semantic route class must implement IFileUpload");
                            }

                            ((IFileUpload)semanticRoute).Content = content;
                        }
                        else
                        {
                            // Instead here, the data is passed in as an object, which comes in as params.  The Javascript for this looks like:
                            // $.post("/geeks/createProfile", { "profileName": profileName }
                            // Note the lack of surrounding ' around the { }
                            // Example: "username=sdfsf&password=sdfsdf&LoginButton=Login"
                            // Use $.post(url, JSON.stringify(data) to convert to JSON
                            string[] parms = data.Split('&');

                            foreach (string parm in parms)
                            {
                                string[]     keyVal = parm.Split('=');
                                PropertyInfo pi     = receptorSemanticType.GetProperty(keyVal[0], BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);

                                if (pi != null)
                                {
                                    // TODO: Should handling of "+" be before or after the UnescapedDataString call?
                                    object valOfType = Converter.Convert(Uri.UnescapeDataString(keyVal[1].Replace('+', ' ')), pi.PropertyType);
                                    pi.SetValue(semanticRoute, valOfType);
                                }
                            }
                        }
                    }
                    else if (verb.Value == "GET")
                    {
                        SetUrlParameters(context.Request.Url.ToString(), semanticRoute, receptorSemanticType);
                    }

                    // Must be done AFTER populating the object -- sometimes the json converter nulls the base class!
                    semanticRoute.Context = context;
                    // TODO: Why are we doing this on the caller thread, except for debugging???
                    proc.ProcessInstance <WebServerMembrane>(semanticRoute, true);
                }
                else
                {
                    // Deal with expired or requires authentication.
                    switch (session.GetState(context))
                    {
                    case SessionState.New:
                        // TODO: Oh man, this is application specific!!!
                        session.SetSessionObject(context, "OneTimeBadAlert", "Please Sign In");
                        context.Redirect("/account/login");
                        //proc.ProcessInstance<WebServerMembrane, StringResponse>(r =>
                        //{
                        //	r.Context = context;
                        //	r.Message = "authenticationRequired";		// used in clifton.spa.js to handle SPA error responses
                        //	r.StatusCode = 403;
                        //});
                        break;

                    case SessionState.Authenticated:
                        proc.ProcessInstance <WebServerMembrane, StringResponse>(r =>
                        {
                            r.Context    = context;
                            r.Message    = "notAuthorized";                                                             // used in clifton.spa.js to handle SPA error responses
                            r.StatusCode = 401;
                        });
                        break;

                    case SessionState.Expired:
                        session.SetSessionObject(context, "OneTimeBadAlert", "Session expired.  Please sign in again.");
                        context.Redirect("/account/login");
                        //proc.ProcessInstance<WebServerMembrane, StringResponse>(r =>
                        //{
                        //	r.Context = context;
                        //	r.Message = "sessionExpired";				// used in clifton.spa.js to handle SPA error responses
                        //	r.StatusCode = 401;
                        //});
                        break;
                    }
                }
            }
            else
            {
                // proc.ProcessInstance<LoggerMembrane, ST_Log>(msg => msg.Message = "Using default handler: " + verb.Value + ": " + path.Value);
                // Put the context on the bus for some service to pick up.
                // All unhandled context are assumed to be public routes.
                proc.ProcessInstance <WebServerMembrane, UnhandledContext>(c => c.Context = context);
            }
        }
Exemplo n.º 22
0
 protected override void Upload(DicomFile data, int frame, IStorageLocation location)
 {
     location.Upload(System.Text.Encoding.UTF8.GetBytes(Converter.Convert(data.DataSet)));
 }
Exemplo n.º 23
0
        /// <summary>
        /// Main program.
        /// </summary>
        /// <param name="args">Command line arguments.</param>
        static void Main(string[] args)
        {
            Helper = new ConsolePrinter();

            Helper.Name        = "Font2Font";
            Helper.Description = "Converts a Windows font to a Woopsi font.";
            Helper.Version     = "V1.2";
            Helper.AddArgument(new Argument("FONT", "string", "Name of the Windows font to convert", false));
            Helper.AddArgument(new Argument("SIZE", "int", "Size of the font in pixels", false));
            Argument arg = new Argument("STYLE", "int", "Style of the font.  Options are:", true);

            arg.AddOption("regular", "Standard font");
            arg.AddOption("bold", "Bold font");
            arg.AddOption("italic", "Italic font");

            Helper.AddArgument(arg);

            arg = new Argument("FONTTYPE", "string", "Type of font to produce.  Options are:", true);
            arg.AddOption("packedfont1", "Monochrome packed proportional font");
            arg.AddOption("packedfont16", "16-bit packed proportional font");

            Helper.AddArgument(arg);

            Helper.AddArgument(new Argument("PATH", "string", "Output path", false));
            Helper.AddArgument(new Argument("R", "int", "Red component of the text colour", true));
            Helper.AddArgument(new Argument("G", "int", "Green component of the text colour", true));
            Helper.AddArgument(new Argument("B", "int", "Blue component of the text colour", true));
            Helper.AddArgument(new Argument("LIST", "int", "Lists all available Windows font names", true));

            Helper.AddParagraph("If the text colour is not specified it defaults to black.");
            Helper.AddParagraph("If the style is not specified it defaults to regular.");
            Helper.AddParagraph("If the path is not specified it defaults to the current path.");
            Helper.AddParagraph("If the font type is not specified it defaults to packedfont1.");

            Console.WriteLine(Helper.Title);

            Console.WriteLine(Helper.HelpText);

            // Fetch arguments
            ParseArgs(args);

            // Use background colour that is opposite of text colour
            int backgroundR = (mTextR ^ 255) & 255;
            int backgroundG = (mTextG ^ 255) & 255;
            int backgroundB = (mTextB ^ 255) & 255;

            // Get the font
            Font font = GetFont(mFontName, mFontSize, mFontStyle);

            // Convert the font to a bitmap
            Bitmap bmp = BitmapCreator.CreateFontBitmap(font, backgroundR, backgroundG, backgroundB, mTextR, mTextG, mTextB);

            // Convert bitmap to Woopsi font
            WoopsiFont woopsiFont = Converter.Convert(mFontName, mFontName, mFontType, bmp, bmp.Width / CHARS_PER_ROW, bmp.Height / ROWS_PER_FONT, backgroundR, backgroundG, backgroundB);

            // Output files
            WriteFile(mOutputPath + "\\" + woopsiFont.HeaderFileName, woopsiFont.HeaderContent);
            WriteFile(mOutputPath + "\\" + woopsiFont.BodyFileName, woopsiFont.BodyContent);

            Console.WriteLine("All done!");
        }
Exemplo n.º 24
0
 public static object Convert(object from, Type toType)
 {
     return(Converter.Convert(from, toType));
 }
Exemplo n.º 25
0
 public static TTo Convert <TFrom, TTo>(TFrom from)
 {
     return(Converter.Convert <TFrom, TTo>(from));
 }
Exemplo n.º 26
0
        static void Main(string[] args)
        {
            ParseArgs(args, ToolName);

            InitializeLogger();

            PrintWelcome(ToolName, RevisionResource);

            if (CreateContextMenuEntry)
            {
                // create context menu entry
                try
                {
                    TraceLogger.Info("Creating context menu entry for xls2x ...");
                    RegisterForContextMenu(GetContextMenuKey(ContextMenuInputExtension, ContextMenuText));
                    TraceLogger.Info("Succeeded.");
                }
                catch (Exception)
                {
                    TraceLogger.Info("Failed. Sorry :(");
                }
            }
            else
            {
                try
                {
                    //copy processing file
                    ProcessingFile procFile = new ProcessingFile(InputFile);

                    //make output file name
                    if (ChoosenOutputFile == null)
                    {
                        if (InputFile.Contains("."))
                        {
                            ChoosenOutputFile = InputFile.Remove(InputFile.LastIndexOf(".")) + ".xlsx";
                        }
                        else
                        {
                            ChoosenOutputFile = InputFile + ".xlsx";
                        }
                    }

                    //parse the document
                    using (StructuredStorageReader reader = new StructuredStorageReader(procFile.File.FullName))
                    {
                        XlsDocument xlsDoc = new XlsDocument(reader);

                        OpenXmlPackage.DocumentType outType = Converter.DetectOutputType(xlsDoc);
                        string conformOutputFile            = Converter.GetConformFilename(ChoosenOutputFile, outType);
                        using (SpreadsheetDocument spreadx = SpreadsheetDocument.Create(conformOutputFile, outType))
                        {
                            //start time
                            DateTime start = DateTime.Now;
                            TraceLogger.Info("Converting file {0} into {1}", InputFile, conformOutputFile);

                            Converter.Convert(xlsDoc, spreadx);

                            DateTime end  = DateTime.Now;
                            TimeSpan diff = end.Subtract(start);
                            TraceLogger.Info("Conversion of file {0} finished in {1} seconds", InputFile, diff.TotalSeconds.ToString(CultureInfo.InvariantCulture));
                        }
                    }
                }
                catch (ParseException ex)
                {
                    TraceLogger.Error("Could not convert {0} because it was created by an unsupported application (Excel 95 or older).", InputFile);
                    TraceLogger.Debug(ex.ToString());
                }
                catch (DirectoryNotFoundException ex)
                {
                    TraceLogger.Error(ex.Message);
                    TraceLogger.Debug(ex.ToString());
                }
                catch (FileNotFoundException ex)
                {
                    TraceLogger.Error(ex.Message);
                    TraceLogger.Debug(ex.ToString());
                }
                catch (ZipCreationException ex)
                {
                    TraceLogger.Error("Could not create output file {0}.", ChoosenOutputFile);
                    TraceLogger.Debug(ex.ToString());
                }
                catch (Exception ex)
                {
                    TraceLogger.Error("Conversion of file {0} failed.", InputFile);
                    TraceLogger.Debug(ex.ToString());
                }
            }
        }
Exemplo n.º 27
0
        public static int Run(string project, string workspace, string msbuildPath, bool diffOnly, bool noBackup)
        {
            if (!string.IsNullOrWhiteSpace(project) && !string.IsNullOrWhiteSpace(workspace))
            {
                Console.WriteLine("Cannot specify both a project and a workspace.");
                return(-1);
            }

            try
            {
                msbuildPath = MSBuildHelpers.HookAssemblyResolveForMSBuild(msbuildPath);
                if (string.IsNullOrWhiteSpace(msbuildPath))
                {
                    Console.WriteLine("Could not find an MSBuild.");
                    return(-1);
                }

                var currentDirectory = Environment.CurrentDirectory;
                var workspacePath    = string.Empty;
                MSBuildWorkspaceType workspaceType;

                if (!string.IsNullOrWhiteSpace(project))
                {
                    workspacePath = Path.GetFullPath(project, Environment.CurrentDirectory);
                    workspaceType = MSBuildWorkspaceType.Project;
                }
                else if (!string.IsNullOrWhiteSpace(workspace))
                {
                    var(isSolution, workspaceFilePath) = MSBuildWorkspaceFinder.FindWorkspace(currentDirectory, workspace);
                    workspaceType = isSolution ? MSBuildWorkspaceType.Solution : MSBuildWorkspaceType.Project;
                    workspacePath = workspaceFilePath;
                }
                else
                {
                    throw new ArgumentException("No valid arguments to fulfill a workspace are given.");
                }

                var workspaceLoader  = new MSBuildWorkspaceLoader(workspacePath, workspaceType);
                var msbuildWorkspace = workspaceLoader.LoadWorkspace(workspacePath, noBackup);

                foreach (var item in msbuildWorkspace.WorkspaceItems)
                {
                    if (diffOnly)
                    {
                        var differ = new Differ(item.UnconfiguredProject.FirstConfiguredProject, item.SdkBaselineProject.Project.FirstConfiguredProject);
                        differ.GenerateReport(workspacePath);
                    }
                    else
                    {
                        var converter = new Converter(item.UnconfiguredProject, item.SdkBaselineProject, item.ProjectRootElement);
                        converter.Convert(item.ProjectRootElement.FullPath);
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                return(-1);
            }

            Console.WriteLine("Conversion complete!");
            return(0);
        }
Exemplo n.º 28
0
        public void Convert_SimpleObjectWithRepeatedColumns_ShouldThrowRepeatedColumnException(Converter sut)
        {
            //Setup
            var repeatedColumnName = "id";
            var columns = new List<string>() {
                repeatedColumnName,
                repeatedColumnName
            };
            var matrix = new List<List<object>>()
            {
                new List<object>() { 1, "name1" }
            };

            //Exercise
            Action exercise = () => sut.Convert(columns, matrix);

            //Verify
            exercise.ShouldThrow<ConverterRepeatedColumnException>()
                .Where(x => x.Message.Contains(repeatedColumnName));
        }
Exemplo n.º 29
0
 public void It_should_convert_it_to_expected_value(int input, string expected)
 {
     var sut = new Converter();
     string actual = sut.Convert(input);
     actual.Should().Be(expected);
 }
Exemplo n.º 30
0
 public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
 {
     return(Converter.Convert(value, convObj.GetType()));
 }
Exemplo n.º 31
0
        /// <summary>
        /// Translation In Xaml
        /// </summary>
        /// <param name="serviceProvider"></param>
        /// <returns></returns>
        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            IProvideValueTarget service = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;

            if (service == null)
            {
                return(this);
            }

            targetProperty = service.TargetProperty as DependencyProperty;
            targetObject   = service.TargetObject as DependencyObject;
            if (targetObject == null || targetProperty == null)
            {
                return(this);
            }

            try
            {
                if (string.IsNullOrEmpty(TextId))
                {
                    if (targetObject != null && targetProperty != null)
                    {
                        string context  = targetObject.GetContextByName();
                        string obj      = targetObject.FormatForTextId();
                        string property = targetProperty.ToString();

                        TextId = $"{context}.{obj}.{property}";
                    }
                    else if (!string.IsNullOrEmpty(DefaultText))
                    {
                        TextId = DefaultText;
                    }
                }
            }
            catch (InvalidCastException)
            {
                // For Xaml Design Time
                TextId = Guid.NewGuid().ToString();
            }

            if (IsDynamic)
            {
                Binding binding = new Binding("TranslatedText")
                {
                    Source = new TrData()
                    {
                        TextId      = TextId,
                        DefaultText = DefaultText,
                        LanguageId  = LanguageId,
                        Prefix      = Prefix,
                        Suffix      = Suffix
                    }
                };

                if (Converter != null)
                {
                    binding.Converter          = Converter;
                    binding.ConverterParameter = ConverterParameter;
                    binding.ConverterCulture   = ConverterCulture;
                }

                BindingOperations.SetBinding(targetObject, targetProperty, binding);

                return(binding.ProvideValue(serviceProvider));
            }
            else
            {
                object result = Prefix + TM.Tr(TextId, DefaultText, LanguageId) + Suffix;

                if (Converter != null)
                {
                    result = Converter.Convert(result, targetProperty.PropertyType, ConverterParameter, ConverterCulture);
                }

                return(result);
            }
        }
Exemplo n.º 32
0
 public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
 {
     return(Converter.Convert(convObj, destinationType));
 }
        /// <summary>
        ///     This function returns the properly prepared output of the markup extension.
        /// </summary>
        public object FormatOutput()
        {
            object result = null;

            if (_targetInfo == null)
            {
                return(null);
            }

            var targetObject = _targetInfo.TargetObject as DependencyObject;

            // Get target type. Change ImageSource to BitmapSource in order to use our own converter.
            var targetType = _targetInfo.TargetPropertyType;

            if (targetType == typeof(ImageSource))
            {
                targetType = typeof(BitmapSource);
            }

            // Try to get the localized input from the resource.
            string resourceKey = LocalizeDictionary.Instance.GetFullyQualifiedResourceKey(Key, targetObject);

            var ci = GetForcedCultureOrDefault();

            // Extract the names of the endpoint object and property
            var epName = "";
            var epProp = "";

            var element = targetObject as FrameworkElement;

            if (element != null)
            {
                epName = element.GetValueSync <string>(NameProperty);
            }
            else if (targetObject is FrameworkContentElement)
            {
                epName =
                    ((FrameworkContentElement)targetObject).GetValueSync <string>(FrameworkContentElement.NameProperty);
            }

            if (_targetInfo.TargetProperty is PropertyInfo)
            {
                epProp = ((PropertyInfo)_targetInfo.TargetProperty).Name;
            }

            else if (_targetInfo.TargetProperty is DependencyProperty)
            {
                epProp = ((DependencyProperty)_targetInfo.TargetProperty).Name;
            }

            // What are these names during design time good for? Any suggestions?
            if (epProp.Contains("FrameworkElementWidth5"))
            {
                epProp = "Height";
            }
            else if (epProp.Contains("FrameworkElementWidth6"))
            {
                epProp = "Width";
            }
            else if (epProp.Contains("FrameworkElementMargin12"))
            {
                epProp = "Margin";
            }

            var    resKeyBase     = ci.Name + ":" + targetType.Name + ":";
            string resKeyNameProp =
                LocalizeDictionary.Instance.GetFullyQualifiedResourceKey(
                    epName + LocalizeDictionary.GetSeparation(targetObject) + epProp,
                    targetObject);
            string resKeyName = LocalizeDictionary.Instance.GetFullyQualifiedResourceKey(epName, targetObject);

            // Check, if the key is already in our resource buffer.
            object input = null;

            if (!IsNullOrEmpty(resourceKey))
            {
                // We've got a resource key. Try to look it up or get it from the dictionary.
                lock (ResourceBufferLock)
                {
                    if (_resourceBuffer.ContainsKey(resKeyBase + resourceKey))
                    {
                        result = _resourceBuffer[resKeyBase + resourceKey];
                    }
                    else
                    {
                        input       = LocalizeDictionary.Instance.GetLocalizedObject(resourceKey, targetObject, ci);
                        resKeyBase += resourceKey;
                    }
                }
            }
            else
            {
                // Try the automatic lookup function.
                // First, look for a resource entry named: [FrameworkElement name][Separator][Property name]
                lock (ResourceBufferLock)
                {
                    if (_resourceBuffer.ContainsKey(resKeyBase + resKeyNameProp))
                    {
                        result = _resourceBuffer[resKeyBase + resKeyNameProp];
                    }
                    else
                    {
                        // It was not stored in the buffer - try to retrieve it from the dictionary.
                        input = LocalizeDictionary.Instance.GetLocalizedObject(resKeyNameProp, targetObject, ci);

                        if (input == null)
                        {
                            // Now, try to look for a resource entry named: [FrameworkElement name]
                            // Note - this has to be nested here, as it would take precedence over the first step in the buffer lookup step.
                            if (_resourceBuffer.ContainsKey(resKeyBase + resKeyName))
                            {
                                result = _resourceBuffer[resKeyBase + resKeyName];
                            }
                            else
                            {
                                input       = LocalizeDictionary.Instance.GetLocalizedObject(resKeyName, targetObject, ci);
                                resKeyBase += resKeyName;
                            }
                        }
                        else
                        {
                            resKeyBase += resKeyNameProp;
                        }
                    }
                }
            }

            // If no result was found, convert the input and add it to the buffer.
            if (result == null && input != null)
            {
                result = Converter.Convert(input, targetType, ConverterParameter, ci);
                SafeAddItemToResourceBuffer(resKeyBase, result);
            }

            return(result);
        }
Exemplo n.º 34
0
 /// <inheritdoc />
 public T Execute <T>(IDictionary <string, object> variables)
 {
     return(Converter.Convert <T>(Execute(variables)));
 }
Exemplo n.º 35
0
 public void ConvertFromTimeSpan()
 {
     TestHelper.AreEqual(9223372036854775807, Converter.Convert <long>(TimeSpan.MaxValue));
     TestHelper.AreEqual(-9223372036854775808, Converter.Convert <long>(TimeSpan.MinValue));
 }
Exemplo n.º 36
0
 /// <inheritdoc />
 public T Execute <T>(IVariableProvider variables = null)
 {
     return(Converter.Convert <T>(Execute(variables)));
 }
Exemplo n.º 37
0
		public bool DoTest(string sfmFileName, string mapFileName, string phase4KeyFileName, string locationOfFinalFile)
		{
			m_sfmName = sfmFileName;
			m_mapName = mapFileName;
			m_keyName = phase4KeyFileName;
			m_Phase5Output = locationOfFinalFile;

			Converter conv = new Converter();

			// read in the Lex Import Fields
			LexImportFields autoFields = new LexImportFields();
			autoFields.ReadLexImportFields(@"C:\fw\DistFiles\Language Explorer\Import\ImportFields.xml");
			// if there are auto fields in the xml file, pass them on to the converter
			Hashtable htAutoFields = autoFields.GetAutoFields();
			foreach (DictionaryEntry laf in htAutoFields)
			{
				string entryClass = laf.Key as String;
				LexImportField lexField = laf.Value as LexImportField;
				string fwDest = lexField.ID;
				conv.AddPossibleAutoField(entryClass, fwDest);
			}

			//// here the Auto import fields needs to be added to the converter as it is in the actual import process
			//conv.AddPossibleAutoField("Entry", "eires");
			//conv.AddPossibleAutoField("Sense", "sires");
			//conv.AddPossibleAutoField("Subentry", "seires");
			//conv.AddPossibleAutoField("Variant", "veires");

			conv.Convert(m_sfmName, m_mapName, m_phase1output);
			ProcessPhase1Errors();

			DoTransform(m_BuildPhase2XSLT, m_phase1output, m_Phase2XSLT);
			DoTransform(m_Phase2XSLT, m_phase1output, m_Phase2Output);
			DoTransform(m_Phase3XSLT, m_Phase2Output, m_Phase3Output);
#if true
			// put the phase4output in to the 'phase 5' file for comparing as there is no phase 5 now.
			DoTransform(m_Phase4XSLT, m_Phase3Output, m_Phase5Output);
			Microsoft.XmlDiffPatch.XmlDiff diff = new Microsoft.XmlDiffPatch.XmlDiff(
				Microsoft.XmlDiffPatch.XmlDiffOptions.IgnoreChildOrder |
				Microsoft.XmlDiffPatch.XmlDiffOptions.IgnoreComments |
				Microsoft.XmlDiffPatch.XmlDiffOptions.IgnoreWhitespace);
			bool same = diff.Compare(m_keyName, m_Phase5Output, false);

#else
			DoTransform(m_Phase4XSLT, m_Phase3Output, m_Phase4Output);

			// strip out the id and target attributes as the guids WILL be different
			DoTransform(m_Phase5XSLT, m_Phase4Output, m_Phase5Output);
			DoTransform(m_Phase5XSLT, m_keyName, m_KeyOutput);
			Microsoft.XmlDiffPatch.XmlDiff diff = new Microsoft.XmlDiffPatch.XmlDiff(
				Microsoft.XmlDiffPatch.XmlDiffOptions.IgnoreChildOrder |
				Microsoft.XmlDiffPatch.XmlDiffOptions.IgnoreComments |
				Microsoft.XmlDiffPatch.XmlDiffOptions.IgnoreWhitespace );
			bool same = diff.Compare(m_KeyOutput, m_Phase5Output, false);
#endif

			return same;
		}
 public override int Run(InterpretedFrame frame)
 {
     frame.Push(Converter.Convert(frame.Pop(), _type));
     return(+1);
 }
Exemplo n.º 39
0
        protected override Visual GetVisualChild(int index)
        {
            if ((Property == null) || (Objects == null))
            {
                MultiChecked = null;
            }
            else
            {
                var property = typeof(TextEditor).GetProperty(Property);
                var match    = Objects.Where(obj => obj.Active).Select(obj => property.GetValue(obj)).Select(value => Converter?.Convert(value, MultiValue.GetType(), null, CultureInfo.DefaultThreadCurrentCulture) ?? value).Select(value => value.Equals(MultiValue)).Distinct().ToList();
                MultiChecked = match.Count == 1 ? match.First() : default(bool?);
            }

            return(base.GetVisualChild(index));
        }
Exemplo n.º 40
0
 /// <inheritdoc />
 public async Task <T> ExecuteAsync <T>(IVariableProvider variables = null, CancellationToken cancellationtoken = new CancellationToken())
 {
     return(Converter.Convert <T>(await ExecuteAsync(variables, cancellationtoken)));
 }
Exemplo n.º 41
0
        public void Convert_SimpleObjectWithInvalidColumnName_ShouldThrowInvalidColumnException(Converter sut)
        {
            var invalidColumnName = "address..zipCode";
            //Setup
            var columns = new List<string>() {
                "id",
                invalidColumnName
            };
            var matrix = new List<List<object>>()
            {
                new List<object>() { 1, 2605 }
            };

            //Exercise
            Action exercise = () => sut.Convert(columns, matrix);

            //Verify
            exercise.ShouldThrow<ConverterInvalidColumnNameException>()
                .Where(x => x.Message.Contains(invalidColumnName));
        }
Exemplo n.º 42
0
 /// <summary>
 /// selects a value from the json structure
 /// </summary>
 /// <typeparam name="T">type of value to select</typeparam>
 /// <param name="path">path to node to select</param>
 /// <returns>typed value</returns>
 public T SelectSingle <T>(string path)
 {
     return(Converter.Convert <T>(SelectSingle(path)));
 }
Exemplo n.º 43
0
 public void ConvertFromSByte()
 {
     TestHelper.AreEqual(127, Converter.Convert <long>(sbyte.MaxValue));
     TestHelper.AreEqual(-128, Converter.Convert <long>(sbyte.MinValue));
 }
Exemplo n.º 44
0
 /// <summary>
 /// selects nodes using a path from a json node
 /// </summary>
 /// <param name="path">path to nodes to select</param>
 /// <returns>enumeration of nodes matching path</returns>
 public IEnumerable <T> Select <T>(string path)
 {
     return(Select(path).Select(n => Converter.Convert <T>(n)));
 }
 private static void CheckConversion(string html, string expected)
 {
     var converter = new Converter();
     var result = converter.Convert(html);
     Assert.Equal<string>(expected, result);
 }
Exemplo n.º 46
0
        public ActionResult SaveRecipe(PostedRecipeViewModel postedRecipeViewModel)
        {
            // NOTE: This action handles saving for both new recipes
            // and edited recipes.  New Recipes post to this action while
            // edits post to this action via Ajax.

            var isNewRecipe = false;

            // Hydrate JSON ReceipeViewModel
            var recipeViewModel = postedRecipeViewModel.HydrateRecipeJson();

            isNewRecipe = recipeViewModel.IsNewRecipe();

            // Validation (client validates also ... this to ensure data consistency)
            var validator        = new RecipeViewModelValidator();
            var validationResult = validator.Validate(recipeViewModel);

            if (!validationResult.IsValid)
            {
                if (isNewRecipe)
                {
                    this.AppendMessage(new ErrorMessage {
                        Text = "Did you leave something blank?  Please check your entries and try again."
                    });
                    ViewBag.RecipeCreationOptions = this.RecipeService.GetRecipeCreationOptions();
                    return(this.View("NewRecipe", recipeViewModel));
                }

                // Signals Invalid
                return(this.Content("0"));
            }

            using (var unitOfWork = this.UnitOfWorkFactory.NewUnitOfWork())
            {
                try
                {
                    var recipe = recipeViewModel.IsNewRecipe() ? new Recipe() : this.RecipeService.GetRecipeById(recipeViewModel.RecipeId);

                    // Issue 404 if recipe does not exists or not owned by user
                    if (!isNewRecipe && !recipe.WasCreatedBy(this.ActiveUser.UserId))
                    {
                        return(this.Issue404());
                    }

                    // Map Recipe
                    Mapper.Map(recipeViewModel, recipe);

                    #region INGREDIENT DELETIONS

                    if (!isNewRecipe)
                    {
                        // Delete Fermentables that were removed
                        var fermentablesForDeletion = recipe.Fermentables.Except(recipe.Fermentables.Join(recipeViewModel.Fermentables ?? new List <RecipeFermentableViewModel>(),
                                                                                                          x => x.RecipeFermentableId, y => Converter.Convert <int>(y.Id), (x, y) => x)).ToList();
                        this.RecipeService.MarkRecipeIngredientsForDeletion <RecipeFermentable>(fermentablesForDeletion);

                        // Delete Hops that were removed
                        var hopsForDeletion = recipe.Hops.Except(recipe.Hops.Join(recipeViewModel.Hops ?? new List <RecipeHopViewModel>(),
                                                                                  x => x.RecipeHopId, y => Converter.Convert <int>(y.Id), (x, y) => x)).ToList();
                        this.RecipeService.MarkRecipeIngredientsForDeletion <RecipeHop>(hopsForDeletion);

                        // Delete Yeasts that were removed
                        var yeastsForDeletion = recipe.Yeasts.Except(recipe.Yeasts.Join(recipeViewModel.Yeasts ?? new List <RecipeYeastViewModel>(),
                                                                                        x => x.RecipeYeastId, y => Converter.Convert <int>(y.Id), (x, y) => x)).ToList();
                        this.RecipeService.MarkRecipeIngredientsForDeletion <RecipeYeast>(yeastsForDeletion);

                        // Delete Adjuncts that were removed
                        var adjunctsForDeletion = recipe.Adjuncts.Except(recipe.Adjuncts.Join(recipeViewModel.Others ?? new List <RecipeOtherViewModel>(),
                                                                                              x => x.RecipeAdjunctId, y => Converter.Convert <int>(y.Id), (x, y) => x)).ToList();
                        this.RecipeService.MarkRecipeIngredientsForDeletion <RecipeAdjunct>(adjunctsForDeletion);

                        // Delete MashSteps that were removed
                        var mashStepsForDeletion = recipe.MashSteps.Except(recipe.MashSteps.Join(recipeViewModel.MashSteps ?? new List <RecipeMashStepViewModel>(),
                                                                                                 x => x.RecipeMashStepId, y => Converter.Convert <int>(y.Id), (x, y) => x)).ToList();
                        this.RecipeService.MarkRecipeIngredientsForDeletion <RecipeMashStep>(mashStepsForDeletion);
                    }

                    #endregion

                    #region INGREDIENT ADDITIONS

                    // Add Fermentables
                    if (recipeViewModel.Fermentables != null)
                    {
                        recipeViewModel.Fermentables.Where(x => Converter.Convert <int>(x.Id) == 0)
                        .ForEach(x => recipe.Fermentables.Add(Mapper.Map(x, new RecipeFermentable())));
                    }

                    // Add Hops
                    if (recipeViewModel.Hops != null)
                    {
                        recipeViewModel.Hops.Where(x => Converter.Convert <int>(x.Id) == 0)
                        .ForEach(x => recipe.Hops.Add(Mapper.Map(x, new RecipeHop())));
                    }

                    // Add Yeasts
                    if (recipeViewModel.Yeasts != null)
                    {
                        recipeViewModel.Yeasts.Where(x => Converter.Convert <int>(x.Id) == 0)
                        .ForEach(x => recipe.Yeasts.Add(Mapper.Map(x, new RecipeYeast())));
                    }

                    // Add Adjuncts
                    if (recipeViewModel.Others != null)
                    {
                        recipeViewModel.Others.Where(x => Converter.Convert <int>(x.Id) == 0)
                        .ForEach(x => recipe.Adjuncts.Add(Mapper.Map(x, new RecipeAdjunct())));
                    }

                    // Add MashStep
                    if (recipeViewModel.MashSteps != null)
                    {
                        recipeViewModel.MashSteps.Where(x => Converter.Convert <int>(x.Id) == 0)
                        .ForEach(x => recipe.MashSteps.Add(Mapper.Map(x, new RecipeMashStep())));
                    }

                    #endregion

                    #region INGREDIENT UPDATES

                    if (!isNewRecipe)
                    {
                        // Update Fermentables
                        if (recipeViewModel.Fermentables != null)
                        {
                            foreach (var recipeFermentableViewModel in recipeViewModel.Fermentables.Where(x => Converter.Convert <int>(x.Id) > 0))
                            {
                                var match = recipe.Fermentables.FirstOrDefault(x => x.RecipeFermentableId == Converter.Convert <int>(recipeFermentableViewModel.Id));
                                if (match == null)
                                {
                                    throw new InvalidOperationException("Unable to find matching fermentable");
                                }

                                Mapper.Map(recipeFermentableViewModel, match);
                            }
                        }

                        // Update Hops
                        if (recipeViewModel.Hops != null)
                        {
                            foreach (var recipeHopViewModel in recipeViewModel.Hops.Where(x => Converter.Convert <int>(x.Id) > 0))
                            {
                                var match = recipe.Hops.FirstOrDefault(x => x.RecipeHopId == Converter.Convert <int>(recipeHopViewModel.Id));
                                if (match == null)
                                {
                                    throw new InvalidOperationException("Unable to find matching Hop");
                                }

                                Mapper.Map(recipeHopViewModel, match);
                            }
                        }

                        // Update Yeasts
                        if (recipeViewModel.Yeasts != null)
                        {
                            foreach (var recipeYeastViewModel in recipeViewModel.Yeasts.Where(x => Converter.Convert <int>(x.Id) > 0))
                            {
                                var match = recipe.Yeasts.FirstOrDefault(x => x.RecipeYeastId == Converter.Convert <int>(recipeYeastViewModel.Id));
                                if (match == null)
                                {
                                    throw new InvalidOperationException("Unable to find matching Yeast");
                                }

                                Mapper.Map(recipeYeastViewModel, match);
                            }
                        }

                        // Update Adjuncts
                        if (recipeViewModel.Others != null)
                        {
                            foreach (var recipeAdjunctViewModel in recipeViewModel.Others.Where(x => Converter.Convert <int>(x.Id) > 0))
                            {
                                var match = recipe.Adjuncts.FirstOrDefault(x => x.RecipeAdjunctId == Converter.Convert <int>(recipeAdjunctViewModel.Id));
                                if (match == null)
                                {
                                    throw new InvalidOperationException("Unable to find matching Adjunct");
                                }

                                Mapper.Map(recipeAdjunctViewModel, match);
                            }
                        }

                        // Update MashSteps
                        if (recipeViewModel.MashSteps != null)
                        {
                            foreach (var recipeMashStepViewModel in recipeViewModel.MashSteps.Where(x => Converter.Convert <int>(x.Id) > 0))
                            {
                                var match = recipe.MashSteps.FirstOrDefault(x => x.RecipeMashStepId == Converter.Convert <int>(recipeMashStepViewModel.Id));
                                if (match == null)
                                {
                                    throw new InvalidOperationException("Unable to find matching MashStep");
                                }

                                Mapper.Map(recipeMashStepViewModel, match);
                            }
                        }
                    }

                    #endregion

                    #region STEP DELETIONS / ADDITIONS / UPDATES

                    // Deletions
                    if (!isNewRecipe)
                    {
                        var stepsForDeletion = recipe.Steps.Except(recipe.Steps.Join(recipeViewModel.Steps ?? new List <RecipeStepViewModel>(),
                                                                                     x => x.RecipeStepId, y => Converter.Convert <int>(y.Id), (x, y) => x)).ToList();
                        this.RecipeService.MarkRecipeStepsForDeletion(stepsForDeletion);
                    }

                    // Additions
                    if (recipeViewModel.Steps != null)
                    {
                        if (recipe.Steps == null)
                        {
                            recipe.Steps = new List <RecipeStep>();
                        }

                        recipeViewModel.GetSteps()
                        .Where(x => Converter.Convert <int>(x.Id) == 0)
                        .Where(x => !string.IsNullOrWhiteSpace(x.Text))
                        .ForEach(x => recipe.Steps.Add(Mapper.Map(x, new RecipeStep {
                            DateCreated = DateTime.Now
                        })));
                    }

                    // Updates
                    if (!isNewRecipe)
                    {
                        if (recipeViewModel.Steps != null)
                        {
                            foreach (var recipeStep in recipeViewModel.GetSteps()
                                     .Where(x => Converter.Convert <int>(x.Id) > 0)
                                     .Where(x => !string.IsNullOrWhiteSpace(x.Text)))
                            {
                                var match = recipe.Steps.FirstOrDefault(x => x.RecipeStepId == Converter.Convert <int>(recipeStep.Id));
                                if (match == null)
                                {
                                    throw new InvalidOperationException("Unable to find matching step");
                                }

                                match = Mapper.Map(recipeStep, match);
                                match.DateModified = DateTime.Now;
                            }
                        }
                    }

                    #endregion

                    // Save the Image
                    if (isNewRecipe)
                    {
                        if (recipeViewModel.PhotoForUpload != null)
                        {
                            // Save the New Image
                            recipe.ImageUrlRoot = this.StaticContentService.SaveRecipeImage(recipeViewModel.PhotoForUpload.InputStream,
                                                                                            this.WebSettings.MediaPhysicalRoot);
                        }
                    }

                    // Finalize Recipe
                    this.RecipeService.FinalizeRecipe(recipe);

                    unitOfWork.Commit();

                    if (isNewRecipe)
                    {
                        this.ForwardMessage(new SuccessMessage {
                            Text = BrewgrMessages.RecipeSaved
                        });
                        return(Redirect(Url.RecipeEditUrl(recipe.RecipeId)));
                    }
                    else
                    {
                        // Signals Success
                        return(Content("1"));
                    }
                }
                catch (Exception ex)
                {
                    this.LogHandledException(ex);
                    unitOfWork.Rollback();

                    if (isNewRecipe)
                    {
                        ViewBag.RecipeCreationOptions = this.RecipeService.GetRecipeCreationOptions();
                        this.AppendMessage(new ErrorMessage {
                            Text = GenericMessages.ErrorMessage
                        });
                        return(View("NewRecipe", recipeViewModel));
                    }
                    else
                    {
                        // Signals Failure
                        return(Content("-1"));
                    }
                }
            }
        }
Exemplo n.º 47
0
        public void TransitiveConversion()
        {
            string targetValue = (string)Converter.Convert(42, typeof(string));

            Assert.AreEqual("42", targetValue);
        }
Exemplo n.º 48
0
        // CUIモード
        static int CUIExec(bool q, List <string> files)
        {
            IOutputController Output = new CUIOutput(q);

            if (files.Count == 0)
            {
                Console.WriteLine(Properties.Resources.NOINPUTFILE);
                return(-5);
            }
            try {
                Directory.CreateDirectory(Path.GetTempPath());
            }
            catch (Exception) {
                Console.WriteLine(String.Format(Properties.Resources.FAIL_TMPFOLDER, Path.GetTempPath()));
                return(-7);
            }

            int failnum = 0;

            var outFiles = new System.Collections.Specialized.StringCollection();

            for (int i = 0; i < files.Count / 2; ++i)
            {
                string file = Path.GetFullPath(files[2 * i]);
                string dir;
                if (Properties.Settings.Default.workingDirectory == "file")
                {
                    dir = Path.GetDirectoryName(file);
                }
                else if (Properties.Settings.Default.workingDirectory == "current")
                {
                    dir = Directory.GetCurrentDirectory();
                }
                else
                {
                    dir = Path.GetTempPath();
                }
                string tmpTeXFileName = TempFilesDeleter.GetTempFileName(Path.GetExtension(file), dir);
                if (tmpTeXFileName == null)
                {
                    Console.WriteLine(String.Format(Properties.Resources.FAIL_TMPFILE, Path.GetTempPath()));
                    return(-6);
                }
                tmpTeXFileName = Path.Combine(dir, tmpTeXFileName);
                // 一時フォルダにコピー
                File.Copy(file, tmpTeXFileName, true);
                (new FileInfo(tmpTeXFileName)).Attributes = FileAttributes.Normal;
                var output = Path.GetFullPath(files[2 * i + 1]);
                // 変換!
                try {
                    using (var converter = new Converter(Output, tmpTeXFileName, output)) {
                        converter.AddInputPath(Path.GetDirectoryName(file));
                        if (!converter.Convert())
                        {
                            ++failnum;
                        }
                        else
                        {
                            outFiles.AddRange(converter.OutputFileNames.ToArray());
                        }
                    }
                    if (Properties.Settings.Default.setFileToClipBoard)
                    {
                        Clipboard.SetFileDropList(outFiles);
                    }
                }
                catch (Exception e) { Console.WriteLine(e.Message); }
            }
            return(failnum);
        }
Exemplo n.º 49
0
 /// <inheritdoc />
 public async Task <T> ExecuteAsync <T>(IDictionary <string, object> variables, CancellationToken cancellationtoken = new CancellationToken())
 {
     return(Converter.Convert <T>(await ExecuteAsync(variables, cancellationtoken)));
 }
 internal static TTo Convert <TFrom, TTo>(TFrom value)
 {
     return(Converter <TFrom, TTo> .Convert(value));
 }