public void TestLogin2()
{
// 测试多个客服端用同一个客服帐号登录
LiveSupport.LiveSupportDAL.SqlProviders.DBHelper.ConnectionString = "Server=rd01;Database=LiveSupport;User ID=sa;Password=;Trusted_Connection=False;";
Account a = new Account();
a.LoginName = Util.RandLetter(10);
a.Password = "******";
AccountsManager.AddAccount(a);
Operator op = OperatorService.Login(a.LoginName, a.LoginName, a.Password);
Assert.AreEqual(a.AccountId, op.OperatorId);
Assert.AreEqual(op.LoginName, a.LoginName);
Account ac = AccountService.FindAccountByLoginName(a.LoginName);
Assert.AreEqual(op.AccountId, ac.AccountId);
Assert.AreEqual(op.Password, a.Password);
Assert.AreEqual(op.Status, OperatorStatus.Idle);
Operator op2 = OperatorService.Login(a.LoginName, a.LoginName, a.Password);
Assert.IsNull(op2);
OperatorService.Logout(op.OperatorId);
op = OperatorService.Login(a.LoginName, a.LoginName, a.Password);
Assert.IsNotNull(op);
}
public static async Task <AccountDataItem> CreateAccountLocally(string username, string localToken, string token, long accountId, int deviceId, bool needsInitialSync)
{
try
{
AccountDataItem account = account = await AccountsManager.CreateAccount(username, localToken, token, accountId, deviceId, true, true, true, needsInitialSync);
return(account);
}
catch (AccountsManager.UsernameExistsLocallyException)
{
AlertUsernameExistsLocally?.Invoke();
}
catch (AccountsManager.UsernameInvalidException)
{
AlertInvalidUsername?.Invoke();
}
catch (AccountsManager.UsernameWasEmptyException)
{
AlertUsernameEmpty?.Invoke();
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex, "UnknownCreateAccountLocallyError");
ShowMessage("Unknown error occurred. Your error has been sent to the developer.\n\n" + ex.ToString(), "Error");
}
return(null);
}
protected override async Task PerformWorkAsync(JobParameters @params)
{
long accountId = @params.Extras.GetLong("AccountId");
if (accountId == 0)
{
return;
}
// First try to grab cached
var account = AccountsManager.GetCurrentlyLoadedAccounts().FirstOrDefault(i => i.AccountId == accountId);
if (account == null)
{
account = (await AccountsManager.GetAllAccounts()).FirstOrDefault(i => i.AccountId == accountId);
}
if (account == null)
{
return;
}
var syncResult = await Sync.SyncAccountAsync(account);
if (syncResult != null && syncResult.SaveChangesTask != null)
{
await syncResult.SaveChangesTask.WaitForAllTasksAsync();
}
}
//添加
protected void ImageButton1_Click(object sender, ImageClickEventArgs e)
{
if (this.txtDepartmentName.Text == "")
{
ClientScript.RegisterStartupScript(this.GetType(), "Error", "<script>alert('部门不能为空');</script>");
return;
}
Department dep = new Department();
dep.DepartmentId = Guid.NewGuid().ToString();
dep.DepartmentName = this.txtDepartmentName.Text;
dep.Account = AccountsManager.GetAccountByAccountId(oepr.Account.AccountId);
dep.IsDefault = false;
dep.AddDate = DateTime.Now.ToString();
bool b = DepartmentManager.AddDepartment(dep);
if (b)
{
ClientScript.RegisterStartupScript(this.GetType(), "Error", "<script>alert('添加成功'); window.location='DepartmentManager.aspx';</script>");
return;
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "Error", "<script>alert('已经存在此部门');</script>");
return;
}
}
private async Task HandleViewTaskOrEventActivation(Guid localAccountId, Guid itemId)
{
if (CurrentAccount == null || CurrentAccount.LocalAccountId != localAccountId)
{
AccountsManager.SetLastLoginIdentifier(localAccountId);
await HandleNormalLaunchActivation();
}
var mainScreen = GetMainScreenViewModel();
if (mainScreen != null && mainScreen.CurrentAccount != null)
{
Popups.Clear();
var singleExam = await SingleTaskOrEventViewItemsGroup.LoadAsync(localAccountId, itemId);
if (singleExam != null && singleExam.Item != null)
{
mainScreen.ShowItem(singleExam.Item);
// Remove all but latest popup
// Have to do this AFTER showing the popup since on iOS if we first clear and then show immediately, iOS freaks out
while (mainScreen.Popups.Count > 1)
{
mainScreen.Popups.RemoveAt(0);
}
}
}
}
private async void SaveAndUpdate()
{
try
{
base.IsEnabled = false;
Debug.WriteLine("Tasks calendar integration settings changed, saving...");
await AccountsManager.Save(Account);
Debug.WriteLine("Tasks calendar integration settings changed, saved.");
if (AppointmentsExtension.Current != null)
{
AppointmentsExtension.Current.ResetAll(Account, await AccountDataStore.Get(Account.LocalAccountId));
// Wait for the calendar integration to complete
await AppointmentsExtension.Current.GetTaskForAllCompleted();
}
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
finally
{
base.IsEnabled = true;
}
}
public ChangePasswordController(AccountsManager accountsManager,
IMapper mapper, UsersManager usersManager)
{
_accountsManager = accountsManager;
_mapper = mapper;
_usersManager = usersManager;
}
public async void Initialize(SemesterItemsViewGroup itemsSource, DateTime currentDate)
{
_itemsSource = itemsSource;
// Unwire events from old one
var prevAdapter = _viewPager.Adapter as DayPagerAdapter;
if (prevAdapter != null)
{
prevAdapter.ItemClick -= Adapter_ItemClick;
prevAdapter.HolidayItemClick -= Adapter_HolidayItemClick;
prevAdapter.ScheduleItemClick -= Adapter_ScheduleItemClick;
prevAdapter.ScheduleClick -= Adapter_ScheduleClick;
}
var account = await AccountsManager.GetOrLoad(itemsSource.LocalAccountId);
var adapter = new DayPagerAdapter(account, itemsSource, currentDate);
adapter.ItemClick += Adapter_ItemClick;
adapter.HolidayItemClick += Adapter_HolidayItemClick;
adapter.ScheduleItemClick += Adapter_ScheduleItemClick;
adapter.ScheduleClick += Adapter_ScheduleClick;
_viewPager.Adapter = adapter;
_viewPager.SetCurrentItem(1000, false);
}
private async Task <List <AccountDataItem> > GetAllAccounts()
{
return(await System.Threading.Tasks.Task.Run(async delegate
{
return await AccountsManager.GetAllAccounts();
}));
}
/// <summary>
/// Used for syncing from background task (raw push notification).
/// </summary>
/// <param name="accountId"></param>
/// <returns></returns>
public static async System.Threading.Tasks.Task SyncAccountInBackgroundAsync(long accountId)
{
try
{
if (accountId == 0)
{
return;
}
// First try to grab cached
var account = AccountsManager.GetCurrentlyLoadedAccounts().FirstOrDefault(i => i.AccountId == accountId);
if (account == null)
{
account = (await AccountsManager.GetAllAccounts()).FirstOrDefault(i => i.AccountId == accountId);
}
if (account == null)
{
return;
}
var syncResult = await Sync.SyncAccountAsync(account);
if (syncResult != null && syncResult.SaveChangesTask != null)
{
await syncResult.SaveChangesTask.WaitForAllTasksAsync();
}
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
}
private async Task HandleSelectMenuItemActivation(Guid localAccountId, NavigationManager.MainMenuSelections menuItem)
{
// If we already have a current account and it matches the specified (or unspecified) account ID
if (CurrentAccount != null && (localAccountId == Guid.Empty || CurrentAccount.LocalAccountId == localAccountId))
{
var mainScreen = GetMainScreenViewModel();
if (mainScreen != null)
{
Popups.Clear();
mainScreen.Popups.Clear();
if (mainScreen.AvailableItems.Contains(menuItem))
{
mainScreen.SelectedItem = menuItem;
}
}
}
// Otherwise it's a fresh boot, or wrong account
else
{
if (localAccountId != Guid.Empty)
{
AccountsManager.SetLastLoginIdentifier(localAccountId);
}
NavigationManager.MainMenuSelection = menuItem;
await HandleNormalLaunchActivation();
}
}
private async Task HandleSelectMenuItemActivation(Guid localAccountId, NavigationManager.MainMenuSelections menuItem)
{
if (CurrentAccount != null && (localAccountId == Guid.Empty || CurrentAccount.LocalAccountId == localAccountId))
{
var mainScreen = GetMainScreenViewModel();
if (mainScreen != null)
{
Popups.Clear();
mainScreen.Popups.Clear();
if (mainScreen.AvailableItems.Contains(menuItem))
{
mainScreen.SelectedItem = menuItem;
}
}
}
else
{
if (localAccountId != Guid.Empty)
{
AccountsManager.SetLastLoginIdentifier(localAccountId);
}
NavigationManager.MainMenuSelection = menuItem;
await HandleNormalLaunchActivation();
}
}
private async void SaveAndUpdate()
{
try
{
base.IsEnabled = false;
await AccountsManager.Save(Account);
base.IsEnabled = true;
// Sync so that push channel gets uploaded/removed
await Sync.SyncAccountAsync(Account);
}
catch (OperationCanceledException) { }
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
finally
{
base.IsEnabled = true;
}
}
public static async System.Threading.Tasks.Task UpdatePrimaryTileNotificationsAsync()
{
try
{
await _updatePrimaryTileNotificationsWorkQueue.QueueOrMergeAsync(0, async delegate
{
await System.Threading.Tasks.Task.Run(async delegate
{
var account = await AccountsManager.GetLastLogin();
AccountDataStore data = null;
if (account != null)
{
data = await AccountDataStore.Get(account.LocalAccountId);
}
await UpdatePrimaryTileNotificationsBlocking(account, data);
});
});
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
Debug.WriteLine("Failed UpdatePrimaryTileNotificationsAsync");
}
}
//下一步
protected void ibtnXia_Click(object sender, ImageClickEventArgs e)
{
pageIndex++;
List <Account> list = AccountsManager.GetAllAccounts();
repAccounts(list);
}
//上一步
protected void ibtnShang_Click(object sender, ImageClickEventArgs e)
{
PageIndex--;
List <Account> list = AccountsManager.GetAllAccounts();
repAccounts(list);
}
public ActionResult SignIn(SignInModel model)
{
try
{
SignInResult result = AccountsManager.Authenticate(model.Username, model.Password);
if (result.Ok)
{
// Set the authentication cookie
FormsAuthentication.SetAuthCookie(result.Username, true);
}
else
{
return(CreateValidationError(result.Reason));
}
return(JsonOK());
}
catch (Exception ex)
{
EventLog.WriteEntry("Krypto", "An error occured while trying to sign-in: " + ex.Message);
return(CreateValidationError("Internal Server Error"));
}
}
public AccountsController(UsersManager usersManager, IMapper mapper, IConfiguration configuration, IMailService mailService, AccountsManager accountsManager)
{
_usersManager = usersManager;
_mapper = mapper;
_configuration = configuration;
_mailService = mailService;
_accountsManager = accountsManager;
}
public string GetAccountNameById(string id)
{
if (AccountsManager.GetAccountByAccountId(id) != null)
{
return(AccountsManager.GetAccountByAccountId(id).CompanyName);
}
return("");
}
public ActionResult Index()
{
IEnumerable <Account> acts = new EFGenericRepository <Account>(_context).Get();
IList <AccountVM> vms = new AccountsManager().GetVMs();
return(View("Index", vms));
}
public async Task Initialize()
{
AccountDataItem account = await AccountsManager.CreateAccount("andrewbares", "andrew", null, 0, 0, true, true, true, false);
LocalAccountId = account.LocalAccountId;
await InitializeAfterAccount();
}
public AccountsManager GetAccountsManager()
{
if (mAccountsManager == null)
{
mAccountsManager = new AccountsManager(mRESTClient, mSerializer, "accounts");
}
return mAccountsManager;
}
public AccountsManager GetAccountsManager()
{
if (mAccountsManager == null)
{
mAccountsManager = new AccountsManager(mRESTClient, mSerializer, "accounts");
}
return(mAccountsManager);
}
public async void AccountsManager_GetAccountAsync_NotNull()
{
var sut = new AccountsManager(_mockLog.Object, _mqPublisher.Object, _accountRepository.Object, _accountEntityService.Object);
var retVal = await sut.GetAccountAsync("TEST");
Assert.NotNull(retVal);
}
private static async Task UpdateTileNotificationsBlocking(AccountDataItem account, AccountDataStore data)
{
// If it's the main account, update primary tile
if (account.LocalAccountId == AccountsManager.GetLastLoginLocalId())
{
await UpdatePrimaryTileNotificationsBlocking(account, data);
}
}
public async void AccountsManager_SaveAccountAsync_DoesntFail()
{
var sut = new AccountsManager(_mockLog.Object, _mqPublisher.Object, _accountRepository.Object, _accountEntityService.Object);
await sut.SaveAccountAsync(new Account(new AccountData()));
// Assert.NotNull(retVal);
}
public async void AccountsManager_GetAccountsAsync_IsEmpty()
{
var sut = new AccountsManager(_mockLog.Object, _mqPublisher.Object, _accountRepository.Object, _accountEntityService.Object);
var retVal = await sut.GetAccountsAsync();
Assert.True(retVal.Count == 0);
}
public async void Handle(BackgroundActivatedEventArgs args)
{
var taskInstance = args.TaskInstance;
taskInstance.Canceled += TaskInstance_Canceled;
var deferral = taskInstance.GetDeferral();
try
{
RawNotification notification = (RawNotification)taskInstance.TriggerDetails;
long accountId = UWPPushExtension.GetAccountIdFromRawNotification(notification);
if (accountId == 0)
{
return;
}
AccountDataItem account = await AccountsManager.GetOrLoadOnlineAccount(accountId);
if (account == null)
{
return;
}
var cancellationToken = _cancellationTokenSource.Token;
try
{
cancellationToken.ThrowIfCancellationRequested();
var result = await Sync.SyncAccountAsync(account);
// Need to wait for the tile/toast tasks to finish before we release the deferral
if (result != null && result.SaveChangesTask != null)
{
await result.SaveChangesTask.WaitForAllTasksAsync();
}
}
catch (OperationCanceledException) { }
// Wait for the calendar integration to complete
await AppointmentsExtension.Current?.GetTaskForAllCompleted();
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
finally
{
deferral.Complete();
}
}
private async System.Threading.Tasks.Task FinishCreateAccount(string username, string localToken, string token, long accountId, int deviceId, string email)
{
if (DefaultAccountToUpgrade != null)
{
if (DefaultAccountToUpgrade.IsOnlineAccount)
{
throw new Exception("Should be an offline account. This implies it got created but for some reason stayed on this page.");
}
DefaultAccountToUpgrade.Username = username;
DefaultAccountToUpgrade.LocalToken = localToken;
DefaultAccountToUpgrade.Token = token;
DefaultAccountToUpgrade.AccountId = accountId;
DefaultAccountToUpgrade.DeviceId = deviceId;
await AccountsManager.Save(DefaultAccountToUpgrade);
TelemetryExtension.Current?.TrackEvent("CreatedAccountFromDefault");
// Transfer the settings
try
{
await SavedGradeScalesManager.TransferToOnlineAccountAsync(DefaultAccountToUpgrade.LocalAccountId, DefaultAccountToUpgrade.AccountId);
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
// Make sure to update user info for telemetry
TelemetryExtension.Current?.UpdateCurrentUser(DefaultAccountToUpgrade);
// Remove this popup, and show a new one saying success!
// We have to show first before removing otherwise iOS never shows it
var parent = Parent;
parent.ShowPopup(new SuccessfullyCreatedAccountViewModel(parent)
{
Username = username,
Email = email
});
base.RemoveViewModel();
// Trigger a sync (without waiting) so all their content uploads
Sync.StartSyncAccount(DefaultAccountToUpgrade);
}
else
{
var account = await AccountsManager.CreateAndInitializeAccountAsync(username, localToken, token, accountId, deviceId);
if (account != null)
{
// Take us to the account
var dontWait = FindAncestor <MainWindowViewModel>().SetCurrentAccount(account);
}
}
}
public MainViewModel()
{
// Initialize Data layer
var fs = new MyAccounts.Business.IO.WindowsFileSystem();
var workingCopy = new WorkingCopy(fs, Properties.Settings.Default.WorkingFolder);
var accountsRepository = new AccountsRepository(workingCopy);
var accountCommandRepository = new AccountCommandRepository(workingCopy);
var placesRepository = new PlacesRepository();
var placeProvider = PlaceProvider.Load(placesRepository);
var placeInfoResolver = new PlaceInfoResolver(placeProvider);
var operationPatternTransformer = new UnifiedAccountOperationPatternTransformer(placeInfoResolver);
var operationsRepository = new OperationsRepository(workingCopy, new CsvAccountOperationManager(), operationPatternTransformer);
// Initialize Managers
var operationsManager = new OperationsManager(App.CacheManager, operationsRepository);
var accountsManager = new AccountsManager(App.CacheManager, accountsRepository);
var importManager = new ImportManager(App.CacheManager, accountCommandRepository, operationsManager);
// Initialize View Models
BusyIndicator = new BusyIndicatorViewModel();
ImportsManagerViewModel = new ImportsManagerViewModel(BusyIndicator, fs, importManager);
OperationsManagerViewModel = new OperationsManagerViewModel(BusyIndicator, operationsManager, importManager);
AccountsManagerViewModel = new AccountsManagerViewModel(BusyIndicator, accountsManager, operationsManager, importManager);
DashboardViewModel = new DashboardViewModel(BusyIndicator);
GmcManager = new GmcManager(BusyIndicator, App.CacheManager, operationsManager);
_settingsManager = new SettingsManager(App.CacheManager);
MessengerInstance.Register <Properties.Settings>(this, OnSettingsUpdated);
_asyncMessageReceiver = new AsyncMessageReceiver(MessengerInstance);
_asyncMessageReceiver.RegisterAsync <AccountDataInvalidated>(this, data => Refresh());
if (!IsInDesignMode)
{
LoadCommand = new AsyncCommand(Load);
RefreshCommand = new AsyncCommand(Refresh);
}
else
{
AccountsManagerViewModel.Accounts.Add(
new AccountViewModel
{
Name = "Blaise CC",
Status =
{
Operations = 7,
Balance = 2541.7345M,
LastImportedOperation = "2012-0001"
}
});
AccountsManagerViewModel.CurrentAccount = AccountsManagerViewModel.Accounts.First();
}
}
private async void OnAddAccountCommand()
{
Debug.WriteLine("Stating the oauth login flow.");
if (await AccountsManager.StartAddAccountFlowAsync())
{
EventsReporterWrapper.ReportEvent(NewLoginEvent.Create());
Debug.WriteLine($"The user logged in: {CredentialsStore.Default.CurrentAccount.AccountName}");
_owner.Close();
}
}
private static bool CheckPlayerStatus(Candidate c)
{
List<string>[] playerInfo;
string ipAddress = ((IPEndPoint)c.socket.RemoteEndPoint).Address.ToString();
if (!Database.Instance.SelectPlayerData(out playerInfo, c.loginName))
{
AppendLog("Couldn't connect with database for: " + ipAddress + ". Rejecting...");
SendClient_AlertMsg(c.socket, "Unexpected loss of connection, try again in a minute!", true);
KillClientSocket(c);
return false;
}
if (playerInfo[0].Count == 0)
{
AppendLog("->" + c.loginName + "<-(" + ipAddress + ") doesn't exist in the database. Rejecting...");
SendClient_AlertMsg(c.socket, "Sorry, but it seems that you've entered an incorrect login or password. Please try again!", true);
KillClientSocket(c);
return false;
}
PlayerDBInfo pInfo = new PlayerDBInfo(playerInfo[0][0], playerInfo[1][0], playerInfo[2][0], playerInfo[3][0]);
if (!CheckPassword(pInfo, c.password))
{
AppendLog("Wrong password for: " + c.loginName + "/" + ipAddress + ". Rejecting...");
SendClient_AlertMsg(c.socket, "Sorry, you've entered incorrect login or password. Please try again!", true);
KillClientSocket(c);
return false;
}
if (!CheckValidating(pInfo))
{
AppendLog("Account is not verified for: " + c.loginName + "/" + ipAddress + ". Rejecting...");
SendClient_AlertMsg(c.socket, "Please validate your account, by confirming your email address!", true);
KillClientSocket(c);
return false;
}
//Load Player, to synchronize his status - gold silver admin.
PreloadPlayer(c, pInfo);
if (!CheckAdmin(pInfo, c))
{
SendClient_AlertMsg(c.socket, "Sorry, but the server is only available to staff members at the moment.", true);
AppendLog(c.loginName + "/" + ipAddress + " isn't an Admin. Rejecting...");
KillClientSocket(c);
return false;
}
if (!CheckSubscription(pInfo, c))
{
SendClient_AlertMsg(c.socket, "Sorry, but the server is only available to Gold or Silver Shinobi at the moment.", true);
AppendLog(c.loginName + "/" + ipAddress + " isn't a Donor" +
"" +
". Rejecting...");
KillClientSocket(c);
return false;
}
//No more checks, it's seems player can join the server.
AccountsManager file = new AccountsManager(_form);
file.SavePlayer(c.loginName, ref c.player);
file.SavePlayerBank(c.loginName, ref c.playerBank);
if (!SendClient_ServerDetails(c))
{
SendClient_AlertMsg(c.socket, "Server is down, try again in a minute!", true);
AppendLog(c.loginName + "/" + ipAddress + " rejected -> no available servers");
KillClientSocket(c);
}
return true;
}
private static void PreloadPlayer(Candidate c, PlayerDBInfo pInfo)
{
c.player = new Player(0);
var file = new AccountsManager(_form);
if (!file.LoadPlayer(c.loginName, ref c.player))
{
for (int i = 0; i < Constants.MAX_PLAYER_FRIENDS; i++)
{
c.player.friends[i].name = new string(' ', Constants.PLAYER_NAME_LENGTH); //<--- max display name length on the forum.
}
}
c.player.PlayerName = pInfo.charName;
c.playerBank = new Bank(0);
file.LoadPlayerBank(c.loginName, ref c.playerBank);
}
