The closest thing I could find was `System.Net.Mime.MediaTypeNames` but that doesn&#39;t seem to have everything (like json) since it seems to be more focused around email attachments.



Is there an enum for the ContentType property on a HttpWebResponse (&quot;text/plain&quot;, &quot;application/octet-stream&quot; etc.)?

What is the exact difference between    

 1. Content-type: text/json 
 2. Content-type: application/json

I&#39;ve been using them randomly and never find any output difference in both http headers?



What is the exact difference between content-type: text/json and application/json?

I&#39;ve written a PHP script that handles file downloads, determining which file is being requested and setting the proper HTTP headers to trigger the browser to actually download the file (rather than displaying it in the browser).

I now have a problem where some users have reported certain files being identified incorrectly (so regardless of extension, the browser will consider it a GIF image). I&#39;m guessing this is because I haven&#39;t set the &quot;Content-type&quot; in the response header. Is this most likely the case? If so, is there a fairly generic type that could be used for all files, rather than trying to account for every possible file type?

Currently I&#39;m only setting the value &quot;Content-disposition: attachment; filename=arandomf.ile&quot;

**Update:** I followed this guide here to build a more robust process for file downloads (http://w-shadow.com/blog/2007/08/12/how-to-force-file-download-with-php/), but there is a significant delay between when the script is executed and when the browser&#39;s download dialog appears. Can anyone identify the bottleneck that is causing this?

Here&#39;s my implementation:

    /**
     * Outputs the specified file to the browser.
     *
     * @param string $filePath the path to the file to output
     * @param string $fileName the name of the file
     * @param string $mimeType the type of file
     */
    function outputFile($filePath, $fileName, $mimeType = &#39;&#39;) {
    	// Setup
    	$mimeTypes = array(
    		&#39;pdf&#39; =&gt; &#39;application/pdf&#39;,
    		&#39;txt&#39; =&gt; &#39;text/plain&#39;,
    		&#39;html&#39; =&gt; &#39;text/html&#39;,
    		&#39;exe&#39; =&gt; &#39;application/octet-stream&#39;,
    		&#39;zip&#39; =&gt; &#39;application/zip&#39;,
    		&#39;doc&#39; =&gt; &#39;application/msword&#39;,
    		&#39;xls&#39; =&gt; &#39;application/vnd.ms-excel&#39;,
    		&#39;ppt&#39; =&gt; &#39;application/vnd.ms-powerpoint&#39;,
    		&#39;gif&#39; =&gt; &#39;image/gif&#39;,
    		&#39;png&#39; =&gt; &#39;image/png&#39;,
    		&#39;jpeg&#39; =&gt; &#39;image/jpg&#39;,
    		&#39;jpg&#39; =&gt; &#39;image/jpg&#39;,
    		&#39;php&#39; =&gt; &#39;text/plain&#39;
    	);
    	
    	$fileSize = filesize($filePath);
    	$fileName = rawurldecode($fileName);
    	$fileExt = &#39;&#39;;
    	
    	// Determine MIME Type
    	if($mimeType == &#39;&#39;) {
    		$fileExt = strtolower(substr(strrchr($filePath, &#39;.&#39;), 1));
    		
    		if(array_key_exists($fileExt, $mimeTypes)) {
    			$mimeType = $mimeTypes[$fileExt];
    		}
    		else {
    			$mimeType = &#39;application/force-download&#39;;
    		}
    	}
    	
    	// Disable Output Buffering
    	@ob_end_clean();
    	
    	// IE Required
    	if(ini_get(&#39;zlib.output_compression&#39;)) {
    		ini_set(&#39;zlib.output_compression&#39;, &#39;Off&#39;);
    	}
    	
    	// Send Headers
    	header(&#39;Content-Type: &#39; . $mimeType);
    	header(&#39;Content-Disposition: attachment; filename=&quot;&#39; . $fileName . &#39;&quot;&#39;);
    	header(&#39;Content-Transfer-Encoding: binary&#39;);
    	header(&#39;Accept-Ranges: bytes&#39;);
    	
    	// Send Headers: Prevent Caching of File
    	header(&#39;Cache-Control: private&#39;);
    	header(&#39;Pragma: private&#39;);
    	header(&#39;Expires: Mon, 26 Jul 1997 05:00:00 GMT&#39;);
    	
    	// Multipart-Download and Download Resuming Support
    	if(isset($_SERVER[&#39;HTTP_RANGE&#39;])) {
    		list($a, $range) = explode(&#39;=&#39;, $_SERVER[&#39;HTTP_RANGE&#39;], 2);
    		list($range) = explode(&#39;,&#39;, $range, 2);
    		list($range, $rangeEnd) = explode(&#39;-&#39;, $range);
    		
    		$range = intval($range);
    		
    		if(!$rangeEnd) {
    			$rangeEnd = $fileSize - 1;
    		}
    		else {
    			$rangeEnd = intval($rangeEnd);
    		}
    		
    		$newLength = $rangeEnd - $range + 1;
    		
    		// Send Headers
    		header(&#39;HTTP/1.1 206 Partial Content&#39;);
    		header(&#39;Content-Length: &#39; . $newLength);
    		header(&#39;Content-Range: bytes &#39; . $range - $rangeEnd / $fileSize);
    	}
    	else {
    		$newLength = $fileSize;
    		header(&#39;Content-Length: &#39; . $fileSize);
    	}
    	
    	// Output File
    	$chunkSize = 1 * (1024*1024);
    	$bytesSend = 0;
    	
    	if($file = fopen($filePath, &#39;r&#39;)) {
    		if(isset($_SERVER[&#39;HTTP_RANGE&#39;])) {
    			fseek($file, $range);
    			
    			while(!feof($file) &amp;&amp; !connection_aborted() &amp;&amp; $bytesSend &lt; $newLength) {
    				$buffer = fread($file, $chunkSize);
    				echo $buffer;
    				flush();
    				$bytesSend += strlen($buffer);
    			}
    			
    			fclose($file);
    		}
    	}
    }

HTTP Headers for File Downloads

I want to get a MIME Content-Type from a given extension (preferably without accessing the physical file). I have seen some questions about this and the methods described to perform this can be resumed in:

 1. Use [registry information][1].
 2. Use [urlmon.dll&#39;s FindMimeFromData][2].
 3. Use [IIS information][3].
 4. Roll your own MIME mapping function. Based on [this table][4], for example.

I&#39;ve been using no.1 for some time but I realized that the information provided by the registry is not consistent and depends on the software installed on the machine. Some extensions, like .zip don&#39;t use to have a Content-Type specified.

Solution no.2 forces me to have the file on disk in order to read the first bytes, which is something slow but may get good results.

The third method is based on Directory Services and all that stuff, which is something I don&#39;t like much because I have to add COM references and I&#39;m not sure it&#39;s consistent between IIS6 and IIS7. Also, I don&#39;t know the performance of this method.

Finally, I didn&#39;t want to use my own table but at the end seems the best option if I want a decent performance and consistency of the results between platforms (even Mono).

Do you think there&#39;s a better option than using my own table or one of other described methods are better? What&#39;s your experience?

  [1]: https://stackoverflow.com/questions/1029740/get-a-mime-from-an-extention/1029796#1029796
  [2]: https://stackoverflow.com/questions/58510/in-c-how-can-you-find-the-mime-type-of-a-file-based-on-the-file-signature-not-th/58570#58570
  [3]: https://stackoverflow.com/questions/174888/asp-net-iis6-how-to-search-the-servers-mime-map/174988#174988
  [4]: http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types

File extensions and MIME Types in .NET

I am uploading a file in php and only want to upload it if it&#39;s a csv file. I believe my syntax is right for the content type. It always goes to else statement when it&#39;s a csv file. What I am doing wrong here?

    if (($_FILES[&quot;file&quot;][&quot;type&quot;] == &quot;text/csv&quot;))
    {
    
    }
    else
    {
    
    }

If I change the content type it works for that format just not csv.

Check file uploaded is in csv format

I have an ASP.NET Web API endpoint with controller action defined as follows : 

    [HttpPost]
    public HttpResponseMessage Post([FromBody] object text)

If my post request body contains plain text ( i.e. should not be interpreted as json, xml, or any other special format ), then I thought I could just include following header to my request : 

    Content-Type: text/plain

However, I receive error : 

    No MediaTypeFormatter is available to read an object of type &#39;Object&#39; from content with media type &#39;text/plain&#39;.

If I change my controller action method signature to : 

    [HttpPost]
    public HttpResponseMessage Post([FromBody] string text)

I get a slightly different error message : 

&gt; No MediaTypeFormatter is available to read an object of type &#39;String&#39; from content with media type &#39;text/plain&#39;.

how to post plain text to ASP.NET Web API endpoint?

I&#39;m downloading some images from a service that doesn&#39;t always include a content-type and doesn&#39;t provide an extension for the file I&#39;m downloading (ugh, don&#39;t ask).

What&#39;s the best way to determine the image format in .NET?

The application that is reading these downloaded images needs to have a proper file extension or all hell breaks loose.

Determine file type of an image

What is the difference between these headers?

    Content-Type: application/javascript
    Content-Type: application/x-javascript
    Content-Type: text/javascript

Which one is best and why?

Please do not say they are identical - if they were identical there would not have been three of them. I know both work - but I would like to know the difference.

Difference between application/x-javascript and text/javascript content types

I&#39;m trying to set the `Content-Type` header of an `HttpClient` object as required by an API I am calling.

I tried setting the `Content-Type` like below:


    using (var httpClient = new HttpClient())
    {
        httpClient.BaseAddress = new Uri(&quot;http://example.com/&quot;);
        httpClient.DefaultRequestHeaders.Add(&quot;Accept&quot;, &quot;application/json&quot;);
        httpClient.DefaultRequestHeaders.Add(&quot;Content-Type&quot;, &quot;application/json&quot;);
        // ...
    }

It allows me to add the `Accept` header but when I try to add `Content-Type` it throws the following exception:

&gt; Misused header name. Make sure request headers are used with
&gt; `HttpRequestMessage`, response headers with `HttpResponseMessage`, and
&gt; content headers with `HttpContent` objects.

How can I set the `Content-Type` header in a `HttpClient` request?

How do you set the Content-Type header for an HttpClient request?

What is the difference between

```
request.ContentType = &quot;application/json; charset=utf-8&quot;;
```
and 

```
request.ContentType = &quot;application/x-www-form-urlencoded&quot;;
```

What are the differences between application/json and application/x-www-form-urlencoded?

As far as I understood there are two places where to set the content type:

 1. The client sets a content type for the body he is sending to the server (e.g. for post)
 2. The server sets a content type for the response.

Does this mean I don&#39;t have to or should not set a content type for all my get requests (client side). And if I can or should what content type would that be?

Also I read in a few posts that the content type of the client specifies what type of content the client would like to receive. So maybe my point 1 is not right?

Do I need a content-type header for HTTP GET requests?

I&#39;m trying to process incoming JSON/Ajax requests with Django/Python.

[`request.is_ajax()`][1] is `True` on the request, but I have no idea where the payload is with the JSON data.

`request.POST.dir` contains this:

    [&#39;__class__&#39;, &#39;__cmp__&#39;, &#39;__contains__&#39;, &#39;__copy__&#39;, &#39;__deepcopy__&#39;, &#39;__delattr__&#39;,
     &#39;__delitem__&#39;, &#39;__dict__&#39;, &#39;__doc__&#39;, &#39;__eq__&#39;, &#39;__ge__&#39;, &#39;__getattribute__&#39;,
    &#39;__getitem__&#39;, &#39;__gt__&#39;, &#39;__hash__&#39;, &#39;__init__&#39;, &#39;__iter__&#39;, &#39;__le__&#39;, &#39;__len__&#39;,
     &#39;__lt__&#39;, &#39;__module__&#39;, &#39;__ne__&#39;, &#39;__new__&#39;, &#39;__reduce__&#39;, &#39;__reduce_ex__&#39;, &#39;__repr__&#39;, 
    &#39;__setattr__&#39;, &#39;__setitem__&#39;, &#39;__str__&#39;, &#39;__weakref__&#39;, &#39;_assert_mutable&#39;, &#39;_encoding&#39;, 
    &#39;_get_encoding&#39;, &#39;_mutable&#39;, &#39;_set_encoding&#39;, &#39;appendlist&#39;, &#39;clear&#39;, &#39;copy&#39;, &#39;encoding&#39;, 
    &#39;fromkeys&#39;, &#39;get&#39;, &#39;getlist&#39;, &#39;has_key&#39;, &#39;items&#39;, &#39;iteritems&#39;, &#39;iterkeys&#39;, &#39;itervalues&#39;, 
    &#39;keys&#39;, &#39;lists&#39;, &#39;pop&#39;, &#39;popitem&#39;, &#39;setdefault&#39;, &#39;setlist&#39;, &#39;setlistdefault&#39;, &#39;update&#39;, 
    &#39;urlencode&#39;, &#39;values&#39;]

There are apparently no keys in the request post keys.

When I look at the POST in [Firebug][2], there is JSON data being sent up in the request.


  [1]: https://docs.djangoproject.com/en/stable/ref/request-response/#django.http.HttpRequest.is_ajax
  [2]: http://en.wikipedia.org/wiki/Firebug

Where&#39;s my JSON data in my incoming Django request?

When creating [email messages][1] you are supposed to set the [Content-Type][2] to `multipart/alternative` when sending HTML and TEXT or `multipart/mixed` when sending TEXT and attachments.

So what do you do if you want to send HTML, Text, and attachments? Use both?


  [1]: http://www.w3.org/Protocols/rfc1341/7_2_Multipart.html
  [2]: http://en.wikipedia.org/wiki/MIME#Content-Type

Mail multipart/alternative vs multipart/mixed

I used to have ElasticSearch 5.2, and just upgraded to 6.0. 

I am trying to create an index template following guide [here](https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-templates.html), but got error

    Content-Type header [application/x-www-form-urlencoded] is not supported

My query is 


    curl -X PUT localhost:9200/_template/template_1 -d &#39;
    {
      &quot;index_patterns&quot;: [&quot;te*&quot;, &quot;bar*&quot;],
      &quot;mappings&quot;: {
        &quot;type1&quot;: {
          &quot;properties&quot;: {
            &quot;host_name&quot;: {
              &quot;type&quot;: &quot;keyword&quot;
            }
          }
        }
      }
    }&#39;

Content-Type header [application/x-www-form-urlencoded] is not supported on Elasticsearch

Suppose I write a REST service whose intent is to add a new data item to a system.

I plan to POST to 

    http://myhost/serviceX/someResources

Suppose that works, what response code should I use? And what content might I return.

I&#39;m looking at the [definitions][1] of HTTP response codes and see these possibilities:

200: Return *an entity describing or containing the result of the action;*

201: which means CREATED. Meaning *The request has been fulfilled and resulted in a new resource being created. The newly created resource can be referenced by the URI(s) returned in the entity of the response, with the most specific URI for the resource given by a Location header field. The response SHOULD include an entity containing a list of resource characteristics and location(s) from which the user or user agent can choose the one most appropriate. The entity format is specified by the media type given in the Content-Type header field. *

The latter sounds more in line with the Http spec, but I&#39;m not at all clear what 

&gt; The response SHOULD include an entity
&gt; containing a list of resource
&gt; characteristics and location(s)

means.

Recommendations? Interpretations?


  [1]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html

Create request with POST, which response codes 200 or 201 and content

I am looking among the standard libraries (like apache commons, jax, jboss, javax) for an interface or enum that lists the values of all the standard mime-type (aka content-type).

This interface should not be encumbered with too deep with other classes that would make it difficult to include the whole bunch as gwt source code.

for example

    interface ContentType{
      String JSON = &quot;Application/JSON&quot;;
      blah ... blah ...
    }

or,

    enum ContentType{
      JSON(&quot;Application/JSON&quot;),
      blah ... blah ...
    }




Interface/enum listing standard mime-type constants

Is there a way to find out the MIME type (or is it called &quot;Content-Type&quot;?) of a file in a Linux bash script?

The reason I need it is because ImageShack appears to need it to upload a file, as for some reason it detects the .png file as an `application/octet-stream` file.
 
I’ve checked the file, and it really is a PNG image:
    
    $ cat /1.png 
    ?PNG
    (with a heap load of random characters)

This gives me the error:

    $ curl -F &quot;fileupload=@/1.png&quot; http://www.imageshack.us/upload_api.php
    &lt;links&gt;
    &lt;error id=&quot;wrong_file_type&quot;&gt;Wrong file type detected for file 1.png:application/octet-stream&lt;/error&gt;
    &lt;/links&gt;


This works, but I need to specify a MIME-TYPE.

    $ curl -F &quot;fileupload=@/1.png;type=image/png&quot; http://www.imageshack.us/upload_api.php

How can I find out a file&#39;s MIME type (Content-Type)?

I have a file upload object on my page: 

    &lt;input type=&quot;file&quot; ID=&quot;fileSelect&quot; /&gt;

with the following excel files on my desktop:

&gt; 1. file1.xlsx 
&gt; 2. file1.xls
&gt; 3. file.csv

   
I want the file upload to ***ONLY*** show `.xlsx`, `.xls`, &amp; `.csv` files. 

Using the `accept` attribute, I found these content-types took care of `.xlsx` &amp; `.xls` extensions... 
&gt; `accept`= application/vnd.openxmlformats-officedocument.spreadsheetml.sheet (.XLSX)
&gt;
&gt; `accept`= application/vnd.ms-excel (.XLS)

However, I cannot find the correct content-type for an Excel CSV file! Any suggestions? 


EXAMPLE: &lt;http://jsfiddle.net/LzLcZ/&gt;

HTML Input=&quot;file&quot; Accept Attribute File Type (CSV)

What I&#39;m trying to do here is get the headers of a given URL so I can determine the MIME type. I want to be able to see if `http://somedomain/foo/` will return an HTML document or a JPEG image for example. Thus, I need to figure out how to send a HEAD request so that I can read the MIME type without having to download the content. Does anyone know of an easy way of doing this?


How do you send a HEAD HTTP request in Python 2?

I&#39;ve seen `application/csv` used and also `text/csv`.

Is there a difference?  Does it matter which as long as the request matches something that&#39;s available?  Are they interchangeable?

What MIME type should I use for CSV?

As far as I know, they are absolute equal. However, browsing some django docs, I&#39;ve
found this piece of code:

`HttpResponse.__init__(content=&#39;&#39;, mimetype=None, status=200, content_type=&#39;text/html&#39;)`

which surprise me the two getting along each other. The official docs was able to solve the issue in a pratical manner:

&gt; content_type is an alias for mimetype.
&gt; Historically, this parameter was only
&gt; called mimetype, but since this is
&gt; actually the value included in the
&gt; HTTP Content-Type header, it can also
&gt; include the character set encoding,
&gt; which makes it more than just a MIME
&gt; type specification. If mimetype is
&gt; specified (not None), that value is
&gt; used. Otherwise, content_type is used.
&gt; If neither is given, the
&gt; DEFAULT_CONTENT_TYPE setting is used.

However, I don&#39;t find it elucidating enough. Why we use 2 different naming for (almost the same) thing? Is &quot;Content-Type&quot; just a name used in browser requests, and with very little use outside it?

What&#39;s the main difference between the each one, and when is right to call something `mimetype` as opposed to `content-type` ? Am I being pitty and grammar nazi?

What&#39;s the difference of ContentType and MimeType

When I have this code

    $.ajax({
        type: &#39;POST&#39;,
        //contentType: &quot;application/json&quot;,
        url: &#39;http://localhost:16329/Hello&#39;,
        data: { name: &#39;norm&#39; },
        dataType: &#39;json&#39;
    });
in Fiddler I can see following raw request

	POST http://localhost:16329/Hello HTTP/1.1
	Host: localhost:16329
	User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:10.0.2) Gecko/20100101 Firefox/10.0.2
	Accept: application/json, text/javascript, */*; q=0.01
	Accept-Language: ru-ru,ru;q=0.8,en-us;q=0.5,en;q=0.3
	Accept-Encoding: gzip, deflate
	Connection: keep-alive
	Content-Type: application/x-www-form-urlencoded; charset=UTF-8
	Referer: http://localhost:14693/WebSite1/index.html
	Content-Length: 9
	Origin: http://localhost:14693
	Pragma: no-cache
	Cache-Control: no-cache

	name=norm

But what I&#39;m trying is to set content-type from **application/x-www-form-urlencoded** to **application/json**. But this code

    $.ajax({
        type: &quot;POST&quot;,
        contentType: &quot;application/json&quot;,
        url: &#39;http://localhost:16329/Hello&#39;,
        data: { name: &#39;norm&#39; },
        dataType: &quot;json&quot;
    });
Generates strange request (which I can see in Fiddler)

	OPTIONS http://localhost:16329/Hello HTTP/1.1
	Host: localhost:16329
	User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:10.0.2) Gecko/20100101 Firefox/10.0.2
	Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
	Accept-Language: ru-ru,ru;q=0.8,en-us;q=0.5,en;q=0.3
	Accept-Encoding: gzip, deflate
	Connection: keep-alive
	Origin: http://localhost:14693
	Access-Control-Request-Method: POST
	Access-Control-Request-Headers: content-type
	Pragma: no-cache
	Cache-Control: no-cache


Why is that? What is OPTIONS when it should be POST there? And where is my content-type set to application/json? And request parameters has gone for some reason.

**UPDATE 1**

On server side I have really simple RESTful service.

    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class RestfulService : IRestfulService
    {
        [WebInvoke(
            Method = &quot;POST&quot;,
            UriTemplate = &quot;Hello&quot;,
            ResponseFormat = WebMessageFormat.Json)]
        public string HelloWorld(string name)
        {
            return &quot;hello, &quot; + name;
        }
    }
But for some reason I can&#39;t call this method with parameters.

**UPDATE 2**

Sorry for not answering so long. 

I&#39;ve added these headers to my server response

     Access-Control-Allow-Origin: *
     Access-Control-Allow-Headers: Content-Type
     Access-Control-Allow-Methods: POST, GET, OPTIONS

It didn&#39;t help, I have **Method not allowed** error from server.

Here is what my fiddler says

![enter image description here][1]

So, now I can be sure that my server accepts *POST, GET, OPTIONS* (if response headers work like I expect). But why &quot;Method not allowed&quot;?

In WebView response from server (you can see *Raw* response on picture above) looks like this

![enter image description here][2]


  [1]: http://i.imgur.com/jIuk0.png
  [2]: http://i.stack.imgur.com/jX2AW.png

Cannot set content-type to &#39;application/json&#39; in jQuery.ajax

I&#39;ve just declared a constant for the &quot;application/json&quot; content type in one of my classes.

    public const string JsonContentType = &quot;application/json&quot;;

I&#39;m not sure it is a good practice.

Does .NET framework have a predefined const for &quot;application/json&quot;?

&quot;application/json&quot; constant in .NET framework

For a number of reasons^, I&#39;d like to use a UUID as a primary key in some of my Django models. If I do so, will I still be able to use outside apps like &quot;contrib.comments&quot;, &quot;django-voting&quot; or &quot;django-tagging&quot; which use generic relations via ContentType?

Using &quot;django-voting&quot; as an example, the Vote model looks like this:

    class Vote(models.Model):
        user         = models.ForeignKey(User)
        content_type = models.ForeignKey(ContentType)
        object_id    = models.PositiveIntegerField()
        object       = generic.GenericForeignKey(&#39;content_type&#39;, &#39;object_id&#39;)
        vote         = models.SmallIntegerField(choices=SCORES)


This app seems to be assuming that the primary key for the model being voted on is an integer. 

The built-in comments app seems to be capable of handling non-integer PKs, though:

    class BaseCommentAbstractModel(models.Model):
        content_type   = models.ForeignKey(ContentType,
                verbose_name=_(&#39;content type&#39;),
                related_name=&quot;content_type_set_for_%(class)s&quot;)
        object_pk      = models.TextField(_(&#39;object ID&#39;))
        content_object = generic.GenericForeignKey(ct_field=&quot;content_type&quot;, fk_field=&quot;object_pk&quot;)

Is this &quot;integer-PK-assumed&quot; problem a common situation for third-party apps which would make using UUIDs a pain? Or, possibly, am I misreading this situation?

Is there a way to use UUIDs as primary keys in Django without causing too much trouble?

&lt;hr/&gt;
^ Some of the reasons: hiding object counts, preventing url &quot;id crawling&quot;, using multiple servers to create non-conflicting objects, ...

Using a UUID as a primary key in Django models (generic relations impact)

The whole question fits in the title. And to add some context: I&#39;m not asking what is the best according to what the specs are saying, but rather what works the best given the mix of browsers deployed nowadays.

Some data points:

* Google uses `text/javascript` for the JS used on their home page.
* Google uses `text/javascript` on Google Docs.
* Google uses `application/x-javascript` to serve JavaScript files with their [Ajax libraries service][1].
* Yahoo uses `application/x-javascript` to serve their JS.
* Yahoo uses `application/x-javascript` for the JavaScript served on their home page.


  [1]: http://code.google.com/apis/ajaxlibs/

When serving JavaScript files, is it better to use the application/javascript or application/x-javascript

Is there a difference between *mimetype*, *contenttype* and *mediatype*? (Java&#39;s JAX-RS [MediaType][2]). 

From the [wikipedia article][1] i gathered that it&#39;s only a content-type in the context of e.g. HTTP requests as a field in a request&#39;s header: So are these just synonyms or are there any actual semantic differences between the different terms?


  [1]: http://en.wikipedia.org/wiki/Internet_media_type
  [2]: http://jackson.codehaus.org/javadoc/jax-rs/1.0/javax/ws/rs/core/MediaType.html

What&#39;s the difference between mediatype, contenttype and mimetype?

Is there a set of constants in the framework for all the [standard content types][1]?


  [1]: http://en.wikipedia.org/wiki/Internet_media_type

ASP MVC - Are there any constants for the default content types?

We have a website hosted on Azure. It is media based, and we are using JWPlayer to playback media with HTTP pseudostreaming. The media files are stored on blob in 3 formats - mp4, ogg, webm.

The issue is the content type of media files is set as application/octet-stream for all types. Due to this there are some issues in media playback and progress bar. 

How can I set the appropriate Content-type of files stored on blob (like - video/mp4, video/ogg, video/webm)?

I do not want to do it manually for each file by going in blob interface. There must be some other way to do it which I am not aware of. Perhaps a config file, settings file, etc sorts. Or perhaps a code block to set up the Content-type for all files stored in a folder.

Any suggestions?
Thanks

Set Content-type of media files stored on Blob

How does one **reliably** determine a file&#39;s type? File extension analysis is not acceptable. There must be a rubyesque tool similar to the UNIX file(1) command?

This is regarding MIME or content type, not file system classifications, such as directory, file, or socket.

Determine file type in Ruby

JSON has [`application/json`][1] as a standard. For protobuf some people use [`application/x-protobuf`][2], but I saw something as odd as [`application/vnd.google.protobuf`][3] being proposed. Do we have an RFC or some other standard that I can use as a reference for this?


  [1]: https://stackoverflow.com/questions/477816/what-is-the-correct-json-content-type
  [2]: https://stackoverflow.com/questions/3190329/protocol-buffers-mime-problem
  [3]: https://groups.google.com/forum/#!topic/protobuf/VAoJ-HtgpAI

What is the correct Protobuf content type?

MS Excel has the following observed MIME types:

 - `application/vnd.ms-excel` (official)
 - `application/msexcel`
 - `application/x-msexcel`
 - `application/x-ms-excel`
 - `application/x-excel`
 - `application/x-dos_ms_excel`
 - `application/xls`
 - `application/x-xls`
 - `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet` (xlsx)

Is there any one type that would work for all versions? If not, do we need to set `response.setContentType()` with each one of these mime types individually?

Also, we use file streaming in our application to display document (not just excel - any type of document). In doing so, how can we retain the filename if the user opts to save the file - currently, the name of the servlet that renders the file appears as the default name.

Setting mime type for excel document

I didn&#39;t see any difference with or without this head information yet.

Is header(&#39;Content-Type:text/plain&#39;); necessary at all?

How to overwrite default Content-Type in nginx? Currently when I request 01.dae file, there&#39;s            

    Content-Type: application/octet-stream;

And I want it to be 

    Content-Type: application/xml;

I tried something like 

    location ~* \.dae$ {
      types { };
      default_type application/xml;
    }

and

    location ~* \.dae$ {
      add_header Content-Type application/xml;
    }

but nothing works.

Force nginx to send specific Content-Type

I am using PHP `mail()` function:
 
        $to      = &#39;AAAA &lt;postmaster@xxx.xx&gt;&#39;;
        $subject = &#39;BBBB&#39;;
        $message = &quot;CCCC\r\nCCCC CCCC \r CCC \n CCC \r\n CCC \n\r CCCC&quot;;
        $headers = &#39;From: DDD&lt;postmaster@xxx.xx&gt;&#39; . &quot;\r\n&quot;;
        $headers .= &quot;Content-Type: text/html; charset=\&quot;UTF-8\&quot;; format=flowed \r\n&quot;;
        $headers .= &quot;Mime-Version: 1.0 \r\n&quot;; 
        $headers .= &quot;Content-Transfer-Encoding: quoted-printable \r\n&quot;;
        mail($to, $subject, $message, $headers);
When I receive this email it looks like this:

    CCCC CCCC CCCC CCC CCC CCC CCCC

I would expect something like this:

    
    CCCC
    CCCC CCCC CCC 
    CCC 
    CCC 
    CCCC

&lt;br&gt;
It works fine without [`Content-Type`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type) HTTP header. How can I make *new lines* and still use my &quot;Content-Type&quot; declaration?

New lines (\r\n) are not working in email body

Using **asp.net core web api**, I want to have my controller action method to return an **jpeg image stream**. &lt;br&gt;
In my current implementation, browser **displays only a json string**.
My expectation is to see the image in the  browser.

While debugging using chrome developer tools I found that the content type is still

`Content-Type:application/json; charset=utf-8` 

 returned in the response header, even though in my code I manually set the content type to &quot;image/jpeg&quot;.

**Looking for a solution**  My Web API is as below

    [HttpGet]
    public async Task&lt;HttpResponseMessage&gt; Get()
    {
        var image = System.IO.File.OpenRead(&quot;C:\\test\random_image.jpeg&quot;);
        var stream = new MemoryStream();

        image.CopyTo(stream);
        stream.Position = 0;            
        result.Content = new StreamContent(image);
        result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue(&quot;attachment&quot;);
        result.Content.Headers.ContentDisposition.FileName = &quot;random_image.jpeg&quot;;
        result.Content.Headers.ContentType = new MediaTypeHeaderValue(&quot;image/jpeg&quot;);
        result.Content.Headers.ContentLength = stream.Length;
         
        return result;
    }

[![enter image description here][1]][1]


  [1]: https://i.stack.imgur.com/bMt50.png

Return jpeg image from Asp.Net Core WebAPI

I have to validate the `Content-Type` header value before passing it to an HTTP request.

Is there a specific list for all the possible values of `Content-Type`?

Otherwise, is there a way to validate the content type before using it in an HTTP request?


What are all the possible values for HTTP &quot;Content-Type&quot; header?

What is the HTTP &quot;content-type&quot; to use when returning a blob of bytes in response to a client&#39;s GET request?

In this case, the information payload is an object serialized using Python&#39;s [Pickle][1] library.


  [1]: http://docs.python.org/2/library/pickle.html

What is the HTTP &quot;content-type&quot; to use for a blob of bytes?

When working with PDFs, I&#39;ve run across the MIME types `application/pdf` and `application/x-pdf` among others. 

Is there a difference between these two types, and if so what is it? Is one preferred over the other?

I&#39;m working on a web app which must deliver huge amounts of PDFs and I want to do it the correct way, if there is one.

Proper MIME media type for PDF files

I&#39;ve noticed that when using $.post() in jquery that the default contentType is application/x-www-form-urlencoded - when my asp.net mvc code needs to have contentType=application/json

(See this question for why I must use application/json: https://stackoverflow.com/questions/2792603/aspnet-mvc-why-is-modelstate-isvalid-false-the-x-field-is-required-when-that)

How can I make $.post() send contentType=application/json? I already have a large number of $.post() functions, so I don&#39;t want to change to $.ajax() because it would take too much time

If I try

    $.post(url, data, function(), &quot;json&quot;) 

It still has contentType=application/x-www-form-urlencoded.  So what exactly does the &quot;json&quot; param do if it does not change the contenttype to json?

If I try

    $.ajaxSetup({
      contentType: &quot;application/json; charset=utf-8&quot;
    });

That works but affects every single $.get and $.post that I have and causes some to break. 

So is there some way that I can change the behavior of $.post() to send contentType=application/json?

Jquery - How to make $.post() use contentType=application/json?

Let&#39;s say I am in the save code. How can I obtain the model&#39;s name or the content type of the object, and use it?

    from django.db import models

    class Foo(models.Model):
        ...
        def save(self):
            I am here....I want to obtain the model_name or the content type of the object

This code works, but I have to know the model_name:

    import django.db.models
    from django.contrib.contenttypes.models import ContentType

    content_type = ContentType.objects.get(model=model_name)
    model = content_type.model_class()

How can I obtain the model&#39;s name or the content type of a Django object?

Curl by default adds headers such as `Content-type` and `User-agent`. Normally that is a good thing but I&#39;m trying to test what our server does when those headers are missing.

My problem is with the `Content-type` header. If it is missing, the server correctly assumes the user sent JSON. However, curl actually adds the missing header and incorrectly assumes that the content I am posting `application/x-www-form-urlencoded`. It also sends an Accept header of */* .

I suppose that is nice default behavior but I basically would like it to not send headers I did not specify. Is there an option for that?

    curl -v -X POST &#39;https://example.com&#39; -d &#39;{...}&#39;

    &gt; User-Agent: curl/7.37.1
    &gt; Host: domain.com
    &gt; Accept: */*
    &gt; Content-Length: 299
    &gt; Content-Type: application/x-www-form-urlencoded

All Content Type Solutions on Gang of Coders

Total of 41 Content Type Solutions