public void CreateTemplate()
        {
            DocumentsService service = new DocumentsService(applicationName);

            DocumentEntry entry = new DocumentEntry();

            // Set the document title
            entry.Title.Text = spreadsheetName;
            entry.IsSpreadsheet = true;

            // Set the media source
            entry.MediaSource = new MediaFileSource(GetStreamWithTemplate(), applicationName, "text/csv");

            // Define the resumable upload link
            Uri createUploadUrl = new Uri("https://docs.google.com/feeds/upload/create-session/default/private/full");
            AtomLink link = new AtomLink(createUploadUrl.AbsoluteUri);
            link.Rel = ResumableUploader.CreateMediaRelation;
            entry.Links.Add(link);

            // Set the service to be used to parse the returned entry
            entry.Service = service;

            // Instantiate the ResumableUploader component.
            ResumableUploader uploader = new ResumableUploader();

            // Start the upload process
            uploader.Insert(new ClientLoginAuthenticator(applicationName,ServiceNames.Documents,userName,password), entry);
        }
        public SpreadSheet()
        {
            service = new SpreadsheetsService("stock-market");
            service.setUserCredentials("shurai", "$gva99void!");

            SpreadsheetQuery query = new SpreadsheetQuery();
            SpreadsheetFeed feed = service.Query(query);

            SpreadsheetEntry ssentry = (SpreadsheetEntry)feed.Entries[0];

            AtomLink sslink = ssentry.Links.FindService(GDataSpreadsheetsNameTable.WorksheetRel, null);
            WorksheetQuery wkquery = new WorksheetQuery(sslink.HRef.ToString());
            WorksheetFeed wkfeed = service.Query(wkquery);
            WorksheetEntry wkentry = (WorksheetEntry)wkfeed.Entries[0];

            listFeedLink = wkentry.Links.FindService(GDataSpreadsheetsNameTable.ListRel, null);
            listQuery = new ListQuery(listFeedLink.HRef.ToString());
            listFeed = service.Query(listQuery);

            Console.WriteLine("Worksheet has {0} rows: ", listFeed.Entries.Count);
            foreach (ListEntry worksheetRow in listFeed.Entries)
            {
                ListEntry.CustomElementCollection elements = worksheetRow.Elements;
                foreach (ListEntry.Custom element in elements)
                {
                    Console.Write(element.Value + "\t");
                }
                Console.WriteLine();
            }
        }
    public async Task UploadToYouTube(HttpPostedFile postedFile, string title)
    {
        UploadingDispatcher.SetProgress(uploadId, 2);
        Video video = new Video();
        video.Title = title;
        video.Tags.Add(new MediaCategory("Autos", YouTubeNameTable.CategorySchema));
        video.Private = false;
        video.MediaSource = new MediaFileSource(postedFile.InputStream, postedFile.FileName, postedFile.ContentType);

        var link = new AtomLink("http://uploads.gdata.youtube.com/resumable/feeds/api/users/default/uploads");
        link.Rel = ResumableUploader.CreateMediaRelation;
        video.YouTubeEntry.Links.Add(link);

        var youtubeApiKey = ConfigurationManager.AppSettings["youtubeApiKey"];
        var applicationName = ConfigurationManager.AppSettings["applicationName"];
        var youtubeUserName = ConfigurationManager.AppSettings["youtubeUserName"];
        var youtubePassword = ConfigurationManager.AppSettings["youtubePassword"];
        var youtubeChunksize = int.Parse(ConfigurationManager.AppSettings["youtubeChunksize"]);

        var resumableUploader = new ResumableUploader(youtubeChunksize); 
        resumableUploader.AsyncOperationCompleted += resumableUploader_AsyncOperationCompleted;
        resumableUploader.AsyncOperationProgress += resumableUploader_AsyncOperationProgress;

      
        var youTubeAuthenticator = new ClientLoginAuthenticator(applicationName, ServiceNames.YouTube, youtubeUserName, youtubePassword);
        youTubeAuthenticator.DeveloperKey = youtubeApiKey;

        resumableUploader.InsertAsync(youTubeAuthenticator, video.YouTubeEntry, uploadId);
    }
Пример #4
0
        /// <summary>
        /// Adds a reply link to this commententry
        ///    -> this new entry will reply to the passed in entry when the comment is 
        ///    submitted. This will not protect from adding the same guy several times.
        /// </summary>
        /// <param name="theOriginalComment"></param>
        /// <returns></returns>
        public void ReplyTo(CommentEntry theOriginalComment) {
            if (theOriginalComment.SelfUri == null) {
                throw new ArgumentException("You can only reply to an entry with a valid SelfUri");
            }

            AtomLink link = new AtomLink(AtomLink.ATOM_TYPE, YouTubeNameTable.ReplyToRelationship);
            link.HRef = theOriginalComment.SelfUri;
            this.Links.Add(link);
        }
Пример #5
0
 public void TypeTest()
 {
     AtomLink target = new AtomLink(); // TODO: Initialize to an appropriate value
     string expected = "TestValue";            
     string actual;
     target.Type = expected;
     actual = target.Type;
     Assert.AreEqual(expected, actual);
 }
Пример #6
0
 public static void CreateGoogleNote(/*Document parentFolder, */Document googleNote, object UserData, DocumentsRequest documentsRequest, ResumableUploader uploader, OAuth2Authenticator authenticator)
 {
     // Define the resumable upload link
     Uri createUploadUrl = new Uri("https://docs.google.com/feeds/upload/create-session/default/private/full");
     //Uri createUploadUrl = new Uri(GoogleNotesFolder.AtomEntry.EditUri.ToString());
     AtomLink link = new AtomLink(createUploadUrl.AbsoluteUri);
     link.Rel = ResumableUploader.CreateMediaRelation;
     googleNote.DocumentEntry.Links.Add(link);
     //if (parentFolder != null)
     //    googleNote.DocumentEntry.ParentFolders.Add(new AtomLink(parentFolder.DocumentEntry.SelfUri.ToString()));
     // Set the service to be used to parse the returned entry
     googleNote.DocumentEntry.Service = documentsRequest.Service;
     // Start the upload process
     //uploader.InsertAsync(_authenticator, match.GoogleNote.DocumentEntry, new object());
     uploader.InsertAsync(authenticator, googleNote.DocumentEntry, UserData);
 }
Пример #7
0
 /// <summary>standard typed accessor method </summary> 
 public bool Contains( AtomLink value )  
 {
     // If value is not of type AtomLink, this will return false.
     return( List.Contains( value ) );
 }
Пример #8
0
 /// <summary>standard typed accessor method </summary> 
 public void Remove( AtomLink value )  
 {
     List.Remove( value );
 }
Пример #9
0
 /// <summary>standard typed accessor method </summary> 
 public void Insert( int index, AtomLink value )  
 {
     List.Insert( index, value );
 }
Пример #10
0
 public void HRefTest()
 {
     AtomLink target = new AtomLink(); // TODO: Initialize to an appropriate value
     AtomUri expected = new AtomUri("http://www.test.com/");
     AtomUri actual;
     target.HRef = expected;
     actual = target.HRef;
     Assert.AreEqual(expected, actual);
 }
Пример #11
0
       /////////////////////////////////////////////////////////////////////////////


       //////////////////////////////////////////////////////////////////////
       /// <summary>compares 2 link objects</summary> 
       /// <param name="theOne">the One link</param>
       /// <param name="theOther">the Other link</param>
       /// <returns>true if identical </returns>
       //////////////////////////////////////////////////////////////////////
       public static bool IsLinkIdentical(AtomLink theOne, AtomLink theOther)
       {
           if (theOne == null && theOther == null)
           {
               return true;
           }

           if (ObjectModelHelper.IsBaseIdentical(theOne, theOther)==false)
           {
               return false;
           }

           if (AtomUri.Compare(theOne.HRef, theOther.HRef)!=0)
           {
               return false;
           }

           if (theOne.Length != theOther.Length)
           {
               return false;
           }

           if (String.Compare(theOne.Rel, theOther.Rel)!= 0)
           {
               return false;
           }
           if (String.Compare(theOne.Type, theOther.Type)!= 0)
           {
               return false;
           }
           if (String.Compare(theOne.HRefLang, theOther.HRefLang)!= 0)
           {
               return false;
           }
           if (String.Compare(theOne.Title, theOther.Title)!= 0)
           {
               return false;
           }

           return true;
       }
Пример #12
0
        private Link mapLink(AtomLink link)
        {
            Link linkObj = new Link();
            linkObj.Rel = link.Rel;
            linkObj.Title = link.Title;
            linkObj.Type = link.Type;
            linkObj.Uri = link.AbsoluteUri;

            return linkObj;
        }
Пример #13
0
        void DrawCreateWorkbookGUI()
        {
            EditorGUILayout.BeginHorizontal();
            DrawHelpButtonGUI("ID_HELP_UPLOAD_WORKBOOK");
            DrawLabelHeader("ID_CREATE_WORKBOOK");
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.Separator();

            EditorGUILayout.BeginHorizontal();
            Indent(1);
            GUI.backgroundColor = Color.clear;
            GUI.color = Color.yellow;
            bool bDoSave = false;
            GUI.SetNextControlName("Clear");
            if (GUILayout.Button(_BrowseButton, EditorStyles.toolbarButton, GUILayout.Width(24)))
            {
                ClearMessages();
                string workbookpath = EditorUtility.OpenFilePanel(
                    Localize("ID_SELECT_UPLOAD_WORKBOOK_PATH"), EditorApplication.applicationPath, "*.xls;*.xlsx;*.ods;*.csv;*.txt;*.tsv");

                if (!string.IsNullOrEmpty(workbookpath))
                {
                    if ((workbookpath.IndexOf(".xls", System.StringComparison.InvariantCultureIgnoreCase) != -1) ||
                        (workbookpath.IndexOf(".xlsx", System.StringComparison.InvariantCultureIgnoreCase) != -1) ||
                        (workbookpath.IndexOf(".ods", System.StringComparison.InvariantCultureIgnoreCase) != -1) ||
                        (workbookpath.IndexOf(".csv", System.StringComparison.InvariantCultureIgnoreCase) != -1) ||
                        (workbookpath.IndexOf(".txt", System.StringComparison.InvariantCultureIgnoreCase) != -1) ||
                        (workbookpath.IndexOf(".tsv", System.StringComparison.InvariantCultureIgnoreCase) != -1))
                    {
                        bDoSave = true;
                    }

                    if (bDoSave)
                    {
                        _WorkbookUploadPath = workbookpath;
                        GUI.FocusControl("Clear");
                        Repaint();
                    }
                    else
                    {
                        _EditorWarning = Localize("ID_ERROR_UPLOAD_WORKBOOK_PATH");
                        Debug.LogWarning(_EditorWarning);
                    }
                }
            }
            GUI.backgroundColor = _DefaultBgColor;
            GUI.color = _DefaultFgColor;
            EditorGUILayout.TextField(_WorkbookUploadPath);
            GUILayout.Label(System.String.Empty, GUILayout.Width(5));

            EditorGUILayout.EndHorizontal();

            EditorGUILayout.BeginHorizontal();
            GUILayout.Label(System.String.Empty);

            if (CreatingWorkbook)
                GUI.enabled = false;

            if (GUILayout.Button(Localize("ID_CREATE"), EditorStyles.miniButton, GUILayout.Width(65)))
            {
                ClearMessages();

                // We need a DocumentService
                var service = new Google.GData.Documents.DocumentsService("GoogleFuUploader");
                string mimeType = GoogleFuMimeType.GetMimeType(_WorkbookUploadPath);

                var authenticator = new Google.GData.Client.ClientLoginAuthenticator("UnityGoogleFu", Google.GData.Client.ServiceNames.Documents, _Username, _Password);
                //service.setUserCredentials(_username, _password);

                // Instantiate a DocumentEntry object to be inserted.
                var entry = new Google.GData.Documents.DocumentEntry();

                CreatingWorkbook = true;
                entry.MediaSource = new Google.GData.Client.MediaFileSource(_WorkbookUploadPath, mimeType);

                // Define the resumable upload link
                var createUploadUrl = new System.Uri("https://docs.google.com/feeds/upload/create-session/default/private/full");
                var link = new Google.GData.Client.AtomLink(createUploadUrl.AbsoluteUri)
                {
                    Rel = Google.GData.Client.ResumableUpload.ResumableUploader.CreateMediaRelation
                };

                entry.Links.Add(link);

                // Set the service to be used to parse the returned entry
                entry.Service = service;


                // Instantiate the ResumableUploader component.
                var uploader = new Google.GData.Client.ResumableUpload.ResumableUploader();

                // Set the handlers for the completion and progress events
                uploader.AsyncOperationCompleted += OnSpreadsheetUploadDone;
                uploader.AsyncOperationProgress += OnSpreadsheetUploadProgress;

                // Start the upload process
                uploader.InsertAsync(authenticator, entry, new object());
                _EditorInfo = Localize("ID_CREATING_DATABASE_MESSAGE");

                //Repaint();
            }
            GUI.enabled = true;
            GUILayout.Label(System.String.Empty, GUILayout.Width(5));
            EditorGUILayout.EndHorizontal();
        }
Пример #14
0
        public void AtomLinkConstructorTest()
        {
            string type = "TestValue"; // TODO: Initialize to an appropriate value
            string rel = "TestValue"; // TODO: Initialize to an appropriate value
            AtomLink target = new AtomLink(type, rel);
            Assert.AreEqual(target.Type, type);
            Assert.AreEqual(target.Rel, rel);

        }
Пример #15
0
 public void XmlNameTest()
 {
     AtomLink target = new AtomLink(); // TODO: Initialize to an appropriate value
     Assert.AreEqual(target.XmlName, AtomParserNameTable.XmlLinkElement);
 }
Пример #16
0
 public void AtomLinkConstructorTest1()
 {
     string link = "http://www.test.com/";
     AtomLink target = new AtomLink(link);
     Assert.AreEqual(target.AbsoluteUri, link);
 }
Пример #17
0
 public void AtomLinkConstructorTest2()
 {
     AtomLink target = new AtomLink();
     Assert.IsNotNull(target);
     Assert.IsNull(target.AbsoluteUri);
 }
Пример #18
0
 public void AbsoluteUriTest()
 {
     AtomLink target = new AtomLink(); // TODO: Initialize to an appropriate value
     AtomUri expected = new AtomUri("http://www.test.com/");
     target.HRef = expected;
     Assert.AreEqual(target.AbsoluteUri, "http://www.test.com/");
 }
Пример #19
0
        /// <summary>creates an atomlink object</summary>
        /// <param name="reader">correctly positioned xmlreader</param>
        /// <param name="owner">the object containing the person</param>
        /// <returns> the created AtomLink object</returns>
        protected AtomLink ParseLink(XmlReader reader, AtomBase owner)
        {
            Tracing.Assert(reader != null, "reader should not be null");
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }

            if (owner == null)
            {
                throw new ArgumentNullException("owner");
            }

            bool noChildren = reader.IsEmptyElement;

            Tracing.TraceCall();

            AtomLink link      = owner.CreateAtomSubElement(reader, this) as AtomLink;
            object   localname = null;

            if (reader.HasAttributes)
            {
                while (reader.MoveToNextAttribute())
                {
                    localname = reader.LocalName;
                    if (localname.Equals(this.nameTable.HRef))
                    {
                        link.HRef = new AtomUri(reader.Value);
                    }
                    else if (localname.Equals(this.nameTable.Rel))
                    {
                        link.Rel = Utilities.DecodedValue(reader.Value);
                    }
                    else if (localname.Equals(this.nameTable.Type))
                    {
                        link.Type = Utilities.DecodedValue(reader.Value);
                    }
                    else if (localname.Equals(this.nameTable.HRefLang))
                    {
                        link.HRefLang = Utilities.DecodedValue(reader.Value);
                    }
                    else if (localname.Equals(this.nameTable.Title))
                    {
                        link.Title = Utilities.DecodedValue(reader.Value);
                    }
                    else if (localname.Equals(this.nameTable.Length))
                    {
                        link.Length = int.Parse(Utilities.DecodedValue(reader.Value), CultureInfo.InvariantCulture);
                    }
                    else
                    {
                        ParseBaseAttributes(reader, link);
                    }
                }
            }
            if (!noChildren)
            {
                reader.MoveToElement();
                int lvl = -1;
                while (NextChildElement(reader, ref lvl))
                {
                    ParseExtensionElements(reader, link);
                }
            }
            return(link);
        }
Пример #20
0
        public AtomEntry updloadAttachment(String filename, String contentType, AtomEntry parent, String title, String description)
        {
            SiteEntry entry = new SiteEntry();

            AtomCategory category = new AtomCategory(SitesService.ATTACHMENT_TERM, SitesService.KIND_SCHEME);
            category.Label = "attachment";
            entry.Categories.Add(category);

            AtomLink parentLink = new AtomLink(AtomLink.ATOM_TYPE, SitesService.PARENT_REL);
            parentLink.HRef = parent.SelfUri;
            entry.Links.Add(parentLink);

            entry.MediaSource = new MediaFileSource(filename, contentType);
            entry.Content.Type = contentType;

            if (title == "")
            {
                entry.Title.Text = entry.MediaSource.Name;
            }
            else
            {
                entry.Title.Text = title;
            }

            entry.Summary.Text = description;

            AtomEntry newEntry = null;
            try
            {
                newEntry = service.Insert(new Uri(makeFeedUri("content")), entry);
            }
            catch (GDataRequestException e)
            {
                Console.WriteLine(e.ResponseString);
            }

            return newEntry;
        }
Пример #21
0
        /// <summary>
        /// insert a new video. 
        /// </summary>
        /// <param name="row"></param>
        /// <param name="retryCounter"></param>
        /// <returns></returns>
        private bool InsertVideo(DataGridViewRow row, int retryCounter) {
            Trace.TraceInformation("Entering InsertVideo: starting a new upload");
            Video v = new Video();
            v.Title = row.Cells[0].Value.ToString();
            v.Description = row.Cells[1].Value.ToString();
            v.Keywords = row.Cells[2].Value.ToString();
            v.Tags.Add(new MediaCategory(row.Cells[3].Value.ToString()));
            v.Private = row.Cells[4].Value.ToString().ToLower() == "true";

            string contentType = MediaFileSource.GetContentTypeForFileName(row.Cells[COLUMNINDEX_FILENAME].Value.ToString());
            v.MediaSource = new MediaFileSource(row.Cells[COLUMNINDEX_FILENAME].Value.ToString(), contentType);

            // add the upload uri to it
            AtomLink link = new AtomLink("http://uploads.gdata.youtube.com/resumable/feeds/api/users/" + this.youtubeAccount + "/uploads");
            link.Rel = ResumableUploader.CreateMediaRelation;
            v.YouTubeEntry.Links.Add(link);

            UserState u = new UserState(row);
            u.RetryCounter = retryCounter;

            lock (this.flag) {
                this.queue.Add(u);
            }
            ru.InsertAsync(this.youTubeAuthenticator, v.YouTubeEntry, u);

            row.Cells[COLUMNINDEX_STATUS].Value = "Queued up...";
            row.Cells[COLUMNINDEX_STATUS].Tag = u;

            return true;
        }
Пример #22
0
     /// <summary>standard typed accessor method </summary> 
     public int Add( AtomLink value )  
     {
 	    // Remove link with same relation to avoid duplication.
 	    AtomLink oldLink = FindService(value.Rel, value.Type);
 	    if (oldLink != null)
 	    {
 	        List.Remove(oldLink);
 	    }
         return( List.Add( value ) );
     }
		private static void RunSample(string username, string password, string accountId) {
			// Connect to the service
			ContentForShoppingService service = new ContentForShoppingService("ContentForShopping-Sample");
			service.setUserCredentials(username, password);

			// Retrieve the list of all existing products
			string projection = "schema";
			ProductQuery query = new ProductQuery(projection, accountId);
			ProductFeed feed = service.Query(query);

			// Display title and id for each product
			Console.WriteLine("Listing all products");
			foreach (ProductEntry p in feed.Entries) {
				Console.WriteLine("Product: " + p.Title.Text + " (" + p.ProductId + ")");
			}

			// Create a new product			
			ProductEntry entry = new ProductEntry();
			entry.Title.Text = "Wool sweater";
			AtomContent c = new AtomContent();
			c.Content = "Comfortable and soft, this sweater will keep you warm on those cold winter nights. Red and blue stripes.";
			entry.Content = c;
			entry.ProductId = "123457";
			entry.Language = "it";
			entry.TargetCountry = "US";
			entry.ContentLanguage = "en";
			entry.Brand = "ACME";
			entry.Condition = "new";
			entry.Price = new Price("usd", "25");
			entry.ProductType = "Clothing & Accessories > Clothing > Outerwear > Sweaters";
			entry.Quantity = 3;
			entry.ShippingWeight = new ShippingWeight("lb", "0.1");
            entry.ImageLink = new ImageLink("http://www.example.com/image.jpg");
            entry.Availability = "available for order";
            entry.Channel = "online";
            entry.Gender = "female";
            entry.Material = "wool";
            entry.Pattern = "Red and blue stripes";
            entry.Color = "red";

			AtomLink link = new AtomLink();
			link.HRef = "http://www.example.com";
			link.Rel = "alternate";
			link.Type = "text/html";
			entry.Links.Add(link);

			// Shipping rules
			Shipping s1 = new Shipping();
			s1.Country = "US";
			s1.Region = "MA";
			s1.Service = "Speedy Shipping - Ground";
			s1.Price = new ShippingPrice("usd", "5.95");

			Shipping s2 = new Shipping();
			s2.Country = "US";
			s2.Region = "024*";
			s2.Service = "Speedy Shipping - Air";
			s2.Price = new ShippingPrice("usd", "7.95");

			entry.ShippingRules.Add(s1);
			entry.ShippingRules.Add(s2);

			// Tax rules
			Tax t1 = new Tax();
			t1.Country = "US";
			t1.Region = "CA";
			t1.Rate = "8.25";
			t1.Ship = true;

			Tax t2 = new Tax();
			t2.Country = "US";
			t2.Region = "926*";
			t2.Rate = "8.75";
			t2.Ship = false;

			entry.TaxRules.Add(t1);
			entry.TaxRules.Add(t2);

			// Additional Image Links
            AdditionalImageLink il1 = new AdditionalImageLink("http://www.example.com/1.jpg");
			entry.AdditionalImageLinks.Add(il1);
            AdditionalImageLink il2 = new AdditionalImageLink("http://www.example.com/2.jpg");
            entry.AdditionalImageLinks.Add(il2);

			// Add the product to the server feed
			Console.WriteLine("Inserting product");
			ProductEntry inserted = service.Insert(feed, entry);

			// Update the product we just inserted
			inserted.Title.Text = "2011 Wool sweater";
			Console.WriteLine("Updating product");
			ProductEntry updated = service.Update(inserted);

			// Retrieve the new list of products
			feed = service.Query(query);

			// Display title and id for each product
			Console.WriteLine("Listing all products again");
			foreach (ProductEntry p in feed.Entries) {
				Console.WriteLine("Product: " + p.Title.Text + " (" + p.ProductId + ")");
			}

			// Delete the item we inserted and updated
			Console.WriteLine("Deleting product");
			service.Delete(updated);
		}
Пример #24
0
 /// <summary>standard typed accessor method </summary> 
 public int IndexOf( AtomLink value )  
 {
     return( List.IndexOf( value ) );
 }
Пример #25
0
        public void DoWorkbookUpload(object in_instance)
        {
            var instance = in_instance as Google2uData;
            if (instance == null)
                return;

            if (!string.IsNullOrEmpty(instance.WorkbookUploadPath))
            {
                try
                {
                    // We need a DocumentService
                    var service = new DocumentsService("Google2Unity");
                    var mimeType = Google2uMimeType.GetMimeType(instance.WorkbookUploadPath);

                    var authenticator = new OAuth2Authenticator("Google2Unity", _authParameters);

                    // Instantiate a DocumentEntry object to be inserted.
                    var entry = new DocumentEntry
                    {
                        MediaSource = new MediaFileSource(instance.WorkbookUploadPath, mimeType)
                    };

                    // Define the resumable upload link
                    var createUploadUrl =
                        new Uri("https://docs.google.com/feeds/upload/create-session/default/private/full");
                    var link = new AtomLink(createUploadUrl.AbsoluteUri)
                    {
                        Rel = ResumableUploader.CreateMediaRelation
                    };

                    entry.Links.Add(link);

                    // Set the service to be used to parse the returned entry
                    entry.Service = service;


                    // Instantiate the ResumableUploader component.
                    var uploader = new ResumableUploader();

                    // Set the handlers for the completion and progress events
                    uploader.AsyncOperationCompleted += OnSpreadsheetUploadDone;
                    uploader.AsyncOperationProgress += OnSpreadsheetUploadProgress;

                    // Start the upload process
                    uploader.InsertAsync(authenticator, entry, instance);
                }
                catch (Exception)
                {
                    PushNotification(
                        "There is a problem with your credentials. Clear the credentials and Re-Authorize G2U");
                    //instance.Messages.Add(new G2GUIMessage(GFGUIMessageType.InvalidLogin, ex.Message));
                    instance.Commands.Remove(GFCommand.WaitingForUpload);
                }
            }
        }
Пример #26
0
 public void LengthTest()
 {
     AtomLink target = new AtomLink(); // TODO: Initialize to an appropriate value
     int expected = 0; // TODO: Initialize to an appropriate value
     int actual;
     target.Length = expected;
     actual = target.Length;
     Assert.AreEqual(expected, actual);
 }