/// <summary>
/// read User by ID pass ID to read user
/// </summary>
/// <param name="Id">id</param>
/// <returns></returns>
public User getUser(long?Id)
{
// create path and map variables
var path = "/user".Replace("{format}", "json");
// query params
var queryParams = new Dictionary <String, String>();
var headerParams = new Dictionary <String, String>();
var formParams = new Dictionary <String, object>();
if (Id != null)
{
queryParams.Add("id", apiInvoker.ParameterToString(Id));
}
try {
if (typeof(User) == typeof(byte[]))
{
var response = apiInvoker.invokeBinaryAPI(basePath, path, "GET", queryParams, null, headerParams, formParams);
return(((object)response) as User);
}
else
{
var response = apiInvoker.invokeAPI(basePath, path, "GET", queryParams, null, headerParams, formParams);
if (response != null)
{
return((User)ApiInvoker.deserialize(response, typeof(User)));
}
else
{
return(null);
}
}
} catch (ApiException ex) {
if (ex.ErrorCode == 404)
{
return(null);
}
else
{
throw ex;
}
}
}
/// <summary>
/// search for users by name-part search for users
/// </summary>
/// <param name="Query">query</param>
/// <returns></returns>
public List <User> searchUsers(string Query)
{
// create path and map variables
var path = "/search".Replace("{format}", "json");
// query params
var queryParams = new Dictionary <String, String>();
var headerParams = new Dictionary <String, String>();
var formParams = new Dictionary <String, object>();
if (Query != null)
{
queryParams.Add("query", apiInvoker.ParameterToString(Query));
}
try {
if (typeof(List <User>) == typeof(byte[]))
{
var response = apiInvoker.invokeBinaryAPI(basePath, path, "GET", queryParams, null, headerParams, formParams);
return(((object)response) as List <User>);
}
else
{
var response = apiInvoker.invokeAPI(basePath, path, "GET", queryParams, null, headerParams, formParams);
if (response != null)
{
return((List <User>)ApiInvoker.deserialize(response, typeof(List <User>)));
}
else
{
return(null);
}
}
} catch (ApiException ex) {
if (ex.ErrorCode == 404)
{
return(null);
}
else
{
throw ex;
}
}
}
/// <summary>
/// Update a single newsletter setting by ID
/// </summary>
/// <param name="id">Mongo ID of newsletter settings to update</param>
/// <param name="vestorlyAuth">Vestorly Auth Token</param>
/// <param name="newsletterSetting">newsletter settings</param>
/// <returns>Newslettersettingresponse</returns>
public Newslettersettingresponse UpdateNewsletterSettingsByID(string id, string vestorlyAuth, NewsletterSettingsInput newsletterSetting)
{
String myPath = "/newsletter_settings/{id}";
if ("vestorlyAuth" == "vestorlyAuth")
{
if (("PUT" == "POST" || "PUT" == "PUT") && "NewslettersettingsApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + vestorlyAuth;
}
}
var _request = new RestRequest(myPath, Method.PUT);
// verify the required parameter 'id' is set
if (id == null)
{
throw new ApiException(400, "Missing required parameter 'id' when calling UpdateNewsletterSettingsByID");
}
// verify the required parameter 'vestorlyAuth' is set
if (vestorlyAuth == null)
{
throw new ApiException(400, "Missing required parameter 'vestorlyAuth' when calling UpdateNewsletterSettingsByID");
}
// verify the required parameter 'newsletterSetting' is set
if (newsletterSetting == null)
{
throw new ApiException(400, "Missing required parameter 'newsletterSetting' when calling UpdateNewsletterSettingsByID");
}
// add default header, if any
foreach (KeyValuePair <string, string> defaultHeader in ApiInvoker.GetDefaultHeader())
{
_request.AddHeader(defaultHeader.Key, defaultHeader.Value);
}
_request.AddUrlSegment("format", "json"); // set format to json by default
_request.AddUrlSegment("id", ApiInvoker.ParameterToString(id)); // path (url segment) parameter
if (vestorlyAuth != null && ("PUT" == "GET" || "PUT" == "DELETE" || "NewslettersettingsApi" == "SessionsApi"))
{
_request.AddParameter("vestorly_auth", ApiInvoker.ParameterToString(vestorlyAuth)); // query parameter
}
_request.AddParameter("application/json", ApiInvoker.Serialize(newsletterSetting), ParameterType.RequestBody); // http body (model) parameter
// make the HTTP request
IRestResponse response = restClient.Execute(_request);
if (((int)response.StatusCode) >= 400)
{
throw new ApiException((int)response.StatusCode, "Error calling UpdateNewsletterSettingsByID: " + response.Content);
}
return((Newslettersettingresponse)ApiInvoker.Deserialize(response.Content, typeof(Newslettersettingresponse)));
}
/// <summary>
/// Creates a new Group
/// </summary>
/// <param name="vestorlyAuth">Vestorly Auth Token</param>
/// <param name="group">Group to add</param>
/// <returns>Groupresponse</returns>
public Groupresponse CreateGroup(string vestorlyAuth, GroupInput group)
{
String myPath = "/groups";
if ("vestorlyAuth" == "vestorlyAuth")
{
if (("POST" == "POST" || "POST" == "PUT") && "GroupsApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + vestorlyAuth;
}
}
var _request = new RestRequest(myPath, Method.POST);
// verify the required parameter 'vestorlyAuth' is set
if (vestorlyAuth == null)
{
throw new ApiException(400, "Missing required parameter 'vestorlyAuth' when calling CreateGroup");
}
// verify the required parameter 'group' is set
if (group == null)
{
throw new ApiException(400, "Missing required parameter 'group' when calling CreateGroup");
}
// add default header, if any
foreach (KeyValuePair <string, string> defaultHeader in ApiInvoker.GetDefaultHeader())
{
_request.AddHeader(defaultHeader.Key, defaultHeader.Value);
}
_request.AddUrlSegment("format", "json"); // set format to json by default
if (vestorlyAuth != null && ("POST" == "GET" || "POST" == "DELETE" || "GroupsApi" == "SessionsApi"))
{
_request.AddParameter("vestorly_auth", ApiInvoker.ParameterToString(vestorlyAuth)); // query parameter
}
_request.AddParameter("application/json", ApiInvoker.Serialize(group), ParameterType.RequestBody); // http body (model) parameter
// make the HTTP request
IRestResponse response = restClient.Execute(_request);
if (((int)response.StatusCode) >= 400)
{
throw new ApiException((int)response.StatusCode, "Error calling CreateGroup: " + response.Content);
}
return((Groupresponse)ApiInvoker.Deserialize(response.Content, typeof(Groupresponse)));
}
/// <summary>
/// Deletes a Group
/// </summary>
/// <param name="vestorlyAuth">Vestorly Auth Token</param>
/// <param name="id">id of group to delete</param>
/// <returns>Groupresponse</returns>
public Groupresponse DeleteGroup(string vestorlyAuth, string id)
{
String myPath = "/groups/{id}";
if ("vestorlyAuth" == "vestorlyAuth")
{
if (("DELETE" == "POST" || "DELETE" == "PUT") && "GroupsApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + vestorlyAuth;
}
}
var _request = new RestRequest(myPath, Method.DELETE);
// verify the required parameter 'vestorlyAuth' is set
if (vestorlyAuth == null)
{
throw new ApiException(400, "Missing required parameter 'vestorlyAuth' when calling DeleteGroup");
}
// verify the required parameter 'id' is set
if (id == null)
{
throw new ApiException(400, "Missing required parameter 'id' when calling DeleteGroup");
}
// add default header, if any
foreach (KeyValuePair <string, string> defaultHeader in ApiInvoker.GetDefaultHeader())
{
_request.AddHeader(defaultHeader.Key, defaultHeader.Value);
}
_request.AddUrlSegment("format", "json"); // set format to json by default
_request.AddUrlSegment("id", ApiInvoker.ParameterToString(id)); // path (url segment) parameter
if (vestorlyAuth != null && ("DELETE" == "GET" || "DELETE" == "DELETE" || "GroupsApi" == "SessionsApi"))
{
_request.AddParameter("vestorly_auth", ApiInvoker.ParameterToString(vestorlyAuth)); // query parameter
}
// make the HTTP request
IRestResponse response = restClient.Execute(_request);
if (((int)response.StatusCode) >= 400)
{
throw new ApiException((int)response.StatusCode, "Error calling DeleteGroup: " + response.Content);
}
return((Groupresponse)ApiInvoker.Deserialize(response.Content, typeof(Groupresponse)));
}
/// <summary>
/// Returns all newsletter settings
/// </summary>
/// <param name="vestorlyAuth">Vestorly Auth Token</param>
/// <returns>NewsletterSettings</returns>
public NewsletterSettings FindNewsletterSettings(string vestorlyAuth)
{
String myPath = "/newsletter_settings";
if ("vestorlyAuth" == "vestorlyAuth")
{
if (("GET" == "POST" || "GET" == "PUT") && "NewslettersettingsApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + vestorlyAuth;
}
}
var _request = new RestRequest(myPath, Method.GET);
// verify the required parameter 'vestorlyAuth' is set
if (vestorlyAuth == null)
{
throw new ApiException(400, "Missing required parameter 'vestorlyAuth' when calling FindNewsletterSettings");
}
// add default header, if any
foreach (KeyValuePair <string, string> defaultHeader in ApiInvoker.GetDefaultHeader())
{
_request.AddHeader(defaultHeader.Key, defaultHeader.Value);
}
_request.AddUrlSegment("format", "json"); // set format to json by default
if (vestorlyAuth != null && ("GET" == "GET" || "GET" == "DELETE" || "NewslettersettingsApi" == "SessionsApi"))
{
_request.AddParameter("vestorly_auth", ApiInvoker.ParameterToString(vestorlyAuth)); // query parameter
}
// make the HTTP request
IRestResponse response = restClient.Execute(_request);
if (((int)response.StatusCode) >= 400)
{
throw new ApiException((int)response.StatusCode, "Error calling FindNewsletterSettings: " + response.Content);
}
return((NewsletterSettings)ApiInvoker.Deserialize(response.Content, typeof(NewsletterSettings)));
}
/// <summary>
/// Returns all articles
/// </summary>
/// <param name="vestorlyAuth">Vestorly Auth Token</param>
/// <param name="limit">Limit on the number of articles to return</param>
/// <param name="textQuery">Search query parameter</param>
/// <param name="sortDirection">Direction of sort (used with sort_by parameter)</param>
/// <param name="sortBy">Field on model to sort by</param>
/// <returns>Articles</returns>
public Articles FindArticles(string vestorlyAuth, int?limit, string textQuery, string sortDirection, string sortBy)
{
String myPath = "/articles";
if ("vestorlyAuth" == "vestorlyAuth")
{
if (("GET" == "POST" || "GET" == "PUT") && "ArticlesApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + vestorlyAuth;
}
}
if ("limit" == "vestorlyAuth")
{
if (("GET" == "POST" || "GET" == "PUT") && "ArticlesApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + limit;
}
}
if ("textQuery" == "vestorlyAuth")
{
if (("GET" == "POST" || "GET" == "PUT") && "ArticlesApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + textQuery;
}
}
if ("sortDirection" == "vestorlyAuth")
{
if (("GET" == "POST" || "GET" == "PUT") && "ArticlesApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + sortDirection;
}
}
if ("sortBy" == "vestorlyAuth")
{
if (("GET" == "POST" || "GET" == "PUT") && "ArticlesApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + sortBy;
}
}
var _request = new RestRequest(myPath, Method.GET);
// verify the required parameter 'vestorlyAuth' is set
if (vestorlyAuth == null)
{
throw new ApiException(400, "Missing required parameter 'vestorlyAuth' when calling FindArticles");
}
// add default header, if any
foreach (KeyValuePair <string, string> defaultHeader in ApiInvoker.GetDefaultHeader())
{
_request.AddHeader(defaultHeader.Key, defaultHeader.Value);
}
_request.AddUrlSegment("format", "json"); // set format to json by default
if (vestorlyAuth != null && ("GET" == "GET" || "GET" == "DELETE" || "ArticlesApi" == "SessionsApi"))
{
_request.AddParameter("vestorly_auth", ApiInvoker.ParameterToString(vestorlyAuth)); // query parameter
}
if (limit != null && ("GET" == "GET" || "GET" == "DELETE" || "ArticlesApi" == "SessionsApi"))
{
_request.AddParameter("limit", ApiInvoker.ParameterToString(limit)); // query parameter
}
if (textQuery != null && ("GET" == "GET" || "GET" == "DELETE" || "ArticlesApi" == "SessionsApi"))
{
_request.AddParameter("text_query", ApiInvoker.ParameterToString(textQuery)); // query parameter
}
if (sortDirection != null && ("GET" == "GET" || "GET" == "DELETE" || "ArticlesApi" == "SessionsApi"))
{
_request.AddParameter("sort_direction", ApiInvoker.ParameterToString(sortDirection)); // query parameter
}
if (sortBy != null && ("GET" == "GET" || "GET" == "DELETE" || "ArticlesApi" == "SessionsApi"))
{
_request.AddParameter("sort_by", ApiInvoker.ParameterToString(sortBy)); // query parameter
}
// make the HTTP request
IRestResponse response = restClient.Execute(_request);
if (((int)response.StatusCode) >= 400)
{
throw new ApiException((int)response.StatusCode, "Error calling FindArticles: " + response.Content);
}
return((Articles)ApiInvoker.Deserialize(response.Content, typeof(Articles)));
}
/// <summary>
/// Login To Vestorly Platform
/// </summary>
/// <param name="username">Username in the vestorly platform</param>
/// <param name="password">Password in Vestorly Platform</param>
/// <returns>Session</returns>
public Session Login(string username, string password)
{
String myPath = "/sessions";
if ("username" == "vestorlyAuth")
{
if (("POST" == "POST" || "POST" == "PUT") && "SessionsApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + username;
}
}
if ("password" == "vestorlyAuth")
{
if (("POST" == "POST" || "POST" == "PUT") && "SessionsApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + password;
}
}
var _request = new RestRequest(myPath, Method.POST);
// verify the required parameter 'username' is set
if (username == null)
{
throw new ApiException(400, "Missing required parameter 'username' when calling Login");
}
// verify the required parameter 'password' is set
if (password == null)
{
throw new ApiException(400, "Missing required parameter 'password' when calling Login");
}
// add default header, if any
foreach (KeyValuePair <string, string> defaultHeader in ApiInvoker.GetDefaultHeader())
{
_request.AddHeader(defaultHeader.Key, defaultHeader.Value);
}
_request.AddUrlSegment("format", "json"); // set format to json by default
if (username != null && ("POST" == "GET" || "POST" == "DELETE" || "SessionsApi" == "SessionsApi"))
{
_request.AddParameter("username", ApiInvoker.ParameterToString(username)); // query parameter
}
if (password != null && ("POST" == "GET" || "POST" == "DELETE" || "SessionsApi" == "SessionsApi"))
{
_request.AddParameter("password", ApiInvoker.ParameterToString(password)); // query parameter
}
// make the HTTP request
IRestResponse response = restClient.Execute(_request);
if (((int)response.StatusCode) >= 400)
{
throw new ApiException((int)response.StatusCode, "Error calling Login: " + response.Content);
}
return((Session)ApiInvoker.Deserialize(response.Content, typeof(Session)));
}
/// <summary>
/// Query all posts
/// </summary>
/// <param name="vestorlyAuth">Vestorly Auth Token</param>
/// <param name="textQuery">Filter post by parameters</param>
/// <param name="externalUrl">Filter by External URL</param>
/// <param name="isPublished">Filter by is_published boolean</param>
/// <returns>Posts</returns>
public Posts FindPosts(string vestorlyAuth, string textQuery, string externalUrl, string isPublished)
{
String myPath = "/posts";
if ("vestorlyAuth" == "vestorlyAuth")
{
if (("GET" == "POST" || "GET" == "PUT") && "PostsApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + vestorlyAuth;
}
}
if ("textQuery" == "vestorlyAuth")
{
if (("GET" == "POST" || "GET" == "PUT") && "PostsApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + textQuery;
}
}
if ("externalUrl" == "vestorlyAuth")
{
if (("GET" == "POST" || "GET" == "PUT") && "PostsApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + externalUrl;
}
}
if ("isPublished" == "vestorlyAuth")
{
if (("GET" == "POST" || "GET" == "PUT") && "PostsApi" != "SessionsApi")
{
myPath += "?vestorly_auth=" + isPublished;
}
}
var _request = new RestRequest(myPath, Method.GET);
// verify the required parameter 'vestorlyAuth' is set
if (vestorlyAuth == null)
{
throw new ApiException(400, "Missing required parameter 'vestorlyAuth' when calling FindPosts");
}
// add default header, if any
foreach (KeyValuePair <string, string> defaultHeader in ApiInvoker.GetDefaultHeader())
{
_request.AddHeader(defaultHeader.Key, defaultHeader.Value);
}
_request.AddUrlSegment("format", "json"); // set format to json by default
if (vestorlyAuth != null && ("GET" == "GET" || "GET" == "DELETE" || "PostsApi" == "SessionsApi"))
{
_request.AddParameter("vestorly_auth", ApiInvoker.ParameterToString(vestorlyAuth)); // query parameter
}
if (textQuery != null && ("GET" == "GET" || "GET" == "DELETE" || "PostsApi" == "SessionsApi"))
{
_request.AddParameter("text_query", ApiInvoker.ParameterToString(textQuery)); // query parameter
}
if (externalUrl != null && ("GET" == "GET" || "GET" == "DELETE" || "PostsApi" == "SessionsApi"))
{
_request.AddParameter("external_url", ApiInvoker.ParameterToString(externalUrl)); // query parameter
}
if (isPublished != null && ("GET" == "GET" || "GET" == "DELETE" || "PostsApi" == "SessionsApi"))
{
_request.AddParameter("is_published", ApiInvoker.ParameterToString(isPublished)); // query parameter
}
// make the HTTP request
IRestResponse response = restClient.Execute(_request);
if (((int)response.StatusCode) >= 400)
{
throw new ApiException((int)response.StatusCode, "Error calling FindPosts: " + response.Content);
}
return((Posts)ApiInvoker.Deserialize(response.Content, typeof(Posts)));
}
