public UsedActionsController(UsedActionFactory factory, UserFactory userFactory, ActionFactory actionFactory, PartnerFactory partnerFactory)
{
_factory = factory;
_partnerFactory = partnerFactory;
_actionFactory = actionFactory;
_userFactory = userFactory;
}
/// <summary>
/// Adds a settlement event to the analytics.
/// </summary>
/// <param name="userId">
/// The canonical user ID to associate with the event.
/// </param>
/// <param name="settlementEventId">
/// The ID of this settlement event.
/// </param>
/// <param name="correlationId">
/// The ID of the event to which this event will be correlated.
/// </param>
/// <param name="dealId">
/// The ID of the deal being redeemed.
/// </param>
/// <param name="currency">
/// The currency involved in the transaction in which the deal was redeeemed.
/// </param>
/// <param name="settlementAmount">
/// The settlement amount in the transaction in which the deal was redeemed.
/// </param>
/// <param name="discountAmount">
/// The discount amount from the transaction in which the deal was redeemed.
/// </param>
/// <param name="discountId">
/// The ID of the discount within the deal that was specifically redeemed.
/// </param>
/// <param name="partnerMerchantId">
/// The ID of the merchant as assigned by the processing partner.
/// </param>
public static void AddSettlementEvent(Guid userId,
Guid settlementEventId,
Guid correlationId,
Guid dealId,
string currency,
int settlementAmount,
int discountAmount,
Guid discountId,
string partnerMerchantId)
{
if (CommerceWorkerConfig.Instance.EnableServiceHealth == true)
{
AnalyticsClient.Payloads.DealSettlementPayload payload = new AnalyticsClient.Payloads.DealSettlementPayload
{
SettlementAmount = settlementAmount,
Currency = currency,
DiscountAmount = discountAmount,
DiscountId = discountId,
PartnerMerchantId = partnerMerchantId
};
AnalyticsClient.AnalyticsItem item = new AnalyticsClient.AnalyticsItem
{
Action = AnalyticsClient.Actions.Actions.Settlement,
UserId = GetAnidFromUserId(userId, CommerceWorkerConfig.Instance),
ClientId = AnalyticsClientId,
EventId = settlementEventId,
ParentEventId = correlationId,
DealId = dealId,
JPayload = JObject.FromObject(payload)
};
PartnerFactory.AnalyticsClient(CommerceWorkerConfig.Instance).Add(item);
}
}
/// <summary>
/// Obtains an authorization token for the specified resource.
/// </summary>
/// <param name="resource">
/// The resource for which to obtain an authorization token.
/// </param>
/// <returns>
/// The authorization token.
/// </returns>
internal static string ObtainAuthorizationToken(string resource)
{
string result;
// Build the fully qualified resource name.
string environment = String.Concat("commerce-", CommerceWorkerConfig.Instance.Environment);
string fullyQualifiedResource = String.Format("https://{0}.TODO_INSERT_YOUR_DOMAIN_HERE/api/commerce/service/{1}", environment,
resource);
// If the token has already been retrieved and is still valid, use it.
if (Tokens.ContainsKey(fullyQualifiedResource) == true && Tokens[fullyQualifiedResource].Received + TokenLifetime > DateTime.Now)
{
result = Tokens[fullyQualifiedResource].Token;
}
// Otherwise, obtain and store a new token.
else
{
ISimpleWebTokenRequestor requestor = PartnerFactory.SimpleWebTokenRequestor();
result = requestor.RequestToken("Orchestrated Job Queue", CommerceWorkerConfig.Instance.AcsClientCredential,
environment, fullyQualifiedResource);
Tokens[fullyQualifiedResource] = new SimpleWebToken {
Token = result, Received = DateTime.Now
};
}
return(result);
}
/// <summary>
/// Pings the Users database.
/// </summary>
/// <returns>
/// * True if the Users database could be pinged.
/// * Else returns false.
/// </returns>
private static bool PingUsers()
{
// Ping Users by attempting to retrieve a User known not to exist.
IUsersDal usersDal = PartnerFactory.UsersDal(CommerceServiceConfig.Instance);
return(usersDal.GetUserByUserId(Guid.Empty) == null);
}
/// <summary>
/// Registers external services for commerce like MVC constructs, security providers and Analytics
/// </summary>
internal static void RegisterExternalServices()
{
// Register log.
LogInitializer.CreateLogInstance(CommerceServiceConfig.Instance.LogVerbosity,
CommerceServiceConfig.Instance.ForceEventLog,
General.CommerceLogSource,
CommerceServiceConfig.Instance);
// Register MVC constructs.
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
// Register security providers.
IUsersDal usersDal = PartnerFactory.UsersDal(CommerceServiceConfig.Instance);
if (CommerceServiceConfig.Instance.EnableDebugSecurityProvider == true)
{
Security.Add("user_debug", new UserDebugSecurityProvider(usersDal));
}
Security.Add("usertoken", new UserTokenSecurityProvider());
// Register Analytics Service
Analytics.Initialize(CommerceServiceConfig.Instance);
}
public AmexOfferRegistrationFileSyncJob()
{
Context = new CommerceContext("Amex Offer Registration File Sync Job", CommerceWorkerConfig.Instance);
Scheduler = PartnerFactory.Scheduler(CommerceWorkerConfig.Instance.SchedulerQueueName,
CommerceWorkerConfig.Instance.SchedulerTableName,
CommerceWorkerConfig.Instance);
}
/// <summary>
/// Initializes a new instance of the Notify class.
/// </summary>
/// <param name="context">
/// The context for this API call.
/// </param>
protected Notify(CommerceContext context)
{
Context = context;
UsersDal = PartnerFactory.UsersDal(Context.Config);
Uri userServicesClientUri = new Uri(Context.Config.UserServicesClientEndpoint);
UserServicesClient = PartnerFactory.UserServicesClient(userServicesClientUri, Context.Config);
SmsServiceUrl = Context.Config.SmsServiceClientEndpoint;
}
public MainController(
PartnerTypeFactory partnerTypeFactory,
PartnerFactory partnerFactory,
PartnerActionMapFactory partnerActionMapFactory
)
{
_partnerTypeFactory = partnerTypeFactory;
_partnerFactory = partnerFactory;
_partnerActionMapFactory = partnerActionMapFactory;
}
/// <summary>
/// Adds a redemption reward for the transaction in the context.
/// </summary>
internal void AddRedemptionRewards()
{
RedeemedDealInfo redeemedDealInfo = (RedeemedDealInfo)Context[Key.RedeemedDealInfo];
if (Context.Config.EnableRedemptionRewards == true && (ReimbursementTender)redeemedDealInfo.ReimbursementTenderId == ReimbursementTender.MicrosoftEarn)
{
IRewardOperations rewardOperations = CommerceOperationsFactory.RewardOperations(Context);
Context[Key.RewardId] = Context.Config.FirstEarnRewardId;
Context[Key.FirstEarnRewardAmount] = Context.Config.FirstEarnRewardAmount;
Context[Key.FirstEarnRewardExplanation] = Context.Config.FirstEarnRewardExplanation;
ConcurrentDictionary <string, string> payload = new ConcurrentDictionary <string, string>();
IScheduler scheduler = PartnerFactory.Scheduler(Context.Config.SchedulerQueueName,
Context.Config.SchedulerTableName,
Context.Config);
if (rewardOperations.AddRedemptionReward() == ResultCode.Success)
{
// Add a job to potentially reward user for their first Earn.
payload[Key.RewardPayoutId.ToString()] = ((Guid)Context[Key.RewardPayoutId]).ToString();
payload[Key.PartnerCardId.ToString()] = (string)Context[Key.PartnerCardId];
payload[Key.PartnerRedeemedDealId.ToString()] = redeemedDealInfo.PartnerRedeemedDealId;
payload[Key.RewardId.ToString()] = Context.Config.FirstEarnRewardId.ToString();
ScheduledJobDetails scheduledJobDetails = new ScheduledJobDetails
{
JobId = Guid.NewGuid(),
JobType = ScheduledJobType.ApplyRedemptionReward,
JobDescription = redeemedDealInfo.GlobalUserId.ToString(),
Orchestrated = true,
Payload = payload
};
scheduler.ScheduleJobAsync(scheduledJobDetails).Wait();
}
// Add a job to potentially reward the person who referred this user for this user's first Earn.
Context[Key.RedeemedDealId] = ((RedeemedDeal)Context[Key.RedeemedDeal]).Id;
Guid globalUserId = ((RedeemedDealInfo)Context[Key.RedeemedDealInfo]).GlobalUserId;
Context[Key.GlobalUserId] = globalUserId;
string userId = globalUserId.ToString();
if (rewardOperations.AddReferredRedemptionReward() == ResultCode.Success)
{
payload[Key.GlobalUserId.ToString()] = userId;
payload[Key.ReferralEvent.ToString()] = ReferralEvent.Signup.ToString();
ScheduledJobDetails scheduledJobDetails = new ScheduledJobDetails
{
JobId = Guid.NewGuid(),
JobType = ScheduledJobType.ApplyReferralReward,
JobDescription = userId,
Orchestrated = true,
StartTime = DateTime.UtcNow,
Payload = payload
};
scheduler.ScheduleJobAsync(scheduledJobDetails).Wait();
}
}
}
/// <summary>
/// Obtains the ANID for the specified canonical user ID.
/// </summary>
/// <param name="userId">
/// The canonical user ID for whose ANID to obtain.
/// </param>
/// <param name="commerceConfig">
/// The configuration instance to use.
/// </param>
/// <returns>
/// The ANID for the specified user.
/// </returns>
private static string GetAnidFromUserId(Guid userId,
CommerceConfig commerceConfig)
{
string puid = String.Empty;
User user = PartnerFactory.UsersDal(commerceConfig).GetUserByUserId(userId);
if (user != null)
{
puid = user.MsId;
}
return(CommerceAnalyticsFactory.AnalyticsUserInfo(commerceConfig).GetAnidFromPuid(puid));
}
public MainController(
UserFactory userFactory,
PartnerFactory partnerFactory,
PartnerActionMapFactory partnerActionMapFactory,
UsedActionFactory usedActionFactory
)
{
_userFactory = userFactory;
_partnerFactory = partnerFactory;
_partnerActionMapFactory = partnerActionMapFactory;
_usedActionFactory = usedActionFactory;
}
/// <summary>
/// Initializes a new instance of the CommerceWorker class.
/// </summary>
public CommerceWorker()
{
ExemptConfigurationItems = new[] { ProcessJobsPropertyKey };
Scheduler = PartnerFactory.Scheduler(CommerceWorkerConfig.Instance.SchedulerQueueName,
CommerceWorkerConfig.Instance.SchedulerTableName,
CommerceWorkerConfig.Instance);
// Register Analytics Service
Analytics.Initialize(CommerceWorkerConfig.Instance);
#if IntDebug || IntRelease
ServicePointManager.ServerCertificateValidationCallback = ValidateServerCertificate;
#endif
}
/// <summary>
/// Registers external services for commerce like MVC constructs, security providers and Analytics
/// </summary>
internal static void RegisterExternalServices()
{
// Use only for debugging
// TelemetryConfiguration.Active.TelemetryChannel.DeveloperMode = true;
TelemetryConfiguration.Active.InstrumentationKey = CloudConfigurationManager.GetSetting("APPINSIGHTS_INSTRUMENTATIONKEY");
// Register log.
LogInitializer.CreateLogInstance(CommerceServiceConfig.Instance.LogVerbosity,
CommerceServiceConfig.Instance.ForceEventLog,
General.CommerceLogSource,
CommerceServiceConfig.Instance);
Log.Info("Started Commerce MBI service.");
// Register MVC constructs.
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
// Bing FrontDoor and user debug security providers.
IUsersDal usersDal = PartnerFactory.UsersDal(CommerceServiceConfig.Instance);
if (CommerceServiceConfig.Instance.EnableDebugSecurityProvider == true)
{
Security.Add("user_debug", new UserDebugSecurityProvider(usersDal));
}
Security.Add("lomo", new LomoSecurityProvider(usersDal));
// Register the mutual SSL security provider.
Security.Add(MutualSslSecurityProvider.Name, new MutualSslSecurityProvider());
// Register the Simple Web Token security provider.
string environment = string.Concat("commerce-", CommerceServiceConfig.Instance.Environment);
string resourceTemplate = string.Concat(string.Format("https://{0}.TODO_INSERT_YOUR_DOMAIN_HERE/api/commerce/service/",
environment), "{0}");
Security.Add(SimpleWebTokenSecurityProvider.Name,
new SimpleWebTokenSecurityProvider(environment, resourceTemplate,
CommerceServiceConfig.Instance.SimpleWebTokenKey));
// Amex payment authorization SWT security provider
Security.Add("Bearer", new SimpleWebTokenSecurityProvider(environment,
string.Concat(string.Format("https://{0}.TODO_INSERT_YOUR_DOMAIN_HERE/api/commerce/amex/", environment), "{0}"),
CommerceServiceConfig.Instance.SimpleWebTokenKey));
// Register Analytics Service
Analytics.Initialize(CommerceServiceConfig.Instance);
}
/// <summary>
/// Adds an item to the analytics
/// </summary>
/// <param name="analyticsAction">
/// Type of action
/// </param>
/// <param name="trackingId">
/// Tracking Id for the request, AKA Event ID.
/// </param>
/// <param name="userId">
/// Id of the user performing the action
/// </param>
/// <param name="dealId">
/// Id of the deal
/// </param>
/// <param name="partnerDealId">
/// Partner Deal Id
/// </param>
public static void Add(AnalyticsAction analyticsAction,
Guid trackingId,
Guid dealId = default(Guid))
{
if (CommerceServiceConfig.Instance.EnableServiceHealth == true)
{
AnalyticsClient.AnalyticsItem item = new AnalyticsClient.AnalyticsItem
{
Action = analyticsAction.ToString(),
ClientId = AnalyticsClientId,
EventId = trackingId,
DealId = dealId,
};
PartnerFactory.AnalyticsClient(CommerceServiceConfig.Instance).Add(item);
}
}
/// <summary>
/// Adds a user registration event to the analytics.
/// </summary>
/// <param name="userId">
/// The canonical user ID to associate with the event.
/// </param>
/// <param name="registerUserEventId">
/// The ID of this register user event.
/// </param>
/// <param name="correlationId">
/// The ID of the event to which this event will be correlated.
/// </param>
/// <param name="referrer">
/// The referrer to which to associate the registration of this user, if any.
/// </param>
public static void AddRegisterUserEvent(Guid userId,
Guid registerUserEventId,
Guid correlationId,
string referrer)
{
if (CommerceServiceConfig.Instance.EnableServiceHealth == true)
{
AnalyticsClient.AnalyticsItem item = new AnalyticsClient.AnalyticsItem
{
Action = AnalyticsClient.Actions.Actions.RegisterUser,
UserId = GetAnidFromUserId(userId, CommerceServiceConfig.Instance),
ClientId = AnalyticsClientId,
EventId = registerUserEventId,
ParentEventId = correlationId,
ReferrerClientId = referrer
};
PartnerFactory.AnalyticsClient(CommerceServiceConfig.Instance).Add(item);
}
}
/// <summary>
/// Adds an add card event to the analytics.
/// </summary>
/// <param name="userId">
/// The canonical user ID to associate with the event.
/// </param>
/// <param name="addCardEventId">
/// The ID of this add card event.
/// </param>
/// <param name="correlationId">
/// The ID of the event to which this event will be correlated.
/// </param>
/// <param name="referrer">
/// The referrer to which to associate the adding of this card, if any.
/// </param>
public static void AddAddCardEvent(Guid userId,
Guid addCardEventId,
Guid correlationId,
string referrer)
{
if (CommerceServiceConfig.Instance.EnableServiceHealth == true)
{
AnalyticsClient.AnalyticsItem item = new AnalyticsClient.AnalyticsItem
{
Action = AnalyticsAction.AddCard.ToString(),
UserId = userId.ToString(),
ClientId = AnalyticsClientId,
EventId = addCardEventId,
ParentEventId = correlationId,
ReferrerClientId = referrer
};
PartnerFactory.AnalyticsClient(CommerceServiceConfig.Instance).Add(item);
}
}
/// <summary>
/// Adds a redemption event to the analytics.
/// </summary>
/// <param name="userId">
/// The canonical user ID to associate with the event.
/// </param>
/// <param name="redemptionEventId">
/// The ID of this redemption event.
/// </param>
/// <param name="correlationId">
/// The ID of the event to which this event will be correlated.
/// </param>
/// <param name="dealId">
/// The ID of the deal being redeemed.
/// </param>
/// <param name="currency">
/// The currency involved in the transaction in which the deal was redeeemed.
/// </param>
/// <param name="authorizationAmount">
/// The authorization amount in the transaction in which the deal was redeemed.
/// </param>
/// <param name="discountAmount">
/// The discount amount from the transaction in which the deal was redeemed.
/// </param>
/// <param name="discountId">
/// The ID of the discount within the deal that was specifically redeemed.
/// </param>
/// <param name="partnerMerchantId">
/// The ID of the merchant as assigned by the processing partner.
/// </param>
/// <param name="config">
/// Optional configuration
/// </param>
public static void AddRedemptionEvent(Guid userId,
Guid redemptionEventId,
Guid correlationId,
Guid dealId,
string currency,
int authorizationAmount,
int discountAmount,
Guid discountId,
string partnerMerchantId,
CommerceConfig config = null)
{
if (config == null)
{
config = CommerceServiceConfig.Instance;
}
if (config.EnableServiceHealth == true)
{
AnalyticsClient.Payloads.DealRedemptionPayload payload = new AnalyticsClient.Payloads.DealRedemptionPayload
{
AuthorizationAmount = authorizationAmount,
Currency = currency,
DiscountAmount = discountAmount,
DiscountId = discountId,
PartnerMerchantId = partnerMerchantId
};
AnalyticsClient.AnalyticsItem item = new AnalyticsClient.AnalyticsItem
{
Action = AnalyticsClient.Actions.Actions.RedeemedDeal,
UserId = GetAnidFromUserId(userId, config),
ClientId = AnalyticsClientId,
EventId = redemptionEventId,
ParentEventId = correlationId,
DealId = dealId,
JPayload = JObject.FromObject(payload)
};
PartnerFactory.AnalyticsClient(config).Add(item);
}
}
/// <summary>
/// Process the rewards if applicable
/// </summary>
/// <param name="settlementDetail">
/// Settlement Details
/// </param>
/// <returns>
/// Async Task Wrapper
/// </returns>
internal async Task ProcessRewardPayoutAsync(SettlementDetail settlementDetail)
{
if (settlementDetail.TransactionType == TransactionType.SettlementRedemption)
{
// First add a redemption reward to the redeeming user if they're enabled.
if (EnableRedemptionRewards == true && WorkerActions.RewardRedemption(RewardOperations, Context) == ResultCode.Success)
{
// Add job to process the reward payout. Note that this job will be scheduled 30 minutes in the
// future to guard against applying a reward for a transaction that was reversed in a later
// record.
ConcurrentDictionary <string, string> payload = new ConcurrentDictionary <string, string>();
payload[Key.RewardPayoutId.ToString()] = ((Guid)Context[Key.RewardPayoutId]).ToString();
payload[Key.PartnerCardId.ToString()] = (string)Context[Key.PartnerCardId];
payload[Key.PartnerRedeemedDealId.ToString()] = settlementDetail.TransactionId;
IScheduler scheduler = PartnerFactory.Scheduler(CommerceWorkerConfig.Instance.SchedulerQueueName,
CommerceWorkerConfig.Instance.SchedulerTableName,
CommerceWorkerConfig.Instance);
ScheduledJobDetails scheduledJobDetails = new ScheduledJobDetails
{
JobId = Guid.NewGuid(),
JobType = ScheduledJobType.ApplyRedemptionReward,
JobDescription = settlementDetail.ConsumerId,
Orchestrated = true,
StartTime = DateTime.UtcNow.AddMinutes(30),
Payload = payload
};
await scheduler.ScheduleJobAsync(scheduledJobDetails).ConfigureAwait(false);
}
// Then add a referred redemption reward to the user who referred the redeeming user.
WorkerActions.RewardReferredRedemption(RewardOperations, Context);
}
else
{
Context.Log.Verbose("No Bing Reward can be given for a reversed transaction.");
}
}
/// <summary>
/// Queues claiming already claimed deals for the new card.
/// </summary>
/// <param name="response">
/// The AddCardResponse being built.
/// </param>
private void QueueClaimingDeals(AddCardResponse response)
{
Context.Log.Verbose("Queueing claiming user's existing claimed deals for the new card.");
string userId = ((User)Context[Key.User]).GlobalId.ToString();
ConcurrentDictionary <string, string> payload = new ConcurrentDictionary <string, string>();
payload[Key.GlobalUserId.ToString()] = userId;
payload[Key.CardId.ToString()] = General.IntegerFromGuid(response.NewCardId).ToString();
ScheduledJobDetails scheduledJobDetails = new ScheduledJobDetails
{
JobId = Guid.NewGuid(),
JobType = ScheduledJobType.ClaimDiscountsForNewCard,
JobDescription = userId,
Orchestrated = true,
StartTime = DateTime.UtcNow,
Payload = payload
};
IScheduler scheduler = PartnerFactory.Scheduler(CommerceServiceConfig.Instance.SchedulerQueueName,
CommerceServiceConfig.Instance.SchedulerTableName,
CommerceServiceConfig.Instance);
scheduler.ScheduleJobAsync(scheduledJobDetails).Wait();
}
/// <summary>
/// Adds a log entry to the log table
/// </summary>
/// <param name="requestId">
/// Request Id that uniquely identifies the service request to the commerce server
/// </param>
/// <param name="resultCode">
/// Result code of the service invocation
/// </param>
/// <param name="resultSummary">
/// Summary explanation of the result code
/// </param>
/// <param name="config">
/// The configuration to use to get settings.
/// </param>
public static void Add(Guid requestId,
ResultCode resultCode,
string resultSummary,
CommerceConfig config)
{
try
{
if (config == null)
{
throw new ArgumentNullException("config", "Parameter config cannot be null.");
}
if (config.EnableServiceHealth == true)
{
DashboardLogEntity logEntity = new DashboardLogEntity(requestId, resultCode.ToString(), resultSummary);
PartnerFactory.AzureTable(config).InsertEntity(logEntity);
}
}
catch (Exception exception)
{
Log.Error(exception, string.Format("Unable to log the data to azure table : {0} ", exception.Message));
}
}
/// <summary>
/// Process the transaction log file
/// </summary>
/// <returns>
/// Async Task Wrapper
/// </returns>
public async Task Process()
{
TransactionLogParser transactionLogParser = new TransactionLogParser(Context.Log);
TransactionLogFile transactionLogFile = transactionLogParser.Parse(TransactionLogFileName, TransactionLogFileStream);
if (transactionLogFile != null)
{
foreach (TransactionLogDetail detail in transactionLogFile.TransactionLogRecords)
{
// block the reversed transactions
if (TransactionIdSet.Contains(detail.TransactionId) || detail.TransactionAmount <= 0)
{
continue;
}
TransactionIdSet.Add(detail.TransactionId);
// 1. process the detail record here -> Insert as redeemed deal
RedeemedDeal redeemedDeal = new RedeemedDeal()
{
AnalyticsEventId = Guid.NewGuid()
};
Context[Key.RedeemedDeal] = redeemedDeal;
MarshalRedeemDeal(detail);
ResultCode result = RedeemedDealOperations.AddRedeemedDeal();
//2. If the record was processed successfully, attempt to add a redemption reward if applicable and analytics
if (result == ResultCode.Created)
{
RedeemedDealInfo redemptionInfo = (RedeemedDealInfo)Context[Key.RedeemedDealInfo];
// First add a redemption reward to the redeeming user if they're enabled.
if (EnableRedemptionRewards)
{
if (WorkerActions.RewardRedemption(RewardOperations, Context) == ResultCode.Success)
{
// Add job to process the reward payout.
ConcurrentDictionary <string, string> payload = new ConcurrentDictionary <string, string>();
payload[Key.RewardPayoutId.ToString()] = ((Guid)Context[Key.RewardPayoutId]).ToString();
payload[Key.PartnerCardId.ToString()] = (string)Context[Key.PartnerCardId];
payload[Key.PartnerRedeemedDealId.ToString()] = redemptionInfo.PartnerRedeemedDealId;
IScheduler scheduler = PartnerFactory.Scheduler(CommerceWorkerConfig.Instance.SchedulerQueueName,
CommerceWorkerConfig.Instance.SchedulerTableName,
CommerceWorkerConfig.Instance);
ScheduledJobDetails scheduledJobDetails = new ScheduledJobDetails
{
JobId = Guid.NewGuid(),
JobType = ScheduledJobType.ApplyRedemptionReward,
JobDescription = redemptionInfo.GlobalUserId.ToString(),
Orchestrated = true,
Payload = payload
};
await scheduler.ScheduleJobAsync(scheduledJobDetails).ConfigureAwait(false);
}
}
// Then add a referred redemption reward to the user who referred the redeeming user.
Context[Key.RedeemedDealId] = ((RedeemedDeal)Context[Key.RedeemedDeal]).Id;
Context[Key.GlobalUserId] = ((RedeemedDealInfo)Context[Key.RedeemedDealInfo]).GlobalUserId;
WorkerActions.RewardReferredRedemption(RewardOperations, Context);
// Update analytics.
// For FDC this happens at AUTH time
// Butfor Amex flow, we put analytics at the time of Transaction File Processing
SharedUserLogic sharedUserLogic = new SharedUserLogic(Context,
CommerceOperationsFactory.UserOperations(Context));
Context[Key.GlobalUserId] = redemptionInfo.GlobalUserId;
User user = sharedUserLogic.RetrieveUser();
Analytics.AddRedemptionEvent(redemptionInfo.GlobalUserId, redeemedDeal.AnalyticsEventId, user.AnalyticsEventId,
redemptionInfo.ParentDealId, redemptionInfo.Currency,
redeemedDeal.AuthorizationAmount, redemptionInfo.DiscountAmount,
redemptionInfo.GlobalId, (string)Context[Key.PartnerMerchantId],
CommerceWorkerConfig.Instance);
}
}
}
}
/// <summary>
/// Places the User object representing the person making this request to the context.
/// </summary>
/// <returns>
/// The ResultCode corresponding to the result of the operation.
/// </returns>
/// <remarks>
/// If flagged to do so, a user account will be created and associated with the specified e-mail address, if the e-mail
/// address has not already been used.
/// </remarks>
private ResultCode PlaceUserInContext()
{
ResultCode result = ResultCode.Success;
bool createUnauthenticatedAccount = false;
if (Context[Key.CreateUnauthenticatedAccount] != null)
{
createUnauthenticatedAccount = (bool)Context[Key.CreateUnauthenticatedAccount];
}
if (createUnauthenticatedAccount == true)
{
string emailAddress = Context[Key.EmailAddress] as string;
if (String.IsNullOrWhiteSpace(emailAddress) == false)
{
try
{
// Ensure the e-mail address may be valid.
MailAddress mailAddress = new MailAddress(emailAddress);
// Attempt to add a user to User Services via Users Dal and obtain its authentication vector.
IUsersDal usersDal = PartnerFactory.UsersDal(Context.Config);
Users.Dal.DataModel.User fullUser = usersDal.CreateUnauthenticatedUser(mailAddress.Address, (string)Context[Key.ReferrerId],
(string)Context[Key.UserLocation]);
UnauthenticatedAddCardResponse response = (UnauthenticatedAddCardResponse)Context[Key.Response];
if (String.IsNullOrWhiteSpace(fullUser.MsId) == true)
{
response.AuthenticationVector = AuthenticationVector.Email.ToString();
}
else if (fullUser.MsId.StartsWith("FB-", StringComparison.OrdinalIgnoreCase) == true)
{
response.AuthenticationVector = AuthenticationVector.Facebook.ToString();
}
else
{
response.AuthenticationVector = AuthenticationVector.MicrosoftAccount.ToString();
}
Guid userId = fullUser.Id;
Context[Key.GlobalUserId] = userId;
// If the user returned by User Services has not already been registered in the Commerce system, register a new Commerce user.
User user = SharedUserLogic.RetrieveUser();
if (user == null)
{
user = new User(userId, Guid.NewGuid());
Context[Key.User] = user;
result = SharedUserLogic.AddUser();
if (result == ResultCode.Created)
{
Analytics.AddRegisterUserEvent(user.GlobalId, user.AnalyticsEventId, Guid.Empty, Context[Key.ReferrerId] as string);
result = ResultCode.Success;
}
}
else
{
Context[Key.User] = user;
}
// If the user was added or retrieved successfully, proceed.
if (result == ResultCode.Success)
{
// If the user has not already signed up officially with Bing Offers, proceed.
if (response.AuthenticationVector == AuthenticationVector.Email.ToString())
{
// If the user has not already added a card, proceed.
SharedCardLogic sharedCardLogic = new SharedCardLogic(Context, CommerceOperationsFactory.CardOperations(Context));
if (sharedCardLogic.RetrieveUserCards().Count() == 0)
{
response.ActivationToken = fullUser.ActivationToken;
}
else
{
result = ResultCode.UnauthenticatedUserAlreadyExists;
}
}
else
{
result = ResultCode.UserAlreadyExists;
}
}
}
catch (FormatException)
{
result = ResultCode.InvalidParameter;
}
}
else
{
result = ResultCode.ParameterCannotBeNull;
}
}
else
{
Context[Key.User] = SharedUserLogic.RetrieveUser();
}
return(result);
}
/// <summary>
/// Creates the appropriate Log instance for the current environment.
/// </summary>
/// <param name="deploymentId">
/// * If running in Azure, the ID of the deployment that created the VM hosting this application
/// * Else null.
/// </param>
/// <param name="instanceId">
/// * If running in Azure, the ID of the role instance currently hosting this application
/// * Else null.
/// </param>
/// <param name="traceListener">
/// * If running in Azure, the Azure diagnostic monitor trace listener to use for the log.
/// * Else null.
/// </param>
/// <param name="logVerbosity">
/// Specified the verbosity level for entries to commit to the log.
/// </param>
/// <param name="forceEventLog">
/// Specifies whether to force use of the event log instead of other logging mechanisms.
/// </param>
/// <param name="source">
/// The source under which to log events.
/// </param>
/// <param name="configuration">
/// The configuration to use to get settings.
/// </param>
internal static void CreateLogInstance(string deploymentId,
string instanceId,
TraceListener traceListener,
SourceLevels logVerbosity,
bool forceEventLog,
string source,
CommerceConfig configuration)
{
lock (CreateLogInstanceLock)
{
string dashboardConnectionKey;
if (General.RunningInAzure == true)
{
// If the event log is not set to be used regardless of environment, create a TraceLog and a listener to
// funnel log entries into central storage.
if (forceEventLog == false)
{
Log.Instance = new TraceLog(new List <TraceListener> {
traceListener
}, logVerbosity)
{
Source = source
};
}
else
{
Log.Instance = new EventLogLog(logVerbosity)
{
Source = source
};
}
// Set the server ID to a value useful in Azure.
RequestInformationExtensions.ServerId = String.Format("{0}_{1}", deploymentId,
instanceId.Substring(instanceId.LastIndexOf("_", StringComparison.OrdinalIgnoreCase) + 1));
dashboardConnectionKey = CloudConfigurationManager.GetSetting(DashboardConnectionString);
}
else
{
Log.Instance = new EventLogLog(logVerbosity)
{
Source = source
};
dashboardConnectionKey = ConfigurationManager.AppSettings[DashboardConnectionString];
}
// Initialize the dashboard table into which a subset of warnings will be logged.
if (String.IsNullOrEmpty(dashboardConnectionKey) == false)
{
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(dashboardConnectionKey);
PartnerFactory.AzureTable(configuration).Initialize(cloudStorageAccount, DashboardTableName,
new ExponentialRetry(TimeSpan.FromSeconds(5), 1));
}
// Flag log instance as set so CommerceLog won't attempt to create one.
CommerceLog.LogInstanceSet = true;
CommerceLog.Config = configuration;
}
}
public PartnerActionMapController(PartnerActionMapFactory factory, PartnerFactory partnerFactory, ActionFactory actionFactory)
{
_factory = factory;
_partnerFactory = partnerFactory;
_actionFactory = actionFactory;
}
/// <summary>
/// Concludes execution of the Add card call after previous work has been completed.
/// </summary>
/// <param name="resultCode">
/// The ResultCode to set within the call response.
/// </param>
/// <exception cref="ArgumentNullException">
/// Parameter context cannot be null.
/// </exception>
public void Conclude(ResultCode resultCode)
{
try
{
Context.Log.Verbose("ResultCode when Conclude process begins: {0}.", resultCode);
// If process succeeded, update internal data storage.
AddCardResponse response = (AddCardResponse)Context[Key.Response];
if (resultCode == ResultCode.Created)
{
// Add the card.
resultCode = AddCard();
if (resultCode == ResultCode.Created || resultCode == ResultCode.Success)
{
response.NewCardId = General.GuidFromInteger(((Card)Context[Key.Card]).Id);
// If a new card was added, kick off confirmation process for unauthenticated users and add needed information to analytics.
// TODO: AddCard() above returns ResultCode.Success. So the code below will not execute. Is it ok?
if (resultCode == ResultCode.Created)
{
// Kick off confirmation process for unauthenticated users.
bool createUnauthenticatedAccount = false;
if (Context[Key.CreateUnauthenticatedAccount] != null)
{
createUnauthenticatedAccount = (bool)Context[Key.CreateUnauthenticatedAccount];
}
if (createUnauthenticatedAccount == true)
{
IUsersDal usersDal = PartnerFactory.UsersDal(Context.Config);
Task.Run(() => usersDal.CompleteUnauthenticatedUserSetUp((Guid)Context[Key.GlobalUserId]));
}
// Add analytics info.
Context.Log.Verbose("Adding new card to analytics.");
User user = (User)Context[Key.User];
Analytics.AddAddCardEvent(user.GlobalId, user.AnalyticsEventId, Guid.Empty, Context[Key.ReferrerId] as string);
}
// Queue deal claiming if set to do so.
bool queueDealClaiming = false;
if (Context[Key.QueueJob] != null)
{
queueDealClaiming = (bool)Context[Key.QueueJob];
}
// Linking is only for First Data, but by the time execution reaches this part of the code, the card may need to be linked to CLO offers or
// Burn offers, or both, but definitely at least one of them. Therefore, a job has to be scheduled to cover the relevant combination of CLO
// and Burn offers. That Earn offers are not registered with First Data doesn't change this-- the filtering will have to occur as part of the job.
if (queueDealClaiming == true)
{
QueueClaimingDeals(response);
resultCode = ResultCode.JobQueued;
}
}
}
response.ResultSummary.SetResultCode(resultCode);
RestResponder.BuildAsynchronousResponse(Context);
}
catch (Exception ex)
{
RestResponder.BuildAsynchronousResponse(Context, ex);
}
}
public PartnersController(PartnerFactory partnerFactory, PartnerTypeFactory partnerTypeFactory)
{
_partnerFactory = partnerFactory;
_partnerTypeFactory = partnerTypeFactory;
}
/// <summary>
/// Initializes the Analytics client
/// </summary>
/// <param name="commerceConfig">
/// The CommerceConfig object to use during initialization.
/// </param>
public static void Initialize(CommerceConfig commerceConfig)
{
PartnerFactory.AnalyticsClient(commerceConfig).Initialize("commerce");
}
public UsersController(UserFactory userFactory, PartnerFactory partnerFactory, AspNetUserManager <DiscountsUser> userManager)
{
_userFactory = userFactory;
_partnerFactory = partnerFactory;
_userManager = userManager;
}
