public void SynchConnections(IChangeSet changeSet, string token)
{
if (Initialise())
{
var dsConnectionChangeSet = changeSet as ChangeSet <long, DataServiceConnection>;
var sbConnectionChangeSet = _dbConnectionRecordType.GetNewChangeSet() as ChangeSet <long, DbConnection>;
var settings = new ProcessChangeSetSettings(token);
var itemRef = 1L;
foreach (DataServiceConnection dsConnection in dsConnectionChangeSet.Create.Values)
{
var sbConnection = new DbConnection
{
ExternalId = dsConnection.Id,
Name = dsConnection.Name,
DatabaseType = dsConnection.DatabaseType,
DataSource = dsConnection.DataSource,
InitialCatalog = dsConnection.InitialCatalog,
Username = dsConnection.Username,
Password = dsConnection.Password,
UseIntegratedSecurity = dsConnection.UseIntegratedSecurity,
ConnectionString = dsConnection.ConnectionString
};
sbConnectionChangeSet.AddCreate(itemRef, sbConnection, Enumerable.Empty <long>(), Enumerable.Empty <long>());
itemRef++;
}
_dbConnectionRecordType.ProcessChangeSet(_sbDataService, sbConnectionChangeSet, settings);
}
}
private ContractTrackingReference CreateContractTrackingReference(long contractId, Guid itemReference,
ContractTrackingState state = ContractTrackingState.ActionsPending,
ContractStatus contractStatus = ContractStatus.AvailableForApproval)
{
var contract = FluentContract
.Create()
.ApplyDefaults()
.ContractStatus(contractStatus)
.Save(this);
var trackingReference = new ContractTrackingReference()
{
ContractId = contract.Id, ItemReference = itemReference.ToString(), State = state
};
var roleIds = Enumerable.Empty <long>();
var changeSet = base.contractTrackingReferenceRecordType.GetNewChangeSet() as ChangeSet <long, ContractTrackingReference>;
var changeSetSettings = new ProcessChangeSetSettings(username: MrAdmin.Name);
var itemRef = 1L;
changeSet.AddCreate(itemRef, trackingReference, roleIds, roleIds);
var processResult = contractTrackingReferenceRecordType.ProcessChangeSet(PreliminaryContractDataService, changeSet, changeSetSettings);
return(processResult.SuccessfullyCreatedItems[processResult.SuccessfullyCreated[itemRef]] as ContractTrackingReference);
}
private void ProcessFile(object sender, FileSystemEventArgs e)
{
try
{
if (File.Exists(e.FullPath))
{
var reader = new ContractReader(e.FullPath);
var contracts = reader.Read();
var settings = new ProcessChangeSetSettings(_dshs.SystemToken, "", true);
var changeSet = _recordType.GetNewChangeSet() as ChangeSet <long, Domain.ProvisionalContract>;
var id = 0L;
foreach (var contract in contracts)
{
changeSet.AddCreate(id++, contract, Enumerable.Empty <long>(), Enumerable.Empty <long>());
}
var results = _recordType.ProcessChangeSet(_dataService, changeSet, settings);
if (!Directory.Exists(_successPath))
{
Directory.CreateDirectory(_successPath);
}
if (File.Exists(Path.Combine(_successPath, e.Name)))
{
File.Delete(Path.Combine(_successPath, e.Name));
}
File.Move(e.FullPath, Path.Combine(_successPath, e.Name));
}
}
catch (Exception ex)
{
if (!Directory.Exists(_failurePath))
{
Directory.CreateDirectory(_failurePath);
}
if (File.Exists(Path.Combine(_failurePath, e.Name)))
{
File.Delete(Path.Combine(_failurePath, e.Name));
}
File.Move(e.FullPath, Path.Combine(_failurePath, e.Name));
}
}
private List <ActionTrackingReference> CreateActionTrackingReferences(ContractTrackingReference contract,
ActionTrackingState state = ActionTrackingState.Pending)
{
var roleIds = Enumerable.Empty <long>();
var changeSet = base.actionTrackingReferenceRecordType.GetNewChangeSet() as ChangeSet <long, ActionTrackingReference>;
var changeSetSettings = new ProcessChangeSetSettings(username: MrAdmin.Name);
for (var itemRef = 1L; itemRef <= 3; itemRef++)
{
var action = new ActionTrackingReference()
{
ItemReference = contract.ItemReference, ActionKey = ActionKeyHelpers.BuildKey(contract.ItemReference, itemRef, itemRef * 10), ActionReference = Guid.NewGuid().ToString(), State = state
};
changeSet.AddCreate(itemRef, action, roleIds, roleIds);
}
var processResult = actionTrackingReferenceRecordType.ProcessChangeSet(PreliminaryContractDataService, changeSet, changeSetSettings);
return(processResult
.SuccessfullyCreatedItems
.Values
.Select(i => i as ActionTrackingReference)
.ToList());
}
public virtual ChangeSetResult <long> ProcessChangeSet(IDataService dataService, ChangeSet <long, T_record> changeSet, ProcessChangeSetSettings settings)
{
var result = new ChangeSetResult <long>();
foreach (var deletion in changeSet.Delete)
{
_repository.Delete <T_record>(deletion);
result.SuccessfullyDeleted.Add(deletion);
}
var validator = new T_validator();
foreach (var update in changeSet.Update)
{
var validationResult = validator.Validate(update.Value);
if (validationResult.IsValid)
{
try
{
_repository.Update <T_record>(update.Value);
result.SuccessfullyUpdated.Add(update.Key);
result.SuccessfullyUpdatedItems.Add(update.Key, update.Value);
}
catch (Exception ex)
{
result.FailedUpdates.Add(update.Key, new MessageSet(ex.Message));
}
}
else
{
var modelValidation = new ModelValidation();
validationResult.Errors.ToList().ForEach(x =>
{
if (string.IsNullOrWhiteSpace(x.PropertyName))
{
modelValidation.ModelValidations.Add(x.ErrorMessage);
}
else
{
modelValidation.PropertyValidations.Add(x.PropertyName, x.ErrorMessage);
}
});
result.FailedUpdates.Add(update.Key, modelValidation);
}
}
foreach (var create in changeSet.Create)
{
var validationResult = validator.Validate(create.Value);
if (validationResult.IsValid)
{
try
{
var created = _repository.Create <T_record>(create.Value);
result.SuccessfullyCreated.Add(create.Key, created.Id);
result.SuccessfullyCreatedItems.Add(created.Id, created);
}
catch (Exception ex)
{
result.FailedCreates.Add(create.Key, new MessageSet(ex.Message));
}
}
else
{
var modelValidation = new ModelValidation();
validationResult.Errors.ToList().ForEach(x =>
{
if (string.IsNullOrWhiteSpace(x.PropertyName))
{
modelValidation.ModelValidations.Add(x.ErrorMessage);
}
else
{
modelValidation.PropertyValidations.Add(x.PropertyName, x.ErrorMessage);
}
});
result.FailedCreates.Add(create.Key, modelValidation);
}
}
dataService.NotifyOfExternalChangesToData();
return(result);
}
public ChangeSetResult <long> ProcessChangeSet(IDataService dataService, string token, string username, ChangeSet <long, T_record> changeSet, bool persistChanges)
{
var settings = new ProcessChangeSetSettings(token, username, persistChanges);
return(ProcessChangeSet(dataService, changeSet, settings));
}
public ChangeSetResult <long> ProcessChangeSet(IDataService dataService, ChangeSet <long, DbConnection> changeSet, ProcessChangeSetSettings settings)
{
var result = new ChangeSetResult <long>();
foreach (var deletion in changeSet.Delete)
{
_repository.Delete <DbConnection>(deletion);
result.SuccessfullyDeleted.Add(deletion);
}
var validator = new DbConnectionValidator(_repository);
foreach (var update in changeSet.Update)
{
var validationResult = validator.Validate(update.Value);
if (validationResult.IsValid)
{
try
{
update.Value.Status = DbConnectionStatus.ValidationPending;
update.Value.StatusMessage = string.Empty;
_repository.Update(update.Value);
result.SuccessfullyUpdated.Add(update.Key);
result.SuccessfullyUpdatedItems.Add(update.Key, update.Value);
}
catch (Exception ex)
{
result.FailedUpdates.Add(update.Key, new MessageSet(ex.Message));
}
}
else
{
var modelValidation = new ModelValidation();
validationResult.Errors.ToList().ForEach(x =>
{
if (string.IsNullOrWhiteSpace(x.PropertyName))
{
modelValidation.ModelValidations.Add(x.ErrorMessage);
}
else
{
modelValidation.PropertyValidations.Add(x.PropertyName, x.ErrorMessage);
}
});
result.FailedUpdates.Add(update.Key, modelValidation);
}
}
foreach (var create in changeSet.Create)
{
var validationResult = validator.Validate(create.Value);
if (validationResult.IsValid)
{
try
{
create.Value.Status = DbConnectionStatus.ValidationPending;
create.Value.StatusMessage = string.Empty;
var created = _repository.Create(create.Value);
result.SuccessfullyCreated.Add(create.Key, created.Id);
result.SuccessfullyCreatedItems.Add(created.Id, created);
}
catch (Exception ex)
{
result.FailedCreates.Add(create.Key, new MessageSet(ex.Message));
}
}
else
{
var modelValidation = new ModelValidation();
validationResult.Errors.ToList().ForEach(x =>
{
if (string.IsNullOrWhiteSpace(x.PropertyName))
{
modelValidation.ModelValidations.Add(x.ErrorMessage);
}
else
{
modelValidation.PropertyValidations.Add(x.PropertyName, x.ErrorMessage);
}
});
result.FailedCreates.Add(create.Key, modelValidation);
}
}
dataService.NotifyOfExternalChangesToData(new DataChangeEvent(dataService.DataServiceName, typeof(DbConnection).Name));
PostProcessChangeSet(dataService, result);
return(result);
}
