public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
if (!RequestValidation.IsRequestValid <UserForRegisterDto>(userForRegisterDto))
{
return(BadRequest("Invalid request"));
}
var newUser = mapper.Map <User>(userForRegisterDto);
var result = await userManager.CreateAsync(newUser, userForRegisterDto.Password);
if (result.Succeeded)
{
var usr = await userManager.FindByNameAsync(newUser.UserName);
//var res = await repo.InitializeUserAsyncReturnCode(Convert.ToString(usr.Id));
try
{
var res = await fsc.AccessControl.CreateUserAsync(Convert.ToString(usr.Id), false);
var r1 = await fsc.Directories.SetCustomMetadataAsync(res.RootDirectory, "Shared", false);
var r2 = await fsc.Directories.SetCustomMetadataAsync(res.RootDirectory, "ShareID", String.Empty);
}
catch (Exception)
{
throw;
}
return(StatusCode(201));
}
return(BadRequest(result.Errors));
}
public IActionResult OwsPost([FromBody] XElement requestXml)
{
if (requestXml == null)
{
return(BadRequest("XML request is not valid."));
}
var requestedService = requestXml.Attributes().FirstOrDefault(a => string.Compare(a.Name.LocalName, "service", StringComparison.OrdinalIgnoreCase) == 0)?.Value;
RequestValidation.ValidateKnownService(requestedService);
var service = RequestValidation.ValidateSupportedService(requestedService);
XDocument resultXml;
switch (service)
{
case SupportedOcgServiceEnum.Wfs:
resultXml = resolveManager.Resolve <WfsHandler>().Handle(requestXml);
break;
case SupportedOcgServiceEnum.Wms:
resultXml = resolveManager.Resolve <WmsHandler>().Handle(requestXml);
break;
default:
throw new ArgumentOutOfRangeException();
}
return(Content(resultXml.ToString(), "text/xml", Encoding.UTF8));
}
public async Task <IActionResult> Register(UserForRegisterDto userForRegisterDto)
{
if (!RequestValidation.IsRequestValid <UserForRegisterDto>(userForRegisterDto))
{
return(BadRequest("Invalid request"));
}
var newUser = mapper.Map <User>(userForRegisterDto);
newUser.Blog = new Blog
{
BlogName = userForRegisterDto.BlogName,
Author = newUser,
AuthorId = newUser.Id,
};
var result = await userManager.CreateAsync(newUser, userForRegisterDto.Password);
if (result.Succeeded)
{
return(StatusCode(201)); // temporarly
// return CreatedAtRoute();
}
return(BadRequest(result.Errors));
}
private status RecordStorePurchase(Stream postBody)
{
//
// Validate the request.
//
RequestValidation.Validate();
//
// Get the passed data POSTed to the service as a form.
//
FormBodyParser form = new FormBodyParser(postBody);
errordetail validationError = ValidateParameters(form);
if (validationError != null)
{
throw new WebFaultException <errordetail>(validationError, validationError.statuscode);
}
//
// With the passed values, let's make it so.
//
bool res = DataManager.RecordPurchase(form.Value(QsKeys.PurchaseId), form.Value(QsKeys.DeviceId), form.Value(QsKeys.AppVersion));
if (res)
{
return(new status(ResultStatus.Success));
}
else
{
return(new status(ResultStatus.Error));
}
}
private OttaMatta.Data.Models.websearch GetSummary(string term, string clientIp, string deviceId, string appVersion)
{
RequestValidation.Validate();
if (Functions.IsEmptyString(term))
{
errordetail err = new errordetail("No search term present", System.Net.HttpStatusCode.BadRequest);
throw new WebFaultException <errordetail>(err, err.statuscode);
}
if (Functions.IsEmptyString(clientIp))
{
clientIp = ApplicationManager.GetUserIPFromOperationContect(OperationContext.Current);
}
/* Google version
* OttaMatta.Data.Models.websearch result = WebSearchManager.SearchSounds(term,
* clientIp,
* new DataSourceFileSystem(HttpContext.Current.Server.MapPath(Config.Get(Config.CacheSearchesDirectory))),
* new ExternalSearchGoogle());
*/
/* Yahoo version
*/
OttaMatta.Data.Models.websearch result = WebSearchManager.SearchSounds(term,
clientIp,
new DataSourceFileSystem(HttpContext.Current.Server.MapPath(Config.Get(Config.CacheSearchesDirectory)),
HttpContext.Current.Server.MapPath(Config.Get(Config.CacheWebobjectsDirectory))),
new ExternalSearchYahoo());
return(result);
}
public async Task <IActionResult> Login(UserLoginDto userLoginDto)
{
if (!RequestValidation.IsRequestValid <UserLoginDto>(userLoginDto))
{
return(BadRequest("Invalid request"));
}
var user = await userManager.FindByEmailAsync(userLoginDto.Email);
if (user == null)
{
return(Unauthorized());
}
var result = await signInManager.CheckPasswordSignInAsync(user, userLoginDto.Password, false);
if (result.Succeeded)
{
var appUser = mapper.Map <UserForListDto>(user);
return(Ok(new
{
token = service.GenerateJwtToken(user, userManager, config).Result,
user = appUser
}));
}
return(Unauthorized());
}
private soundssummary GetSummary(string term, string order, string includeInappropriate, string page, string pageSize, string deviceId, string appVersion)
{
RequestValidation.Validate();
int reqPage = Functions.ConvertInt(page, 0);
int reqPageSize = Functions.ConvertInt(pageSize, 50);
long totalResults = -1;
List <dynamic> soundList = DataManager.SearchSounds(term.Left(10), Functions.ConvertInt(order, 0), Functions.ConvertInt(includeInappropriate, 0) == 1, reqPage, reqPageSize, out totalResults);
soundssummary result = new soundssummary();
result.sounds = (from item in soundList
select new sound {
name = item.Name,
soundid = item.Id,
filename = item.FileName,
description = item.Description,
downloads = item.DownloadCount,
uploadedby = item.UploadBy,
uploadDate = item.UploadDate.ToString("yyyy-MM-dd'T'HH:mm:ss'Z'"), // RFC 3339 date-time format
averagerating = item.AverageRating,
size = item.Size,
hasicon = item.HasIcon,
imagethumb = null
}).ToList <sound>();
result.totalresults = totalResults.ToString();
return(result);
}
private static WfsSupportedVersionEnum GetSupportedVersionForRequestedVersion(string requestedVersionStr)
{
RequestValidation.ValidateVersion(requestedVersionStr, "version");
// since PTV supports just 1.1.0 version for now,
// no version handling is needed
// the only supported version is used
return(WfsSupportedVersionEnum._1_1_0);
}
public ActionResult StreamView(string id)
{
if (RequestValidation.HasNullParams(id))
{
return(RedirectToAction("Index", "Home"));
}
else
{
Video requestedVid = DatabaseOps.GetVideoRecord(id);
System.Diagnostics.Debug.WriteLine("Video Title: " + requestedVid.Title);
return(View(requestedVid));
}
}
private bool Validate()
{
var validationResult = RequestValidation.Validate(CreditAmount.Text, CreditSalary.Text);
if (validationResult.IsValid)
{
return(true);
}
else
{
MessageBox.Show(validationResult.Error);
return(false);
}
}
private imagedata GetIconData(string soundId)
{
RequestValidation.Validate();
dynamic data = DataManager.GetIconData(int.Parse(soundId));
imagedata result = new imagedata();
result.soundid = data.Id;
result.extension = data.Extension;
result.md5hash = data.Md5;
result.datasixtyfour = data.Data;
return(result);
}
private sound GetSoundData(string soundId)
{
RequestValidation.Validate();
dynamic data = DataManager.GetSoundData(int.Parse(soundId));
sound result = new sound();
result.soundid = data.Id;
result.filename = data.FileName;
result.md5hash = data.Md5;
result.datasixtyfour = data.Data;
result.size = data.Size;
return(result);
}
public void RequestValidation_Test()
{
HttpRequest request = new DefaultHttpRequest(new DefaultHttpContext());
var jwt = Utils.EncodeToken("123", "mock_client_id", "tests", 1, "GET", "/a/b/c", "a=b");
request.Path = "/a/b/c";
request.Method = "GET";
request.QueryString = new QueryString($@"?a=b&jwt={jwt}");
var v = new RequestValidation(request);
var reg = new Mock <Interface.IRegistrationData>();
reg.SetupGet(e => e.ClientKey).Returns("mock_client_id");
reg.SetupGet(e => e.SharedSecret).Returns("123");
Assert.True(v.Validate(reg.Object), "Request is invalid");
}
/// <summary>
/// Process the upload request.
/// </summary>
/// <param name="postBody">The upload data POSTed to the service</param>
/// <returns>The inserted sound if successful, otherwise throws an eror. Just the new id is populated.</returns>
private sound UploadASound(Stream postBody)
{
//
// Validate the request.
//
RequestValidation.Validate();
//
// Get the passed data POSTed to the service as a form.
//
FormBodyParser form = new FormBodyParser(postBody);
errordetail validationError = ValidateParameters(form);
if (validationError != null)
{
throw new WebFaultException <errordetail>(validationError, validationError.statuscode);
}
//
// With the passed values, let's make it so.
//
int newId = -1;
bool res = DataManager.InsertSound(form.Value(QsKeys.Name),
form.Value(QsKeys.SoundFName),
form.Value(QsKeys.Description),
form.Value(QsKeys.UserId),
form.Base64DecodedValue(QsKeys.SoundData),
form.Value(QsKeys.IconFName),
form.Base64DecodedValue(QsKeys.IconData),
Functions.ConvertBool(form.Value(QsKeys.IsBrowsable), false),
out newId
);
//bool res = false;
if (!res)
{
throw new WebFaultException <errordetail>(new errordetail("Error saving sound", System.Net.HttpStatusCode.InternalServerError), System.Net.HttpStatusCode.InternalServerError);
}
sound newSound = new sound();
newSound.soundid = newId;
return(newSound);
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
// if (Service == null)
// {
// throw new OwsException(
// OwsExceptionCodeEnum.MissingParameterValue,
// "service",
// CoreMessages.NoServiceWasSpecified);
// }
RequestValidation.ValidateKnownService(Service);
if (Request == null)
{
throw new OwsException(
OwsExceptionCodeEnum.MissingParameterValue,
"request",
CoreMessages.RequestParameterMustBeSet);
}
// KnownOcgServiceEnum knownOcgService;
// if (!Enum.TryParse(Service, true, out knownOcgService))
// {
// throw new OwsException(
// OwsExceptionCodeEnum.InvalidParameterValue,
// "service",
// string.Format(CoreMessages.SpecifiedServiceIsNotKnownOcgService, Service));
// }
// SupportedOcgServiceEnum supportedService;
// if (!Enum.TryParse(Service, true, out supportedService))
// {
// throw new OwsException(
// OwsExceptionCodeEnum.NoApplicableCode,
// "service",
// new[]
// {
// $"Specified service '{Service}' is not a supported.",
// $"Supported services: '{string.Join(", ", Enum.GetNames(typeof (SupportedOcgServiceEnum))).ToUpper()}'"
// });
// }
SupportedService = RequestValidation.ValidateSupportedService(Service);
return(Enumerable.Empty <ValidationResult>());
}
public HttpResponseMessage GetSubSetCount(Request _Request)
{
Logger.WritetoFile(LogPath, "Requested String : " + _Request.StrInput + ", Requested Size : " + _Request.Size);
SResponse _SResponse = new SResponse();
int subSetCount = 0;
try
{
if (!RequestValidation.ValidateRequest(_Request, ref StrErrMsg))
{
throw new Exception(StrErrMsg);
}
if (!CountSubSet.GetCountSubset(_Request.StrInput, Convert.ToInt32(_Request.Size), ref StrErrMsg, ref subSetCount))
{
throw new Exception(StrErrMsg);
}
_SResponse.Count = subSetCount;
_SResponse.status = "success";
if (!objDB.PushHttpRequest(_Request.StrInput, _Request.Size, _SResponse.status + ", Count : " + _SResponse.Count, ref StrErrMsg))
{
Logger.WritetoFile(LogPath, "Error in Database : " + StrErrMsg + " at DateTime : " + DateTime.Now);
}
;
Logger.WritetoFile(LogPath, "Success in Request : " + _SResponse.status + " at DateTime : " + DateTime.Now);
return(Request.CreateResponse <SResponse>(HttpStatusCode.OK, _SResponse));
}
catch (Exception ex)
{
_SResponse.status = ex.Message;
_SResponse.Count = subSetCount;
Logger.WritetoFile(LogPath, "Error in Request : " + ex.Message + " at DateTime : " + DateTime.Now);
if (!objDB.PushHttpRequest(_Request.StrInput, _Request.Size, "fail " + _SResponse.status + " : " + _SResponse.Count, ref StrErrMsg))
{
Logger.WritetoFile(LogPath, "Error in Database : " + StrErrMsg + " at DateTime : " + DateTime.Now);
}
;
return(Request.CreateResponse <SResponse>(HttpStatusCode.BadRequest, _SResponse));
}
}
private WfsSupportedVersionEnum GetAcceptableVersion(IEnumerable <string> acceptVersions)
{
foreach (var v in acceptVersions)
{
RequestValidation.ValidateVersion(v, "AcceptVersion");
var enumStringVersion = ParseStringVersionToEnumFormat(v);
WfsSupportedVersionEnum enumVersion;
if (Enum.TryParse(enumStringVersion, true, out enumVersion))
{
return(enumVersion);
}
}
throw new OwsException(OwsExceptionCodeEnum.VersionNegotiationFailed,
"acceptVersion",
"No supported version has been found.");
}
public HttpResponseMessage ValidateCreditCard(string creditcardnumber, string expirydate)
{
MethodBase currentMethod = MethodBase.GetCurrentMethod();
CreditCardLogManager.Entering(string.Format("Card Number : {0}, Expiry Date : {1}", creditcardnumber, expirydate), currentClass, currentMethod);
var errorMsg = RequestValidation.BadRequestValidationCardNumber(creditcardnumber, expirydate);
if (!string.IsNullOrEmpty(errorMsg))
{
return(BuildResponse(creditcardnumber, HttpStatusCode.BadRequest, (int)HttpStatusCode.BadRequest, errorMsg));
}
try
{
var response = new ValidateCreditCardResponse();
using (var context = new CreditcardDBEntities())
{
var result = context.ValidateCreditCard(creditcardnumber, expirydate).ToList();
if (result.Count > 0)
{
foreach (var item in result)
{
response.CreditCardNumber = item.CARDNUMBER;
response.StatusCode = (int)HttpStatusCode.OK;
response.StatusMessage = HttpStatusCode.OK.ToString();
response.IsExist = item.ISEXIST;
response.IsValid = item.ISVALID;
response.CardType = item.CARDTYPE;
}
;
}
}
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
catch (Exception ex)
{
return(BuildResponse(creditcardnumber, HttpStatusCode.InternalServerError, (int)HttpStatusCode.InternalServerError, ex.Message));
}
}
private bool ValidateOrderDetail()
{
var excessApproved = _order.OrderDetails.FirstOrDefault(o => o.ApprovedQuantity > o.AvailableQuantity);
if (excessApproved != null)
{
XtraMessageBox.Show(
string.Format(
"The item {0} has an approved quantity greater than the SOH {1}. Please correct quantity before approving the order.", excessApproved.ItemName, excessApproved.AvailableQuantity.ToString("#,##0.##")), "Error:", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
var requestValidation = new RequestValidation();
requestValidation.Validate(_request);
if (!requestValidation.Errors.Any())
{
return(true);
}
foreach (var error in requestValidation.Errors)
{
if (error.ErrorType == RequestErrorType.NoApprovedQuantity)
{
gridOrderDetailView.SetColumnError(colApprovedQuantity1, "No quantity approved for Client");
}
else if (error.ErrorType == RequestErrorType.DuplicateRequestDetail)
{
XtraMessageBox.Show(
string.Format(
"The item {0} has a split entries with the same preference. Please change preference to approve the order.", error.RequestDetail.Item.ItemName), "Error:", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
else if (error.ErrorType == RequestErrorType.NoActivitySelected)
{
XtraMessageBox.Show(string.Format("Please select activity for item {0}",
error.RequestDetail.Item.ItemName), "Error:", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
return(false);
}
public async Task InvokeAsync(HttpContext context, DbContext.DatabaseContext dbContext, IAppJiraCloudExporterCli client)
{
client.RegistrationData = null;
try
{
var requestValidation = new RequestValidation(context.Request);
if (requestValidation.TokenExists)
{
var registrationData = dbContext.ClientRegistration.FirstOrDefault(r =>
r.Key == client.AtlassianAppKey && r.ClientKey == requestValidation.ClientKey
);
// if registration data is not found and it is allowed for the request to be unauthorized, pass it through
if (default(Model.ClientRegistration) == registrationData && _options.TokenRequired)
{
throw new Exception($"Unregistered client {requestValidation.ClientKey}");
}
// if registration data is found, request has to be authorized
if (default(Model.ClientRegistration) != registrationData &&
requestValidation.Validate(registrationData))
{
client.RegistrationData = registrationData;
}
}
else if (_options.TokenRequired)
{
throw new Exception($"No token");
}
}
catch (Exception ex)
{
if (_options.ThrowException)
{
throw;
}
client.AuthException = ex;
}
await _next(context);
}
private OttaMatta.Data.Models.websearchsound GetSound(string term, string soundId, string deviceId, string appVersion)
{
RequestValidation.Validate();
if (Functions.IsEmptyString(soundId))
{
errordetail err = new errordetail("No sound id passed", System.Net.HttpStatusCode.BadRequest);
throw new WebFaultException <errordetail>(err, err.statuscode);
}
OttaMatta.Data.Models.websearchsound result = WebSearchManager.GetSound(term, soundId,
new DataSourceFileSystem(HttpContext.Current.Server.MapPath(Config.Get(Config.CacheSearchesDirectory)),
HttpContext.Current.Server.MapPath(Config.Get(Config.CacheWebobjectsDirectory))));
if (result == null)
{
errordetail err = new errordetail("Sound id not found", System.Net.HttpStatusCode.BadRequest);
throw new WebFaultException <errordetail>(err, err.statuscode);
}
else
{
return(result);
}
}
/// <summary>
/// Process the web request
/// </summary>
/// <param name="postBody">The request parameters</param>
/// <returns>The status or an error is thrown.</returns>
private status ProcessSoundRating(Stream postBody)
{
//
// Validate the request.
//
RequestValidation.Validate();
//
// Get the passed data POSTed to the service as a form.
//
FormBodyParser form = new FormBodyParser(postBody);
errordetail validationError = ValidateParameters(form);
if (validationError != null)
{
throw new WebFaultException <errordetail>(validationError, validationError.statuscode);
}
//
// With the passed values, let's make it so.
//
bool res = DataManager.RateSound(int.Parse(form.Value(QsKeys.SoundId)), int.Parse(form.Value(QsKeys.Rating)), form.Value(QsKeys.Text));
return(new status {
code = 0, description = "Success"
});
/*
* else
* {
* errordetail err = new errordetail("Data update failed.", System.Net.HttpStatusCode.InternalServerError);
* throw new WebFaultException<errordetail>(err, err.statuscode);
* }
* */
}
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken)
{
if (!RequestActions.TryGetValue(request.Action, out var requestAction))
{
throw new NotSupportedException($"Unable to find an action for {request.Action}");
}
if (RequestValidation.TryGetValue(request.Action, out var requestValidationDelegate))
{
var attempt = await requestValidationDelegate.Invoke(request, cancellationToken);
if (!attempt.Successful)
{
if (attempt.ValidationFailures != null && attempt.ValidationFailures.Any())
{
throw new ValidationException(attempt.ValidationFailures);
}
throw new ArgumentException("Request validation failed", nameof(request));
}
}
return(await requestAction?.Invoke(request, cancellationToken));
}
public ValidationTest()
{
_requestValidation = new RequestValidation();
}
public RequestProcessing(BasicRequestValidation basicRequestValidation)
{
_basicRequestValidation = basicRequestValidation;
}
public WebApiApplication()
{
requestValidation = new RequestValidation();
}
