/* Groovy Class [View Code>$doc.fullName?viewer=code]  
#** 
   * Register Groovy Page
   * @programming
   * @type groovy
   *#
*/

import com.xpn.xwiki.api.Document;

public class register {
 def msgmap = [ "email_notvalid": "This email is not valid", 
"account_already_exists": "This account already exists", "email_already_exists": "This email address is already used", "empty_password": "You have not entered a password", "unmatched_password" : "The passwords are not matching", "account_notvalid" : "This community name is invalid. Please enter a name without spaces or special characters.", "validation_failed" : "Some fields are incorrectly completed"];

 def xmsgmap;
 def xwiki;
 def context;
 def message = "";
 def firstname = "";
 def lastname = "";
 def account = "";
 def email = "";
 def password = "";
 def validkey = "";

 public void setObjects(xwiki, context, msg) {
   setXWiki(xwiki)
   setContext(context)
   setMessageMap(msg)
 } 

 public void setMessageMap(msg) {
   xmsgmap = msg;
 }

 public void setXWiki(xwiki) {
   this.xwiki = xwiki;
 }

 public void setContext(context) {
   this.context = context;
 }

 public String getMessage(msgid) {
   def msg2 = xmsgmap.get("curriki_" + msgid)
   if ((msg2==null)||(msg2=="curriki_" + msgid)) {
    def msg3 = msgmap.get(msgid)
    if (msg3==null)
     return msgid
    else
     return msg3
   }
   else
    return msg2 
 }

 public String getMessage() {
   return getMessage(message)
 }

 public String getMessageCode() {
   return message
 }

 public boolean isValidPassword(request) {
   def password = request.get("XWiki.XWikiUsers_0_password");
   def password2 = request.get("2XWiki.XWikiUsers_0_password");

   if ((password==null)||(password.equals(""))) {
    message = "empty_password";
    return false;
   }
   
   if ((password2==null)||(!password.equals(password2))) {
    message =  "unmatched_password";
    return false;
   }
   
   return true;
 }

 public boolean isValidAccount(account) {
   if (!account.equals("") && account.replaceAll("[a-zA-Z0-9]","").equals("")) {
    if (xwiki.exists("XWiki.${account}") || "superadmin".equals("${account}")) {
     message = "account_already_exists";
     return false;
    }
    else {
     return true;
    }
   }
   else {
    message = "account_notvalid";
    return false;
   }
 }

 public boolean isValidEmail(request) {
   def email = request.get("XWiki.XWikiUsers_0_email");
   def atIndex = email.indexOf("@");

   def query = ",BaseObject as obj, StringProperty as prop where doc.fullName=obj.name and obj.className='XWiki.XWikiUsers' and obj.id=prop.id.id and prop.id.name='email' and prop.value='"+email+"'";

   // Check to see if the email address is already used
   if (xwiki.searchDocuments(query).size() > 0) {
     message = "email_already_exists";
     return false;
   }

   // We should make this a bit better...
   if ((atIndex < 1) || (email.lastIndexOf(".") <= (atIndex+1)) || (email.length() <= (email.lastIndexOf(".") + 1)) || (email.lastIndexOf("@") != atIndex) || !email.matches("[a-zA-Z0-9_+=\\.-]+@([a-zA-Z0-9-]+[\\.])+([a-zA-Z]){2,4}")) {
     message = "email_notvalid";
     return false;
   }
   return true;
 }

 public Document getUserDocument(request, generatePassword, withValidation) {
   def account = request.get("xwikiname");
   password = request.get("XWiki.XWikiUsers_0_password");

   if (!isValidAccount(account)){
     return null;
   }

   if (!generatePassword) {
     if (!isValidPassword(request)){
       return null;
     }
   }

   if (!isValidEmail(request)){
     return null;
   }
   
   def userdoc = new Document(xwiki.xWiki.getDocument("XWiki.${account}", context.context), context.context);
   userdoc.addObjectFromRequest("XWiki.XWikiUsers");
   def userobj = userdoc.getObject("XWiki.XWikiUsers");

   if (generatePassword) {
     password = org.apache.commons.lang.RandomStringUtils.randomAlphanumeric(8);
     userobj.set("password", password);
   }  

   if (withValidation) {
     userobj.set("active", "0");
     userobj.set("email_undeliverable", "1");
     validkey = xwiki.xWiki.generateValidationKey(16);
     userobj.set("validkey", validkey);
     if (request.xredirect!=null)
      userobj.set("validredirect", request.xredirect);
   } else {
     userobj.set("active", "1");
     userobj.set("email_undeliverable", "0");
   }

   //userdoc.setParent("XWiki.XWikiUsers");
   userdoc.setContent('#include' + 'Form("XWiki.XWikiUserSheet")');
   userdoc.getDoc().setCreator(userdoc.getFullName());
   userdoc.getDoc().setAuthor(userdoc.getFullName());

   def rightobj = userdoc.newObject("XWiki.XWikiRights");
   rightobj.set("users", new String("${account}"));
   rightobj.set("allow", new String("1"));
   rightobj.set("levels", new String("edit"));
   rightobj.set("groups", new String(""));
   return userdoc;
 }

 public boolean createAccount(request) {
   return createAccount(request, false);
 }

 public boolean createAccount(request, generatePassword) {
   return createAccount(request, false, true);
 }

 public boolean createAccount(request, generatePassword, withValidation) {
   def userdoc = getUserDocument(request, generatePassword, withValidation);

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

   if (userdoc.validate()) {
     //userdoc.saveWithProgrammingRights();
     xwiki.xWiki.saveDocument(userdoc.getDoc(), "", context.getContext());
     // CURRIKI-738 - removed - xwiki.addToAllGroup(request.xwikiname);
     if (withValidation) {
       xwiki.xWiki.sendValidationEmail(userdoc.name, password, request.get("XWiki.XWikiUsers_0_email"), validkey, "validation_email_content", context.getContext());
     } else {
       xwiki.sendConfirmationMail(userdoc.name, password, request.get("XWiki.XWikiUsers_0_email"), "confirmation_email_content");
     }

     return true; 
    }

    message = "validation_failed";
    return false;
 }

 public boolean validateUser() {
   return validateUser(true);
 }

 public boolean validateUser(withConfirmEmail){
  try {
   return (xwiki.validateUser(withConfirmEmail) ==0);
  } catch (Exception e){
   return false;
  }
 }
}
/* *# */