public async Task <HttpResponseMessage> ExecuteAuthorizationFilterAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func <Task <HttpResponseMessage> > continuation)
{
string action = ProfilerActionSplitterAttribute.GetActionDescription(actionContext);
try
{
using (TimeTracker.Start(action))
{
using (HeavyProfiler.Log("Web.API " + actionContext.Request.Method, () => actionContext.Request.RequestUri.ToString()))
{
var user = (IUserEntity)GetProp(actionContext, SignumAuthenticationFilterAttribute.UserKey);
using (user != null ? UserHolder.UserSession(user) : null)
{
var culture = SignumAuthenticationFilterAttribute.GetCurrentCultures?.Invoke(actionContext);
using (culture != null ? CultureInfoUtils.ChangeBothCultures(culture) : null)
{
var result = await continuation();
return(result);
}
}
}
}
}
finally
{
Statics.CleanThreadContextAndAssert();
}
}
static void StartTrainingAsync(PredictorEntity p)
{
var cancellationSource = new CancellationTokenSource();
var ctx = new PredictorTrainingContext(p, cancellationSource.Token);
var state = new PredictorTrainingState(cancellationSource, ctx);
if (!Trainings.TryAdd(p.ToLite(), state))
{
throw new InvalidOperationException(PredictorMessage._0IsAlreadyBeingTrained.NiceToString(p));
}
using (ExecutionContext.SuppressFlow())
{
Task.Run(() =>
{
var user = ExecutionMode.Global().Using(_ => p.User !.RetrieveAndRemember());
using (UserHolder.UserSession(user))
{
try
{
DoTraining(ctx);
}
finally
{
Trainings.TryRemove(p.ToLite(), out var _);
}
}
});
}
}
public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
{
ReadData();
if (users.ContainsKey(username))
{
status = MembershipCreateStatus.DuplicateUserName;
return(null);
}
if (RequiresUniqueEmail && GetUserNameByEmail(email) != "")
{
status = MembershipCreateStatus.DuplicateEmail;
return(null);
}
UserHolder u = new UserHolder();
u.PasswordHash = GeneratePasswordHash(password);
u.User = new MembershipUser(this.Name, username, providerUserKey, email, passwordQuestion, "", isApproved, false, DateTime.Now, DateTime.Now, DateTime.Now, DateTime.Now, new DateTime());
users.Add(username, u);
WriteData();
status = MembershipCreateStatus.Success;
return(u.User);
}
protected T Return <T>(IUserEntity user, MethodBase mi, string description, Func <T> function)
{
try
{
using (UserHolder.UserSession(user))
{
return(function());
}
}
catch (Exception e)
{
e.LogException(el =>
{
el.ControllerName = GetType().Name;
el.ActionName = mi.Name;
el.QueryString = description;
el.Version = Schema.Current.Version.ToString();
});
throw;
}
finally
{
Statics.CleanThreadContextAndAssert();
}
}
public override void UpdateUser(MembershipUser user)
{
ReadData();
UserHolder u = users[user.UserName];
u.User = user;
users[user.UserName] = u;
WriteData();
}
public override RecyclerView.ViewHolder OnCreateViewHolder(ViewGroup parent, int viewType)
{
var itemBindingContext = new MvxAndroidBindingContext(parent.Context, BindingContext.LayoutInflaterHolder);
var itemView = LayoutInflater.From(parent.Context).Inflate(Resource.Layout.item_user, parent, false);
var holder = new UserHolder(itemView, itemBindingContext);
holder.SetOnElementClickListener(this);
return(holder);
}
public void Execute()
{
var user = ExecutionMode.Global().Using(_ => CurrentProcess.User.RetrieveAndRemember());
using (UserHolder.UserSession(user))
{
using (ProcessLogic.OnApplySession(CurrentProcess))
{
if (UserEntity.Current == null)
{
UserEntity.Current = AuthLogic.SystemUser !;
}
try
{
Algorithm.Execute(this);
CurrentProcess.ExecutionEnd = TimeZoneManager.Now;
CurrentProcess.State = ProcessState.Finished;
CurrentProcess.Progress = null;
CurrentProcess.User.ClearEntity();
using (OperationLogic.AllowSave <ProcessEntity>())
CurrentProcess.Save();
}
catch (OperationCanceledException e)
{
if (!e.CancellationToken.Equals(this.CancellationToken))
{
throw;
}
CurrentProcess.SuspendDate = TimeZoneManager.Now;
CurrentProcess.State = ProcessState.Suspended;
using (OperationLogic.AllowSave <ProcessEntity>())
CurrentProcess.Save();
}
catch (Exception e)
{
if (Transaction.InTestTransaction)
{
throw;
}
CurrentProcess.State = ProcessState.Error;
CurrentProcess.ExceptionDate = TimeZoneManager.Now;
CurrentProcess.Exception = e.LogException(el => el.ActionName = CurrentProcess.Algorithm.ToString()).ToLite();
using (OperationLogic.AllowSave <ProcessEntity>())
CurrentProcess.Save();
}
finally
{
ProcessRunnerLogic.OnFinally?.Invoke(this);
}
}
}
}
public override IDisposable GetResource(ResourceExecutingContext context)
{
var result = Authenticate(context);
if (result == null)
{
return(null);
}
return(result.User != null?UserHolder.UserSession(result.User) : null);
}
public override IDisposable?GetResource(ResourceExecutingContext context)
{
var result = Authenticate(context);
if (result == null)
{
return(null);
}
context.HttpContext.Items[Signum_User_Key] = result.User;
return(result.User != null?UserHolder.UserSession(result.User) : null);
}
public static IDisposable UnsafeUserSession(string username)
{
UserEntity?user;
using (AuthLogic.Disable())
{
user = RetrieveUser(username);
if (user == null)
{
throw new ApplicationException(AuthMessage.Username0IsNotValid.NiceToString().FormatWith(username));
}
}
return(UserHolder.UserSession(user));
}
public static ResetPasswordRequestEntity ResetPasswordRequestExecute(string code, string password)
{
using (AuthLogic.Disable())
{
var rpr = Database.Query <ResetPasswordRequestEntity>()
.Where(r => r.Code == code && r.IsValid)
.SingleEx();
using (UserHolder.UserSession(rpr.User))
{
rpr.Execute(ResetPasswordRequestOperation.Execute, password);
}
return(rpr);
}
}
public override bool ChangePassword(string username, string oldPassword, string newPassword)
{
ReadData();
if (!ValidateUser(username, oldPassword))
{
return(false);
}
UserHolder u = users[username];
u.PasswordHash = GeneratePasswordHash(newPassword);
users[username] = u;
WriteData();
return(true);
}
public static ResetPasswordRequestEntity ResetPasswordRequestExecute(string code, string password)
{
using (AuthLogic.Disable())
{
//Remove old previous requests
var rpr = Database.Query <ResetPasswordRequestEntity>()
.Where(r => r.Code == code && !r.Lapsed)
.SingleOrDefault();
using (UserHolder.UserSession(rpr.User))
{
rpr.Execute(ResetPasswordRequestOperation.Execute, password);
}
return(rpr);
}
}
private UserHolder?GetUser(Func <KeyValuePair <string, UserHolder>, bool> condition, bool userIsOnline)
{
ReadData();
UserHolder user;
try
{
user = users.Where(condition).First().Value;
} catch (Exception)
{
// probably nothing found
return(null);
}
if (userIsOnline)
{
UserHolder u = users[user.User.UserName];
u.User.LastActivityDate = DateTime.Now;
WriteData();
}
return(user);
}
public ActionResult <LoginResponse> Login([Required, FromBody] LoginRequest data)
{
if (string.IsNullOrEmpty(data.userName))
{
return(ModelError("userName", AuthMessage.UserNameMustHaveAValue.NiceToString()));
}
if (string.IsNullOrEmpty(data.password))
{
return(ModelError("password", AuthMessage.PasswordMustHaveAValue.NiceToString()));
}
// Attempt to login
UserEntity user;
try
{
if (AuthLogic.Authorizer == null)
{
user = AuthLogic.Login(data.userName, Security.EncodePassword(data.password));
}
else
{
user = AuthLogic.Authorizer.Login(data.userName, data.password);
}
}
catch (Exception e) when(e is IncorrectUsernameException || e is IncorrectPasswordException)
{
if (AuthServer.MergeInvalidUsernameAndPasswordMessages)
{
return(ModelError("login", AuthMessage.InvalidUsernameOrPassword.NiceToString()));
}
else if (e is IncorrectUsernameException)
{
return(ModelError("userName", AuthMessage.InvalidUsername.NiceToString()));
}
else if (e is IncorrectPasswordException)
{
return(ModelError("password", AuthMessage.InvalidPassword.NiceToString()));
}
throw;
}
catch (Exception e)
{
return(ModelError("login", e.Message));
}
using (UserHolder.UserSession(user))
{
if (data.rememberMe == true)
{
UserTicketServer.SaveCookie(ControllerContext);
}
AuthServer.OnUserPreLogin(ControllerContext, user);
AuthServer.AddUserSession(ControllerContext, user);
string?message = AuthLogic.OnLoginMessage();
var token = AuthTokenServer.CreateToken(user);
return(new LoginResponse {
message = message, userEntity = user, token = token
});
}
}
public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
{
ReadData();
if (users.ContainsKey(username))
{
status = MembershipCreateStatus.DuplicateUserName;
return null;
}
if (RequiresUniqueEmail && GetUserNameByEmail(email) != "") {
status = MembershipCreateStatus.DuplicateEmail;
return null;
}
UserHolder u = new UserHolder();
u.PasswordHash = GeneratePasswordHash(password);
u.User = new MembershipUser(this.Name, username, providerUserKey, email, passwordQuestion, "", isApproved, false, DateTime.Now, DateTime.Now, DateTime.Now, DateTime.Now, new DateTime());
users.Add(username, u);
WriteData();
status = MembershipCreateStatus.Success;
return u.User;
}
public virtual Lite <DisconnectedExportEntity> BeginExportDatabase(DisconnectedMachineEntity machine)
{
Lite <DisconnectedExportEntity> export = new DisconnectedExportEntity
{
Machine = machine.ToLite(),
Copies = downloadTables.Select(t => new DisconnectedExportTableEmbedded
{
Type = t.Type.ToTypeEntity().ToLite()
}).ToMList()
}.Save().ToLite();
var cancelationSource = new CancellationTokenSource();
var user = UserHolder.Current;
var token = cancelationSource.Token;
var task = Task.Factory.StartNew(() =>
{
using (UserHolder.UserSession(user))
{
OnStartExporting(machine);
DisconnectedMachineEntity.Current = machine.ToLite();
try
{
using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.Lock, s => l).Execute()))
{
foreach (var tuple in downloadTables)
{
token.ThrowIfCancellationRequested();
if (tuple.Strategy.Upload == Upload.Subset)
{
miUnsafeLock.MakeGenericMethod(tuple.Type).Invoke(this, new object[] { machine.ToLite(), tuple.Strategy, export });
}
}
}
string connectionString;
using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.CreateDatabase, s => l).Execute()))
connectionString = CreateDatabase(machine);
var newDatabase = new SqlServerConnector(connectionString, Schema.Current, ((SqlServerConnector)Connector.Current).Version);
using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.CreateSchema, s => l).Execute()))
using (Connector.Override(newDatabase))
using (ObjectName.OverrideOptions(new ObjectNameOptions {
AvoidDatabaseName = true
}))
{
Administrator.TotalGeneration();
}
using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.DisableForeignKeys, s => l).Execute()))
using (Connector.Override(newDatabase))
using (ObjectName.OverrideOptions(new ObjectNameOptions {
AvoidDatabaseName = true
}))
{
foreach (var tuple in downloadTables.Where(t => !t.Type.IsEnumEntity()))
{
token.ThrowIfCancellationRequested();
DisableForeignKeys(tuple.Table);
}
}
var isPostgres = Schema.Current.Settings.IsPostgres;
DatabaseName newDatabaseName = new DatabaseName(null, newDatabase.DatabaseName(), isPostgres);
foreach (var tuple in downloadTables)
{
token.ThrowIfCancellationRequested();
int ms = 0;
using (token.MeasureTime(l => ms = l))
{
tuple.Strategy.Exporter !.Export(tuple.Table, tuple.Strategy, newDatabaseName, machine);
}
export.MListElementsLite(_ => _.Copies).Where(c => c.Element.Type.Is(tuple.Type.ToTypeEntity())).UnsafeUpdateMList()
.Set(mle => mle.Element.CopyTable, mle => ms)
.Execute();
}
using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.EnableForeignKeys, s => l).Execute()))
foreach (var tuple in downloadTables.Where(t => !t.Type.IsEnumEntity()))
{
token.ThrowIfCancellationRequested();
EnableForeignKeys(tuple.Table);
}
using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.ReseedIds, s => l).Execute()))
{
var tablesToUpload = Schema.Current.Tables.Values.Where(t => DisconnectedLogic.GetStrategy(t.Type).Upload != Upload.None)
.SelectMany(t => t.TablesMList().Cast <ITable>().And(t)).Where(t => t.PrimaryKey.Identity).ToList();
var maxIdDictionary = tablesToUpload.ToDictionary(t => t,
t => DisconnectedTools.MaxIdInRange(t, machine.SeedMin, machine.SeedMax));
using (Connector.Override(newDatabase))
using (ObjectName.OverrideOptions(new ObjectNameOptions {
AvoidDatabaseName = true
}))
{
foreach (var table in tablesToUpload)
{
token.ThrowIfCancellationRequested();
long?max = maxIdDictionary.GetOrThrow(table);
DisconnectedTools.SetNextId(table, (max + 1) ?? machine.SeedMin);
}
}
}
CopyExport(export, newDatabase);
machine.InDB().UnsafeUpdate().Set(s => s.State, s => DisconnectedMachineState.Disconnected).Execute();
using (SqlServerConnector.Override(newDatabase))
using (ObjectName.OverrideOptions(new ObjectNameOptions {
AvoidDatabaseName = true
}))
machine.InDB().UnsafeUpdate().Set(s => s.State, s => DisconnectedMachineState.Disconnected).Execute();
using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.BackupDatabase, s => l).Execute()))
BackupDatabase(machine, export, newDatabase);
using (token.MeasureTime(l => export.InDB().UnsafeUpdate().Set(s => s.DropDatabase, s => l).Execute()))
DropDatabase(newDatabase);
token.ThrowIfCancellationRequested();
export.InDB().UnsafeUpdate()
.Set(s => s.State, s => DisconnectedExportState.Completed)
.Set(s => s.Total, s => s.CalculateTotal())
.Execute();
}
catch (Exception e)
{
var ex = e.LogException();
export.InDB().UnsafeUpdate()
.Set(s => s.Exception, s => ex.ToLite())
.Set(s => s.State, s => DisconnectedExportState.Error)
.Execute();
OnExportingError(machine, export, e);
}
finally
{
runningExports.Remove(export);
DisconnectedMachineEntity.Current = null;
OnEndExporting();
}
}
});
runningExports.Add(export, new RunningExports(task, cancelationSource));
return(export);
}
public static ScheduledTaskLogEntity ExecuteSync(ITaskEntity task, ScheduledTaskEntity?scheduledTask, IUserEntity?user)
{
IUserEntity entityIUser = (user ?? (IUserEntity?)scheduledTask?.User.RetrieveAndRemember()) !;
var isolation = entityIUser.TryIsolation();
if (isolation == null)
{
var ientity = task as IEntity;
isolation = ientity?.TryIsolation();
}
using (IsolationEntity.Override(isolation))
{
ScheduledTaskLogEntity stl = new ScheduledTaskLogEntity
{
Task = task,
ScheduledTask = scheduledTask,
StartTime = TimeZoneManager.Now,
MachineName = Environment.MachineName,
ApplicationName = Schema.Current.ApplicationName,
User = entityIUser.ToLite(),
};
using (AuthLogic.Disable())
{
using (Transaction tr = Transaction.ForceNew())
{
stl.Save();
tr.Commit();
}
}
try
{
var ctx = new ScheduledTaskContext(stl);
RunningTasks.TryAdd(stl, ctx);
using (UserHolder.UserSession(entityIUser))
{
using (Transaction tr = Transaction.ForceNew())
{
stl.ProductEntity = ExecuteTask.Invoke(task, ctx);
using (AuthLogic.Disable())
{
stl.EndTime = TimeZoneManager.Now;
stl.Remarks = ctx.StringBuilder.ToString();
stl.Save();
}
tr.Commit();
}
}
}
catch (Exception ex)
{
using (AuthLogic.Disable())
{
if (Transaction.InTestTransaction)
{
throw;
}
var exLog = ex.LogException().ToLite();
using (Transaction tr = Transaction.ForceNew())
{
stl.Exception = exLog;
stl.EndTime = TimeZoneManager.Now;
stl.Save();
tr.Commit();
}
}
throw;
}
finally
{
RunningTasks.TryRemove(stl, out var ctx);
OnFinally?.Invoke(stl);
}
return(stl);
}
}
public virtual Lite <DisconnectedImportEntity> BeginImportDatabase(DisconnectedMachineEntity machine, Stream file = null)
{
Lite <DisconnectedImportEntity> import = new DisconnectedImportEntity
{
Machine = machine.ToLite(),
Copies = uploadTables.Select(t => new DisconnectedImportTableEmbedded
{
Type = t.Type.ToTypeEntity().ToLite(),
DisableForeignKeys = t.Strategy.DisableForeignKeys.Value,
}).ToMList()
}.Save().ToLite();
if (file != null)
{
using (FileStream fs = File.OpenWrite(BackupNetworkFileName(machine, import)))
{
file.CopyTo(fs);
file.Close();
}
}
var threadContext = Statics.ExportThreadContext();
var cancelationSource = new CancellationTokenSource();
var user = UserEntity.Current;
var token = cancelationSource.Token;
var task = Task.Factory.StartNew(() =>
{
lock (SyncLock)
using (UserHolder.UserSession(user))
{
OnStartImporting(machine);
DisconnectedMachineEntity.Current = machine.ToLite();
try
{
if (file != null)
{
using (token.MeasureTime(l => import.InDB().UnsafeUpdate().Set(s => s.RestoreDatabase, s => l).Execute()))
{
DropDatabaseIfExists(machine);
RestoreDatabase(machine, import);
}
}
string connectionString = GetImportConnectionString(machine);
var newDatabase = new SqlConnector(connectionString, Schema.Current, DynamicQueryManager.Current, ((SqlConnector)Connector.Current).Version);
using (token.MeasureTime(l => import.InDB().UnsafeUpdate().Set(s => s.SynchronizeSchema, s => l).Execute()))
using (Connector.Override(newDatabase))
using (ObjectName.OverrideOptions(new ObjectNameOptions {
AvoidDatabaseName = true
}))
using (ExecutionMode.DisableCache())
{
var script = Administrator.TotalSynchronizeScript(interactive: false, schemaOnly: true);
if (script != null)
{
string fileName = BackupNetworkFileName(machine, import) + ".sql";
script.Save(fileName);
throw new InvalidOperationException("The schema has changed since the last export. A schema sync script has been saved on: {0}".FormatWith(fileName));
}
}
try
{
using (token.MeasureTime(l => import.InDB().UnsafeUpdate().Set(s => s.DisableForeignKeys, s => l).Execute()))
foreach (var item in uploadTables.Where(u => u.Strategy.DisableForeignKeys.Value))
{
DisableForeignKeys(item.Table);
}
foreach (var tuple in uploadTables)
{
ImportResult result = null;
using (token.MeasureTime(l =>
{
if (result != null)
{
import.MListElementsLite(_ => _.Copies).Where(mle => mle.Element.Type.RefersTo(tuple.Type.ToTypeEntity())).UnsafeUpdateMList()
.Set(mle => mle.Element.CopyTable, mle => l)
.Set(mle => mle.Element.DisableForeignKeys, mle => tuple.Strategy.DisableForeignKeys.Value)
.Set(mle => mle.Element.InsertedRows, mle => result.Inserted)
.Set(mle => mle.Element.UpdatedRows, mle => result.Updated)
.Execute();
}
}))
{
result = tuple.Strategy.Importer.Import(machine, tuple.Table, tuple.Strategy, newDatabase);
}
}
using (token.MeasureTime(l => import.InDB().UnsafeUpdate().Set(s => s.Unlock, s => l).Execute()))
UnlockTables(machine.ToLite());
}
finally
{
using (token.MeasureTime(l => import.InDB().UnsafeUpdate().Set(s => s.EnableForeignKeys, s => l).Execute()))
foreach (var item in uploadTables.Where(u => u.Strategy.DisableForeignKeys.Value))
{
EnableForeignKeys(item.Table);
}
}
using (token.MeasureTime(l => import.InDB().UnsafeUpdate().Set(s => s.DropDatabase, s => l).Execute()))
DropDatabase(newDatabase);
token.ThrowIfCancellationRequested();
import.InDB().UnsafeUpdate()
.Set(s => s.State, s => DisconnectedImportState.Completed)
.Set(s => s.Total, s => s.CalculateTotal())
.Execute();
machine.InDB().UnsafeUpdate()
.Set(m => m.State, m => file == null ? DisconnectedMachineState.Fixed : DisconnectedMachineState.Connected)
.Execute();
}
catch (Exception e)
{
var ex = e.LogException();
import.InDB().UnsafeUpdate()
.Set(m => m.Exception, m => ex.ToLite())
.Set(m => m.State, m => DisconnectedImportState.Error)
.Execute();
machine.InDB().UnsafeUpdate()
.Set(m => m.State, m => DisconnectedMachineState.Faulted)
.Execute();
OnImportingError(machine, import, e);
}
finally
{
runningImports.Remove(import);
DisconnectedMachineEntity.Current = null;
OnEndImporting();
}
}
});
runningImports.Add(import, new RunningImports {
Task = task, CancelationSource = cancelationSource
});
return(import);
}
private static void ExecuteProcess()
{
if (running)
{
throw new InvalidOperationException("WorkflowScriptRunner process is already running");
}
using (ExecutionContext.SuppressFlow())
{
Task.Factory.StartNew(() =>
{
SystemEventLogLogic.Log("Start WorkflowScriptRunner");
ExceptionEntity exception = null;
try
{
running = true;
CancelProcess = new CancellationTokenSource();
autoResetEvent.Set();
timer = new Timer(ob => WakeUp("TimerNextExecution", null),
null,
Timeout.Infinite,
Timeout.Infinite);
GC.KeepAlive(timer);
using (UserHolder.UserSession(AuthLogic.SystemUser))
{
if (CacheLogic.WithSqlDependency)
{
SetSqlDependency();
}
while (autoResetEvent.WaitOne())
{
if (CancelProcess.IsCancellationRequested)
{
return;
}
timer.Change(Timeout.Infinite, Timeout.Infinite);
nextPlannedExecution = null;
using (HeavyProfiler.Log("WorkflowScriptRunner", () => "Execute process"))
{
processIdentifier = Guid.NewGuid();
if (RecruitQueuedItems())
{
while (queuedItems > 0 || RecruitQueuedItems())
{
var items = Database.Query <CaseActivityEntity>().Where(m => m.DoneDate == null &&
m.ScriptExecution.ProcessIdentifier == processIdentifier)
.Take(WorkflowLogic.Configuration.ChunkSizeRunningScripts).ToList();
queuedItems = items.Count;
foreach (var caseActivity in items)
{
CancelProcess.Token.ThrowIfCancellationRequested();
try
{
using (Transaction tr = Transaction.ForceNew())
{
caseActivity.Execute(CaseActivityOperation.ScriptExecute);
tr.Commit();
}
}
catch
{
try
{
var ca = caseActivity.ToLite().Retrieve();
var retry = ca.WorkflowActivity.Script.RetryStrategy;
var nextDate = retry?.NextDate(ca.ScriptExecution.RetryCount);
if (nextDate == null)
{
ca.Execute(CaseActivityOperation.ScriptFailureJump);
}
else
{
ca.Execute(CaseActivityOperation.ScriptScheduleRetry, nextDate.Value);
}
}
catch (Exception e)
{
e.LogException();
throw;
}
}
queuedItems--;
}
queuedItems = Database.Query <CaseActivityEntity>()
.Where(m => m.ScriptExecution.ProcessIdentifier == processIdentifier && m.DoneDate == null)
.Count();
}
}
SetTimer();
SetSqlDependency();
}
}
}
}
catch (Exception e)
{
try
{
exception = e.LogException(edn =>
{
edn.ControllerName = "WorkflowScriptRunner";
edn.ActionName = "ExecuteProcess";
});
}
catch { }
}
finally
{
SystemEventLogLogic.Log("Stop WorkflowScriptRunner", exception);
running = false;
}
}, TaskCreationOptions.LongRunning);
}
}
public LoginResponse Login([FromBody] LoginRequest data)
{
if (string.IsNullOrEmpty(data.userName))
{
throw ModelException("userName", AuthMessage.UserNameMustHaveAValue.NiceToString());
}
if (string.IsNullOrEmpty(data.password))
{
throw ModelException("password", AuthMessage.PasswordMustHaveAValue.NiceToString());
}
// Attempt to login
UserEntity user = null;
try
{
user = AuthLogic.Login(data.userName, Security.EncodePassword(data.password));
}
catch (Exception e) when(e is IncorrectUsernameException || e is IncorrectPasswordException)
{
if (AuthServer.MergeInvalidUsernameAndPasswordMessages)
{
ModelState.AddModelError("userName", AuthMessage.InvalidUsernameOrPassword.NiceToString());
ModelState.AddModelError("password", AuthMessage.InvalidUsernameOrPassword.NiceToString());
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, this.ModelState));
}
else if (e is IncorrectUsernameException)
{
throw ModelException("userName", AuthMessage.InvalidUsername.NiceToString());
}
else if (e is IncorrectPasswordException)
{
throw ModelException("password", AuthMessage.InvalidPassword.NiceToString());
}
}
catch (IncorrectPasswordException)
{
throw ModelException("password", AuthServer.MergeInvalidUsernameAndPasswordMessages ?
AuthMessage.InvalidUsernameOrPassword.NiceToString() :
AuthMessage.InvalidPassword.NiceToString());
}
using (UserHolder.UserSession(user))
{
if (data.rememberMe == true)
{
UserTicketServer.SaveCookie();
}
AuthServer.AddUserSession(user);
string message = AuthLogic.OnLoginMessage();
var token = AuthTokenServer.CreateToken(user);
return(new LoginResponse {
message = message, userEntity = user, token = token
});
}
}
