Trigger Mailings

First implementations

1. How to tag consumers to whom we have already sent this email?
2. How to process all consumers as quickly as possible and at the same time not slow down the work of sites (which access the same records in the database)?

1. Sending newsletters comes from the windows-service, which periodically checks to see if there are new consumers that match the conditions.
2. In the service, the first step is one query to the database with the Read Uncommitted isolation level . This request pulls the Id of all consumers to whom the letter should be sent. Due to the low level of isolation, such a request does not impose locks on entries in the database and, as a result, extremely weakly affects the operation of the site. However, it does not guarantee the purity of the data and must be re-checked with a higher level of isolation.
3. After we pulled the Id of consumers, for each consumer we perform a separate transaction with a isolation level of Serializable. In this transaction, we re-check whether the consumer is suitable for the conditions and if so, send him a letter and issue a marker action. Since we process each consumer in a separate transaction, locks are imposed only on the data of one consumer and are not affected by the work of other consumers. Since such a transaction is very short, the consumer to whom the letter is sent will also not have much problems if he visits the site at this time. The transaction isolation level should be exactly Serializable, in order not to accidentally send one letter twice, or not send a letter to a consumer who suddenly ceased to fit the conditions. Although, if we guarantee that sending the same mailing can go only from one stream and from one server, we’ll also hammer it at a small chanceRead committed transaction.

• marker action template (we used to call the template an action type: I think this is a more understandable term for developers) that is issued when sending an email
• sending method
• a method that performs additional actions (for example, together with sending a birthday greetings, we can issue points to the consumer)
• method that forms expressionion>verifying that the consumer is eligible

Replacing inheritance with a composition

• instead of overloading a property that returns a marker action template, this property is affixed to the class instance
• instead of overloading the methods sending letters / sms and performing additional logic, an arbitrary operation is put down on the class instance, which must be performed on the consumer. Moreover, the operation may be a combination of other operations
• instead of overloading the method that forms Expression, the class instance is given a condition. In this case, the conditions can be combined through AND / OR

Add(new Trigger(“Приглашение на сайт для пришедших через канал one-to-one”)
{
	MarkerActionTemplateSystemName = “InvitationMarker”,
	TriggerAction = new TriggerActionCombination(
		new GeneratePasswordForCustomerTriggerAction(),
		new SendEmailTriggerAction(“InvitationMailing”)),
	TriggerCondition = new AndTriggerConditionSet(
		new CustomerHasSubscripionCondition(),
		new CustomerHasEmailTriggerCondition(),
		new CustomerHadFirstActionOverChannelCondition(“OneToOne”)),
});

public interface ITriggerAction
{
	void Execute(
		ModelContext modelContext, // класс для работы с БД 
		Customer customer);
}

public class TriggerCondition
{
	private readonly Func>> triggerExpressionBuilder;
	public TriggerCondition(Func>> triggerExpressionBuilder)
	{
		if (triggerExpressionBuilder == null)
			throw new ArgumentNullException("triggerExpressionBuilder");
		this.triggerExpressionBuilder = triggerExpressionBuilder;
	}
	public Expression> GetExpression(ModelContext modelContext)
	{
		return triggerExpressionBuilder(modelContext, brand);
	}
	// Используется в Read Uncommitted транзакции для получения спиcка Id потребителей, подходящих под условие
	public IQueryable ChooseCustomers(ModelContext modelContext, IQueryable customers)
	{
		if (modelContext == null)
			throw new ArgumentNullException("modelContext");
		if (customers == null)
			throw new ArgumentNullException("customers");
		var expression = GetExpression(modelContext);
		return customers.Where(expression).ExpandExpressions();
	}
	// Используется в Serializable транзакции, для проверки, что потребитель все еще подходит под условие
	public bool ShouldTrigger(ModelContext modelContext, Customer customer)
	{
		if (modelContext == null)
			throw new ArgumentNullException("modelContext");
		if (customer == null)
			throw new ArgumentNullException("customer");
		var expression = GetExpression(modelContext);
		// Можно бы было просто вызывать expression.Evaluate(customer),
		// но тогда для сложных условий выполнилось бы несколько запросов в БД вместо одного
		return modelContext.Repositories.Get().Items
			.Where(aCustomer => aCustomer == customer)
			.Where(aCustomer => expression.Evaluate(aCustomer))
			.ExpandExpressions()
			.Any();
	}
}

All tired, start your triggers yourself

• By this time, we began to register the sending of any letter as an action, and the action marker became redundant - we could already determine to whom we sent the letter, and in general we would like to get rid of issuing unnecessary actions wherever possible
• in addition to simple triggers that performed a specific set of operations once on each consumer, we now have periodic triggers . It was necessary to figure out how to transfer all this to the database and at the same time allow the use of arbitrary markers
• marketers come up with triggers not separately from each other, but as chains in which there are both triggers and operations performed by the consumer on the site (a letter asking to go to the site and do something → the consumer performs several operations on the site → bonus points are awarded and a letter is sent about this). If I didn’t immediately realize this, I would like to leave the groundwork for the future so that it would not be difficult to describe the dependencies between triggers and operations

Need More Expressions

public sealed override Expression> GetIsMarkerExpression(ModelContext modelContext)
{
	return action => action.ActionTemplateId == ActionTemplateId;
}

public override Expression> GetIsMarkerExpression(ModelContext modelContext)
{
	IQueryablehabracut customerPrizes = modelContext.Repositories.Get().GetByPrizes(Prize);
	// отфильтровываем действия, связанные с выдачей заданного приза
	return action => customerPrizes.Any(prize => prize.CustomerActionId == action.Id);
}

public override Expression> BuildShouldRepeatExpression(ModelContext modelContext, 
Expression> isMarkerExpression)
{
	var markerActions = modelContext.Repositories.Get().Items
		.Where(isMarkerExpression.ExpandExpressions());
	return customer => !markerActions.Any(action => action.Customer == customer);
}

public override Expression> BuildShouldRepeatExpression(
	ModelContext modelContext, Expression> isMarkerExpression)
{
	var isInPeriodExpression = PeriodType.BuildIsInPeriodExpression(modelContext, PeriodValue);
	var markerActions = modelContext.Repositories.Get().Items
		.Where(isMarkerExpression.ExpandExpressions());
	var markerActionsInPeriod = markerActions.Where(isInPeriodExpression.ExpandExpressions());
	if (MaxRepeatCount == null)
	{
		return customer => !markerActionsInPeriod.Any(action => action.Customer == customer);
	}
	else
	{
		return customer => 
			!markerActionsInPeriod.Any(action => action.Customer == customer) &&
			markerActions.Count() < MaxRepeatCount.Value;
	} 
}