/// <summary>
 /// Unregister the profiler using %SystemRoot%\system\regsvr32.exe
 /// </summary>
 /// <param name="registration">User - use the /n /i:user switches</param>
 public static void Unregister(Registration registration)
 {
     if (registration == Registration.Normal || registration == Registration.User)
     {
         ExecuteRegsvr32(registration == Registration.User, false);
     }
 }

        /* Register Button */
        private void btnRegister_Click(object sender, EventArgs e)
        {
            try
            {
                custID = Convert.ToInt32(cmbCustomer.SelectedValue);
                prodCode = cmbProduct.SelectedValue.ToString();
                regDate = DTPickerRegistration.Value;

                Registration rego = new Registration(custID, prodCode, regDate);
                //RegistrationDB.AddRegistration(rego);
                if (RegistrationDB.AddRegistration(rego) == true)
                {
                    MessageBox.Show("Registration Complete.");
                    clearForm();
                }
                else
                {
                    MessageBox.Show("Registration Failed.");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, ex.GetType().ToString());
            }
        }

 public void ValidateTemplateRegistrationAfterRegister(Registration registration, string zumoInstallationId)
 {
     ValidateTemplateRegistration(registration);
     Assert.IsNotNull(registration.RegistrationId);
     Assert.IsTrue(registration.Tags.Contains(zumoInstallationId));
     Assert.AreEqual(registration.Tags.Count(), DefaultTags.Length + 1);
 }

        public object GetInstance(Container container, Registration reg)
        {
            if (reg.Instance == null)
                reg.Instance = reg.CreateInstance(container);

            return reg.Instance;
        }

        public static void SendInvitationEmail(string username, string sendername, string email,Guid teamid)
        {
            try
            {
                Registration reg = new Registration();
                string tid = reg.MD5Hash(email);
                MailHelper mailhelper = new MailHelper();
                string mailpath = HttpContext.Current.Server.MapPath("~/Layouts/Mails/SendInvitation.htm");
                string html = File.ReadAllText(mailpath);
                string fromemail = ConfigurationManager.AppSettings["fromemail"];
                string usernameSend = ConfigurationManager.AppSettings["username"];
                string host = ConfigurationManager.AppSettings["host"];
                string port = ConfigurationManager.AppSettings["port"];
                string pass = ConfigurationManager.AppSettings["password"];
                string urllogin = "http://woosuite.socioboard.com/Default.aspx";
                string registrationurl = "http://woosuite.socioboard.com/Registration.aspx?tid="+teamid;
                string Body = mailhelper.InvitationMail(html, username, sendername, "", urllogin, registrationurl);
                string Subject = "You've been Invited to " + username + " Moople Social Account";
                //   MailHelper.SendMailMessage(host, int.Parse(port.ToString()), fromemail, pass, email, string.Empty, string.Empty, Subject, Body);

                MailHelper.SendSendGridMail(host, Convert.ToInt32(port), fromemail, "", email, "", "", Subject, Body, usernameSend, pass);

            }
            catch (Exception ex)
            {

                logger.Error(ex.Message);
            }
        }

        protected override bool Validator(Registration.Registration registration, DateTime datetime)
        {
            bool drive = true;

            int position = registration.Number.Length -1;

            String digit = registration.Number.Substring(position,1);

            string weekday = datetime.DayOfWeek.ToString();

            if (weekday == WeekDay.week_day.Monday.ToString() && (digit == "1" || digit == "2"))
            {
                drive = false;
            }
            else if (weekday == WeekDay.week_day.Tuesday.ToString() && (digit == "3" || digit == "4"))
            {
                drive = false;
            }
            else if (weekday == WeekDay.week_day.Wednesday.ToString() && (digit == "5" || digit == "6"))
            {
                drive = false;
            }
            else if (weekday == WeekDay.week_day.Thursday.ToString() && (digit == "7" || digit == "8"))
            {
                drive = false;
            }
            else if (weekday == WeekDay.week_day.Friday.ToString() && (digit == "9" || digit == "0"))
            {
                drive = false;
            }

            return drive;
        }

        public string Login(string EmailId, string Password)
        {
            //
            try
            {
                UserRepository userrepo = new UserRepository();
                Registration regObject = new Registration();
                User user = userrepo.GetUserInfo(EmailId, regObject.MD5Hash(Password));

                if (user != null)
                {
                    return new JavaScriptSerializer().Serialize(user);
                }
                else
                {
                    return "Invalid user name or password";
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.StackTrace);
                return null;
            }
        }

        public void ValidateTemplateRegistration(Registration registration)
        {
            var mpnsTemplateRegistration = (MpnsTemplateRegistration)registration;
            Assert.AreEqual(mpnsTemplateRegistration.BodyTemplate, BodyTemplate);

            foreach (KeyValuePair<string, string> header in DefaultHeaders)
            {
                Assert.IsTrue(mpnsTemplateRegistration.MpnsHeaders.ContainsKey(header.Key));
                Assert.AreEqual(mpnsTemplateRegistration.MpnsHeaders[header.Key], header.Value);
            }

            foreach (KeyValuePair<string, string> header in DetectedHeaders)
            {
                Assert.IsTrue(mpnsTemplateRegistration.MpnsHeaders.ContainsKey(header.Key));
                Assert.AreEqual(mpnsTemplateRegistration.MpnsHeaders[header.Key], header.Value);
            }

            Assert.AreEqual(mpnsTemplateRegistration.MpnsHeaders.Count, DefaultHeaders.Count + DetectedHeaders.Count);

            foreach (string tag in DefaultTags)
            {
                Assert.IsTrue(registration.Tags.Contains(tag));
            }

            Assert.AreEqual(mpnsTemplateRegistration.Name, DefaultToastTemplateName);
            Assert.AreEqual(mpnsTemplateRegistration.TemplateName, DefaultToastTemplateName);
        }

        private void SubscribeToService()
        {
            try
            {
                // Get User
                User msgUser = new User();

                var msg = new GetUserMessage(this, message =>
                {
                    msgUser = message;
                });

                Messenger.Default.Send(msg);

                // Create Registration
                Registration registration = new Registration();
                registration.URI = httpChannel.ChannelUri.ToString();
                registration.UserId = msgUser.UserId;

                // Register
                CapitalServiceClient client = new CapitalServiceClient();
                client.RegisterCompleted += (s, e) => { };
                client.RegisterAsync(registration);
            }
            catch
            {

            }
        }

        public String ValidateSchedule(Schedule.Schedule schedule, Registration.Registration vehicle)
        {
            String information = "";

            try
            {

                if (comboBoxCountry.SelectedItem.ToString() == Registration.Country.country_name.Ecuador.ToString())
                {
                    vehicle = new Registration.EcuadorRegistration(this.textBoxRegistration.Text);

                    schedule = new Schedule.EcuadorSchedule();

                    DateTime dt = new DateTime();

                    dt = Convert.ToDateTime(dateTimePicker.Text);

                    if (!(schedule as Schedule.EcuadorSchedule).EcuadorValidator(vehicle, dt))

                        information = "El vehículo con matrícula " + vehicle.Number + " no puede conducir en la ciudad de Quito entre las las 7:00 y las 9:30 en la mañana y entre las 16:00 y las 19:30 en la tarde y noche.";
                    else
                        information = "El vehículo con matrícula " + vehicle.Number + " puede conducir libremente en la ciudad de Quito en la fecha seleccionada.";
                }
                else
                    information = "Información solo disponible para " + Registration.Country.country_name.Ecuador.ToString();

            }
            catch (Exception exception)
            {
                information = exception.Message;
            }

            return information;
        }

        public HarmonizeConnector(Registration.IFactory registrationFactory, With.Messaging.Client.IEndpoint messagingEndpoint)
        {
            _registrationFactory = registrationFactory;
            _messagingEndpoint = messagingEndpoint;

            _registrations = new Registration.Collection();
        }

        public void ValidateTemplateRegistration(Registration registration)
        {
            var mpnsTemplateRegistration = (MpnsTemplateRegistration)registration;
            Assert.AreEqual(mpnsTemplateRegistration.BodyTemplate, BodyTemplate);

            foreach (KeyValuePair<string, string> header in DefaultHeaders)
            {
                string foundKey = mpnsTemplateRegistration.MpnsHeaders.Keys.Single(s => s.ToLower() == header.Key.ToLower());
                Assert.IsNotNull(foundKey);
                Assert.AreEqual(mpnsTemplateRegistration.MpnsHeaders[foundKey], header.Value);
            }

            foreach (KeyValuePair<string, string> header in DetectedHeaders)
            {

                string foundKey = mpnsTemplateRegistration.MpnsHeaders.Keys.Single(s => s.ToLower() == header.Key.ToLower());
                Assert.IsNotNull(foundKey);
                Assert.AreEqual(mpnsTemplateRegistration.MpnsHeaders[foundKey], header.Value);
            }

            Assert.AreEqual(mpnsTemplateRegistration.MpnsHeaders.Count, DefaultHeaders.Count + DetectedHeaders.Count);

            foreach (string tag in DefaultTags)
            {
                Assert.IsTrue(registration.Tags.Contains(tag));
            }

            Assert.AreEqual(mpnsTemplateRegistration.Name, DefaultToastTemplateName);
            Assert.AreEqual(mpnsTemplateRegistration.TemplateName, DefaultToastTemplateName);
        }

    private string[] AddRegister()
    {
        var regs = new Registration()
                                {
                                    Adress = txtAdres.Text,
                                    BirthDate = txtDogumTar.Text,
                                    BirthPlace = txtDogumYeri.Text,
                                    Chapter = txtBolum.Text,
                                    FatherJob = txtBabaMeslek.Text,
                                    FatherName = txtBabaMeslek.Text,
                                    FatherTNo = txtBabaTCKNo.Text,
                                    MailAdress = txtMail.Text,
                                    MobileNumber = txtCepNo.Text,
                                    MotherJob = txtAnneMeslek.Text,
                                    MotherName = txtAnneAdi.Text,
                                    Name = txtAd.Text,
                                    Number = txtTel.Text,
                                    SchoolLeaver = txtMezunOkul.Text,
                                    Surname = txtSoyad.Text,
                                    TCKNo = txtTckNo.Text
                                };
        string[] returnResult = _registrationBusiness.AddRegistrtaion(regs);

        return returnResult;
    }

        // Register a node address for a given mesh ID
        public int Register(string meshId, PeerNodeAddress nodeAddress)
        {
            bool newMeshId = false;
            int registrationId;
            Registration registration = new Registration(meshId, nodeAddress);

            // Add the new registration to the registration table; update meshIdTable with the newly registered nodeAddress
            lock (registrationTable)
            {
                registrationId = nextRegistrationId++;
                lock (meshIdTable)
                {
                    // Update the meshId table
                    Dictionary<int, PeerNodeAddress> addresses;
                    if (!meshIdTable.TryGetValue(meshId, out addresses))
                    {
                        // MeshID doesn't exist and needs to be added to meshIdTable
                        newMeshId = true;
                        addresses = new Dictionary<int, PeerNodeAddress>();
                        meshIdTable[meshId] = addresses;
                    }
                    addresses[registrationId] = nodeAddress;

                    // Add an entry to the registration table
                    registrationTable[registrationId] = new Registration(meshId, nodeAddress);
                }
            }
            if (newMeshId)
                Console.WriteLine("Registered new meshId {0}", meshId);
            return registrationId;
        }

		public void CheckEquality( Registration sut, string key, string other )
		{
			sut.Key = key;

			Assert.True( sut.Equals( key ) );

			Assert.False( sut.Equals( other ) );
		} 

 public void a_AddValid()
 {
     var response = client.AddRegistration(entity);
     WasSuccessfulTest(response);
     Assert.True(response.Data.id > 0);
     Assert.True(response.Data.data_saved.id == response.Data.id);
     entity = response.Data.data_saved;
 }

        private void ReplaceOriginalExpression(Registration decoratorRegistration)
        {
            this.e.Expression = decoratorRegistration.BuildExpression(this.e.InstanceProducer);

            this.e.ReplacedRegistration = decoratorRegistration;

            this.e.InstanceProducer.IsDecorated = true;
        }

 public void ValidateTemplateRegistrationAfterRegister(Registration registration)
 {
     ValidateTemplateRegistration(registration);
     Assert.IsNotNull(registration.RegistrationId);
     // TODO: Uncomment when .Net Runtime implements installationID
     //Assert.IsTrue(registration.Tags.Contains(zumoInstallationId));
     //Assert.AreEqual(registration.Tags.Count(), DefaultTags.Length + 1);
 }

 internal override void Execute()
 {
     var cmdlet = (ReceiveTmxTestTaskCommand)Cmdlet;
     var clientSettings = ClientSettings.Instance;
     clientSettings.StopImmediately = false;
     
     var taskLoader = new TaskLoader(new RestRequestCreator());
     // 20141020 squeezing a task to its proxy
     ITestTask task = null;
     // ITestTaskProxy task = null;
     // ITestTaskCodeProxy task = null;
     
     // temporarily
     // TODO: to a template method
     var startTime = DateTime.Now;
     while (!clientSettings.StopImmediately) {
         
         // TODO: move to aspect
         try {
             task = taskLoader.GetCurrentTask();
         }
         catch (ClientNotRegisteredException) {
             if (Guid.Empty != ClientSettings.Instance.ClientId && string.Empty != ClientSettings.Instance.ServerUrl) {
                 var registration = new Registration(new RestRequestCreator());
                 ClientSettings.Instance.ClientId = registration.SendRegistrationInfoAndGetClientId(ClientSettings.Instance.CurrentClient.CustomString);
             }
             
             // TODO: AOP
             Trace.TraceWarning("ReceiveTestTaskCommand.1");
             // temporary
             Trace.TraceWarning("ClientNotRegisteredException");
             
             throw;
         }
         catch (Exception e) {
             // NullreferenceException
             
             // TODO: AOP
             Trace.TraceWarning("ReceiveTestTaskCommand.2");
             // temporary
             Trace.TraceWarning(e.Message);
         }
         
         if (null != task)
             break;
         
         if (!cmdlet.Continuous)
             if ((DateTime.Now - startTime).TotalSeconds >= cmdlet.Seconds)
                 throw new Exception("Failed to receive a task in " + cmdlet.Seconds + " seconds");
         
         System.Threading.Thread.Sleep(Preferences.ReceivingTaskSleepIntervalMilliseconds);
     }
     
     clientSettings.StopImmediately = false;
     clientSettings.CurrentTask = task;
     
     cmdlet.WriteObject(task);
 }

        internal InitializationContext(InstanceProducer producer, Registration registration)
        {
            // producer will be null when a user calls Registration.BuildExpression() directly, instead of
            // calling InstanceProducer.BuildExpression() or InstanceProducer.GetInstance(). 
            Requires.IsNotNull(registration, nameof(registration));

            this.Producer = producer;
            this.Registration = registration;
        }