public void GetByUnitName_ReturnsGeneralSettings()
{
string userSettingJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"UserSettings.json");
var userSettings = JsonConvert.DeserializeObject <List <UserSetting> >(userSettingJson).Where(u => u.User.Id == TESTING_USER_ID);
string testingUnitName = Setting.UnitOptions.General.ToString();
UserSettingRepository.Setup(s => s.GetAll()).Returns(userSettings);
UserSettingRepository
.Setup(s => s.GetByUnitName(Setting.UnitOptions.General.ToString()))
.Returns(userSettings.Where(s => s.Setting.UnitName == Setting.UnitOptions.General.ToString()));
UserSettingRepository
.Setup(s => s.GetByUnitName(Setting.UnitOptions.Notifications.ToString()))
.Returns(userSettings.Where(s => s.Setting.UnitName == Setting.UnitOptions.Notifications.ToString()));
var resultUserSettings = UserSettingService.GetByUnitName(testingUnitName);
Assert.NotNull(resultUserSettings);
Assert.Equal(
userSettings.Count(s => s.Setting.UnitName == Setting.UnitOptions.General.ToString()),
resultUserSettings.Count()
);
}
public async Task UpdateUserSettingAsync()
{
var settings = new List <UserSetting>()
{
setting1, setting2, setting3
};
var mockSettings = CreateDbSetMock(settings.AsQueryable());
var mockContext = new Mock <UserSettingContext>();
mockContext.Setup(m => m.UserSettings).Returns(mockSettings.Object);
var service = new UserSettingService(mockContext.Object);
await service.UpdateUserSettingAsync(new UserSettingModel
{
SettingKey = "SettingKey1",
SettingValue = "UpdatedValue",
UserId = "testuser1",
UserSettingId = 1
});
var results = await service.GetUserSettingsByUserIdAsync(this.setting1.UserId);
Assert.NotNull(results);
Assert.Equal(2, results.Count());
Assert.NotNull(results.FirstOrDefault(s => s.SettingValue == "UpdatedValue"));
await Assert.ThrowsAsync <ArgumentException>(() => service.UpdateUserSettingAsync(_mapper.Map <UserSettingModel>(this.setting4)));
}
public async Task <JsonResult> GetByUID(string id)
{
try {
var data = UserSettingService.GetByUID(Guid.Parse(id));
return(Success(UserSettingsVM.MToVM(data)));
} catch { return(Failed(MessageUtility.ServerError())); }
}
public async Task Update_ReturnsUpdatedSettings()
{
string settingsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Settings.json");
var settings = JsonConvert.DeserializeObject <List <Setting> >(settingsJson);
string userSettingsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"UserSettings.json");
var userSetting = JsonConvert.DeserializeObject <List <UserSetting> >(userSettingsJson).First(s => s.User.Id == TESTING_USER_ID);
string settingName = Setting.SettingOptions.ShowBalance.ToString();
string settingValue = false.ToString().ToLower();
var newUserSetting = new UserSetting
{
Id = userSetting.Id,
Name = userSetting.Name,
Value = settingValue
};
UserSettingRepository.Setup(s => s.GetByName(newUserSetting.Name)).Returns(userSetting);
UserSettingRepository.Setup(s => s.Update(userSetting)).ReturnsAsync(userSetting);
SettingRepository.Setup(s => s.GetByKey(settingName)).Returns(settings.First(c => c.Name == settingName));
var resultUserSetting = await UserSettingService.Update(newUserSetting);
Assert.NotNull(resultUserSetting);
Assert.NotNull(resultUserSetting.User);
Assert.NotNull(resultUserSetting.Setting);
Assert.Equal(TESTING_USER_ID, resultUserSetting.User.Id);
Assert.Equal(settingName, resultUserSetting.Setting.Name);
Assert.Equal(settingValue, resultUserSetting.Value);
}
public async Task GetUserSettingsById()
{
var settings = new List <UserSetting>()
{
setting1, setting2, setting3
};
var mockSettings = CreateDbSetMock(settings.AsQueryable());
mockSettings.Setup(m => m.FindAsync(It.IsAny <object[]>())).Returns((object[] r) =>
{
return(new ValueTask <UserSetting>(mockSettings.Object.FirstOrDefaultAsync(b => b.UserSettingId == (int)r[0])));
});
var mockContext = new Mock <UserSettingContext>();
mockContext.Setup(m => m.UserSettings).Returns(mockSettings.Object);
var service = new UserSettingService(mockContext.Object);
var result = await service.GetUserSettingsByIdAsync(this.setting1.UserSettingId);
Assert.NotNull(result);
Assert.Equal(this.setting1.UserSettingId, result.UserSettingId);
result = await service.GetUserSettingsByIdAsync(1000);
Assert.Null(result);
}
public static void CreateFirstTimeDefaults(string username)
{
ScrumTimeEntities scrumTimeEntities = new ScrumTimeEntities();
UserSetting userSetting = UserSettingService.GetUserSettingByUsername(scrumTimeEntities, username);
if (userSetting == null)
{
// Load sample product id
ProductService productService = new ProductService(scrumTimeEntities);
int productIdOfSample = productService.GetProductIdOfSample();
if (productIdOfSample > -1)
{
SprintService sprintService = new SprintService(scrumTimeEntities);
List <Sprint> mostRecentSprints = sprintService.GetMostRecentSprints(productIdOfSample, -1, 1);
if (mostRecentSprints.Count > 0 && mostRecentSprints[0] != null)
{
userSetting = new UserSetting()
{
CurrentProduct = productIdOfSample,
CurrentSprint = mostRecentSprints[0].SprintId,
LastMainTabSelected = 1,
Username = username
};
scrumTimeEntities.AddToUserSettings(userSetting);
scrumTimeEntities.SaveChanges(System.Data.Objects.SaveOptions.AcceptAllChangesAfterSave);
}
}
}
}
partial void btn_save_TouchUpInside(UIButton sender)
{
switch (SegmentProTest.SelectedSegment)
{
case 0:
case 1:
if (db != null)
{
foreach (var config in db.DescTableItems)
{
bool validURL = true;
validURL = URLValidation(config, validURL);
if (!validURL)
{
return;
}
success = ConfigurationDO.UpdateConfiguration(AppDelegate.DatabaseContext, config);
}
configTableView.ReloadData();
if (success == 1)
{
UIAlertView alert = new UIAlertView(@" ", @"Url's Saved Successfully", null, NSBundle.MainBundle.LocalizedString("OK", "OK"));
alert.Show();
}
}
break;
case 2:
foreach (var userSet in db.UserSettingItems)
{
bool validData = true;
if (userSet.ID == 3)
{
validData = DBVersionValidation(userSet, validData);
}
else
{
validData = DataValidation(userSet, validData);
}
if (!validData)
{
return;
}
using (UserSettingService ser = new UserSettingService(AppDelegate.DatabaseContext))
{
success = ser.UpdateUserSetting(userSet);
}
}
configTableView.ReloadData();
if (success == 1)
{
UIAlertView alert = new UIAlertView(@" ", @"User Setting Saved Successfully", null, NSBundle.MainBundle.LocalizedString("OK", "OK"));
alert.Show();
}
break;
}
}
/// <summary>
/// Play the Encoded file
/// </summary>
private void PlayFile()
{
// Launch VLC and Play video.
if (this.CurrentlyPlaying != string.Empty)
{
if (File.Exists(this.CurrentlyPlaying))
{
string args = "\"" + this.CurrentlyPlaying + "\"";
if (this.UseSystemDefaultPlayer)
{
Process.Start(args);
}
else
{
if (!File.Exists(UserSettingService.GetUserSetting <string>(UserSettingConstants.VLCPath)))
{
// Attempt to find VLC if it doesn't exist in the default set location.
string vlcPath;
if (8 == IntPtr.Size || (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("PROCESSOR_ARCHITEW6432"))))
{
vlcPath = Environment.GetEnvironmentVariable("ProgramFiles(x86)");
}
else
{
vlcPath = Environment.GetEnvironmentVariable("ProgramFiles");
}
if (!string.IsNullOrEmpty(vlcPath))
{
vlcPath = Path.Combine(vlcPath, "VideoLAN\\VLC\\vlc.exe");
}
if (File.Exists(vlcPath))
{
UserSettingService.SetUserSetting(UserSettingConstants.VLCPath, vlcPath);
}
else
{
this.errorService.ShowMessageBox(Resources.StaticPreviewViewModel_UnableToFindVLC,
Resources.Error, MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
if (File.Exists(UserSettingService.GetUserSetting <string>(UserSettingConstants.VLCPath)))
{
ProcessStartInfo vlc = new ProcessStartInfo(UserSettingService.GetUserSetting <string>(UserSettingConstants.VLCPath), args);
Process.Start(vlc);
}
}
}
else
{
this.errorService.ShowMessageBox(Resources.StaticPreviewViewModel_UnableToPlayFile,
Resources.Error, MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
}
/// <summary>
/// Play the Encoded file
/// </summary>
private void PlayFile()
{
// Launch VLC and Play video.
if (this.CurrentlyPlaying != string.Empty)
{
if (File.Exists(this.CurrentlyPlaying))
{
string args = "\"" + this.CurrentlyPlaying + "\"";
if (this.UseSystemDefaultPlayer)
{
Process.Start(args);
}
else
{
if (!File.Exists(UserSettingService.GetUserSetting <string>(UserSettingConstants.VLCPath)))
{
// Attempt to find VLC if it doesn't exist in the default set location.
string vlcPath;
if (8 == IntPtr.Size || (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("PROCESSOR_ARCHITEW6432"))))
{
vlcPath = Environment.GetEnvironmentVariable("ProgramFiles(x86)");
}
else
{
vlcPath = Environment.GetEnvironmentVariable("ProgramFiles");
}
if (!string.IsNullOrEmpty(vlcPath))
{
vlcPath = Path.Combine(vlcPath, "VideoLAN\\VLC\\vlc.exe");
}
if (File.Exists(vlcPath))
{
UserSettingService.SetUserSetting(UserSettingConstants.VLCPath, vlcPath);
}
else
{
this.errorService.ShowMessageBox("Unable to detect VLC Player. \nPlease make sure VLC is installed and the directory specified in HandBrake's options is correct. (See: \"Tools Menu > Options > Picture Tab\")",
Resources.Error, MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
if (File.Exists(UserSettingService.GetUserSetting <string>(UserSettingConstants.VLCPath)))
{
ProcessStartInfo vlc = new ProcessStartInfo(UserSettingService.GetUserSetting <string>(UserSettingConstants.VLCPath), args);
Process.Start(vlc);
}
}
}
else
{
this.errorService.ShowMessageBox("Unable to find the preview file. Either the file was deleted or the encode failed. Check the activity log for details.",
Resources.Error, MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
}
public static double getAutoSyncInterval()
{
double autoSyncTime;
List <UserSetting> userSetting = new UserSettingService(AppDelegate.DatabaseContext).GetUserSettings();
string strAutoIntervalTime = userSetting.Where(u => u.SettingName.Trim() == "Auto Sync Interval(in Secs)").SingleOrDefault().SettingValue;
Double.TryParse(strAutoIntervalTime, out autoSyncTime);
return(autoSyncTime);
}
private static UserSetting LoadUserSetting(ScrumTimeEntities scrumTimeEntities, string username)
{
UserSetting userSetting = null;
if (username != null && username.Length > 0)
{
userSetting = UserSettingService.GetUserSettingByUsername(scrumTimeEntities, username);
}
return(userSetting);
}
public async Task <JsonResult> Insert()
{
try {
var id = Guid.NewGuid();
var uid = Guid.Parse(Request.Form["uid"]);
var aid = Guid.Parse(Request.Form["aid"]);
if (UserSettingService.Insert(id, uid, aid, DateTime.Now))
{
return(Success(id.ToString()));
}
return(Failed(MessageUtility.ServerError()));
} catch { return(Failed(MessageUtility.ServerError())); }
}
/// <summary>
/// Start Encode
/// </summary>
public void StartEncode()
{
if (this.queueProcessor.Count == 0)
{
this.errorService.ShowMessageBox(
"There are no pending jobs.", Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
this.JobStatus = "Queue Started";
this.JobsPending = string.Format("{0} jobs pending", this.queueProcessor.Count);
this.IsEncoding = true;
this.queueProcessor.Start(UserSettingService.GetUserSetting <bool>(UserSettingConstants.ClearCompletedFromQueue));
}
/// <summary>
/// Start Encode
/// </summary>
public void StartEncode()
{
if (this.queueProcessor.Count == 0)
{
this.errorService.ShowMessageBox(
Resources.QueueViewModel_NoPendingJobs, Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
this.JobStatus = Resources.QueueViewModel_QueueStarted;
this.JobsPending = string.Format(Resources.QueueViewModel_JobsPending, this.queueProcessor.Count);
this.IsEncoding = true;
this.queueProcessor.Start(UserSettingService.GetUserSetting <bool>(UserSettingConstants.ClearCompletedFromQueue));
}
public async Task Delete_ReturnsDeletedSetting()
{
string userSettingsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"UserSettings.json");
var userSetting = JsonConvert.DeserializeObject <List <UserSetting> >(userSettingsJson).First(s => s.User.Id == TESTING_USER_ID);
UserSettingRepository.Setup(s => s.GetByKey(userSetting.Id)).Returns(userSetting);
UserSettingRepository.Setup(s => s.Delete(userSetting.Id)).ReturnsAsync(userSetting);
var resultUserSetting = await UserSettingService.Delete(userSetting.Id);
Assert.NotNull(resultUserSetting);
Assert.Equal(userSetting.Name, resultUserSetting.Name);
Assert.Equal(userSetting.Value, resultUserSetting.Value);
}
public async Task AddUserSettingAsync()
{
var settings = new List <UserSetting>();
var mockSettings = CreateDbSetMock(settings.AsQueryable());
mockSettings.Setup(m => m.AddAsync(It.IsAny <UserSetting>(), default)).Callback <UserSetting, CancellationToken>((s, token) =>
{
settings.Add(s);
});
var mockContext = new Mock <UserSettingContext>();
mockContext.Setup(m => m.UserSettings).Returns(mockSettings.Object);
var service = new UserSettingService(mockContext.Object);
var result = await service.AddUserSettingAsync(_mapper.Map <UserSettingModel>(this.setting1));
Assert.NotNull(result);
Assert.Equal(this.setting1.SettingKey, result.SettingKey);
await Assert.ThrowsAsync <ArgumentException>(() => service.AddUserSettingAsync(_mapper.Map <UserSettingModel>(this.setting1)));
}
public async Task GetUserSettingsByUserId()
{
var settings = new List <UserSetting>()
{
setting1, setting2, setting3
};
var mockSettings = CreateDbSetMock(settings.AsQueryable());
var mockContext = new Mock <UserSettingContext>();
mockContext.Setup(m => m.UserSettings).Returns(mockSettings.Object);
var service = new UserSettingService(mockContext.Object);
var result = await service.GetUserSettingsByUserIdAsync(this.setting1.UserId);
Assert.NotNull(result);
Assert.Equal(2, result.Count());
result = await service.GetUserSettingsByUserIdAsync("non-existing-user");
Assert.Empty(result);
}
public async Task DeleteUserSettingAsync()
{
var settings = new List <UserSetting>()
{
setting1, setting2, setting3
};
var mockSettings = CreateDbSetMock(settings.AsQueryable());
mockSettings.Setup(m => m.Remove(It.IsAny <UserSetting>())).Callback <UserSetting>(s =>
{
settings.Remove(settings.Find(t => t.UserSettingId == s.UserSettingId));
});
var mockContext = new Mock <UserSettingContext>();
mockContext.Setup(m => m.UserSettings).Returns(mockSettings.Object);
var service = new UserSettingService(mockContext.Object);
await service.DeleteUserSettingAsync(setting1.UserSettingId);
await Assert.ThrowsAsync <ArgumentException>(() => service.DeleteUserSettingAsync(setting1.UserSettingId));
}
public UserSettingServiceTest()
{
ContextProvider = new Mock <IContextProvider>();
UserSettingRepository = new Mock <IUserSettingRepository>();
SettingRepository = new Mock <ISettingRepository>();
UserRepository = new Mock <IUserRepository>();
UserContext = new Mock <IUserContext>();
UserContext.Setup(c => c.GetUserId()).Returns(TESTING_USER_ID);
ContextProvider
.Setup(c => c.GetRepository <IUserSettingRepository>())
.Returns(UserSettingRepository.Object);
ContextProvider
.Setup(c => c.GetRepository <ISettingRepository>())
.Returns(SettingRepository.Object);
ContextProvider
.Setup(c => c.GetRepository <IUserRepository>())
.Returns(UserRepository.Object);
UserSettingService = new UserSettingService(ContextProvider.Object, UserContext.Object);
}
public DB_ConfigTableSource(ConfigType configType)
{
var data = ConfigurationDO.getConfiguration(AppDelegate.DatabaseContext);
selectedSegment = configType;
switch (configType)
{
case ConfigType.ProductionService:
DescTableItems = data.Where(i => i.IsDefault == true);
break;
case ConfigType.TestService:
DescTableItems = data.Where(i => i.IsDefault == false);
break;
case ConfigType.UserSetting:
using (UserSettingService usr = new UserSettingService(AppDelegate.DatabaseContext))
{
var userSetting = usr.GetUserSettings();
UserSettingItems = userSetting;
}
break;
}
}
public async Task Update_ReturnsUpdatedAndCreatedSettings()
{
string settingsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Settings.json");
var settings = JsonConvert.DeserializeObject <List <Setting> >(settingsJson);
string usersJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Users.json");
var user = JsonConvert.DeserializeObject <List <User> >(usersJson).First(s => s.Id == TESTING_USER_ID);
string userSettingsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"UserSettings.json");
var userSetting = JsonConvert.DeserializeObject <List <UserSetting> >(userSettingsJson).First(s => s.User.Id == TESTING_USER_ID);
string settingName = Setting.SettingOptions.TurnNotificationsSoundOn.ToString();
string settingUnitName = Setting.UnitOptions.Notifications.ToString();
string settingValue = true.ToString().ToLower();
var updatingUserSetting = new UserSetting
{
Id = userSetting.Id,
Name = userSetting.Name,
Value = settingValue,
User = userSetting.User
};
var newUserSetting = new UserSetting
{
Name = settingName,
Value = settingValue
};
UserRepository.Setup(u => u.GetByKey(TESTING_USER_ID)).Returns(user);
UserSettingRepository.Setup(s => s.GetByName(newUserSetting.Name)).Returns((UserSetting)null);
UserSettingRepository.Setup(s => s.GetByName(updatingUserSetting.Name)).Returns(userSetting);
UserSettingRepository
.Setup(s => s.Create(new List <UserSetting> {
newUserSetting
}))
.ReturnsAsync(new List <UserSetting> {
newUserSetting
});
UserSettingRepository
.Setup(s => s.Update(new List <UserSetting> {
updatingUserSetting
}))
.ReturnsAsync(new List <UserSetting> {
updatingUserSetting
});
SettingRepository.Setup(s => s.GetByKey(settingName)).Returns(settings.First(c => c.Name == settingName));
var resultUserSettings = await UserSettingService.Update(new List <UserSetting>
{
newUserSetting,
updatingUserSetting
});
Assert.NotNull(resultUserSettings);
// I can't assert this because inside service it creates a new list so I can't mock repository methods results
//Assert.Equal(2, resultUserSettings.Count());
Assert.NotNull(newUserSetting.User);
Assert.NotNull(newUserSetting.Setting);
Assert.Equal(TESTING_USER_ID, newUserSetting.User.Id);
Assert.Equal(settingName, newUserSetting.Setting.Name);
Assert.Equal(settingUnitName, newUserSetting.Setting.UnitName);
Assert.Equal(settingValue, newUserSetting.Value);
Assert.NotNull(userSetting.User);
Assert.NotNull(userSetting.Setting);
Assert.Equal(TESTING_USER_ID, userSetting.User.Id);
Assert.Equal(updatingUserSetting.Value, userSetting.Value);
}
/// <summary>
/// Login button clicked method.
/// Network Connectivity is checked.
/// Authentication
/// DB version is checked with the server and db updation happens according
/// </summary>
/// <param name="sender">Sender.</param>
async partial void btnLogin_TouchUpInside(UIButton sender)
{
this.ResignFirstResponder();
this.txtUserName.ResignFirstResponder();
this.txtPassword.ResignFirstResponder();
try
{
this.ResignFirstResponder();
if (CrossConnectivity.Current.IsConnected == false)
{
if (CrossConnectivity.Current.IsConnected == false)
{
UIAlertView alert = new UIAlertView(@"Alert", @"You are not connected to the network", null, NSBundle.MainBundle.LocalizedString("OK", "OK"));
alert.Show();
return;
}
}
if (txtUserName.Text.Length <= 0 || txtPassword.Text.Length <= 0)
{
UIAlertView alert = new UIAlertView(@"Alert", @"Please fill in both username and password", null, NSBundle.MainBundle.LocalizedString("OK", "OK"));
alert.Show();
return;
}
if (txtUserName.Text.ToUpper() == Constants.AdminUserID && txtPassword.Text.ToUpper() == Constants.AdminPassword)
{
config con = this.Storyboard.InstantiateViewController("config") as config;
this.NavigationController.PushViewController(con, true);
}
else if (txtUserName.Text.ToUpper() == Constants.AdminUserID && txtPassword.Text.ToUpper() != Constants.AdminPassword)
{
UIAlertView alert = new UIAlertView(@"Alert", @"Invalid Username Or Password", null, NSBundle.MainBundle.LocalizedString("OK", "OK"));
alert.Show();
}
else
{
if (AppDelegate.DatabaseContext != null)
{
//AppDelegate del=new AppDelegate();
loginScrollView.ContentOffset = new CGPoint(0, 0);
LoadOverLayPopup();
//getter method should return if we should allow going to dashboard or not
string username = txtUserName.Text;
string password = txtPassword.Text;
authenticatedUser = await Task.Run(() => LoginToService(username, password));
HideOverLay();
if (authenticatedUser.Result != null && (authenticatedUser.Result.code == 0 || authenticatedUser.Result.code == 1) && authenticatedUser.UserDetails != null && authenticatedUser.IsTokenActive)
{
AppDelegate.user = authenticatedUser;
using (MasterDataUpdateService masterDataUpdateService = new MasterDataUpdateService(AppDelegate.DatabaseContext))
{
string dbVersion = "1.0";
using (UserSettingService usrSetting = new UserSettingService(AppDelegate.DatabaseContext))
{
var dbVersions = usrSetting.GetUserSettings().Where(u => u.SettingName == "DBVersion");
if (dbVersions != null && dbVersions.Count() > 0)
{
dbVersion = dbVersions.FirstOrDefault().SettingValue;
}
}
var AppDbVersion = string.IsNullOrEmpty(dbVersion) ?1:float.Parse(dbVersion);
var serverDBVersion = string.IsNullOrEmpty(authenticatedUser.DBVersion) ?1:float.Parse(authenticatedUser.DBVersion);
if (AppDbVersion < serverDBVersion)
{
UIAlertView alert1 = new UIAlertView(@"Alert", @"Master Data update available,DB update is going to start.", null, NSBundle.MainBundle.LocalizedString("Ok", "Ok"));
alert1.Show();
alert1.Clicked += async(DBsender, buttonArgs) => {
masterDataUpdateService.progressDelegate = this.UpdateProgress;
this.ResignFirstResponder();
this.View.UserInteractionEnabled = false;
progressView.Hidden = false;
dataProgressLabel.Hidden = false;
CGAffineTransform transform = CGAffineTransform.MakeScale(1.0f, 6.0f);
progressView.Transform = transform;
MasterDataUpdateStatus resultMasterData = await Task.Run(() => masterDataUpdateService.UpdateDatabaseService(authenticatedUser.UserDetails.Token));
progressView.Hidden = true;
dataProgressLabel.Hidden = true;
if (resultMasterData != null)
{
UIAlertView alert = new UIAlertView(@"Alert", resultMasterData.ErrorMessage, null, NSBundle.MainBundle.LocalizedString("OK", "OK"));
alert.Show();
if (resultMasterData.Result == false)
{
this.View.UserInteractionEnabled = true;
AppDelegate.deleteSession();
}
else
{
this.View.UserInteractionEnabled = true;
MoveToDashBoard(authenticatedUser);
}
}
else
{
this.View.UserInteractionEnabled = true;
}
};
}
else
{
MoveToDashBoard(authenticatedUser);
}
}
}
else if (authenticatedUser.Result != null && (authenticatedUser.Result.code == 0 || authenticatedUser.Result.code == 1) && authenticatedUser.UserDetails != null && !authenticatedUser.IsTokenActive)
{
UIAlertView alert1 = new UIAlertView(@"Invalid Token", @"Token Expired", null, NSBundle.MainBundle.LocalizedString("OK", "OK"));
alert1.Show();
}
else
{
this.ShowErrorResponse(authenticatedUser.Result.code);
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception Occured in btnLogin_TouchUpInside method due to " + ex.Message);
}
finally
{
progressView.Hidden = true;
dataProgressLabel.Hidden = true;
this.View.UserInteractionEnabled = true;
}
}
public void GetSetting()
{
UserSettingService usersettingservice = new UserSettingService();
usersettingservice.GetByUsername("fengzijun");
}
