You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
530 lines
21 KiB
530 lines
21 KiB
/*
|
|
* Service Collaborateur API
|
|
*
|
|
* Api du service Collaborateur, utilisée pour récupérer les données des collaborateurs d'Apside
|
|
*
|
|
* OpenAPI spec version: 1.1.3
|
|
* Contact: lilian.gayet@apside-groupe.com
|
|
* Generated by: https://github.com/swagger-api/swagger-codegen.git
|
|
*/
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Text.RegularExpressions;
|
|
using System.IO;
|
|
using System.Web;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Text;
|
|
using Newtonsoft.Json;
|
|
using RestSharp;
|
|
|
|
namespace IO.Swagger.ClientCollaborateur
|
|
{
|
|
/// <summary>
|
|
/// API client is mainly responsible for making the HTTP call to the API backend.
|
|
/// </summary>
|
|
public partial class ApiClient
|
|
{
|
|
private JsonSerializerSettings serializerSettings = new JsonSerializerSettings
|
|
{
|
|
ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
|
|
DateFormatString = "yyyy/MM/dd"
|
|
};
|
|
|
|
/// <summary>
|
|
/// Allows for extending request processing for <see cref="ApiClient"/> generated code.
|
|
/// </summary>
|
|
/// <param name="request">The RestSharp request object</param>
|
|
partial void InterceptRequest(IRestRequest request);
|
|
|
|
/// <summary>
|
|
/// Allows for extending response processing for <see cref="ApiClient"/> generated code.
|
|
/// </summary>
|
|
/// <param name="request">The RestSharp request object</param>
|
|
/// <param name="response">The RestSharp response object</param>
|
|
partial void InterceptResponse(IRestRequest request, IRestResponse response);
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="ApiClient" /> class
|
|
/// with default configuration.
|
|
/// </summary>
|
|
public ApiClient()
|
|
{
|
|
Configuration = IO.Swagger.ClientCollaborateur.Configuration.Default;
|
|
RestClient = new RestClient("https://virtserver.swaggerhub.com/LilianG/Service-Collaborateur/1.1.1");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="ApiClient" /> class
|
|
/// with default base path (https://virtserver.swaggerhub.com/LilianG/Service-Collaborateur/1.1.1).
|
|
/// </summary>
|
|
/// <param name="config">An instance of Configuration.</param>
|
|
public ApiClient(Configuration config)
|
|
{
|
|
Configuration = config ?? IO.Swagger.ClientCollaborateur.Configuration.Default;
|
|
|
|
RestClient = new RestClient(Configuration.BasePath);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="ApiClient" /> class
|
|
/// with default configuration.
|
|
/// </summary>
|
|
/// <param name="basePath">The base path.</param>
|
|
public ApiClient(String basePath = "http://localhost:3000")
|
|
{
|
|
if (String.IsNullOrEmpty(basePath))
|
|
throw new ArgumentException("basePath cannot be empty");
|
|
|
|
RestClient = new RestClient(basePath);
|
|
Configuration = ClientCollaborateur.Configuration.Default;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the default API client for making HTTP calls.
|
|
/// </summary>
|
|
/// <value>The default API client.</value>
|
|
[Obsolete("ApiClient.Default is deprecated, please use 'Configuration.Default.ApiClient' instead.")]
|
|
public static ApiClient Default;
|
|
|
|
/// <summary>
|
|
/// Gets or sets an instance of the IReadableConfiguration.
|
|
/// </summary>
|
|
/// <value>An instance of the IReadableConfiguration.</value>
|
|
/// <remarks>
|
|
/// <see cref="IReadableConfiguration"/> helps us to avoid modifying possibly global
|
|
/// configuration values from within a given client. It does not guarantee thread-safety
|
|
/// of the <see cref="Configuration"/> instance in any way.
|
|
/// </remarks>
|
|
public IReadableConfiguration Configuration { get; set; }
|
|
|
|
/// <summary>
|
|
/// Gets or sets the RestClient.
|
|
/// </summary>
|
|
/// <value>An instance of the RestClient</value>
|
|
public RestClient RestClient { get; set; }
|
|
|
|
// Creates and sets up a RestRequest prior to a call.
|
|
private RestRequest PrepareRequest(
|
|
String path, RestSharp.Method method, List<KeyValuePair<String, String>> queryParams, Object postBody,
|
|
Dictionary<String, String> headerParams, Dictionary<String, String> formParams,
|
|
Dictionary<String, FileParameter> fileParams, Dictionary<String, String> pathParams,
|
|
String contentType)
|
|
{
|
|
var request = new RestRequest(path, method);
|
|
|
|
// add path parameter, if any
|
|
foreach(var param in pathParams)
|
|
request.AddParameter(param.Key, param.Value, ParameterType.UrlSegment);
|
|
|
|
// add header parameter, if any
|
|
foreach(var param in headerParams)
|
|
request.AddHeader(param.Key, param.Value);
|
|
|
|
// add query parameter, if any
|
|
foreach(var param in queryParams)
|
|
request.AddQueryParameter(param.Key, param.Value);
|
|
|
|
// add form parameter, if any
|
|
foreach(var param in formParams)
|
|
request.AddParameter(param.Key, param.Value);
|
|
|
|
// add file parameter, if any
|
|
foreach(var param in fileParams)
|
|
{
|
|
request.AddFile(param.Value.Name, param.Value.Writer, param.Value.FileName, param.Value.ContentLength, param.Value.ContentType);
|
|
}
|
|
|
|
if (postBody != null) // http body (model or byte[]) parameter
|
|
{
|
|
request.AddParameter(contentType, postBody, ParameterType.RequestBody);
|
|
}
|
|
|
|
return request;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Makes the HTTP request (Sync).
|
|
/// </summary>
|
|
/// <param name="path">URL path.</param>
|
|
/// <param name="method">HTTP method.</param>
|
|
/// <param name="queryParams">Query parameters.</param>
|
|
/// <param name="postBody">HTTP body (POST request).</param>
|
|
/// <param name="headerParams">Header parameters.</param>
|
|
/// <param name="formParams">Form parameters.</param>
|
|
/// <param name="fileParams">File parameters.</param>
|
|
/// <param name="pathParams">Path parameters.</param>
|
|
/// <param name="contentType">Content Type of the request</param>
|
|
/// <returns>Object</returns>
|
|
public Object CallApi(
|
|
String path, RestSharp.Method method, List<KeyValuePair<String, String>> queryParams, Object postBody,
|
|
Dictionary<String, String> headerParams, Dictionary<String, String> formParams,
|
|
Dictionary<String, FileParameter> fileParams, Dictionary<String, String> pathParams,
|
|
String contentType)
|
|
{
|
|
var request = PrepareRequest(
|
|
path, method, queryParams, postBody, headerParams, formParams, fileParams,
|
|
pathParams, contentType);
|
|
|
|
// set timeout
|
|
|
|
RestClient.Timeout = Configuration.Timeout;
|
|
// set user agent
|
|
RestClient.UserAgent = Configuration.UserAgent;
|
|
|
|
InterceptRequest(request);
|
|
var response = RestClient.Execute(request);
|
|
InterceptResponse(request, response);
|
|
|
|
return (Object) response;
|
|
}
|
|
/// <summary>
|
|
/// Makes the asynchronous HTTP request.
|
|
/// </summary>
|
|
/// <param name="path">URL path.</param>
|
|
/// <param name="method">HTTP method.</param>
|
|
/// <param name="queryParams">Query parameters.</param>
|
|
/// <param name="postBody">HTTP body (POST request).</param>
|
|
/// <param name="headerParams">Header parameters.</param>
|
|
/// <param name="formParams">Form parameters.</param>
|
|
/// <param name="fileParams">File parameters.</param>
|
|
/// <param name="pathParams">Path parameters.</param>
|
|
/// <param name="contentType">Content type.</param>
|
|
/// <returns>The Task instance.</returns>
|
|
public async System.Threading.Tasks.Task<Object> CallApiAsync(
|
|
String path, RestSharp.Method method, List<KeyValuePair<String, String>> queryParams, Object postBody,
|
|
Dictionary<String, String> headerParams, Dictionary<String, String> formParams,
|
|
Dictionary<String, FileParameter> fileParams, Dictionary<String, String> pathParams,
|
|
String contentType)
|
|
{
|
|
var request = PrepareRequest(
|
|
path, method, queryParams, postBody, headerParams, formParams, fileParams,
|
|
pathParams, contentType);
|
|
InterceptRequest(request);
|
|
var response = await RestClient.ExecuteTaskAsync(request);
|
|
InterceptResponse(request, response);
|
|
return (Object)response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Escape string (url-encoded).
|
|
/// </summary>
|
|
/// <param name="str">String to be escaped.</param>
|
|
/// <returns>Escaped string.</returns>
|
|
public string EscapeString(string str)
|
|
{
|
|
return UrlEncode(str);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create FileParameter based on Stream.
|
|
/// </summary>
|
|
/// <param name="name">Parameter name.</param>
|
|
/// <param name="stream">Input stream.</param>
|
|
/// <returns>FileParameter.</returns>
|
|
public FileParameter ParameterToFile(string name, Stream stream)
|
|
{
|
|
if (stream is FileStream)
|
|
return FileParameter.Create(name, ReadAsBytes(stream), Path.GetFileName(((FileStream)stream).Name));
|
|
else
|
|
return FileParameter.Create(name, ReadAsBytes(stream), "no_file_name_provided");
|
|
}
|
|
|
|
/// <summary>
|
|
/// If parameter is DateTime, output in a formatted string (default ISO 8601), customizable with Configuration.DateTime.
|
|
/// If parameter is a list, join the list with ",".
|
|
/// Otherwise just return the string.
|
|
/// </summary>
|
|
/// <param name="obj">The parameter (header, path, query, form).</param>
|
|
/// <returns>Formatted string.</returns>
|
|
public string ParameterToString(object obj)
|
|
{
|
|
if (obj is DateTime)
|
|
// Return a formatted date string - Can be customized with Configuration.DateTimeFormat
|
|
// Defaults to an ISO 8601, using the known as a Round-trip date/time pattern ("o")
|
|
// https://msdn.microsoft.com/en-us/library/az4se3k1(v=vs.110).aspx#Anchor_8
|
|
// For example: 2009-06-15T13:45:30.0000000
|
|
return ((DateTime)obj).ToString (Configuration.DateTimeFormat);
|
|
else if (obj is DateTimeOffset)
|
|
// Return a formatted date string - Can be customized with Configuration.DateTimeFormat
|
|
// Defaults to an ISO 8601, using the known as a Round-trip date/time pattern ("o")
|
|
// https://msdn.microsoft.com/en-us/library/az4se3k1(v=vs.110).aspx#Anchor_8
|
|
// For example: 2009-06-15T13:45:30.0000000
|
|
return ((DateTimeOffset)obj).ToString (Configuration.DateTimeFormat);
|
|
else if (obj is IList)
|
|
{
|
|
var flattenedString = new StringBuilder();
|
|
foreach (var param in (IList)obj)
|
|
{
|
|
if (flattenedString.Length > 0)
|
|
flattenedString.Append(",");
|
|
flattenedString.Append(param);
|
|
}
|
|
return flattenedString.ToString();
|
|
}
|
|
else
|
|
return Convert.ToString (obj);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deserialize the JSON string into a proper object.
|
|
/// </summary>
|
|
/// <param name="response">The HTTP response.</param>
|
|
/// <param name="type">Object type.</param>
|
|
/// <returns>Object representation of the JSON string.</returns>
|
|
public object Deserialize(IRestResponse response, Type type)
|
|
{
|
|
IList<Parameter> headers = response.Headers;
|
|
if (type == typeof(byte[])) // return byte array
|
|
{
|
|
return response.RawBytes;
|
|
}
|
|
|
|
// TODO: ? if (type.IsAssignableFrom(typeof(Stream)))
|
|
if (type == typeof(Stream))
|
|
{
|
|
if (headers != null)
|
|
{
|
|
var filePath = String.IsNullOrEmpty(Configuration.TempFolderPath)
|
|
? Path.GetTempPath()
|
|
: Configuration.TempFolderPath;
|
|
var regex = new Regex(@"Content-Disposition=.*filename=['""]?([^'""\s]+)['""]?$");
|
|
foreach (var header in headers)
|
|
{
|
|
var match = regex.Match(header.ToString());
|
|
if (match.Success)
|
|
{
|
|
string fileName = filePath + SanitizeFilename(match.Groups[1].Value.Replace("\"", "").Replace("'", ""));
|
|
File.WriteAllBytes(fileName, response.RawBytes);
|
|
return new FileStream(fileName, FileMode.Open);
|
|
}
|
|
}
|
|
}
|
|
var stream = new MemoryStream(response.RawBytes);
|
|
return stream;
|
|
}
|
|
|
|
if (type.Name.StartsWith("System.Nullable`1[[System.DateTime")) // return a datetime object
|
|
{
|
|
return DateTime.Parse(response.Content, null, System.Globalization.DateTimeStyles.RoundtripKind);
|
|
}
|
|
|
|
if (type == typeof(String) || type.Name.StartsWith("System.Nullable")) // return primitive type
|
|
{
|
|
return ConvertType(response.Content, type);
|
|
}
|
|
|
|
// at this point, it must be a model (json)
|
|
try
|
|
{
|
|
return JsonConvert.DeserializeObject(response.Content, type, serializerSettings);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new ApiException(500, e.Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serialize an input (model) into JSON string
|
|
/// </summary>
|
|
/// <param name="obj">Object.</param>
|
|
/// <returns>JSON string.</returns>
|
|
public String Serialize(object obj)
|
|
{
|
|
try
|
|
{
|
|
return obj != null ? JsonConvert.SerializeObject(obj) : null;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new ApiException(500, e.Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///Check if the given MIME is a JSON MIME.
|
|
///JSON MIME examples:
|
|
/// application/json
|
|
/// application/json; charset=UTF8
|
|
/// APPLICATION/JSON
|
|
/// application/vnd.company+json
|
|
/// </summary>
|
|
/// <param name="mime">MIME</param>
|
|
/// <returns>Returns True if MIME type is json.</returns>
|
|
public bool IsJsonMime(String mime)
|
|
{
|
|
var jsonRegex = new Regex("(?i)^(application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(;.*)?$");
|
|
return mime != null && (jsonRegex.IsMatch(mime) || mime.Equals("application/json-patch+json"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Select the Content-Type header's value from the given content-type array:
|
|
/// if JSON type exists in the given array, use it;
|
|
/// otherwise use the first one defined in 'consumes'
|
|
/// </summary>
|
|
/// <param name="contentTypes">The Content-Type array to select from.</param>
|
|
/// <returns>The Content-Type header to use.</returns>
|
|
public String SelectHeaderContentType(String[] contentTypes)
|
|
{
|
|
if (contentTypes.Length == 0)
|
|
return "application/json";
|
|
|
|
foreach (var contentType in contentTypes)
|
|
{
|
|
if (IsJsonMime(contentType.ToLower()))
|
|
return contentType;
|
|
}
|
|
|
|
return contentTypes[0]; // use the first content type specified in 'consumes'
|
|
}
|
|
|
|
/// <summary>
|
|
/// Select the Accept header's value from the given accepts array:
|
|
/// if JSON exists in the given array, use it;
|
|
/// otherwise use all of them (joining into a string)
|
|
/// </summary>
|
|
/// <param name="accepts">The accepts array to select from.</param>
|
|
/// <returns>The Accept header to use.</returns>
|
|
public String SelectHeaderAccept(String[] accepts)
|
|
{
|
|
if (accepts.Length == 0)
|
|
return null;
|
|
|
|
if (accepts.Contains("application/json", StringComparer.OrdinalIgnoreCase))
|
|
return "application/json";
|
|
|
|
return String.Join(",", accepts);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encode string in base64 format.
|
|
/// </summary>
|
|
/// <param name="text">String to be encoded.</param>
|
|
/// <returns>Encoded string.</returns>
|
|
public static string Base64Encode(string text)
|
|
{
|
|
return System.Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(text));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dynamically cast the object into target type.
|
|
/// </summary>
|
|
/// <param name="fromObject">Object to be casted</param>
|
|
/// <param name="toObject">Target type</param>
|
|
/// <returns>Casted object</returns>
|
|
public static dynamic ConvertType(dynamic fromObject, Type toObject)
|
|
{
|
|
return Convert.ChangeType(fromObject, toObject);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert stream to byte array
|
|
/// </summary>
|
|
/// <param name="inputStream">Input stream to be converted</param>
|
|
/// <returns>Byte array</returns>
|
|
public static byte[] ReadAsBytes(Stream inputStream)
|
|
{
|
|
byte[] buf = new byte[16*1024];
|
|
using (MemoryStream ms = new MemoryStream())
|
|
{
|
|
int count;
|
|
while ((count = inputStream.Read(buf, 0, buf.Length)) > 0)
|
|
{
|
|
ms.Write(buf, 0, count);
|
|
}
|
|
return ms.ToArray();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// URL encode a string
|
|
/// Credit/Ref: https://github.com/restsharp/RestSharp/blob/master/RestSharp/Extensions/StringExtensions.cs#L50
|
|
/// </summary>
|
|
/// <param name="input">String to be URL encoded</param>
|
|
/// <returns>Byte array</returns>
|
|
public static string UrlEncode(string input)
|
|
{
|
|
const int maxLength = 32766;
|
|
|
|
if (input == null)
|
|
{
|
|
throw new ArgumentNullException("input");
|
|
}
|
|
|
|
if (input.Length <= maxLength)
|
|
{
|
|
return Uri.EscapeDataString(input);
|
|
}
|
|
|
|
StringBuilder sb = new StringBuilder(input.Length * 2);
|
|
int index = 0;
|
|
|
|
while (index < input.Length)
|
|
{
|
|
int length = Math.Min(input.Length - index, maxLength);
|
|
string subString = input.Substring(index, length);
|
|
|
|
sb.Append(Uri.EscapeDataString(subString));
|
|
index += subString.Length;
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sanitize filename by removing the path
|
|
/// </summary>
|
|
/// <param name="filename">Filename</param>
|
|
/// <returns>Filename</returns>
|
|
public static string SanitizeFilename(string filename)
|
|
{
|
|
Match match = Regex.Match(filename, @".*[/\\](.*)$");
|
|
|
|
if (match.Success)
|
|
{
|
|
return match.Groups[1].Value;
|
|
}
|
|
else
|
|
{
|
|
return filename;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert params to key/value pairs.
|
|
/// Use collectionFormat to properly format lists and collections.
|
|
/// </summary>
|
|
/// <param name="name">Key name.</param>
|
|
/// <param name="value">Value object.</param>
|
|
/// <returns>A list of KeyValuePairs</returns>
|
|
public IEnumerable<KeyValuePair<string, string>> ParameterToKeyValuePairs(string collectionFormat, string name, object value)
|
|
{
|
|
var parameters = new List<KeyValuePair<string, string>>();
|
|
|
|
if (IsCollection(value) && collectionFormat == "multi")
|
|
{
|
|
var valueCollection = value as IEnumerable;
|
|
parameters.AddRange(from object item in valueCollection select new KeyValuePair<string, string>(name, ParameterToString(item)));
|
|
}
|
|
else
|
|
{
|
|
parameters.Add(new KeyValuePair<string, string>(name, ParameterToString(value)));
|
|
}
|
|
|
|
return parameters;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if generic object is a collection.
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <returns>True if object is a collection type</returns>
|
|
private static bool IsCollection(object value)
|
|
{
|
|
return value is IList || value is ICollection;
|
|
}
|
|
}
|
|
}
|
|
|