public void SavePreValues(int dataTypeId, IEnumerable <string> values)
{
//TODO: Should we raise an event here since we are really saving values for the data type?
using (var uow = UowProvider.GetUnitOfWork())
{
var sortOrderObj =
uow.Database.ExecuteScalar <object>(
"SELECT max(sortorder) FROM cmsDataTypePreValues WHERE datatypeNodeId = @DataTypeId", new { DataTypeId = dataTypeId });
int sortOrder;
if (sortOrderObj == null || int.TryParse(sortOrderObj.ToString(), out sortOrder) == false)
{
sortOrder = 1;
}
foreach (var value in values)
{
var dto = new DataTypePreValueDto {
DataTypeNodeId = dataTypeId, Value = value, SortOrder = sortOrder
};
uow.Database.Insert(dto);
sortOrder++;
}
uow.Commit();
}
}
/// <summary>
/// Saves a list of PreValues for a given DataTypeDefinition
/// </summary>
/// <param name="id">Id of the DataTypeDefinition to save PreValues for</param>
/// <param name="values">List of string values to save</param>
public void SavePreValues(int id, IEnumerable <string> values)
{
using (new WriteLock(Locker))
{
using (var uow = _uowProvider.GetUnitOfWork())
{
var sortOrderObj =
uow.Database.ExecuteScalar <object>(
"SELECT max(sortorder) FROM cmsDataTypePreValues WHERE datatypeNodeId = @DataTypeId", new { DataTypeId = id });
int sortOrder;
if (sortOrderObj == null || int.TryParse(sortOrderObj.ToString(), out sortOrder) == false)
{
sortOrder = 1;
}
using (var transaction = uow.Database.GetTransaction())
{
foreach (var value in values)
{
var dto = new DataTypePreValueDto {
DataTypeNodeId = id, Value = value, SortOrder = sortOrder
};
uow.Database.Insert(dto);
sortOrder++;
}
transaction.Complete();
}
}
}
}
/// <summary>
/// Creates a PreValue for a <see cref="IDataTypeDefinition"/>
/// </summary>
/// <param name="dataTypeDefinitionId"></param>
/// <param name="value"></param>
/// <param name="sortOrder"></param>
/// <param name="alias"></param>
public static void CreatePrevalueForDataTypeDefinition(int dataTypeDefinitionId, string value, int sortOrder, string alias)
{
var poco = new DataTypePreValueDto
{
Alias = alias,
DataTypeNodeId = dataTypeDefinitionId,
SortOrder = sortOrder,
Value = value
};
ApplicationContext.Current.DatabaseContext.Database.Insert(poco);
}
public IDataType AddPreValueJson(object value, int sortOrder = 0, string alias = "")
{
var dtpv = new DataTypePreValueDto
{
Alias = alias,
Value = JsonConvert.SerializeObject(value),
DataTypeNodeId = DataTypeDefinition.Id,
SortOrder = sortOrder
};
UmbracoDatabase.Insert(dtpv);
return(this);
}
public IDataType AddPreValue(string value, int sortOrder = 0, string alias = "")
{
var dtpv = new DataTypePreValueDto
{
Alias = alias,
Value = value,
DataTypeNodeId = DataTypeDefinition.Id,
SortOrder = sortOrder
};
UmbracoDatabase.Insert(dtpv);
return(this);
}
protected override void PersistNewItem(PreValueEntity entity)
{
if (entity.DataType.HasIdentity == false)
{
throw new InvalidOperationException("Cannot insert a pre value for a data type that has no identity");
}
//NOTE: We used to check that the Alias was unique for the given DataTypeNodeId prevalues list, BUT
// in reality there is no need to check the uniqueness of this alias because the only way that this code executes is
// based on an IDictionary<string, PreValue> dictionary being passed to this repository and a dictionary
// must have unique aliases by definition, so there is no need for this additional check
var dto = new DataTypePreValueDto
{
DataTypeNodeId = entity.DataType.Id,
Value = entity.Value,
SortOrder = entity.SortOrder,
Alias = entity.Alias
};
Database.Insert(dto);
}
public void AddOrUpdatePreValues(IDataTypeDefinition dataType, IDictionary <string, PreValue> values)
{
var currentVals = new DataTypePreValueDto[] { };
if (dataType.HasIdentity)
{
//first just get all pre-values for this data type so we can compare them to see if we need to insert or update or replace
var sql = new Sql().Select("*")
.From <DataTypePreValueDto>(SqlSyntax)
.Where <DataTypePreValueDto>(dto => dto.DataTypeNodeId == dataType.Id)
.OrderBy <DataTypePreValueDto>(dto => dto.SortOrder, SqlSyntax);
currentVals = Database.Fetch <DataTypePreValueDto>(sql).ToArray();
}
//already existing, need to be updated
var valueIds = values.Where(x => x.Value.Id > 0).Select(x => x.Value.Id).ToArray();
var existingByIds = currentVals.Where(x => valueIds.Contains(x.Id)).ToArray();
//These ones need to be removed from the db, they no longer exist in the new values
var deleteById = currentVals.Where(x => valueIds.Contains(x.Id) == false);
foreach (var d in deleteById)
{
_preValRepository.Delete(new PreValueEntity
{
Alias = d.Alias,
Id = d.Id,
Value = d.Value,
DataType = dataType,
SortOrder = d.SortOrder
});
}
var sortOrder = 1;
foreach (var pre in values)
{
var existing = existingByIds.FirstOrDefault(valueDto => valueDto.Id == pre.Value.Id);
if (existing != null)
{
_preValRepository.AddOrUpdate(new PreValueEntity
{
//setting an id will update it
Id = existing.Id,
DataType = dataType,
//These are the new values to update
Alias = pre.Key,
SortOrder = sortOrder,
Value = pre.Value.Value
});
}
else
{
_preValRepository.AddOrUpdate(new PreValueEntity
{
Alias = pre.Key,
SortOrder = sortOrder,
Value = pre.Value.Value,
DataType = dataType,
});
}
sortOrder++;
}
}
