2010-09-09 03:14:17 +00:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								< ? php 
							 
						 
					
						
							
								
									
										
										
										
											2010-12-10 04:41:42 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								/** 
							 
						 
					
						
							
								
									
										
										
										
											2020-02-09 15:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  @ copyright  Copyright  ( C )  2020 ,  Friendica 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  @ license  GNU  AGPL  version  3  or  any  later  version 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  This  program  is  free  software :  you  can  redistribute  it  and / or  modify 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  it  under  the  terms  of  the  GNU  Affero  General  Public  License  as 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  published  by  the  Free  Software  Foundation ,  either  version  3  of  the 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  License ,  or  ( at  your  option )  any  later  version . 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  This  program  is  distributed  in  the  hope  that  it  will  be  useful , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  but  WITHOUT  ANY  WARRANTY ;  without  even  the  implied  warranty  of 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  MERCHANTABILITY  or  FITNESS  FOR  A  PARTICULAR  PURPOSE .   See  the 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  GNU  Affero  General  Public  License  for  more  details . 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  You  should  have  received  a  copy  of  the  GNU  Affero  General  Public  License 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  along  with  this  program .   If  not ,  see  < https :// www . gnu . org / licenses />. 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  Automatic  post - databse  structure  change  updates 
							 
						 
					
						
							
								
									
										
										
										
											2010-12-10 04:41:42 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-19 14:24:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  These  functions  are  responsible  for  doing  critical  post  update  changes  to  the  data  ( not  the  structure )  in  the  database . 
							 
						 
					
						
							
								
									
										
										
										
											2014-06-03 22:44:58 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
									
										
										
										
											2019-06-23 17:56:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  Database  structure  changes  are  done  in  static / dbstructure . config . php 
							 
						 
					
						
							
								
									
										
										
										
											2010-12-10 04:41:42 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-19 14:24:46 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  For  non - critical  database  migrations ,  please  add  a  method  in  the  Database\PostUpdate  class 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  If  there  is  a  need  for  a  post  update  to  a  structure  change ,  update  this  file 
							 
						 
					
						
							
								
									
										
										
										
											2017-12-22 21:31:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  by  adding  a  new  function  at  the  end  with  the  number  of  the  new  DB_UPDATE_VERSION . 
							 
						 
					
						
							
								
									
										
										
										
											2010-12-10 04:41:42 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
									
										
										
										
											2017-12-22 21:31:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  The  numbered  script  in  this  file  has  to  be  exactly  like  the  DB_UPDATE_VERSION 
							 
						 
					
						
							
								
									
										
										
										
											2010-12-10 04:41:42 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
									
										
										
										
											2017-12-22 14:48:29 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  Example : 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  You  are  currently  on  version  4711  and  you  are  preparing  changes  that  demand  an  update  script . 
							 
						 
					
						
							
								
									
										
										
										
											2010-12-10 04:41:42 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
									
										
										
										
											2017-12-22 21:31:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  1.  Create  a  function  " update_4712() "  here  in  the  update . php 
							 
						 
					
						
							
								
									
										
										
										
											2019-06-23 17:56:21 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 *  2.  Apply  the  needed  structural  changes  in  static / dbStructure . php 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  3.  Set  DB_UPDATE_VERSION  in  static / dbstructure . config . php  to  4712. 
							 
						 
					
						
							
								
									
										
										
										
											2018-07-20 19:47:16 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 * 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								 *  If  you  need  to  run  a  script  before  the  database  update ,  name  the  function  " pre_update_4712() " 
							 
						 
					
						
							
								
									
										
										
										
											2010-12-10 04:41:42 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								 */ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-02-09 15:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								use  Friendica\Core\Logger ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								use  Friendica\Core\Update ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								use  Friendica\Core\Worker ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-11-19 19:34:48 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								use  Friendica\Database\Database ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-02-09 15:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								use  Friendica\Database\DBA ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-06-06 20:43:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								use  Friendica\Database\DBStructure ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-02-09 15:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								use  Friendica\DI ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								use  Friendica\Model\Contact ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								use  Friendica\Model\Item ; 
							 
						 
					
						
							
								
									
										
										
										
											2021-01-23 09:53:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								use  Friendica\Model\Notification ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-08-21 18:37:58 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								use  Friendica\Model\Photo ; 
							 
						 
					
						
							
								
									
										
										
										
											2021-01-16 04:11:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								use  Friendica\Model\Post ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-02-09 15:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								use  Friendica\Model\Storage ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								use  Friendica\Worker\Delivery ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2018-12-18 16:53:00 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								// Post-update script of PR 5751
 
							 
						 
					
						
							
								
									
										
										
										
											2018-12-24 10:15:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								function  update_1298 () 
							 
						 
					
						
							
								
									
										
										
										
											2018-12-20 10:49:58 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2018-12-24 10:15:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									$keys  =  [ 'gender' ,  'marital' ,  'sexual' ]; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									foreach  ( $keys  as  $translateKey )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										$allData  =  DBA :: select ( 'profile' ,  [ 'id' ,  $translateKey ]); 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-18 19:55:41 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										$allLangs  =  DI :: l10n () -> getAvailableLanguages (); 
							 
						 
					
						
							
								
									
										
										
										
											2018-12-24 10:15:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										$success  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										$fail  =  0 ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										foreach  ( $allData  as  $key  =>  $data )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											$toTranslate  =  $data [ $translateKey ]; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											if  ( $toTranslate  !=  '' )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												foreach  ( $allLangs  as  $key  =>  $lang )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													$a  =  new  \stdClass (); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													$a -> strings  =  []; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													// First we get the the localizations
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if  ( file_exists ( " view/lang/ $lang /strings.php " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														include  " view/lang/ $lang /strings.php " ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if  ( file_exists ( " addon/morechoice/lang/ $lang /strings.php " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														include  " addon/morechoice/lang/ $lang /strings.php " ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													$localizedStrings  =  $a -> strings ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													unset ( $a ); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													$key  =  array_search ( $toTranslate ,  $localizedStrings ); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													if  ( $key  !==  false )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														break ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													// defaulting to empty string
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													$key  =  '' ; 
							 
						 
					
						
							
								
									
										
										
										
											2018-12-20 16:43:07 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2018-12-24 10:15:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												if  ( $key  ==  '' )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													$fail ++ ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
												}  else  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													DBA :: update ( 'profile' ,  [ $translateKey  =>  $key ],  [ 'id'  =>  $data [ 'id' ]]); 
							 
						 
					
						
							
								
									
										
										
										
											2018-12-30 20:42:56 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													Logger :: notice ( 'Updated contact' ,  [ 'action'  =>  'update' ,  'contact'  =>  $data [ 'id' ],  " $translateKey "  =>  $key , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
														'was'  =>  $data [ $translateKey ]]); 
							 
						 
					
						
							
								
									
										
										
										
											2019-04-05 18:04:39 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													Worker :: add ( PRIORITY_LOW ,  'ProfileUpdate' ,  $data [ 'id' ]); 
							 
						 
					
						
							
								
									
										
										
										
											2018-12-24 10:15:32 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
													Contact :: updateSelfFromUserID ( $data [ 'id' ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
													$success ++ ; 
							 
						 
					
						
							
								
									
										
										
										
											2018-12-20 16:43:07 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
												} 
							 
						 
					
						
							
								
									
										
										
										
											2018-12-18 16:53:00 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
										
										
											2018-12-24 09:53:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2018-12-30 20:42:56 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										Logger :: notice ( $translateKey  .  "  fix completed " ,  [ 'action'  =>  'update' ,  'translateKey'  =>  $translateKey ,  'Success'  =>  $success ,  'Fail'  =>  $fail  ]); 
							 
						 
					
						
							
								
									
										
										
										
											2018-12-24 09:53:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2019-04-05 18:04:39 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1309 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									$queue  =  DBA :: select ( 'queue' ,  [ 'id' ,  'cid' ,  'guid' ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									while  ( $entry  =  DBA :: fetch ( $queue ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										$contact  =  DBA :: selectFirst ( 'contact' ,  [ 'uid' ],  [ 'id'  =>  $entry [ 'cid' ]]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if  ( ! DBA :: isResult ( $contact ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											continue ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2021-01-16 04:11:28 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										$item  =  Post :: selectFirst ([ 'id' ,  'gravity' ],  [ 'uid'  =>  $contact [ 'uid' ],  'guid'  =>  $entry [ 'guid' ]]); 
							 
						 
					
						
							
								
									
										
										
										
											2019-04-05 18:04:39 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if  ( ! DBA :: isResult ( $item ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											continue ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										$deliver_options  =  [ 'priority'  =>  PRIORITY_MEDIUM ,  'dont_fork'  =>  true ]; 
							 
						 
					
						
							
								
									
										
										
										
											2019-06-10 14:19:24 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										Worker :: add ( $deliver_options ,  'Delivery' ,  Delivery :: POST ,  $item [ 'id' ],  $entry [ 'cid' ]); 
							 
						 
					
						
							
								
									
										
										
										
											2020-02-16 11:32:18 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										Logger :: info ( 'Added delivery worker' ,  [ 'item'  =>  $item [ 'id' ],  'contact'  =>  $entry [ 'cid' ]]); 
							 
						 
					
						
							
								
									
										
										
										
											2019-04-05 20:24:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										DBA :: delete ( 'queue' ,  [ 'id'  =>  $entry [ 'id' ]]); 
							 
						 
					
						
							
								
									
										
										
										
											2019-04-05 18:04:39 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2019-06-29 08:30:48 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1315 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2020-08-22 05:22:08 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( DBStructure :: existsTable ( 'item-delivery-data' ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										DBA :: delete ( 'item-delivery-data' ,  [ 'postopts'  =>  '' ,  'inform'  =>  '' ,  'queue_count'  =>  0 ,  'queue_done'  =>  0 ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2019-07-09 07:23:36 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1318 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									DBA :: update ( 'profile' ,  [ 'marital'  =>  " In a relation " ],  [ 'marital'  =>  " Unavailable " ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									DBA :: update ( 'profile' ,  [ 'marital'  =>  " Single " ],  [ 'marital'  =>  " Available " ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Worker :: add ( PRIORITY_LOW ,  'ProfileUpdate' ); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
									
										
										
										
											2019-07-07 22:00:48 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2019-09-19 03:54:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1323 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									$users  =  DBA :: select ( 'user' ,  [ 'uid' ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									while  ( $user  =  DBA :: fetch ( $users ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Contact :: updateSelfFromUserID ( $user [ 'uid' ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									DBA :: close ( $users ); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2019-12-17 07:10:55 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								function  update_1327 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									$contacts  =  DBA :: select ( 'contact' ,  [ 'uid' ,  'id' ,  'blocked' ,  'readonly' ],  [ " `uid` != ? AND (`blocked` OR `readonly`) AND NOT `pending` " ,  0 ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									while  ( $contact  =  DBA :: fetch ( $contacts ))  { 
							 
						 
					
						
							
								
									
										
										
										
											2020-08-04 04:47:02 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										Contact\User :: setBlocked ( $contact [ 'id' ],  $contact [ 'uid' ],  $contact [ 'blocked' ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										Contact\User :: setIgnored ( $contact [ 'id' ],  $contact [ 'uid' ],  $contact [ 'readonly' ]); 
							 
						 
					
						
							
								
									
										
										
										
											2019-12-17 07:10:55 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									DBA :: close ( $contacts ); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-01-06 20:14:01 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								function  update_1330 () 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-05 00:58:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-19 20:21:13 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									$currStorage  =  DI :: config () -> get ( 'storage' ,  'class' ,  '' ); 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-05 00:58:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-01-06 21:46:22 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									// set the name of the storage instead of the classpath as config
 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-05 00:58:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( ! empty ( $currStorage ))  { 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-06 21:46:22 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										/** @var Storage\IStorage $currStorage */ 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-19 20:21:53 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										if  ( ! DI :: config () -> set ( 'storage' ,  'name' ,  $currStorage :: getName ()))  { 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-06 20:14:01 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
											return  Update :: FAILED ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-06 22:23:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										// try to delete the class since it isn't needed. This won't work with config files
 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-19 20:22:33 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										DI :: config () -> delete ( 'storage' ,  'class' ); 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-05 00:58:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-01-06 21:46:22 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									// Update attachments and photos
 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-17 22:47:26 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: p ( " UPDATE `photo` SET `photo`.`backend-class` = SUBSTR(`photo`.`backend-class`, 25) WHERE `photo`.`backend-class` LIKE 'Friendica \\ \ Model \\ \ Storage \\ \ %' ESCAPE '|' " )  || 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									    ! DBA :: p ( " UPDATE `attach` SET `attach`.`backend-class` = SUBSTR(`attach`.`backend-class`, 25) WHERE `attach`.`backend-class` LIKE 'Friendica \\ \ Model \\ \ Storage \\ \ %' ESCAPE '|' " ))  { 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-06 20:14:01 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									}; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-01-05 00:58:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-19 14:43:59 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1332 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									$condition  =  [ " `is-default` IS NOT NULL " ]; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									$profiles  =  DBA :: select ( 'profile' ,  [],  $condition ); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									while  ( $profile  =  DBA :: fetch ( $profiles ))  { 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-23 19:00:35 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										DI :: profileField () -> migrateFromLegacyProfile ( $profile ); 
							 
						 
					
						
							
								
									
										
										
										
											2020-01-19 14:43:59 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									DBA :: close ( $profiles ); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									DBA :: update ( 'contact' ,  [ 'profile-id'  =>  null ],  [ '`profile-id` IS NOT NULL' ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-09 15:38:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1347 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									foreach  ( Item :: ACTIVITIES  as  $index  =>  $activity )  { 
							 
						 
					
						
							
								
									
										
										
										
											2020-11-19 19:34:48 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										DBA :: insert ( 'verb' ,  [ 'id'  =>  $index  +  1 ,  'name'  =>  $activity ],  Database :: INSERT_IGNORE ); 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-09 15:38:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 14:55:03 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  pre_update_1348 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 17:41:16 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: exists ( 'contact' ,  [ 'id'  =>  0 ]))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										DBA :: insert ( 'contact' ,  [ 'nurl'  =>  '' ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										$lastid  =  DBA :: lastInsertId (); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if  ( $lastid  !=  0 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											DBA :: update ( 'contact' ,  [ 'id'  =>  0 ],  [ 'id'  =>  $lastid ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 17:37:02 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 14:55:03 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									// The tables "permissionset" and "tag" could or could not exist during the update.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									// This depends upon the previous version. Depending upon this situation we have to add
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									// the "0" values before adding the foreign keys - or after would be sufficient.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									update_1348 (); 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 17:37:02 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-08-24 20:06:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									DBA :: e ( " DELETE FROM `auth_codes` WHERE NOT `client_id` IN (SELECT `client_id` FROM `clients`) " ); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									DBA :: e ( " DELETE FROM `tokens` WHERE NOT `client_id` IN (SELECT `client_id` FROM `clients`) " ); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 17:37:02 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 14:55:03 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1348 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									// Insert a permissionset with id=0
 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 17:48:34 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									// Inserting it without an ID and then changing the value to 0 tricks the auto increment
 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 17:41:16 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: exists ( 'permissionset' ,  [ 'id'  =>  0 ]))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										DBA :: insert ( 'permissionset' ,  [ 'allow_cid'  =>  '' ,  'allow_gid'  =>  '' ,  'deny_cid'  =>  '' ,  'deny_gid'  =>  '' ]); 	
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										$lastid  =  DBA :: lastInsertId (); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if  ( $lastid  !=  0 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											DBA :: update ( 'permissionset' ,  [ 'id'  =>  0 ],  [ 'id'  =>  $lastid ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 17:37:02 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 17:41:16 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: exists ( 'tag' ,  [ 'id'  =>  0 ]))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										DBA :: insert ( 'tag' ,  [ 'name'  =>  '' ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										$lastid  =  DBA :: lastInsertId (); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if  ( $lastid  !=  0 )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											DBA :: update ( 'tag' ,  [ 'id'  =>  0 ],  [ 'id'  =>  $lastid ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 17:37:02 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-10 14:55:03 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-19 20:28:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1349 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2021-01-30 22:03:53 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( ! DBStructure :: existsTable ( 'item-activity' ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-05-19 20:28:27 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									$correct  =  true ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									foreach  ( Item :: ACTIVITIES  as  $index  =>  $activity )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if  ( ! DBA :: exists ( 'verb' ,  [ 'id'  =>  $index  +  1 ,  'name'  =>  $activity ]))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											$correct  =  false ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! $correct )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										// The update failed - but it cannot be recovered, since the data doesn't match our expectation
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										// This means that we can't use this "shortcut" to fill the "vid" field and we have to rely upon
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										// the postupdate. This is not fatal, but means that it will take some longer time for the system
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										// to fill all data.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `item` INNER JOIN `item-activity` ON `item`.`uri-id` = `item-activity`.`uri-id`
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										SET  `vid`  =  `item-activity` . `activity`  +  1  WHERE  `gravity`  =  ?  AND  ( `vid`  IS  NULL  OR  `vid`  =  0 ) " , GRAVITY_ACTIVITY))  { 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-28 21:44:55 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1351 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `thread` INNER JOIN `item` ON `thread`.`iid` = `item`.`id` SET `thread`.`uri-id` = `item`.`uri-id` " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2020-06-06 20:43:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  pre_update_1354 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
									
										
										
										
											2020-06-07 16:41:01 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( DBStructure :: existsColumn ( 'contact' ,  [ 'ffi_keyword_blacklist' ]) 
							 
						 
					
						
							
								
									
										
										
										
											2020-07-16 10:23:56 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										&&  ! DBStructure :: existsColumn ( 'contact' ,  [ 'ffi_keyword_denylist' ]) 
							 
						 
					
						
							
								
									
										
										
										
											2020-06-06 20:43:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										&&  ! DBA :: e ( " ALTER TABLE `contact` CHANGE `ffi_keyword_blacklist` `ffi_keyword_denylist` text null " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2020-07-16 18:30:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1354 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( DBStructure :: existsColumn ( 'contact' ,  [ 'ffi_keyword_blacklist' ]) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										&&  DBStructure :: existsColumn ( 'contact' ,  [ 'ffi_keyword_denylist' ]))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										if  ( ! DBA :: e ( " UPDATE `contact` SET `ffi_keyword_denylist` = `ffi_keyword_blacklist` " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										} 
							 
						 
					
						
							
								
									
										
										
										
											2020-06-06 20:43:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-07-16 18:30:20 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										// When the data had been copied then the main task is done.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										// Having the old field removed is only beauty but not crucial.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										// So we don't care if this was successful or not.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										DBA :: e ( " ALTER TABLE `contact` DROP `ffi_keyword_blacklist` " ); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2020-06-06 20:43:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2020-07-19 10:03:33 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1357 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `contact` SET `failed` = true WHERE `success_update` < `failure_update` AND `failed` IS NULL " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `contact` SET `failed` = false WHERE `success_update` > `failure_update` AND `failed` IS NULL " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `contact` SET `failed` = false WHERE `updated` > `failure_update` AND `failed` IS NULL " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `contact` SET `failed` = false WHERE `last-item` > `failure_update` AND `failed` IS NULL " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `gserver` SET `failed` = true WHERE `last_contact` < `last_failure` AND `failed` IS NULL " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `gserver` SET `failed` = false WHERE `last_contact` > `last_failure` AND `failed` IS NULL " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2020-08-14 19:21:49 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  pre_update_1358 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `contact-relation` WHERE NOT `relation-cid` IN (SELECT `id` FROM `contact`) OR NOT `cid` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2020-08-21 18:37:58 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  pre_update_1363 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									Photo :: delete ([ " `contact-id` != ? AND NOT `contact-id` IN (SELECT `id` FROM `contact`) " ,  0 ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-08-24 20:06:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  pre_update_1364 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `2fa_recovery_codes` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `2fa_app_specific_password` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `attach` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `clients` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `conv` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `fsuggest` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `group` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-08-24 21:03:00 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `intro` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-08-24 20:06:06 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `manage` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `manage` WHERE NOT `mid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `mail` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `mailacct` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `notify` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `openwebauth-token` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `pconfig` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `profile` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `profile_check` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `profile_field` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `push_subscriber` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `register` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `search` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `tokens` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `user-contact` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `user-item` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `notify-threads` WHERE NOT `receiver-uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `event` WHERE NOT `cid` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `fsuggest` WHERE NOT `cid` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `group_member` WHERE NOT `contact-id` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `intro` WHERE NOT `contact-id` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `participation` WHERE NOT `cid` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `profile_check` WHERE NOT `cid` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `user-contact` WHERE NOT `cid` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `participation` WHERE NOT `fid` IN (SELECT `id` FROM `fcontact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `group_member` WHERE NOT `gid` IN (SELECT `id` FROM `group`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `gserver-tag` WHERE NOT `gserver-id` IN (SELECT `id` FROM `gserver`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `participation` WHERE NOT `iid` IN (SELECT `id` FROM `item`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `user-item` WHERE NOT `iid` IN (SELECT `id` FROM `item`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2020-08-26 05:32:47 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  pre_update_1365 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `notify-threads` WHERE NOT `notify-id` IN (SELECT `id` FROM `notify`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `thread` WHERE NOT `iid` IN (SELECT `id` FROM `item`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-11-14 14:50:24 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-08-26 07:01:01 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2020-11-13 10:05:52 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1375 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `item` SET `thr-parent` = `parent-uri`, `thr-parent-id` = `parent-uri-id` WHERE `thr-parent` = '' " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2020-11-17 22:33:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  pre_update_1376 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									// Insert a user with uid=0
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									DBStructure :: checkInitialValues (); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `item` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `event` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `thread` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `permissionset` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `openwebauth-token` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `post-category` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-11-19 06:26:30 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									Photo :: delete ([ " NOT `uid` IN (SELECT `uid` FROM `user`) " ]); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-11-17 22:33:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `contact` WHERE NOT `uid` IN (SELECT `uid` FROM `user`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-11-19 06:26:30 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  pre_update_1377 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									DBStructure :: checkInitialValues (); 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `item` WHERE NOT `author-id` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `item` WHERE NOT `owner-id` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `item` SET `contact-id` = `owner-id` WHERE NOT `contact-id` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `thread` WHERE NOT `author-id` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `thread` WHERE NOT `owner-id` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `thread` SET `contact-id` = `owner-id` WHERE NOT `contact-id` IN (SELECT `id` FROM `contact`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `notify` SET `uri-id` = NULL WHERE `uri-id` = 0 " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2021-01-07 18:13:40 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( DBStructure :: existsTable ( 'diaspora-interaction' )  &&  ! DBA :: e ( " DELETE FROM `diaspora-interaction` WHERE `uri-id` NOT IN (SELECT `id` FROM `item-uri`) " ))  { 
							 
						 
					
						
							
								
									
										
										
										
											2021-01-07 17:34:23 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2021-01-07 18:24:26 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( DBStructure :: existsTable ( 'item-activity' )  &&  ! DBA :: e ( " DELETE FROM `item-activity` WHERE `uri-id` NOT IN (SELECT `id` FROM `item-uri`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( DBStructure :: existsTable ( 'item-content' )  &&  ! DBA :: e ( " DELETE FROM `item-content` WHERE `uri-id` NOT IN (SELECT `id` FROM `item-uri`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-11-19 06:26:30 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `notify` WHERE `uri-id` NOT IN (SELECT `id` FROM `item-uri`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `notify` SET `parent-uri-id` = NULL WHERE `parent-uri-id` = 0 " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `notify` WHERE `parent-uri-id` NOT IN (SELECT `id` FROM `item-uri`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `notify-threads` SET `master-parent-uri-id` = NULL WHERE `master-parent-uri-id` = 0 " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `notify-threads` WHERE `master-parent-uri-id` NOT IN (SELECT `id` FROM `item-uri`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " DELETE FROM `notify-threads` WHERE `master-parent-item` NOT IN (SELECT `id` FROM `item`) " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
									
										
										
										
											2020-11-17 22:33:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2020-11-25 19:56:39 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1380 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `notify` INNER JOIN `item` ON `item`.`id` = `notify`.`iid` SET `notify`.`uri-id` = `item`.`uri-id` WHERE `notify`.`uri-id` IS NULL AND `notify`.`otype` IN (?, ?) " , 
							 
						 
					
						
							
								
									
										
										
										
											2021-01-23 09:53:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										Notification\ObjectType :: ITEM ,  Notification\ObjectType :: PERSON ))  { 
							 
						 
					
						
							
								
									
										
										
										
											2020-11-25 19:56:39 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " UPDATE `notify` INNER JOIN `item` ON `item`.`id` = `notify`.`parent` SET `notify`.`parent-uri-id` = `item`.`uri-id` WHERE `notify`.`parent-uri-id` IS NULL AND `notify`.`otype` IN (?, ?) " , 
							 
						 
					
						
							
								
									
										
										
										
											2021-01-23 09:53:44 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										Notification\ObjectType :: ITEM ,  Notification\ObjectType :: PERSON ))  { 
							 
						 
					
						
							
								
									
										
										
										
											2020-11-25 19:56:39 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2021-01-28 22:45:54 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  pre_update_1395 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( DBStructure :: existsTable ( 'post-user' )  &&  ! DBA :: e ( " DROP TABLE `post-user` " ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1395 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " INSERT INTO `post-user`(`id`, `uri-id`, `uid`, `contact-id`, `unseen`, `origin`, `psid`)
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										SELECT  `id` ,  `uri-id` ,  `uid` ,  `contact-id` ,  `unseen` ,  `origin` ,  `psid`  FROM  `item` 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ON  DUPLICATE  KEY  UPDATE  `contact-id`  =  `item` . `contact-id` ,  `unseen`  =  `item` . `unseen` ,  `origin`  =  `item` . `origin` ,  `psid`  =  `item` . `psid` " ))  { 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " INSERT INTO `post-user`(`uri-id`, `uid`, `hidden`, `notification-type`)
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										SELECT  `uri-id` ,  `user-item` . `uid` ,  `hidden` , `notification-type`  FROM  `user-item` 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											INNER  JOIN  `item`  ON  `item` . `id`  =  `user-item` . `iid` 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										ON  DUPLICATE  KEY  UPDATE  `hidden`  =  `user-item` . `hidden` ,  `notification-type`  =  `user-item` . `notification-type` " ))  { 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
									
										
										
										
											2021-01-30 22:03:53 +00:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  update_1396 () 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								{ 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBStructure :: existsTable ( 'item-content' ))  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									if  ( ! DBA :: e ( " INSERT IGNORE INTO `post-content`(`uri-id`, `title`, `content-warning`, `body`, `raw-body`,
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										`location` ,  `coord` ,  `language` ,  `app` ,  `rendered-hash` ,  `rendered-html` , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										`object-type` ,  `object` ,  `target-type` ,  `target` ,  `resource-id` ,  `plink` ) 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										SELECT  `item-content` . `uri-id` ,  `item-content` . `title` ,  `item-content` . `content-warning` , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											`item-content` . `body` ,  `item-content` . `raw-body` ,  `item-content` . `location` ,  `item-content` . `coord` , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											`item-content` . `language` ,  `item-content` . `app` ,  `item-content` . `rendered-hash` , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											`item-content` . `rendered-html` ,  `item-content` . `object-type` ,  `item-content` . `object` , 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											`item-content` . `target-type` ,  `item-content` . `target` ,  `item` . `resource-id` ,  `item-content` . `plink` 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
											FROM  `item-content`  INNER  JOIN  `item`  ON  `item` . `uri-id`  =  `item-content` . `uri-id` " ))  { 
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
										return  Update :: FAILED ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
									return  Update :: SUCCESS ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								}