public void RequestFactoryTest()
        {
            Service target = new Service(); // TODO: Initialize to an appropriate value
            IGDataRequestFactory expected = new GDataGAuthRequestFactory("cl", "test");
            IGDataRequestFactory actual;

            target.RequestFactory = expected;
            actual = target.RequestFactory;
            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 2
0
        //////////////////////////////////////////////////////////////////////
        /// <summary>the setup method</summary>
        //////////////////////////////////////////////////////////////////////
        [SetUp] public override void InitTest()
        {
            base.InitTest();
            GDataGAuthRequestFactory authFactory = this.factory as GDataGAuthRequestFactory;

            if (authFactory != null)
            {
                authFactory.Handler = this.strAuthHandler;
            }
        }
        public List <PicasaWebAlbum> QueryAlbums(BackgroundWorker worker, int overallJobPercent)
        {
            // Create an authentication factory to deal with logging in.
            GDataGAuthRequestFactory authFactory = new GDataGAuthRequestFactory("lh2", this.m_serviceName);

            authFactory.AccountType = "GOOGLE_OR_HOSTED";


            this.m_albumQuery                  = new AlbumQuery(PicasaQuery.CreatePicasaUri("default"));
            this.m_albumQuery.Access           = PicasaQuery.AccessLevel.AccessAll;
            this.m_albumService                = new PicasaService(authFactory.ApplicationName);
            this.m_albumService.RequestFactory = authFactory;
            // this.m_albumService.setUserCredentials(this.m_userName, this.m_password);
            //string token = this.m_albumService.QueryAuthenticationToken();
            this.m_albumService.SetAuthenticationToken(this.mUserToken);
            List <PicasaWebAlbum> retval = new List <PicasaWebAlbum>();
            decimal count      = ((decimal)overallJobPercent / 100) * 10;
            int     smallCount = (int)count;

            try
            {
                worker.ReportProgress(0, (object)"Creating proxy");
                CreateAlbumProxy();
                worker.ReportProgress(smallCount, (object)"Proxy created");
                worker.ReportProgress(0, (object)"Querying google");
                this.m_albumFeed = this.m_albumService.Query(this.m_albumQuery);
                worker.ReportProgress(smallCount, (object)"Done");
            }
            catch (Exception e)
            {
                this.m_albumQuery = null;
                this.m_albumService.RequestFactory = null;
                this.m_albumService = null;
                this.m_albumFeed    = null;
                retval = null;
                throw new Exception("PicasaReader failed when downloading album feed for " + this.m_userName, e);
            }
            if (this.m_albumFeed.Entries.Count > 0)
            {
                int percent = (int)Math.Round((decimal)((overallJobPercent - (smallCount * 2)) / this.m_albumFeed.Entries.Count), 0);
                worker.ReportProgress(0, (object)"Processing album data");
                foreach (PicasaEntry entry in this.m_albumFeed.Entries)
                {
                    AlbumAccessor ac = new AlbumAccessor(entry);

                    retval.Add(new PicasaWebAlbum(entry.Title.Text, entry.Updated, ac.NumPhotos, Convert.ToUInt64(ac.Id)));
                    worker.ReportProgress(percent, null);
                }
            }
            this.m_albumQuery = null;
            this.m_albumService.RequestFactory = null;
            this.m_albumService = null;
            this.m_albumFeed    = null;
            return(retval);
        }
Ejemplo n.º 4
0
        //////////////////////////////////////////////////////////////////////
        /// <summary>the setup method</summary>
        //////////////////////////////////////////////////////////////////////
        [SetUp] public override void InitTest()
        {
            base.InitTest();
            GDataGAuthRequestFactory authFactory = this.factory as GDataGAuthRequestFactory;

            if (authFactory != null)
            {
                authFactory.Handler = this.strAuthHandler;
            }
            FeedCleanup(this.bloggerURI, this.userName, this.passWord, VersionDefaults.Major);
        }
        public void StrictRedirectTest()
        {
            string service                  = "TestValue";                                            // TODO: Initialize to an appropriate value
            string applicationName          = "TestValue";                                            // TODO: Initialize to an appropriate value
            GDataGAuthRequestFactory target = new GDataGAuthRequestFactory(service, applicationName); // TODO: Initialize to an appropriate value
            bool expected = true;                                                                     // TODO: Initialize to an appropriate value
            bool actual;

            target.StrictRedirect = expected;
            actual = target.StrictRedirect;
            Assert.AreEqual(expected, actual);
        }
        /// <summary>
        /// notifier if someone changes the requestfactory of the service
        /// </summary>
        public override void OnRequestFactoryChanged()
        {
            base.OnRequestFactoryChanged();
            GDataGAuthRequestFactory factory = this.RequestFactory as GDataGAuthRequestFactory;

            if (factory != null && this.developerID != null)
            {
                RemoveOldKeys(factory.CustomHeaders);
                factory.CustomHeaders.Add(GoogleAuthentication.YouTubeDevKey + this.developerID);
                factory.Handler = YouTubeService.AuthenticationHandler;
            }
        }
        public void NumberOfRetriesTest()
        {
            string service                  = "TestValue";                                            // TODO: Initialize to an appropriate value
            string applicationName          = "TestValue";                                            // TODO: Initialize to an appropriate value
            GDataGAuthRequestFactory target = new GDataGAuthRequestFactory(service, applicationName); // TODO: Initialize to an appropriate value
            int expected = 2;                                                                         // TODO: Initialize to an appropriate value
            int actual;

            target.NumberOfRetries = expected;
            actual = target.NumberOfRetries;
            Assert.AreEqual(expected, actual);
        }
        public void UserAgentTest()
        {
            string service                  = "TestValue";                                            // TODO: Initialize to an appropriate value
            string applicationName          = "TestValue";                                            // TODO: Initialize to an appropriate value
            GDataGAuthRequestFactory target = new GDataGAuthRequestFactory(service, applicationName); // TODO: Initialize to an appropriate value
            string expected                 = "TestValue";
            string actual;

            target.UserAgent = expected;
            actual           = target.UserAgent;
            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 9
0
        //static string user1name = ConfigurationManager.AppSettings["CalendarUser1"].ToString();
        //static string user1pwd = ConfigurationManager.AppSettings["Calendarpass1"].ToString();
        public static void AddEvent1(CalendarService service, string id, string title, string contents, string location, DateTime startTime, DateTime endTime, string calendarName, string emailId)
        {
            try
            {
                Google.GData.Calendar.EventEntry entry = new Google.GData.Calendar.EventEntry();
                // Set the title and content of the entry.
                entry.Title.Text      = id + "-" + title;
                entry.Content.Content = contents;

                // Set a location for the event.
                Where eventLocation = new Where();
                eventLocation.ValueString = location;
                entry.Locations.Add(eventLocation);

                When eventTime = new When(startTime, endTime);
                entry.Times.Add(eventTime);
                GoogleCalendar ggadmin = new GoogleCalendar(calendarName, AdminuserName, AdminuserPwd);
                // string CalendarId = ggadmin.GetCalendarId();

                //CalendarService Calservice = new CalendarService("CalendarSampleApp");
                AclEntry aclEntry = new AclEntry();

                aclEntry.Scope       = new AclScope();
                aclEntry.Scope.Type  = AclScope.SCOPE_USER;
                aclEntry.Scope.Value = emailId;
                aclEntry.Role        = AclRole.ACL_CALENDAR_READ;
                // Uri postUri = new Uri("https://www.google.com/calendar/feeds/" + CalendarId + "/private/full");

                Uri aclUri = new Uri(string.Format("https://www.google.com/calendar/feeds/{0}/acl/full", service.Credentials.Username.ToString()));



                GDataGAuthRequestFactory requestFactory = (GDataGAuthRequestFactory)service.RequestFactory;
                IWebProxy iProxy  = WebRequest.GetSystemWebProxy();
                WebProxy  myProxy = new WebProxy();
                // potentially, setup credentials on the proxy here
                myProxy.Credentials           = CredentialCache.DefaultCredentials;
                myProxy.UseDefaultCredentials = false;

                // requestFactory.CreateRequest(GDataRequestType.Insert, postUri);//  = myProxy;
                // Send the request and receive the response:
                //AtomEntry insertEntry = service.Insert(postUri, entry);

                AclEntry insertedEntry = service.Insert(aclUri, aclEntry) as AclEntry;
            }
            catch (Exception ex)
            {
                //LogManager.Instance.WriteToFlatFile(ex.Message);
            }
        }
        /// <summary>
        /// notifier if someone changes the requestfactory of the service
        /// </summary>
        public override void OnRequestFactoryChanged()
        {
            base.OnRequestFactoryChanged();
            GDataGAuthRequestFactory factory = this.RequestFactory as GDataGAuthRequestFactory;

            if (factory != null && this.devKey != null)
            {
                RemoveWebKey(factory.CustomHeaders);
                factory.CustomHeaders.Add(GoogleAuthentication.WebKey + this.devKey);
                if (this.authHandlerSet == true)
                {
                    factory.Handler = this.authHandler == null ? null : this.authHandler.ToString();
                }
            }
        }
Ejemplo n.º 11
0
        public AnalyticsProxy(GDataGAuthRequestFactory request)
        {
            this.ProxyAddress = Settings.Default.ProxyUrl;

            if (ProxyAddress.Length == 0)
            {
                request.Proxy = MyProxy;
            }
            else
            {
                this.UserName = Settings.Default.AnalyticsProxyUsername;
                this.Password = Settings.Default.AnalyticsProxyPassword;
                this.NewUri   = new Uri(ProxyAddress);
                MyProxy       = new WebProxy();
                MyProxy.GetProxy(NewUri);
                MyProxy.Credentials = new NetworkCredential(UserName, Password);
                request.Proxy       = MyProxy;
            }
        }
Ejemplo n.º 12
0
        public List <String> getProfileIdList()
        {
            try
            {
                List <String>            profilesIdList = new List <String>();
                GDataGAuthRequestFactory requestFactory = new GDataGAuthRequestFactory("analytics", "GTGATracker");
                requestFactory.AccountType = "GOOGLE";
                AnalyticsProxy             = new AnalyticsProxy(requestFactory);
                this.RequestFactory        = requestFactory;
                this.setUserCredentials(GetEmail(), GetPassword());
                string        queri           = ConfigurationManager.AppSettings["FeedAccountsUri"] + ConfigurationManager.AppSettings["API_Key"];
                string        webProfileId    = "";
                string        webPropertie    = "";
                string        profileIdUrl    = "";
                List <String> webProfilesList = new List <String>();
                List <String> idList          = new List <String>();
                DataQuery     query           = new DataQuery(queri);
                DataFeed      feedWebProperty = this.Query(query);
                foreach (AtomEntry entry in feedWebProperty.Entries)
                {
                    webProfileId = entry.Links[1].HRef.Content;
                    DataQuery propertyQuery = new DataQuery(webProfileId);
                    DataFeed  feedProfile   = this.Query(propertyQuery);
                    foreach (DataEntry entri in feedProfile.Entries)
                    {
                        webPropertie = entri.Links[2].HRef.Content;
                        DataQuery profileIdQuery = new DataQuery(webPropertie);
                        DataFeed  feedProfileId  = this.Query(profileIdQuery);
                        foreach (DataEntry entrie in feedProfileId.Entries)
                        {
                            idList.Add(entrie.Links[0].HRef.Content);
                            profileIdUrl = entrie.Links[0].HRef.Content;
                        }
                    }
                }

                return(idList);
            }
            catch (GDataRequestException e)
            {
                throw e;
            }
        }
        /*  public string LoginToGoogle(out string token)
         * {
         *    GDataGAuthRequestFactory authFactory = new GDataGAuthRequestFactory("lh2", this.m_serviceName);
         *    authFactory.AccountType = "GOOGLE_OR_HOSTED";
         *
         *    this.m_albumService = new PicasaService(authFactory.ApplicationName);
         *    try
         *    {
         *        this.m_albumService.setUserCredentials(this.m_userName, this.m_password);
         *        this.m_albumService.QueryAuthenticationToken(); // Authenticate the user immediately
         *    }
         *    catch (CaptchaRequiredException e)
         *    {
         *        token = e.Token;
         *        return e.Url;
         *    }
         * }
         *
         * public string LoginToGoogle(out string token, string CAPTCHAAnswer, string CAPTCHAToken)
         * {
         *    GDataGAuthRequestFactory authFactory = new GDataGAuthRequestFactory("lh2", this.m_serviceName);
         *    authFactory.AccountType = "GOOGLE_OR_HOSTED";
         *    string token = string.Empty;
         *    this.m_albumService = new PicasaService(authFactory.ApplicationName);
         *    authFactory.CaptchaAnswer = CAPTCHAAnswer;
         *    authFactory.CaptchaToken = CAPTCHAToken;
         *    this.m_albumService.setUserCredentials(this.m_userName, this.m_password);
         *
         *    token = this.m_albumService.QueryAuthenticationToken(); // Authenticate the user immediately
         *    return token;
         *
         *
         * }
         */
        public List <PicasaWebAlbum> QueryAlbums()
        {
            // Create an authentication factory to deal with logging in.
            GDataGAuthRequestFactory authFactory = new GDataGAuthRequestFactory("lh2", this.m_serviceName);

            authFactory.AccountType = "GOOGLE_OR_HOSTED";

            this.m_albumService = new PicasaService(authFactory.ApplicationName);
            this.m_albumService.RequestFactory = authFactory;
            this.m_albumService.SetAuthenticationToken(this.mUserToken);


            this.m_albumQuery        = new AlbumQuery(PicasaQuery.CreatePicasaUri("default"));
            this.m_albumQuery.Access = PicasaQuery.AccessLevel.AccessAll;


            List <PicasaWebAlbum> retval = new List <PicasaWebAlbum>();

            try
            {
                CreateAlbumProxy();
                this.m_albumFeed = this.m_albumService.Query(this.m_albumQuery);
            }
            catch (Exception e)
            {
                this.m_albumQuery = null;
                this.m_albumService.RequestFactory = null;
                this.m_albumService = null;
                this.m_albumFeed    = null;
                retval = null;
                throw new Exception("PicasaReader failed when downloading album feed for " + this.m_userName, e);
            }
            foreach (PicasaEntry entry in this.m_albumFeed.Entries)
            {
                AlbumAccessor ac = new AlbumAccessor(entry);
                retval.Add(new PicasaWebAlbum(entry.Title.Text, entry.Updated, ac.NumPhotos, Convert.ToUInt64(ac.Id)));
            }
            this.m_albumQuery = null;
            this.m_albumService.RequestFactory = null;
            this.m_albumService = null;
            this.m_albumFeed    = null;
            return(retval);
        }
Ejemplo n.º 14
0
        private void button1_Click(object sender, EventArgs e)
        {
            string CLIENT_ID     = "978724980491-bvs462ns4r1p81g5vjcji6ue1cg5e5nd.apps.googleusercontent.com";
            string CLIENT_SECRET = "Zf-TZntewp7gF23Rg3xzV8Jl";
            //string SCOPE = "https://spreadsheets.google.com/feeds https://docs.google.com/feeds";
            string REDIRECT_URI = "urn:ietf:wg:oauth:2.0:oob";

            var parameters = new OAuth2Parameters()
            {
                //Client
                ClientId     = CLIENT_ID,
                ClientSecret = CLIENT_SECRET,
                RedirectUri  = REDIRECT_URI,
                Scope        = "https://www.google.com/m8/feeds",
                ResponseType = "code"
            };

            //User clicks this auth url and will then be sent to your redirect url with a code parameter
            var authorizationUrl = OAuthUtil.CreateOAuth2AuthorizationUrl(parameters);



            Service service = new Service("blogger", "");

            service.Credentials = new GDataCredentials("*****@*****.**", "1q2w3e4r!@#");
            GDataGAuthRequestFactory factory = (GDataGAuthRequestFactory)service.RequestFactory;

            factory.AccountType = "GOOGLE";

            AtomEntry newPost = new AtomEntry();

            newPost.Title.Text      = "Test";
            newPost.Content         = new AtomContent();
            newPost.Content.Content = "Testpostssssssssssssssssssssss";
            newPost.Content.Type    = "xhtml";
            // newPost.IsDraft = true;

            string    blogID       = "6927940079287773210";
            Uri       blogFeedUri  = new Uri("http://www.blogger.com/feeds/" + blogID + "/posts/default");
            AtomEntry createdEntry = service.Insert(blogFeedUri, newPost);
        }
        public List <PicasaWebPhoto> QueryPhoto(string tags)
        {
            List <PicasaWebPhoto>    retval      = new List <PicasaWebPhoto>();
            GDataGAuthRequestFactory authFactory = new GDataGAuthRequestFactory("lh2", this.m_serviceName);

            authFactory.AccountType = "GOOGLE_OR_HOSTED";
            this.m_photoQuery       = new PhotoQuery(PicasaQuery.CreatePicasaUri(this.m_userName, this.m_albumName));
            this.m_photoQuery.Tags  = tags;

            this.m_photoService = new PicasaService(authFactory.ApplicationName);
            this.m_photoService.RequestFactory = authFactory;
            //this.m_photoService.setUserCredentials(this.m_userName, this.m_password);
            this.m_photoService.SetAuthenticationToken(this.mUserToken);



            CreatePhotoProxy();
            try
            {
                this.m_photoFeed = this.m_photoService.Query(this.m_photoQuery);

                foreach (PicasaEntry photo in this.m_photoFeed.Entries)
                {
                    retval.Add(new PicasaWebPhoto(photo, this.m_albumName));
                }
            }
            catch (Exception e)
            {
                throw new Exception("Query Photo Exception", e);
            }
            finally
            {
                this.m_photoQuery = null;
                this.m_photoService.RequestFactory = null;
                this.m_photoService = null;
                this.m_photoFeed    = null;
            }


            return(retval);
        }
Ejemplo n.º 16
0
        // Validates a username/pass by attempting to login to calendar
        public static bool checkPw(string username, string password)
        {
            GDataGAuthRequestFactory authFactory = new GDataGAuthRequestFactory("cl", "Seadragon");

            authFactory.AccountType = "HOSTED";

            CalendarService client = new CalendarService(authFactory.ApplicationName);

            client.RequestFactory = authFactory;
            client.setUserCredentials(username + "@" + DOMAIN, password);

            try
            {
                client.QueryClientLoginToken(); // Authenticate the user immediately
            }
            catch (WebException)                // Invalid login
            {
                return(false);
            }

            return(true);
        }
Ejemplo n.º 17
0
        public static void AddEvent(CalendarService service, string id, string title, string contents, string location, DateTime startTime, DateTime endTime, string calendarName)
        {
            try
            {
                Google.GData.Calendar.EventEntry entry = new Google.GData.Calendar.EventEntry();
                // Set the title and content of the entry.
                entry.Title.Text      = id + "-" + title;
                entry.Content.Content = contents;

                // Set a location for the event.
                Where eventLocation = new Where();
                eventLocation.ValueString = location;
                entry.Locations.Add(eventLocation);

                When eventTime = new When(startTime, endTime);
                entry.Times.Add(eventTime);
                GoogleCalendar ggadmin    = new GoogleCalendar(calendarName, AdminuserName, AdminuserPwd);
                string         CalendarId = ggadmin.GetCalendarId();


                Uri postUri = new Uri("https://www.google.com/calendar/feeds/" + CalendarId + "/private/full");


                GDataGAuthRequestFactory requestFactory = (GDataGAuthRequestFactory)service.RequestFactory;
                IWebProxy iProxy  = WebRequest.GetSystemWebProxy();
                WebProxy  myProxy = new WebProxy();
                // potentially, setup credentials on the proxy here
                myProxy.Credentials           = CredentialCache.DefaultCredentials;
                myProxy.UseDefaultCredentials = false;

                requestFactory.CreateRequest(GDataRequestType.Insert, postUri);//  = myProxy;
                // Send the request and receive the response:
                AtomEntry insertedEntry = service.Insert(postUri, entry);
            }
            catch (Exception ex)
            {
                //LogManager.Instance.WriteToFlatFile(ex.Message);
            }
        }
Ejemplo n.º 18
0
        /// <summary>
        /// Authenticates to Google servers
        /// </summary>
        /// <param name="username">The user's username (e-mail)</param>
        /// <param name="password">The user's password</param>
        /// <exception cref="AuthenticationException">Thrown on invalid credentials.</exception>
        public void Login(string username, string password)
        {
            if (loggedIn)
            {
                throw new ApplicationException("Already logged in.");
            }
            try
            {
                service = new DocumentsService(APP_NAME);
                GDataGAuthRequestFactory reqFactory = (GDataGAuthRequestFactory)service.RequestFactory;
                reqFactory.KeepAlive     = false;
                reqFactory.ProtocolMajor = 3;

                service.setUserCredentials(username, password);

                loggedIn = true;
            }
            catch (AuthenticationException e)
            {
                loggedIn = false;
                service  = null;
                throw e;
            }
        }
Ejemplo n.º 19
0
        public List <String> getWebPropertiesList()
        {
            List <String>            webPropertieList = new List <String>();
            GDataGAuthRequestFactory requestFactory   = new GDataGAuthRequestFactory("analytics", "GTGATracker");

            requestFactory.AccountType = "GOOGLE";
            IWebProxy         myProxy     = new WebProxy(ConfigurationManager.AppSettings["ProxyUrl"]);
            NetworkCredential credentials = new NetworkCredential(ConfigurationManager.AppSettings["AnalyticsProxyUsername"],
                                                                  ConfigurationManager.AppSettings["AnalyticsProxyPassword"]);

            myProxy.Credentials  = credentials;
            requestFactory.Proxy = myProxy;
            this.setUserCredentials(GetEmail(), GetPassword());
            String queri = ConfigurationManager.AppSettings["FeedAccountsUri"]
                           + ConfigurationManager.AppSettings["API_Key"];
            DataQuery query           = new DataQuery(queri);
            DataFeed  feedWebProperty = this.Query(query);

            foreach (AtomEntry entry in feedWebProperty.Entries)
            {
                webPropertieList.Add(entry.Links[1].HRef.Content);
            }
            return(webPropertieList);
        }
Ejemplo n.º 20
0
        public IList <Feed> FeedsList(int?quantity)
        {
            // Try to retrieve from cache
            string cacheKey = CacheFeedList + quantity;

            ICache       cache = ServiceLocator.Current.GetInstance <ICache>();
            IList <Feed> lst   = cache.Get <IList <Feed> >(cacheKey);

            if (lst != null)
            {
                return(lst);
            }

            // TODO: Move hardcoded data to config file
            Service service = new Service("blogger", "ocaecommerce");

            service.Credentials = new GDataCredentials(Config.GoogleUser, Config.GooglePass);
            GDataGAuthRequestFactory factory = (GDataGAuthRequestFactory)service.RequestFactory;

            factory.AccountType = "GOOGLE";

            // Otherwise go get it
            lst = new List <Feed>();

            FeedQuery query = new FeedQuery();

            query.Uri = new Uri("http://www.blogger.com/feeds/default/blogs");

            AtomFeed feed = service.Query(query);

            foreach (AtomEntry entry in feed.Entries)
            {
                FeedQuery feedQuery = new FeedQuery();
                feedQuery.Uri = new Uri(entry.FeedUri);
                AtomFeed innerfeed = null;
                innerfeed = service.Query(feedQuery);

                foreach (AtomEntry innerentry in innerfeed.Entries)
                {
                    Feed f = new Feed();

                    int feedStartIndex = innerentry.Id.AbsoluteUri.IndexOf("post-") + 5;
                    f.Id            = innerentry.Id.AbsoluteUri.Substring(feedStartIndex);
                    f.Title         = innerentry.Title.Text;
                    f.FeedData      = innerentry.Content.Content;
                    f.FeedUrl       = innerentry.AlternateUri.Content;
                    f.DatePublished = innerentry.Published;

                    if (quantity != null)
                    {
                        if (quantity.Value == 0)
                        {
                            break;
                        }
                        quantity--;
                    }
                    lst.Add(f);
                }
            }

            cache.Set(cacheKey, lst, new TimeSpan(0, 20, 0));
            return(lst);
        }
Ejemplo n.º 21
0
    public int sendPostToBlogspot(string blogId, string username, string password, string title, string postBody, string tags)
    {
        //CheckForIllegalCrossThreadCalls = false;
        int     q       = 0;
        Service service = new Service("blogger", "googleAPIshittyName");

        service.Credentials = new GDataCredentials(username, password);
        GDataGAuthRequestFactory factory = (GDataGAuthRequestFactory)service.RequestFactory;

        factory.AccountType = "GOOGLE";
        /////////////////////////////////////////////////////////////

        if (postBody.Contains("[IMGLINK]"))
        {
            postBody = postBody.Replace("[IMGLINK]", uploadImageToGoogle("image.png", username, password, blogId));
        }
        postBody = BaseView.RemoveHtmlTagsUsingCharArray(postBody);
        ///////post////////////////////////////////
        AtomEntry post = new AtomEntry();

        post.Title.Text      = title;
        post.Content         = new AtomContent();
        post.Content.Content = postBody;
        post.Content.Type    = "xhtml";
        int length = 0;

        //make sure that tags are not too long
        string[] tagsS = tags.Split(',');
        foreach (string label in tagsS)
        {
            length = length + label.Count();
            if (length > 198)
            {
                string       label2 = label.Substring(0, 199);
                AtomCategory cat    = new AtomCategory();
                cat.Scheme = new Uri("http://www.blogger.com/atom/ns#");
                cat.Term   = label2;
                post.Categories.Add(cat);
                //this.txtTag.Text = this.txtTag.Text + label2 + ",";
                break;
            }
            else
            {
                AtomCategory cat = new AtomCategory();
                cat.Scheme = new Uri("http://www.blogger.com/atom/ns#");
                cat.Term   = label;
                post.Categories.Add(cat);
            }
        }
        post.IsDraft = false;
        ///////////////publishing post/_/_/_/_/_/_\_|_/_)_(_--> () - {} - [] 0_o
        Uri       blogFeedUri  = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
        AtomEntry createdEntry = null;

        try
        {
            createdEntry = service.Insert(blogFeedUri, post);
            //MessageBox.Show("Done!");
            Label1.Text += "Thành Công!!! <br/>";
            q            = 1;
        }
        catch (GDataRequestException exception)
        {
            if (exception.ResponseString == "Blog has exceeded rate limit or otherwise requires word verification for new posts")
            {   // MessageBox.Show("Blog has exceeded rate limit or otherwise requires word verification for new posts");
                Label1.Text += "Blog has exceeded rate limit or otherwise requires word verification for new posts <br/>";
                q            = 0;
            }
        }
        if (createdEntry == null)
        {
            //MessageBox.Show("Something went wrong, atricle was not published...\nCheck all html tags...");
            Label1.Text += "Something went wrong, atricle was not published...\nCheck all html tags...<br/>";
            q            = 0;
        }
        return(q);
    }