joesoc / google-api-dotnet-client Goto Github PK

The Request class should expose a WithApiKey(string key) method to support 
those APIs requiring API keys for authentication.

The API key can't be passed along with other parameters to 
WithParameters(string parameters) as it is not included in the method 
definition in the discovery document and therefore parameter validation will 
fail.

All requests (including those unauthenticated) in the library and samples 
should use HTTPS instead of HTTP.

Allow streams to return XmlDocument

What steps will reproduce the problem?
1.
2.
3.

What is the expected output? What do you see instead?


Please use labels and text to provide additional information.

Purpose of code changes on this branch:
Two empty app.config files are under two the projects, 
CommandLineGeneratedService and CommandLineServiceGenerator.
Those make build errors.
For now I just remove them out of each project.

When reviewing my code changes, please focus on:
CommandLineGeneratedService and CommandLineServiceGenerator
project under sample solution

After the review, I'll merge this branch into:
/trunk

The GenerateTimestamp method in Oauthutil.cs can be optimized to use non-string 
operations.

Also OAuthUtilTest.cs is in the repository, but not included within the 
solution file.

In my rush to get stuff in I put this in the wrong place.

All requests attach a specific User agent of the form:

<application_name> google-api-<language>-client/<library_version> <platform>

We currently do not support <platform>, given that .Net can run on a variety of 
devices and platforms such as Mono, there might be specific issue with a given 
platform that we cannot detect from the server side.

The parser is unable to parse schemes in several services like urlshortener or 
discovery itself. Exception:

Unhandled Exception: System.ApplicationException: Failed to parse schema 
[AnalyticsSummary] which was defined as 
[{"id":"AnalyticsSummary","type":"object","properties":{"allTime":{"$ref":"Analy
ticsSnapshot","description":"Click analytics over all 
time."},"day":{"$ref":"AnalyticsSnapshot","description":"Click analytics over 
the last day."},"month":{"$ref":"AnalyticsSnapshot","description":"Click 
analytics over the last 
month."},"twoHours":{"$ref":"AnalyticsSnapshot","description":"Click analytics 
over the last two 
hours."},"week":{"$ref":"AnalyticsSnapshot","description":"Click analytics over 
the last week."}}}] ---> System.Exception: Expected StartObject while parsing 
schema object, got EndObject.
  at Newtonsoft.Json.Schema.JsonSchemaBuilder.BuildSchema () [0x00000] 
  at Newtonsoft.Json.Schema.JsonSchemaBuilder.ProcessProperties () [0x00000] 
  at Newtonsoft.Json.Schema.JsonSchemaBuilder.ProcessSchemaProperty (System.String propertyName) [0x00000] 
  at Newtonsoft.Json.Schema.JsonSchemaBuilder.BuildSchema () [0x00000] 
  at Newtonsoft.Json.Schema.JsonSchemaBuilder.Parse (Newtonsoft.Json.JsonReader reader) [0x00000] 
  at Newtonsoft.Json.Schema.JsonSchema.Read (Newtonsoft.Json.JsonReader reader, Newtonsoft.Json.Schema.JsonSchemaResolver resolver) [0x00000] 
  at Newtonsoft.Json.Schema.JsonSchema.Parse (System.String json, Newtonsoft.Json.Schema.JsonSchemaResolver resolver) [0x00000] 
  at Google.Apis.Discovery.Schema.SchemaImpl..ctor (System.String name, System.String jsonSchemaDefinition, Google.Apis.Discovery.Schema.FutureJsonSchemaResolver resolver) [0x00048] in /home/mlinder/Desktop/Source/issue_36_samples_v1/Src/GoogleApis/Apis/Discovery/Schema/SchemaImpl.cs:47 
  --- End of inner exception stack trace ---
  at Google.Apis.Discovery.Schema.SchemaImpl..ctor (System.String name, System.String jsonSchemaDefinition, Google.Apis.Discovery.Schema.FutureJsonSchemaResolver resolver) [0x0005b] in /home/mlinder/Desktop/Source/issue_36_samples_v1/Src/GoogleApis/Apis/Discovery/Schema/SchemaImpl.cs:50 
  at Google.Apis.Discovery.BaseService.ParseSchemas (Google.Apis.Json.JsonDictionary js) [0x00068] in /home/mlinder/Desktop/Source/issue_36_samples_v1/Src/GoogleApis/Apis/Discovery/Service.cs:128 
  at Google.Apis.Discovery.BaseService.get_Schemas () [0x00043] in /home/mlinder/Desktop/Source/issue_36_samples_v1/Src/GoogleApis/Apis/Discovery/Service.cs:148 

Purpose of code changes on this branch:
Automate the build and release of client Dlls, also to test a process for 
producing code release.

After the review, I'll merge this branch into:
/default

Currently a PUT/POST command will allow a developer to submit XML or ATOM 
regardless of what result is expected.

Discovery has enum types in it, we should create types based on these , not 
just comments as present.

Currently the CodeGen only generates subclasses following the pattern 
"NestedClass{0}{1}". We should create more friendly names, especially for array 
schemas.

Otherwise the user would have to construct these array entries using 
"new DetectionList.NestedClass01()".

The SchemeGenerator.GetSchemmaName currently only takes a number/id and does 
not support customization.

During my big push to get Demo Days project complete I put in changes to 
support Discovery 0.2. This code was not documented or unit tested enough

This bug has been created to track my effort to correct this.

The generated class currently only exposes synchronouse methods and uses 
synchronouse network calls. For silverlight and windows phone 7 this is an 
unsupported operation. For other environments  it is well worth having an async 
option. I propose adding another method for each discovery method which returns 
a Task<Stream> or Task<ReturnType> and uses the async network operations.

Check what changes have been made to discovery, and what changes we need to 
make to support it.

this json failed

"utc_offset":-18000

adding
   || cur == '-'

to this case in TokenStream::GetNextToken

default:
            token.type = JsonToken.Type.Undefined;
            if (Char.IsNumber(cur) || cur == '-') {
              sb = new StringBuilder(BuilderBufferSize);
              sb.Append(cur);
              while (IsTokenSeperator((char)reader.Peek()) == false) {
                sb.Append((char)reader.Read());
              }
              token.value = sb.ToString();
              decimal decNumber;
              if(Decimal.TryParse(token.value, out decNumber)){
                token.number = decNumber;
                token.type = JsonToken.Type.Number;
              }
            }
            break;

Fixed it

Create an Automated process or semi automated process for producing DLLs

in discovery Rest parameters can be marked as repeat:true
I don't believe the API code currently supports this, and I know the generated 
code does not.

For generated code this should go from type => IList<type>

For the Api we will need to figure out what to do here

http://example.url/path/method?repeatedParam=0&repeatedParam=2&repeatedParam=3

Would be my guess but we will need to check with other clients.
Also can path parameters ever repeat? if so we will need to investergate what 
to do.

These two apis are generating code that does not compile. 
Both fail with type Foo can not have the same name as its Parent.

The sample for shopping is using Discovery 0.1 and is passing in parameters no 
longer supported see 
http://code.google.com/p/google-api-dotnet-client/wiki/SearchForShoppingSample 
and the comment at the bottom.

The new discovery api is 
https://www.googleapis.com/discovery/v1/apis/shopping/v1/rest

parameters with hypens in them e.g max-results are currently being displays as 
maxresultsParameter3. Where possible i.e. does not cause naming conflicts this 
should be changed to maxResults

Create an ASP.Net MVC Sample

Support IQueryable so that LINQ can be used.

There's a typo in the AdSenseGadget sample project which is incorrectly named 
"AdSenseGadet".
Solution/Folder name and any other occurrences should be fixed.

Add support for returning XDocument

Purpose of code changes on this branch:

To fix error.

When reviewing my code changes, please focus on:
Listserice-> main.cs

After the review, I'll merge this branch into:
/trunk

Google APIs support GZip compression of the HTTP content of both requests and 
responses.  This can have an order of magnitude improvement in terms of HTTP 
content size.

In order to enable the Google API server to send a gzipped HTTP response, you 
need to add the following HTTP header:

Accept-Encoding: gzip

When sending a gzipped HTTP request, you need to add the following header:

Content-Type: application/json

Remove /Src/GoogleApi.sln
Rename /CodeGeneration.sln to be more generic

The existing solution GoogleApi, is messy and requires the full version of 
VisualStudio to open. CodeGeneration.sln is simpler and nicer 

Schemes like DetectionsResource in the Translate API are actually arrays 
instead of normal types, and are currently not yet supported by the CodeGen 
library.

This json failed because of the escaped quote in there

source":"\u003Ca href=\"http:\/\/blackberry.com\/twitter\" 
rel=\"nofollow\"\u003ETwitter for BlackBerry\u00ae\u003C\/a\u003E"

changing GetNextToken quote case to this:
case '"':
            token.type = JsonToken.Type.String;
            // let's read in the string
            sb = new StringBuilder(BuilderBufferSize);
            char next = (char)reader.Read();
            char current = '"';

            while (!(next == '"' && current != '\\'))
            {
              sb.Append(next);
              current = next;
              next = (char)reader.Read();
            }
            token.value = sb.ToString();

            break;

Fixed it for me

The Library currently only supports OAuth 1.0 and OAuth 1.0a, it needs to 
support OAuth2.

It can be hard for developers to install the client library and any future 
tools.  Create an installer package so that it is easy for developers to get 
started.

The three above services do not generate code, they fail to parse the Json.

Currently the library will make requests using its own in built OAuth code.  
This code does not handle any of the interactions in the "Oauth dance"  instead 
it assumes that the developer has already done all this work and requests only 
that the developer supply the Access Token and Token Secret.

Make it easier to for developers to integrate their preferred OAuth client API 
of choice.

Some methods, parameters, resources have descriptions display these as XMLDocs 
in the genreated code

Create a WPF example

Large portions of the code does not adhere to any coding guidelines, and it 
should be refactored and properly documented. I know this is a long process and 
not even possible for the entire API, but this issue should serve as a base for 
CL's only containing refactoring.

UserAgent sent by the .NET client library has to comply with the canonical 
format:

<application_name> google-api-dotnet-client/<library_version>

Support Static types.

The auto-discovery nature of the new apis means that it is not possible to 
easily create classes specific to an API.

Code-gen will help solve this by allowing the developer to build client API's 
and static classes based of the discovery document.

Where resources have resources the sub-resources never get constructed.

e.g. DiacritizeService will not work the corpus member is never Initialized.

public class Diacritize {
        private Google.Apis.Discovery.ISchemaAwareRequestExecutor service;
        private const string Resource = "diacritize";
        private log4net.ILog logger = log4net.LogManager.GetLogger(typeof(Diacritize));
        private Corpus corpus;
        public Diacritize(DiacritizeService service) {
            this.service = service;
        }
        public virtual Corpus Corpus {
            get {
                return this.corpus;
            }
        }
    }


Constructor should be creating Corpus

public Diacritize(DiacritizeService service) 
{
      this.service = service;
      this.corpus = new Corpus(service);
}

Currently there is no option to set the developer key without modifying the 
generated library. We should allow the developer to set it when creating/using 
the service.

Currently some of the Sample projects in the solution are using .NET 4.0, while 
others are e.g. using .NET 3.0.

We should target one uniform framework, or at least change all projects to use 
only the framework they actually require (most/all? of the projects don't use 
.NET 4.0 features). 

This should be done because the code otherwise won't compile on the standard 
mono version provided within Ubuntu repositories. I recommend using .NET 2.0 
for all projects unless newer features are required, as this version is the one 
still most likely to be used. 

Compiler features introduced in newer .NET versions can still be used, even 
when an older .NET framework is targeted.

The following line in Google.Apis.Requests.Request throws a 
NullReferenceException if Authenticator is null:

HttpWebRequest request = 
this.Authenticator.CreateHttpWebRequest(this.Method.HttpMethod, RequestUrl);

This prevents developers to use APIs that don't require authentication, as in 
the following snippet:

Request request = Request.CreateRequest(service, method);
var stream = request.WithParameters(requestParameters).ExecuteRequest()

Parameters generated should be ordered mandatory before optional then 
alphabetically. 

This is as per other Api clients and help maintain a stable API.

For details please contact davidwaters

Apparently the JsonReader cannot fully parse a document when using the 
WebDiscoveryDevice under windows. The TokenStream from Netwon.
Json.Net35.dll will start returning only null-tokens at some point, and the 
resulting document/dictionary gets corrupted.

The issue does not occur when preloading the full document/using the 
StringDiscoveryDevice.

It may be caused by a timeout or something similar (especially since it is not 
happening under mono), but no Exception is thrown. Have to investigate!

Tested with discovery V1

The current NAnt task uses a hard coded list of services and version to 
generate, this could/should use discovery so that when API's go live we 
automatically start generating client libs for them.

There is code hanging round to support old discovery versions. We will drop 
support for this soon. every service is available in discovery 0.3 so this 
should not adversly effect anyone. 

Create an ASP.Net Sample