public ActionResult Edit(int id, FormCollection fc, List <AgentBankModel> AgentBankModel)
{
AgencyModel model = new AgencyModel();
var ts = (TravelSession)Session["TravelPortalSessionInfo"];
model = ser.SignUpAgentsDetail(id);
model.CreatedBy = ts.AppUserId;
model.CreatedbyUser = ts.AppUserId;
try
{
int[] ChkProductId = new int[1] {
1
};
int agentID = ser.Create(model, AgentBankModel, ChkProductId, fc);
ser.UpdateSignUpAgent(id, agentID);
ser.Approve(id);
SecureQueryString qs = new SecureQueryString(mKey);
model.domainname = UrlHelperExtensions.AbsolutePath(HttpContext.Request.Url.OriginalString);
model.UrlLinktoSendLocal = UrlHelperExtensions.AbsolutePath(HttpContext.Request.Url.OriginalString); //ConfigurationManager.AppSettings["LoginPageUrlLocal"];
model.UrlLinktoSendLive = "https://agent.arihantholidays.com/"; //ConfigurationManager.AppSettings["LoginPageUrlLive"];
string htmlContent = RenderPartialViewToString("EMailTemplate", model);
var result = ser.SendEmail(htmlContent, id, "Agency Confirmation Mail");
return(RedirectToAction("Index", "AgentManagement"));
}
catch (Exception ex)
{
TempData["ErrorMessage"] = ex.Message;
return(RedirectToAction("Detail", new { id = id }));
}
}
public async Task PostNewJobOpportunity(JobOpportunity jobOpportunity, UrlHelper urlHelper)
{
if (string.IsNullOrWhiteSpace(jobOpportunity?.Title) || jobOpportunity.Id <= 0)
{
return;
}
var length = 80;
var hashtag = string.Empty;
if (jobOpportunity.IsRemote)
{
length = 64;
hashtag = " #weworkremotely";
}
var title = jobOpportunity.Title.Length > length
? jobOpportunity.Title.Substring(0, length)
: jobOpportunity.Title;
var action = UrlHelperExtensions.SeoUrl(jobOpportunity.Id, jobOpportunity.Title);
var url = urlHelper.AbsoluteUrl(action, "jobs");
var message = $"Se busca: {title}{hashtag} {url}";
await PostTweet(message).ConfigureAwait(false);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc(options => {
options.EnableEndpointRouting = false;
});
// Configuration
services.AddOptions();
services.Configure <Settings>(Configuration);
int assetVersion = Configuration.GetValue <int>("AssetVersion");
if (!UrlHelperExtensions.SetAssetVersionIfUnset(assetVersion))
{
throw new System.Exception("Asset value already set, which must not happen.");
}
// Database repositories
services.AddSingleton <IAttemptRepository, AttemptRepository>();
services.AddSingleton <ICommentRepository, CommentRepository>();
services.AddSingleton <ICommentVoteRepository, CommentVoteRepository>();
services.AddSingleton <ICounterRepository, CounterRepository>();
services.AddSingleton <IGameRepository, GameRepository>();
services.AddSingleton <INotificationRepository, NotificationRepository>();
services.AddSingleton <IPositionRepository, PositionRepository>();
services.AddSingleton <IPuzzleRepository, PuzzleRepository>();
services.AddSingleton <IRatingRepository, RatingRepository>();
services.AddSingleton <IReportRepository, ReportRepository>();
services.AddSingleton <ISavedLoginRepository, SavedLoginRepository>();
services.AddSingleton <ITimedTrainingScoreRepository, TimedTrainingScoreRepository>();
services.AddSingleton <IUserRepository, UserRepository>();
services.AddSingleton <ITagRepository, TagRepository>();
// Memory repositories
services.AddSingleton <IEndgameTrainingSessionRepository, EndgameTrainingSessionRepository>();
services.AddSingleton <IGameRepoForSocketHandlers, GameRepoForSocketHandlers>();
services.AddSingleton <IGameSocketHandlerRepository, GameSocketHandlerRepository>();
services.AddSingleton <ILobbySeekRepository, LobbySeekRepository>();
services.AddSingleton <ILobbySocketHandlerRepository, LobbySocketHandlerRepository>();
services.AddSingleton <IPuzzlesBeingEditedRepository, PuzzlesBeingEditedRepository>();
services.AddSingleton <IPuzzleTrainingSessionRepository, PuzzleTrainingSessionRepository>();
services.AddSingleton <ITimedTrainingSessionRepository, TimedTrainingSessionRepository>();
// Miscellaneous services
services.AddSingleton <IEmailSender, EmailSender>();
services.AddSingleton <IGameConstructor, GameConstructor>();
services.AddSingleton <IMoveCollectionTransformer, MoveCollectionTransformer>();
services.AddSingleton <IPasswordHasher, PasswordHasher>();
services.AddSingleton <IPersistentLoginHandler, PersistentLoginHandler>();
services.AddSingleton <IRandomProvider, RandomProvider>();
services.AddSingleton <IRatingUpdater, RatingUpdater>();
services.AddSingleton <IUserVerifier, UserVerifier>();
services.AddSingleton <IValidator, Validator>();
services.Configure <RouteOptions>(options =>
{
options.ConstraintMap.Add("supportedVariantOrMixed", typeof(SupportedVariantOrMixedRouteConstraint));
options.ConstraintMap.Add("supportedVariant", typeof(SupportedVariantRouteConstraint));
});
services.AddSession();
}
public async Task <ActionResult> Wizard(Wizard model)
{
if (!ModelState.IsValid)
{
return(View(model)
.WithError("Han ocurrido errores de validación que no permiten continuar el proceso"));
}
var jobOpportunity = model.ToEntity();
var jobExists = _jobOpportunityService.JobExists(model.Id);
if (!jobExists)
{
_jobOpportunityService.CreateNewJobOpportunity(jobOpportunity, User.Identity.GetUserId());
}
else
{
_jobOpportunityService.UpdateJobOpportunity(model.Id, model.ToEntity());
}
await _twitterService.PostNewJobOpportunity(jobOpportunity, Url);
return(RedirectToAction(nameof(Detail), new
{
id = UrlHelperExtensions.SeoUrl(jobOpportunity.Id, jobOpportunity.Title),
fromWizard = 1
}));
}
public async Task <ActionResult> New(NewJobOpportunityViewModel model, bool captchaValid)
{
if (!ModelState.IsValid)
{
return(View(model)
.WithError("Han ocurrido errores de validación que no permiten continuar el proceso"));
}
if (string.IsNullOrWhiteSpace(model.LocationPlaceId))
{
ModelState.AddModelError("LocationName", "");
return(View(model).WithError("Debe seleccionar una Localidad."));
}
var jobOpportunity = model.ToEntity();
_jobOpportunityService.CreateNewJobOpportunity(jobOpportunity);
await _twitterService.PostNewJobOpportunity(jobOpportunity);
return(RedirectToAction("Detail", new
{
id = UrlHelperExtensions.SeoUrl(jobOpportunity.Id, jobOpportunity.Title)
}));
}
private string GetParentUrl(string baseUri, string blobPrefix)
{
var segments = GetOutlineFromUrl(blobPrefix);
var parentPath = string.Join(Delimiter, segments.Take(segments.Length - 1));
return(UrlHelperExtensions.Combine(baseUri, EscapeUri(parentPath)));
}
protected virtual async Task MoveAsync(string oldUrl, string newUrl, bool isCopy = false)
{
string oldPath, newPath;
var isFolderRename = string.IsNullOrEmpty(Path.GetFileName(oldUrl));
var containerName = GetContainerNameFromUrl(oldUrl);
//if rename file
if (!isFolderRename)
{
oldPath = GetFilePathFromUrl(oldUrl);
newPath = GetFilePathFromUrl(newUrl);
}
else
{
oldPath = GetDirectoryPathFromUrl(oldUrl);
newPath = GetDirectoryPathFromUrl(newUrl);
}
var taskList = new List <Task>();
var blobContainer = _blobServiceClient.GetBlobContainerClient(containerName);
var blobItems = blobContainer.GetBlobsAsync(prefix: oldPath);
await foreach (var blobItem in blobItems)
{
var blobName = UrlHelperExtensions.Combine(containerName, blobItem.Name);
var newBlobName = blobName.Replace(oldPath, newPath);
taskList.Add(MoveBlob(blobContainer, blobName, newBlobName, isCopy));
}
await Task.WhenAll(taskList);
}
public void AbsoluteRoute_SchemeChange(string requestScheme, string routeScheme, string routeDomain)
{
// Arrange
var variables = new NameValueCollection();
variables.Add("X_FORWARDED_PROTO", requestScheme);
m_mockHttpContext.Setup(context => context.Request.ServerVariables).Returns(variables);
var headers = new NameValueCollection();
headers.Add("Host", "example.org");
m_mockHttpContext.Setup(context => context.Request.Headers).Returns(headers);
var defaults = new RouteValueDictionary();
defaults.Add("domain", routeDomain);
defaults.Add("scheme", routeScheme);
var route = new Route("index.html", defaults, new StopRoutingHandler());
var routeData = new RouteData();
var routes = new RouteCollection();
routes.Add("x", route);
var helper = new UrlHelper(new RequestContext(m_mockHttpContext.Object, routeData), routes);
// Act
var result = UrlHelperExtensions.AbsoluteRouteUrl(helper, m_mockHttpContext.Object, "x", null);
// Assert
Assert.Equal(routeScheme + "://example.org/index.html", result);
}
public virtual async Task RemoveAsync(string[] urls)
{
foreach (var url in urls)
{
var absoluteUri = url.IsAbsoluteUrl()
? new Uri(url).ToString()
: UrlHelperExtensions.Combine(_blobServiceClient.Uri.ToString(), url);
var blobContainer = GetBlobContainer(GetContainerNameFromUrl(absoluteUri));
var isFolder = string.IsNullOrEmpty(Path.GetFileName(absoluteUri));
var blobSearchPrefix = isFolder ? GetDirectoryPathFromUrl(absoluteUri)
: GetFilePathFromUrl(absoluteUri);
if (string.IsNullOrEmpty(blobSearchPrefix))
{
await blobContainer.DeleteIfExistsAsync();
}
else
{
var blobItems = blobContainer.GetBlobsAsync(prefix: blobSearchPrefix);
await foreach (var blobItem in blobItems)
{
var blobClient = blobContainer.GetBlobClient(blobItem.Name);
await blobClient.DeleteIfExistsAsync();
}
}
}
}
public void ParseQueryString_admits_no_question_mark()
{
var d = UrlHelperExtensions.ParseQueryString("pep=1");
Assert.AreEqual(1, d.Count);
Assert.AreEqual("1", d["pep"]);
}
public static MvcForm ModularBeginForm <TController>(this HtmlHelper helper, Expression <Action <TController> > expression, FormMethod method, object arguments, object htmlAttributes) where TController : ControllerBase
{
string actionName, controllerName, areaName, moduleName;
UrlHelperExtensions.DetermineParameters <TController>(expression, helper.RouteCollection, out actionName, out controllerName, out areaName, out moduleName);
return(ModularBeginForm(helper, actionName, controllerName, areaName, moduleName, method, arguments, htmlAttributes));
}
public static void ModularRenderAction <TController>(this HtmlHelper helper, Expression <Action <TController> > expression, RouteValueDictionary arguments) where TController : ControllerBase
{
string actionName, controllerName, areaName, moduleName;
UrlHelperExtensions.DetermineParameters <TController>(expression, helper.RouteCollection, out actionName, out controllerName, out areaName, out moduleName);
ModularRenderAction(helper, actionName, controllerName, areaName, moduleName, arguments);
}
public void ParseQueryString_url_decodes()
{
var d = UrlHelperExtensions.ParseQueryString("?pep=1&Nothing=%3D%25");
Assert.AreEqual(2, d.Count);
Assert.AreEqual("=%", d["nothing"]);
}
public async Task SendVerificationEmail(IdentityUserViewModel model)
{
try
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
throw new Exception($"Unable to load user");
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = UrlHelperExtensions.EmailConfirmationLink(user.Id, code);
var email = user.Email;
await _emailSender.SendEmailAsync(email, "Confirm email", callbackUrl);
_logger.LogInformation($"Verification email sent to {user.Id}.");
}
catch (Exception ex)
{
_logger.LogError(ex);
}
}
public static MvcForm BeginAjaxForm(this IHtmlHelper htmlHelper, string actionName, string controllerName, RouteValueDictionary routeValues, FormMethod method, AjaxFormOptions options, IDictionary <string, object> htmlAttributes)
{
var actionContext = new ActionContext(htmlHelper.ViewContext.HttpContext, htmlHelper.ViewContext.HttpContext.GetRouteData(), new ActionDescriptor());
string formAction = UrlHelperExtensions.Action(new UrlHelper(actionContext), actionName, controllerName, routeValues ?? new RouteValueDictionary());
return(FormHelper(htmlHelper, formAction, method, options, htmlAttributes));
}
public async Task <IOperationResult> CreateRegisterInvite(string toEmail)
{
try
{
var userToCreate = new ApplicationUser
{
Email = toEmail,
UserName = toEmail
};
await _userManager.CreateAsync(userToCreate);
var createdUser = await _userManager.FindByEmailAsync(userToCreate.Email);
await _userManager.SetLockoutEnabledAsync(createdUser, true);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(createdUser);
var emailBody =
$@"Accept invite: {UrlHelperExtensions.ConfirmInviteCallbackLink(createdUser.Id, code)}";
await _emailSender.SendEmailAsync(createdUser.Email, "Accept invite", emailBody);
return(OperationResult.Success);
}
catch (Exception ex)
{
return(OperationResult.Failed(ex.Message));
}
}
public async Task New_POST_ValidModel_CreatesJob_PostsTweet_RedirectsToDetail()
{
// Arrange
var model = new NewJobOpportunityViewModel {
Title = "myTitle",
Category = JobCategory.MobileDevelopment,
Description = "My description",
CompanyName = "Company",
CompanyUrl = "http://example.com",
CompanyLogoUrl = "http://example.com/logo.png",
CompanyEmail = "*****@*****.**",
IsRemote = true,
LocationName = "My location",
LocationPlaceId = "123",
LocationLatitude = "18.3939393",
LocationLongitude = "-69.22222",
JobType = JobType.FullTime
};
_sut.ControllerContext = GenerateControllerContext(_sut);
_jobOpportunityService.WhenForAnyArgs(x => x.CreateNewJobOpportunity(null, null))
.Do(x => { x.Arg <JobOpportunity>().Id = 1; });
// Act
var result = (RedirectToRouteResult)await _sut.New(model, false);
// Assert
_jobOpportunityService.Received(1).CreateNewJobOpportunity(
Arg.Do <JobOpportunity>(entity => VerifyGeneratedJobOpportunityEntity(model, entity)), null);
await _twitterService.Received(1).PostNewJobOpportunity(
Arg.Do <JobOpportunity>(entity => VerifyGeneratedJobOpportunityEntity(model, entity)));
result.RouteValues["action"].Should().Be(nameof(_sut.Detail));
result.RouteValues["id"].Should().Be(UrlHelperExtensions.SeoUrl(1, "myTitle"));
}
public ActionResult Create()
{
ContentsModel model = new ContentsModel();
model.DomainName = UrlHelperExtensions.AbsolutePath(HttpContext.Request.Url.OriginalString);
return(View(model));
}
public static MvcHtmlString ModularAction <TController>(this HtmlHelper helper, Expression <Func <TController, object> > expression, RouteValueDictionary arguments) where TController : ControllerBase
{
string actionName, controllerName, areaName, moduleName;
UrlHelperExtensions.DetermineParameters <TController>(expression, helper.RouteCollection, out actionName, out controllerName, out areaName, out moduleName);
return(ModularAction(helper, actionName, controllerName, areaName, moduleName, arguments));
}
public async Task <IActionResult> Logout(LogoutInputModel model)
{
// build a model so the logged out page knows what to display
var vm = await _account.BuildLoggedOutViewModelAsync(model.LogoutId);
var user = HttpContext.User;
if (user?.Identity.IsAuthenticated == true)
{
// delete local authentication cookie
await HttpContext.SignOutAsync();
// raise the logout event
await _events.RaiseAsync(new UserLogoutSuccessEvent(user.GetSubjectId(), user.GetDisplayName()));
}
// check if we need to trigger sign-out at an upstream identity provider
if (vm.TriggerExternalSignout)
{
// build a return URL so the upstream provider will redirect back
// to us after the user has logged out. this allows us to then
// complete our single sign-out processing.
string url = UrlHelperExtensions.Action(Url, "Logout", new { logoutId = vm.LogoutId });
// this triggers a redirect to the external provider for sign-out
return(SignOut(new AuthenticationProperties {
RedirectUri = url
}, vm.ExternalAuthenticationScheme));
}
return(View("LoggedOut", vm));
}
public async Task <IActionResult> Forgot([FromBody] AccountDTO dto)
{
if (!IsPopulated(dto?.email))
{
return(BadRequest());
}
var user = await _userManager.FindByEmailAsync(dto.Username);
if (user == null)
{
return(BadRequest("@UnknownUser"));
}
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = UrlHelperExtensions.Action(Url, "Index", "Home", new { reset = dto.Username, code = code }, HttpContext.Request.Scheme);
_logger.LogInformation(5, $"User {dto.Username} requested a password reset link.");
var subject = dto.messages != null && dto.messages.Length > 0 && !string.IsNullOrWhiteSpace(dto.messages[0]) ? dto.messages[0] : "Tracktor - password reset";
var body = dto.messages != null && dto.messages.Length > 1 && !string.IsNullOrWhiteSpace(dto.messages[1]) ? dto.messages[1] : "Please click the link below to reset your password.";
await _emailSender.SendEmailAsync(dto.Username, subject, body, callbackUrl);
return(Ok());
}
public void ParseQueryString_admits_duplicate_parameters_but_keeps_last()
{
var d = UrlHelperExtensions.ParseQueryString("pep=1&pep=2");
Assert.AreEqual(1, d.Count);
Assert.AreEqual("2", d["pep"]);
}
public async Task <ActionResult> New(NewJobOpportunityViewModel model, bool captchaValid)
{
if (!ModelState.IsValid)
{
return(View(model)
.WithError("Han ocurrido errores de validación que no permiten continuar el proceso"));
}
if (string.IsNullOrWhiteSpace(model.LocationPlaceId))
{
ModelState.AddModelError(nameof(model.LocationName), "");
return(View(model).WithError("Debe seleccionar una Localidad."));
}
if (!string.IsNullOrWhiteSpace(model.CompanyLogoUrl) && !UrlHelperExtensions.IsImageAvailable(model.CompanyLogoUrl))
{
return(View(model).WithError("La url del logo debe ser a una imagen en formato png o jpg"));
}
var jobOpportunity = model.ToEntity();
var userId = User.Identity.GetUserId();
_jobOpportunityService.CreateNewJobOpportunity(jobOpportunity, userId);
await _twitterService.PostNewJobOpportunity(jobOpportunity, Url).ConfigureAwait(false);
return(RedirectToAction(nameof(Detail), new
{
id = UrlHelperExtensions.SeoUrl(jobOpportunity.Id, jobOpportunity.Title)
}));
}
public IBlobContentStorageProvider CreateProvider(string basePath)
{
var clonedOptions = _options.Clone() as AzureContentBlobOptions;
clonedOptions.RootPath = UrlHelperExtensions.Combine(clonedOptions.RootPath, basePath);
return(new AzureContentBlobStorageProvider(new OptionsWrapper <AzureContentBlobOptions>(clonedOptions), _platformOptions, _settingsManager));
}
public void ParseQueryString_admits_extra_ampersands()
{
var d = UrlHelperExtensions.ParseQueryString("?&pep=&&&Nothing=&");
Assert.AreEqual(2, d.Count);
Assert.AreEqual("", d["pep"]);
Assert.AreEqual("", d["Nothing"]);
}
public void ParseQueryString_admits_empty_parameters()
{
var d = UrlHelperExtensions.ParseQueryString("?pep=&Nothing=");
Assert.AreEqual(2, d.Count);
Assert.AreEqual("", d["pep"]);
Assert.AreEqual("", d["Nothing"]);
}
public void DictToQuerystring_url_encodes()
{
var s = UrlHelperExtensions.DictToQuerystring(new Dictionary <string, string> {
{ "pp", "==" },
});
Assert.AreEqual("pp=%3d%3d", s);
}
public void DictToQuerystring_empty_key()
{
var s = UrlHelperExtensions.DictToQuerystring(new Dictionary <string, string> {
{ "", "a" },
});
Assert.AreEqual("", s);
}
public void DictToQuerystring_null_value()
{
var s = UrlHelperExtensions.DictToQuerystring(new Dictionary <string, string> {
{ "pp", null },
});
Assert.AreEqual("pp=", s);
}
public static void ModularRenderPartial <TController>(this HtmlHelper helper, string partialViewName, Object model, ViewDataDictionary viewData) where TController : ControllerBase
{
string controllerName, areaName, moduleName;
controllerName = UrlHelperExtensions.GetControllerName <TController>();
UrlHelperExtensions.DetermineAreaAndModule <TController>(helper.RouteCollection, out areaName, out moduleName);
ModularRenderPartial(helper, partialViewName, controllerName, areaName, moduleName, model, viewData);
}
