コード例 #1
0
 public static function checkPassword($entitySignature, $loginKey, $passwdKey, $login, $passwd)
 {
     $tag = "Login::checkPassword()";
     Log::notice("{$tag}: <{$login}>");
     try {
         $blueprint = BlueprintReader::read($entitySignature);
         $authTable = $blueprint->getKey();
         $passwdField = $blueprint->get($passwdKey);
         $encType = $passwdField->getEncType();
         if ($encType != "plain") {
             $passwd = hash($encType, $passwd);
         }
     } catch (Exception $e) {
         Log::error("{$tag}: " . $e->getMessage());
         return false;
     }
     $query = "SELECT {$passwdKey} FROM {$authTable} WHERE {$loginKey}='{$login}'";
     $sql = new DatabaseQuery($query);
     try {
         $sql->doQuery();
         if ($sql->get_num_rows() == 0) {
             Log::notice("{$tag}: Login not found.");
             return false;
         } else {
             if ($sql->get_num_rows() == 1) {
                 $row = $sql->get_next_row();
                 $_passwd = $row->{$passwdKey};
                 if ($_passwd == $passwd) {
                     Log::notice("{$tag}: Password Correct");
                     return true;
                 } else {
                     Log::notice("{$tag}: Password INCORRECT");
                     return false;
                 }
             } else {
                 if ($sql->get_num_rows() > 1) {
                     Log::warning("{$tag}: Multiple matches for login.");
                     return false;
                 }
             }
         }
     } catch (Exception $e) {
         Log::error("{$tag}: " . $e->getMessage());
         return false;
     }
 }
コード例 #2
0
 public static function authenticate($entitySignature, $identityKey, $resourceKey, $authKey, $identity, $resource)
 {
     $tag = "Sentry::authenticate()";
     Log::notice("{$tag}: <entitySignature={$entitySignature}, {$identityKey}={$identity}, {$resourceKey}={$resource}>");
     // TODO: (?) check users session for cached permissions
     try {
         $sentryBP = BlueprintReader::read($entitySignature);
         $entityDAO = new EntityDAO($sentryBP);
         $keys = array("{$identityKey}", "{$resourceKey}");
         $values = array("{$identity}", "{$resource}");
         $matches = $entityDAO->findWhere($keys, $values);
         if (0 == count($matches)) {
             Log::debug("{$tag}: No permission record was found.");
             return false;
         } else {
             if (1 == count($matches)) {
                 // found a matching permission record
                 $entity = $matches[0];
                 // extract value of $authKey field
                 $authValue = $entity->get($authKey);
                 // test for boolean values
                 if (empty($authValue) || $authValue == 0 || $authValue == "0" || strtoupper($authValue) == "NO" || strtoupper($authValue) == "FALSE") {
                     Log::debug("{$tag}: {$identityKey} {$identity} does not have permission to access {$resourceKey} {$resource}");
                     return false;
                 } else {
                     if ($authValue == 1 || $authValue == "1" || strtoupper($authValue) == "YES" || strtoupper($authValue) == "TRUE") {
                         Log::debug("{$tag}: {$identityKey} {$identity} has permission to access {$resourceKey} {$resource}");
                         return true;
                     }
                 }
             } else {
                 if (1 < count($matches)) {
                     Log::warning("{$tag}: ! More than one permission record was found.");
                     return false;
                 }
             }
         }
     } catch (Exception $e) {
         Log::error("{$tag}: " . $e->getMessage());
         return false;
     }
 }
コード例 #3
0
 public static function get($blueprintSignature, $id, $field, $timezone_offset = NULL)
 {
     $tag = "EntityDAO: get()";
     Log::debug("{$tag}: <blueprintSignature={$blueprintSignature}, id={$id}, field={$field}, timezone_offset={$timezone_offset}>");
     // Init timezone offsets
     if (empty($timezone_offset)) {
         $timezone_offset = BPTimezone::getOffset();
     }
     try {
         $blueprint = BlueprintReader::read($blueprintSignature);
         $dao = new EntityDAO($blueprint, $timezone_offset);
         if ($entity = $dao->load($id)) {
             $value = $entity->get($field);
             Log::debug("{$tag}: {$field} = {$value}");
             return $value;
         } else {
             // entity with "id" not found
             Log::warning("{$tag}: {$blueprintSignature} with id {$id} not found.");
             return false;
         }
     } catch (Exception $e) {
         Log::error("{$tag}: Caught: " . $e->getMessage());
         throw $e;
     }
 }
コード例 #4
0
 public static function import($path_csv, $path_resources = null, $mapping = array())
 {
     $tag = "EntityImporter:import()";
     Log::notice("{$tag}: <{$path_csv}, {$path_resources}, {$mapping}>");
     // pseudo contants
     $IMPORT_MODE_INSERT = 0;
     $IMPORT_MODE_UPDATE = 1;
     // init results array
     $stat = array();
     $stat["attempts"] = 0;
     $stat["inserts"] = 0;
     $stat["updates"] = 0;
     $stat["warnings"] = 0;
     $stat["errors"] = 0;
     // TODO: include sub-arrays for warning messages and error messages
     // eg: $stat["warning_messages"] = array(); where array indecies reference csv row numbers
     if (!is_readable($path_csv)) {
         Log::error("{$tag}: Unable to read from path {$path_csv}");
         throw new Exception("{$tag}: Unable to read from path {$path_csv}");
     }
     if ($path_resources != null && !is_readable($path_resources)) {
         Log::error("{$tag}: Unable to read from path {$path_resources}");
         throw new Exception("{$tag}: Unable to read from path {$path_resources}");
     }
     $csv_filename = basename($path_csv);
     $blueprint_key = substr($csv_filename, 0, strpos($csv_filename, "."));
     $blueprint_signature = $blueprint_key . ".entity.xml";
     Log::debug("{$tag}: Blueprint Signature: {$blueprint_signature}");
     /*
     // Compare CSV Header with Blueprint
     // determine if mapping is required
     */
     // read blueprint (on server)
     $bp = BlueprintReader::read($blueprint_signature);
     // init csv file for parsing
     $csv = new Csv($path_csv);
     // read csv header row
     $csv_header_row = $csv->nextRow();
     // apply mappings
     for ($i = 0; $i < count($csv_header_row); $i++) {
         $import_field = $csv_header_row[$i];
         $mapping_key = "mapping_" . $bp->getKey() . "_" . str_replace(".", "_", $import_field);
         // skip <id> columns
         if ($import_field == "id") {
             continue;
         }
         // skip columns where mapping is _DROP
         if (array_key_exists($mapping_key, $mapping) && $mapping[$mapping_key] == "_DROP") {
             continue;
         }
         if (array_key_exists($mapping_key, $mapping)) {
             // replace csv column header with mapped value
             $csv_header_row[$i] = $mapping["{$mapping_key}"];
         }
     }
     foreach ($csv_header_row as $import_field) {
         // skip <id> columns
         if ($import_field == "id") {
             continue;
         }
         // skip columns where mapping is _DROP
         $mapping_key = "mapping_" . $bp->getKey() . "_" . str_replace(".", "_", $import_field);
         if (array_key_exists($mapping_key, $mapping) && $mapping[$mapping_key] == "_DROP") {
             continue;
         }
         if (!$bp->keyExists($import_field)) {
             throw new EntityImporterException($bp, $csv_header_row);
         }
     }
     // check for id column
     $with_ids = false;
     if (in_array("id", $csv_header_row)) {
         $with_ids = true;
         Log::debug("{$tag}: Importing with ids");
     }
     // init Entity DAO
     $entityDAO = new EntityDAO($bp);
     // Import rows from Csv
     while (($row = $csv->nextRow()) !== FALSE) {
         $stat["attempts"]++;
         // init an entity to import
         unset($entity);
         // clear previous
         $entity = null;
         // flag an import mode (insert, update)
         $import_mode = EntityImporter::$IMPORT_MODE_INSERT;
         // check <id> to see if this csv row references an existing entity
         if ($with_ids) {
             $import_id = $row[0];
             if (!empty($import_id) && $import_id != 0) {
                 // check that an entity with this id exists
                 try {
                     if ($match = $entityDAO->load($import_id)) {
                         $entity = $match;
                         $import_mode = EntityImporter::$IMPORT_MODE_UPDATE;
                         Log::debug("{$tag}: Updating an existing {$blueprint_signature} with id {$import_id}");
                     } else {
                         $entity = $bp->build();
                         $entity->setId($import_id);
                         Log::debug("{$tag}: Creating a new {$blueprint_signature} with id {$import_id}");
                     }
                 } catch (Exception $e) {
                     $stat["warnings"]++;
                     Log::warning("{$tag}: Caught Exception: " . $e->getMessage());
                     $entity = $bp->build();
                     $entity->setId($import_id);
                     Log::debug("{$tag}: Creating a new {$blueprint_signature} with id {$import_id}");
                 }
             }
             // END: if( (!empty($import_id)) && ($import_id!=0) )
         }
         // END: if($with_ids)
         // if we are not working with an existing entity, build a new one
         if ($entity == null) {
             $entity = $bp->build();
             Log::debug("{$tag}: Creating a new {$blueprint_signature} without an id");
         }
         for ($i = 0; $i < count($csv_header_row); $i++) {
             // extract data from csv
             $import_field_key = $csv_header_row[$i];
             $import_field_value = $row[$i];
             // skid <id> column
             if ($import_field_key == "id") {
                 continue;
             }
             // skip columns where mapping is _DROP
             $mapping_key = "mapping_" . $bp->getKey() . "_" . str_replace(".", "_", $import_field_key);
             if (array_key_exists($mapping_key, $mapping) && $mapping[$mapping_key] == "_DROP") {
                 continue;
             }
             // extract field information from blueprint
             $field = $bp->get($import_field_key);
             switch ($field->getDataType()) {
                 case "date":
                     // reformat dates for mysql
                     $time = strtotime($import_field_value);
                     $import_field_value = date("Y-m-d", $time);
                     $entity->set($import_field_key, $import_field_value);
                     break;
                 case "binary":
                     $path_binary = $path_resources . $import_field_value;
                     Log::debug("{$tag}: Searching for binary at path {$path_binary}");
                     if (is_readable($path_binary)) {
                         Log::debug("{$tag}: Found readable binary at path {$path_binary}");
                         $binaryString = file_get_contents($path_binary);
                         $entity->set($import_field_key, $binaryString);
                     } else {
                         Log::debug("{$tag}: No readable binary at path {$path_binary}");
                     }
                     break;
                 default:
                     $entity->set($import_field_key, $import_field_value);
                     break;
             }
             // END: switch($field->getType())
         }
         // END: for($i=0; $i<count($csv_header_row); $i++)
         switch ($import_mode) {
             case EntityImporter::$IMPORT_MODE_UPDATE:
                 try {
                     $entityDAO->update($entity);
                     $stat["updates"]++;
                 } catch (Exception $e) {
                     Log::warning("{$tag}: Caught Exception: " . $e->getMessage());
                     $stat["errors"]++;
                 }
                 break;
             case EntityImporter::$IMPORT_MODE_INSERT:
                 try {
                     $entityDAO->insert($entity);
                     $stat["inserts"]++;
                 } catch (Exception $e) {
                     Log::warning("{$tag}: Caught Exception: " . $e->getMessage());
                     $stat["errors"]++;
                 }
                 break;
         }
     }
     // END: while( ($row = $csv->nextRow()) !== FALSE )
     return $stat;
 }
コード例 #5
0
             $status = "error";
             $message = "Login throttle has prevented another attempt.";
         } else {
             // Check Password
             if (Login::checkPassword($entity_blueprint, $login_key, $passwd_key, $login, $passwd)) {
                 Login::start($login, $domain);
                 // ! TODO: inject BPConfig::$guardian_identity_session_key into the users session
                 $status = "success";
                 $message = "Login Successful.";
             } else {
                 $status = "error";
                 $message = "Username or password is incorrect.";
                 Log::warning("* Failed login attempt");
                 if (BPConfig::$login_throttle_enabled) {
                     // Record a failed login attempt
                     $failedLoginAttemptBP = BlueprintReader::read(BPConfig::$login_throttle_blueprint);
                     $failedLoginAttemptDAO = new EntityDAO($failedLoginAttemptBP, "+0:00");
                     $fla = $failedLoginAttemptBP->build();
                     $fla->set(BPConfig::$login_throttle_field_id, $member_id);
                     $fla->set("time", gmdate("Y-m-d H:i:s"));
                     $failedLoginAttemptDAO->insert($fla);
                 }
             }
         }
     } else {
         // Login not found
         $status = "error";
         $message = "Username or password is incorrect.";
     }
     break;
 case "logout":
コード例 #6
0
		}

		try
		{
			echo "Creating Session database.<br/>";
			$sessionBP = BlueprintReader::read("Session.entity.xml");
			$sessionDAO = new EntityDAO($sessionBP);
			$sessionDAO->create();
		}
		catch(Exception $e)
		{
			echo "Exception: " . $e->getMessage() . "<br>";
		}
		
		try
		{
			echo "Creating AuthFailedLoginAttempts database.<br/>";
			$loginBP = BlueprintReader::read("AuthFailedLoginAttempts.entity.xml");
			$loginDAO = new EntityDAO($loginBP);
			$loginDAO->create();
		}
		catch(Exception $e)
		{
			echo "Exception: " . $e->getMessage() . "<br>";
		}
		
		?>
	
	</body>
</html>
コード例 #7
0
<?php

require_once "Config.php";
require_once "Blueprint.php";
require_once "BlueprintReader.php";
require_once "EntityExporter.php";
?>
<h1>EntityExporter Test</h1>
<?

// extract config variables
$path_blueprints = BPConfig::$path_blueprints;

$blueprint = $_GET["blueprint"];
$path = $path_blueprints . $blueprint . ".xml";

echo "Path = $path<br>";

$bp = BlueprintReader::read($path);

$csv = EntityExporter::exportCsv($bp);
$csv = nl2br($csv);

echo "<pre>";
echo "$csv";
echo "</pre>";

?>
コード例 #8
0
echo "using ListDrafter<br/>";
DraftingDesk::renderList("ListDrafter", "Member.entity.xml");
echo "using ListUlDrafter<br/>";
echo "using ListUlDrafter with a ListBlueprint<br/>";
DraftingDesk::renderList("ListUlDrafter", "Member.entity.xml", "Member.Directory.list.xml");
$params = array();
$params["order"] = "lname DESC";
$params["filters"] = array();
$params["filters"]["filter_fname_like"] = "Be";
DraftingDesk::renderList("ListTableDrafter", "Member.entity.xml", null, $params);
echo "<br/><br/><hr/><br/><br/>";
echo "Test FilterDrafter<br/><br/>";
$drafter = new FilterDrafter($entityBP);
$html = $drafter->render();
echo $html;
echo "<br/><br/>";
echo "Test Reading a Filter Blueprint<br/><br/>";
$filterBP = BlueprintReader::read("Member.Name.filter.xml");
echo "Test class instance..<br>";
if ($filterBP instanceof FilterBlueprint) {
    echo "filterBP is an instance of FilterBlueprint<br><br>";
} else {
    echo "filterBP is not an instance of FilterBlueprint<br><br>";
}
echo "Test FilterDrafter with a FilterBlueprint<br/><br/>";
$drafter = new FilterDrafter($entityBP, $filterBP);
$html = $drafter->render();
echo $html;
echo "<br/><br/><hr/><br/><br/>";
echo "Testing DraftingDesk, renderFilter()...<br/>";
DraftingDesk::renderFilter("FilterDrafter", "Member.entity.xml", "Member.Name.filter.xml");
コード例 #9
0
 // Decode params
 $params = ParamEncoder::decode($params);
 /*
 // Read Blueprints
 */
 // Read Entity Blueprint
 try {
     $entityBP = BlueprintReader::read($entitySignature);
 } catch (Exception $e) {
     Log::error("{$tag}: Caught Exception reading entity blueprint " . $entitySignature);
     // TODO: return error response; do not continue
 }
 // Read Filter Blueprint
 if ($filterSignature != null) {
     try {
         $filterBP = BlueprintReader::read($filterSignature);
     } catch (Exception $e) {
         Log::error("{$tag}: Caught Exception reading filter blueprint " . $filterSignature);
     }
 } else {
     $filterBP = null;
 }
 /*
 // Use a FilterDrafter to initialize filters from Blueprints
 // Note: FilterPostDrafter overrides FilterDrafter.initFilterValues()
 // 				to read filter values from $_POST array
 */
 $filterPostDrafter = new FilterPostDrafter($entityBP, $filterBP);
 $filters = $filterPostDrafter->filters();
 $filterKeys = array_keys($filters);
 Log::debug(count($filters) . " returned from FilterPostDrafter");
コード例 #10
0
$config_timezone_offset = BPConfig::$timezone_offset;
echo "Config timezone offset: ";
if (!empty($config_timezone_offset)) {
    echo "{$config_timezone_offset}";
} else {
    echo "EMPTY";
}
echo "<br/><br/>";
$default_timezone_offset = BPTimezone::UTC;
echo "Default timezone offset: {$default_timezone_offset}";
echo "<br/><br/>";
echo "<hr/>";
echo "<h1>Timezone Conversion</h1>";
echo "<strong>Using BPConfig::\$timezone_offset of " . BPConfig::$timezone_offset . "</strong><br/><br/>";
try {
    $accessBP = BlueprintReader::read("Access.entity.xml");
    $accessDAO = new EntityDAO($accessBP);
    // Debug
    echo "Local time is " . date("Y-m-d H:i:s") . "<br/>";
    echo "Universal time is " . gmdate("Y-m-d H:i:s") . "<br/>";
    echo "<br/>";
    // Build new Access
    $access = $accessBP->build();
    $access->set("member_id", 1);
    $access->set("time", date("Y-m-d H:i:s"));
    $access->set("resource_id", 1);
    $access->set("description", "Timezone Test");
    // Insert new Access
    $access_id = $accessDAO->insert($access);
    echo "Inserted new Access with id {$access_id}<br/>";
    unset($access);
コード例 #11
0
 public static function renderReport($renderer, $reportBlueprintSignature, $params = null)
 {
     $tag = "DraftingDesk::renderReport()";
     Log::debug("{$tag} <{$renderer}, {$reportBlueprintSignature}>");
     // Read Report Blueprint
     try {
         $reportBlueprint = BlueprintReader::read($reportBlueprintSignature);
     } catch (Exception $e) {
         Log::error("{$tag}: Caught Exception reading report blueprint " . $reportBlueprintSignature);
         throw $e;
     }
     // create an instance of the requested ReportDrafter class
     loadClass($renderer);
     $reportDrafter = new $renderer($reportBlueprint, $params);
     // send render message
     return $reportDrafter->render();
 }
コード例 #12
0
 private function test_access_list_rule_ownership($rule, $identity, $listRows)
 {
     $tag = "Guardian: test_access_list_rule_ownership()";
     Log::debug("{$tag}");
     $ownerIdentifier = (string) $rule;
     $keyPath = $rule["keyPath"];
     $identityKeyPath = $rule["identityKeyPath"];
     list($ownershipTable, $ownershipField) = explode(".", $keyPath);
     list($identityTable, $identityField) = explode(".", $identityKeyPath);
     list($ownerIdentifierTable, $ownerIdentifierField) = explode(".", $ownerIdentifier);
     Log::debug("{$tag}: Rule requires ownership of " . count($listRows) . " list item(s) from keyPath '{$keyPath}'");
     if ($ownershipTable == $identityTable) {
         // TEST FOR DIRECT OWNERSHIP BY IDENTITY (of each listRow)
         foreach ($listRows as $row) {
             $entityId = $row->id;
             $owner_id = $row->columns["{$ownershipField}"];
             Log::debug("{$tag}: Testing list rows {$entityId} with {$ownershipField}={$owner_id}");
             if ($owner_id == $identity) {
                 Log::debug("{$tag}: {$ownershipTable} with ID {$entityId} is owned by requestor");
                 // Continue testing next row
             } else {
                 Log::debug("{$tag}: {$ownershipTable} with ID {$entityId} is not owned by requestor");
                 return false;
             }
         }
         // If processing has reached this point, all rows are owned by the requestor
         Log::debug("{$tag}: All {$ownershipTable} rows are owned by requestor");
         return true;
     } else {
         if (!empty($ownerIdentifier)) {
             // TEST FOR INDIRECT OWNERSHIP BY AFFILIATION (of each listRow)
             // Lookup the "group" that owns this record (in $keyPath)
             // Verify that the requestor is Affiliated with this group
             try {
                 // Query for the "affiliations" of "identity" from "ownerIdentifierTable"
                 // The results from this query can be reused to test ownership of each listRow
                 $ownerIdentifierBP = BlueprintReader::read($ownerIdentifierTable . ".entity.xml");
                 $ownerIdentifierDAO = new EntityDAO($ownerIdentifierBP);
                 // "id's" are not defined as "fields" in a blueprint; therefore if "identityField" references an "id", we should do a direct load
                 if ($identityField == "id") {
                     $affiliationObj = $ownerIdentifierDAO->load($identity);
                     $affiliations = array($affiliationObj);
                 } else {
                     $affilations = $ownerIdentifierDAO->findWhere("{$identityField}", "{$identity}");
                 }
                 foreach ($listRows as $row) {
                     $entityId = $row->id;
                     $owner_id = $row->columns["{$ownershipField}"]->value;
                     Log::debug("Rule requires ownership through affiliation with '{$owner_id}' from keyPath '{$ownerIdentifier}'");
                     // NOTE:
                     // "affiliations" may be defined in such a way that each identity has multiple affiliations
                     // check each matching affiliation for this identity
                     if (count($affiliations > 0)) {
                         for ($i = 0; $i < count($affiliations); $i++) {
                             $affiliationObj = $affiliations[0];
                             $_affiliation = $affiliationObj->get($ownerIdentifierField);
                             if ($_affiliation == $owner_id) {
                                 Log::debug("{$tag}: Found matching affiliation '{$_affiliation}' for entityId={$entityId}");
                                 // Continue checking the next listRow
                             }
                         }
                     } else {
                         Log::debug("{$tag}: No affiliation records matching this identity");
                         return false;
                     }
                 }
                 // END: foreach($listRow as $row)
                 // If processing has reached this point, all rows are owned by the requestor
                 Log::debug("{$tag}: All {$ownershipTable} rows are owned by the requestor");
                 return true;
             } catch (Exception $e) {
                 Log::error("{$tag}: Caught: " . $e->getMessage());
                 return false;
             }
         } else {
             Log::error("{$tag}: Invalid <Ownership> rule");
             return false;
         }
     }
 }
コード例 #13
0
 */
 // Retrieve request parameters
 $domain = @$_GET["domain"];
 $destination = @$_GET["destination"];
 // Init Defaults
 if (empty($destination)) {
     $destination = "/";
 }
 // Debug
 Log::debug("* domain = {$domain}");
 Log::debug("* destination = {$destination}");
 if (Login::loggedIn($domain)) {
     // Retrieve 'login' from users Login Session
     $login = Login::who($domain);
     // Retrieve member data
     $memberBP = BlueprintReader::read("Member.entity.xml");
     $memberDAO = new EntityDAO($memberBP);
     $matches = $memberDAO->findWhere("login", $login);
     if (count($matches) > 0) {
         $member = $matches[0];
         // Add data to the users session
         Session::user("member_id", $member->getId());
         // Required by Guardian
         // Forward user
         Log::debug("* REDIRECTING TO: {$destination}\n");
         header("location: {$destination}");
         exit;
     } else {
         // Should never happen, since users password was just checked
         Log::error("* Member with login '{$login}' was not found.");
         $content->addHtml("<strong>Login Error</strong><br/>");
コード例 #14
0
 public static function blueprints($blueprintType = "entity", $entityBlueprintSignature = null)
 {
     $tag = "BlueprintEnumerator::blueprints()";
     Log::debug("{$tag}: <{$blueprintType}, {$entityBlueprintSignature}>");
     try {
         $signatures = self::signatures($blueprintType, $entityBlueprintSignature);
         $blueprints = array();
         foreach ($signatures as $s) {
             try {
                 $bp = BlueprintReader::read($s);
                 $blueprints["{$s}"] = $bp;
             } catch (Exception $e) {
                 Log::error("{$tag}: Caught Exception");
                 throw $e;
             }
         }
         return $blueprints;
     } catch (Exception $e) {
         Log::error("{$tag}: Caught Exception");
         throw $e;
     }
 }
コード例 #15
0
$type = @$_GET["type"];
if (empty($type)) {
    $type = "csv";
}
if (empty($blueprint)) {
    echo "ERROR: Missing required input \"blueprint\"";
    exit;
} else {
    $blueprintSignature = $blueprint;
    // extract filters from Session
    // NOTE: requires enhancement to Session.php to allow retrieval from a named page
    // $filters = Session::namedPage($page, "filters");
    $filters = array();
    try {
        // read blueprint
        $bp = BlueprintReader::read($blueprintSignature);
        $bpKey = $bp->getKey();
        // get export data
        $tar = EntityExporter::export($bp, $type, $where, $filters);
    } catch (Exception $e) {
        // return err to ajax client
        echo "Caught Exception: " . $e->getMessage();
        exit;
    }
    // create filename
    $filename = $bpKey . ".{$type}";
    // set headers
    header("Content-Type: application/x-gzip");
    header("Content-Disposition: attachment; filename={$filename}");
    header("Content-Transfer-Encoding: binary");
    echo "{$tar}";
コード例 #16
0
$entityId = @$_POST["entityId"];
// either a single id or an array of ids
if (!empty($entitySignature) && !empty($entityId)) {
    Log::debug("* entitySignature = {$entitySignature}");
    Log::debug("* entityId = {$entityId}");
    if (is_array($entityId)) {
        $ids = implode(", ", $entityId);
        Log::debug("* entityId[] = {$ids}");
    } else {
        // force single entityId into an array
        $array = array($entityId);
        // update pointer
        $entityId = $array;
    }
    try {
        $bp = BlueprintReader::read($entitySignature);
        $dao = new EntityDAO($bp);
        $failures = 0;
        foreach ($entityId as $id) {
            $xmlDelete = $xmlAttempts->addChild("delete");
            $xmlDelete->addAttribute("signature", $entitySignature);
            $xmlDelete->addAttribute("id", $id);
            try {
                // Make sure the user has permission to perform this action
                if (BPConfig::$guardian_enable !== true || Guardian::authorize(Session::user(BPConfig::$guardian_identity_session_key), "DELETE", $bp->getKey(), $id)) {
                    $dao->delete($id);
                    $xmlDelete->addChild("status", "success");
                    $xmlDelete->addChild("message", "Entity was deleted successfully.");
                    $xmlDelete->addChild("html", "Deleted " . $entitySignature . " with ID#" . $id);
                } else {
                    Log::warning("* Guardian denied access to delete " . $bp->getKey() . " with ID {$id}");
コード例 #17
0
$blueprint = $_GET["blueprint"];
$field = $_GET["field"];
$id = $_GET["id"];
if (empty($action)) {
    $action = "file";
}
if (empty($blueprint) || empty($field) || empty($id)) {
    Log::error("Missing a required input");
    echo "ERROR: Missing a required input.";
    exit;
} else {
    Log::debug("... " . $blueprint . "." . $field . ": " . $id);
    try {
        // load the blueprint
        $blueprint_file_name = $blueprint . ".entity.xml";
        $bp = BlueprintReader::read($blueprint_file_name);
        // lookup the field
        $f = $bp->get($field);
        // retrieve meta data for file creation
        $mimeType = $f->getMimeType();
        // retrieve the binary as a string
        $binaryString = Binary::getString($blueprint, $field, $id);
    } catch (Exception $e) {
        Log::error($e->getMessage());
        echo "EXCEPTION: " . $e->getMessage();
        exit;
    }
    switch ($action) {
        case "file":
            // create filename
            $ext = Binary::extension($mimeType);