Exemplo n.º 1
0
        /// <summary>
        /// Checks whether the user is authenticated with a new or used service.
        /// </summary>
        private void manageMultipleAccount(Security.User user)
        {
            UserID = user.UserId;
            List <Storage.Service> services = sto.getServicesByUserID(UserID);

            if (services == null)
            {
                showError("An error occurred during recovery services", false);
            }

            bool addExt = true;

            foreach (Storage.Service serv in services)
            {
                if (serv.serviceID == servID)
                {
                    addExt = false;
                    break;
                }
            }
            if (addExt)
            {
                /*
                 * Controllo che non esista un altro user (diverso da quello corrente) che abbia questo account esterno.
                 * Se esiste devo fondere i due utenti perche' rappresentano la stessa persona.
                 */
                Storage.User userAlredyExist = sto.getUserByExternalAccount(servID, LoginUserName);
                if (userAlredyExist != null)
                {
                    showError("External account already exists. UserId=" + userAlredyExist.userID, false);
                }

                // Operazione da eseguire su db ora solo se gia' registrato
                if (user.Registered)
                {
                    ExternalAccount extAcc = sto.addExternalAccount(UserID, LoginUserName, servID);
                    if (extAcc == null)
                    {
                        showError("An error occurred during the addition of new service", false);
                    }
                }
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Authorizes a list of contacts to fill this ComputableWorkflow.
        /// This Method can be used only in the _NOT_ filling case
        /// This Method can be used only for private Workflows
        /// </summary>
        /// <param name="contactList">The list of <see cref="Security.Contact"/>s to be allowed</param>
        /// <returns><value>true</value> on success, <value>false</value>otherwise (including operation not permitted)</returns>
        public bool PermitContacts(List <Security.Contact> contactList)
        {
            if (!complete)
            {
                fillReference();
            }

            if (!isPrivate || filling)
            {
                return(false);
            }

            if (contactList == null)
            {
                return(false);
            }

            LoaMailSender mailSender = new LoaMailSender();

            List <Security.Contact> rejected = new List <Contact>();

            foreach (Security.Contact contact in contactList)
            {
                string token = RandomStringGenerator.GetRandomString(10);
                Storage.CompilationRequest creq = sto.addContactToPublication(this.publicationId, contact.ContactID, token);
                if (creq == null)
                {
                    creq = sto.getCompilationRequestByPulicationAndContact(contact.ContactID, publicationId);
                    if (creq == null)
                    {
                        return(false);
                    }
                }

                Storage.Service s = sto.getEntityByID <Storage.Service>(contact.Service.ServiceId);
                if (s == null)
                {
                    return(false);
                }

                // Check if the service uses emails and if the email seems correct

                if (s.externalUserIDMail)
                {
                    try
                    {
                        System.Net.Mail.MailAddress address = new System.Net.Mail.MailAddress(contact.Email);
                        LoaMail mail = new LoaMail(address, GetWorkflowName(), creq);
                        if (!mailSender.SendMail(mail))
                        {
                            rejected.Add(contact);
                        }
                    }
                    catch (Exception)
                    {
                        rejected.Add(contact);
                    }
                }
                else
                {
                    rejected.Add(contact);
                }
            }


            if (rejected.Count > 0)
            {
                Storage.User user = sto.getEntityByID <Storage.User>(userId);
                //Genero email per creatore
                try
                {
                    System.Net.Mail.MailAddress userMail = new System.Net.Mail.MailAddress(user.mail);
                    MailToFormCreator           mail     = new MailToFormCreator(userMail, GetWorkflowName(), publicationId, rejected);
                    LoaMailSender sender = new LoaMailSender();
                    return(sender.SendMail(mail));
                }
                catch
                {
                    //non dovrebbe mai arrivare qui, la mail dello user e' controllata in fase di registrazione
                    return(false);
                }
            }
            return(true);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Autenticate a user
        /// </summary>
        private void ProcessLoginUser()
        {
            string starting = (string)Session["LoginPhase"];

            service = (ILoginService)Session["LoginService"];
            try
            {
                servID = (int)Session["ServiceID"];
            }
            catch (Exception)
            {
                servID = -1;
            }

            if (string.IsNullOrEmpty(starting))
            {
                #region first phase

                Storage.Service serv = sto.getEntityByID <Storage.Service>(servID);
                if (serv == null)
                {
                    showError("An error occurred while retrieving the service used", false);
                }
                string servName = serv.nameService;
                if (servName == null)
                {
                    showError("An error occurred while retrieving the service name used", false);
                }

                Assembly assembly = null;
                if (serv.dllPath == null)
                {
                    assembly = typeof(LoginServices.OAuthBase).Assembly;
                }
                else
                {
                    assembly = Assembly.LoadFrom(serv.dllPath);
                }

                foreach (Type type in assembly.GetTypes())
                {
                    if (type.IsClass && type.Name == serv.className)
                    {
                        Object instance = Activator.CreateInstance(type);
                        if (instance == null)
                        {
                            service = null;
                        }
                        else
                        {
                            service = (Security.Auth.ILoginService)instance;
                        }
                    }
                }

                if (service == null)
                {
                    showError("An error occurred while creating the service", false);
                }

                LoginUrl = service.StartLogin(Session, Server);
                if (LoginUrl == null)
                {
                    showError("An error occurred during the first phase of the login.<br />Please check that your time settings are correct.", false);
                }

                Session["LoginPhase"]   = "Second";
                Session["LoginService"] = service;
                Response.Redirect(LoginUrl);

                #endregion
            }
            else
            {
                if (service == null)
                {
                    showError("An error occurred in the service", false);
                }

                if (!starting.Equals("Second"))
                {
                    showError("An error occurred during the second phase of login", false);
                }

                if (!service.ProcessLogin(Session, Request, Server))
                {
                    showError("An error occurred during the authentication process", false);
                }

                //Process login correctly

                #region second phase

                LoginUserName = service.getUsername();
                if (LoginUserName == null)
                {
                    showError("An error occurred in the username", false);
                }

                Token         tok  = (Token)Session["Token"];
                Security.User user = null;

                if ((tok == null) || (!tok.Authenticated))
                {
                    #region first time login

                    Storage.User tempUser = sto.getUserByExternalAccount(servID, LoginUserName);

                    if (tempUser != null)
                    {
                        // user already registered
                        UserID = tempUser.userID;
                        user   = new Security.User(UserID, tempUser.nickname, tempUser.mail);
                    }
                    else
                    {
                        //user not yet registered
                        UserID = -1;
                        user   = new Security.User(UserID, LoginUserName, "");
                    }

                    user.AddLoggedService(servID, service);

                    tok = new Token(user);
                    Session["Token"] = tok;

                    #endregion
                }
                else
                {
                    #region add service to the current user

                    user = tok.GetCurrentUser();
                    manageMultipleAccount(user);
                    user.AddLoggedService(servID, service);

                    #endregion
                }

                /* clean session */

                Session["LoginPhase"]   = null;
                Session["LoginService"] = null;
                Session["ServiceID"]    = null;
                Session["LoginContact"] = null;
                Session["LoginError"]   = null;

                string url = (string)Session["ReturnURL"];
                if (url == null)
                {
                    url = URLHome;
                }
                Session["ReturnURL"] = null;

                if (url.Contains("?"))
                {
                    url += "&reg=true";
                }
                else
                {
                    url += "?reg=true";
                }
                Response.Redirect(url);

                #endregion

                #region registration

                //DA CAMBIAREEEEEEEEEEEee

                /*if (user.Registered)
                 *  //redirect to the url where the login process begin
                 *  Response.Redirect(url);
                 * else
                 * {
                 *  //redirect to registration page
                 *  Session["ReturnURL"] = url;
                 *  Response.Redirect(URLReg);
                 * }*/


                #endregion
            }
        }
Exemplo n.º 4
0
        /// <summary>
        /// Make the workflow pointed by this WorkflowReference computable
        /// </summary>
        /// <param name="ftype">The <see cref="Security.FormType"/>of the computable workflow</param>
        /// <param name="serviceId"> The serviceId allowed to fill this workflow</param>
        /// <param name="publicationDescription"> The workflowdescription of the publication, empty string for empty description</param>
        /// <param name="expireDate"> The expire date gg/mm/aaaa</param>
        /// <param name="communicationUri"> The uri used by communication package</param>
        /// <returns>A <see cref="Security.ComputableWorkflowReference"/> pointing the newly created <see cref="Core.WF.IComputableWorkflow"/>; <value>null</value> if an error happens</returns>
        public ComputableWorkflowReference MakeComputable(FormType ftype, int serviceId, string publicationDescription, string expireDate, string communicationUri)
        {
            if (publicationDescription == null)
            {
                return(null);
            }
            if (!complete)
            {
                fillReference();
            }

            bool publicp          = ((ftype == FormType.PUBLIC_BY_SERVICE) || (ftype == FormType.PUBLIC_WITH_REPLICATION) || (ftype == FormType.PUBLIC_WITHOUT_REPLICATION));
            bool anonym           = ((ftype == FormType.PRIVATE_ANONYM) || (ftype == FormType.PUBLIC_BY_SERVICE) || (ftype == FormType.PUBLIC_WITH_REPLICATION) || (ftype == FormType.PUBLIC_WITHOUT_REPLICATION));
            bool resultReplicated = (ftype == FormType.PUBLIC_WITH_REPLICATION);

            if (ftype == FormType.PUBLIC_BY_SERVICE && (serviceId == 1))
            {
                // Not allowed, we need a valid serviceId
                return(null);
            }


            if (wf_cache == null)
            {
                if (!_RetrieveWf())
                {
                    return(null);
                }
            }

            IFormatProvider provider = CultureInfo.InvariantCulture;
            DateTime        date;

            if (!DateTime.TryParse(expireDate, provider, DateTimeStyles.AdjustToUniversal, out date))
            {
                provider = CultureInfo.GetCultureInfo("it-IT");
                if (!DateTime.TryParse(expireDate, provider, DateTimeStyles.AdjustToUniversal, out date))
                {
                    date = DateTime.Now.AddMonths(1);
                }
            }

            Publication pub = sto.publish(modelId, DateTime.Now, date, "", wf_cache.Save(), anonym, publicp, resultReplicated, serviceId, communicationUri, "Inutile", publicationDescription);

            if (pub == null)
            {
                return(null);
            }

            // Make it public
            int creqid = -1;

            if (publicp)
            {
                CompilationRequest creq = null;
                if (resultReplicated)
                {
                    creq = sto.addPublicPublication(pub.publicationID);
                    if (creq == null)
                    {
                        return(null);
                    }
                    creqid = creq.compilReqID;
                }

                Storage.User user = sto.getEntityByID <Storage.User>(userId);
                //Genero email per creatore
                try
                {
                    System.Net.Mail.MailAddress userMail = new System.Net.Mail.MailAddress(user.mail);
                    MailForPublicForm           mail     = new MailForPublicForm(userMail, pub, creq);
                    LoaMailSender sender = new LoaMailSender();
                    sender.SendMail(mail);
                }
                catch
                {
                    //non dovrebbe mai arrivare qui visto che la mail dell'utente e' controllata in fase di registrazione
                    return(null);
                }
            }
            if (!String.IsNullOrEmpty(communicationUri))
            {
                CommunicationService.Instance.Setup(pub);
            }

            return(new ComputableWorkflowReference(userId, pub.publicationID, pub.namePublication, pub.description, themeId, creqid, !publicp, false, date));
        }