public IAtomicCommandWithTarget SetTarget(DatabaseEntity target)
{
var configuration = target as AggregateConfiguration;
if (configuration != null)
{
_aggregateConfiguration = configuration;
}
var cohort = target as ExtractableCohort;
if (cohort != null)
{
_cohort = cohort;
}
var project = target as Project;
if (project != null)
{
_projectSpecific = project;
}
return(this);
}
public DatabaseExecuteDeleteHistoryAction(MultiRowDbTableEditorViewModel viewModel,
DatabaseEntity entity)
{
this.viewModel = viewModel;
this.entity = entity;
actualKey = entity.GenerateKey(viewModel.TableDefinition);
}
public DatabaseCellViewModel(DatabaseRowViewModel parent,
DatabaseEntity parentEntity,
IDatabaseField tableField,
IParameterValue parameterValue,
IObservable <bool>?cellIsVisible)
{
Link(tableField, tf => tf.IsModified, () => IsModified);
ParentEntity = parentEntity;
Parent = parent;
TableField = tableField;
ParameterValue = parameterValue;
if (cellIsVisible != null)
{
AutoDispose(cellIsVisible.Subscribe(v =>
{
IsVisible = v;
RaisePropertyChanged(nameof(IsVisible));
}));
}
AutoDispose(parameterValue.ToObservable().SubscribeAction(_ =>
{
if (!inConstructor)
{
parent.AnyFieldModified();
}
OriginalValueTooltip =
tableField.IsModified ? "Original value: " + parameterValue.OriginalString : null;
RaisePropertyChanged(nameof(OriginalValueTooltip));
RaisePropertyChanged(nameof(AsBoolValue));
}));
inConstructor = false;
}
public List <Ubicacion> getAllUbicacionesDisponibles(int publicacion)
{
DatabaseEntity dbEntity = new DatabaseEntity();
List <List <Object> > listaDeListas = dbEntity.Get("Ubicaciones", new List <SqlParameter>
{
new SqlParameter("@publicacion_codigo", publicacion)
});
List <Ubicacion> ubicaciones = new List <Ubicacion>();
listaDeListas.ForEach(lista =>
{
Ubicacion ubicacion = new Ubicacion();
ubicacion.id = (int)lista[0];
ubicacion.publicacion = (int)lista[1];
Tipo_Ubicacion tipo = new Tipo_Ubicacion((int)lista[2], (string)lista[3]);
ubicacion.tipo = tipo;
ubicacion.sinNumerar = (bool)lista[4];
ubicacion.filas = (int)lista[5];
ubicacion.asientos = (int)lista[6];
ubicacion.precio = Convert.ToDouble(lista[7]);
ubicacion.ocupados = (int)lista[8];
ubicaciones.Add(ubicacion);
});
return(ubicaciones);
}
private bool objectSaverButton1OnBeforeSave(DatabaseEntity databaseEntity)
{
if (_namesMatchedWhenDialogWasLaunched)
{
var cataItem = ExtractionInformation.CatalogueItem;
try
{
if (!cataItem.Name.Equals(ExtractionInformation.GetRuntimeName()))
{
//which now has a different name (usually alias)
if (
Activator.YesNo(
$"Rename CatalogueItem {cataItem.Name} to match the new Alias? ({ExtractionInformation.GetRuntimeName()})",
"Update CatalogueItem name?"))
{
cataItem.Name = ExtractionInformation.GetRuntimeName();
cataItem.SaveToDatabase();
}
}
}
catch (RuntimeNameException)
{
// there was a problem working out the runtime name. Maybe it is missing an alias or whatever
// so we can't do this rename - no big deal
}
}
return(true);
}
public IQuery GenerateDeleteQuery(DatabaseTableDefinitionJson table, DatabaseEntity entity)
{
return(Queries
.Table(table.TableName)
.Where(r => r.Column <uint>(table.TablePrimaryKeyColumnName) == entity.Key)
.Delete());
}
public void saveRol(Rol rol)
{
DatabaseEntity dbEntity = new DatabaseEntity();
int rol_nuevo_id = dbEntity.spExecuteScalar("ESECUELE.SaveRol", new List <SqlParameter>
{
new SqlParameter("@rol_nombre_nuevo", rol.Nombre)
});
DataTable dt = new DataTable("Nuevo_rol");
dt.Columns.Add("frol_rol_id", typeof(int));
dt.Columns.Add("frol_func_id", typeof(int));
foreach (Funcionalidad funcionalidad in rol.GetFuncionalidades())
{
dt.Rows.Add(rol_nuevo_id, funcionalidad.GetId());
}
var sqlParam = new SqlParameter("@func_nuevo_rol", SqlDbType.Structured);
sqlParam.Value = dt;
dbEntity.spExecute("ESECUELE.SaveRolFuncionalidades", new List <SqlParameter> {
sqlParam
});
}
public DatabaseEntityConditionsChangedHistoryAction(DatabaseEntity entity,
IReadOnlyList <ICondition>?oldConditions, IReadOnlyList <ICondition>?newConditions)
{
this.entity = entity;
this.oldConditions = oldConditions;
this.newConditions = newConditions;
}
bool objectSaverButton1_BeforeSave(DatabaseEntity arg)
{
File.WriteAllText(_processTask.Path, _scintilla.Text);
_scintilla.SetSavePoint();
return(true);
}
public DatabaseCellViewModel(int columnIndex, DatabaseColumnJson columnDefinition, DatabaseEntityViewModel parent, DatabaseEntity parentEntity, IDatabaseField tableField, IParameterValue parameterValue)
{
ColumnIndex = columnIndex * 2;
CanBeNull = columnDefinition.CanBeNull;
IsReadOnly = columnDefinition.IsReadOnly;
ColumnName = columnDefinition.Name;
ParentEntity = parentEntity;
Parent = parent;
TableField = tableField;
ParameterValue = parameterValue;
if (UseItemPicker)
{
AutoDispose(ParameterValue.ToObservable().Subscribe(_ => RaisePropertyChanged(nameof(OptionValue))));
}
if (UseFlagsPicker)
{
AutoDispose(ParameterValue.ToObservable().Subscribe(_ => RaisePropertyChanged(nameof(AsLongValue))));
}
AutoDispose(parameterValue.ToObservable().SubscribeAction(_ =>
{
OriginalValueTooltip =
tableField.IsModified ? "Original value: " + parameterValue.OriginalString : null;
RaisePropertyChanged(nameof(OriginalValueTooltip));
RaisePropertyChanged(nameof(AsBoolValue));
}));
}
public void SaveReportSettings(DatabaseEntity <ReportSettings> reportSettingsEntity)
{
using (var client = new CouchDbClient(_couchDbSettings, _logger))
{
client.SaveReportSettings(reportSettingsEntity);
}
}
public DatabaseEntityRemovedHistoryAction(DatabaseEntity entity, int index,
ViewModelBase viewModel)
{
this.entity = entity;
this.index = index;
this.viewModel = viewModel;
}
public void SaveScreenshot(DatabaseEntity <TestScreenshot> testScreenshotEntity)
{
using (var client = new CouchDbClient(_couchDbSettings, _logger))
{
client.SaveScreenshot(testScreenshotEntity);
}
}
public static string BuildInsertStatement(this DatabaseEntity dbEntity)
{
var type = dbEntity.GetType();
if (InsertStatementCache.TryGetValue(dbEntity.GetType(), out var statement))
{
return(statement);
}
var sqlBuilder = new StringBuilder($"INSERT INTO {dbEntity.GetTableName()} (");
var valuesBuilder = new StringBuilder();
foreach (var property in type.GetProperties())
{
var propertyName = property.Name;
sqlBuilder.Append($"{propertyName},");
valuesBuilder.Append($"@{propertyName},");
}
sqlBuilder.Length--;
valuesBuilder.Length--;
var builtStatement = sqlBuilder.Append($") VALUES ({valuesBuilder});").ToString();
InsertStatementCache.Add(type, builtStatement);
return(builtStatement);
}
public static DatabaseEntity <Run> Map(this RunDto runDto)
{
var id = $"run_{runDto.RunInfo.Guid}";
var run = new Run
{
Name = runDto.Name,
RunInfo = runDto.RunInfo.MapRunInfo(id),
RunSummary = runDto.RunSummary.Map(),
Sprint = runDto.Sprint,
TestRuns = runDto.TestsInfo.Select(ti => new ItemInfo
{
Guid = ti.Guid,
Start = ti.Start,
Finish = ti.Finish
}).ToList()
};
var entity = new DatabaseEntity <Run>
{
Data = run,
Id = id,
Type = EntityType.RunType
};
return(entity);
}
protected async Task EditParameter(IParameterValue parameterValue, DatabaseEntity entity)
{
if (!parameterValue.BaseParameter.HasItems)
{
return;
}
if (parameterValue is IParameterValue <long> valueHolder)
{
var result = await parameterPickerService.PickParameter <long>(valueHolder.Parameter, valueHolder.Value, entity);
if (result.ok)
{
valueHolder.Value = result.value;
}
}
else if (parameterValue is IParameterValue <string> stringValueHolder)
{
var result = await parameterPickerService.PickParameter <string>(stringValueHolder.Parameter, stringValueHolder.Value ?? "", entity);
if (result.ok)
{
stringValueHolder.Value = result.value;
}
}
}
public void SaveRun(DatabaseEntity <Run> runEntity)
{
using (var client = new CouchDbClient(_couchDbSettings, _logger))
{
client.SaveRun(runEntity);
}
}
public IAtomicCommandWithTarget SetTarget(DatabaseEntity target)
{
_catalogue = (Catalogue)target;
//must have both of these things to be DQEd
if (_catalogue.TimeCoverage_ExtractionInformation_ID == null)
{
SetImpossible("Catalogue does not have a Time Coverage column set");
return(this);
}
if (string.IsNullOrWhiteSpace(_catalogue.ValidatorXML))
{
SetImpossible("Catalogue does not have any validation rules configured");
return(this);
}
var dqeServer = Activator.ServerDefaults.GetDefaultFor(PermissableDefaults.DQE);
if (dqeServer == null)
{
SetImpossible("There is no DQE server");
return(this);
}
if (!ServerHasAtLeastOneEvaluation(_catalogue))
{
SetImpossible("DQE has never been run for Catalogue");
}
return(this);
}
public DatabaseEntityRemovedByIndexHistoryAction(DatabaseEntity entity, int index, ViewModelBase viewModel)
{
this.entity = entity;
this.index = index;
this.viewModel = viewModel;
actualKey = entity.GenerateKey(viewModel.TableDefinition);
}
private SearchEntity CreateSearchEntity(SearchSpecification search, DatabaseEntity database)
{
var queryId = Guid.NewGuid();
var searchEntity = new SearchEntity(queryId);
searchEntity.Name = search.Name;
searchEntity.JobId = queryId.ToString();
searchEntity.InputContainer = "job-" + queryId.ToString();
searchEntity.OutputContainer = "job-" + queryId.ToString();
searchEntity.DatabaseId = search.DatabaseName;
searchEntity.DatabaseType = database.Type;
searchEntity.DatabaseContainer = database.ContainerName;
searchEntity.Executable = search.Executable;
searchEntity.ExecutableArgs = search.ExecutableArgs;
searchEntity.ExecutableArgsSanitised = search.ExecutableArgs;
searchEntity.State = SearchState.StagingData;
searchEntity.StartTime = DateTime.UtcNow;
searchEntity.PoolId = search.PoolId;
searchEntity.PoolDisplayName = search.PoolDisplayName;
searchEntity.TargetDedicated = search.TargetDedicated;
searchEntity.VirtualMachineSize = search.VirtualMachineSize;
searchEntity.CompletedTasks = 0;
searchEntity.TotalTasks = search.SearchInputFiles.Count();
ParseExecutableArgs(search, searchEntity);
_tableStorageProvider.InsertEntity(searchEntity);
return(searchEntity);
}
public virtual void SetDatabaseObject(IActivateItems activator, T databaseObject)
{
SetItemActivator(activator);
Activator.RefreshBus.EstablishSelfDestructProtocol(this, activator, databaseObject);
DatabaseObject = databaseObject;
CommonFunctionality.ClearToolStrip();
if (_colorIndicator == null && AssociatedCollection != RDMPCollection.None)
{
var colorProvider = new BackColorProvider();
_colorIndicator = new Control();
_colorIndicator.Dock = DockStyle.Top;
_colorIndicator.Location = new Point(0, 0);
_colorIndicator.Size = new Size(150, BackColorProvider.IndiciatorBarSuggestedHeight);
_colorIndicator.TabIndex = 0;
_colorIndicator.BackColor = colorProvider.GetColor(AssociatedCollection);
this.Controls.Add(this._colorIndicator);
}
if (_binder == null)
{
_binder = new BinderWithErrorProviderFactory(activator);
}
SetBindings(_binder, databaseObject);
if (this is ISaveableUI)
{
ObjectSaverButton1.SetupFor(this, databaseObject, activator);
}
}
/// <summary>
/// GenerateFileName
/// </summary>
/// <param name="entity"></param>
/// <param name="component"></param>
/// <returns></returns>
public string GenerateFileName(DatabaseEntity entity, GeneratorComponent component)
{
if (FormAspNetMvcCoreTemplateConfiguration.Instance.ValidateForm(false))
{
AspNetMvcCoreGenerator generator = new AspNetMvcCoreGenerator(Settings, entity);
switch (component.Id)
{
case (int)eAspNetMvcCoreTemplateComponent.MODEL: { return(generator.ModelClassName + _defaultCsExtension); }
case (int)eAspNetMvcCoreTemplateComponent.CONTROLLER: { return(generator.ControllerClassName + _defaultCsExtension); }
case (int)eAspNetMvcCoreTemplateComponent.VIEW_CREATE: { return(Settings[AspNetMvcCoreConstants.CREATE_VIEWNAME].Value + _defaultCshtmlExtension); }
case (int)eAspNetMvcCoreTemplateComponent.VIEW_DELETE: { return(Settings[AspNetMvcCoreConstants.DELETE_VIEWNAME].Value + _defaultCshtmlExtension); }
case (int)eAspNetMvcCoreTemplateComponent.VIEW_DETAILS: { return(Settings[AspNetMvcCoreConstants.DETAILS_VIEWNAME].Value + _defaultCshtmlExtension); }
case (int)eAspNetMvcCoreTemplateComponent.VIEW_EDIT: { return(Settings[AspNetMvcCoreConstants.EDIT_VIEWNAME].Value + _defaultCshtmlExtension); }
case (int)eAspNetMvcCoreTemplateComponent.VIEW_INDEX: { return(Settings[AspNetMvcCoreConstants.INDEX_VIEWNAME].Value + _defaultCshtmlExtension); }
}
}
return(string.Empty);
}
/// <summary>
/// Generate
/// </summary>
/// <param name="entity"></param>
/// <param name="component"></param>
/// <returns></returns>
public string Generate(DatabaseEntity entity, GeneratorComponent component)
{
if (FormAspNetMvcCoreTemplateConfiguration.Instance.ValidateForm())
{
AspNetMvcCoreGenerator generator = new AspNetMvcCoreGenerator(Settings, entity);
switch (component.Id)
{
case (int)eAspNetMvcCoreTemplateComponent.MODEL: { return(generator.GenerateCodeModel()); }
case (int)eAspNetMvcCoreTemplateComponent.CONTROLLER: { return(generator.GenerateCodeController()); }
case (int)eAspNetMvcCoreTemplateComponent.VIEW_CREATE: { return(generator.GenerateViewCreate()); }
case (int)eAspNetMvcCoreTemplateComponent.VIEW_DELETE: { return(generator.GenerateViewDelete()); }
case (int)eAspNetMvcCoreTemplateComponent.VIEW_DETAILS: { return(generator.GenerateViewDetails()); }
case (int)eAspNetMvcCoreTemplateComponent.VIEW_EDIT: { return(generator.GenerateViewEdit()); }
case (int)eAspNetMvcCoreTemplateComponent.VIEW_INDEX: { return(generator.GenerateViewIndex()); }
}
}
return(string.Empty);
}
public static async Task <SymsManifestContent> ToDataAsync(CdmManifestDefinition instance, ResolveOptions resOpt, CopyOptions options,
bool isDeltaSync = false, IList <TableEntity> existingSymsTables = null, IList <RelationshipEntity> existingSymsRelationships = null)
{
var source = CreateDataSource(instance);
if (source == null)
{
return(null);
}
var properties = CreateDatabasePropertyBags(instance, resOpt, options);
Dictionary <string, TableEntity> existingTableEntities = null;
List <string> removedSymsTable = null;
if (existingSymsTables != null && existingSymsTables.Count > 0)
{
// convert to dictionary for better searching
existingTableEntities = existingSymsTables.ToDictionary(x => x.Name, x => x);
removedSymsTable = existingSymsTables.Select(x => x.Name).Except(instance.Entities.Select(x => x.EntityName)).ToList();
}
var addedOrModifiedSymsTables = await CreateSymsTablesObjects(instance, resOpt, options, source.Location, existingTableEntities);
// TODO : Submanifest
Dictionary <string, RelationshipEntity> existingRelationshipEntities = null;
List <string> removedSymsRelationships = null;
if (existingSymsRelationships != null && existingSymsRelationships.Count > 0)
{
existingRelationshipEntities = existingSymsRelationships.ToDictionary(x => x.Name, x => x);
removedSymsRelationships = existingSymsRelationships.Select(x => x.Name).Except(instance.Relationships.Select(x => x.Name)).ToList();
}
var addedOrModifiedSymsRelationships = CreateRelationships(instance, existingRelationshipEntities, resOpt, options);
DatabaseProperties dbProperties = new DatabaseProperties
{
Description = instance.Explanation != null ? instance.Explanation : $"{instance.ManifestName} syms database",
Source = source,
Properties = properties
};
var databaseEntity = new DatabaseEntity
{
Name = instance.ManifestName,
Properties = dbProperties,
Type = SASEntityType.DATABASE
};
return(new SymsManifestContent
{
Database = databaseEntity,
Entities = addedOrModifiedSymsTables,
Relationships = addedOrModifiedSymsRelationships,
InitialSync = !isDeltaSync,
RemovedEntities = removedSymsTable,
RemovedRelationships = removedSymsRelationships
});
}
public object?Evaluate(DatabaseEntity entity)
{
lexer.Reset();
tokens.Reset();
parser.Reset();
visitor.SetContext(entity);
return(visitor.Visit(parser.expr()));
}
private IDatabaseProvider GetDatabaseProvider(DatabaseEntity db)
{
if (db != null && db.DedicatedContainer)
{
return(new BlobBackedDatabaseProvider(_blobStorageProvider, db.ContainerName, true));
}
return(_blobBackedDatabaseProvider);
}
public void CanMapADatabaseEntityToADomainObject()
{
var databaseEntity = new DatabaseEntity();
var entity = databaseEntity.ToDomain();
databaseEntity.Id.Should().Be(entity.Id);
databaseEntity.CreatedAt.Should().BeSameDateAs(entity.CreatedAt);
}
public ExecuteCommandShowRelatedObject(IActivateItems activator, ReferenceOtherObjectDatabaseEntity node) : base(activator)
{
_toShow = (DatabaseEntity)node.GetReferencedObject(Activator.RepositoryLocator);
if (_toShow == null)
{
SetImpossible("Reference is an orphan");
}
}
public void CanBeCreatedFromDatabaseEntity()
{
var databaseEntity = new DatabaseEntity();
var entity = databaseEntity.ToDomain();
databaseEntity.Id.Should().Be(entity.Id);
databaseEntity.CreatedAt.Should().BeSameDateAs(entity.CreatedAt);
}
public void SaveScreenshot(DatabaseEntity <TestScreenshot> screenshotEntity)
{
var settingsContent = _contentBuilder.GetContent(screenshotEntity);
var postResult = _client.Put($"/{_ghprDatabaseName}/{screenshotEntity.Id}?new_edits?=false", settingsContent);
_messageProcessor.ProcessScreenshotSavedMessage(postResult, screenshotEntity.Data.TestGuid.ToString(), screenshotEntity.Data.TestScreenshotInfo.Date);
_logger.Debug($"Screenshot was saved: {JsonConvert.SerializeObject(screenshotEntity, Formatting.Indented)}");
}
