public virtual void StoreConvention(ConventionWrapper convention, IList <string> deletedIds)
{
using (var session = _holder.Store.OpenSession())
{
var model = convention.Inner;
if (model.CreateTimeStamp == Instant.MinValue)
{
model.CreateTimeStamp = SystemClock.Instance.GetCurrentInstant();
}
model.UpdateTimeStamp = SystemClock.Instance.GetCurrentInstant();
var conventionData = model.Id.IsNotEmptyString() ?
session.Load <Convention>(model.Id) :
new Convention();
StoreGeneralInformation(convention, conventionData);
StoreConvDays(convention, conventionData, session);
StoreConvHalls(convention, conventionData, session);
StoreConvTickets(convention, conventionData, session);
foreach (var id in deletedIds)
{
if (string.IsNullOrWhiteSpace(id))
{
session.Delete(id);
}
}
session.Store(conventionData);
session.SaveChanges();
}
}
private void MigrateDays(ConventionWrapper oldCon)
{
foreach (var day in oldCon.Days)
{
//Days.AddDay(day.Key, day.Value.StartTime, day.Value.EndTime);
//Days.SetTimeSlotStrategy(day.Key, day.Value.TimeSlotStrategy);
}
}
private static void StoreConvHalls(ConventionWrapper convention, Convention convData, IDocumentSession session)
{
convData.HallIds = new List <string>();
foreach (var hall in convention.Halls)
{
session.Store(hall);
convData.HallIds.Add(hall.Id);
}
}
private void StoreConvTickets(ConventionWrapper convention, Convention convData, IDocumentSession session)
{
convData.TicketIds = new List <string>();
foreach (var ticket in convention.Tickets)
{
session.Store(ticket);
convData.TicketIds.Add(ticket.Id);
}
}
private void StoreGeneralInformation(ConventionWrapper wrapperData, Convention conventionData)
{
conventionData.Name = wrapperData.Inner.Name;
conventionData.CreateTimeStamp = wrapperData.Inner.CreateTimeStamp;
conventionData.UpdateTimeStamp = wrapperData.Inner.UpdateTimeStamp;
conventionData.TimeStrategy = wrapperData.Inner.TimeStrategy;
conventionData.Location = wrapperData.Inner.Location;
conventionData.TagLine = wrapperData.Inner.TagLine;
}
private static void StoreConvDays(ConventionWrapper convention, Convention convData, IDocumentSession session)
{
convData.DayIds = new List <string>();
foreach (var day in convention.Days)
{
session.Store(day);
convData.DayIds.Add(day.Id);
}
}
private void MigrateHalls(ConventionWrapper oldCon)
{
foreach (var hall in _convention.Halls)
{
var prevHall = hall;
Halls.AddHall(prevHall.Name,
prevHall.Description,
prevHall.FirstTable,
prevHall.LastTable);
}
}
public ConventionBuilder NewConvention(string name)
{
_convention = new ConventionWrapper
{
Halls = new List <Hall>(),
Tickets = new List <Ticket>(),
Days = new List <Day>()
};
_convention.Inner.Name = name;
CreateSubBuilders();
return(this);
}
private void MigrateTickets(ConventionWrapper oldCon)
{
foreach (var ticket in oldCon.Tickets)
{
//Tickets.AddLimitedTicket(ticket.Value.TicketType, ticket.Key, ticket.Value.Days.Select(x => x.Date).ToArray());
//Tickets.SetTicketPrice(ticket.Key, ticket.Value.Price);
//Tickets.SetTransactionCode(ticket.Key, ticket.Value.TransactionCode);
//if (ticket.Value.IsUnlimited)
// Tickets.SetUnlimitedActivities(ticket.Key);
//else if (ticket.Value.ActivitiesAllowed != null)
// Tickets.SetNumberOfActivities(ticket.Key, ticket.Value.ActivitiesAllowed.Value);
}
}
public ConventionBuilder NewFromOldConvention(string conventionName, ConventionWrapper oldCon, params Migrate[] migrations)
{
ThrowIfRequestInvalid(migrations);
NewConvention(conventionName);
if (migrations.Contains(Migrate.Halls))
{
MigrateHalls(oldCon);
}
if (migrations.Contains(Migrate.Days))
{
MigrateDays(oldCon);
}
if (migrations.Contains(Migrate.Tickets))
{
MigrateTickets(oldCon);
}
return(this);
}
/// <summary>Register a token which defines methods by duck-typing convention.</summary>
/// <param name="mod">The manifest of the mod defining the token.</param>
/// <param name="name">The token name.</param>
/// <param name="provider">The token value provider.</param>
private void RegisterValueProviderByConvention(IManifest mod, string name, object provider)
{
// validate token
if (provider == null)
{
this.Monitor.Log($"Rejected token '{name}' added by {mod.Name} because the token is null.", LogLevel.Error);
return;
}
// get a strongly-typed wrapper
if (!ConventionWrapper.TryCreate(provider, this.Reflection, out ConventionWrapper wrapper, out string error))
{
this.Monitor.Log($"Rejected token '{name}' added by {mod.Name} because it could not be mapped: {error}", LogLevel.Error);
return;
}
// register
this.RegisterValueProvider(mod, new ConventionValueProvider(name, wrapper));
}
public void RegisterToken(IManifest mod, string name, Func <bool> updateContext, Func <bool> isReady, Func <string, IEnumerable <string> > getValue, bool allowsInput, bool requiresInput)
{
// log deprecation warning
string warning = $"{mod.Name} used an experimental token API that will break in the next Content Patcher update.";
if (this.LoggedDeprecationWarnings.Add(warning))
{
this.Monitor.Log(warning, LogLevel.Warn);
}
// hack to wrap legacy token
ConventionWrapper wrapper = new ConventionWrapper();
this.Reflection.GetField <ConventionDelegates.UpdateContext>(wrapper, $"{nameof(wrapper.UpdateContext)}Impl").SetValue(() => updateContext());
this.Reflection.GetField <ConventionDelegates.IsReady>(wrapper, $"{nameof(wrapper.IsReady)}Impl").SetValue(() => isReady());
this.Reflection.GetField <ConventionDelegates.GetValues>(wrapper, $"{nameof(wrapper.GetValues)}Impl").SetValue(input => getValue(input));
this.Reflection.GetField <ConventionDelegates.AllowsInput>(wrapper, $"{nameof(wrapper.AllowsInput)}Impl").SetValue(() => allowsInput);
this.Reflection.GetField <ConventionDelegates.RequiresInput>(wrapper, $"{nameof(wrapper.RequiresInput)}Impl").SetValue(() => requiresInput);
this.RegisterValueProvider(mod, new ConventionValueProvider(name, wrapper));
}
protected BuilderBase(ConventionBuilder parent, ConventionWrapper convention)
{
Convention = convention;
Parent = parent;
}
public DaysBuilder(ConventionBuilder builder, ConventionWrapper convention) : base(builder, convention)
{
}
public TicketsBuilder(ConventionBuilder parent, ConventionWrapper convention) :
base(parent, convention)
{
}
public ConventionBuilder LoadConvention(string id)
{
_convention = _gateway.GetConventionWrapper(id);
CreateSubBuilders();
return(this);
}
