Example #1
0
        public static Dictionary<string, string> SubmitPaymentRequest(Dictionary<string, string> requestNvps, PaymentProcessorPayFlowProConfiguration settings, UserContext userContext, IEntityContext entityContext)
        {
            var payflowProSettings = new PayflowProSettingsDto
            {
                Id = settings.Id,
                Environment = settings.Environment,
                UserId = settings.UserId,
                Name = settings.Name,
                Password = settings.Password,
                Partner = settings.Partner,
                VendorId = settings.VendorId
            };

            return SubmitPaymentRequest(requestNvps, payflowProSettings, userContext, entityContext);
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="TrackingAuditEvent"/> class.
 /// </summary>
 /// <param name="context">The context.</param>
 public TrackingAuditEvent(UserContext context)
 {
     if (context == null)
     {
         throw new ArgumentNullException("context");
     }
     DateOccurred = DateTime.UtcNow;
     AuditEntities = new Collection<AuditEntity>();
     ClientIP = context.ClientIP;
     UserName = context.UserName;
     Url = context.Uri == null ? null : context.Uri.ToString();
     SessionIdentifier = context.SessionIdentifier;
     SiteCollectionIdentifier = context.SiteCollectionIdentifier;
     SiteIdentifier = context.SiteIdentifier;
     SiteSubscriptionId = ServiceContext.HostSettings.AuditSiteSubscriptionId;
 }
Example #3
0
        public static Dictionary<string, string> SubmitPaymentRequest(Dictionary<string, string> requestNvps, PayflowProSettingsDto settings, UserContext userContext, IEntityContext entityContext)
        {
            CheckSettings(settings);

            //Add Settings to Request String
            var nvpRequest = new StringBuilder();
            var accountNum = string.Empty;
            var securityCode = string.Empty;

            nvpRequest.AppendFormat(CultureInfo.InvariantCulture, "USER={0}&VENDOR={1}&PARTNER={2}&PWD={3}", settings.UserId, settings.VendorId, settings.Partner, settings.Password);

            foreach (var nvp in requestNvps)
            {
                nvpRequest.AppendFormat(CultureInfo.InvariantCulture, "&{0}={1}", nvp.Key, nvp.Value);

                if (nvp.Key == Constants.AccountNumber) accountNum = nvp.Value;
                if (nvp.Key == Constants.VerificationCode) securityCode = nvp.Value;
            }

            //Create API Request Object
            var payflowApi = new PayflowNETAPI();
            var hostAddress = settings.Environment.ToUpperInvariant() == "SANDBOX" ?
                "pilot-payflowpro.paypal.com" : "payflowpro.paypal.com";

            payflowApi.SetParameters(hostAddress, 443, 45, "", 0, "", "", "enabled", "1", "payflow.log", "10240000", false);

            //Send request and retrieve response
            var response = payflowApi.SubmitTransaction(nvpRequest.ToString(), PayflowUtility.RequestId);

            //Parse Response
            var responseNvp = new Dictionary<string, string>();
            foreach (var pair in response.Split('&'))
            {
                var values = pair.Split('=');

                if (values.Length == 2)
                    responseNvp.Add(values[0], values[1]);
            }

            //TODO: edit from original
            var pnref = responseNvp.ContainsKey("PNREF") ? responseNvp["PNREF"] : string.Empty;
            var result = responseNvp.ContainsKey("RESULT") ? responseNvp["RESULT"] : string.Empty;

            CreatePaymentOperationRecord(nvpRequest.ToString(), accountNum, securityCode, result, pnref, settings.Id, userContext, entityContext);

            return responseNvp;
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="TestUserContextFactory"/> class.
 /// </summary>
 /// <param name="userContext">The user context.</param>
 public TestUserContextFactory(UserContext userContext)
 {
     UserContext = userContext;
 }
Example #5
0
 	public TestAuditableContext(string connectionString, UserContext userContext, IAuditEventPublisher auditEventPublisher, IAuditConfiguration auditConfiguration)
 		: base(connectionString, ContainerName, userContext, auditEventPublisher, auditConfiguration)
 	{
         this.ContextOptions.LazyLoadingEnabled = true;
         this.ContextOptions.ProxyCreationEnabled = false;
 	}
Example #6
0
        private static void CreatePaymentOperationRecord(string request, string accountNum, string securityCode, string responseCode, string transactionId, int? configurationId, UserContext userContext, IEntityContext entityContext)
        {
            if (userContext == null || entityContext == null)
                return;

            // Mask credit card number/security code from logged operation details
            var accountNumSanitized = "XXXX" + accountNum.Substring(accountNum.Length - 4, 4);
            request = request.Replace(accountNum, accountNumSanitized);
            request = request.Replace("=" + securityCode + "&", "=XXXX&");

            PaymentProcessorOperation operation = new PaymentProcessorOperation
            {
                ClientIP = userContext.ClientIP,
                Url = userContext.Uri.ToString(),
                UserName = userContext.UserName,
                ApiMethod = string.Empty,
                ResponseCode = responseCode,
                CorrelationId = Guid.NewGuid().ToString(),
                ErrorCode = string.Empty,
                LongMessage = request,
                ShortMessage = string.Empty,
                OperationDate = DateTime.UtcNow,
                TransactionId = transactionId,
                PaymentProcessorName = "PayFlowPro",
                PaymentProcessorConfigurationId = configurationId
            };

            entityContext.EntitySet<PaymentProcessorOperation>().Add(operation);
            entityContext.SaveChanges();
        }
Example #7
0
        /// <summary>
        /// Builds a user context object based on a supplied authorization token
        /// </summary>
        /// <param name="token"></param>
        /// <returns></returns>
        private UserContext CreateUserContextFromToken(HttpContext httpContext, string token, RoleType minimumRoleType)
        {
            // Create new user context
            if (httpContext != null && httpContext.Request != null)
            {
                if (!httpContext.Items.Contains(CommonParameters.UserContext))
                {
                    var httpRequest = httpContext.Request;

                    // Lookup token details
                    AuthorizationTokenModel authToken = null;

                    // Check cache first, then get from data provider as a fallback
                    var cache = CacheManager.GetCache(CacheRegion.Authentication, false, false, false, true);
                    var cacheKey = Constants.Authentication.AuthTokenCachePrefix + token;

                    if (cache.Contains(cacheKey))
                        authToken = (AuthorizationTokenModel)cache.Get(cacheKey);
                    else
                    {
                        var dataProxy = ServiceContext.DataProviderFactory.CreateDataProvider(CmsType.Convert);
                        authToken = dataProxy.GetAuthorizationTokenDetails(token);

                        if(authToken != null)
                            cache.Put(cacheKey, authToken, Constants.Authentication.AuthTokenCacheTimeInSeconds);
                    }

                    // Validate token
                    if (authToken == null)
                        return null;
                    if (authToken.ExpiresDate <= DateTime.Now)
                        return null;
                    if (minimumRoleType == RoleType.Admin && !authToken.IsAuthorizedAdminUser)
                        return null;
                    if (minimumRoleType == RoleType.Staff && (!authToken.IsAuthorizedAdminUser && !authToken.IsAuthorizedStaffUser))
                        return null;

                    // Build and return a user context based on request/token details
                    var userContext = new UserContext
                    {
                        AuthorizationToken = authToken.Token,
                        UserId = authToken.UserId,
                        UserName = authToken.UserName,
                        ClientIP = httpRequest.UserHostAddress,
                        Uri = httpRequest.Url,
                        UserAgent = httpRequest.UserAgent,
                        IsAuthorizedAdminUser = authToken.IsAuthorizedAdminUser,
                        IsAuthorizedStaffUser = authToken.IsAuthorizedStaffUser,
                        IsAuthorizedPageEditorUser = authToken.IsAuthorizedPageEditorUser
                    };

                    return userContext;
                }
                else
                {
                    // A user context was already set for current request, so reuse it
                    return (UserContext)httpContext.Items[CommonParameters.UserContext];
                }
            }

            return null;
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="AuditableObjectContext"/> class.
 /// </summary>
 /// <param name="connectionString">The connection string.</param>
 /// <param name="defaultContainerName">Default name of the container.</param>
 /// <param name="userContext">The user context.</param>
 /// <param name="auditEventPublisher">The audit event publisher.</param>
 /// <param name="auditConfiguration">The audit configuration.</param>
 public AuditableObjectContext(string connectionString, string defaultContainerName, UserContext userContext, IAuditEventPublisher auditEventPublisher, IAuditConfiguration auditConfiguration)
     : base(connectionString, defaultContainerName)
 {
     Initialize(userContext, auditEventPublisher, auditConfiguration);
 }
 private void Initialize(UserContext userContext, IAuditEventPublisher auditEventPublisher, IAuditConfiguration auditConfiguration)
 {
     _userContext = userContext;
     _auditEventPublisher = auditEventPublisher;
     _auditConfiguration = auditConfiguration;
     InitializeAuditEvent();
     AttachToEvents();
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="AuditableEntityContext" /> class.
 /// </summary>
 /// <param name="nameOrConnectionString">The name or connection string.</param>
 /// <param name="userContext">The user context.</param>
 /// <param name="auditEventPublisher">The audit event publisher.</param>
 /// <param name="auditConfiguration">The audit configuration.</param>
 public AuditableEntityContext(string nameOrConnectionString, UserContext userContext, IAuditEventPublisher auditEventPublisher, IAuditConfiguration auditConfiguration)
     : base(nameOrConnectionString)
 {
     Initialize(userContext, auditEventPublisher, auditConfiguration);
 }