public void FindMissingColumn() { var table = new DocumentTable("Entities"); table.Register(new Column("Number", typeof(int))); schema.Add(table); configuration.Document <Entity>(); var commands = migrator.CalculateSchemaChanges(schema, configuration).Cast <RemoveColumn>().ToList(); commands[0].Table.ShouldBe(GetTableFor <Entity>()); commands[0].Name.ShouldBe("Number"); }
public List <ApplicationUser> GetSignUsers(DocumentTable docuTable) { List <ApplicationUser> signUsers = new List <ApplicationUser>(); if (docuTable != null) { IEnumerable <WFTrackerTable> trackerTables = _WorkflowTrackerService.GetCurrentStep(x => x.DocumentTableId == docuTable.Id && x.SignUserId == null); foreach (var trackerTable in trackerTables) { if (trackerTable.Users != null) { foreach (var trackUser in trackerTable.Users) { signUsers.Add(_AccountService.Find(trackUser.UserId)); } } } List <ApplicationUser> delegationUserCheck = signUsers.ToList(); foreach (var user in delegationUserCheck) { var delegationItems = _DelegationService.GetPartial(x => x.EmplTableTo.ApplicationUserId == user.Id && x.DateFrom <= DateTime.UtcNow && x.DateTo >= DateTime.UtcNow && x.isArchive == false && x.CompanyTableId == user.CompanyTableId); foreach (var delegationItem in delegationItems) { if (delegationItem.GroupProcessTableId != null || delegationItem.ProcessTableId != null) { if (delegationItem.ProcessTableId == docuTable.ProcessTableId) { signUsers.Add(_AccountService.Find(delegationItem.EmplTableFrom.ApplicationUserId)); } else if (_ProcessService.Find(docuTable.ProcessTableId).GroupProcessTableId == delegationItem.GroupProcessTableId) { signUsers.Add(_AccountService.Find(delegationItem.EmplTableFrom.ApplicationUserId)); } } else { signUsers.Add(_AccountService.Find(delegationItem.EmplTableFrom.ApplicationUserId)); } } } } return(signUsers); }
public void can_spot_an_extra_index() { theMapping.Index(x => x.UserName); writeTable(); theMapping.Index(x => x.FirstName); var table = new DocumentTable(theMapping); var delta = table.FetchDelta(_conn); delta.IndexChanges.Count.ShouldBe(1); delta.IndexRollbacks.Count.ShouldBe(1); }
public void write_ddl_in_create_if_not_exists_mode() { var users = DocumentMapping.For <User>(); var table = new DocumentTable(users); var rules = new DdlRules { TableCreation = CreationStyle.CreateIfNotExists }; var ddl = table.ToDDL(rules); ddl.ShouldNotContain("DROP TABLE IF EXISTS public.mt_doc_user CASCADE;"); ddl.ShouldContain("CREATE TABLE IF NOT EXISTS public.mt_doc_user"); }
public DocumentSchema(DocumentMapping mapping) { _mapping = mapping; Table = new DocumentTable(_mapping); Upsert = new UpsertFunction(_mapping); Insert = new InsertFunction(_mapping); Update = new UpdateFunction(_mapping); if (_mapping.UseOptimisticConcurrency) { Overwrite = new OverwriteFunction(_mapping); } }
public void write_ddl_in_default_drop_then_create_mode() { var users = DocumentMapping.For <User>(); var table = new DocumentTable(users); var rules = new DdlRules { TableCreation = CreationStyle.DropThenCreate }; var ddl = table.ToDDL(rules); ddl.ShouldContain("DROP TABLE IF EXISTS public.mt_doc_user CASCADE;"); ddl.ShouldContain("CREATE TABLE public.mt_doc_user"); }
public void not_matching_with_columns_of_same_name_that_are_different() { var users = DocumentMapping.For <User>(); var actual = new DocumentTable(users); var expected = new DocumentTable(users); actual.ReplaceOrAddColumn("id", "int"); var diff = new TableDelta(expected, actual); diff.Matches.ShouldBeFalse(); diff.Different.Single().Name.ShouldBe("id"); }
public void do_not_drop_unchanged_index() { StoreOptions(_ => { _.AutoCreateSchemaObjects = AutoCreate.CreateOrUpdate; _.Advanced.DdlRules.TableCreation = CreationStyle.CreateIfNotExists; _.Schema.For <Bug1043.Thing>().Index(x => x.Name, x => { x.IndexName = "Test_Index"; x.IsUnique = true; x.Casing = ComputedIndex.Casings.Lower; x.IsConcurrent = true; }); }); using (var session = theStore.OpenSession()) { session.Insert(new Bug1043.Thing { Id = "test/1", Name = "A Thing", Count = 1 }); session.SaveChanges(); } var mapping = DocumentMapping.For <Bug1043.Thing>(); mapping.DatabaseSchemaName = SchemaName; mapping.Index(x => x.Name, x => { x.IndexName = "Test_Index"; x.IsUnique = true; x.Casing = ComputedIndex.Casings.Lower; x.IsConcurrent = true; }); var docTable = new DocumentTable(mapping); using (var connection = new Npgsql.NpgsqlConnection(ConnectionSource.ConnectionString)) { connection.Open(); var diff = docTable.FetchDelta(connection); Assert.NotNull(diff); Assert.Equal(0, diff.IndexChanges.Count); Assert.Equal(0, diff.IndexRollbacks.Count); } }
//[Fact] -- unreliable in CI public void can_add_same_primary_key_to_multiple_tenant() { var guid = Guid.NewGuid(); var store = DocumentStore.For(_ => { _.Connection(ConnectionSource.ConnectionString); _.Policies.AllDocumentsAreMultiTenanted(); _.Logger(new ConsoleMartenLogger()); }); store.Tenancy.Default.EnsureStorageExists(typeof(Target)); var existing = store.Tenancy.Default.DbObjects.ExistingTableFor(typeof(Target)); var mapping = store.Options.Storage.MappingFor(typeof(Target)); var expected = new DocumentTable(mapping); var delta = new TableDelta(expected, existing); delta.Matches.ShouldBeTrue(); using (var session = store.OpenSession("123")) { var target = Target.Random(); target.Id = guid; target.String = "123"; session.Store("123", target); session.SaveChanges(); } using (var session = store.OpenSession("abc")) { var target = Target.Random(); target.Id = guid; target.String = "abc"; session.Store("abc", target); session.SaveChanges(); } using (var session = store.OpenSession("123")) { var target = session.Load <Target>(guid); target.ShouldNotBeNull(); target.String.ShouldBe("123"); } using (var session = store.OpenSession("abc")) { var target = session.Load <Target>(guid); target.ShouldNotBeNull(); target.String.ShouldBe("abc"); } }
public void not_matching_with_extra_columns() { var users = DocumentMapping.For <User>(); var actual = new DocumentTable(users); var expected = new DocumentTable(users); var tableColumn = new TableColumn("new", "varchar"); actual.AddColumn(tableColumn); var diff = new TableDelta(expected, actual); diff.Matches.ShouldBeFalse(); diff.Extras.Single().ShouldBe(tableColumn); }
public void add_the_tenant_id_column_when_it_is_conjoined_tenancy() { var options = new StoreOptions(); options.Connection(ConnectionSource.ConnectionString); options.Policies.AllDocumentsAreMultiTenanted(); var mapping = new DocumentMapping(typeof(User), options); mapping.TenancyStyle = TenancyStyle.Conjoined; var table = new DocumentTable(mapping); table.Any(x => x is TenantIdColumn).ShouldBeTrue(); }
public void CanExecuteOnMultipleThreads() { UseGlobalTempTables(); UseTableNamePrefix(Guid.NewGuid().ToString()); Document <Entity>().With(x => x.Property); InitializeStore(); Parallel.For(0, 10, x => { var table = new DocumentTable("Entities"); store.Insert(table, NewId(), new { Property = "Asger", Version = 1 }); }); }
public static IEnumerable <QueryResult <T> > Query <T>( this IDocumentStore store, DocumentTable table, string @join, out QueryStats stats, bool top1 = false, string select = null, string where = "", Window window = null, string orderby = "", bool includeDeleted = false, object parameters = null) { using (var tx = store.BeginTransaction()) { var(queryStats, rows) = tx.Query <T>(table, @join, top1, @select, @where, window, @orderby, includeDeleted, parameters); tx.Complete(); stats = queryStats; return(rows); } }
public void FindMissingColumn() { var table = new DocumentTable("Entities"); table.Add(new Column <int>("Number")); schema.Add(table.Name, table.Columns.Select(x => x.Name).ToList()); configuration.Document <Entity>(); var commands = migrator.CalculateSchemaChanges(schema, configuration).Cast <RemoveColumn>().ToList(); commands[0].Table.ShouldBe(GetTableFor <Entity>()); commands[0].Name.ShouldBe("Number"); }
public List <WFTrackerUsersTable> GetUsersSLAStatus(DocumentTable docuTable, SLAStatusList status) { IEnumerable <WFTrackerTable> items = GetCurrentSignStep(docuTable.Id); List <WFTrackerUsersTable> users = new List <WFTrackerUsersTable>(); foreach (var item in items) { if (item.SLAStatus() == status) { users.AddRange(item.Users); } } return(users); }
/// <summary> /// Creates result table based on surface results. /// </summary> /// <param name="resInPtCollection">Result in point collection</param> /// <param name="resultTypes">The type of results, values and description to use in the table.</param> /// <param name="document">Revit document</param> /// <param name="elementType">Type of element</param> /// <returns>Document table containing surface results</returns> private DocumentTable CreateResultTableForSurfaceElements(List <ResultInPointSurface> resInPtCollection, IEnumerable <ResultTypeSurface> resultTypes, Autodesk.Revit.DB.Document document, ElementType elementType) { // results table data int rowsCount = 1 + resInPtCollection.Count(), colsCount = (ElementType.Wall == elementType ? 3 : 2) + resultTypes.Count(); Units units = document.GetUnits(); DocumentTable resultTable = new DocumentTable(rowsCount, colsCount); resultTable.HeaderColumnsCount = ElementType.Wall == elementType ? 3 : 2; resultTable.HeaderRowsCount = 1; // results table data List <ResultTypeSurface> typesToPresent = ElementType.Wall == elementType ? new List <ResultTypeSurface>() { ResultTypeSurface.X, ResultTypeSurface.Y, ResultTypeSurface.Z } : new List <ResultTypeSurface>() { ResultTypeSurface.X, ResultTypeSurface.Y }; typesToPresent.AddRange(resultTypes); int colId = 0; foreach (ResultTypeSurface resultType in typesToPresent) { resultTable[0, colId].Elements.Add(new DocumentText(ResultDescription(elementType, resultType))); UnitType unitType = resultType.GetUnitType(); DisplayUnitType displayUnitType = Utility.UnitsConverter.GetInternalUnit(unitType); int rowId = 1; foreach (ResultInPointSurface resultInPoint in resInPtCollection) { if (DisplayUnitType.DUT_UNDEFINED != displayUnitType) { resultTable[rowId++, colId].Elements.Add(new DocumentValue(resultInPoint[resultType], displayUnitType, unitType, units)); } else { resultTable[rowId++, colId].Elements.Add(new DocumentText(resultInPoint[resultType].ToString())); } } colId++; } return(resultTable); }
public async Task can_add_same_primary_key_to_multiple_tenant() { var guid = Guid.NewGuid(); await theStore.EnsureStorageExistsAsync(typeof(Target)); var existing = await theStore.Tenancy.Default.Database.ExistingTableFor(typeof(Target)); var mapping = theStore.Options.Storage.MappingFor(typeof(Target)); var expected = new DocumentTable(mapping); var delta = new TableDelta(expected, existing); delta.Difference.ShouldBe(SchemaPatchDifference.None); using (var session = theStore.OpenSession("123")) { var target = Target.Random(); target.Id = guid; target.String = "123"; session.ForTenant("123").Store(target); await session.SaveChangesAsync(); } using (var session = theStore.OpenSession("abc")) { var target = Target.Random(); target.Id = guid; target.String = "abc"; session.ForTenant("abc").Store(target); await session.SaveChangesAsync(); } using (var session = theStore.OpenSession("123")) { var target = session.Load <Target>(guid); target.ShouldNotBeNull(); target.String.ShouldBe("123"); } using (var session = theStore.OpenSession("abc")) { var target = session.Load <Target>(guid); target.ShouldNotBeNull(); target.String.ShouldBe("abc"); } }
private void searchable(Expression <Func <Target, object> > expression) { StoreOptions(_ => { _.Schema.For <Target>().Duplicate(expression); }); theStore.Tenancy.Default.StorageFor <Target>().ShouldNotBeNull(); var existing = theStore.TableSchema(typeof(Target)); var configured = new DocumentTable(theStore.Storage.MappingFor(typeof(Target)).As <DocumentMapping>()); var delta = new TableDelta(configured, existing); delta.Difference.ShouldBe(SchemaPatchDifference.None); }
public void FindDocument() { if (string.IsNullOrWhiteSpace(TableName)) { return; } var table = new DocumentTable(TableName); var sw = Stopwatch.StartNew(); StatusMessage = string.Format("Getting document {0} from table {1}", documentId, table.Name); Loading = true; FindDocument(table, documentId); Loading = false; StatusMessage = string.Format("Fetched document {0} in {1}ms", documentId, sw.ElapsedMilliseconds); }
public void can_add_same_primary_key_to_multiple_tenant() { var guid = Guid.NewGuid(); theStore.Tenancy.Default.EnsureStorageExists(typeof(Target)); var existing = theStore.Tenancy.Default.DbObjects.ExistingTableFor(typeof(Target)); var mapping = theStore.Options.Storage.MappingFor(typeof(Target)); var expected = new DocumentTable(mapping); var delta = new TableDelta(expected, existing); delta.Matches.ShouldBeTrue(); using (var session = theStore.OpenSession("123")) { var target = Target.Random(); target.Id = guid; target.String = "123"; session.Store("123", target); session.SaveChanges(); } using (var session = theStore.OpenSession("abc")) { var target = Target.Random(); target.Id = guid; target.String = "abc"; session.Store("abc", target); session.SaveChanges(); } using (var session = theStore.OpenSession("123")) { var target = session.Load <Target>(guid); SpecificationExtensions.ShouldNotBeNull(target); target.String.ShouldBe("123"); } using (var session = theStore.OpenSession("abc")) { var target = session.Load <Target>(guid); SpecificationExtensions.ShouldNotBeNull(target); target.String.ShouldBe("abc"); } }
public void AcceptsConcurrentWrites() { UseRealTables(); Document <Entity>().With(x => x.Number); store.Initialize(); var id = NewId(); var table = new DocumentTable("Entities"); var etag = store.Insert(table, id, new { Discriminator = typeof(Entity).AssemblyQualifiedName, Version = 0, Document = configuration.Serializer.Serialize(new Entity()) }); var gate1 = new ManualResetEvent(false); var gate2 = new ManualResetEvent(false); UseMigrations(new InlineMigration(1, new ChangeDocument <Entity>((serializer, bytes) => { gate1.Set(); Thread.Sleep(1000); return(bytes); }))); bool?failed = null; new DocumentMigrationRunner() .Run(store) .ContinueWith(x => { failed = x.IsFaulted; gate2.Set(); }); gate1.WaitOne(); store.Update(table, id, etag, new {}); gate2.WaitOne(); failed.ShouldBe(false); }
public void can_do_substitutions() { var mapping = DocumentMapping.For <User>(); mapping.Duplicate(x => x.FirstName); var table = new DocumentTable(mapping); table.BuildTemplate($"*{DdlRules.SCHEMA}*").ShouldBe($"*{table.Identifier.Schema}*"); table.BuildTemplate($"*{DdlRules.TABLENAME}*").ShouldBe($"*{table.Identifier.Name}*"); table.BuildTemplate($"*{DdlRules.COLUMNS}*") .ShouldBe($"*id, data, mt_last_modified, mt_version, mt_dotnet_type, first_name*"); table.BuildTemplate($"*{DdlRules.NON_ID_COLUMNS}*") .ShouldBe($"*data, mt_last_modified, mt_version, mt_dotnet_type, first_name*"); table.BuildTemplate($"*{DdlRules.METADATA_COLUMNS}*") .ShouldBe("*mt_last_modified, mt_version, mt_dotnet_type*"); }
public DateTime?GetSLAPerformDate(Guid DocumentId, DateTime CreatedDate, double SLAOffset) { DocumentTable documentTable = Find(DocumentId); if (documentTable != null && documentTable.ProcessTable != null) { WorkScheduleTable scheduleTable = _WorkScheduleService.Find(documentTable.ProcessTable.WorkScheduleTableId); if (scheduleTable != null) { CreatedDate = GetWorkStartDate(CreatedDate, scheduleTable); double SLAMinutes = (SLAOffset * 60); return(GetSLAAddOffset(scheduleTable, CreatedDate, SLAMinutes)); } } return(null); }
public void UtilityColsAreRemovedFromQueryResults() { Document <Entity>(); var table = new DocumentTable("Entities"); store.Insert(table, NewId(), new { Version = 1 }); var result1 = store.Query(table, out _, window: new SkipTake(0, 2)).Single(); result1.ContainsKey(new Column("RowNumber", typeof(int))).ShouldBe(false); result1.ContainsKey(new Column("TotalResults", typeof(int))).ShouldBe(false); var result2 = store.Query <object>(table, out _, window: new SkipTake(0, 2)).Single(); ((IDictionary <string, object>)result2.Data).ContainsKey("RowNumber").ShouldBe(false); ((IDictionary <string, object>)result2.Data).ContainsKey("TotalResults").ShouldBe(false); }
public static void AddTable(WordprocessingDocument doc, DocumentTable tableModel) { var body = doc.MainDocumentPart .Document.Body; var elem = body.ChildElements.FirstOrDefault(el => el.InnerText == tableModel.PlacingText); if (elem == null) { throw new ApplicationException($"Не найден элемент с внутренним текстом '{tableModel.PlacingText}', " + $"вместо которого нужно вставить таблицу."); } var table = DocTableCreator.GetTable(tableModel); elem.InsertAfterSelf(table); elem.Remove(); }
public void does_not_regenerate_the_login_table() { var existing = theStore.TableSchema(typeof(Login)); var mapping = theStore.Tenancy.Default.MappingFor(typeof(Login)); var configured = new DocumentTable(mapping.As <DocumentMapping>()); if (!existing.Equals(configured)) { var writer = new StringWriter(); writer.WriteLine("Expected:"); configured.Write(theStore.Schema.DdlRules, writer); writer.WriteLine(); writer.WriteLine("But from the database, was:"); existing.Write(theStore.Schema.DdlRules, writer); throw new Exception(writer.ToString()); } }
/// <summary> /// Presentation file data source /// </summary> /// <returns></returns> public static GroupDocs.Assembly.Data.DocumentTable PresentationData() { // Do not extract column names from the first row, so that the first row to be treated as a data row. // Limit the largest row index, so that only the first four data rows to be loaded. DocumentTableOptions options = new DocumentTableOptions(); options.MaxRowIndex = 3; // Use data of the _second_ table in the document. DocumentTable table = new DocumentTable(presentationDataFile, 1, options); // Check column count and names. Debug.Assert(table.Columns.Count == 2); // NOTE: Default column names are used, because we do not extract the names from the first row. Debug.Assert(table.Columns[0].Name == "Column1"); Debug.Assert(table.Columns[1].Name == "Column2"); return(table); }
public Guid SaveDocument(dynamic viewTable, string tableName, Guid processId, Guid fileId, string currentUserName = "") { string localUserName = getCurrentUserName(currentUserName); var docuTable = new DocumentTable(); docuTable.ProcessTableId = processId; docuTable.CreatedDate = DateTime.UtcNow; docuTable.ModifiedDate = docuTable.CreatedDate; docuTable.DocumentState = DocumentState.Created; docuTable.FileId = fileId; ApplicationUser user = _AccountService.FirstOrDefault(x => x.UserName == localUserName); docuTable.CompanyTableId = user.CompanyTableId; docuTable.ApplicationUserCreatedId = user.Id; docuTable.ApplicationUserModifiedId = user.Id; EmplTable emplTable = _EmplService.FirstOrDefault(x => x.ApplicationUserId == user.Id); docuTable.EmplTableId = emplTable.Id; Guid numberSeqId = _ProcessService.Find(processId).GroupProcessTable.NumberSeriesTableId ?? Guid.Empty; docuTable.DocumentNum = _NumberSeqService.GetDocumentNum(numberSeqId); _uow.GetRepository <DocumentTable>().Add(docuTable); _uow.Save(); var domainTable = RouteCustomModelDomain(tableName); Mapper.Map(viewTable, domainTable); domainTable.DocumentTableId = docuTable.Id; domainTable.CreatedDate = DateTime.UtcNow; domainTable.ModifiedDate = domainTable.CreatedDate; RouteCustomRepository(tableName).Add(domainTable); _uow.Save(); docuTable.RefDocumentId = domainTable.Id; _uow.GetRepository <DocumentTable>().Update(docuTable); _uow.Save(); return(docuTable.Id); }
public void FindColumnTypeChange() { var table = new DocumentTable("Entities"); table.Register(new Column("Number", typeof(int))); schema.Add(table); configuration.Document <Entity>().With("Number", x => x.String); var commands = migrator.CalculateSchemaChanges(schema, configuration).ToList(); commands[0].ShouldBeOfType <AddColumn>() .Tablename.ShouldBe(GetTableFor <Entity>().Name); ((AddColumn)commands[0]).Column.ShouldBe(GetTableFor <Entity>()["Number"]); commands[1].ShouldBeOfType <RemoveColumn>() .Table.ShouldBe(GetTableFor <Entity>()); ((RemoveColumn)commands[1]).Name.ShouldBe("Number"); }
public DocumentSchema(DocumentMapping mapping) { _mapping = mapping; Table = new DocumentTable(_mapping); foreach (var metadataColumn in Table.Columns.OfType <MetadataColumn>()) { metadataColumn.RegisterForLinqSearching(mapping); } Upsert = new UpsertFunction(_mapping); Insert = new InsertFunction(_mapping); Update = new UpdateFunction(_mapping); if (_mapping.UseOptimisticConcurrency) { Overwrite = new OverwriteFunction(_mapping); } }