public void CreateProfile(dtoBaseProfile profile, Int32 idProfileType, String ProfileName, Int32 idOrganization)
{
UrlAuthenticationProvider provider = GetProvider();
List <ProfilerError> errors = UrlService.VerifyProfileInfo(profile, View.idProvider, View.ExternalCredentials);
if (errors.Count == 0)
{
ProfileSubscriptionMessage message = View.CreateProfile(profile, idProfileType, ProfileName, idOrganization, AuthenticationProviderType.Url, View.idProvider);
Int32 idPerson = View.IdProfile;
if (idPerson > 0)
{
PolicyService.SaveUserSelection(CurrentManager.GetPerson(idPerson), View.GetPolicyInfo);
}
if (message == ProfileSubscriptionMessage.CreatedWithAutoLogon && idPerson > 0)
{
Person person = CurrentManager.GetPerson(View.IdProfile);
View.LogonUser(person, View.idProvider, provider.RemoteLoginUrl, false, CurrentManager.GetUserDefaultIdOrganization(View.IdProfile));
}
else
{
if (message == ProfileSubscriptionMessage.CreatedWithAutoLogon)
{
message = ProfileSubscriptionMessage.Created;
}
View.LoadRegistrationMessage(message);
}
}
else
{
if (errors.Contains(ProfilerError.loginduplicate))
{
View.LoadRegistrationMessage(ProfileSubscriptionMessage.LoginDuplicated);
}
else if (errors.Contains(ProfilerError.mailDuplicate))
{
View.LoadRegistrationMessage(ProfileSubscriptionMessage.MailDuplicated);
}
else if (errors.Contains(ProfilerError.taxCodeDuplicate))
{
View.LoadRegistrationMessage(ProfileSubscriptionMessage.TaxCodeDuplicated);
}
else if (errors.Contains(ProfilerError.uniqueIDduplicate))
{
View.LoadRegistrationMessage(ProfileSubscriptionMessage.MatriculaDuplicated);
}
else if (errors.Contains(ProfilerError.externalUniqueIDduplicate))
{
View.LoadRegistrationMessage(ProfileSubscriptionMessage.externalUniqueIDduplicate);
}
else
{
View.LoadRegistrationMessage(ProfileSubscriptionMessage.UnknownError);
}
}
}
private String GetExternalUserInfo()
{
String result = "";
UrlAuthenticationProvider provider = GetProvider();
if (provider != null)
{
result = View.UrlIdentifierValue;
}
return(result);
}
private UrlAuthenticationProvider GetProvider()
{
UrlAuthenticationProvider provider = UrlService.GetActivePovider(View.UrlIdentifier);
if (provider != null && provider.Id != View.idProvider)
{
View.idProvider = provider.Id;
}
return(provider);
}
public void InitView()
{
Boolean accessAvailable = !(View.isSystemOutOfOrder);
Int32 idProfile = View.PreloadedIdProfile;
long idProvider = View.PreloadedIdProvider;
View.IdProfile = idProfile;
View.IdProvider = idProvider;
if (idProfile == 0)
{
View.GotoAuthenticationSelctorPage();
}
else
{
AuthenticationProvider provider = CurrentManager.Get <AuthenticationProvider>(idProvider);
Person person = CurrentManager.GetPerson(idProfile);
if (person == null)
{
View.GotoAuthenticationSelctorPage();
}
else
{
switch (provider.ProviderType)
{
case AuthenticationProviderType.Internal:
View.AllowInternalAuthentication = true && accessAvailable;
break;
case AuthenticationProviderType.Url:
UrlAuthenticationProvider urlProvider = (UrlAuthenticationProvider)provider;
if (!string.IsNullOrEmpty(urlProvider.RemoteLoginUrl))
{
View.AllowExternalWebAuthentication(urlProvider.RemoteLoginUrl);
}
else if (!string.IsNullOrEmpty(urlProvider.SenderUrl))
{
View.AllowExternalWebAuthentication(urlProvider.SenderUrl);
}
break;
}
if (Service.IsProfileWaitingForActivation(person))
{
View.DisplayNotActivatedAccount(person.Name);
}
else
{
View.DisplayDisabledAccount(person.Name);
}
}
}
}
private void MoveFromStepProfileTypeSelector()
{
UrlAuthenticationProvider provider = GetProvider();
dtoBaseProfile profile = new dtoBaseProfile();
if (provider != null)
{
profile.IdProfileType = View.SelectedProfileTypeId;
}
if (View.SelectedProfileTypeId > 0)
{
View.GotoStepProfileInfo(profile);
}
}
private void UrlProviderLogon(dtoUrlToken urlToken)
{
UrlAuthenticationProvider urlProvider = UrlService.GetPovider(urlToken.Identifier);
if (urlProvider != null)
{
dtoUrlToken vToken = urlProvider.ValidateToken(urlToken);
//UrlProviderResult result = urlProvider.ValidateToken(urlToken.Value);
if (!String.IsNullOrEmpty(urlProvider.RemoteLoginUrl))
{
View.SetExternalWebLogonUrl(urlProvider.RemoteLoginUrl);
}
else if (!String.IsNullOrEmpty(urlProvider.SenderUrl))
{
View.SetExternalWebLogonUrl(urlProvider.SenderUrl);
}
//urlToken.DecriptedValue = urlProvider.GetTokenIdentifier(urlToken.Value);
List <ExternalLoginInfo> users = UrlService.FindUserByIdentifier(vToken.DecriptedValue, urlProvider);
switch (vToken.Evaluation.Result)
{
case UrlProviderResult.ValidToken:
if (users.Count == 1)
{
ExternalLogonManage(users[0], urlProvider);
}
else if (!String.IsNullOrEmpty(vToken.DecriptedValue))
{
View.GoToProfile(urlProvider.Id, vToken, lm.Comol.Core.BaseModules.ProfileManagement.RootObject.UrlProfileWizard(urlProvider.Id));
}
break;
default:
int idPerson = (users.Count == 1 && users[0].Person != null) ? users[0].Person.Id : 0;
String tokenUrl = RootObject.InvalidToken(idPerson, urlProvider.Id, vToken.Evaluation.Result);
//urlToken.FullDecriptedValue = urlProvider.FullDecryptToken(urlToken.Value);
View.DisplayInvalidToken(tokenUrl, idPerson, vToken, vToken.Evaluation.Result);
//if (!String.IsNullOrEmpty(urlProvider.RemoteLoginUrl))
// View.GotoRemoteUrl(urlProvider.RemoteLoginUrl);
//else if (!String.IsNullOrEmpty(urlProvider.SenderUrl))
// View.GotoRemoteUrl(urlProvider.SenderUrl);
break;
}
}
}
public void InitView(dtoExpiredAccessUrl expiredInfo)
{
Person person = null;
if (expiredInfo.IdPerson > 0)
{
person = CurrentManager.GetPerson(expiredInfo.IdPerson);
}
InitializeLanguage(person, expiredInfo.CodeLanguage);
View.UnknownAccessTicket = expiredInfo;
View.WriteLogonCookies(expiredInfo);
if (person == null)
{
View.GoToDefaultPage();
}
else
{
List <AuthenticationProvider> providers = ProfileService.GetUserAuthenticationProviders(person);
if (providers.Count == 0 || person.IdDefaultProvider == 0 || !providers.Where(p => p.Id == person.IdDefaultProvider).Any())
{
//if (person.AuthenticationTypeID != 1)
// View.LoadOldAuthenticationPage(person.AuthenticationTypeID);
//else
View.GoToDefaultPage();
}
else
{
AuthenticationProvider provider = providers.Where(p => p.Id == person.IdDefaultProvider).FirstOrDefault();
switch (provider.ProviderType)
{
case AuthenticationProviderType.Internal:
View.LoadInternalLoginPage();
break;
case AuthenticationProviderType.Url:
UrlAuthenticationProvider urlProvider = (UrlAuthenticationProvider)provider;
View.LoadExternalProviderPage(urlProvider.RemoteLoginUrl);
break;
default:
View.GoToDefaultPage();
break;
}
}
}
}
public void InitView(DateTime dateTimeToVerify)
{
String moduleCode = View.PreLoadedModuleCode;
String modulePage = View.PreloadedModulePage;
String externalProviderCode = View.PreLoadedExternalSource;
String encodedToken = "";
Authentication.AuthenticationProvider provider = Service.GetActiveProvider(externalProviderCode);
if (provider == null)
{
View.UnknowAuthenticationProvider();
}
else if (provider.ProviderType == Authentication.AuthenticationProviderType.Url)
{
UrlAuthenticationProvider urlProvider = (UrlAuthenticationProvider)provider;
encodedToken = View.GetEncodedIdUser(urlProvider.UrlIdentifier);
UrlProviderResult response = UrlProviderResult.NotEvaluatedToken;
if (encodedToken == "")
{
response = UrlProviderResult.UnknowToken;
}
else
{
response = urlProvider.ValidateToken(encodedToken, View.PreloadedPreviousUrl, dateTimeToVerify);
}
switch (response)
{
case UrlProviderResult.ValidToken:
string decodedToken = urlProvider.GetTokenIdentifier(encodedToken);
LoadUser(decodedToken, urlProvider);
break;
//case UrlProviderResult.UnknowToken:
// View.showLogonInfo(UrlProviderResult.
// break;
default:
View.showLogonInfo(response, urlProvider.RemoteLoginUrl);
break;
}
}
}
private void MoveFromStepInternalCredentials()
{
dtoInternalCredentials credentials = View.GetInternalCredentials;
InternalLoginInfo info = InternalService.GetAuthenticatedUser(credentials.Login, credentials.Password);
if (info == null || info.Person == null)
{
View.DisplayInvalidCredentials();
}
else
{
UrlAuthenticationProvider provider = GetProvider();
if (provider == null)
{
View.DisplayInternalCredentialsMessage(ProfileSubscriptionMessage.ProviderUnknown);
}
else
{
ExternalLoginInfo account = UrlService.AddFromInternalAccount(info, provider, View.UrlIdentifierValue);
if (account == null)
{
View.DisplayInternalCredentialsMessage(ProfileSubscriptionMessage.UnableToConnectToInternalProvider);
}
else if (account != null && account.Person.isDisabled)
{
View.LoadRegistrationMessage(ProfileSubscriptionMessage.AccountDisabled);
}
else if (PolicyService.UserHasPolicyToAccept(account.Person))
{
View.IdProfile = account.Person.Id;
InternalService.UpdateUserAccessTime(account.Person);
View.DisplayPrivacyPolicy(account.Person.Id, provider.Id, provider.RemoteLoginUrl, false);
}
else
{
View.LogonUser(account.Person, View.idProvider, provider.RemoteLoginUrl, false, CurrentManager.GetUserDefaultIdOrganization(account.Person.Id));
}
}
}
}
public void InitView(String urlIdentifier, String urlIdentifierValue)
{
View.UrlIdentifier = urlIdentifier;
View.UrlIdentifierValue = urlIdentifierValue;
UrlAuthenticationProvider provider = UrlService.GetActivePovider(urlIdentifier);
if (View.isSystemOutOfOrder)
{
View.DisplaySystemOutOfOrder();
}
else if (String.IsNullOrEmpty(urlIdentifier) || provider == null)
{
View.GotoDefaultPage();
}
else if (String.IsNullOrEmpty(urlIdentifierValue))
{
if (String.IsNullOrEmpty(provider.RemoteLoginUrl))
{
View.GotoDefaultPage();
}
else
{
View.GotoRemoteLogonPage(provider.RemoteLoginUrl);
}
}
else
{
List <ProfileWizardStep> steps = Service.GetStandardProfileWizardStep(WizardType.UrlProvider);
View.idProvider = View.PreloadedIdProvider;
View.AvailableSteps = steps;
List <AuthenticationProviderType> providers = new List <AuthenticationProviderType>();
providers.Add(AuthenticationProviderType.Internal);
providers.Add(AuthenticationProviderType.Url);
View.ExternalUserInfo = GetExternalUserInfo();
View.InitializeUnknownProfileStep(AuthenticationProviderType.Url, providers);
View.InitializeStep(ProfileWizardStep.OrganizationSelector);
View.GotoStep(ProfileWizardStep.UnknownProfileDisclaimer);
}
}
public void InitView(int idPerson, long idProvider, UrlProviderResult message)
{
Person person = CurrentManager.GetPerson(idPerson);
InitializeLanguage(person);
UrlAuthenticationProvider provider = CurrentManager.Get <UrlAuthenticationProvider>(idProvider);
if (person != null)
{
View.DisplayMessage(person.SurnameAndName, message);
}
else
{
View.DisplayMessage(message);
}
String defaultUrl = (provider != null) ? provider.RemoteLoginUrl : "";
if (message != UrlProviderResult.ValidToken)
{
View.SetAutoLogonUrl(defaultUrl);
}
}
public void MoveToNextStep(ProfileWizardStep step)
{
switch (step)
{
case ProfileWizardStep.UnknownProfileDisclaimer:
MoveFromStepUnknownProfileDisclaimer();
break;
case ProfileWizardStep.InternalCredentials:
MoveFromStepInternalCredentials();
break;
case ProfileWizardStep.OrganizationSelector:
MoveFromStepOrganizationSelector();
break;
case ProfileWizardStep.ProfileTypeSelector:
MoveFromStepProfileTypeSelector();
break;
case ProfileWizardStep.ProfileUserData:
List <ProfilerError> errors = UrlService.VerifyProfileInfo(View.ProfileInfo);
if (errors.Count > 0)
{
View.LoadProfileInfoError(errors);
}
else
{
View.UnloadProfileInfoError();
if (!View.AvailableSteps.Contains(ProfileWizardStep.Privacy))
{
UpdateStepsToSkip(ProfileWizardStep.Privacy, true);
View.GotoStep(ProfileWizardStep.Summary);
}
else
{
if (!View.IsInitialized(ProfileWizardStep.Privacy))
{
View.InitializeStep(ProfileWizardStep.Privacy);
}
View.GotoStep(ProfileWizardStep.Privacy);
}
}
break;
case ProfileWizardStep.Privacy:
Boolean UseInternalCredentials = (View.SelectedProvider == AuthenticationProviderType.Internal);
if (View.AcceptedMandatoryPolicy && UseInternalCredentials && View.IdProfile > 0)
{
Person person = CurrentManager.GetPerson(View.IdProfile);
UrlAuthenticationProvider provider = GetProvider();
View.LogonUser(person, View.idProvider, provider.RemoteLoginUrl, false, CurrentManager.GetUserDefaultIdOrganization(View.IdProfile));
}
else if (View.AcceptedMandatoryPolicy && !UseInternalCredentials)
{
View.GotoStep(ProfileWizardStep.Summary);
}
break;
case ProfileWizardStep.Summary:
break;
}
}
private ExternalLoginInfo AddUserInfo(Person person, Person currentUser, UrlAuthenticationProvider provider, String externalString)
{
ExternalLoginInfo account = null;
try
{
Manager.BeginTransaction();
//List<String> userIdentifiers = externalString.Split(' ').ToList();
var query = (from si in Manager.GetIQ <ExternalLoginInfo>() where si.Provider == provider select si);
List <ExternalLoginInfo> accounts = new List <ExternalLoginInfo>();
//foreach (String identifier in userIdentifiers.Where(i => !string.IsNullOrEmpty(i)).ToList())
//{
// accounts.AddRange(query.Where(si => si.Provider == provider && si.IdExternalString == identifier).ToList());
//}
accounts.AddRange(query.Where(si => si.Provider == provider && si.IdExternalString == externalString).ToList());
//foreach (String identifier in userIdentifiers.Where(i => !string.IsNullOrEmpty(i)).ToList())
//{
if (accounts.Where(a => a.IdExternalString.ToLower() == externalString.ToLower()).Any())
{
account = accounts.Where(a => a.IdExternalString.ToLower() == externalString.ToLower()).FirstOrDefault();
if (account != null)
{
UpdateAccount(account, person, currentUser, provider, externalString);
}
else
{
account = CreateAccount(person, currentUser, provider, externalString);
}
}
else
{
account = CreateAccount(person, currentUser, provider, externalString);
}
Manager.SaveOrUpdate(account);
AddToHistory(account);
//}
if (person.IdDefaultProvider == 0 || String.IsNullOrEmpty(person.FirstLetter))
{
//// TEMPORANEO
//creator.Login = login;
//creator.Password=userInfo.Password;
//// TEMPORANEO
if (person.IdDefaultProvider == 0 && provider != null)
{
person.IdDefaultProvider = provider.Id;
}
if (String.IsNullOrEmpty(person.FirstLetter))
{
person.FirstLetter = person.Surname[0].ToString().ToLower();
}
Manager.SaveOrUpdate(person);
}
Manager.Commit();
}
catch (Exception ex)
{
Manager.RollBack();
}
return(account);
}
public ExternalLoginInfo AddUserInfo(Person person, UrlAuthenticationProvider provider, String externalString)
{
Person currentUser = Manager.GetPerson(UC.CurrentUserID);
return(AddUserInfo(person, (currentUser == null) ? person : currentUser, provider, externalString));
}
public ExternalLoginInfo AddFromInternalAccount(InternalLoginInfo internalAccount, UrlAuthenticationProvider provider, String externalString)
{
return(AddUserInfo(internalAccount.Person, internalAccount.Person, provider, externalString));
}
public void InitView(Boolean defaultPageForInternal)
{
Person person = CurrentManager.GetPerson(UserContext.CurrentUserID);
if (person != null && person.TypeID != (int)UserTypeStandard.Guest && person.TypeID != (int)UserTypeStandard.PublicUser)
{
List <AuthenticationProvider> providers = ProfileService.GetUserAuthenticationProviders(person);
if (providers.Count == 0 || person.IdDefaultProvider == 0 || !providers.Where(p => p.Id == person.IdDefaultProvider).Any())
{
//if (IsShibbolethSessionActive())
////if (person.AuthenticationTypeID != 1)
//// View.LoadOldAuthenticationPage(person.AuthenticationTypeID);
////else
// View.GoToDefaultPage();
LoadData(LogoutMode.logoutMessage, AuthenticationProviderType.ActiveDirectory, "");
}
else
{
lm.Comol.Core.DomainModel.Helpers.dtoLoginCookie userInfo = View.UserAccessInfo;
AuthenticationProvider provider = providers.Where(p => p.Id == userInfo.IdProvider).FirstOrDefault();
if (provider == null)
{
provider = providers.Where(p => p.Id == person.IdDefaultProvider).FirstOrDefault();
}
AuthenticationProviderType providerType = (provider == null) ? AuthenticationProviderType.None : provider.ProviderType;
switch (providerType)
{
case AuthenticationProviderType.Internal:
if (defaultPageForInternal || provider.LogoutMode == LogoutMode.portalPage)
{
LoadData(LogoutMode.portalPage, providerType, "");
}
else
{
LoadData(provider.LogoutMode, providerType, "");
}
break;
case AuthenticationProviderType.Url:
UrlAuthenticationProvider urlProvider = (UrlAuthenticationProvider)provider;
LoadData(provider.LogoutMode, providerType, urlProvider.RemoteLoginUrl);
break;
case AuthenticationProviderType.UrlMacProvider:
MacUrlAuthenticationProvider mProvider = (MacUrlAuthenticationProvider)provider;
LoadData(provider.LogoutMode, providerType, mProvider.RemoteLoginUrl);
break;
default:
LoadData(LogoutMode.portalPage, providerType, "");
break;
}
}
}
else
{
View.GoToDefaultPage();
}
}
