private void SignalHandler()
{
this._taskScheduler.ThrowIfNotOnThread();
TsMediaStreamSource.Operation operation1 = TsMediaStreamSource.Operation.None;
TsMediaStreamSource.Operation operation2 = TsMediaStreamSource.Operation.None;
try
{
if (this._isClosed)
{
this.ForceClose();
}
else
{
bool flag;
do
{
if (TsMediaStreamSource.Operation.None == this.HandleOperation(TsMediaStreamSource.Operation.Seek))
{
if (TsMediaStreamSource.SourceState.Play == this.State)
{
operation1 = this.HandleOperation(TsMediaStreamSource.Operation.Audio | TsMediaStreamSource.Operation.Video);
operation2 |= operation1;
if (TsMediaStreamSource.Operation.None != operation2)
{
TsMediaStreamSource.Operation operation3 = this._streamOpenFlags;
bool canCallReportBufferingProgress = operation3 == (operation2 & operation3);
flag = false;
if (TsMediaStreamSource.Operation.None != (operation2 & TsMediaStreamSource.Operation.Video) && null != this.VideoStreamSource && this.SendStreamSample(this.VideoStreamSource, this._videoStreamDescription, canCallReportBufferingProgress))
{
operation2 &= ~TsMediaStreamSource.Operation.Video;
flag = true;
}
if (TsMediaStreamSource.Operation.None != (operation2 & TsMediaStreamSource.Operation.Audio) && null != this.AudioStreamSource && this.SendStreamSample(this.AudioStreamSource, this._audioStreamDescription, canCallReportBufferingProgress))
{
operation2 &= ~TsMediaStreamSource.Operation.Audio;
flag = true;
}
}
else
{
goto label_3;
}
}
else
{
goto label_8;
}
}
else
{
goto label_4;
}
}while (flag);
goto label_20;
label_4:
if (TsMediaStreamSource.Operation.None != operation1)
{
operation2 |= operation1;
}
Task task = this.SeekHandler();
TaskCollector.Default.Add(task, "TsMediaStreamSource.SignalHandler SeekHandler()");
return;
label_8:
return;
label_3:
return;
label_20 :;
}
}
catch (Exception ex)
{
Debug.WriteLine("TsMediaStreamSource.SignalHandler() failed: " + ExceptionExtensions.ExtendedMessage(ex));
}
finally
{
if (TsMediaStreamSource.Operation.None != operation2)
{
Debug.WriteLine("TsMediaStreamSource.SignalHandler() re-requesting " + (object)operation2);
this.RequestOperation(operation2);
}
}
}
/// <summary>
/// Rename Folder
/// </summary>
/// <param name="label">new Name of Folder</param>
/// <returns>VSConstants.S_OK, if succeeded</returns>
public override int SetEditLabel(string label)
{
if (this.IsBeingCreated)
{
return(FinishFolderAdd(label, false));
}
else
{
if (StringComparer.Ordinal.Equals(CommonUtils.GetFileOrDirectoryName(this.Url), label))
{
// Label matches current Name
return(VSConstants.S_OK);
}
var newPath = CommonUtils.GetAbsoluteDirectoryPath(CommonUtils.GetParent(this.Url), label);
// Verify that No Directory/file already exists with the new name among current children
var existingChild = this.Parent.FindImmediateChildByName(label);
if (existingChild != null && existingChild != this)
{
return(ShowFileOrFolderAlreadyExistsErrorMessage(newPath));
}
// Verify that No Directory/file already exists with the new name on disk.
// Unless the path exists because it is the path to the source file also.
if ((Directory.Exists(newPath) || File.Exists(newPath)) && !CommonUtils.IsSamePath(this.Url, newPath))
{
return(ShowFileOrFolderAlreadyExistsErrorMessage(newPath));
}
if (!this.ProjectMgr.Tracker.CanRenameItem(this.Url, newPath, VSRENAMEFILEFLAGS.VSRENAMEFILEFLAGS_Directory))
{
return(VSConstants.S_OK);
}
}
try
{
var oldTriggerFlag = this.ProjectMgr.EventTriggeringFlag;
this.ProjectMgr.EventTriggeringFlag |= ProjectNode.EventTriggering.DoNotTriggerTrackerQueryEvents;
try
{
RenameFolder(label);
}
finally
{
this.ProjectMgr.EventTriggeringFlag = oldTriggerFlag;
}
//Refresh the properties in the properties window
var shell = this.ProjectMgr.GetService(typeof(SVsUIShell)) as IVsUIShell;
Utilities.CheckNotNull(shell, "Could not get the UI shell from the project");
ErrorHandler.ThrowOnFailure(shell.RefreshPropertyBrowser(0));
// Notify the listeners that the name of this folder is changed. This will
// also force a refresh of the SolutionExplorer's node.
this.ProjectMgr.OnPropertyChanged(this, (int)__VSHPROPID.VSHPROPID_Caption, 0);
}
catch (Exception ex) when(!ExceptionExtensions.IsCriticalException(ex))
{
throw new InvalidOperationException(SR.GetString(SR.RenameFolder, ex.Message));
}
return(VSConstants.S_OK);
}
/// <summary>
/// Registers the <see cref="Type"/> of the Exceptions
/// that are not considered root exceptions by the <see cref="ExceptionExtensions"/>.
/// </summary>
protected virtual void RegisterFrameworkExceptionTypes()
{
ExceptionExtensions.RegisterFrameworkExceptionType(typeof(ActivationException));
}
void IVsProjectUpgradeViaFactory4.UpgradeProject_CheckOnly(
string bstrFileName,
IVsUpgradeLogger pLogger,
out uint pUpgradeRequired,
out Guid pguidNewProjectFactory,
out uint pUpgradeProjectCapabilityFlags
)
{
pguidNewProjectFactory = Guid.Empty;
if (!File.Exists(bstrFileName))
{
pUpgradeRequired = 0;
pUpgradeProjectCapabilityFlags = 0;
return;
}
var backupSupport = __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED |
__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP |
__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_SXSBACKUP;
var logger = new UpgradeLogger(bstrFileName, pLogger);
try
{
var projectXml = ProjectRootElement.Open(bstrFileName);
var userProjectName = bstrFileName + ".user";
var userProjectXml = File.Exists(userProjectName) ? ProjectRootElement.Open(userProjectName) : null;
var upgradeRequired = UpgradeProjectCheck(
projectXml,
userProjectXml,
logger.Log,
ref pguidNewProjectFactory,
ref backupSupport
);
switch (upgradeRequired)
{
case ProjectUpgradeState.SafeRepair:
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_SAFEREPAIR;
break;
case ProjectUpgradeState.UnsafeRepair:
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_UNSAFEREPAIR;
break;
case ProjectUpgradeState.OneWayUpgrade:
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_ONEWAYUPGRADE;
break;
case ProjectUpgradeState.Incompatible:
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_INCOMPATIBLE;
break;
case ProjectUpgradeState.Deprecated:
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_DEPRECATED;
break;
default:
case ProjectUpgradeState.NotNeeded:
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
break;
}
}
catch (Exception ex) when(!ExceptionExtensions.IsCriticalException(ex))
{
// Log the error and don't attempt to upgrade the project.
logger.Log(__VSUL_ERRORLEVEL.VSUL_ERROR, SR.GetString(SR.UnexpectedUpgradeError, ex.Message));
try
{
ActivityLog.LogError(GetType().FullName, ex.ToString());
}
catch (InvalidOperationException)
{
// Cannot log to ActivityLog. This may occur if we are
// outside of VS right now (for example, unit tests).
System.Diagnostics.Trace.TraceError(ex.ToString());
}
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
}
pUpgradeProjectCapabilityFlags = (uint)backupSupport;
// If the upgrade checker set the factory GUID to ourselves, we need
// to clear it
if (pguidNewProjectFactory == GetType().GUID)
{
pguidNewProjectFactory = Guid.Empty;
}
}
/// <summary>
/// Registers in the <see cref="IContainer"/> the <see cref="Type"/> of the Exceptions
/// that are not considered root exceptions by the <see cref="ExceptionExtensions"/>.
/// </summary>
protected override void RegisterFrameworkExceptionTypes()
{
base.RegisterFrameworkExceptionTypes();
ExceptionExtensions.RegisterFrameworkExceptionType(typeof(DependencyResolutionException));
}
int IVsProjectUpgradeViaFactory.UpgradeProject(
string bstrFileName,
uint fUpgradeFlag,
string bstrCopyLocation,
out string pbstrUpgradedFullyQualifiedFileName,
IVsUpgradeLogger pLogger,
out int pUpgradeRequired,
out Guid pguidNewProjectFactory
)
{
pbstrUpgradedFullyQualifiedFileName = null;
// We first run (or re-run) the upgrade check and bail out early if
// there is actually no need to upgrade.
var hr = ((IVsProjectUpgradeViaFactory)this).UpgradeProject_CheckOnly(
bstrFileName,
pLogger,
out pUpgradeRequired,
out pguidNewProjectFactory,
out var dummy
);
if (!ErrorHandler.Succeeded(hr))
{
return(hr);
}
var logger = new UpgradeLogger(bstrFileName, pLogger);
var backup = (__VSPPROJECTUPGRADEVIAFACTORYFLAGS)fUpgradeFlag;
bool anyBackup, sxsBackup, copyBackup;
anyBackup = backup.HasFlag(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED);
if (anyBackup)
{
sxsBackup = backup.HasFlag(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_SXSBACKUP);
copyBackup = !sxsBackup && backup.HasFlag(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP);
}
else
{
sxsBackup = copyBackup = false;
}
if (copyBackup)
{
throw new NotSupportedException("PUVFF_COPYBACKUP is not supported");
}
pbstrUpgradedFullyQualifiedFileName = bstrFileName;
if (pUpgradeRequired == 0 && !copyBackup)
{
// No upgrade required, and no backup required.
logger.Log(__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, SR.GetString(SR.UpgradeNotRequired));
return(VSConstants.S_OK);
}
try
{
UpgradeLogger logger2 = null;
var userFileName = bstrFileName + ".user";
if (File.Exists(userFileName))
{
logger2 = new UpgradeLogger(userFileName, pLogger);
}
else
{
userFileName = null;
}
if (sxsBackup)
{
// For SxS backups we want to put the old project file alongside
// the current one.
bstrCopyLocation = Path.GetDirectoryName(bstrFileName);
}
if (anyBackup)
{
var namePart = Path.GetFileNameWithoutExtension(bstrFileName);
var extPart = Path.GetExtension(bstrFileName) + (sxsBackup ? ".old" : "");
var projectFileBackup = Path.Combine(bstrCopyLocation, namePart + extPart);
for (var i = 1; File.Exists(projectFileBackup); ++i)
{
projectFileBackup = Path.Combine(
bstrCopyLocation,
string.Format("{0}{1}{2}", namePart, i, extPart)
);
}
File.Copy(bstrFileName, projectFileBackup);
// Back up the .user file if there is one
if (userFileName != null)
{
if (sxsBackup)
{
File.Copy(
userFileName,
Path.ChangeExtension(projectFileBackup, ".user.old")
);
}
else
{
File.Copy(userFileName, projectFileBackup + ".old");
}
}
// TODO: Implement support for backing up all files
//if (copyBackup) {
// - Open the project
// - Inspect all Items
// - Copy those items that are referenced relative to the
// project file into bstrCopyLocation
//}
}
var queryEdit = this.site.GetService(typeof(SVsQueryEditQuerySave)) as IVsQueryEditQuerySave2;
if (queryEdit != null)
{
var tagVSQueryEditFlags_QEF_AllowUnopenedProjects = (tagVSQueryEditFlags)0x80;
ErrorHandler.ThrowOnFailure(queryEdit.QueryEditFiles(
(uint)(tagVSQueryEditFlags.QEF_ForceEdit_NoPrompting |
tagVSQueryEditFlags.QEF_DisallowInMemoryEdits |
tagVSQueryEditFlags_QEF_AllowUnopenedProjects),
1,
new[] { bstrFileName },
null,
null,
out var editVerdict,
out var queryEditMoreInfo
));
if (editVerdict != (uint)tagVSQueryEditResult.QER_EditOK)
{
logger.Log(__VSUL_ERRORLEVEL.VSUL_ERROR, SR.GetString(SR.UpgradeCannotCheckOutProject));
return(VSConstants.E_FAIL);
}
// File may have been updated during checkout, so check
// again whether we need to upgrade.
if ((queryEditMoreInfo & (uint)tagVSQueryEditResultFlags.QER_MaybeChanged) != 0)
{
hr = ((IVsProjectUpgradeViaFactory)this).UpgradeProject_CheckOnly(
bstrFileName,
pLogger,
out pUpgradeRequired,
out pguidNewProjectFactory,
out dummy
);
if (!ErrorHandler.Succeeded(hr))
{
return(hr);
}
if (pUpgradeRequired == 0)
{
logger.Log(__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, SR.GetString(SR.UpgradeNotRequired));
return(VSConstants.S_OK);
}
}
}
// Load the project file and user file into MSBuild as plain
// XML to make it easier for subclasses.
var projectXml = ProjectRootElement.Open(bstrFileName);
if (projectXml == null)
{
throw new Exception(SR.GetString(SR.UpgradeCannotLoadProject));
}
var userXml = userFileName != null?ProjectRootElement.Open(userFileName) : null;
// Invoke our virtual UpgradeProject function. If it fails, it
// will throw and we will log the exception.
UpgradeProject(ref projectXml, ref userXml, logger.Log);
// Get the SCC info from the project file.
if (projectXml != null)
{
this._cachedSccProject = bstrFileName;
this._cachedSccProjectName = string.Empty;
this._cachedSccAuxPath = string.Empty;
this._cachedSccLocalPath = string.Empty;
this._cachedSccProvider = string.Empty;
foreach (var property in projectXml.Properties)
{
switch (property.Name)
{
case ProjectFileConstants.SccProjectName:
this._cachedSccProjectName = property.Value;
break;
case ProjectFileConstants.SccAuxPath:
this._cachedSccAuxPath = property.Value;
break;
case ProjectFileConstants.SccLocalPath:
this._cachedSccLocalPath = property.Value;
break;
case ProjectFileConstants.SccProvider:
this._cachedSccProvider = property.Value;
break;
default:
break;
}
}
}
// Save the updated files.
if (projectXml != null)
{
projectXml.Save();
}
if (userXml != null)
{
userXml.Save();
}
// Need to add "Converted" (unlocalized) to the report because
// the XSLT refers to it.
logger.Log(__VSUL_ERRORLEVEL.VSUL_STATUSMSG, "Converted");
return(VSConstants.S_OK);
}
catch (Exception ex) when(!ExceptionExtensions.IsCriticalException(ex))
{
logger.Log(__VSUL_ERRORLEVEL.VSUL_ERROR, SR.GetString(SR.UnexpectedUpgradeError, ex.Message));
try
{
ActivityLog.LogError(GetType().FullName, ex.ToString());
}
catch (InvalidOperationException)
{
// Cannot log to ActivityLog. This may occur if we are
// outside of VS right now (for example, unit tests).
System.Diagnostics.Trace.TraceError(ex.ToString());
}
return(VSConstants.E_FAIL);
}
}
int IVsProjectUpgradeViaFactory.UpgradeProject_CheckOnly(
string bstrFileName,
IVsUpgradeLogger pLogger,
out int pUpgradeRequired,
out Guid pguidNewProjectFactory,
out uint pUpgradeProjectCapabilityFlags
)
{
pUpgradeRequired = 0;
pguidNewProjectFactory = Guid.Empty;
if (!File.Exists(bstrFileName))
{
pUpgradeProjectCapabilityFlags = 0;
return(VSConstants.E_INVALIDARG);
}
var backupSupport = __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED |
__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP |
__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_SXSBACKUP;
var logger = new UpgradeLogger(bstrFileName, pLogger);
try
{
var projectXml = ProjectRootElement.Open(bstrFileName);
var userProjectName = bstrFileName + ".user";
var userProjectXml = File.Exists(userProjectName) ? ProjectRootElement.Open(userProjectName) : null;
var upgradeRequired = UpgradeProjectCheck(
projectXml,
userProjectXml,
logger.Log,
ref pguidNewProjectFactory,
ref backupSupport
);
if (upgradeRequired != ProjectUpgradeState.NotNeeded)
{
pUpgradeRequired = 1;
}
}
catch (Exception ex) when(!ExceptionExtensions.IsCriticalException(ex))
{
// Log the error and don't attempt to upgrade the project.
logger.Log(__VSUL_ERRORLEVEL.VSUL_ERROR, SR.GetString(SR.UnexpectedUpgradeError, ex.Message));
try
{
ActivityLog.LogError(GetType().FullName, ex.ToString());
}
catch (InvalidOperationException)
{
// Cannot log to ActivityLog. This may occur if we are
// outside of VS right now (for example, unit tests).
System.Diagnostics.Trace.TraceError(ex.ToString());
}
pUpgradeRequired = 0;
}
pUpgradeProjectCapabilityFlags = (uint)backupSupport;
// If the upgrade checker set the factory GUID to ourselves, we need
// to clear it
if (pguidNewProjectFactory == GetType().GUID)
{
pguidNewProjectFactory = Guid.Empty;
}
return(VSConstants.S_OK);
}
protected override void RegisterFrameworkExceptionTypes()
{
base.RegisterFrameworkExceptionTypes();
ExceptionExtensions.RegisterFrameworkExceptionType(typeof(ContainerException));
}
public async Task <ResponseModel <List <CreateTrainingModel> > > Handle(CreateTrainingCommand request, CancellationToken cancellationToken)
{
var redisKey = $"TrainingsByTenantId{request.TenantId}";
var newTrainings = new List <Training>();
var createdTrainings = new List <CreateTrainingModel>();
using (var transaction = await _context.Database.BeginTransactionAsync(cancellationToken))
{
try
{
foreach (var createTrainingModel in request.CreateTrainingModels)
{
var newTraining = new Training
{
CreatedBy = request.CreatedBy,
TrainingSeriesId = createTrainingModel.TrainingSeriesId,
Name = createTrainingModel.Name,
Description = createTrainingModel.Description,
BeginDateTime = createTrainingModel.BeginDateTime,
EndDateTime = createTrainingModel.EndDateTime,
TrainingCategoryId = createTrainingModel.TrainingCategoryId
};
newTrainings.Add(newTraining);
}
if (newTrainings.Count > 20)
{
_context.BulkInsert(newTrainings);
}
else
{
await _context.Trainings.AddRangeAsync(newTrainings, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
}
transaction.Commit();
await _cacheService.RedisCacheUpdateAsync(redisKey,
_ => _context.Trainings
.AsNoTracking()
.ToListAsync(cancellationToken),
cancellationToken);
newTrainings.ForEach(x =>
createdTrainings.Add(new CreateTrainingModel(x.Id, x.TrainingSeriesId, x.TrainingCategoryId, x.Name, x.Description, x.CreatedBy, x.CreatedAt, x.BeginDateTime, x.EndDateTime)));
}
catch (DbUpdateException ex) when((ex.InnerException is SqlException sqlException && (sqlException.Number == 2627 || sqlException.Number == 2601)) ||
(ex.InnerException is SqliteException sqliteException && sqliteException.SqliteErrorCode == 19))
{
transaction.Rollback();
throw new ObjectAlreadyExistsException(nameof(Training), ExceptionExtensions.GetExceptionMessage(ex));
}
catch (Exception)
{
transaction.Rollback();
throw new TransactionException();
}
}
return(new ResponseModel <List <CreateTrainingModel> >(createdTrainings));
}
public void ExceptionInformationLogging()
{
ExceptionExtensions.LogInformation("SmallBusinessTrackingTests.ExceptionInformationLogging", "Logging information test");
}
public override void ProcessMessage(object sender, MessageEventArgs args)
{
bool handled = false;
try
{
FacebookDataComponent dc = new FacebookDataComponent();
string msg = Encoding.UTF8.GetString(args.Message.BodyStream.ToByteArray());
Page page = Utility.DeserializeXMLString <Page>(msg);
if (!Object.Equals(page, null))
{
dc.FBPage = page;
handled = true;
FireMessageProcessingEvent();
QueueComponentDataSource.Process(dc);
FireMessageProcessedEvent();
}
else
{
Demographic <Country> ctry = Utility.DeserializeXMLString <Demographic <Country> >(msg);
if (!Object.Equals(ctry, null))
{
dc.CountryDemographic = ctry;
handled = true;
FireMessageProcessingEvent();
QueueComponentDataSource.Process(dc);
FireMessageProcessedEvent();
}
else
{
Demographic <Locale> lcl = Utility.DeserializeXMLString <Demographic <Locale> >(msg);
if (!Object.Equals(lcl, null))
{
dc.LocaleDemographic = lcl;
handled = true;
FireMessageProcessingEvent();
QueueComponentDataSource.Process(dc);
FireMessageProcessedEvent();
}
else
{
Demographic <Gender> gndr = Utility.DeserializeXMLString <Demographic <Gender> >(msg);
if (!Object.Equals(gndr, null))
{
dc.GenderDemographic = gndr;
handled = true;
FireMessageProcessingEvent();
QueueComponentDataSource.Process(dc);
FireMessageProcessedEvent();
}
}
}
}
}
catch (Exception e)
{
ExceptionExtensions.LogError(e, "QueueFacebook.ProcessMessage");
if (Utility.IsCriticalDBError(e))
{
FireShuttingDownEvent();
}
if (handled)
{
FireMessageProcessedEvent();
}
}
}
public async Task <ResponseModel <List <UpdateTraineeGroupModel> > > Handle(UpdateTraineeGroupCommand request, CancellationToken cancellationToken)
{
var redisKey = $"TraineeGroupsByTenantId{request.TenantId}";
var updateTraineeGroups = new List <TraineeGroup>();
var updatedTraineeGroups = new List <UpdateTraineeGroupModel>();
var redisTraineeGroups = await _cacheService.RedisCacheAsync(redisKey,
_ => _context.TraineeGroups
.AsNoTracking()
.Where(x => x.TenantId == request.TenantId)
.ToList()
, cancellationToken);
using (var transaction = await _context.Database.BeginTransactionAsync(cancellationToken))
{
try
{
foreach (var updateTraineeGroupModel in request.UpdateTraineeGroupCommandModels)
{
var traineeGroup = redisTraineeGroups.FirstOrDefault(x => x.Id == updateTraineeGroupModel.Id);
if (traineeGroup != null)
{
throw new TransactionException();
}
var updateTraineeGroup = new TraineeGroup
{
TenantId = request.TenantId,
UpdatedBy = request.UpdatedBy,
Name = updateTraineeGroupModel.Name
};
updateTraineeGroups.Add(updateTraineeGroup);
}
if (updateTraineeGroups.Count > 20)
{
_context.BulkUpdate(updateTraineeGroups);
}
else
{
await _context.TraineeGroups.AddRangeAsync(updateTraineeGroups, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
}
transaction.Commit();
await _cacheService.RedisCacheUpdateAsync(redisKey,
_ => _context.TraineeGroups
.AsNoTracking()
.ToListAsync(cancellationToken),
cancellationToken);
updateTraineeGroups.ForEach(x => updatedTraineeGroups.Add(new UpdateTraineeGroupModel(x.Id,
x.Name,
x.UpdatedBy,
x.UpdatedAt
)));
}
catch (DbUpdateException ex) when((ex.InnerException is SqlException sqlException && (sqlException.Number == 2627 || sqlException.Number == 2601)) ||
(ex.InnerException is SqliteException sqliteException && sqliteException.SqliteErrorCode == 19))
{
transaction.Rollback();
throw new ObjectAlreadyExistsException(nameof(TraineeGroup), ExceptionExtensions.GetExceptionMessage(ex));
}
catch (NotFoundException)
{
transaction.Rollback();
throw;
}
catch (Exception)
{
transaction.Rollback();
throw new TransactionException();
}
}
return(new ResponseModel <List <UpdateTraineeGroupModel> >(updatedTraineeGroups));
}
protected override void RegisterFrameworkExceptionTypes()
{
base.RegisterFrameworkExceptionTypes();
ExceptionExtensions.RegisterFrameworkExceptionType(typeof(AutofacCore.DependencyResolutionException));
ExceptionExtensions.RegisterFrameworkExceptionType(typeof(AutofacCore.Registration.ComponentNotRegisteredException));
}
internal virtual HttpWebRequest CreateRequest(Uri url, Uri referrer, IWebReader parent, ContentType contentType, string method = null, bool allowBuffering = false, long?fromBytes = null, long?toBytes = null)
{
referrer = referrer ?? HttpWebRequestWebReaderManager.GetReferrer(parent);
if ((Uri)null == url && null != parent)
{
url = parent.RequestUri ?? parent.BaseAddress;
}
if ((Uri)null != referrer && ((Uri)null == url || !url.IsAbsoluteUri))
{
url = new Uri(referrer, url);
}
HttpWebRequest webRequest = this._httpWebRequests.CreateWebRequest(url, referrer, method, contentType, allowBuffering, fromBytes, toBytes);
if (null != this._webReaderManagerParameters.DefaultHeaders)
{
foreach (KeyValuePair <string, string> keyValuePair in this._webReaderManagerParameters.DefaultHeaders)
{
try
{
webRequest.Headers[keyValuePair.Key] = keyValuePair.Value;
}
catch (ArgumentException ex)
{
Debug.WriteLine("HttpWebRequestWebReaderManager.CreateRequest({0}) header {1}={2} failed: {3}", (object)url, (object)keyValuePair.Key, (object)keyValuePair.Value, (object)ExceptionExtensions.ExtendedMessage((Exception)ex));
}
}
}
return(webRequest);
}
