protected async Task SetUpFakeUser (Guid userId)
{
ServiceContainer.Register<ISettingsStore> (Mock.Of<ISettingsStore> (
(store) => store.ApiToken == "test" &&
store.UserId == userId));
var authManager = new AuthManager ();
ServiceContainer.Register<AuthManager> (authManager);
// Wait for the auth manager to load user data:
var tcs = new TaskCompletionSource<object> ();
Action checkUser = delegate {
if (authManager.User != null && authManager.User.DefaultWorkspaceId != Guid.Empty) {
tcs.TrySetResult (null);
}
};
authManager.PropertyChanged += (sender, e) => {
if (e.PropertyName == AuthManager.PropertyUser) {
checkUser ();
}
};
checkUser ();
await tcs.Task;
MessageBus.Send (new AuthChangedMessage (authManager, AuthChangeReason.Login));
}
public async static Task RegisterAsync ()
{
ServiceContainer.Register<MessageBus> ();
ServiceContainer.Register<UpgradeManger> ();
ServiceContainer.Register<ActiveTimeEntryManager> ();
ServiceContainer.Register<DataCache> ();
ServiceContainer.Register<ForeignRelationManager> ();
ServiceContainer.Register<TimeCorrectionManager> ();
ServiceContainer.Register<ISyncManager> (() => new SyncManager ());
if (ServiceContainer.Resolve<IPlatformInfo> ().IsWidgetAvailable) {
ServiceContainer.Register<WidgetSyncManager> (() => new WidgetSyncManager ());
}
ServiceContainer.Register<IPushClient> (() => new PushRestClient (Build.ApiUrl));
ServiceContainer.Register<IDataStore> (CreateDataStore);
ServiceContainer.Register<LogStore> ();
// Core services that are most likelly to be overriden by UI code:
ServiceContainer.Register<ITogglClient> (() => new TogglRestClient (Build.ApiUrl));
ServiceContainer.Register<IReportsClient> (() => new ReportsRestClient (Build.ReportsApiUrl));
// Asynchronous Initialization Pattern
// as described at http://blog.stephencleary.com/2013/01/async-oop-2-constructors.html
var authManagerServ = new AuthManager ();
ServiceContainer.Register<AuthManager> (authManagerServ);
RegisterJsonConverters ();
ServiceContainer.Register<LoggerUserManager> ();
// initialise async services.
await authManagerServ.Initialization;
}
//инициализация
public AccountController(MongoUserManager userManager
, IAuthenticationManager authenticationManager, MongoSignInManager signInManager
, CustomContentManager contentManager, AuthManager authManager
, ICommonLogger logger)
: base(contentManager)
{
_userManager = userManager;
_signInManager = signInManager;
_authenticationManager = authenticationManager;
_authManager = authManager;
_logger = logger;
}
public WidgetSyncManager ()
{
authManager = ServiceContainer.Resolve<AuthManager>();
authManager.PropertyChanged += OnAuthPropertyChanged;
activeTimeEntryManager = ServiceContainer.Resolve<ActiveTimeEntryManager> ();
widgetUpdateService = ServiceContainer.Resolve<IWidgetUpdateService> ();
messageBus = ServiceContainer.Resolve<MessageBus> ();
subscriptionSyncStarted = messageBus.Subscribe<SyncStartedMessage> (OnSyncWidget);
subscriptionSyncFinished = messageBus.Subscribe<SyncFinishedMessage> (OnSyncWidget);
subscriptionStartStopFinished = messageBus.Subscribe<StartStopMessage> (OnSyncWidget);
}
public WidgetSyncManager ()
{
authManager = ServiceContainer.Resolve<AuthManager>();
authManager.PropertyChanged += OnAuthPropertyChanged;
widgetUpdateService = ServiceContainer.Resolve<IWidgetUpdateService>();
timeEntryManager = ServiceContainer.Resolve<ActiveTimeEntryManager> ();
timeEntryManager.PropertyChanged += OnTimeEntryManagerPropertyChanged;
ResetModelToRunning ();
messageBus = ServiceContainer.Resolve<MessageBus> ();
subscriptionSyncStarted = messageBus.Subscribe<SyncStartedMessage> (OnSync);
subscriptionSyncFinished = messageBus.Subscribe<SyncFinishedMessage> (OnSync);
}
public bool Test()
{
m_Msg = new List<string>();
AuthManager authTest = new AuthManager();
string message;
string testToken;
DateTime expireTime;
testFunction(authTest.Register("userName2", "1234567890", out message));
testFunction(authTest.Register("userName3", "11", out message));
testFunction(authTest.Register("userName4", "completely", out message));
testFunction(authTest.Register("userName5", "abcdefghijklmnopqrstuvwxyx", out message));
testFunction(authTest.Register("userName6", "123abgccadsa", out message));
testFunction(authTest.Register("userName6", "123abgccadsa", out message));
testFunction(authTest.Register("userName7", "_dafgaowerd", out message));
testFunction(authTest.Register("userName8", "_12456774", out message));
testFunction(authTest.LogIn("userName2", "1234567890", out testToken, out message));
testFunction(authTest.TokenVerifier(testToken, out expireTime));
return true;
}
protected async override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) {
if (request.RequestUri.PathAndQuery == "/api/Auth" || request.RequestUri.PathAndQuery == "/api/Users") {
return await base.SendAsync(request, cancellationToken);
}
var token = request.Headers.GetValues("AUTH_TOKEN").First();
var result = new AuthManager().CheckToken(token);
if (result == null) {
var response = new HttpResponseMessage(HttpStatusCode.Forbidden);
var tsc = new TaskCompletionSource<HttpResponseMessage>();
tsc.SetResult(response);
return await tsc.Task;
}
request.Properties.Add("AUTH_USER", result);
return await base.SendAsync(request, cancellationToken);
}
public async Task <ActionResult> Login(LoginModel details, string returnUrl)
{
if (ModelState.IsValid)
{
AppUser user = await UserManager.FindAsync(details.Email, details.Password);
if (user == null)
{
ModelState.AddModelError("", "Некорректное имя или пароль.");
}
else
{
ClaimsIdentity ident = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut();
AuthManager.SignIn(new AuthenticationProperties
{
IsPersistent = false
}, ident);
return(RedirectToAction("Index", "Home"));
}
}
return(View(details));
}
public async Task <ActionResult> Login(LoginViewModel model)
{
var user = await UserManager.FindAsync(model.Email, model.Password);
if (user == null)
{
ModelState.AddModelError("", "Login failed, please try again!");
}
else
{
ClaimsIdentity ident = await UserManager.CreateIdentityAsync(user,
DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut();
AuthManager.SignIn(new AuthenticationProperties
{
IsPersistent = model.RememberMe
}, ident);
return(RedirectToAction("Index", "Home"));
}
return(View(model));
}
public int LoginUnionid(string unionid)
{
try
{
var search = UserManager.Users.Where(t => t.unionid == unionid).FirstOrDefault();
search.DateOfLast = DateTime.Now;
var temp = UserManager.Update(search);
if (search != null)
{
ClaimsIdentity ident = UserManager.CreateIdentity(search,
DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut();
AuthManager.SignIn(new AuthenticationProperties {
IsPersistent = false
}, ident);
return(1);
}
return(0);
}
catch (Exception e)
{
return(0);
}
}
private InteractResult TryPickUp(WorldObject obj, InteractionContext context)
{
var basicResult = BasicToolOnWorldObjectCheck(context);
if (context.Modifier == InteractionModifier.Ctrl ? basicResult.IsFailure : !basicResult.IsNoOp)
{
return(basicResult);
}
var authResult = AuthManager.IsAuthorized(obj, context.Player.User, AccessType.FullAccess);
if (!authResult.Success)
{
return((InteractResult)authResult);
}
var pickupResult = obj.TryPickUp(context.Player);
if (pickupResult.Success)
{
this.BurnCalories(context.Player);
}
return((InteractResult)pickupResult);
}
public ActionResult Budgets(string year, string costcenterid)
{
try
{
CostCenter working;
List <Budget> budgets;
// 1. Get working costcenter.
working = AuthManager.GetWorkingCostCenter();
// 2. Get by raw query
var bm = new BudgetManager();
budgets = bm.GetOverall(year, costcenterid).ToList();
// 3. Set return object.
returnobj.SetSuccess(budgets);
}
catch (Exception ex)
{
returnobj.SetError(ex.Message);
}
return(Content(returnobj.ToJson(), "application/json"));
}
public ConfirmAuthHandler(
IOptionsMonitor <AuthenticationSchemeOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock,
SecurityContext securityContext,
EmailValidationKeyProvider emailValidationKeyProvider,
SetupInfo setupInfo,
TenantManager tenantManager,
UserManager userManager,
AuthManager authManager,
AuthContext authContext,
IServiceProvider serviceProvider) :
base(options, logger, encoder, clock)
{
SecurityContext = securityContext;
EmailValidationKeyProvider = emailValidationKeyProvider;
SetupInfo = setupInfo;
TenantManager = tenantManager;
UserManager = userManager;
AuthManager = authManager;
AuthContext = authContext;
ServiceProvider = serviceProvider;
}
public void CreateInterviewerByAdmin([FromBody] RegistrationData data)
{
var tokenString = Request.Headers["Authorization"];
var token = new TokenData(tokenString);
if (!AuthManager.ValidateAuthToken(token))
{
Response.StatusCode = (int)HttpStatusCode.NetworkAuthenticationRequired;
return;
}
if (!UsersManager.GetUser(token).HasRoot(RootEnum.Admin))
{
Response.StatusCode = (int)HttpStatusCode.Forbidden;
return;
}
var tokenNewUser = AuthManager.RegisterUser(new RegistrationData(data.Login, data.Password)
{
RootType = RootEnum.Interviewer
});
AuthManager.LogOutUser(tokenNewUser);
}
public TokenData Authorization([FromBody] AuthData data)
{
try
{
var token = AuthManager.AuthUser(data);
token.UserType = UsersManager.GetUser(token).RootType;
return(token);
}
catch (ArgumentException)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(null);
}
catch (AuthExceptions.UserDoesNotExists)
{
Response.StatusCode = (int)HttpStatusCode.NotFound;
return(null);
}
catch (AuthExceptions.IncorrectPassword)
{
Response.StatusCode = (int)HttpStatusCode.PreconditionFailed;
return(null);
}
}
public void CreateTest([FromBody] TestData testData)
{
var tokenString = Request.Headers["Authorization"];
var token = new TokenData(tokenString);
if (!AuthManager.ValidateAuthToken(token))
{
Response.StatusCode = (int)HttpStatusCode.NetworkAuthenticationRequired;
return;
}
if (!UsersManager.GetUser(token).HasRoot(RootEnum.Manager))
{
Response.StatusCode = (int)HttpStatusCode.Forbidden;
return;
}
TestsManager.CreateTest(testData);
var assigningData = new TestAssigningData();
assigningData.ProgramId = testData.ProgramId;
assigningData.TestId = testData.TestId;
ProgramsManager.AssignTestToProgram(assigningData);
}
public async Task SimpleAuthTest()
{
var database = new Butterfly.Core.Database.Memory.MemoryDatabase();
//var database = new Butterfly.MySql.MySqlDatabase("Server=127.0.0.1;Uid=test;Pwd=test!123;Database=butterfly_auth_test");
await TruncateData(database);
await database.CreateFromResourceFileAsync(Assembly.GetExecutingAssembly(), "Butterfly.Core.Test.db.sql");
database.SetDefaultValue("id", tableName => Guid.NewGuid().ToString());
database.SetDefaultValue("created_at", tableName => DateTime.Now.ToUnixTimestamp());
database.SetDefaultValue("updated_at", tableName => DateTime.Now.ToUnixTimestamp());
database.AddInputPreprocessor(BaseDatabase.RemapTypeInputPreprocessor <DateTime>(dateTime => dateTime.ToUnixTimestamp()));
AuthManager authManager = new AuthManager(database, userTableRoleFieldName: null, onForgotPassword: user => {
logger.Debug($"onForgotPassword():user={user}");
return(Task.FromResult(0));
});
UserRefToken registerAuthToken = await authManager.RegisterAsync(new {
username = "******",
first_name = "John",
last_name = "Smith",
email = "*****@*****.**",
phone = "+13162105368",
password = "******"
});
if (database.CanJoin)
{
AuthToken authToken = await authManager.AuthenticateAsync(UserRefTokenAuthenticator.AUTH_TYPE, registerAuthToken.id);
}
await authManager.ForgotPasswordAsync("johnsmith");
//await Task.Delay(30000);
}
public override void BlockInteraction(Vector3i pos, Quaternion rot, VehicleComponent vehicle, Inventory inv = null)
{
foreach (var offset in area)
{
var targetPos = (rot.RotateVector(offset) + pos).XYZi;
Result authResult = AuthManager.IsAuthorized(targetPos, vehicle.Driver.User);
if (authResult.Success)
{
var plant = PlantBlock.GetPlant(targetPos);
if (!(plant is IHarvestable))
{
continue;
}
if (plant.Alive)
{
((IHarvestable)plant).TryHarvest(vehicle.Driver, false, inv);
}
else
{
World.DeleteBlock(targetPos);
}
}
}
}
public async Task <ActionResult> SignIn(LoginViewModel login, String ReturnUrl)
{
AppUser usr = UserManager.Find(login.UserName, login.Password);
if (usr == null || login.UserName == null || login.Password == null)
{
ModelState.AddModelError("Error", "Логин или пароль неправильные");
return(View());
}
ClaimsIdentity ident = await UserManager.CreateIdentityAsync(usr, DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut();
AuthManager.SignIn(new AuthenticationProperties
{
IsPersistent = false
}, ident);
if (Url.IsLocalUrl(ReturnUrl))
{
return(Redirect(ReturnUrl));
}
return(RedirectToAction("Index", "Main"));
}
void Awake()
{
Instance = this;
FirebaseApp.CheckAndFixDependenciesAsync().ContinueWith(task =>
{
dependencyStatus = task.Result;
if (dependencyStatus == DependencyStatus.Available)
{
InitializeFirebase();
}
else
{
Debug.LogError("Could not resolve all Firebase dependencies: " + dependencyStatus);
}
});
if (!FB.IsInitialized)
{
FB.Init(InitCallback, null);
}
else
{
FB.ActivateApp();
}
}
/// <summary>
/// 派生类里需要重载
/// </summary>
/// <param name="Message"></param>
/// <returns></returns>
public virtual object InvokeMessage(YqunMessage Message)
{
object ReturnValue = null;
bool haveAuth = AuthManager.GetFunctionAuth(BizID, Message.TypeFlag);
if (!haveAuth)
{
try
{
switch (Message.TypeFlag.ToUpper())
{
default:
break;
}
return(ReturnValue);
}
catch
{ }
}
return(ReturnValue);
}
public async Task <ActionResult> Login(LoginModel details, string returnUrl)
{
if (ModelState.IsValid)
{
AppUser user = await UserManager.FindAsync(details.UserName, details.Password);
if (user == null)
{
ModelState.AddModelError("", "Invalid name or password.");
}
else
{
ClaimsIdentity ident = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut();
AuthManager.SignIn(new AuthenticationProperties
{
IsPersistent = false
}, ident);
return(Redirect(returnUrl));
}
}
return(View());
}
// GET: Users/Edit/5
public ActionResult Edit(int?id)
{
if (ViewBag.ShowError == null)
{
ViewBag.ShowError = false;
}
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
User user = repo.GetById(id.Value);
var authentication = AuthManager.GetAuthenticated();
if (authentication == null || authentication.Id != user.Id)
{
return(RedirectToAction("Details/" + user.Id, "Users"));
}
if (user == null)
{
return(HttpNotFound());
}
return(View(user));
}
public async Task <ActionResult> IzmeniProfil(AccountModifyModel model)
{
if (ModelState.IsValid)
{
AppUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.UserName = model.UserName;
if (model.NewProfilePicture != null)
{
user.ProfilePicture = model.NewProfilePicture.ToByteArray();
}
var updateResult = await UserManager.UpdateAsync(user);
var emailUpdateResult = await UserManager.SetEmailAsync(user.Id, model.Email);
if (updateResult.Succeeded && emailUpdateResult.Succeeded)
{
AuthManager.SignOut();
await SignInManager.SignInAsync(user, isPersistent : true, rememberBrowser : false);
TempData["Success"] = "Izmene uspesno sacuvane!";
return(RedirectToAction("IzmeniProfil"));
}
AddErrorsFromResult(string.Empty, updateResult, emailUpdateResult);
}
ModelState.AddModelError(string.Empty, "Doslo je do greske, pokušajte ponovo.");
}
return(View(model));
}
public async Task <ActionResult> ObrisiNalog(string userId)
{
AppUser user = await UserManager.FindByIdAsync(userId);
if (user != null)
{
var result = await UserManager.DeleteAsync(user);
if (result.Succeeded)
{
if (User.Identity.GetUserId().Equals(user.Id))
{
// Ako korisnik brise svoj nalog, odjavi ga
AuthManager.SignOut();
return(Redirect("/"));
}
return(RedirectToAction("Nalozi"));
}
// Brisanje nije uspelo, ispisi greske
AddErrorsFromResult("AccountDeleteValidation", result);
}
TempData["accNotFoundError"] = "Greska! Pokušajte kasnije.";
return(RedirectToAction("IzmeniProfil", new { userId }));
}
public async Task <ActionResult> Login(LoginViewModel details, string returnUrl)
{
AppUser user = await UserManager.FindAsync(details.Name, details.Password);
if (user == null)
{
ModelState.AddModelError("", "Неправильные логин или пароль");
}
else
{
ClaimsIdentity ident = await UserManager.CreateIdentityAsync(user,
DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut();
AuthManager.SignIn(new AuthenticationProperties
{
IsPersistent = false
}, ident);
return(Redirect(returnUrl));
}
return(View(details));
}
private void Checkdb()
{
string uid = AuthManager.Instance.auth.CurrentUser.UserId;
Logger.Log("Check user in Database", this);
result = ProcessResult.Running;
QDataManager.Instance.UserExists(uid, (bool exists) =>
{
if (!exists)
{
Logger.Log("User not found in database, Uploading...", this, true);
QDataManager.Instance.RegisterPlayerToDatabase(new UserPlayer(uid), () =>
{
Logger.Log("Upload user to database completed!", this, true);
AuthManager.FinishProcess();
result = ProcessResult.Completed;
}, (System.Exception ex) =>
{
_ex = ex;
AuthManager.FinishProcess();
result = ProcessResult.Failure;
});
}
else
{
Logger.Log("User already exists in database, continue without changes", this, true);
AuthManager.FinishProcess();
result = ProcessResult.Completed;
}
}, (System.Exception ex) =>
{
AuthManager.FinishProcess();
_ex = ex;
result = ProcessResult.Failure;
});
}
public ActionResult Login(LoginViewModel details, string returnUrl)
{
if (ModelState.IsValid)
{
Usuario user = UserManager.Find(details.Nome, details.Senha);
if (user == null)
{
ModelState.AddModelError("", "Nome ou senha inválido(s).");
}
else
{
ClaimsIdentity ident = UserManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut();
AuthManager.SignIn(new AuthenticationProperties {
IsPersistent = false
}, ident);
Session["UserId"] = ident.GetUserId();
return(RedirectToAction("Index", "../Cadastros/Eventos"));
}
}
return(View(details));
}
public ActionResult Index()
{
User currentUser = AuthManager.GetAuthenticated();
ViewBag.IsLogged = currentUser != null;
if (currentUser != null)
{
List <Picture> list = new List <Picture>();
var picturesToShow = db.Users.Find(currentUser.Id).Following.Select(f => f.Pictures);
foreach (var userPictures in picturesToShow)
{
foreach (var picture in userPictures)
{
list.Add(picture);
}
}
list = list.OrderByDescending(p => p.UploadDate).ToList();
return(View(list));
}
else
{
return(View());
}
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl = "~/")
{
if (ModelState.IsValid)
{
ClaimsIdentity identity = await _service.CreateIdentity(model);
if (identity == null)
{
ModelState.AddModelError("", "ユーザー名やパスワードが一致しません");
}
else
{
AuthManager.SignOut();
AuthManager.SignIn(new AuthenticationProperties
{
IsPersistent = model.RememberMe
}, identity);
return(Redirect(returnUrl));
}
}
ViewBag.returnUrl = returnUrl;
return(View(model));
}
public AuthController(IConfiguration conf, IKullaniciService kullaniciService)
{
authManager = new AuthManager(conf);
_kullaniciService = kullaniciService;
}
private Authentication Authentication(AuthManager authManager, UserManagerSupplier userManagerSupplier)
{
return(new BasicAuthentication(authManager, userManagerSupplier));
}
public AuthController()
{
authManager = new AuthManager();
}
public AuthController()
{
_authManager = new AuthManager();
}
public AuthFailedMessage (AuthManager manager, Reason reason, Exception ex = null) : base (manager)
{
this.reason = reason;
this.exception = ex;
}
private void SendAuthMessage (AuthChangeReason reason)
{
var authManager = new AuthManager ();
ServiceContainer.Register<AuthManager> (authManager);
MessageBus.Send (new AuthChangedMessage (authManager, reason));
}
public void RunApplication()
{
bool stopRun = false;
LicenseHelper.Register();
AppProfileManager.Instance.InitApplication(AppTypeEnum.PrintSchedule);
FileStorageManager.Instance.UsingLocalMode += (o, e) =>
{
if (FileStorageManager.Instance.UseLocalMode) return;
FormStart.CloseProgress();
if (FileStorageManager.Instance.DataState != DataActualityState.Updated)
{
Utilities.Instance.ShowWarning("Server is not available. Application will be closed");
stopRun = true;
Application.Exit();
return;
}
if (Utilities.Instance.ShowWarningQuestion("Server is not available. Do you want to continue to work in local mode?") != DialogResult.Yes)
{
stopRun = true;
Application.Exit();
}
};
FileStorageManager.Instance.Authorizing += (o, e) =>
{
var authManager = new AuthManager();
authManager.Init();
FormStart.SetTitle("Checking credentials...", "*This should not take long…");
authManager.Auth(e);
};
FormStart.ShowProgress();
FormStart.SetTitle("Connecting to adSALEScloud…", "*This should not take long…");
var thread = new Thread(() => AsyncHelper.RunSync(FileStorageManager.Instance.Init));
thread.Start();
while (thread.IsAlive)
Application.DoEvents();
if (stopRun) return;
FileStorageManager.Instance.Downloading += (sender, args) =>
FormStart.SetDetails(args.ProgressPercent < 100 ?
String.Format("Loading {0} - {1}%", args.FileName, args.ProgressPercent) :
String.Empty);
FileStorageManager.Instance.Extracting += (sender, args) =>
FormStart.SetDetails(args.ProgressPercent < 100 ?
String.Format("Extracting {0} - {1}%", args.FileName, args.ProgressPercent) :
String.Empty);
if (FileStorageManager.Instance.Activated)
{
if (FileStorageManager.Instance.DataState == DataActualityState.NotExisted)
FormStart.SetTitle("Syncing adSALEScloud for the 1st time…", "*This may take a few minutes…");
else if (FileStorageManager.Instance.DataState == DataActualityState.Outdated)
FormStart.SetTitle("Refreshing data from adSALEScloud…", "*This may take a few minutes…");
else
FormStart.SetTitle("Loading application data...", "*This should not take long…");
thread = new Thread(() =>
{
AsyncHelper.RunSync(() => Controls.Controller.Instance.InitBusinessObjects());
FileStorageManager.Instance.DataState = DataActualityState.Updated;
});
thread.Start();
while (thread.IsAlive)
Application.DoEvents();
FormMain.Instance.Init();
}
FormStart.CloseProgress();
if (FileStorageManager.Instance.Activated)
{
if (PowerPointManager.Instance.SettingsSource == SettingsSourceEnum.PowerPoint &&
MasterWizardManager.Instance.SelectedWizard != null &&
!MasterWizardManager.Instance.SelectedWizard.HasSlideConfiguration(PowerPointManager.Instance.SlideSettings))
{
var availableMasterWizards = MasterWizardManager.Instance.MasterWizards.Values.Where(w => w.HasSlideConfiguration(PowerPointManager.Instance.SlideSettings)).ToList();
if (availableMasterWizards.Any())
{
using (var form = new FormSelectMasterWizard())
{
form.comboBoxEditSlideFormat.Properties.Items.AddRange(availableMasterWizards);
form.comboBoxEditSlideFormat.EditValue = availableMasterWizards.FirstOrDefault();
if (form.ShowDialog() != DialogResult.OK)
return;
SettingsManager.Instance.SelectedWizard = ((MasterWizard)form.comboBoxEditSlideFormat.EditValue).Name;
MasterWizardManager.Instance.SetMasterWizard();
}
}
else
{
Utilities.Instance.ShowWarning("Slide pack not found for selected size. Contact adSALESapps Support ([email protected])");
return;
}
}
Application.Run(FormMain.Instance);
}
else
Utilities.Instance.ShowWarning("This app is not activated. Contact adSALESapps Support ([email protected])");
}
public AuthChangedMessage (AuthManager manager, AuthChangeReason reason) : base (manager)
{
this.reason = reason;
}
public AuthChangedMessage (AuthManager manager) : base (manager)
{
}
/// <summary>
/// Class Constructor. Set the local properties
/// </summary>
/// <param name="db">Receive the gAppDbContext instance from the ASP.Net Pipeline</param>
/// <param name="sm)">Receive the SignInManager instance from the ASP.Net Pipeline</param>
/// <param name="um)">Receive the UserManager instance from the ASP.Net Pipeline</param>
public AuthenticationController(gAppDbContext db, AuthManager <gUser> sm, UserManager <gUser> um)
{
DbContext = db;
authManager = sm;
UserManager = um;
}
//инициализация
public CommentsController(CustomContentManager contentManager, AuthManager authManager)
: base(contentManager)
{
_postManager = contentManager;
_authManager = authManager;
}
public AuthFailedMessage (AuthManager manager, AuthResult result, Exception ex = null) : base (manager)
{
this.result = result;
exception = ex;
}
private void AddUserButton_Click(object sender, EventArgs e)
{
AddUserButton.Enabled = false;
UsernameTextBox.Enabled = false;
PasswordTextBox.Enabled = false;
YesNoToggleSwitch.Enabled = false;
ControlBox = false;
AddUserButton.Text = _configuration.Localization.PleaseWait;
BackgroundWorker bgw = new BackgroundWorker();
bgw.DoWork += delegate
{
User user = new User
{
Username = UsernameTextBox.Text
};
if (!YesNoToggleSwitch.Value)
{
user.Type = "offline";
if (_userManager.Accounts.ContainsKey(user.Username))
{
_userManager.Accounts[user.Username] = user;
}
else
{
_userManager.Accounts.Add(user.Username, user);
}
_userManager.SelectedUsername = user.Username;
SaveUsers();
UpdateUsers();
return;
}
AuthManager auth = new AuthManager
{
Email = UsernameTextBox.Text,
Password = PasswordTextBox.Text
};
try
{
auth.Login();
user.Type = auth.IsLegacy ? "legacy" : "mojang";
user.AccessToken = auth.AccessToken;
user.ClientToken = auth.ClientToken;
user.Uuid = auth.Uuid;
user.UserProperties = auth.UserProperties;
if (_userManager.Accounts.ContainsKey(user.Username))
{
_userManager.Accounts[user.Username] = user;
}
else
{
_userManager.Accounts.Add(user.Username, user);
}
_userManager.SelectedUsername = user.Username;
}
catch (WebException ex)
{
if (ex.Status != WebExceptionStatus.ProtocolError)
{
return;
}
RadMessageBox.Show(_configuration.Localization.IncorrectLoginOrPassword,
_configuration.Localization.Error, MessageBoxButtons.OK,
RadMessageIcon.Error);
return;
}
Invoke(new Action(() =>
{
SaveUsers();
UpdateUsers();
UsernameTextBox.Clear();
PasswordTextBox.Clear();
}));
};
bgw.RunWorkerCompleted += delegate
{
UsernameTextBox.Enabled = true;
YesNoToggleSwitch.Enabled = true;
ControlBox = true;
AddUserButton.Text = _configuration.Localization.AddNewUserButton;
YesNoToggleSwitch_ValueChanged(this, EventArgs.Empty);
};
bgw.RunWorkerAsync();
}
public ActionResult Logout()
{
AuthManager.SignOut();
return(Redirect("/Home"));
}
/// <summary>
/// 查询用户操作行为
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public DataPack <ResponseBehaviorStat> Query(RequestQueryBehaviorStatQuery query)
{
string carriercode = AuthManager.GetCurrentUser().Code;
var contactName = AuthManager.GetCurrentUser().ContactName;
var isAdmin = AuthManager.GetCurrentUser().IsAdmin;
int pSize = query.PageSize ?? 10;
int count = ((query.PageIndex == default(int) ? 1 : query.PageIndex) - 1) * pSize;
var result = behaviorStatRepository.FindAll();
if (!string.IsNullOrEmpty(carriercode))
{
result = result.Where(p => p.CarrierCode.ToLower().Equals(carriercode.ToLower()));
}
if (!string.IsNullOrEmpty(query.BusinessmanCode))
{
result = result.Where(p => p.BusinessmanCode.ToLower().Equals(query.BusinessmanCode.ToLower()));
}
if (!string.IsNullOrEmpty(query.BusinessmanName))
{
result = result.Where(p => p.BusinessmanName.ToLower().Contains(query.BusinessmanName.ToLower()));
}
if (!string.IsNullOrEmpty(query.BusinessmanType))
{
result = result.Where(p => p.BusinessmanType.ToLower().Equals(query.BusinessmanType.ToLower()));
}
if (!isAdmin && !string.IsNullOrEmpty(contactName))
{
result = result.Where(p => p.ContactName.ToLower().Equals(contactName.ToLower()));
}
if (query.StartDateTime != null)
{
var date = query.StartDateTime.Value.Date;
result = result.Where(p => p.OpDateTime >= date);
}
if (query.EndDateTime != null)
{
var date = query.EndDateTime.Value.Date.AddDays(1).AddSeconds(-1);
result = result.Where(p => p.OpDateTime <= date);
}
var res = ProcessBehaviorStatsToResponseBehaviorStats(result);
if (string.IsNullOrWhiteSpace(query.Sort) || string.IsNullOrWhiteSpace(query.Order))
{
res = res.OrderByDescending(p => p.OutTicketCount).ToList();
}
else
{
if (query.Order == "desc")
{
switch (query.Sort)
{
case "LoginCount":
res = res.OrderByDescending(p => p.LoginCount).ToList();
break;
case "QueryCount":
res = res.OrderByDescending(p => p.QueryCount).ToList();
break;
case "ImportCount":
res = res.OrderByDescending(p => p.ImportCount).ToList();
break;
case "OutTicketCount":
res = res.OrderByDescending(p => p.OutTicketCount).ToList();
break;
case "BackTicketCount":
res = res.OrderByDescending(p => p.BackTicketCount).ToList();
break;
case "AbolishTicketCount":
res = res.OrderByDescending(p => p.AbolishTicketCount).ToList();
break;
case "AccessCount":
res = res.OrderByDescending(p => p.AccessCount).ToList();
break;
case "FinancingCount":
res = res.OrderByDescending(p => p.FinancingCount).ToList();
break;
case "UseCount":
res = res.OrderByDescending(p => p.UseCount).ToList();
break;
default:
res = res.OrderByDescending(p => p.OutTicketCount).ToList();
break;
}
}
else
{
switch (query.Sort)
{
case "LoginCount":
res = res.OrderBy(p => p.LoginCount).ToList();
break;
case "QueryCount":
res = res.OrderBy(p => p.QueryCount).ToList();
break;
case "ImportCount":
res = res.OrderBy(p => p.ImportCount).ToList();
break;
case "OutTicketCount":
res = res.OrderBy(p => p.OutTicketCount).ToList();
break;
case "BackTicketCount":
res = res.OrderBy(p => p.BackTicketCount).ToList();
break;
case "AbolishTicketCount":
res = res.OrderBy(p => p.AbolishTicketCount).ToList();
break;
case "AccessCount":
res = res.OrderBy(p => p.AccessCount).ToList();
break;
case "FinancingCount":
res = res.OrderBy(p => p.FinancingCount).ToList();
break;
case "UseCount":
res = res.OrderBy(p => p.UseCount).ToList();
break;
default:
res = res.OrderBy(p => p.OutTicketCount).ToList();
break;
}
}
}
var totalCount = res.Count();
res = res.Skip(count).Take(pSize).ToList();
var dataPack = new DataPack <ResponseBehaviorStat>();
dataPack.TotalCount = totalCount;
dataPack.List = res;
return(dataPack);
}
protected override void OnCreateActivity (Bundle state)
{
base.OnCreateActivity (state);
SetContentView (Resource.Layout.MainDrawerActivity);
MainToolbar = FindViewById<Toolbar> (Resource.Id.MainToolbar);
DrawerListView = FindViewById<ListView> (Resource.Id.DrawerListView);
DrawerUserView = LayoutInflater.Inflate (Resource.Layout.MainDrawerListHeader, null);
DrawerUserName = DrawerUserView.FindViewById<TextView> (Resource.Id.TitleTextView);
DrawerEmail = DrawerUserView.FindViewById<TextView> (Resource.Id.EmailTextView);
DrawerImage = DrawerUserView.FindViewById<ProfileImageView> (Resource.Id.IconProfileImageView);
if (!ServiceContainer.Resolve<AuthManager>().OfflineMode) {
DrawerListView.AddHeaderView (DrawerUserView);
}
DrawerListView.Adapter = drawerAdapter = new DrawerListAdapter ();
DrawerListView.ItemClick += OnDrawerListViewItemClick;
authManager = ServiceContainer.Resolve<AuthManager> ();
authManager.PropertyChanged += OnUserChangedEvent;
DrawerLayout = FindViewById<DrawerLayout> (Resource.Id.DrawerLayout);
DrawerToggle = new ActionBarDrawerToggle (this, DrawerLayout, MainToolbar, Resource.String.EntryName, Resource.String.EntryName);
DrawerLayout.SetDrawerShadow (Resource.Drawable.drawershadow, (int)GravityFlags.Start);
DrawerLayout.SetDrawerListener (DrawerToggle);
var drawerFrameLayout = FindViewById<FrameLayout> (Resource.Id.DrawerFrameLayout);
drawerFrameLayout.Touch += (sender, e) => {
// Do nothing, just absorb the event
// TODO: Improve this dirty solution?
};
Timer.OnCreate (this);
var lp = new Android.Support.V7.App.ActionBar.LayoutParams (ViewGroup.LayoutParams.MatchParent, ViewGroup.LayoutParams.MatchParent, (int)GravityFlags.Right);
MainToolbar.SetNavigationIcon (Resource.Drawable.ic_menu_black_24dp);
SetSupportActionBar (MainToolbar);
SupportActionBar.SetTitle (Resource.String.MainDrawerTimer);
SupportActionBar.SetCustomView (Timer.Root, lp);
SupportActionBar.SetDisplayShowCustomEnabled (true);
if (state == null) {
OpenPage (DrawerListAdapter.TimerPageId);
} else {
// Restore page stack
pageStack.Clear ();
var arr = state.GetIntArray (PageStackExtra);
if (arr != null) {
pageStack.AddRange (arr);
}
}
// Make sure that the user will see newest data when they start the activity
ServiceContainer.Resolve<ISyncManager> ().Run ();
}
