Exemplo n.º 1
0
        public override void OnExecute(object sender)
        {
            var editor = GetMarkdownEditor();

            if (editor == null)
            {
                return;
            }

            var gist = new GistItem()
            {
                code     = editor.AceEditor.getselection(false),
                language = "cs"
            };

            PasteCodeAsGistWindow       = new PasteCodeAsGitWindow(this);
            PasteCodeAsGistWindow.Owner = Model.Window;
            PasteCodeAsGistWindow.Gist  = gist;
            PasteCodeAsGistWindow.ShowDialog();

            if (PasteCodeAsGistWindow.Cancelled)
            {
                return;
            }

            if (!string.IsNullOrEmpty(gist.embedUrl))
            {
                editor.SetSelectionAndFocus($"<script src=\"{gist.embedUrl}\"></script>\r\n");
            }

            Model.Window.ShowStatus("Gist embedded", 5000);
            Model.Window.SetStatusIcon(FontAwesomeIcon.GithubAlt, Colors.Green);
        }
        /// <summary>
        /// Retrieves a list of recent gists from a given user
        /// </summary>
        /// <param name="userId"></param>
        public static async Task <List <GistItem> > ListGistsForUserAsync(string userId, string githubToken = null)
        {
            var settings = new HttpRequestSettings
            {
                Url      = GistUrl + $"/users/{userId}/gists?per_page=100",
                HttpVerb = "GET"
            };

            settings.Headers.Add("User-agent", "Markdown Monster Markdown Editor Gist Add-in");
            settings.Headers.Add("Accept", "application/json");

            if (!string.IsNullOrEmpty(githubToken))
            {
                settings.Headers.Add("Authorization", "token " + githubToken);
            }

            List <GistItem> gists = new List <GistItem>();

            try
            {
                var giststructs = await HttpUtils.JsonRequestAsync <List <GistStructure> >(settings);

                foreach (var giststruct in giststructs)
                {
                    var file = giststruct.files.FirstOrDefault().Value;

                    var gist = new GistItem()
                    {
                        description = giststruct.description,
                        filename    = file.filename,
                        rawUrl      = giststruct.url,
                        htmlUrl     = giststruct.html_url,
                        username    = giststruct.owner?.login,
                        isPublic    = giststruct._public,
                        updated     = giststruct.updated_at,
                        id          = giststruct.id
                    };
                    if (string.IsNullOrEmpty(gist.username))
                    {
                        gist.isAnonymous = true;
                    }

                    gists.Add(gist);
                }
            }
            catch (Exception ex)
            {
                var gist = new GistItem()
                {
                    hasError     = true,
                    errorMessage = "Gist retrieval failed: " + ex.Message
                };
                gists.Add(gist);
            }

            return(gists);
        }
        /// <summary>
        /// Retrieves a Gist from the server
        /// </summary>
        /// <param name="gistId"></param>
        /// <param name="githubToken"></param>
        /// <returns></returns>
        public static GistItem GetGistFromServer(string gistId, string githubToken = null)
        {
            var settings = new HttpRequestSettings
            {
                Url      = GistUrl + "/gists/" + gistId,
                HttpVerb = "GET"
            };

            settings.Headers.Add("User-agent", "Markdown Monster Markdown Editor Gist Add-in");
            settings.Headers.Add("Accept", "application/json");

            if (!string.IsNullOrEmpty(githubToken))
            {
                settings.Headers.Add("Authorization", "token " + githubToken);
            }

            GistItem gist;

            try
            {
                var giststruct = HttpUtils.JsonRequest <GistStructure>(settings);

                var file = giststruct.files.FirstOrDefault().Value;

                gist = new GistItem()
                {
                    description = giststruct.description,
                    code        = file.content,
                    filename    = file.filename,
                    rawUrl      = giststruct.url,
                    htmlUrl     = giststruct.html_url,
                    username    = giststruct.owner?.login,
                    isPublic    = giststruct._public,
                    updated     = giststruct.updated_at,
                    id          = giststruct.id
                };
                if (string.IsNullOrEmpty(gist.username))
                {
                    gist.isAnonymous = true;
                }
            }
            catch (Exception ex)
            {
                gist = new GistItem()
                {
                    hasError     = true,
                    errorMessage = "Gist retrieval failed: " + ex.Message
                };
            }

            return(gist);
        }
        /// <summary>
        /// Creates a JSON object from a Gist that contains only
        /// partial Gist data required to post to a server
        /// </summary>
        /// <param name="gist"></param>
        /// <returns></returns>
        public static JObject CreateGistPostJson(GistItem gist)
        {
            dynamic obj = new JObject();

            obj.Add("description", new JValue(gist.description));
            obj.Add("public", gist.isPublic);
            obj.Add("files", new JObject());

            obj.files.Add(gist.filename, new JObject());

            var fileObj = obj.files[gist.filename];

            fileObj.content = gist.code;

            return(obj);
        }
        /// <summary>
        /// Updates an existing Gist
        /// </summary>
        /// <param name="gist"></param>
        /// <param name="githubUserToken"></param>
        /// <returns></returns>
        public static GistItem UpdateGist(GistItem gist, string githubUserToken = null)
        {
            if (string.IsNullOrEmpty(githubUserToken))
            {
                githubUserToken = PasteCodeAsGistConfiguration.Current.GithubUserToken;
            }

            var json = CreateGistPostJson(gist);

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

            var settings = new HttpRequestSettings
            {
                Url         = GistUrl + $"/gists/{gist.id}",
                HttpVerb    = "PATCH",
                Content     = json.ToString(),
                ContentType = "application/json; charset=utf-8;"
            };

            settings.Headers.Add("User-agent", "Markdown Monster Markdown Editor Gist Add-in");
            settings.Headers.Add("Accept", "application/json");

            if (!gist.isAnonymous && !string.IsNullOrEmpty(githubUserToken))
            {
                settings.Headers.Add("Authorization", "token " + githubUserToken);
            }

            string result = null;

            try
            {
                result = HttpUtils.HttpRequestString(settings);
            }
            catch (Exception ex)
            {
                gist.hasError     = true;
                gist.errorMessage = "Gist upload failed: " + ex.Message;
                return(gist);
            }

            dynamic jsn = JValue.Parse(result);

            gist.htmlUrl = jsn.html_url;
            gist.id      = jsn.id;


            JObject   files    = jsn.files;
            JProperty fileProp = files.First as JProperty;
            dynamic   fileObj  = fileProp.Value as JObject;

            gist.rawUrl   = fileObj.raw_url;
            gist.filename = fileObj.filename;

            dynamic user = jsn.owner;

            if (user != null)
            {
                gist.username = user.login;
            }

            return(gist);
        }