public HttpStatusCode AddRule(GatewayViewModel inputData)
{
//GatewayViewModel inputData = (GatewayViewModel)TempData["ipData"];
inputData.operation = Operations.AddRule.ToString();
var result = ApiOperations.ExecutivePutApi(_apiHostedUrl, inputData);
if (result == HttpStatusCode.OK)
{
_resultset.Add(new Resultcs()
{
Message = "Rule created successfully", Status = "Completed", State = true
});
return(HttpStatusCode.OK);
}
else
{
_resultset.Add(new Resultcs()
{
Message = "Unable to create Rule", Status = "Error", State = false
});
}
return(HttpStatusCode.BadRequest);
}
public async Task <IActionResult> RegisterGateway(GatewayViewModel model)
{
var response = new ApiResponseModel();
if (!ModelState.IsValid)
{
response.SetMessage("INVALID_INPUT").SetData(ModelState.Values.SelectMany(v => v.Errors));
return(Json(response));
}
var insertResult = await _gatewayBusiness.Add(new GatewayDto
{
SerialNumber = model.SerialNumber,
FirmwareVersion = model.FirmwareVersion,
State = model.State,
IP = model.IP,
Port = model.Port
});
response
.SetStatus(insertResult.Success)
.SetMessage(insertResult.Message)
.SetData(insertResult.Data);
return(Json(response));
}
public async Task <ActionResult> Edit(GatewayViewModel data)
{
try
{
if (ModelState.IsValid)
{
var gateway = mapper.Map <Gateway>(data);
await gatewayService.UpdateGatewayAsync(gateway);
await gatewayService.SaveChangesAsync();
TempData["success"] = true;
TempData["msg"] = "Gateway edited successfully";
return(RedirectToAction("Index"));
}
return(View(data));
}
catch
{
return(View(data));
}
}
public ActionResult Gateway(int paymentId, string currency, string commerceReturnUrl)
{
var payment = _paymentService.Find(paymentId);
var model = new GatewayViewModel
{
Description = payment.Description,
PaymentId = paymentId,
Amount = payment.Amount,
Currency = currency,
CommerceReturnUrl = commerceReturnUrl
};
return(View(model));
}
public async Task <IActionResult> GetGateway([FromRoute] int id)
{
var model = new GatewayViewModel();
try
{
model = _mapper.Map <GatewayViewModel>(await _gatewayRepository.Queryable().Include(d => d.Devices).Where(d => d.Id == id).FirstAsync());
}
catch (Exception e)
{
return(NotFound());
}
return(Ok(model));
}
/// <summary>
/// Get text for the non-barcode part of the label.
/// </summary>
/// <param name="vm">View Model from which to extract data.</param>
/// <returns>List of lines to use for the label.</returns>
private List <string> GetDescriptiveTextLines(GatewayViewModel vm)
{
var lines = new List <string>(3);
// Future, test for type and set up "Tag" or "Node".
// if (vm.SerialNumber.SerialNumberType...
string topLine = string.Format(
Local.Resources.LabelLineOneFormat,
Local.Resources.LabelTag,
Local.Resources.LabelTagVersionNumber);
lines.Add(topLine);
lines.Add(Local.Resources.LabelOverviewUri);
lines.Add(Local.Resources.LabelFccId);
return(lines);
}
public async Task <IActionResult> PostGateway([FromBody] GatewayViewModel model)
{
if (!ModelState.IsValid || !IsIPv4(model.GatewayIpAddress))
{
return(BadRequest("Invalid model"));
}
try
{
var gateway = _mapper.Map <Gateway>(model);
_gatewayRepository.Create(gateway);
await _unitOfWork.SaveChangesAsync();
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(Ok());
}
public async Task <IHttpActionResult> UpdateGatewayAsync([FromBody] GatewayViewModel gatewayviewmodel)
{
try
{
if (gatewayviewmodel == null)
{
return(new BadRequestError("GATEWAY OBJECT IS NULL"));
}
var gateway = mapper.Map <Gateway>(gatewayviewmodel);
await gatewayService.UpdateGatewayAsync(gateway);
var result = await gatewayService.SaveChangesAsync();
return(Ok(result));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public HttpStatusCode AddAddHttpSettings(GatewayViewModel inputData)
{
//var inputData = (GatewayViewModel)TempData["ipData"];
if (TempData["myData"] != null)
{
_resultset = TempData["myData"] as List <Resultcs>;
}
TempData.Keep();
inputData.operation = Operations.AddHTTPSettings.ToString();
var result = ApiOperations.ExecutivePutApi(_apiHostedUrl, inputData);
if (result == HttpStatusCode.OK)
{
_resultset.Add(new Resultcs()
{
Message = "HttpSettings created successfully", Status = "Completed", State = true
});
//RedirectToAction("AddBackendAddressPool", "Gateway");
return(AddBackendAddressPool(inputData));
}
else
{
_resultset.Add(new Resultcs()
{
Message = "Failed to create HttpSettings", Status = "Error", State = false
});
_resultset.Add(new Resultcs()
{
Message = "Unable to create BackendAddressPool", Status = "Not Performed", State = false
});
_resultset.Add(new Resultcs()
{
Message = "Unable to create Rule", Status = "Not Performed", State = false
});
}
return(HttpStatusCode.BadRequest);
}
public async Task <IActionResult> PutGateway([FromRoute] int id, [FromBody] GatewayViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
model.GatewayId = id;
var gateway = _mapper.Map <Gateway>(model);
_gatewayRepository.Update(gateway);
await _unitOfWork.SaveChangesAsync();
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(Ok());
}
public static HttpStatusCode ExecutivePutApi(string apiUri, GatewayViewModel probObject)
{
string jsonInput = JsonConvert.SerializeObject(probObject);
var httpContent = new StringContent(jsonInput, Encoding.UTF8, "application/json");
using (var client = new HttpClient())
{
try
{
client.BaseAddress = new Uri(apiUri);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", probObject.brearerToken);
var responseTask = client.PutAsync(apiUri, httpContent);
responseTask.Wait();
var result = responseTask.Result;
return(result.StatusCode);
}
catch (HttpRequestException)
{
//Console.WriteLine(e.InnerException.Message);
return(HttpStatusCode.BadRequest);
}
}
}
public ActionResult AddProbe(UserInputModel inputData)
{
GatewayViewModel apiInputData = new GatewayViewModel();
apiInputData.operation = Operations.CreateProbe.ToString();
apiInputData.SubscriptionId = Constant.subscriptionId;
apiInputData.ResourceGroupName = Constant.resourceGroupName;
apiInputData.ApplicationGatewayName = Constant.applicationGatewayName;
apiInputData.ProbeName = inputData.FIName + "CustomHealthProbe";
apiInputData.Protocol = inputData.Protocol;
apiInputData.Host = inputData.Host;
apiInputData.Probepath = inputData.Probepath;
apiInputData.HttpSettingsName = inputData.FIName + "AppGatewayHTTPSettings";
apiInputData.HttpSettingsPort = inputData.Port;
apiInputData.BckendPoolName = inputData.FIName + "AppGWBackendpool";
apiInputData.BckendipAddress = inputData.Host;
apiInputData.RuleName = inputData.FIName;
apiInputData.RulePath = inputData.RulePath;
apiInputData.brearerToken = inputData.BrearerToken;
var result = ApiOperations.ExecutivePutApi(_apiHostedUrl, apiInputData);
if (result == HttpStatusCode.OK)
{
_resultset.Add(new Resultcs()
{
Message = "Probe created successfully", Status = "Completed", State = true
});
AddAddHttpSettings(apiInputData);
}
else
{
_resultset.Add(new Resultcs()
{
Message = "Failed to create Probe", Status = "Error", State = false
});
_resultset.Add(new Resultcs()
{
Message = "Unable to create HttpSettings", Status = "Not Performed", State = false
});
_resultset.Add(new Resultcs()
{
Message = "Unable to create BackendAddressPool", Status = "Not Performed", State = false
});
_resultset.Add(new Resultcs()
{
Message = "Unable to create Rule", Status = "Not Performed", State = false
});
}
TempData.Put("Result", _resultset);
return(RedirectToAction("SendResult"));
}
