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); }