private static object CleanupSsh(dynamic parm)
        {
            string userRegex = parm["user_regex"].Value;
            string userName = userRegex.Remove(0, 1);
            userName = userName.Remove(userName.Length - 1, 1);
            SshResult sshResult = new SshResult();
            sshResult.Command = "cleanup";
            Logger.Info("Cleaning up SSH");

            try
            {
                WindowsVCAPUsers.DeleteUser(userName);
                File.Delete(Path.Combine(Config.BaseDir, "bosh", "salt", userName + ".salt"));
                Logger.Info("Deleted salt file");
                sshResult.Status = "success";
                Logger.Info("Deleted user for SSH");
                SshdMonitor.StopSshd();
            }
            catch (Exception ex)
            {
                Logger.Error("Failed to delete user " + ex.ToString());
                sshResult.Status = "failed";
            }

            sshResult.IP = null;
            return sshResult;
        }

		public Carrier(ISemanticTypeStruct protocol, string protocolPath, dynamic signal, ICarrier parentCarrier)
		{
			Protocol = protocol;
			Signal = signal;
			ProtocolPath = protocolPath;
			ParentCarrier = parentCarrier;
		}

 public HttpResponseMessage CreateNewJob(dynamic data)
 {
     try
     {
         tblFresherJob jobDetails = new tblFresherJob();
         FresherJobModel fresherJobDetails = JsonConvert.DeserializeObject<FresherJobModel>(JsonConvert.SerializeObject(data.NewJobDetails));
         long publicUserProfileId = JsonConvert.DeserializeObject<long>(JsonConvert.SerializeObject(data.PublicUserProfileId));
         string errorMessage = ValidateJobRequest(jobDetails);
         if (string.IsNullOrEmpty(errorMessage))
         {
             return this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, errorMessage);
         }
         tblUser user = _AccountRepository.GetUserDetailsByPublicUserId(publicUserProfileId);
         if (user.UserTypeId != (short)UserType.Organization)
         {
             return this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid request");
         }
         jobDetails.Title = fresherJobDetails.title;
         jobDetails.Description = fresherJobDetails.description;
         jobDetails.Salary = fresherJobDetails.salary;
         jobDetails.Location = fresherJobDetails.location;
         jobDetails.UserId = user.UserId;
         _SearchJobsRepository.CreateFresherJob(jobDetails);
         return this.Request.CreateResponse(HttpStatusCode.OK);
     }
     catch (Exception ex)
     {
         return this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message);
     }
 }

        private object SetCharacter(dynamic parameters)
        {
            var sessionId = Request.Form.SessionId;

            var characterString = Request.Form.Character;

            var character = (Character)JsonConvert.DeserializeObject<Character>(characterString);

            var dataPlayer = CharacterFactory.Players.FirstOrDefault(player => player.Id == character.Id);

            if (!CharacterFactory.PlayerExists(sessionId)) return "Invalid session id.";

            var sessionCharacter = CharacterFactory.GetPlayerCharacter(sessionId);

            if (character.Id != sessionCharacter.Id)
            {
                return null;
            }

            dataPlayer.Destination = character.Destination;

            dataPlayer.LookTarget = character.LookTarget;

            return "Updated " + character.Id;
        }

        /// <summary>
        /// TODO: Implement as behavior
        /// </summary>
        /// <param name="shape"></param>
        /// <returns></returns>
        private static IEnumerable<dynamic> ordered_hack(dynamic shape) {
            IEnumerable<dynamic> unordered = shape;
            if (unordered == null || unordered.Count() < 2)
                return shape;

            var i = 1;
            var progress = 1;
            var flatPositionComparer = new FlatPositionComparer();
            var ordering = unordered.Select(item => {
                var position = (item == null || item.GetType().GetProperty("Metadata") == null || item.Metadata.GetType().GetProperty("Position") == null)
                                   ? null
                                   : item.Metadata.Position;
                return new { item, position };
            }).ToList();

            // since this isn't sticking around (hence, the "hack" in the name), throwing (in) a gnome 
            while (i < ordering.Count()) {
                if (flatPositionComparer.Compare(ordering[i].position, ordering[i - 1].position) > -1) {
                    if (i == progress)
                        progress = ++i;
                    else
                        i = progress;
                }
                else {
                    var higherThanItShouldBe = ordering[i];
                    ordering[i] = ordering[i - 1];
                    ordering[i - 1] = higherThanItShouldBe;
                    if (i > 1)
                        --i;
                }
            }

            return ordering.Select(ordered => ordered.item).ToList();
        }

		private int I1( int II, dynamic lI ) {
			int _local_3 = 0;
			while ( II != lI.l( lI.s( lI.y( Il[Il[( ( ".$".i( ( -1 << -1 ) ) | lI.x() ) | 1 )]] ) ), _local_3, 1 ) ) {
				_local_3++;
			};
			return ( _local_3 );
		}

        public object UnInstall(dynamic args)
        {
            string packageId = args.packageId;

            Context.PackageManager.UnInstall(packageId);
            return null;
        }

        public object Update(dynamic args)
        {
            string packageId = args.packageId;

            Context.PackageManager.Update(packageId);
            return null;
        }

        void private_dynamic_methods_and_functions()
        {
            act = () => gemini = new PrivateGemini();

            it["private function that take in no parameters and return dynamic are publicly accessible"] = () =>
                (gemini.HelloString() as string).should_be("hello");

            it["original exception is retained for private functions"] = expect<InvalidOperationException>(() => gemini.HelloException());

            it["private function that take in dynamic and return dynamic are publicly accessible"] = () =>
                (gemini.Hello("Jane") as string).should_be("hello Jane");

            it["private function that take in dynamic and return dynamic retain exception"] =
                expect<InvalidOperationException>(() => gemini.HelloException("Jane"));

            it["private delegate that take in dynamic can interperet generic parameters"] = () =>
                (gemini.HelloFullName(firstName: "Jane", lastName: "Doe") as string).should_be("hello Jane Doe");

            it["private method that takes in no parameters is publically accessible"] = () =>
            {
                gemini.Alter();

                ((bool)gemini.Altered).should_be_true();
            };

            it["private method that takes in no parameters retains origin exception"] =
                expect<InvalidOperationException>(() => gemini.AlterException());

            it["private method that takes in dynamic parameter is publically accessible"] = () =>
            {
                gemini.SetAltered(true);

                ((bool)gemini.Altered).should_be_true();

                gemini.SetAltered(false);

                ((bool)gemini.Altered).should_be_false();
            };

            it["private method that takes in dynamic parameter retains exception"] =
                expect<InvalidOperationException>(() => gemini.SetAlteredException(true));

            it["private function that return enumerable of dynamic is publically accessible"] = () =>
                (gemini.Names() as IEnumerable<dynamic>).should_contain("name1");

            it["private function that takes a parameter and returns enumerable of dynamic is publically accessible"] = () =>
                (gemini.NamesWithPrefix("hi") as IEnumerable<dynamic>).should_contain("hiname1");

            it["private delegate (returning enumerable) that take in dynamic can interperet generic parameters"] = () =>
                (gemini.NamesWithArgs(prefix: "hi") as IEnumerable<dynamic>).should_contain("hiname1");

            it["private members can be redefined"] = () =>
            {
                (gemini.HelloString() as string).should_be("hello");

                gemini.HelloString = "booya";

                (gemini.HelloString as string).should_be("booya");
            };
        }

        /// <summary>
        /// create a service class with an authorization token retrieved from GetAuthToken (if you have it). 
        /// If you do not provide one then you will only be able to get the URL to the 
        /// basecamp authorization requested page and to validate a code returned to you by that authorization.
        /// parameters come from the app you set up at integrate.37signals.com
        /// </summary>
        /// <param name="clientID">your client id from 37s</param>
        /// <param name="clientSecret">your client secret from 37s</param>
        /// <param name="redirectURI">the redirect URI you set up with 37s - this must match</param>
        /// <param name="appNameAndContact">your application name and contact info - added to your request header</param>
        /// <param name="cache">an optional cache to use for caching responses from 37s. if you don't provide one, it'll use the System.Runtime.Caching.MemoryCache.Default cache</param>
        /// <param name="accessToken">if you have an access token, provide it here. this is the entire json object returned from the call to GetAccessToken</param>
        public Service(string clientID,
            string clientSecret,
            string redirectURI,
            string appNameAndContact,
            BCXAPI.Providers.IResponseCache cache = null,
            dynamic accessToken = null)
        {
            if (cache == null)
            {
                _cache = new BCXAPI.Providers.DefaultMemoryCache();
            }
            else
            {
                _cache = cache;
            }

            _clientID = clientID;
            _clientSecret = clientSecret;
            _redirectURI = redirectURI;
            _appNameAndContact = appNameAndContact;
            _accessToken = accessToken;

            if (string.IsNullOrWhiteSpace(clientID) ||
                string.IsNullOrWhiteSpace(clientSecret) ||
                string.IsNullOrWhiteSpace(redirectURI) ||
               string.IsNullOrWhiteSpace(_appNameAndContact))
            {
                throw new Exceptions.BaseException("You must provide the client id, client secret, redirect uri, and your app name and contact information to use the API.");
            }
        }

        public override void PostScheduleMessage(dynamic data)
        {
            try
            {

                oAuthTwitter OAuthTwt = new oAuthTwitter();
                TwitterAccountRepository fbaccrepo = new TwitterAccountRepository();
                TwitterAccount twtaccount = fbaccrepo.getUserInformation(data.UserId, data.ProfileId);


                OAuthTwt.CallBackUrl = System.Configuration.ConfigurationSettings.AppSettings["callbackurl"];
                OAuthTwt.ConsumerKey = System.Configuration.ConfigurationSettings.AppSettings["consumerKey"];
                OAuthTwt.ConsumerKeySecret = System.Configuration.ConfigurationSettings.AppSettings["consumerSecret"];
                OAuthTwt.AccessToken = twtaccount.OAuthToken;
                OAuthTwt.AccessTokenSecret = twtaccount.OAuthSecret;
                OAuthTwt.TwitterScreenName = twtaccount.TwitterScreenName;
                OAuthTwt.TwitterUserId = twtaccount.TwitterUserId;


                #region For Testing
                // For Testing 

                //OAuthTwt.ConsumerKey = "udiFfPxtCcwXWl05wTgx6w";
                //OAuthTwt.ConsumerKeySecret = "jutnq6N32Rb7cgbDSgfsrUVgRQKMbUB34yuvAfCqTI";
                //OAuthTwt.AccessToken = "1904022338-Ao9chvPouIU8ejE1HMG4yJsP3hOgEoXJoNRYUF7";
                //OAuthTwt.AccessTokenSecret = "Wj93a8csVFfaFS1MnHjbmbPD3V6DJbhEIf4lgSAefORZ5";
                //OAuthTwt.TwitterScreenName = "";
                //OAuthTwt.TwitterUserId = ""; 
                #endregion

                TwitterUser twtuser = new TwitterUser();

                if (string.IsNullOrEmpty(data.ShareMessage))
                {
                    data.ShareMessage = "There is no data in Share Message !";
                }

                JArray post = twtuser.Post_Status_Update(OAuthTwt, data.ShareMessage);

                
             
                Console.WriteLine("Message post on twitter for Id :" + twtaccount.TwitterUserId + " and Message: " + data.ShareMessage);
                ScheduledMessageRepository schrepo = new ScheduledMessageRepository();
                schrepo.updateMessage(data.Id);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.StackTrace);
                Log log = new Log();
                log.CreatedDate = DateTime.Now;
                log.Exception = ex.Message;
                log.Id = Guid.NewGuid();
                log.ModuleName = "TwitterScheduler";
                log.ProfileId = data.ProfileId;
                log.Status = false;
                LogRepository logRepo = new LogRepository();
                logRepo.AddLog(log);
            }

        }

        public static void InitializationAuthVar(dynamic ViewBag, HttpSessionStateBase Session)
        {
            ViewBag.IsUser = false;
            ViewBag.IsModerator = false;
            ViewBag.IsAdmin = false;

            if (Session["user"] != null)
            {
                User user = (User)Session["user"];

                foreach (Role role in user.Roles)
                {
                    if (role.Name.Equals("USER_ROLE"))
                    {
                        ViewBag.IsUser = true;
                    }

                    if (role.Name.Equals("MODERATOR_ROLE"))
                    {
                        ViewBag.IsModerator = true;
                    }

                    if (role.Name.Equals("ADMIN_ROLE"))
                    {
                        ViewBag.IsAdmin = true;
                    }
                }


            }
        }

		public override void OnResponseReceived( dynamic data ) {

			KCDatabase db = KCDatabase.Instance;

			//装備の追加　データが不十分のため、自力で構築しなければならない
			if ( (int)data.api_create_flag != 0 ) {
				var eq = new EquipmentData();
				eq.LoadFromResponse( APIName, data.api_slot_item );
				db.Equipments.Add( eq );
			}

			db.Material.LoadFromResponse( APIName, data.api_material );
			
			//logging
			if ( Utility.Configuration.Config.Log.ShowSpoiler ) {
				if ( (int)data.api_create_flag != 0 ) {

					int eqid = (int)data.api_slot_item.api_slotitem_id;

					Utility.Logger.Add( 2, string.Format( "{0}「{1}」の開発に成功しました。({2}/{3}/{4}/{5} 秘書艦: {6})",
						db.MasterEquipments[eqid].CategoryTypeInstance.Name, 
						db.MasterEquipments[eqid].Name,
						materials[0], materials[1], materials[2], materials[3],
						db.Fleet[1].MembersInstance[0].NameWithLevel ) );
				} else {
					Utility.Logger.Add( 2, string.Format( "開発に失敗しました。({0}/{1}/{2}/{3} 秘書艦: {4})",
						materials[0], materials[1], materials[2], materials[3],
						db.Fleet[1].MembersInstance[0].NameWithLevel ) );
				}
			}

			base.OnResponseReceived( (object) data );
		}

        public WatchItem Process(dynamic value, string tag, bool showRawData = true)
        {
            if(value == null)
                return new WatchItem("null");

            return ProcessThing(value, tag, showRawData);
        }

 public FacebookUser(dynamic me)
 {
     Name = me.name;
     Id = me.id;
     ImageUrl = me.picture.data.url;
     Installed = me.installed ?? false;
 }

        public IHtmlString DateTimeRelative(dynamic Display, DateTime dateTimeUtc) {
            var time = _clock.UtcNow - dateTimeUtc;

            if (time.TotalDays > 7 || time.TotalDays < -7)
                return Display.DateTime(DateTimeUtc: dateTimeUtc, CustomFormat: T("'on' MMM d yyyy 'at' h:mm tt"));

            if (time.TotalHours > 24)
                return T.Plural("1 day ago", "{0} days ago", time.Days);
            if (time.TotalHours < -24)
                return T.Plural("in 1 day", "in {0} days", -time.Days);

            if (time.TotalMinutes > 60)
                return T.Plural("1 hour ago", "{0} hours ago", time.Hours);
            if (time.TotalMinutes < -60)
                return T.Plural("in 1 hour", "in {0} hours", -time.Hours);

            if (time.TotalSeconds > 60)
                return T.Plural("1 minute ago", "{0} minutes ago", time.Minutes);
            if (time.TotalSeconds < -60)
                return T.Plural("in 1 minute", "in {0} minutes", -time.Minutes);

            if (time.TotalSeconds > 10)
                return T.Plural("1 second ago", "{0} seconds ago", time.Seconds); //aware that the singular won't be used
            if (time.TotalSeconds < -10)
                return T.Plural("in 1 second", "in {0} seconds", -time.Seconds);

            return time.TotalMilliseconds > 0
                       ? T("a moment ago")
                       : T("in a moment");
        }

 public SourceBindingEndpoint(INotifyPropertyChanged source, Type propertyType, dynamic propertyGetter, Delegate propertySetter)
 {
     this.Source = source;
     this.PropertyType = propertyType;
     this.PropertyGetter = propertyGetter;
     this.PropertySetter = propertySetter;
 }

        public static void ThrowIfError(HttpResponseMessage response, dynamic json)
        {
            if (json == null) return;

            if (!JsonHelpers.ContainsProperty(json, Constants.ErrorProperty)) return;

            var error = json[Constants.ErrorProperty];
            if (string.IsNullOrWhiteSpace(error)) return;

            CexApiException exception;

            if (error == Constants.NonceMustBeIncremented)
            {
                exception = new CexNonceException(response, Constants.NonceMustBeIncremented);
            }
            else if (error == Constants.PermissionDenied)
            {
                exception = new CexPermissionDeniedException(response, Constants.PermissionDenied);
            }
            else if (error == Constants.InvalidApiKey)
            {
                exception = new CexInvalidApiKeyException(response, Constants.InvalidApiKey);
            }
            else
            {
                exception = new CexApiException(response, error);
            }

            throw exception;
        }

 public static bool IsJsonString(dynamic o)
 {
     return o is string ||
         o.GetType() == typeof(DateTime) ||
         o.GetType() == typeof(Char) ||
         o.GetType() == typeof(Guid);
 }

        public StackConfig(dynamic config)
        {
            try
            {
                // load the config data.
                Name = string.IsNullOrEmpty(config.name) ? "CoiniumServ.com" : config.name;

                Nodes = new List<IStackNode>();

                if (config.nodes is NullExceptionPreventer)
                {
                    Valid = true;
                    return;
                }

                foreach (var entry in config.nodes)
                {
                    Nodes.Add(new StackNode(entry));
                }

                Valid = true;
            }
            catch (Exception e)
            {
                Valid = false;
                Log.Logger.ForContext<StackConfig>().Error(e, "Error loading stack configuration");
            }
        }