// GET: Menus/Delete/id
public async Task <IActionResult> Delete(int?id)
{
return(View(await RestHelper.ApiGet <Menu>(menuApi, id)));
}
public void WhenIGetAWebChatByID()
{
url = envSettings.BaseUrl + "webchats/api/Customers/" + customerId + "/Interactions/" + interactionId + "/webchats/" + webChatId;
response = RestHelper.Get(url, envSettings.TouchPointId, envSettings.SubscriptionKey);
}
public async Task <IActionResult> Create([Bind("Id,Name")] Menu menu)
{
await RestHelper.ApiCreate <Menu>(menuApi, menu);
return(RedirectToAction("Index"));
}
public void WhenIGetAnAdviserByID()
{
url = envSettings.BaseUrl + "adviserdetails/api/AdviserDetails/" + adviserDetailId;
response = RestHelper.Get(url, envSettings.TouchPointId, envSettings.SubscriptionKey);
}
public void WhenIGetAnOutcomeByID()
{
url = envSettings.BaseUrl + "outcomes/api/Customers/" + customerId + "/Interactions/" + interactionId + "/ActionPlans/" + actionPlanId + "/outcomes/" + outcomeId;
response = RestHelper.Get(url, envSettings.TouchPointId, envSettings.SubscriptionKey);
}
/// <summary>
/// execute as an asynchronous operation.
/// </summary>
/// <param name="controllerContext">The controller context for a single HTTP operation.</param>
/// <param name="cancellationToken">The cancellation token assigned for the HTTP operation.</param>
/// <returns>The newly started task.</returns>
public override async Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
var fullUrl = controllerContext.Request.RequestUri.PathAndQuery;
var routeTemplate = controllerContext.RouteData.Route.RouteTemplate;
var routeTemplateLower = routeTemplate.ToLower();
var controllerEnd = routeTemplateLower.IndexOf("{controller}", StringComparison.Ordinal);
if (controllerEnd == -1)
{
throw new NotSupportedException("Can only handle host controllers accessed through a route template that includes a {controller} definition.");
}
controllerEnd += 13;
var routeTemplateFragment = routeTemplate.Substring(0, controllerEnd);
if (!routeTemplateFragment.EndsWith("/"))
{
routeTemplateFragment = routeTemplateFragment.Substring(0, routeTemplateFragment.Length - 1);
}
var slashCount = routeTemplateFragment.Occurs("/");
if (fullUrl.StartsWith("/") && !routeTemplateFragment.StartsWith("/"))
{
fullUrl = fullUrl.Substring(1);
}
var urlFragmentStartPosition = fullUrl.At("/", slashCount);
var urlFragment = string.Empty;
if (urlFragmentStartPosition > 0)
{
urlFragment = fullUrl.Substring(urlFragmentStartPosition);
}
var httpMethod = controllerContext.Request.Method.Method.ToUpper();
CheckContractInterface();
var method = RestHelper.GetMethodNameFromUrlFragmentAndContract(urlFragment, httpMethod, _contractType);
if (method == null)
{
throw new NotSupportedException("Refusing request");
}
if (httpMethod == "GET")
{
var urlParameters = RestHelper.GetUrlParametersFromUrlFragmentAndContract(urlFragment, httpMethod, _contractType);
var parameters = method.GetParameters();
if (parameters.Length != 1)
{
throw new NotSupportedException("Only service methods/operations with a single input parameter can be mapped to REST-GET operations. Method " + method.Name + " has " + parameters.Length + " parameters. Consider changing the method to have a single object with multiple properties instead.");
}
var parameterType = parameters[0].ParameterType;
var parameterObject = Activator.CreateInstance(parameterType);
foreach (var propertyName in urlParameters.Keys)
{
var urlProperty = parameterType.GetProperty(propertyName);
if (urlProperty == null)
{
continue;
}
urlProperty.SetValue(parameterObject, urlParameters[propertyName], null);
}
object result;
try
{
result = method.Invoke(_host, new[] { parameterObject });
}
catch (TargetException ex)
{
throw new TargetException("Service " + _host.GetType() + " does not implement interface " + _contractType + ".", ex);
}
var json = JsonHelper.SerializeToRestJson(result);
var response = new HttpResponseMessage {
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
return(response);
}
else
{
var parameters = method.GetParameters();
if (parameters.Length != 1)
{
throw new NotSupportedException("Only service methods/operations with a single input parameter can be mapped to REST-GET operations. Method " + method.Name + " has " + parameters.Length + " parameters. Consider changing the method to have a single object with multiple properties instead.");
}
var parameterType = parameters[0].ParameterType;
var formatter = new JsonMediaTypeFormatter();
var stream = await controllerContext.Request.Content.ReadAsStreamAsync();
var parameterObject = await formatter.ReadFromStreamAsync(parameterType, stream, controllerContext.Request.Content, null);
object result;
try
{
result = method.Invoke(_host, new[] { parameterObject });
}
catch (TargetException ex)
{
throw new TargetException("Service " + _host.GetType() + " does not implement interface " + _contractType + ".", ex);
}
var json = JsonHelper.SerializeToRestJson(result);
var response = new HttpResponseMessage {
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
return(response);
}
}
public void WhenIGetACustomerByID()
{
url = envSettings.BaseUrl + "customers/api/customers/" + customerId;
response = RestHelper.Get(url, envSettings.TouchPointId, envSettings.SubscriptionKey);
}
public async Task <ActionResult> Add(string url, string version)
{
var ctx = new APIDiscoveryContext();
if (ModelState.IsValid)
{
RestHelper helper = new RestHelper();
try
{
var status = await helper.Ping(url, version);
if (status != null && status.status.ToLower() == Constants.ASTE_PINGSTATUS_SUCCESS)
{
try
{
var config = await helper.Config(url, version);
if (config != null)
{
if (config.type.ToLower() == Constants.ASTE_MODULETYPE_PROCESS)
{
Module new_module = new Module();
new_module.name = config.name;
new_module.created = DateTime.Now;
new_module.guid = config.guid;
new_module.description = config.description;
new_module.author = config.author;
new_module.authorContact = config.authorContact;
new_module.isProcess = true;
new_module.methods = new List <ModuleMethod>();
new_module.my_dependencies = new List <ModuleDependency>();
new_module.api_url = url;
new_module.version = version;
if (config.methods != null)
{
foreach (var m in config.methods)
{
new_module.methods.Add(new ModuleMethod()
{
created = new DateTime(),
name = m.method,
methodInfo = m.@params
});
}
}
var dependency_not_found = false;
foreach (var d in config.dependencies)
{
var db_module = ctx.modules.Where(x => x.guid == d).FirstOrDefault();
if (db_module == null)
{
ModelState.AddModelError("Config", "Process dependency {0} was not found, could not install API to discovery");
dependency_not_found = true;
break;
}
else
{
new_module.my_dependencies.Add(new ModuleDependency()
{
created = DateTime.Now,
dependency_id = db_module.id,
name = db_module.name
});
}
}
if (!dependency_not_found)
{
ctx.modules.Add(new_module);
ctx.SaveChanges();
}
}
else
{
ModelState.AddModelError("Config", "Contacted api is a module, not a process");
return(View("New", new Models.newModelOrProcess()
{
url = url, version = version
}));
}
}
else
{
ModelState.AddModelError("Config", "config did not return any data");
return(View("New", new Models.newModelOrProcess()
{
url = url, version = version
}));
}
}
catch (Exception ex)
{
ModelState.AddModelError("Config", "Url of the API could not be resolved, or the service is not listening - config method");
return(View("New", new Models.newModelOrProcess()
{
url = url, version = version
}));
}
}
else
{
ModelState.AddModelError("Ping", status.message);
return(View("New", new Models.newModelOrProcess()
{
url = url, version = version
}));
}
}
catch (Exception ex)
{
ModelState.AddModelError("Ping", "Url of the API could not be resolved, or the service is not listening - ping method");
return(View("New", new Models.newModelOrProcess()
{
url = url, version = version
}));
}
return(RedirectToAction("Index", "Process"));
}
return(View("New", new Models.newModelOrProcess()
{
url = url, version = version
}));
}
public static Task <ListTunnelsResult> ListTunnels()
{
return(RestHelper.CallGetMethodAsync <ListTunnelsResult>(ApiProvider, Method, settings: Settings));
}
static async Task <ApiConversation <StudyDto, TResponse> > Update <TResponse>(RestHelper restHelper, int studyId, StudyDto studyDto)
{
var response = await restHelper.PutAsForm <TResponse, StudyDto>($"api/studies/{studyId}/details", "study", studyDto);
return(new ApiConversation <StudyDto, TResponse>(studyDto, response));
}
public virtual IHttpActionResult Get(int?pageNumber = null, int?pageSize = null, string filter = null, string sort = null, string search = null, bool?deep = null, bool descriptive = true)
{
try
{
Durados.Web.Mvc.View view = (Durados.Web.Mvc.View)Maps.Instance.DuradosMap.Database.Views[viewName];
if (view == null)
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NotFound, string.Format(Messages.ViewNameNotFound, viewName))));
}
if (!IsAllow(view))
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.Forbidden, Messages.ViewIsUnauthorized)));
}
int rowCount = 0;
Dictionary <string, object>[] filterArray = null;
if (!string.IsNullOrEmpty(filter) && filter != "filter" && filter != "false" && filter != "null" && filter != "undefined" && filter != "[{}]")
{
if (filter == "(Collection)")
{
filter = "[" + System.Web.HttpContext.Current.Request.Params["filter"] + "]";
}
if (filter.StartsWith("{"))
{
filter = "[" + filter + "]";
}
try
{
filterArray = JsonConverter.DeserializeArray(filter);
}
catch (Exception exception)
{
Map.Logger.Log(GetControllerNameForLog(this.ControllerContext), "get", exception.Source, exception, 1, "Deserialize filter " + filter + ", original: " + System.Web.HttpContext.Current.Request.Params["filter"]);
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NotAcceptable, Messages.StringifyFilter)));
}
}
Dictionary <string, object>[] sortArray = null;
if (!string.IsNullOrEmpty(sort) && sort != "sort" && sort != "false" && sort != "null" && sort != "undefined" && sort != "[{}]")
{
if (sort == "(Collection)")
{
sort = "[" + System.Web.HttpContext.Current.Request.Params["sort"] + "]";
}
if (sort.StartsWith("{"))
{
sort = "[" + sort + "]";
}
try
{
sortArray = JsonConverter.DeserializeArray(sort);
}
catch (Exception exception)
{
Map.Logger.Log(GetControllerNameForLog(this.ControllerContext), "get", exception.Source, exception, 1, "Deserialize sort " + sort + ", original: " + System.Web.HttpContext.Current.Request.Params["sort"]);
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NotAcceptable, Messages.StringifySort)));
}
}
if (search == "null" || search == "undefined")
{
search = null;
}
var items = RestHelper.Get(view, false, false, pageNumber ?? 1, pageSize ?? 200, filterArray, search, sortArray, out rowCount, deep ?? false, view_BeforeSelect, view_AfterSelect, false, descriptive, true);
return(Ok(items));
}
catch (FilterException exception)
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NotAcceptable, exception.Message)));
}
catch (SortException exception)
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NotAcceptable, exception.Message)));
}
catch (Exception exception)
{
throw new BackAndApiUnexpectedResponseException(exception, this);
}
}
public static async Task <ApiConversation <StudyDto, Common.Dto.ErrorResponse> > UpdateAndExpectFailure(RestHelper restHelper, int studyId, StudyDto studyDto)
{
return(await Update <Common.Dto.ErrorResponse>(restHelper, studyId, studyDto));
}
public static async Task <ApiConversation <StudyDto, StudyDto> > UpdateAndExpectSuccess(RestHelper restHelper, int studyId, StudyDto studyDto)
{
return(await Update <StudyDto>(restHelper, studyId, studyDto));
}
protected void Page_Load(object sender, EventArgs e)
{
var openIdRelyingParty = new OpenIdRelyingParty();
var openid_identifier = ConfigurationManager.AppSettings["openid_identifier"];
var returnUrl = "~/OpenID/Connect";
var response = openIdRelyingParty.GetResponse();
if (response == null)
{
// Stage 2: user submitting Identifier
Identifier id;
if (Identifier.TryParse(openid_identifier, out id))
{
IAuthenticationRequest request = openIdRelyingParty.CreateRequest(openid_identifier);
FetchRequest fetch = new FetchRequest();
fetch.Attributes.Add(new AttributeRequest(WellKnownAttributes.Contact.Email));
fetch.Attributes.Add(new AttributeRequest(WellKnownAttributes.Name.FullName));
fetch.Attributes.Add(new AttributeRequest("http://axschema.org/intuit/realmId"));
request.AddExtension(fetch);
request.RedirectToProvider();
}
}
else
{
if (response.FriendlyIdentifierForDisplay == null)
{
Response.Redirect("~/OpenID/Connect");
}
// Stage 3: OpenID Provider sending assertion response
//Session["FriendlyIdentifier"] = response.FriendlyIdentifierForDisplay;
FetchResponse fetch = response.GetExtension <FetchResponse>();
if (fetch != null)
{
var openIdEmail = fetch.GetAttributeValue(WellKnownAttributes.Contact.Email);
var openIdFullName = fetch.GetAttributeValue(WellKnownAttributes.Name.FullName);
var openIdRealmId = fetch.GetAttributeValue("http://axschema.org/intuit/realmId");
string userName = Membership.GetUserNameByEmail(openIdEmail);
if (userName == null)
{
Membership.CreateUser(openIdEmail, Guid.NewGuid().ToString(), openIdEmail);
FormsAuthentication.SetAuthCookie(openIdEmail, true);
if (Request.QueryString["Subscribe"] != null)
{
String csname = "DirectConnectScript";
Type cstype = this.GetType();
ClientScriptManager csm = Page.ClientScript;
// Check to see if the startup script is already registered.
if (!csm.IsStartupScriptRegistered(cstype, csname))
{
StringBuilder cstext = new StringBuilder();
cstext.AppendLine("<script>");
cstext.AppendLine("$(document).ready(function () {");
cstext.AppendLine("intuit.ipp.anywhere.directConnectToIntuit();");
cstext.AppendLine("});");
cstext.AppendLine("</script>");
csm.RegisterStartupScript(cstype, csname, cstext.ToString());
}
}
}
else if (Request.QueryString["Disconnect"] != null)
{
RestHelper.clearProfile(IppRealmOAuthProfile.Read());
Response.Redirect("~/ManageConnection");
}
else if (userName != null)
{
FormsAuthentication.SetAuthCookie(userName, true);
if (!string.IsNullOrEmpty(returnUrl))
{
Response.Redirect("~/Default");
}
}
}
}
}
public void Prepare(string address)
{
WebRequest = RestHelper.PrepareGet(address);
}
// INDEX: /Activities
public async Task <IActionResult> Index()
{
return(View(await RestHelper.ApiGet <Activity>(api)));
}
public async Task <ModuleInfo> GetActiveModules(string module, string method, string version, string source)
{
RestHelper rs = new RestHelper();
Helper helper = new Helper();
var api_key = helper.GetApiKey(Request);
await rs.Log("Incoming getActiveModule call from: " + source + " at " + helper.GetClientIp(Request));
if (string.IsNullOrEmpty(module))
{
await rs.Log("GetActiveModule failed: Missing module name from " + source + " at " + helper.GetClientIp(Request));
HttpResponseMessage no_name_response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Format("module name cannot be empty"));
throw new HttpResponseException(no_name_response);
}
if (string.IsNullOrEmpty(method))
{
await rs.Log("GetActiveModule failed: Missing module method from " + source + " at " + helper.GetClientIp(Request));
HttpResponseMessage no_method_response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Format("module method cannot be empty"));
throw new HttpResponseException(no_method_response);
}
if (string.IsNullOrEmpty(version))
{
await rs.Log("GetActiveModule failed: Missing module version from " + source + " at " + helper.GetClientIp(Request));
HttpResponseMessage no_version_response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Format("module version cannot be empty"));
throw new HttpResponseException(no_version_response);
}
if (string.IsNullOrEmpty(source))
{
await rs.Log("GetActiveModule failed: Missing module source at " + helper.GetClientIp(Request));
HttpResponseMessage no_source_response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Format("module source cannot be empty"));
throw new HttpResponseException(no_source_response);
}
if (!string.IsNullOrEmpty(api_key))
{
var exists = ctx.clients.Where(x => x.api_key == api_key && !x.isdeleted).FirstOrDefault();
if (exists != null)
{
var activeModules = ctx.modules.Where(x => !x.isdeleted && x.active && !x.isProcess && x.name == module).ToList();
if (activeModules == null)
{
var module_not_found_message = string.Format("Module {0} not found from: " + source + " at " + helper.GetClientIp(Request), module);
await rs.Log(module_not_found_message);
HttpResponseMessage response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Format("Module {0} not found", module));
throw new HttpResponseException(response);
}
var VersionFound = false;
var MethodFound = false;
foreach (var m in activeModules)
{
if (m.version == version)
{
VersionFound = true;
foreach (var moduleMethod in m.methods)
{
if (moduleMethod.name == method)
{
MethodFound = true;
ModuleInfo info = new ModuleInfo()
{
api_url = m.api_url,
name = m.name,
version = m.version
};
return(info);
}
}
}
}
if (!VersionFound)
{
var version_not_found_message = string.Format("Version {0} is not available for module {1} from: " + source + " at " + helper.GetClientIp(Request), version, module);
await rs.Log(version_not_found_message);
HttpResponseMessage version_response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Format("Version {0} is not available for module {1}.", version, module));
throw new HttpResponseException(version_response);
}
if (!MethodFound)
{
var method_not_found_message = string.Format("method {0} is not available for module {1} version {2} from: " + source + " at " + helper.GetClientIp(Request), method, module, version);
await rs.Log(method_not_found_message);
HttpResponseMessage method_response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Format("method {0} is not available for module {1} version {2}.", method, module, version));
throw new HttpResponseException(method_response);
}
var message = string.Format("Version {0} is not available for module {1} from: " + source + " at " + helper.GetClientIp(Request), version, module);
await rs.Log(message);
HttpResponseMessage error_response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Error while fetching module information");
throw new HttpResponseException(error_response);
}
else
{
var message = string.Format("Invalid API key from: " + source + " at " + helper.GetClientIp(Request));
await rs.Log(message);
HttpResponseMessage response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid API key.");
throw new HttpResponseException(response);
}
}
else
{
var message = string.Format("API key missing from: " + source + " at " + helper.GetClientIp(Request));
await rs.Log(message);
HttpResponseMessage response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "API key missing.");
throw new HttpResponseException(response);
}
}
public async Task <IActionResult> Create([Bind("Id,Description,Location,Price,StartTime,EndTime")] Activity activity)
{
await RestHelper.ApiCreate <Activity>(api, activity);
return(RedirectToAction("Index"));
}
protected override void ExecuteCmdlet()
{
var overwriteExisting = true;
if (ParameterSpecified(nameof(OutPath)))
{
if (!System.IO.Path.IsPathRooted(OutPath))
{
OutPath = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, OutPath);
}
if (System.IO.Directory.Exists(OutPath))
{
throw new PSArgumentException("Please specify a folder including a filename");
}
if (System.IO.File.Exists(OutPath))
{
if (Force || ShouldContinue($"File '{OutPath}' exists. Overwrite?", "Export Flow"))
{
overwriteExisting = true;
}
else
{
overwriteExisting = false;
}
}
}
if (!overwriteExisting)
{
return; // exit cmdlet
}
var environmentName = Environment.GetName();
var flowName = Identity.GetName();
if (AsZipPackage)
{
var postData = new
{
baseResourceIds = new[] {
$"/providers/Microsoft.Flow/flows/{flowName}"
}
};
var wrapper = RestHelper.PostAsync <PackageResourceWrapper>(HttpClient, $"https://management.azure.com/providers/Microsoft.BusinessAppPlatform/environments/{environmentName}/listPackageResources?api-version=2016-11-01", AccessToken, payload: postData).GetAwaiter().GetResult();
if (wrapper.Status == "Succeeded")
{
foreach (var resource in wrapper.Resources)
{
if (resource.Value.Type == "Microsoft.Flow/flows")
{
resource.Value.SuggestedCreationType = "Update";
}
else
{
resource.Value.SuggestedCreationType = "Existing";
}
}
dynamic details = new System.Dynamic.ExpandoObject();
var exportPostData = new
{
includedResourceIds = new[] {
$"/providers/Microsoft.Flow/flows/{flowName}"
},
details = new
{
displayName = PackageDisplayName,
description = PackageDescription,
creator = PackageCreatedBy,
sourceEnvironment = PackageSourceEnvironment
},
resources = wrapper.Resources
};
var resultElement = RestHelper.PostAsync <JsonElement>(HttpClient, $"https://management.azure.com/providers/Microsoft.BusinessAppPlatform/environments/{environmentName}/exportPackage?api-version=2016-11-01", AccessToken, payload: exportPostData).GetAwaiter().GetResult();
if (resultElement.TryGetProperty("status", out JsonElement statusElement))
{
if (statusElement.GetString() == "Succeeded")
{
if (resultElement.TryGetProperty("packageLink", out JsonElement packageLinkElement))
{
if (packageLinkElement.TryGetProperty("value", out JsonElement valueElement))
{
var packageLink = valueElement.GetString();
using (var requestMessage = new HttpRequestMessage(HttpMethod.Get, packageLink))
{
//requestMessage.Headers.Add("Authorization", $"Bearer {AccessToken}");
var response = HttpClient.SendAsync(requestMessage).GetAwaiter().GetResult();
var byteArray = response.Content.ReadAsByteArrayAsync().GetAwaiter().GetResult();
var fileName = string.Empty;
if (ParameterSpecified(nameof(OutPath)))
{
if (!System.IO.Path.IsPathRooted(OutPath))
{
OutPath = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, OutPath);
}
fileName = OutPath;
if (System.IO.Directory.Exists(fileName))
{
}
if (System.IO.File.Exists(fileName))
{
}
}
else
{
fileName = new System.Text.RegularExpressions.Regex("([^\\/]+\\.zip)").Match(packageLink).Value;
fileName = System.IO.Path.Combine(SessionState.Path.CurrentFileSystemLocation.Path, fileName);
}
System.IO.File.WriteAllBytes(fileName, byteArray);
var returnObject = new PSObject();
returnObject.Properties.Add(new PSNoteProperty("Filename", fileName));
WriteObject(returnObject);
}
}
}
}
}
}
}
else
{
var json = RestHelper.PostAsync(HttpClient, $"https://management.azure.com/providers/Microsoft.ProcessSimple/environments/{environmentName}/flows/{flowName}/exportToARMTemplate?api-version=2016-11-01", AccessToken).GetAwaiter().GetResult();
WriteObject(json);
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Description,Location,Price,StartTime,EndTime")] Activity activity)
{
await RestHelper.ApiEdit <Activity>(api + id, activity);
return(RedirectToAction("Index", "Activities"));
}
public void WhenIGetAnAddressByID()
{
url = envSettings.BaseUrl + "addresses/api/Customers/" + customerId + "/Addresses/" + addressId;
response = RestHelper.Get(url, envSettings.TouchPointId, envSettings.SubscriptionKey);
}
// GET: Activities/Delete/5
public async Task <IActionResult> Delete(int?id)
{
return(View(await RestHelper.ApiGet <Activity>(api, id)));
}
public void WhenIGetAContactByID()
{
url = envSettings.BaseUrl + "contactDetails/api/Customers/" + customerId + "/contactDetails/" + contactId;
response = RestHelper.Get(url, envSettings.TouchPointId, envSettings.SubscriptionKey);
}
/// <summary>
/// execute as an asynchronous operation.
/// </summary>
/// <param name="controllerContext">The controller context for a single HTTP operation.</param>
/// <param name="cancellationToken">The cancellation token assigned for the HTTP operation.</param>
/// <returns>The newly started task.</returns>
public override async Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
var lowerFullCalledUri = controllerContext.Request.RequestUri.AbsoluteUri.ToLower();
if (HttpsMode == ControllerHttpsMode.RequireHttps && !lowerFullCalledUri.StartsWith("https://"))
{
throw new AccessViolationException("Service must be called over a secure connection (HTTPS)");
}
if (HttpsMode == ControllerHttpsMode.RequireHttpsExceptLocalhost && !lowerFullCalledUri.StartsWith("https://") && controllerContext.Request.RequestUri.Host.ToLower() != "localhost")
{
throw new AccessViolationException("Service must be called over a secure connection (HTTPS)");
}
var fullUrl = controllerContext.Request.RequestUri.PathAndQuery;
var applicationPath = controllerContext.Request.GetRequestContext().VirtualPathRoot;
fullUrl = fullUrl.Substring(applicationPath.Length);
var routeTemplate = controllerContext.RouteData.Route.RouteTemplate;
fullUrl = RemoveMeaninglessUrlSegments(fullUrl, routeTemplate);
routeTemplate = RemoveMeaninglessUrlSegments(routeTemplate, routeTemplate);
var routeTemplateLower = routeTemplate.ToLower();
// First, we figure out where the controller information is in the URL, which we can then discard, since the controller has already been invoked (otherwise, we wouldn't have gotten here)
const string controllerPatternString = "{controller}";
var controllerStart = routeTemplateLower.IndexOf(controllerPatternString, StringComparison.Ordinal);
if (controllerStart == -1)
{
throw new NotSupportedException("Can only handle host controllers accessed through a route template that includes a {controller} definition.");
}
var controllerEnd = controllerStart + controllerPatternString.Length;
var routeTemplateUpToController = routeTemplateLower.Substring(0, controllerEnd);
var slashCountUpToController = routeTemplateUpToController.Occurs("/");
var firstCharAfterController = routeTemplate.Substring(controllerEnd, 1);
// We get the URL Fragment with everything before the controller removed
string urlFragmentUpToController;
if (slashCountUpToController > 0)
{
var currentFragment = fullUrl;
var positionOfLastSlash = 0;
for (var slashCounter = 0; slashCounter < slashCountUpToController; slashCounter++)
{
var currentIndex = currentFragment.IndexOf('/');
if (currentIndex < 0)
{
throw new NotSupportedException("Invalid URL pattern detected. Can't process current request");
}
positionOfLastSlash += currentIndex;
currentFragment = currentFragment.Substring(currentIndex + 1);
}
urlFragmentUpToController = fullUrl.Substring(positionOfLastSlash + 1);
}
else
{
urlFragmentUpToController = fullUrl;
}
// We find the first special character after the controller, which is the start of the parameters
var firstCharAfterControllerIndex = urlFragmentUpToController.IndexOf(firstCharAfterController, StringComparison.Ordinal);
var urlFragment = firstCharAfterControllerIndex < 0 ? string.Empty : urlFragmentUpToController.Substring(firstCharAfterControllerIndex);
var httpMethod = controllerContext.Request.Method.Method.ToUpper();
CheckContractInterface();
if (httpMethod == "OPTIONS" && EnableCors)
{
var response = new HttpResponseMessage {
Content = new StringContent(string.Empty)
};
HandleCors(controllerContext, response);
return(response);
}
var method = RestHelper.GetMethodNameFromUrlFragmentAndContract(urlFragment, httpMethod, _contractType);
if (method == null)
{
throw new NotSupportedException("Refusing request: " + fullUrl);
}
if (httpMethod == "GET" || httpMethod == "HEAD" || httpMethod == "TRACE" || httpMethod == "DELETE" || httpMethod == "CONNECT" || httpMethod == "MKCOL" || httpMethod == "COPY" || httpMethod == "MOVE" || httpMethod == "UNLOCK")
{
// These verbs/http-methods do NOT have a body that is posted
var urlParameters = RestHelper.GetUrlParametersFromUrlFragmentAndContract(urlFragment, httpMethod, _contractType);
var parameters = method.GetParameters();
if (parameters.Length != 1)
{
throw new NotSupportedException("Only service methods/operations with a single input parameter can be mapped to REST-GET operations. Method " + method.Name + " has " + parameters.Length + " parameters. Consider changing the method to have a single object with multiple properties instead.");
}
var parameterType = parameters[0].ParameterType;
var parameterObject = Activator.CreateInstance(parameterType);
foreach (var propertyName in urlParameters.Keys)
{
var urlProperty = parameterType.GetProperty(propertyName);
if (urlProperty == null)
{
continue;
}
urlProperty.SetValue(parameterObject, urlParameters[propertyName], null);
}
BeforeInvokeMethod(controllerContext, method.Name, httpMethod, method, parameterObject);
object result;
try
{
result = method.Invoke(_host, new[] { parameterObject });
}
catch
{
var errorResponse = new HttpResponseMessage(HttpStatusCode.NotAcceptable)
{
ReasonPhrase = "Error invoking service operation."
};
HandleCors(controllerContext, errorResponse);
return(errorResponse);
}
BeforeCreatingResponse(result, controllerContext, method.Name, httpMethod, method);
var json = JsonHelper.SerializeToRestJson(result, JsonPropertyCaseMode == JsonPropertyCaseMode.ForceCamelCase);
var response = new HttpResponseMessage {
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
BeforeReturningResponse(response, json, controllerContext, method.Name, httpMethod, method, result);
HandleCors(controllerContext, response);
return(response);
}
else
{
var parameters = method.GetParameters();
if (parameters.Length != 1)
{
throw new NotSupportedException("Only service methods/operations with a single input parameter can be mapped to REST-GET operations. Method " + method.Name + " has " + parameters.Length + " parameters. Consider changing the method to have a single object with multiple properties instead.");
}
var parameterType = parameters[0].ParameterType;
var formatter = new JsonMediaTypeFormatter();
var stream = await controllerContext.Request.Content.ReadAsStreamAsync();
object parameterObject;
try
{
parameterObject = await formatter.ReadFromStreamAsync(parameterType, stream, controllerContext.Request.Content, null);
}
catch
{
var errorResponse = new HttpResponseMessage(HttpStatusCode.NotAcceptable)
{
ReasonPhrase = "Error invoking service operation: Invalid input parameter."
};
HandleCors(controllerContext, errorResponse);
return(errorResponse);
}
BeforeInvokeMethod(controllerContext, method.Name, httpMethod, method, parameterObject);
object result;
try
{
result = method.Invoke(_host, new[] { parameterObject });
}
catch
{
var errorResponse = new HttpResponseMessage(HttpStatusCode.NotAcceptable)
{
ReasonPhrase = "Error invoking service operation."
};
HandleCors(controllerContext, errorResponse);
return(errorResponse);
}
BeforeCreatingResponse(result, controllerContext, method.Name, httpMethod, method);
var json = JsonHelper.SerializeToRestJson(result, JsonPropertyCaseMode == JsonPropertyCaseMode.ForceCamelCase);
var response = new HttpResponseMessage {
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
BeforeReturningResponse(response, json, controllerContext, method.Name, httpMethod, method, result);
HandleCors(controllerContext, response);
return(response);
}
}
public void WhenIGetASessionByID()
{
url = envSettings.BaseUrl + "sessions/api/Customers/" + customerId + "/Interactions/" + interactionId + "/sessions/" + sessionId;
response = RestHelper.Get(url, envSettings.TouchPointId, envSettings.SubscriptionKey);
}
static async Task <ApiConversation <SandboxCreateDto, TResponse> > Create <TResponse>(RestHelper restHelper, int studyId, string sandboxName = "sandboxName", string region = "norwayeast")
{
var request = new SandboxCreateDto()
{
Name = sandboxName, Region = region
};
var response = await restHelper.Post <TResponse, SandboxCreateDto>(String.Format(ApiUrls.STUDY_SANDBOXES, studyId), request);
return(new ApiConversation <SandboxCreateDto, TResponse>(request, response));
}
public async Task <IActionResult> DeleteConfirmed(int id)
{
await RestHelper.ApiDelete <Menu>(menuApi, id);
return(RedirectToAction(nameof(Index)));
}
public static async Task <ApiConversation <SandboxCreateDto, SandboxDetails> > CreateAndExpectSuccess(RestHelper restHelper, int studyId, string sandboxName = "sandboxName", string region = "norwayeast")
{
return(await Create <SandboxDetails>(restHelper, studyId, sandboxName, region));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name")] Menu menu)
{
await RestHelper.ApiEdit <Menu>(menuApi + id, menu);
return(RedirectToAction("Index", "Menus"));
}
public static async Task <ApiConversation <SandboxCreateDto, Common.Dto.ErrorResponse> > CreateAndExpectFailure(RestHelper restHelper, int studyId, string sandboxName = "sandboxName", string region = "norwayeast")
{
return(await Create <Common.Dto.ErrorResponse>(restHelper, studyId, sandboxName, region));
}
public async Task<string> Process(string json)
{
//Serialize given json to model
dynamic model = JsonConvert.DeserializeObject(json.ToString());
//Get Api key from request headers
var api_key = Request.Headers.Where(x => x.Key == "api_key").FirstOrDefault();
if (api_key.Value != null)
{
string process = "";
string method = "";
string version = "";
//Check mandatory values
if (model["process"] == null)
{
HttpResponseMessage response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Mandatory parameter missing: process");
throw new HttpResponseException(response);
}
else
{
//Get process to be called from model
process = model["process"];
}
if (model["method"] == null)
{
HttpResponseMessage response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Mandatory parameter missing: method");
throw new HttpResponseException(response);
}
else
{
//Get process method from model
method = model["method"];
}
if (model["version"] == null)
{
HttpResponseMessage response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Mandatory parameter missing: version");
throw new HttpResponseException(response);
}
else
{
//Get Version
version = model["version"];
}
//Create Resthelper
RestHelper<object> rh = new RestHelper<object>();
//Get Process info from API Discovery
var data = await rh.GetConfig(process, method, api_key.Value.FirstOrDefault().ToString(), version);
if(data == null)
{
//If process was not found, or process is not activated, return bad request
HttpResponseMessage response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Process not found.");
throw new HttpResponseException(response);
}
else
{
//Get process url from API Data
var url = data.api_url;
//Call Process
var response = await rh.CallGetProcess(data.name,version, method, model["parameters"], url, api_key.Value.FirstOrDefault().ToString());
//Return Data to APP
return response;
}
}
else
{
//API Key missing, returning bad request
HttpResponseMessage response = this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "API key missing.");
throw new HttpResponseException(response);
}
}
public CustomerUiService()
{
Customers = new ObservableCollection<CustomerViewModel>();
CustomersGroup = new ObservableCollection<AlphaKeyGroup<CustomerViewModel>>();
_restClient = new RestHelper(Common.ServiceUrl);
}
