public function postVideo()
{
ini_set('max_execution_time', 300);
$userid = Auth::user()->id;
$idcurso = Input::get('idcurso');
$recurso = new Recurso();
$recurso->nombre = Input::get('nombre');
$recurso->descripcion = Input::get('descripcion');
//$file = Input::file('image');
$recurso->activo = Input::get('activo');
$recurso->id_user = 1;
$recurso->id_curso = $idcurso;
$recurso->save();
$the_id = $recurso->id;
$recurso = Recurso::find($the_id);
$destinationPath = 'temp/';
$file = Input::file('video');
$filename = $userid . "" . $file->getClientOriginalName();
Input::file('video')->move($destinationPath, $filename);
$file = ParseFile::createFromFile($destinationPath . "/" . $filename, $filename);
$file->save();
$url = $file->getURL();
$recurso->URL = "" . $url;
$jobApplication = new ParseObject("recursos");
$jobApplication->set("myid", $the_id);
$jobApplication->set("res", $file);
$jobApplication->save();
$recurso->save();
File::delete($destinationPath . "/" . $filename);
}
public function add($data)
{
$filePath = $data["uploadPhoto"]["tmp_name"];
$ext = pathinfo($data["uploadPhoto"]["name"], PATHINFO_EXTENSION);
$file = ParseFile::createFromFile($filePath, $data["username"] . "." . $ext);
$file->save();
$url = $file->getUrl();
$cp = new ParseObject("_User");
$cp->set("username", $data["username"]);
$cp->set("password", 'leafblast');
$cp->set("firstName", $data["firstName"]);
$cp->set("lastName", $data["lastName"]);
$cp->set("email", $data["email"]);
$cp->set("homeAddress", $data["homeAddress"]);
$cp->set("phoneNumber", $data["phoneNumber"]);
$cp->set("operatorPicture", $file);
$cp->set("isOperator", true);
$cp->set("isRemoved", false);
$cp->set("isSuspended", true);
$cp->set("isFirstTime", true);
$cp->set("isDeactivated", true);
try {
$cp->save();
// die('<pre>'.print_r($cp, true));
$cu = new ParseObject("UserData");
$cu->set("user", $cp);
$cu->save();
return $cp->getObjectId();
} catch (ParseException $ex) {
die('<pre>' . print_r($ex->getMessage(), true));
}
}
public function agregar()
{
$userid = Auth::user()->id;
$curso = new Curso();
$curso->nombre = Input::get('nombre');
$curso->descripcion = Input::get('descripcion');
//$file = Input::file('image');
$curso->activo = Input::get('activo');
$curso->tipo = Input::get('tipo');
$curso->basefile = "";
$curso->id_user = 1;
$curso->save();
$the_id = $curso->id;
$curso = Curso::find($the_id);
$file = Input::file('logo');
$destinationPath = 'temp/';
$filename = $userid . "" . $file->getClientOriginalName();
Input::file('logo')->move($destinationPath, $filename);
$file = ParseFile::createFromFile($destinationPath . "/" . $filename, $filename);
$file->save();
$url = $file->getURL();
$curso->img = "" . $url;
$jobApplication = new ParseObject("cursos");
$jobApplication->set("myid", $the_id);
$jobApplication->set("img", $file);
$jobApplication->save();
$curso->save();
File::delete($destinationPath . "/" . $filename);
}
private function _addTestObjects($numberOfObjects = 5)
{
$objects = [];
for ($i = 0; $i < $numberOfObjects; $i++) {
$object = new ParseObject($this->testParseClassName);
$object->set('String', 'String' . $i);
$objects[] = $object;
}
ParseObject::saveAll($objects);
}
/**
* Creates a new item and associates it with the current user. Redirects to the app (PRG) and uses the flash message
* to pass on any errors.
*
* @throws \Exception
*/
public function addAction()
{
if (!$this->request instanceof \Zend\Http\Request or !$this->request->isPost()) {
return;
//nothing to do
}
$item = new ParseObject(self::PARSE_CLASS);
$item->set('todoItem', $this->request->getPost('item'));
$item->set('user', $this->user);
try {
$item->save();
} catch (ParseException $e) {
$this->flashMessenger()->addErrorMessage($e->getMessage());
}
$this->redirect()->toRoute('app');
}
public function __construct($objectId = null)
{
parent::__construct("Camera", $objectId, false);
$query = new ParseQuery("Camera");
$query->equalTo("objectId", $objectId);
$this->_cam = $query->first();
}
public function __construct($objectId = null)
{
parent::__construct("AnimalV2", $objectId, false);
$query = new ParseQuery("AnimalV2");
$query->equalTo("objectId", $objectId);
$this->_animal = $query->first();
}
/**
* Gets a query that can be used to query the objects in this relation.
*
* @return ParseQuery That restricts the results to objects in this relations.
*/
public function getQuery()
{
$query = new ParseQuery($this->targetClassName);
$query->relatedTo('object', $this->parent->_toPointer());
$query->relatedTo('key', $this->key);
return $query;
}
/**
* Store a newly created resource in storage.
*
* @return Response
*/
public function store()
{
try {
ParseClient::initialize(env('PARSE_ID', 'f**k'), env('PARSE_REST', 'f**k'), env('PARSE_MASTER', 'f**k'));
$data = Input::file('file');
$path = $data->getRealPath();
$mime = $data->getMimeType();
$nomeOriginal = $data->getClientOriginalName();
$nomeCorrigido = preg_replace('/\\s+/', '', $nomeOriginal);
$file = ParseFile::createFromFile($path, $nomeCorrigido, $mime);
$file->save();
$nome = Input::get('nome');
$especialidadeId = Input::get('especialidadeId');
$especQuery = new ParseQuery("Especialidade");
$especialidade = $especQuery->get($especialidadeId);
$anexo = ParseObject::create("Anexo");
$anexo->set('conteudo', $file);
$anexo->set('nome', $nome);
$anexo->set('especialidade', $especialidade);
$anexo->save();
return json_encode(['url' => $anexo->get('conteudo')->getURL(), 'Id' => $anexo->getObjectId()]);
} catch (ParseException $error) {
return $error;
}
}
public function purchase()
{
$input = Input::all();
$mailEmail = strpos($input['stripeEmail'], "mail.mcgill.ca");
//send back if not a validStripe Token
if (empty($input['stripeToken'])) {
return Redirect::back();
}
//Charge Customer
$charge = Stripe::charges()->create(['source' => $input['stripeToken'], 'receipt_email' => $input['stripeEmail'], 'currency' => 'CAD', 'amount' => env($input['sponsor'] . "_PRICE")]);
//Save to Parse
$object = ParseObject::create("Transaction");
$objectId = $object->getObjectId();
// Set values:
$object->set("name", $input['email']);
$object->set("email", $input['stripeEmail']);
$object->set("studentID", $input['IdNumber']);
$object->set("sponsor", $input['sponsor']);
$object->set("stripeToken", $input['stripeToken']);
$object->set("used", false);
$object->set("deal", env($input['sponsor'] . "_DEAL_TITLE"));
$object->set("deployment", env('DEPLOYMENT'));
$object->set("experation", env($input['sponsor'] . "_EXPIRATION"));
// Save:
$object->save();
//data to pass
$data = ["expirationdate" => env($input['sponsor'] . "_EXPIRATION"), "sponsorName" => env($input['sponsor'] . "_RETAILER"), "stripeOrderNumber" => $charge['id'], "price" => env($input['sponsor'] . "_PRICE"), "email" => $input['email'], "flag" => "true"];
$email = $input['stripeEmail'];
Mail::send('email.billing', $data, function ($message) use($email) {
$message->to($email)->subject('Thank you for Your Order');
});
return View::make('thanks', $data)->with('data', $data);
}
public function testFunctionsWithObjectParamsFails()
{
$obj = ParseObject::create('SomeClass');
$obj->set('name', 'Zanzibar');
$obj->save();
$params = ['key1' => $obj];
$this->setExpectedException('\\Exception', 'ParseObjects not allowed');
ParseCloud::run('foo', $params);
}
public function update($obj)
{
if (empty($obj)) {
die("No hay asistentes para Actualizar.");
}
$con = new Connect();
$var = $con->connect_to_db();
$date = new DateTime();
$resultado = new ParseObject("Asistencia", $obj["IdUsuario"]);
$resultado->set("Fecha", $date);
$resultado->set("Presente", $obj["Presente"]);
try {
$resultado->save();
echo 'El objeto fue actualizado: ' . $resultado->getObjectId();
} catch (ParseException $ex) {
echo 'Fallo al actualizar, mensaje de error: ' . $ex->getMessage();
}
}
public function testParseBytesFromBase64Data()
{
$obj = ParseObject::create('BytesObject');
$bytes = ParseBytes::createFromBase64Data('R3JhbnRsYW5k');
$obj->set('byteColumn', $bytes);
$obj->save();
$query = new ParseQuery('BytesObject');
$objAgain = $query->get($obj->getObjectId());
$this->assertEquals('Grantland', $objAgain->get('byteColumn'));
}
public function save($useMasterKey = false)
{
if (!$this->getACL()) {
throw new ParseException("Roles must have an ACL.");
}
if (!$this->getName() || !is_string($this->getName())) {
throw new ParseException("Roles must have a name.");
}
return parent::save($useMasterKey);
}
/**
* Create a new user instance after a valid registration.
*
* @param array $data
*
* @return User
*/
public function create(array $data)
{
$userSubclass = ParseObject::getRegisteredSubclass('_User');
$user = new $userSubclass();
$user->username = isset($data['username']) ? $data['username'] : $data['email'];
$user->email = $data['email'];
$user->password = $data['password'];
$user->signUp();
return $user;
}
public function dtestParseBytesFromBase64Data()
{
$obj = ParseObject::create("TestObject");
$bytes = ParseBytes::createFromBase64Data("R3JhbnRsYW5k");
$obj->set("byteColumn", $bytes);
$obj->save();
$query = new ParseQuery("TestObject");
$objAgain = $query->get($obj->getObjectId());
$this->assertEquals("Grantland", $objAgain->get("byteColumn"));
}
/**
* Envia push de atualizaçao.
*
* @return Response
*/
public function enviarAtualizacao()
{
try {
ParseClient::initialize('YZzX02HIZ0xnl2XgzYRHB9QRwYr6FBgWrDUYl5w0', 'zNGQwg11i4fQRhGUCZIR777A8VRWjCqe3BQeZgDI', '4neCCcchvafqvgZlnVu0c4q3s3nsmh9n5tYV0x2o');
$session = Cache::get('sessionToken', 'default');
$usuario = ParseUser::become($session);
$texto = Input::get('texto');
$atualizacaoQuery = new ParseQuery("Atualizacao");
$atualizacaoQuery->descending("numero");
$ultimaAtualizacao = $atualizacaoQuery->first();
$novoNumero = $ultimaAtualizacao->get('numero') + 1;
$novaAtualizacao = new ParseObject("Atualizacao");
$novaAtualizacao->set('numero', $novoNumero);
$novaAtualizacao->set('usuario', $usuario);
$novaAtualizacao->set('texto', $texto);
$novaAtualizacao->save();
// $fields = array('Accept'=>'application/json',
// 'X-Parse-Application-Id' => 'YZzX02HIZ0xnl2XgzYRHB9QRwYr6FBgWrDUYl5w0',
// 'X-Parse-Master-Key' => '4neCCcchvafqvgZlnVu0c4q3s3nsmh9n5tYV0x2o');
// $ch = curl_init();
// curl_setopt($ch, CURLOPT_URL, 'https://api.parse.com/1/jobs/jobTeste');
// curl_setopt($ch, CURLOPT_RETURNTRANSFER, false);
// curl_setopt($ch, CURLOPT_HEADER, $fields);
// curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
// // curl_setopt(CURLOPT_USERPWD, 'XXXXXX');
// $result = curl_exec($ch);
// curl_close($ch);
// $cmd='curl -X POST \
// -H \"X-Parse-Application-Id: YZzX02HIZ0xnl2XgzYRHB9QRwYr6FBgWrDUYl5w0\" \
// -H \"X-Parse-Master-Key: 4neCCcchvafqvgZlnVu0c4q3s3nsmh9n5tYV0x2o\" \
// -H \"Content-Type: application/json\" \
// -d \"{\"plan\":\"paid\"}\" \
// https://api.parse.com/1/jobs/jobTeste';
// Log::info($cmd);
// exec($cmd,$result);
Log::info("CHEGUEI NEGAO");
// Log::info($result);
return 200;
} catch (ParseException $error) {
return $error;
}
}
public function postUpdate($objectId)
{
$object = ParseObject::create("todo", $objectId);
if (\Input::has('title')) {
$object->set("title", \Input::get('title'));
}
if (\Input::has('completed')) {
$object->set("completed", filter_var(\Input::get('completed'), FILTER_VALIDATE_BOOLEAN));
}
$object->save();
}
/**
* Validate a user against the given credentials.
*
* @param \Illuminate\Contracts\Auth\Authenticatable $user
* @param array $credentials
*
* @return bool
*/
public function validateCredentials(Authenticatable $user, array $credentials)
{
try {
$username = $this->getUsernameFromCredentials($credentials);
/** @var ParseUser $userClass */
$userClass = ParseObject::getRegisteredSubclass('_User');
$userClass::logIn($username, $credentials['password']);
return true;
} catch (ParseException $error) {
return false;
}
}
function upload_to_parse($name, $image, $description, $archive)
{
$obj = ParseObject::create("News");
try {
$file_image = ParseFile::createFromFile($image, basename($image));
$obj->set("image", $file_image);
$obj->set("caption", $name);
$obj->save();
} catch (\Parse\ParseException $e) {
print $e;
}
}
function newActivityObject()
{
$object = new ParseObject("Activity");
$object->set("phoneNumber", $_REQUEST['From']);
$object->set("body", $_REQUEST['Body']);
$object->set("to", $_REQUEST['To']);
$object->set("fromCountry", $_REQUEST['FromCountry']);
$object->set("messageSid", $_REQUEST['MessageSid']);
$object->save();
}
public function addTask(Request $request)
{
$parseTask = new ParseObject("Task");
$parseCropQuery = new ParseQuery("Crop");
$parseCropQuery->equalTo("cropName", $request->input('crop'));
$crop = $parseCropQuery->first();
$parseQuery = new ParseQuery("Task");
$parseQuery->equalTo("cropName", $crop);
$parseQuery->equalTo("taskDesc", $request->input('taskName'));
if ($parseQuery->count() > 0) {
return redirect('/tasks');
}
$parseTask->set("cropName", $crop);
$parseTask->set("taskDesc", $request->input('taskName'));
$parseTask->set("taskDuration", $request->input('taskDuration'));
$parseTask->set("taskStart", $request->input('taskStart'));
try {
$parseTask->save();
\Session::put('message', 1);
return redirect('tasks');
} catch (ParseException $e) {
\Session::put('message', -1);
return redirect('tasks');
}
}
public function upload(Request $request)
{
if (isset($_FILES['image'])) {
// save file to Parse
try {
$fname = str_replace(' ', '', $_FILES['image']['name']);
$file = ParseFile::createFromData(file_get_contents($_FILES['image']['tmp_name']), $fname);
$file->save();
// save something to class TestObject
$asset = new ParseObject("Assets");
// add the file we saved above
$asset->set("file", $file);
$asset->save();
$ret = ['status' => 'success', 'data' => ['asset' => ['id' => $asset->getObjectId()], 'file' => ['url' => $file->getUrl()]]];
return response()->json($ret);
} catch (ParseException $ex) {
$ret = ['status' => 'fail', 'error' => $ex->getMessage()];
return response()->json($ret);
}
} else {
$ret = ['status' => 'fail', 'error' => 'no file selected'];
return response()->json($ret);
}
}
function getStolenBikes()
{
$query = new ParseQuery("Bikes");
$query->exists("sessionStartTime");
$query->limit(1000);
$results = $query->find();
$count = count($results);
$listOfBikes = array();
$stolenBikes = 0;
for ($i = 0; $i < $count; $i++) {
$startDate = $results[$i]->get("sessionStartTime");
$startDate = $startDate->format('Y-m-d H:i:s');
$startDate = strtotime($startDate);
$currentDate = new DateTime('now');
$currentDate = $currentDate->format('Y-m-d H:i:s');
$currentDate = strtotime($currentDate);
$subtractedDate = $currentDate - $startDate;
$expiredTime = 200 * 60;
if ($subtractedDate >= $expiredTime * 60) {
$stolenBikes++;
$bike = $results[$i];
try {
$lostBike = new ParseObject("LostBikes");
$lostBike->set("bikeId", $bike->getObjectId());
$user = $bike->get("currentUser");
$user->fetch();
$customerID = $user->get("stripeID");
$amount = 200 * 100;
$charge = \Stripe\Charge::create(array('customer' => $customerID, 'amount' => $amount, 'currency' => 'usd'));
$lostBike->set("currentUser", $user);
$lostBike->set("lastLocation", $bike->get("lastLocation"));
$lostBike->set("condition", $bike->get("condition"));
$lostBike->save();
$bike->destroy();
} catch (\Parse\ParseException $ex) {
return 'Failed to create LostBikes object and destroy Bikes object ' . $ex->getMessage();
} catch (\Stripe\Error\InvalidRequest $e) {
return $e->getMessage();
} catch (\Stripe\Error\Authentication $e) {
return $e->getMessage();
} catch (\Stripe\Error\ApiConnection $e) {
return $e->getMessage();
} catch (\Stripe\Error\Base $e) {
return $e->getMessage();
} catch (Exception $e) {
return $e->getMessage();
}
}
}
$rString = 0;
if ($stolenBikes > 0) {
$rString = "Successfully removed " . $stolenBikes . " stolen bikes.";
}
return $rString;
}
public function testQueryDataUnt()
{
$department = "ACCT";
$course = "2010";
$section = "001";
$obj = ParseObject::create('TestObject');
$obj->set('department', $department);
$obj->set('course', $course);
$obj->set('section', $section);
$obj->save();
$query = new ParseQuery('TestObject');
$query->startsWith('department', $department);
$query->equalTo('course', $course);
$query->startsWith('section', $section);
$query->limit(1);
$response = $query->find();
$this->assertTrue(count($response) == 1);
}
public function store(ValidateAddExpert $request)
{
$expert = new ParseObject("experts");
$expert->set("name", $request->get('name'));
$expert->set("email", $request->get('email'));
$expert->set("password", bcrypt($request->get('password')));
$cityID = $request->get('city');
$c = new ParseQuery("Cities");
$city = $c->get($cityID);
$expert->set("city", $city);
$expert->save();
return \Redirect::route('addExpert')->with('message', 'Expert has been created');
}
/**
* Store a newly created resource in storag
*
* @return Response
*/
public function store()
{
try {
ParseClient::initialize(env('PARSE_ID', 'Credenciais Parse'), env('PARSE_REST', 'Credenciais Parse'), env('PARSE_MASTER', 'Credenciais Parse'));
$input = Request::all();
$especialidade = ParseObject::create("Especialidade");
$nome = $input['nome'];
if (!strlen($nome)) {
throw new Exception("Nome da especialidade não pode ser vazio", 2);
}
$especialidade->set('nome', $nome);
$especialidade->set('origem', $input['origem']);
$especialidade->save();
$id = $especialidade->getObjectId();
return Redirect::action('EspecialidadeController@show', array($id));
} catch (ParseException $error) {
return $error;
}
}
/**
* Show the form for creating a new resource.
*
* @return Response
*/
public function create()
{
try {
ParseClient::initialize(env('PARSE_ID', 'f**k'), env('PARSE_REST', 'f**k'), env('PARSE_MASTER', 'f**k'));
$session = Cache::get('sessionToken', 'default');
$user = ParseUser::become($session);
$nome = Input::get('nome');
$especialidadeId = Input::get('especialidadeId');
$especQuery = new ParseQuery("Especialidade");
$especialidade = $especQuery->get($especialidadeId);
$protocolo = ParseObject::create("Protocolo");
$protocolo->set('nome', $nome);
$protocolo->set('especialidade', $especialidade);
$protocolo->save();
$id = $protocolo->getObjectId();
return $id;
} catch (ParseException $error) {
return $error;
}
}
/**
* Update the specified resource in storage.
*
* @param int $id
* @return Response
*/
public function update()
{
try {
ParseClient::initialize(env('PARSE_ID', 'f**k'), env('PARSE_REST', 'f**k'), env('PARSE_MASTER', 'f**k'));
$condicoesJSON = Input::get('condicoes');
$condicoes = json_decode($condicoesJSON);
$protocoloId = Input::get('id');
$protocoloQuery = new ParseQuery("Protocolo");
$protocolo = $protocoloQuery->get($protocoloId);
$condQuery = new ParseQuery("DescritivoMinimo");
$condQuery->equalTo('protocolo', $protocolo);
$condicoesFromServer = $condQuery->find();
$condicoesArray = [];
for ($serverIndex = 0; $serverIndex < count($condicoesFromServer); $serverIndex++) {
$present = false;
if (array_key_exists($serverIndex, $condicoesFromServer)) {
$keysArray = array_keys($condicoes);
for ($localIndex = 0; $localIndex < count($keysArray); $localIndex++) {
if (array_key_exists($keysArray[$localIndex], $condicoes)) {
if ($condicoes[$keysArray[$localIndex]]->id == $condicoesFromServer[$serverIndex]->getObjectId()) {
$present = true;
$condicoesFromServer[$serverIndex]->set('ordem', $condicoes[$keysArray[$localIndex]]->ordem);
$condicoesFromServer[$serverIndex]->save();
$condicoesArray[$condicoes[$keysArray[$localIndex]]->ordem] = $condicoesFromServer[$serverIndex]->getObjectId();
unset($condicoes[$keysArray[$localIndex]]);
}
}
}
if ($present == false) {
$condicoesFromServer[$serverIndex]->destroy();
}
}
}
$keysArray = array_keys($condicoes);
for ($index = 0; $index < count($keysArray); $index++) {
$condicao = new ParseObject("DescritivoMinimo");
$condicao->set('frase', $condicoes[$keysArray[$index]]->frase);
$condicao->set('ordem', $condicoes[$keysArray[$index]]->ordem);
$condicao->set('protocolo', $protocolo);
$condicao->save();
$condicoesArray[$condicoes[$keysArray[$index]]->ordem] = $condicao->getObjectId();
}
return json_encode($condicoesArray);
} catch (ParseException $error) {
dd($error);
return $error;
}
}
public function testFunctions()
{
$params = array('key1' => 'value1', 'key2' => array(1, 2, 3));
$response = ParseCloud::run('foo', $params);
$obj = $response['object'];
$this->assertTrue($obj instanceof ParseObject);
$this->assertEquals('Foo', $obj->className);
$this->assertEquals(2, $obj->get('x'));
$relation = $obj->get('relation');
$this->assertTrue($relation instanceof ParseObject);
$this->assertEquals('Bar', $relation->className);
$this->assertEquals(3, $relation->get('x'));
$obj = $response['array'][0];
$this->assertTrue($obj instanceof ParseObject);
$this->assertEquals('Bar', $obj->className);
$this->assertEquals(2, $obj->get('x'));
$response = ParseCloud::run('foo', array('key1' => 'value1'));
$this->assertEquals(2, $response['a']);
try {
$response = ParseCloud::run('bar', array('key1' => 'value1'));
$this->fail('Should have thrown an exception.');
} catch (Parse\ParseException $ex) {
// A parse exception should occur.
}
$response = ParseCloud::run('bar', array('key2' => 'value1'));
$this->assertEquals('Foo', $response);
$obj = ParseObject::create('SomeClass');
$obj->set('name', 'Zanzibar');
$obj->save();
$params = array('key2' => 'value1', 'key1' => $obj);
try {
$response = ParseCloud::run('foo', $params);
$this->fail('Should have thrown an exception.');
} catch (\Exception $ex) {
// An exception should occur.
}
}
