webapi, how to read the file from a POST/PUT actio

I have the following react component, which apparently its working fine:

import React, { Component } from 'react';
import { Row, Col } from 'antd';
import PageHeader from '../../components/utility/pageHeader';
import Box from '../../components/utility/box';
import LayoutWrapper from '../../components/utility/layoutWrapper.js';
import ContentHolder from '../../components/utility/contentHolder';
import basicStyle from '../../settings/basicStyle';
import IntlMessages from '../../components/utility/intlMessages';
import { adalApiFetch } from '../../adalConfig';

export default class extends Component {
  constructor(props) {
    super(props);
    this.state = {TenantId: '', TenantUrl: '', TenantPassword: '' };
    this.handleChangeTenantUrl = this.handleChangeTenantUrl.bind(this);
    this.handleChangeTenantPassword = this.handleChangeTenantPassword.bind(this);
    this.handleChangeTenantId= this.handleChangeTenantId.bind(this);
    this.handleSubmit = this.handleSubmit.bind(this);
  };


  handleChangeTenantUrl(event){
    this.setState({TenantUrl: event.target.value});
  }

  handleChangeTenantPassword(event){
    this.setState({TenantPassword: event.target.value});
  }

  handleChangeTenantId(event){
    this.setState({TenantId: event.target.value});
  }

  handleSubmit(event){
    event.preventDefault();

    let data = new FormData();
    //Append files to form data
    data.append("model", {"TenantId": this.state.TenantId, "TenantUrl": this.state.TenantUrl, "TenantPassword": this.state.TenantPassword });

    let files = this.state.selectedFiles;
    for (let i = 0; i < files.length; i++) {
      data.append("file", files[i], files[i].name);
    }

    const options = {
      method: 'put',
      body: data,
      config: {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      }
    };

    adalApiFetch(fetch, "/Tenant", options)
      .then(response => response.json())
      .then(responseJson => {
        if (!this.isCancelled) {
          this.setState({ data: responseJson });
        }
      })
      .catch(error => {
        console.error(error);
      });
  }


  upload(e){
    let files = e.target.files;
    this.setState({ 'selectedFiles': files });
}

  render(){
    const { data } = this.state;
    const { rowStyle, colStyle, gutter } = basicStyle;

    return (
      <div>
        <LayoutWrapper>
        <PageHeader>{<IntlMessages id="pageTitles.TenantAdministration" />}</PageHeader>
        <Row style={rowStyle} gutter={gutter} justify="start">
          <Col md={12} sm={12} xs={24} style={colStyle}>
            <Box
              title={<IntlMessages id="pageTitles.TenantAdministration" />}
              subtitle={<IntlMessages id="pageTitles.TenantAdministration" />}
            >
              <ContentHolder>
              <form onSubmit={this.handleSubmit}>
                <label>
                  TenantId:
                  <input type="text" value={this.state.TenantId} onChange={this.handleChangeTenantId} />
                </label>
                <label>
                  TenantUrl:
                  <input type="text" value={this.state.TenantUrl} onChange={this.handleChangeTenantUrl} />
                </label>
                <label>
                  TenantPassword:
                  <input type="text" value={this.state.TenantPassword} onChange={this.handleChangeTenantPassword} />
                </label>
                <label>
                  Certificate:
                  <input onChange = { e => this.upload(e) } type = "file" id = "files" ref = { file => this.fileUpload } />
                </label>            
              <input type="submit" value="Submit" />
              </form>
              </ContentHolder>
            </Box>
          </Col>
        </Row>
      </LayoutWrapper>
      </div>
    );
  }
}

However, I have a custom model binder like this:

public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            if (bindingContext.ModelType != typeof(Tenant))
            {
                return false;
            }

            var task = Task.Run(async () =>
            {
                var model = new Tenant();

                if (!actionContext.Request.Content.IsMimeMultipartContent())
                {
                    bindingContext.ModelState.AddModelError(bindingContext.ModelName, "WebRequeest content 'multipart/form-data' is valid");
                }
                else
                {
                    var provider = await actionContext.Request.Content.ReadAsMultipartAsync();

                    var fileContent = provider.Contents.FirstOrDefault(n => n.Headers.ContentDisposition.Name.Equals("file"));
                    if (fileContent == null)
                    {
                        bindingContext.ModelState.AddModelError(bindingContext.ModelName, "Section 'file' is missed");
                    }

                    var modelContent = provider.Contents.FirstOrDefault(n => n.Headers.ContentDisposition.Name.Equals("model"));
                    if (modelContent == null)
                    {
                        bindingContext.ModelState.AddModelError(bindingContext.ModelName, "Section 'model' is missed");
                    }

                    if (fileContent != null && modelContent != null)
                    {
                        model = JsonConvert.DeserializeObject<Tenant>(await modelContent.ReadAsStringAsync());
                        //model.Text = "<NativeTranslation>";
                        model.ContentType = provider.Contents[0].Headers.ContentType.MediaType;
                        model.CertificateFile = await fileContent.ReadAsByteArrayAsync();
                        //model.TenantId = fileContent.Headers.ContentDisposition.FileName;
                    }
                }

                return model;
            });

            task.Wait();

            bindingContext.Model = task.Result;
            return true;
        }
    }

but filecontent is null and model is null too

Update 1:

I didn't expect this, but it seems you have to include quotes when checking the name of the ContentDispositionHeader.

For file, instead of

var fileContent = provider.Contents.FirstOrDefault(n => n.Headers.ContentDisposition.Name.Equals("file"));

it must be

var fileContent = provider.Contents.FirstOrDefault(n => n.Headers.ContentDisposition.Name.Equals(@"""file"""));

For model it must be

var modelContent = provider.Contents.FirstOrDefault(n => n.Headers.ContentDisposition.Name.Equals(@"""model"""));

If you inspect the file in Visual Studio's Immediate Window via provider.Contents[0].Headers.ContentDisposition (might be index [1] for you) you see the output below.
Notice the difference in quotes between DispositionType: "form-data" and Name: "\"file\"", although both are of type String.

{form-data; name="file"; filename="upload.txt"}
    CreationDate: null
    DispositionType: "form-data"
    FileName: "\"upload.txt\""
    FileNameStar: null
    ModificationDate: null
    Name: "\"file\""
    Parameters: Count = 2
    ReadDate: null
    Size: null

I'm no React developer (yet), so I couldn't execute my Web APIcode via your React script, but I used this simple html form here below ... similar concept.
I see the same behaviour when posting via a tool like eg. Fiddler.

<html>
<head>
</head>
<body>
    <form method="post" enctype="multipart/form-data" action="http://url-to-your-webapi-controller-method-here">
        <input type="file" name="file" />
        <input type="text" name="model" />
        <input type="submit" />
    </form>
</body>
</html>