public void CancelReservation(Reservation reservation)
{
int userId = sessMan.GetUserId();
User user = Umodel.GetUserById(userId);
bool admin = user.Admin;
CancelStatus cancelStatus;
if (admin)
{
cancelStatus = CancelStatus.InTime;
}
else
{
int timeTillReservation = HowLongUntil(reservation);
cancelStatus = CancelStatusFromHours(timeTillReservation);
}
Cancellation cancellation = new Cancellation()
{
Reservation = reservation,
ByAdmin = admin,
CancelStatus = cancelStatus,
Done = admin,
CancelDate = timeManager.Now()
};
Cancellations.Add(cancellation);
Reservations.SaveChanges();
}
public void Play()
{
if (this._currentState == VoiceMessageAttachmentViewModel.State.NotStarted || this._currentState == VoiceMessageAttachmentViewModel.State.Failed)
{
this.CurrentState = VoiceMessageAttachmentViewModel.State.Downloading;
Stream stream = CacheManager.GetStreamForWrite(this._localFile);
this._currentCancellationToken = new Cancellation();
JsonWebRequest.Download(this.VideoUri, stream, delegate(bool res)
{
Execute.ExecuteOnUIThread(delegate
{
try
{
if (this._currentCancellationToken.IsSet)
{
this.CurrentState = VoiceMessageAttachmentViewModel.State.Failed;
stream.Close();
CacheManager.TryDelete(this._localFile, CacheManager.DataType.CachedData);
}
else
{
int fileSize = (int)stream.Length;
stream.Close();
if (res)
{
MediaLRUCache.Instance.AddLocalFile(this.VideoUri, this._localFile, fileSize);
this.CurrentState = VoiceMessageAttachmentViewModel.State.Downloaded;
this.CurrentState = VoiceMessageAttachmentViewModel.State.Playing;
}
else
{
this.CurrentState = VoiceMessageAttachmentViewModel.State.Failed;
CacheManager.TryDelete(this._localFile, CacheManager.DataType.CachedData);
}
}
}
catch
{
try
{
stream.Close();
}
catch
{
}
this.CurrentState = VoiceMessageAttachmentViewModel.State.Failed;
CacheManager.TryDelete(this._localFile, CacheManager.DataType.CachedData);
}
});
}, delegate(double progress)
{
this.DownloadProgress = progress;
}, this._currentCancellationToken);
return;
}
if (this._currentState == VoiceMessageAttachmentViewModel.State.Downloaded)
{
this.CurrentState = VoiceMessageAttachmentViewModel.State.Playing;
}
}
public IHttpActionResult Put(Cancellation value)
{
try
{
var data = from b in dbContext.Cancellation
where b.BookingId == value.BookingId && b.Status.Equals("New")
select b;
Cancellation old = data.SingleOrDefault();
old.Status = value.Status;
dbContext.SaveChanges();
try
{ if (value.Status == "Approved")
{
var data2 = from b2 in dbContext.Booking
where b2.BookingId == value.BookingId
select b2;
Booking old2 = data2.SingleOrDefault();
old2.Status = "Cancelled";
dbContext.SaveChanges();
return(Ok("Approved"));
}
else
{
return(Ok("Dispproved"));
} }
catch (Exception ex2) {
return(Ok("fail2" + ex2.Message));
}
}
catch (Exception ex)
{
string message = "fail " + ex.Message;
return(Ok(message));
}
}
public IActionResult Cancel(string id, [FromBody] Cancellation cancellation)
{
// Cancle can be done by anyone Employee/Superviser
if (UserDB.Find(cancellation.Resource) != null)
{
Timecard timecard = Database.Find(id);
if (timecard != null)
{
if (timecard.Status != TimecardStatus.Draft && timecard.Status != TimecardStatus.Submitted)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
var transition = new Transition(cancellation, TimecardStatus.Cancelled);
timecard.Transitions.Add(transition);
return(Ok(transition));
}
else
{
return(NotFound());
}
}
return(StatusCode(401, new InvalidUser()
{
}));
}
public ActionResult New(int?id)
{
if (!Utils.Utils.GetPermission("ORDER_ADD"))
{
return(new RedirectResult("/Main"));
}
if (id.HasValue && id.Value > 0)
{
using (DataContext _db = new DataContext())
{
Cancellation _cancellation = _db.Cancellations.Where(c => c.Id == id.Value).FirstOrDefault();
if (_cancellation != null)
{
return(View(new Cancellation()
{
Customer = Newtonsoft.Json.JsonConvert.DeserializeObject <Abonent>(_cancellation.Data).Customer,
GetDate = _cancellation.GetDate,
ReceiversCount = _cancellation.ReceiversCount,
}));
}
}
}
return(View(new Cancellation()
{
Customer = new Customer(), GetDate = DateTime.Now, ReceiversCount = 1
}));
}
public TestCommand(ICremaApplication application, TestCommandContext testCommandContext, Cancellation cancellation)
: base("test")
{
this.application = application;
this.testCommandContext = testCommandContext;
this.cancellation = cancellation;
}
private void ProcessSource(uint id)
{
var source = session.Load <WaybillSource>(id);
Cancellation.ThrowIfCancellationRequested();
_logger.DebugFormat("Попытка забрать накладные с FTP поставщика. Код поставщика = {0}", source.Id);
if (!source.IsReady)
{
_logger.DebugFormat("Пропускаю источник не истек период ожидания {0} дата последнего опроса {1}",
source.DownloadInterval,
source.LastDownload);
return;
}
foreach (var documentType in _documentTypes)
{
ReceiveDocuments(documentType, source, source.Uri(documentType));
// Удаление временных файлов
Cleanup();
}
if (!_failedSources.Contains(source.Id))
{
source.LastDownload = DateTime.Now;
}
}
public IActionResult Cancel(string id, [FromBody] Cancellation cancellation)
{
Timecard timecard = Database.Find(id);
if (timecard != null)
{
if (timecard.Status != TimecardStatus.Draft && timecard.Status != TimecardStatus.Submitted)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
//Verify that timecard resource is consistent
if (timecard.Resource != cancellation.Resource)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
var transition = new Transition(cancellation, TimecardStatus.Cancelled);
timecard.Transitions.Add(transition);
return(Ok(transition));
}
else
{
return(NotFound());
}
}
public void Cancel()
{
if (!_isDisposed)
{
Cancellation.Cancel();
}
}
private void ProcessParts(BlockingQueue <byte[]> inputBlockingQueue,
BlockingQueue <BlockingWorkItem <byte[]> > outputBlockingQueue,
Cancellation cancellation = null)
{
var threadPool = new StaticThreadPool();
new Thread(() =>
{
while (inputBlockingQueue.Dequeue(out var item))
{
if (cancellation?.IsCancelled() ?? false)
{
break;
}
var blockingWorkItem = new BlockingWorkItem <byte[]>();
outputBlockingQueue.Enqueue(blockingWorkItem);
var part = item;
threadPool.QueueJob(() =>
{
var processed = ProcessPart(part);
blockingWorkItem.SetResult(processed);
});
}
outputBlockingQueue.Complete();
}).Start();
}
public void MultipleThreadsParallelArchiver()
{
var cancellation = new Cancellation();
var finishedEvent = new AutoResetEvent(false);
UseDefaultConfiguration(defaultConfiguration =>
{
UseDifferentBufferSizes(defaultConfiguration, bufferSize =>
{
var parallelCompressor = new ParallelCompressor(
defaultConfiguration.CompressingFile,
defaultConfiguration.CompressedFile,
1 * 10,
bufferSize);
UseMeasure((stopMeasure) =>
{
parallelCompressor.Process(() => { stopMeasure(); finishedEvent.Set(); }, cancellation);
}, defaultConfiguration.CompressingFile);
finishedEvent.WaitOne();
});
var parallelDecompressor = new ParallelDecompressor(
defaultConfiguration.DecompressingFile,
defaultConfiguration.DecompressedFile);
Console.WriteLine();
UseMeasure((stopMeasure) =>
{
parallelDecompressor.Process(() => { stopMeasure(); finishedEvent.Set(); }, cancellation);
}, defaultConfiguration.DecompressingFile);
finishedEvent.WaitOne();
CompareMd5(defaultConfiguration.CompressingFile, defaultConfiguration.DecompressedFile);
});
}
/// <summary>
/// Stops the running application
/// </summary>
/// <returns></returns>
public async Task StopAsync()
{
Cancellation.Cancel();
await Startup.ShutdownAsync();
Running = false;
}
public void SendCancellationEmails(Reservation res, User user, Cancellation cxl)
{
IList <User> admins = UModel.GetAllAdmins();
if (cxl.ByAdmin)
{
emailManager.SendReservationCancellationByAdminEmail(user, res);
}
else
{
switch (cxl.CancelStatus)
{
case CancelStatus.FourtyEightHours:
emailManager.SendReservationCancellationClient48Email(user, res);
foreach (var admin in admins)
{
emailManager.SendReservationCancellationAdmin48Email(admin, user, res);
}
break;
case CancelStatus.OneHour:
emailManager.SendReservationCancellationClient1Email(user, res);
foreach (var admin in admins)
{
emailManager.SendReservationCancellationAdmin1Email(admin, user, res);
}
break;
case CancelStatus.InTime:
emailManager.SendReservationCancellationClientEmail(user, res);
break;
}
}
}
private void StartDownload(string localDirectory)
{
Debug.Assert(localDirectory != null);
if (_scp == null || _scpExecuting)
{
return;
}
Debug.Assert(_scpThread == null || !_scpThread.IsAlive);
string remotePath;
if (!TryGetRemotePath(out remotePath))
{
return;
}
bool recursive = this.checkRecursive.Checked;
bool preseveTime = this.checkPreserveTime.Checked;
_fileTransferCancellation = new Cancellation();
ChangeExecutingState(true);
_scpThread = new Thread((ThreadStart)
delegate() {
DownloadThread(localDirectory, remotePath, recursive, preseveTime);
ChangeExecutingState(false);
_fileTransferCancellation = null;
});
_scpThread.Start();
}
public JsonResult ChangeComment(string ids, string comment)
{
using (DataContext _db = new DataContext())
{
using (DbContextTransaction tran = _db.Database.BeginTransaction(IsolationLevel.Snapshot))
{
try
{
int user_id = ((User)Session["CurrentUser"]).Id;
int[] order_ids = ids.Split(',').Select(c => int.Parse(c)).ToArray();
foreach (int order_id in order_ids)
{
Cancellation Cancellation = _db.Cancellations.Where(c => c.Id == order_id).FirstOrDefault();
if (Cancellation != null)
{
var data = Newtonsoft.Json.JsonConvert.DeserializeObject <CancellationCardNum>(Cancellation.Data);
data.Customer_Desc = comment;
Cancellation.Data = Newtonsoft.Json.JsonConvert.SerializeObject(data);
//order.ExecutorID = executerID != null ? Convert.ToInt32(executerID) : 0;
_db.Entry(Cancellation).State = EntityState.Modified;
_db.SaveChanges();
}
}
tran.Commit();
}
catch (Exception ex)
{
tran.Rollback();
return(Json(0));
}
}
return(Json(1));
}
}
public async Task when_create_timeout_token_it_should_produce_cancellation_token_cancels_task_within_expected_timeout_length()
{
var timeout = Cancellation.TimeoutToken(TimeSpan.FromSeconds(value: 1));
Func <Task> sut = async() => await Task.Delay(TimeSpan.FromSeconds(value: 3), timeout);
await sut.Should().ThrowExactlyAsync <TaskCanceledException>();
}
public object cancel(Cancel Lvm)
{
try
{
FRSEntities db = new FRSEntities();
Cancellation c = new Cancellation();
if (c.CancellationID == 0)
{
c.CancellationDate = Lvm.CancellationDate;
c.FlightID = Lvm.FlightID;
c.RefundAmount = Lvm.RefundAmount;
c.BookingID = Lvm.BookingID;
db.Cancellations.Add(c);
db.SaveChanges();
return(new Response
{
Status = "Success", Message = "SuccessFully Saved."
});
}
}
catch (Exception)
{
throw;
}
return(new Response
{
Status = "Error", Message = "Invalid Data."
});
}
public IActionResult Cancel(string id, [FromBody] Cancellation cancellation)//resource should be specified
{
Timecard timecard = Database.Find(id);
if (timecard != null)
{
if (timecard.Status != TimecardStatus.Draft && timecard.Status != TimecardStatus.Submitted)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
if (cancellation.Resource == null)//can be same or different person
{
return(StatusCode(408, new InvalidResource()
{
}));
}
if (timecard.Lines.Count < 1)
{
return(StatusCode(409, new EmptyTimecardError()
{
}));
}
var transition = new Transition(cancellation, TimecardStatus.Cancelled);
timecard.Transitions.Add(transition);
return(Ok(transition));
}
else
{
return(NotFound());
}
}
///// <summary>
///// Method updates the details of existing cancellation details
///// </summary>
///// <param name="id"></param>
///// <param name="customer"></param>
///// <returns>return bool value</returns>
public bool UpdateCancellation(int id, Cancellation cancellation)
{
try
{
using (AirlineDBEntities db = new AirlineDBEntities())
{
db.Configuration.LazyLoadingEnabled = false;
db.Entry(cancellation).State = EntityState.Modified;
try
{
db.SaveChanges();
return(true);
}
catch (DbUpdateConcurrencyException)
{
if (!CancellationExists(id))
{
return(false);
}
else
{
throw;
}
}
}
}
catch (CancellationException)
{
throw new CancellationException("Id Doesnt Exists");
}
}
/// <summary>
/// Method to add cancelled tickets
/// </summary>
/// <returns></returns>
public bool AddCancellation(Cancellation cancellation)
{
try
{
using (AirlineDBEntities db = new AirlineDBEntities())
{
if ((db.Cancellations.Count(c => c.CancellationId == cancellation.CancellationId)) == 0)
{
//Add command that will add to database
db.Cancellations.Add(cancellation);
db.SaveChanges();
db.Configuration.LazyLoadingEnabled = false;
return(true);
}
else
{
return(false);
}
}
}
catch (CancellationException)
{
throw new CancellationException("Internal Error");
}
}
public IActionResult Cancel(string id, [FromBody] Cancellation cancellation)
{
Timecard timecard = Database.Find(id);
if (timecard != null)
{
if (timecard.Status != TimecardStatus.Draft && timecard.Status != TimecardStatus.Submitted)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
//Only you can cancel your timecard
if (timecard.Resource == cancellation.Resource)
{
var transition = new Transition(cancellation, TimecardStatus.Cancelled);
timecard.Transitions.Add(transition);
return(Ok(transition));
}
else
{
return(StatusCode(409, new NotAuthorizedError()
{
}));
}
}
else
{
return(NotFound());
}
}
private void WriteByParts(BlockingQueue <BlockingWorkItem <byte[]> > inputBlockingQueue,
Action onFinished,
Cancellation cancellation = null)
{
new Thread(() =>
{
_target.WriteByParts(CompressedParts());
if (!cancellation.IsCancelled())
{
onFinished();
}
IEnumerable <byte[]> CompressedParts()
{
while (inputBlockingQueue.Dequeue(out var part))
{
if (cancellation?.IsCancelled() ?? false)
{
yield break;
}
yield return(part.GetResult());
}
}
}).Start();
}
public IActionResult GetCancellation(string id, [FromBody] Cancellation cancellation)
{
Timecard timecard = Database.Find(id);
if (timecard != null)
{
if (timecard.Status == TimecardStatus.Cancelled)
{
var transition = timecard.Transitions
.Where(t => t.TransitionedTo == TimecardStatus.Cancelled)
.OrderByDescending(t => t.OccurredAt)
.FirstOrDefault();
return(Ok(transition));
}
else
{
return(StatusCode(409, new MissingTransitionError()
{
}));
}
}
else
{
return(NotFound());
}
}
public IActionResult Cancel(string id, [FromBody] Cancellation cancellation)
{
Timecard timecard = Database.Find(id);
if (timecard != null)
{
// timecard is submitted and only can be cancelled by supervisor
if (cancellation.Resource == timecard.Resource && timecard.Status == TimecardStatus.Submitted)
{
return(StatusCode(409, new InvalidResourceError()
{
}));
}
if (timecard.Status != TimecardStatus.Draft && timecard.Status != TimecardStatus.Submitted)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
var transition = new Transition(cancellation, TimecardStatus.Cancelled);
timecard.Transitions.Add(transition);
return(Ok(transition));
}
else
{
return(NotFound());
}
}
public Task CancelTask()
{
return(Task.Run(() =>
{
Cancellation.Cancel();
}));
}
public IActionResult Cancel(Guid id, [FromBody] Cancellation cancellation)
{
logger.LogInformation($"Looking for timesheet {id}");
Timecard timecard = repository.Find(id);
if (timecard != null)
{
if (timecard.Status != TimecardStatus.Draft && timecard.Status != TimecardStatus.Submitted)
{
return(StatusCode(409, new InvalidStateError()
{
}));
}
var transition = new Transition(cancellation, TimecardStatus.Cancelled);
logger.LogInformation($"Adding cancellation transition {transition}");
timecard.Transitions.Add(transition);
repository.Update(timecard);
return(Ok(transition));
}
else
{
return(NotFound());
}
}
/// <summary>
/// Gets the specified radio button for cancellation reason then proceeds to save a log of specified reason for cancellation
/// </summary>
private void Log()
{
try
{
USERS deleter = (USERS)cancelUserBox.SelectedItem;
string reasonCancel = " kunden ikke mødte op";
string phoneCancel = " kunden har aflyst telefonisk";
string elseCancel = " der har været Andet i vejen";
if (cuCancelRadio.Checked)
{
Trace.WriteLine($"\n{DateTime.Now}: ansatte: {deleter} har aflyst denne aftale fordi kunden ikke mødte op");
Cancellation name = new Cancellation(Reason.IkkeMødtOp, deleter);
CancelAppointmentController.CancellationUsersList.Add(name);
}
if (cuCancelPhoneRadio.Checked)
{
Trace.WriteLine($"\n{DateTime.Now}: ansatte: {deleter} har aflyst denne aftale fordi kunden har aflyst telefonisk");
Cancellation name = new Cancellation(Reason.AflystTelefonisk, deleter);
CancelAppointmentController.CancellationUsersList.Add(name);
}
if (cuCancelElseRadio.Checked)
{
Trace.WriteLine($"\n{DateTime.Now}: ansatte: {deleter} har aflyst denne aftale fordi der har været Andet i vejen");
Cancellation name = new Cancellation(Reason.Aflyst, deleter);
CancelAppointmentController.CancellationUsersList.Add(name);
}
}
catch (Exception)
{
}
}
private void SFTPDownload(string[] remoteFiles, string localDirectoryPath)
{
_fileTransferCancellation = new Cancellation();
BeginSFTPThread(delegate() {
ClearProgressBar();
Log("=== DOWNLOAD ===");
string localFullPath = Path.GetFullPath(localDirectoryPath);
bool continued = true;
try {
bool overwite = false;
foreach (string remotePath in remoteFiles)
{
continued = SFTPDownload_DownloadRecursively(remotePath, localFullPath, ref overwite);
if (!continued)
{
break;
}
}
}
finally {
ClearProgressBar();
}
_fileTransferCancellation = null;
Log("DOWNLOAD " + (continued ? "completed." : "canceled."));
}, true, true);
}
public IHttpActionResult PutCancellation(int id, Cancellation cancellation)
{
//Checking whether the model passes to every validation applied
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//Checks whether the incoming Id and the Id that is to be updated are equal or not
if (id != cancellation.CancellationId)
{
return(BadRequest());
}
//One amonng the five states of entity state that is being tracked by the entity for modification
try
{
bool isUpdated = cancService.UpdateCancellation(id, cancellation);
if (isUpdated)
{
return(StatusCode(HttpStatusCode.NoContent));
}
else
{
return(NotFound());
}
}
catch (CancellationException)
{
throw;
}
}
private async Task<object> BlockThreat(ICyThreatInstance[] instance)
{
Cancellation.ThrowIfCancellationRequested();
WriteVerbose($"Locally quarantining threat {instance[0].sha256} on device {instance[0].device_id}.");
var r = await Connection.QuarantineDeviceThreatAsync(instance[0]);
return r;
}
public void Cancel(CancellationType cancellationType, string reason, DateTime madeOn)
{
if (Cancellation == null)
Cancellation = new Cancellation
{
DateMade = madeOn,
Reason = reason,
Type = cancellationType
};
}
