public async Task InvokeAsync( HttpContext context, IContentStorage contentStore, ISchemaStorage schemaStorage, JsonService jsonService) { string schema = (string)context.GetRouteValue("schema"); QueryParameters queryParameters = await jsonService.Deserialize <QueryParameters>(context.Request.Body); ContentSchema schemaModel = await schemaStorage.GetContentSchemaAsync(schema); QueryResult <ContentItem> contentItems = await contentStore.Query(schema, queryParameters); foreach (ContentItem contentItem in contentItems.Items) { contentItem.ApplySchema(schemaModel); } QueryResult <RestContentItem> resultQuery = new QueryResult <RestContentItem>() { Offset = contentItems.Offset, Count = contentItems.Count, TotalCount = contentItems.TotalCount, Items = contentItems.Items.Select(x => x.ToRest()).ToList() }; string json = jsonService.Serialize(resultQuery); await context.Response.WriteAsync(json); }
private static Profile Load(IContentStorage storage, string profileFolder, Guid id, string file) { Profile profile = null; var path = storage.CombinePath(profileFolder, file); if (storage.IsFileExist(path)) { var document = new XmlDocument(); using (var stream = storage.OpenForRead(path)) { document.Load(stream); } var rootElement = document.DocumentElement; var name = rootElement.GetChildElementText(NameElementName) ?? file; var passwordHash = rootElement.GetChildElementText(PasswordHashElementName); profile = new Profile(id, name, passwordHash); profile.WorldName = rootElement.GetChildElementText(WorldElemenName); var activeData = rootElement.GetChildElementText(LastActiveElementName); DateTime lastActive; if (!string.IsNullOrEmpty(activeData) && DateTime.TryParse(activeData, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out lastActive)) { profile.LastActive = lastActive; } else { profile.LastActive = DateTime.MinValue; } } return(profile); }
/// <summary> /// Public constructor used for dependencies injection /// </summary> /// <param name="rssSourcesProvider">RSS Sources prodiver instance</param> /// <param name="newsProvider">New provider instance</param> /// <param name="storage">Storage provider instance</param> /// <param name="parser">Parser provider instance</param> public SourcesController(IRssSourcesProvider rssSourcesProvider, INewsProvider newsProvider, IContentStorage storage, IParserProvider parser) { _rssSourcesProvider = rssSourcesProvider; _newsProvider = newsProvider; _contentStorage = storage; _newsParser = parser; }
protected BaseCloudProvider(IContentStorage storage, AzureStorageConfiguration configuration) { Ensure.That(storage).IsNotNull(); Ensure.That(configuration).IsNotNull(); Storage = storage; Configuration = configuration; }
public TempContentStorage( IOptions <TempContentStorageOptions> options, IContentStorage contentStorage, ILogger <TempContentStorage> logger) { this.contentStorage = contentStorage ?? throw new ArgumentNullException(nameof(contentStorage)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); this.options = options?.Value ?? throw new ArgumentNullException(nameof(options)); }
public async Task InvokeAsync( HttpContext context, IContentStorage contentStore) { Guid contentId = Guid.Parse((string)context.GetRouteValue("id")); string schema = (string)context.GetRouteValue("schema"); await contentStore.PublishAsync(schema, contentId); }
public MessageService( IUnitOfWork unitOfWork, IContentStorage contentStorage, CloudStorageConfiguration cloudStorageConfiguration, AttachmentConfiguration attachmentConfiguration) : base(unitOfWork) { _contentStorage = contentStorage; _cloudStorageConfiguration = cloudStorageConfiguration; _attachmentConfiguration = attachmentConfiguration; }
private async Task RemoveExpiredContent(IContentStorage contentStorage, CancellationToken cancellationToken) { await foreach (var page in contentStorage.GetAll(options.ContentCategory, cancellationToken)) { foreach (var item in page.Where(x => x.Timestamp.Add(options.ContentSavePeriod) < DateTimeOffset.UtcNow)) { await contentStorage.Delete(item.Id, options.ContentCategory, cancellationToken); } } }
public ChannelService(IUnitOfWork unitOfWork, IChannelMemberService channelMemberService, IMemberService memberService, CloudStorageConfiguration configuration, IContentStorage contentStorage) : base(unitOfWork) { _channelMemberService = channelMemberService; _memberService = memberService; _configuration = configuration; _contentStorage = contentStorage; }
public DocumentStorage( IElasticClient elasticClient, IOptions <DocumentStorageOptions> options, IContentStorage contentStorage, ITextHighlighter textHighlighter) { this.elasticClient = elasticClient ?? throw new ArgumentNullException(nameof(elasticClient)); this.contentStorage = contentStorage ?? throw new ArgumentNullException(nameof(contentStorage)); this.textHighlighter = textHighlighter ?? throw new ArgumentNullException(nameof(textHighlighter)); this.options = options?.Value ?? throw new ArgumentNullException(nameof(options)); }
/// <summary> /// Initializes a new instance of the <see cref="MediaControllerHelper" /> class. /// </summary> /// <param name="mediaService">The media service.</param> /// <param name="contentStorage">The content storage.</param> /// <param name="tagsService">The tags service.</param> /// <param name="tagsSearchCacheHelper">The tags search cache helper.</param> public MediaControllerHelper( IMediaService mediaService, IContentStorage contentStorage, ITagsService tagsService, ITagsSearchCacheHelper tagsSearchCacheHelper ) { this.mediaService = mediaService; this.contentStorage = contentStorage; this.tagsService = tagsService; this.tagsSearchCacheHelper = tagsSearchCacheHelper; }
public static XmlElement LoadXml(this IContentStorage storage, string path) { XmlElement element = null; if (storage.IsFileExist(path)) { using (var stream = storage.OpenForRead(path)) { var document = new XmlDocument(); document.Load(stream); element = document.DocumentElement; } } return(element); }
/// <summary> /// Initializes a new instance of the <see cref="SelectionAnswerSetsControllerHelper" /> class. /// </summary> /// <param name="selectionAnswerSetService">The selection answer set service.</param> /// <param name="careElementContext">The care element context.</param> /// <param name="contentStorage">The content storage.</param> /// <param name="globalSearchCacheHelper">The global search cache helper.</param> /// <param name="tagsSearchCacheHelper">The tags search cache helper.</param> /// <param name="tagsService">The tags service.</param> /// <param name="mediaFileHelper">The audio file helper.</param> public SelectionAnswerSetsControllerHelper( ISelectionAnswerSetService selectionAnswerSetService, ICareElementContext careElementContext, IContentStorage contentStorage, IGlobalSearchCacheHelper globalSearchCacheHelper, ITagsSearchCacheHelper tagsSearchCacheHelper, ITagsService tagsService, IMediaFileHelper mediaFileHelper ) { this.selectionAnswerSetService = selectionAnswerSetService; this.careElementContext = careElementContext; this.contentStorage = contentStorage; this.globalSearchCacheHelper = globalSearchCacheHelper; this.tagsSearchCacheHelper = tagsSearchCacheHelper; this.tagsService = tagsService; this.mediaFileHelper = mediaFileHelper; }
public virtual void Start( IContentStorage contentStorage = null, IProfileStorage profileStorage = null, ILog log = null) { if (contentStorage == null) { contentStorage = new ContentFileStorage(); } if (profileStorage == null) { profileStorage = new ProfileFileStorage(contentStorage); } var context = new GameContext(); this.Context = context; context.Log = log ?? new ConsoleLogger(); context.ContentStorage = contentStorage; context.ProfileStorage = profileStorage; context.Settings = new GameSettings(contentStorage, log); context.ColorManager = new ColorManager(); context.LocaleManager = new LocaleManager(this.Context.Settings.DefaultLocale); context.TypeManager = new TypeManager(contentStorage); // Load resource collection ResourceCollection.LoadResources(context); context.RoomManager = new RoomManager(context); var worldManager = new WorldManager(context.Settings.LoginWorldName, context.Settings.StartWorldName); this.RegisterWorlds(worldManager, context); context.WorldManager = worldManager; context.ActionableItemManager = new ActionableObjectManager(); profileStorage.Init(context); this.StopEvent = new ManualResetEventSlim(false); this.thread = new Thread(RunGame); this.thread.Start(this); }
public async Task InvokeAsync( HttpContext context, IContentStorage contentStore, JsonService jsonService) { RestContentItem input = await jsonService.Deserialize <RestContentItem>(context.Request.Body); ContentItem model = input.ToModel(); await contentStore.UpdateAsync(model); ResourceCreated result = new ResourceCreated() { Id = input.Id }; string json = jsonService.Serialize(result); await context.Response.WriteAsync(json); }
public async Task InvokeAsync( HttpContext context, IContentStorage contentStore, ISchemaStorage schemaStorage, JsonService jsonService) { Guid contentId = Guid.Parse((string)context.GetRouteValue("id")); string schema = (string)context.GetRouteValue("schema"); ContentItem result = await contentStore.GetContentItemAsync(schema, contentId); ContentSchema schemaModel = await schemaStorage.GetContentSchemaAsync(schema); result.ApplySchema(schemaModel); RestContentItem restModel = result.ToRest(); string json = jsonService.Serialize(restModel); await context.Response.WriteAsync(json); }
private void LoadRoomsFromMapFolder( IContentStorage storage, string folder, IGameContext context, bool inDesign, object syncObject, IList <RoomData> dataToProcess) { var files = storage.GetFiles(folder); if ((files != null) && (files.Count > 0)) { Parallel.For( 0, files.Count, index => { var path = storage.CombinePath(folder, files[index]); LoadRoomsFromMapFile(storage, path, syncObject, context, inDesign, dataToProcess); }); } }
/// <summary> /// Initializes a new instance of the <see cref="GameSettingsData" /> class. /// </summary> public GameSettings(IContentStorage storage, ILog log, string filename = DefaultSettingsFilename) { if (!storage.IsFileExist(filename)) { // TODO: Write error. Settings file does not exist return; } var rootElement = storage.LoadXml(filename); this.DefaultLocale = rootElement.GetChildElementText(LocaleElementName); this.HeartBeat = rootElement.GetChildElementValue <int>(HeartBeatElementName, 500); this.LineSpace = Math.Max(1, rootElement.GetChildElementValue <int>(LineSpaceElementName, 1)); this.LoginWorldName = rootElement.GetChildElementText(LoginWorldElementName); this.StartWorldName = rootElement.GetChildElementText(StartWorldElementName); this.PlayerProfileFolder = DefaultPlayerProfileFolder; this.PlayerDataFolder = DefaultPlayerDataFolder; this.MapDataFolder = DefaultMapDataFolder; this.MapDesignFolder = DefaultMapDesignFolder; this.WorldDataFolder = DefaultWorldDataFolder; this.SetFolders(rootElement.SelectSingleNode(FolderRootElementName) as XmlElement, log); this.LoadWorldConfigurations(rootElement.SelectSingleNode(WorldRootElementName) as XmlElement, log); }
public FileController(ILogger logger, CloudStorageConfiguration storageConfiguration, IContentStorage contentStorage) : base(logger) { _storageConfiguration = storageConfiguration; _contentStorage = contentStorage; }
public static XmlElement LoadXml(this IContentStorage storage, string folder, string file) { var path = string.IsNullOrEmpty(folder) ? file : storage.CombinePath(folder, file); return(storage.LoadXml(path)); }
public ContentCacheLoader(IContentStorage storage, IWebLoader webLoader) { Storage = storage; WebLoader = webLoader; }
/// <summary> /// Initializes a new instance of the <see cref="TypeManager" /> class. /// </summary> /// <param name="storage">content storage</param> /// <param name="typeFilename">type XML file path</param> public TypeManager(IContentStorage storage, string typeFilename = DefaultTypeFilename) : this(storage.LoadXml(typeFilename)) { }
public QuestionAdminService(IUnitOfWork unitOfWork, IAnswerAdminService answerAdminService, IContentStorage contentStorage) : base(unitOfWork) { _answerAdminService = answerAdminService; _contentStorage = contentStorage; }
private void LoadRoomsFromMapFile( IContentStorage storage, string path, object syncObject, IGameContext context, bool inDesign, IList <RoomData> dataToProcess) { XmlElement rootElement = storage.LoadXml(path); string areaName = rootElement.GetAttribute(AreaNameAttributeName); if (string.IsNullOrWhiteSpace(areaName)) { // TODO: write log. area name is required return; } Area area; lock (syncObject) { if (!this.areas.TryGetValue(areaName, out area)) { area = new Area(areaName); this.areas.Add(areaName, area); } } foreach (XmlElement roomElement in rootElement.SelectNodes(RoomElementName)) { string roomName = roomElement.GetAttribute(RoomNameAttributeName); if (string.IsNullOrWhiteSpace(roomName)) { // TODO: write error. room name is required continue; } roomName = roomName.Trim(); IRoom room = null; var typeElement = roomElement.SelectSingleNode(TypeElementName) as XmlElement; if (typeElement != null) { room = RuntimeUtility.CreateInstance <IRoom>(typeElement, context.TypeManager, context.Log); } if (room == null) { room = new Room(); } var fullName = GetRoomFullName(areaName, roomName); var roomData = new RoomData { Name = roomName, Area = area, InDesign = inDesign, Data = roomElement }; lock (syncObject) { if (area.Rooms.ContainsKey(roomName)) { // TODO: write error } else { area.Rooms.Add(roomName, room); rooms.Add(fullName, room); dataToProcess.Add(roomData); } } } }
public static async Task UnpublishAsync <TContentType>(this IContentStorage storage, Guid id) where TContentType : class { }
/// <summary> /// Public constructor used for dependency injection /// </summary> /// <param name="storage"></param> public ParserProvider(IContentStorage storage) { _storage = storage; }
public CloudAttachmentProvider(IContentStorage storage, AzureStorageConfiguration configuration) : base(storage, configuration) { }
public DbStoryRunner(IContentProvider contentProvider, IContentStorage contentStorage, ISourceControl versioning) { this.contentProvider = contentProvider; this.contentStorage = contentStorage; this.versioning = versioning; }
public EntitiesStorage(IContentStorage contentStorage) { this._contentStorage = contentStorage; }
public CloudTokenProvider(IContentStorage contentStorage, AzureStorageConfiguration storageConfiguration) : base(contentStorage, storageConfiguration) { }
/// <summary> /// Initializes a new instance of the <see cref="MediaFileHelper" /> class. /// </summary> /// <param name="contentStorage">The content storage.</param> /// <param name="tagsService">The tags service.</param> public MediaFileHelper(IContentStorage contentStorage, ITagsService tagsService) { this.contentStorage = contentStorage; this.tagsService = tagsService; }
public AzureCloudStorageIntegrationTest() { _contentStorage = new AzureCloudStorage(_cloudStorageConnectionString); }
public static async Task UpdateAsync <TContentType>(this IContentStorage storage, TContentType entity) where TContentType : class { }
/// <summary> /// Default constructor /// </summary> public RssProvider() { _httpClient = new HttpClient(); var kernel = NinjectWebCommon.Kernel; _contentStorage = kernel.Get<IContentStorage>(); // direct ise of dependency injection }