text:
package org.apereo.cas.authentication;

import org.apereo.cas.cassandra.CassandraSessionFactory;
import org.apereo.cas.configuration.model.support.cassandra.authentication.CassandraAuthenticationProperties;
import org.apereo.cas.util.CollectionUtils;

import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.cql.BoundStatement;
import com.datastax.oss.driver.api.core.cql.PreparedStatement;
import lombok.extern.slf4j.Slf4j;
import lombok.val;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * This is {@link DefaultCassandraRepository}.
 *
 * @author Misagh Moayyed
 * @since 5.2.0
 */
@Slf4j
public class DefaultCassandraRepository implements CassandraRepository {

    private final CqlSession session;

    private final PreparedStatement selectUserQuery;

    public DefaultCassandraRepository(final CassandraAuthenticationProperties cassandraProperties,
                                      final CassandraSessionFactory cassandraSessionFactory) {
        val query = String.format(cassandraProperties.getQuery(), cassandraProperties.getTableName(),
            cassandraProperties.getUsernameAttribute());
        this.session = cassandraSessionFactory.getSession();
        this.selectUserQuery = this.session.prepare(query);
    }

    @Override
    public Map<String, List<Object>> getUser(final String uid) {
        val attributes = new HashMap<String, List<Object>>();
        val row = session.execute(bind(selectUserQuery, uid)).one();
        if (row != null) {
            row.getColumnDefinitions().forEach(c -> {
                LOGGER.debug("Located attribute column [{}]", c.getName());
                attributes.put(c.getName().asInternal(), CollectionUtils.toCollection(row.getObject(c.getName()), ArrayList.class));
            });
        }
        return attributes;
    }

    private static BoundStatement bind(final PreparedStatement statement, final Object... params) {
        val boundStatement = statement.bind(params);
        LOGGER.debug("CQL: [{}] with parameters [{}]", statement.getQuery(), StringUtils.join(params, ", "));
        return boundStatement;
    }
}


text:
namespace tcmalloc {

// Note: the following only works for "n"s that fit in 32-bits, but
// that is fine since we only use it for small sizes.
static inline int LgFloor(size_t n) {
  int log = 0;
  for (int i = 4; i >= 0; --i) {
    int shift = (1 << i);
    size_t x = n >> shift;
    if (x != 0) {
      n = x;
      log += shift;
    }
  }
  ASSERT(n == 1);
  return log;
}

int AlignmentForSize(size_t size) {
  int alignment = kAlignment;
  if (size > kMaxSize) {
    // Cap alignment at kPageSize for large sizes.
    alignment = kPageSize;
  } else if (size >= 128) {
    // Space wasted due to alignment is at most 1/8, i.e., 12.5%.
    alignment = (1 << LgFloor(size)) / 8;
  } else if (size >= 16) {
    // We need an alignment of at least 16 bytes to satisfy
    // requirements for some SSE types.
    alignment = 16;
  }
  // Maximum alignment allowed is page size alignment.
  if (alignment > kPageSize) {
    alignment = kPageSize;
  }
  CHECK_CONDITION(size < 16 || alignment >= 16);
  CHECK_CONDITION((alignment & (alignment - 1)) == 0);
  return alignment;
}

int SizeMap::NumMoveSize(size_t size) {
  if (size == 0) return 0;
  // Use approx 64k transfers between thread and central caches.
  int num = static_cast<int>(64.0 * 1024.0 / size);
  if (num < 2) num = 2;

  // Avoid bringing too many objects into small object free lists.
  // If this value is too large:
  // - We waste memory with extra objects sitting in the thread caches.
  // - The central freelist holds its lock for too long while
  //   building a linked list of objects, slowing down the allocations
  //   of other threads.
  // If this value is too small:
  // - We go to the central freelist too often and we have to acquire
  //   its lock each time.
  // This value strikes a balance between the constraints above.
  if (num > 32) num = 32;

  return num;
}

// Initialize the mapping arrays
void SizeMap::Init() {
  // Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
  if (ClassIndex(0) < 0) {
    Log(kCrash, __FILE__, __LINE__,
        "Invalid class index for size 0", ClassIndex(0));
  }
  if (ClassIndex(kMaxSize) >= sizeof(class_array_)) {
    Log(kCrash, __FILE__, __LINE__,
        "Invalid class index for kMaxSize", ClassIndex(kMaxSize));
  }

  // Compute the size classes we want to use
  int sc = 1;   // Next size class to assign
  int alignment = kAlignment;
  CHECK_CONDITION(kAlignment <= 16);
  for (size_t size = kMinClassSize; size <= kMaxSize; size += alignment) {
    alignment = AlignmentForSize(size);
    CHECK_CONDITION((size % alignment) == 0);

    int blocks_to_move = NumMoveSize(size) / 4;
    size_t psize = 0;
    do {
      psize += kPageSize;
      // Allocate enough pages so leftover is less than 1/8 of total.
      // This bounds wasted space to at most 12.5%.
      while ((psize % size) > (psize >> 3)) {
        psize += kPageSize;
      }
      // Continue to add pages until there are at least as many objects in
      // the span as are needed when moving objects from the central
      // freelists and spans to the thread caches.
    } while ((psize / size) < (blocks_to_move));
    const size_t my_pages = psize >> kPageShift;

    if (sc > 1 && my_pages == class_to_pages_[sc-1]) {
      // See if we can merge this into the previous class without
      // increasing the fragmentation of the previous class.
      const size_t my_objects = (my_pages << kPageShift) / size;
      const size_t prev_objects = (class_to_pages_[sc-1] << kPageShift)
                                  / class_to_size_[sc-1];
      if (my_objects == prev_objects) {
        // Adjust last class to include this size
        class_to_size_[sc-1] = size;
        continue;
      }
    }

    // Add new class
    class_to_pages_[sc] = my_pages;
    class_to_size_[sc] = size;
    sc++;
  }
  if (sc != kNumClasses) {
    Log(kCrash, __FILE__, __LINE__,
        "wrong number of size classes: (found vs. expected )", sc, kNumClasses);
  }

  // Initialize the mapping arrays
  int next_size = 0;
  for (int c = 1; c < kNumClasses; c++) {
    const int max_size_in_class = class_to_size_[c];
    for (int s = next_size; s <= max_size_in_class; s += kAlignment) {
      class_array_[ClassIndex(s)] = c;
    }
    next_size = max_size_in_class + kAlignment;
  }

  // Double-check sizes just to be safe
  for (size_t size = 0; size <= kMaxSize; size++) {
    const int sc = SizeClass(size);
    if (sc <= 0 || sc >= kNumClasses) {
      Log(kCrash, __FILE__, __LINE__,
          "Bad size class (class, size)", sc, size);
    }
    if (sc > 1 && size <= class_to_size_[sc-1]) {
      Log(kCrash, __FILE__, __LINE__,
          "Allocating unnecessarily large class (class, size)", sc, size);
    }
    const size_t s = class_to_size_[sc];
    if (size > s || s == 0) {
      Log(kCrash, __FILE__, __LINE__,
          "Bad (class, size, requested)", sc, s, size);
    }
  }

  // Initialize the num_objects_to_move array.
  for (size_t cl = 1; cl  < kNumClasses; ++cl) {
    num_objects_to_move_[cl] = NumMoveSize(ByteSizeForClass(cl));
  }
}

// Metadata allocator -- keeps stats about how many bytes allocated.
static uint64_t metadata_system_bytes_ = 0;
void* MetaDataAlloc(size_t bytes) {
  static size_t pagesize;
#ifdef HAVE_GETPAGESIZE
  if (pagesize == 0)
    pagesize = getpagesize();
#endif

  void* result = TCMalloc_SystemAlloc(bytes, NULL, pagesize);
  if (result != NULL) {
    metadata_system_bytes_ += bytes;
  }
  return result;
}

uint64_t metadata_system_bytes() { return metadata_system_bytes_; }

void increment_metadata_system_bytes(size_t bytes) {
  metadata_system_bytes_ += bytes;
}

}  // namespace tcmalloc

redpajama_set_name: RedPajamaGithub


text:
notes: >

  Card blocks to display and link to content. For use on hub pages.

---

Choose Victoria and make
              a difference

Victoria's research  output is used at community, national and international levels. Our academic and business partnerships have global impacts in many fields.

Victoria's research  output is used at community, national and international levels. Our academic and business partnerships have global impacts in many fields.

              Learn more

Find a supervisor

Victoria's research  output is used at community, national and international levels. Our academic and business partnerships have global impacts in many fields.

Victoria's research  output is used at community, national and international levels. Our academic and business partnerships have global impacts in many fields.

              Learn more

Funding your study

Victoria's research  output is used at community, national and international levels. Our academic and business partnerships have global impacts in many fields.

Victoria's research  output is used at community, national and international levels. Our academic and business partnerships have global impacts in many fields.

              Learn more
              Scholarships

How to apply

Victoria's research  output is used at community, national and international levels. Our academic and business partnerships have global impacts in many fields.

Victoria's research  output is used at community, national and international levels. Our academic and business partnerships have global impacts in many fields.

              Learn more


text:
var extensions = {
  '.co': 'coco',
  '.coffee': 'coffee-script/register',
  '.coffee.md': 'coffee-script/register',
  '.csv': 'require-csv',
  '.iced': 'iced-coffee-script/register',
  '.ini': 'require-ini',
  '.js': null,
  '.json': null,
  '.jsx': 'node-jsx',
  '.litcoffee': 'coffee-script/register',
  '.ls': 'LiveScript',
  '.toml': 'toml-require',
  '.xml': 'require-xml',
  '.yaml': 'require-yaml',
  '.yml': 'require-yaml'
};

var register = {
  'node-jsx': function (module) {
    module.install({ extension: '.jsx', harmony: true });
  },
  'toml-require': function (module) {
    module.install();
  }
};

var jsVariantExtensions = [
  '.js',
  '.co',
  '.coffee',
  '.coffee.md',
  '.iced',
  '.jsx',
  '.litcoffee',
  '.ls'
];

module.exports = {
  extensions: extensions,
  register: register,
  jsVariants: jsVariantExtensions.reduce(function (result, ext) {
    result[ext] = extensions[ext];
    return result;
  }, {})
};


text:
<?php
require_once('../bootstrap.php');

$username = $_POST['username'];
$password = $_POST['password'];
$uid = null;

if ( !Validate::Username($username) && !Validate::Password($password) )
{
	echo json_encode(false);
	exit();
}

$user = new User();

$user->setUsername($username);
$user->setPassword($password);

if ( $user->Login() )
{
	//redirect to home
	echo json_encode(true);
	exit();
}

// redirect to home
echo json_encode(false);

?>


text:
package org.netbeans.modules.atom.electron.glue;

/**
 *
 * @author spindizzy
 */
public interface CommandType {

    Type getType();

    enum Type {

        ELECTRON_RUN, ELECTRON_DEBUG, INSPECTOR
    };

    Preferences getPreferences();

}


text:
<!doctype>

		<title>Lego generator</title>

			Largeur légo : <input type="number" id="lego-length" min="1" value="1">

			Longueur légo : <input type="number" id="lego-width" min="1" value="1">

			Hauteur légo : <input type="number" id="lego-height" min="1" value="1">


text:
<?php

namespace Jzpeepz\Dynamo;

class IndexRow
{
    protected $html;
    protected $type = null;

    public function __construct(callable $html)
    {
        $this->html = $html;
    }

    public static function make(callable $html)
    {
        return new static($html);
    }

    public function type($type)
    {
        $this->type = $type;
        return $this;
    }

    public function render($item)
    {
        return call_user_func($this->html, $item);
    }

    public function isType($type)
    {
        return $this->type === $type;
    }
}


text:
package rotateit.service.rotation;

import static org.assertj.core.api.Assertions.assertThat;

import java.util.ArrayDeque;
import java.util.Deque;
import org.junit.Before;
import org.junit.Test;
import rotateit.data.model.Team;

public class RotatorTest {

    private static final String FIRST = "First";
    private static final String AFTER_FIRST = "AfterFirst";
    private static final String BEFORE_LAST = "BeforeLast";
    private static final String LAST = "Last";

    private final Deque<Team> rotationState = new ArrayDeque<>();

    private final Rotator rotator = new Rotator(rotationState);

    @Before
    public void setUp() {
        rotationState.clear();
    }

    private void givenRotationList() {
        rotationState.add(new Team(1, FIRST));
        rotationState.add(new Team(2, AFTER_FIRST));
        rotationState.add(new Team(3, BEFORE_LAST));
        rotationState.add(new Team(4, LAST));
    }

    @Test
    public void shouldPickFirstTeamFromListAndMoveItToEnd() {
        givenRotationList();

        Team pickedTeam = rotator.rotate();

        assertThat(pickedTeam.getName()).isEqualTo(FIRST);
        assertThat(pickedTeam).isEqualTo(rotationState.getLast());
    }

    @Test
    public void shouldKeepChangingOrderOfTeamsAfterMultipleRotations() {
        givenRotationList();

        Team firstPick = rotator.rotate();
        Team secondPick = rotator.rotate();
        Team thirdPick = rotator.rotate();

        assertThat(firstPick.getName()).isEqualTo(FIRST);
        assertThat(secondPick.getName()).isEqualTo(AFTER_FIRST);
        assertThat(thirdPick.getName()).isEqualTo(BEFORE_LAST);
        assertThat(thirdPick).isEqualTo(rotationState.getLast());
    }
}


text:
#include <string>
#include "application_manager/commands/mobile/get_vehicle_data_request.h"

#include "application_manager/application_impl.h"
#include "application_manager/message_helper.h"
#include "interfaces/MOBILE_API.h"
#include "interfaces/HMI_API.h"

namespace application_manager {

namespace commands {

namespace str = strings;

#ifdef HMI_DBUS_API
GetVehicleDataRequest::GetVehicleDataRequest(
    const MessageSharedPtr& message, ApplicationManager& application_manager)
    : CommandRequestImpl(message, application_manager) {}

GetVehicleDataRequest::~GetVehicleDataRequest() {}

void GetVehicleDataRequest::Run() {
  LOG4CXX_AUTO_TRACE(logger_);

  int32_t app_id =
      (*message_)[strings::params][strings::connection_key].asUInt();
  ApplicationSharedPtr app = application_manager_.application(app_id);

  if (!app) {
    LOG4CXX_ERROR(logger_, "NULL pointer");
    SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED);
    return;
  }

  const VehicleData& vehicle_data = MessageHelper::vehicle_data();
  VehicleData::const_iterator it = vehicle_data.begin();

  for (; vehicle_data.end() != it; ++it) {
    if (true == (*message_)[str::msg_params].keyExists(it->first) &&
        true == (*message_)[str::msg_params][it->first].asBool()) {
      SendRequestsToHmi(app->app_id());
      return;
    }
  }

  SendResponse(false, mobile_apis::Result::INVALID_DATA);
}

namespace {
struct Subrequest {
  hmi_apis::FunctionID::eType func_id;
  const char* str;
};
Subrequest subrequests[] = {
    {hmi_apis::FunctionID::VehicleInfo_GetGpsData, str::gps},
    {hmi_apis::FunctionID::VehicleInfo_GetSpeed, str::speed},
    {hmi_apis::FunctionID::VehicleInfo_GetRpm, str::rpm},
    {hmi_apis::FunctionID::VehicleInfo_GetFuelLevel, str::fuel_level},
    {hmi_apis::FunctionID::VehicleInfo_GetFuelLevelState,
     str::fuel_level_state},
    {hmi_apis::FunctionID::VehicleInfo_GetInstantFuelConsumption,
     str::instant_fuel_consumption},
    {hmi_apis::FunctionID::VehicleInfo_GetExternalTemperature,
     str::external_temp},
    {hmi_apis::FunctionID::VehicleInfo_GetVin, str::vin},
    {hmi_apis::FunctionID::VehicleInfo_GetPrndl, str::prndl},
    {hmi_apis::FunctionID::VehicleInfo_GetTirePressure, str::tire_pressure},
    {hmi_apis::FunctionID::VehicleInfo_GetOdometer, str::odometer},
    {hmi_apis::FunctionID::VehicleInfo_GetBeltStatus, str::belt_status},
    {hmi_apis::FunctionID::VehicleInfo_GetBodyInformation,
     str::body_information},
    {hmi_apis::FunctionID::VehicleInfo_GetDeviceStatus, str::device_status},
    {hmi_apis::FunctionID::VehicleInfo_GetDriverBraking, str::driver_braking},
    {hmi_apis::FunctionID::VehicleInfo_GetWiperStatus, str::wiper_status},
    {hmi_apis::FunctionID::VehicleInfo_GetHeadLampStatus,
     str::head_lamp_status},
    {hmi_apis::FunctionID::VehicleInfo_GetEngineTorque, str::engine_torque},
    {hmi_apis::FunctionID::VehicleInfo_GetAccPedalPosition, str::acc_pedal_pos},
    {hmi_apis::FunctionID::VehicleInfo_GetSteeringWheelAngle,
     str::steering_wheel_angle},
    {hmi_apis::FunctionID::VehicleInfo_GetECallInfo, str::e_call_info},
    {hmi_apis::FunctionID::VehicleInfo_GetAirbagStatus, str::airbag_status},
    {hmi_apis::FunctionID::VehicleInfo_GetEmergencyEvent, str::emergency_event},
    {hmi_apis::FunctionID::VehicleInfo_GetClusterModeStatus,
     str::cluster_mode_status},
    {hmi_apis::FunctionID::VehicleInfo_GetMyKey, str::my_key},
};
}

void GetVehicleDataRequest::SendRequestsToHmi(const int32_t app_id) {
  smart_objects::SmartObject msg_params(smart_objects::SmartType_Map);
  msg_params[strings::app_id] = app_id;

  for (size_t i = 0; i < sizeof(subrequests) / sizeof(subrequests[0]); ++i) {
    const Subrequest& sr = subrequests[i];
    if (true == (*message_)[str::msg_params].keyExists(sr.str) &&
        true == (*message_)[str::msg_params][sr.str].asBool()) {
      HmiRequest hmi_request;
      hmi_request.str = sr.str;
      hmi_request.func_id = sr.func_id;
      hmi_request.complete = false;
      hmi_requests_.push_back(hmi_request);
    }
  }

  LOG4CXX_INFO(logger_,
               hmi_requests_.size() << " requests are going to be sent to HMI");

  for (HmiRequests::const_iterator it = hmi_requests_.begin();
       it != hmi_requests_.end();
       ++it) {
    SendHMIRequest(it->func_id, &msg_params, true);
  }
}

void GetVehicleDataRequest::on_event(const event_engine::Event& event) {
  LOG4CXX_INFO(logger_, "GetVehicleDataRequest::on_event " << event.id());

  const smart_objects::SmartObject& message = event.smart_object();

  for (HmiRequests::iterator it = hmi_requests_.begin();
       it != hmi_requests_.end();
       ++it) {
    HmiRequest& hmi_request = *it;
    if (hmi_request.func_id == event.id()) {
      hmi_request.status = static_cast<hmi_apis::Common_Result::eType>(
          message[strings::params][hmi_response::code].asInt());
      if (hmi_apis::Common_Result::SUCCESS == hmi_request.status)
        hmi_request.value = message[str::msg_params][hmi_request.str];
      hmi_request.complete = true;
      break;
    }
  }

  bool all_complete = true;
  bool any_arg_success = false;
  mobile_api::Result::eType status = mobile_api::Result::eType::SUCCESS;
  for (HmiRequests::const_iterator it = hmi_requests_.begin();
       it != hmi_requests_.end();
       ++it) {
    if (!it->complete) {
      all_complete = false;
      break;
    }
    if (hmi_apis::Common_Result::SUCCESS != it->status) {
      if (mobile_api::Result::SUCCESS == status) {
        status = static_cast<mobile_apis::Result::eType>(it->status);
      } else if (status !=
                 static_cast<mobile_apis::Result::eType>(it->status)) {
        status = mobile_api::Result::eType::GENERIC_ERROR;
      }
      LOG4CXX_TRACE(logger_,
                    "Status from HMI: " << it->status
                                        << ", so response status become "
                                        << status);
    } else {
      any_arg_success = true;
    }
  }

  if (all_complete) {
    smart_objects::SmartObject response_params(smart_objects::SmartType_Map);
    if (any_arg_success) {
      for (HmiRequests::const_iterator it = hmi_requests_.begin();
           it != hmi_requests_.end();
           ++it) {
        response_params[it->str] = it->value;
      }
    }
    LOG4CXX_INFO(logger_, "All HMI requests are complete");
    const char* info = NULL;
    std::string error_message;
    if (true == message[strings::params].keyExists(strings::error_msg)) {
      error_message = message[strings::params][strings::error_msg].asString();
      info = error_message.c_str();
    }
    SendResponse(any_arg_success, status, info, &response_params);
  }
}
#else
GetVehicleDataRequest::GetVehicleDataRequest(
    const MessageSharedPtr& message, ApplicationManager& application_manager)
    : CommandRequestImpl(message, application_manager) {}

GetVehicleDataRequest::~GetVehicleDataRequest() {}

void GetVehicleDataRequest::Run() {
  LOG4CXX_AUTO_TRACE(logger_);

  int32_t app_id =
      (*message_)[strings::params][strings::connection_key].asUInt();
  ApplicationSharedPtr app = application_manager_.application(app_id);

  if (!app) {
    LOG4CXX_ERROR(logger_, "NULL pointer");
    SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED);
    return;
  }

  if (app->AreCommandLimitsExceeded(
          static_cast<mobile_apis::FunctionID::eType>(function_id()),
          application_manager::TLimitSource::CONFIG_FILE)) {
    LOG4CXX_ERROR(logger_, "GetVehicleData frequency is too high.");
    SendResponse(false, mobile_apis::Result::REJECTED);
    return;
  }
  const VehicleData& vehicle_data = MessageHelper::vehicle_data();
  VehicleData::const_iterator it = vehicle_data.begin();
  smart_objects::SmartObject msg_params =
      smart_objects::SmartObject(smart_objects::SmartType_Map);
  msg_params[strings::app_id] = app->app_id();
  const uint32_t min_length_msg_params = 1;
  for (; vehicle_data.end() != it; ++it) {
    if (true == (*message_)[str::msg_params].keyExists(it->first) &&
        true == (*message_)[str::msg_params][it->first].asBool()) {
      msg_params[it->first] = (*message_)[strings::msg_params][it->first];
    }
  }
  if (msg_params.length() > min_length_msg_params) {
    StartAwaitForInterface(HmiInterfaces::HMI_INTERFACE_VehicleInfo);
    SendHMIRequest(
        hmi_apis::FunctionID::VehicleInfo_GetVehicleData, &msg_params, true);
    return;
  } else if (HasDisallowedParams()) {
    SendResponse(false, mobile_apis::Result::DISALLOWED);
  } else {
    SendResponse(false, mobile_apis::Result::INVALID_DATA);
  }
}

void GetVehicleDataRequest::on_event(const event_engine::Event& event) {
  LOG4CXX_AUTO_TRACE(logger_);
  smart_objects::SmartObject message = event.smart_object();

  switch (event.id()) {
    case hmi_apis::FunctionID::VehicleInfo_GetVehicleData: {
      EndAwaitForInterface(HmiInterfaces::HMI_INTERFACE_VehicleInfo);
      hmi_apis::Common_Result::eType result_code =
          static_cast<hmi_apis::Common_Result::eType>(
              message[strings::params][hmi_response::code].asInt());
      bool result = PrepareResultForMobileResponse(
          result_code, HmiInterfaces::HMI_INTERFACE_VehicleInfo);
      std::string response_info;
      GetInfo(message, response_info);
      result = result ||
               ((hmi_apis::Common_Result::DATA_NOT_AVAILABLE == result_code) &&
                (message[strings::msg_params].length() > 1));

      if (true ==
          message[strings::msg_params].keyExists(hmi_response::method)) {
        message[strings::msg_params].erase(hmi_response::method);
      }
      if (true == message[strings::params].keyExists(strings::error_msg)) {
        response_info = message[strings::params][strings::error_msg].asString();
      }
      SendResponse(result,
                   MessageHelper::HMIToMobileResult(result_code),
                   response_info.empty() ? NULL : response_info.c_str(),
                   &(message[strings::msg_params]));
      break;
    }
    default: {
      LOG4CXX_ERROR(logger_, "Received unknown event" << event.id());
      return;
    }
  }
}

#endif  // #ifdef HMI_DBUS_API

}  // namespace commands

}  // namespace application_manager


text:
<!DOCTYPE html>

  <meta charset="UTF-8">

  <title>CodePen - M.Celeste Stage 1 Project</title>

    <link rel="stylesheet" href="css/style.css">

  <!DOCTYPE html>

  <meta charset="UTF-8">

  <title>CodePen - Understanding HTML </title>

  <link rel="stylesheet" type="text/css" href="style1.css">

 					Understanding HTML

 Mark Celeste

				 Unit 1:  The Basics of the Web and HTML

			 World Wide Web

 1) You, your PC Browser

 2) The Internet- The worlds largest Computer Network

 3) HTTP Requests - Protocal to communitcate with servers

 4) Connected to servers - hosting files in a remote location

			 HTML - Hypertext Mark Up Language

 1) Text Content - What you See!

 2) Mark Up - what it looks like

 3) Reference to other docs - e.g. images, pictures, or video's'

 4) Misc - made up as tags  (E.G. "name" Contents "Name"     (Opening tag and closing tag, closing has an extra line, entire thing is considered an element, not adding a closing tag leaves the code open and it continues on...

						 HTML Tags & Structure

 PAGE TAGS

 TEXT TAGS

  LINK TAGS

  LIST TAGS

  IMAGE TAGS

  ALL TAG INDEX

					HTML Reference Tag Site

 Common HTML Tags Reference Site (Many common tag examples)

					Container elements: elements that do nothing but contain stuff inside of them. The purpose of these elements will not be clear yet, but in the next lesson you will see how these elements can be used to create web pages with complex structures.

				 Unit 1 Summary

 The five most important things to take from this lesson are the following:

					 1) What a Web Page is  - A web page is a text document written in a language called HTML. Web browsers read these documents, and then interpret and display them.

					 2) How Coding Works  - Coding happens when programmers write text in a language that a computer can understand. The computer can then follow the instructions the programmer wrote. For example, the computer might do this by making text like this:

					 3) Computers are Not so "SMART"  - Programmers need to write exactly the way a computer understands (also known as writing with correct "syntax"). For example, if you forget to close a bold tag, the computer won't be able to figure out what you had intended to make bold. This "stupidity" can be very frustrating, but it also gives programmers incredible power: if you know how to talk to a computer than you can tell it do do anything you want.

					 4) Programmers Can't Remember Everything  - There are too many details to keep everything in your head. And that's okay. If you forget how to make text italic in HTML, you can always just look it up.

		 Basic HTML Vocabulary

				 Tag:  An HTML tag is always contained within angled brackets. Most tags have an opening tag (" p " ' for example) and a closing tag, ("p"). Some tags (called "void" tags) do not require a closing tag (like the "br" tag).

				Element: An HTML element refers to everything within a set of opening and closing tags.

				 Attribute:   This is a property of an HTML element. For example, to set the href attribute of an anchor tag to the Udacity URL,  " a href="www.udacity.com"

 Span and Div will be used often in this class! 							 Span is Inline and Div is a block element

 				 See video on how to save an HTML file!!

				Saving HTML File

				 Unit 2:  Web Pages, Documents, and Structure

						 Google Chrome  - Has great develpment tools and allows one to breakdown a webpage and view the HTML tree Structure. While there are other browsers that have similar tools, we have chosen to use Chrome for simplicity of instruction. The knowledge and skills you acquire by using these tools will however easily translate to other similar developer oriented tools.

						 HTML Editor  - examples include Sublime Text, Bracket's, Notes Plus Plus. Learn to use the tools, they make your coding that much easier. I have also found many tutorial videos on you tube for Sublime text.

			 HTML & Browser Structure

					 HTML  - HyperText Markup Language - the standard markup language used to create web pages. (Tags, browser turns tag in elements, tags have types). HTML controls the strucutre of the web page. Understand the tree like structure.  Wiki Tree Structures

					 HTML RESOURCE

			 				 CSS  - Cascading Style Sheets - style sheet language used for describing the look and formatting of a document written in a markup language. (Allows to use syntax rules to change how elements can change on a page) HTML and CSS are both languages.

			 				 CSS RESOURCE

						 DOM  - Document Object Model - a cross-platform and language-independent convention for representing and interacting with objects in HTML (and other markup languages). The nodes of every document are organized in a tree structure, called the DOM tree.

						 DOM TREE RESOURCE

  Unit 3:  Style & Structure with CSS

	 		 CSS - How it works and How to Use it

	 				 CSS Files  - You can have several sheets, all will be used to define page styles, think of it as laws that make the whole. The most specific rule is applied to every element, refers to cascading

	 				 Order Matters

					It also matters where you define the rules and in what order they are applied. Styles can be defined in different places and are applied in the following order, with definitions further down the list overwriting previous definitions: the default style of a browser (different browsers have slightly different styles)
					stylesheet in a separate file (this is what you will be mostly using)stylesheet inside HTML (this can be done for small projects but is not ideal) inline style in an element (this can also be done but should be avoided)

					 Specifics Matter

					"Cascading" means that rules are applied not only to the elements they directly match, but also to all of those elements' child elements. However, if a child element has multiple, overlapping rules defined for it, the more specific rule takes effect.

					That idea is known as inheritance and understanding it requires abstract thinking.

					 Selecter

					Write style that applies to class  e.g. description
					Combine selectors
					Very nice article on CSS selectors.

					 Selector Resource Link

  Selecting a Class

			lassing HTML elements, makes it possible to define CSS styles for classes of elements.

			Equal styles for equal classes, or different styles for different classes.

			In the example, we can set the background-color of every h1 to black. If you only want to add style to certain h1s, you can use class selectors.

			Classing Block Elements

			The HTML "div" element is a block level element. It can be used as a container for other HTML elements.

			Classing "div" elements, makes it possible to define equal styles for equal "div" elements:

			Classing Inline Elements
			The HTML "span" element is an inline element that can be used as a container for text.

			Classing "span" elements makes it possible to design equal styles for equal "span" elements.

			 CLASS Resource Link

  Including CSS Styling in the web page

				 Method 1: write CSS in the "head" of your HTML

				This method is good for very small projects (like what you'd do in scratchpad.io). To do this: 1. At the top of your HTML document, add a "head" element. 2. Inside the "head" element, add a "style" element. 3. Write your CSS in the "style" element and then put the HTML for the rest of your page below.

				Method 2: Link your HTML to a separate CSS file

				This adds another step, but it lets you stay more organized when working on larger projects. To do this: 1. Write all of your structural HTML in one file (let's call it main.html). 2. In a separate file (let's call it main.css), put all of your CSS code. 3. Add a "head" element to the top of your HTML. 4. Add a "link" tag inside the "head" element. Since "link" is a "void tag" you don't need to add a closing "link".

				 Method 3: Write your style inline with your HTML

				This is generally a very bad idea because it leads to lots of repeated code. But you may see code that uses this method so it's good to be familiar with it. If you want to know more, check out the question and answers in this conversation on Stack Overflow (Stack Overflow is the most widely used programming Q/A community out there).

				With this method, you modify the style attributes of every individual HTML element.

				 Browsers   use default stylesheets to determine how to display HTML elements. You can view the default style rules for h1 and other elements for the following browsers:

					 WebKit  (Chrome and Safari)  Web Kit Link

					 Firefox    Fire Fox Link

				 Internet Explorer

						Because these rules differ sometimes between browsers, there are efforts to promote consistency in styles across browsers. One popular solution to this issue is using what is referred to as a CSS reset such as normalize.css.  http://necolas.github.io/normalize.css/

  Box Sizing

					HTML elements are boxes and each box has 4 components.
					Because there are so many components to each box, it can often be hard to get the size of a box just right.
					There are two techniques you can use to help deal with sizing issues.

					 Code  -  Test   - Refine

						Structure - Visually Box
						Tags - heading
						Size of the boxes
						How to position
						Once layout is complete
						Time for smaller details

					Look for Natural Boxes
					Look for repeated styles and Semantic elements
					Write your HTML
					Apply Styles  (big to small)
					Fix the small things

  Verify HTML Code

To verify HTML:  Verift HTML Link

To verify CSS:  Verify CSS Link


text:
namespace Util.Ui.Operations {
    /// <summary>
    /// 标签
    /// </summary>
    public interface ILabel {
    }
}


text:
using Piranha.Manager;
using Piranha.Models;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Threading.Tasks;

namespace Piranha.Areas.Manager.Controllers
{
    [Area("Manager")]
    public class AccountController : Controller
    {
        /// <summary>
        /// The current Api.
        /// </summary>
        private readonly IApi api;

        /// <summary>
        /// The current security provider.
        /// </summary>
        private readonly ISecurity security;

        /// <summary>
        /// Default constructor.
        /// </summary>
        /// <param name="api">The current Api</param>
        /// <param name="security">The current security provider</param>
        public AccountController(IApi api, ISecurity security) {
            this.api = api;
            this.security = security;
        }

        /// <summary>
        /// Gets the login view.
        /// </summary>
        /// <param name="returnurl">The optional return url</param>
        [Route("manager/login/{returnurl?}")]
        public IActionResult Login(string returnurl = null) {
            return View("Login", returnurl);
        }

        /// <summary>
        /// Signs out the user and redirects to the login page.
        /// </summary>
        /// <param name="returnurl">The optional return url</param>
        [Route("manager/logout")]
        public async Task<IActionResult> Logout(string returnurl = null) {
            await security.SignOut(HttpContext);

            return RedirectToAction("Login", "Account");
        }

        /// <summary>
        /// Signs in the user with the given credentials.
        /// </summary>
        /// <param name="model">The login model</param>
        [HttpPost]
        [Route("manager/login")]
        public async Task<IActionResult> Login(Models.LoginModel model) {
            if (!string.IsNullOrWhiteSpace(model.UserName) && !string.IsNullOrWhiteSpace(model.Password))
            {
                var result = await security.SignIn(HttpContext, model.UserName, model.Password);

                if (result) {
                    if (!string.IsNullOrWhiteSpace(model.ReturnUrl))
                        return Redirect(model.ReturnUrl);
                    else return RedirectToAction("List", "Page", new { pageId = "" });
                }
            }
            ViewBag.Message = "You have entered an invalid username or password ";
            return Login(model.ReturnUrl);
        }
    }
}


text:
=====================
Elastic Cloud Server
=====================

An Elastic Cloud Server (ECS) is a virtual server that runs in a secure and isolated environment. You can create multiple ECSs and adjust their specifications at any time to meet changing service requirements.

.. toctree::
   :maxdepth: 2

   api-reference/index
   user-guide/index


text:
copyright:
  years: 2016, 2017
lastupdated: "2017-03-13"

---

{:new_window: target="\_blank"}
{:shortdesc: .shortdesc}
{:screen: .screen}
{:codeblock: .codeblock}
{:pre: .pre}

# {{site.data.keyword.iot_short_notm}}-Blockchain-Integration
{: #gettingstartedtemplate}

Durch die {{site.data.keyword.iot_short_notm}}-Integration von Blockchain ist es möglich, dass IoT-Geräte Daten für Blockchain-Transaktionen bereitstellen; dadurch werden die Daten im nicht veränderbaren Blockchain-Konto gespeichert und in den Geschäftsregeln verwendet, die in den intelligenten Blockchain-Verträgen implementiert sind.
{:shortdesc}

Die Plattform akzeptiert Gerätedaten im nativen MQTT-Format, ordnet sie dem für die intelligenten Verträge von Blockchain erforderlichen Datenformat zu und übergibt sie an ein Blockchain-Fabric, damit sie im Blockchain-Konto gespeichert werden. Ein Blockchain-Fabric ist eine Sammlung von Peer- und Zertifizierungsknoten, die eine Instanz von {{site.data.keyword.blockchainfull}} und Hyperledger bilden.

## Architektur der Blockchain-Integration
{: #architecture}

Eine generische {{site.data.keyword.iot_short_notm}}-Umgebung für die Blockchain-Integration besteht aus den folgenden Komponenten:
- Mindestens ein Gerät, das Daten generiert, die Sie in ein Blockchain-Konto schreiben möchten.
- {{site.data.keyword.Bluemix_notm}}-Organisation:
 - {{site.data.keyword.iot_short_notm}}-Service mit aktivierter IoT-Blockchain-Integration.
 - {{site.data.keyword.blockchainfull_notm}}- oder Hyperledger-Fabric mit mindestens einem bereitgestellten intelligenten Vertrag.
- Lokale Umgebung:
 - IoT-Blockchain-Benutzerschnittstelle für die Überwachung

Weitere Informationen zur Einrichtung und zu den Anforderungen für eine erweiterte Umgebung, die zum Erstellen und Bereitstellen von intelligenten Verträgen verwendet werden soll, finden Sie in [Intelligente Verträge für die {{site.data.keyword.iot_short_notm}}-Integration mit Blockchain entwickeln](blockchain/dev_blockchain.html).

Das folgende Diagramm veranschaulicht die allgemeine Umgebung für die {{site.data.keyword.iot_short_notm}}-Integration mit Blockchain.

![Die IoT-Blockchain-Architektur.](blockchain/images/architecture_generic.svg "IoT-Blockchain-Architektur")

## Vorbereitende Schritte
{: #byb}

- Verschaffen Sie sich bei IBM.com eine Übersicht über {{site.data.keyword.iot_short_notm}}, über dessen Beziehung zum allgemeinen Blockchain-Konzept und was es für Sie in [{{site.data.keyword.iot_short_notm}} ![Symbol für externen Link](../../icons/launch-glyph.svg "Symbol für externen Link")](http://www.ibm.com/blockchain/){: new_window} ausführen kann.
- [Aktivieren Sie die {{site.data.keyword.iot_short_notm}}-Blockchain-Integration](reference/extensions/index.html#blockchain) für Ihre Organisation.
- Stellen Sie eine Verbindung für Geräte her, die Daten erzeugen, die Sie in das Blockchain-Konto schreiben möchten.
Folgen Sie den Anweisungen im Abschnitt [Geräte verbinden](iotplatform_task.html), um für Ihre Geräte eine Verbindung herzustellen.
- Installieren Sie die Benutzerschnittstelle für die Überwachung.
Mit der Benutzerschnittstelle für die Überwachung wird die Verbindung zwischen {{site.data.keyword.iot_short_notm}} und dem Blockchain-Fabric überprüft. Folgen Sie den Anweisungen im Readme-Dokument der Benutzerschnittstelle für die Überwachung, das im GitHub-Verzeichnis der [Blockchain-Benutzerschnittstelle für die Überwachung ![Symbol für externen Link](../../icons/launch-glyph.svg "Symbol für externen Link")](https://github.com/ibm-watson-iot/blockchain-samples/tree/master/applications/monitoring_ui){: new_window} verfügbar ist.

### IBM Basisszenario für einen schnellen Start

Um schnell mit dem Testen der {{site.data.keyword.iot_short_notm}}-Integration mit Blockchain zu starten, können Sie eine Verbindung zu einem von IBM bereitgestellten Fabric herstellen und dem von IBM bereitgestellten Beispielvertrag ein Node-RED-Beispielgerät zuordnen.  Die für dieses Szenario erforderlichen Schritte werden in diesem Abschnitt als **IBM Basisszenario** bezeichnet.
**Wichtig:** Beachten Sie, dass das von IBM bereitgestellte Blockchain-Beispielkonto und alle zugehörigen Daten für alle Benutzer des Blockchain-Beispielkontos sichtbar sind. Speichern Sie in dem von IBM bereitgestellten Blockchain-Beispielkonto keine sensiblen Informationen. Darüber hinaus sind bei Beispielfabrics, die das Beispiel unterstützen, sowie bei Trade Lane-Verträgen einschließlich der Verbindungsinformationen für die einzelnen Peers Änderungen vorbehalten. Die Verbindungsdetails stehen in der Watson IoT-Blockchain-Community auf der Wikiseite [IoT-Blockchain-Verbindungsinformationen ![Symbol für externen Link](../../icons/launch-glyph.svg "Symbol für externen Link")](https://www.ibm.com/developerworks/community/wikis/home?lang=en#!/wiki/W7a44a0e604d9_4a90_89b7_0a2bdbe81b00/page/Blockchain%20Fabric%20Connections){: new_window} zur Verfügung.

Die von IBM bereitgestellte grundlegende Umgebung für die {{site.data.keyword.iot_short_notm}}-Integration mit Blockchain besteht aus den folgenden Komponenten:
- {{site.data.keyword.Bluemix_notm}}:
 - {{site.data.keyword.iot_short_notm}}-Service mit aktivierter IoT-Blockchain-Integration
 - Optional: Node-RED-Anwendung, die einen IoT-Gerätesimulator ausführt

 **Hinweis:** Der Gerätesimulator kann auch in einer lokalen Node-RED-Umgebung implementiert sein.
- Lokale Umgebung:
 - Node.js
 - IoT-Blockchain-Benutzerschnittstelle für die Überwachung
- Von IBM bereitgestellt:
 - Optional: {{site.data.keyword.iot_short_notm}}-Fabric mit einem einfach gehaltenen intelligenten Vertrag, der vorimplementiert ist.

Das folgende Architekturdiagramm veranschaulicht die für dieses Beispielszenario erforderlichen Komponenten.

![Die IoT-Blockchain-Architektur.](blockchain/images/architecture.svg "IoT-Blockchain-Architektur")

**IBM Basisszenario:** Erstellen Sie einen Node-RED-Gerätesimulator, indem Sie den Anweisungen im Abschnitt [Node-RED-Gerätesimulator erstellen und verbinden](nodereddevice_sample.html) folgen. Verwenden Sie für eine Blockchain-Integration beim Importieren der Knotendaten die für Blockchain-Geräte spezifischen Knoteninformationen. Die Knoteninformationen stehen auf der Wikiseite [Node-RED Device Simulator ![Symbol für externen Link](../../icons/launch-glyph.svg)](https://www.ibm.com/developerworks/community/wikis/home?lang=en#!/wiki/W7a44a0e604d9_4a90_89b7_0a2bdbe81b00/page/Node-RED%20Device%20Simulator){: new_window} der Watson IoT-Blockchain-Community zur Verfügung. Wenden Sie sich gegebenenfalls an Ihren IBM Ansprechpartner für Blockchain, um Zugang zu der Community zu erhalten.

## Verbindung zu Blockchain-Fabric herstellen
{: #getting_started}
Da die {{site.data.keyword.iot_short_notm}}-Blockchain-Integration aktiviert ist, können Sie nun eine Verbindung zu Blockchain-Fabrics herstellen, die von {{site.data.keyword.blockchainfull_notm}} oder Linux Foundation Hyperledger gehostet werden.

So stellen Sie die Verbindung zu einem Blockchain-Fabric her:
1. Wählen Sie im {{site.data.keyword.iot_short_notm}}-Dashboard die Option **Erweiterungen** aus.
2. Klicken Sie auf der Seite **Erweiterungen** der Kachel 'Blockchain' auf **Einrichten**.
3. Klicken Sie auf der Seite **Erweiterungen** der Kachel 'Blockchain' auf **Einrichten** oder klicken Sie auf ![Zahnradsymbol](images/gear.png "Konfigurieren"), falls bereits Fabrics verbunden sind, und geben Sie die Fabric-Informationen ein.
 1. Geben Sie auf der Registerkarte **Fabric** einen Namen ein, um das Fabric in {{site.data.keyword.iot_short_notm}} anzugeben, und klicken Sie anschließend auf **Weiter**.
 2. Geben Sie auf der Registerkarte **Peer** die Peerinformationen ein.

Parameter
Wert

Name
Geben Sie einen Namen ein, um den Peer in {{site.data.keyword.iot_short_notm}} anzugeben.

Host
Die Adresse `api_host` für den Server des überprüfenden Peers 1.

Port
Die Nummer `api_port`.

Verwenden Sie Port 80, wenn Ihre Implementierung kein TLS verwendet.

Verwenden Sie Port 443, wenn Ihre Implementierung TLS verwendet.

Benutzer-ID
Die Zeichenfolge `username` (Benutzername) für den Benutzer, die zum Registrieren des intelligenten Vertrags bei Blockchain verwendet wurde. Sie verwenden diese Benutzer-ID auch, wenn Sie später die einfache Benutzerschnittstelle konfigurieren (Simple UI).

Geheimer Schlüssel
Die Zeichenfolge `secret` für den Benutzer.

TLS verwenden
An oder Aus
Verwenden Sie Transport Layer Security, um die Kommunikation zwischen {{site.data.keyword.iot_short_notm}} und dem Vertrag im Fabric zu verschlüsseln. Die Standardportnummern werden durch die bereitgestellte {{site.data.keyword.iot_short_notm}}-Instanz festgelegt, zu der Sie eine Verbindung herstellen.

 3. Klicken Sie auf **Fertigstellen**.
3. Klicken Sie im Abschnitt zum Konfigurieren von Blockchain auf **Fertig**, um die Fabric-Informationen zu speichern.

**IBM Basisszenario:** Verwenden Sie zum Herstellen einer Verbindung zu dem von IBM bereitgestellten Fabric die Verbindungsdetails für den Beispielvertrag, die auf der Wikiseite [IoT-Blockchain-Verbindungsinformationen ![Symbol für externen Link](../../icons/launch-glyph.svg "Symbol für externen Link")](https://www.ibm.com/developerworks/community/wikis/home?lang=en#!/wiki/W7a44a0e604d9_4a90_89b7_0a2bdbe81b00/page/Blockchain%20Fabric%20Connections){: new_window} der Watson IoT-Blockchain-Community zur Verfügung stehen. Wenden Sie sich gegebenenfalls an Ihren IBM Ansprechpartner für Blockchain, um Zugang zu der Community zu erhalten.

## Gerätedaten intelligenten Verträgen zuordnen
{: #map_device_properties}

Um Gerätedaten in das Blockchain-Konto zu schreiben, müssen Sie zuerst die Geräteeigenschaften für einen Gerätetyp den Parametern zuordnen, die durch den intelligenten Vertrag definiert sind.

Gehen Sie wie folgt vor, um Gerätedaten einem Vertrag zuzuordnen:
 1. Klicken Sie im {{site.data.keyword.iot_short_notm}}-Dashboard in der seitlichen Menüleiste auf ![Blockchain.](blockchain/images/platform_blockchain.png "Blockchain").
 3. Klicken Sie auf **Gerätedaten zuordnen**.
 4. Wählen Sie den Gerätetyp aus, für den Sie Gerätedaten in Blockchain speichern wollen.
 5. Geben Sie den Ereignisnamen für die Ereignisse ein, die Sie speichern möchten.
 **Tipp:** Der standardmäßige Ereignisname für das Node-RED-Blockchain-Beispielgerät lautet 'obc'. Um die Ereignistypen für ein Gerät zu finden, wählen Sie im {{site.data.keyword.iot_short_notm}}-Dashboard die Option **Geräte** aus und klicken Sie auf den Gerätenamen, um die Seite mit den Gerätedetails zu öffnen. Blättern Sie abwärts zum Abschnitt **Sensorinformationen**, um eine Liste der verfügbaren Ereignisse und Datenpunkte für das Gerät anzuzeigen. Sie können den Ereignisnamen ändern, den das Node-RED-Gerät publiziert, indem Sie das Feld 'Topic' im MQTT-Ausgangsknoten 'Publish to IoT' aktualisieren.
 6. Klicken Sie auf **Weiter**.
 6. Wählen Sie die Fabric-Instanz aus, die Sie zuvor erstellt haben.
 7. Geben Sie einen Vertragsnamen und die Vertrags-ID ein.

Parameter
Kommentar

Vertragsname
Ein Name, der verwendet wird, um den Vertrag in {{site.data.keyword.iot_short_notm}} anzugeben.

Vertrags-ID
Die eindeutige Zeichenfolge des zugeordneten Vertrags mit 128 Zeichen.
 **Wichtig:** Der Vertrag, den Sie zuordnen, muss mindestens folgende Methoden unterstützen:
- updateAsset
- readAssetSchemas

**IBM Basisszenario:** Der vorimplementierte intelligente Beispielvertrag lässt zu, dass Sie Datenpunkte des Geräts zu bestimmten Vertragsattributen zuordnen, um die Datenpunktwerte im Blockchain-Konto zu speichern. Verwenden Sie den Beispielvertrag, um die Zuordnung von Gerätedaten zu testen, bevor Sie versuchen, die erweiterten Trade Lane-Verträge zu verwenden oder eigene Verträge zu schreiben. Die Vertrags-ID wird auf der Wikiseite [IoT-Blockchain-Verbindungsinformationen ![Symbol für externen Link](../../icons/launch-glyph.svg "Symbol für externen Link")](https://www.ibm.com/developerworks/community/wikis/home?lang=en#!/wiki/W7a44a0e604d9_4a90_89b7_0a2bdbe81b00/page/Blockchain%20Fabric%20Connections){: new_window} der Watson IoT-Blockchain-Community zur Verfügung gestellt. Wenden Sie sich gegebenenfalls an Ihren IBM Ansprechpartner für Blockchain, um Zugang zu der Community zu erhalten.

 8. Erstellen Sie eine Route, um Geräteeigenschaften zu Vertragsparametern zuzuordnen.
 Die im Vertrag verfügbaren Parameter werden importiert. Geben Sie für jeden Parameter eine entsprechende Ereigniseigenschaft ein.
 **Wichtig:** Schließen Sie nicht das Zeichen `d.` ein, das dem Datenpunkt in der Gerätenachricht vorangestellt ist.
 **IBM Basisszenario:** Ordnen Sie bei Verwendung der von IBM bereitgestellten Verträge folgende Parameter zu, die auf der Wikiseite [Datenzuordnung ![Symbol für externen Link](../../icons/launch-glyph.svg "Symbol für externen Link")](https://www.ibm.com/developerworks/community/wikis/home?lang=en#!/wiki/W7a44a0e604d9_4a90_89b7_0a2bdbe81b00/page/Data%20Mapping){: new_window} der Watson IoT-Blockchain-Community zur Verfügung stehen. Wenden Sie sich gegebenenfalls an Ihren IBM Ansprechpartner für Blockchain, um Zugang zu der Community zu erhalten.
 9. Überprüfen Sie auf der Übersichtsseite, dass alle Informationen ordnungsgemäß eingegeben wurden.
 10. Die Zuordnung der Gerätedaten zum Vertrag wird auf der Blockchain-Seite angezeigt.

Glückwunsch - alles ist betriebsbereit!

## Testlauf für das von IBM bereitgestellte Beispiel für einen intelligenten Vertrag ausführen
{: #test_simple}

Wenn eine Verbindung zu dem von IBM bereitgestellten Fabric besteht und Sie Ihre Gerätedaten dem Beispielvertrag zugeordnet haben, können Sie testen, ob der Datenfluss vom Gerät zum Blockchain-Konto durchgängig ist. Verwenden Sie die IoT-Blockchain-Benutzerschnittstelle für die Überwachung, um die Blockchain-Aktivität und die Daten für Ihre Assets anzuzeigen.
**Tipp:** Wenn die Benutzerschnittstelle für die Überwachung noch nicht in Ihrer lokalen Umgebung installiert ist, können Sie sie jetzt installieren. Folgen Sie den Anweisungen im Readme-Dokument der Benutzerschnittstelle für die Überwachung, das im GitHub-Verzeichnis der [Blockchain-Benutzerschnittstelle für die Überwachung ![Symbol für externen Link](../../icons/launch-glyph.svg "Symbol für externen Link")](https://github.com/ibm-watson-iot/blockchain-samples/tree/master/applications/monitoring_ui){: new_window} verfügbar ist.
1. Konfigurieren Sie die Benutzerschnittstelle für die Überwachung, um eine Verbindung zu {{site.data.keyword.iot_short_notm}} herzustellen.
 Klicken Sie in der Benutzerschnittstelle für die Überwachung auf die Option für **Konfiguration**, um die Verbindung für die Benutzerschnittstelle für die Überwachung zu konfigurieren:

Parameter
Kommentar

API-Host und -Port
Der Host und der Port für die {{site.data.keyword.iot_short_notm}}-REST-API, der `http://` vorangestellt ist. Verwenden Sie die Adresse `api_host` und die Nummer `api_port`.

Chaincode-ID
Die Vertrags-ID ist eine alphanumerische Zeichenfolge aus 128 Zeichen, die dem Eintrag für die Vertrags-ID entspricht.
**Wichtig:** Wenn Sie die Chaincode-ID ausschneiden und einfügen, müssen Sie sicherstellen, dass in der ID keine Leerzeichen enthalten sind. Wenn die ID falsch eingegeben wird, werden die Einträge des Blockchain-Kontos angezeigt, aber die Suchfunktion für Assets funktioniert nicht.

Sicherer Kontext
Dieser Parameter ist für das Herstellen einer Verbindung zu {{site.data.keyword.iot_short_notm}}-Instanzen in Bluemix erforderlich. Verwenden Sie den Eintrag 'secureContext'.
**Wichtig:** 'secureContext' sollte ein berechtigter Benutzer des Fabrics sein, der beim Erstellen des Fabrics definiert wurde.

**IBM Basisszenario:** Um die Benutzerschnittstelle für die Überwachung für das Herstellen einer Verbindung zu Basis- oder Trade Lane-Verträgen zu konfigurieren, verwenden Sie die Verbindungsdetails, die auf der Wikiseite [IoT-Blockchain-Verbindungsinformationen ![Symbol für externen Link](../../icons/launch-glyph.svg "Symbol für externen Link")](https://www.ibm.com/developerworks/community/wikis/home?lang=en#!/wiki/W7a44a0e604d9_4a90_89b7_0a2bdbe81b00/page/Blockchain%20Fabric%20Connections){: new_window} der Watson IoT-Blockchain-Community zur Verfügung stehen. Wenden Sie sich gegebenenfalls an Ihren IBM Ansprechpartner für Blockchain, um Zugang zu der Community zu erhalten.
2. Klicken Sie im Node-RED-Ablaufeditor auf die Schaltfläche auf dem Knoten CON123, um Gerätedaten einzufügen, sie als Nachricht an {{site.data.keyword.iot_short_notm}} zu senden und sie über den einfachen Vertrag in das {{site.data.keyword.iot_short_notm}}-Konto zu schreiben.
**Tipp:** Um einen fortlaufenden Datenfluss zu erhalten, doppelklicken Sie auf den Einfügeknoten, legen Sie für den Parameter 'repeat' die Einstellung `interval` fest und konfigurieren Sie für das Intervall eine entsprechende Länge, beispielsweise '1 Minute'.
3. Überprüfen Sie in der Benutzerschnittstelle für die Überwachung, dass Gerätedaten in den Blockchain-Blöcken wie erwartet angezeigt werden.
  1. Überprüfen Sie, dass beim Einfügen von Daten, die vom Gerät stammen, der Kette (Chain) Blöcke hinzugefügt werden.
  **Wichtig:** Verwenden Sie zur Aktualisierung der Benutzerschnittstelle für die Überwachung nicht die Schaltfläche für Aktualisierung des Browsers. Die Benutzerschnittstelle wird nach jeweils wenigen Sekunden automatisch aktualisiert. Bei Verwendung der Schaltfläche für Aktualisierung des Browsers werden die Benutzerschnittstelleneinstellungen auf die Standardwerte zurückgesetzt und Sie müssen die Benutzerschnittstelle für die Überwachung erneut konfigurieren, um die Blockchain für Verträge anzuzeigen.
  2. Um die neuesten Kontoinformationen für Ihr Asset anzuzeigen, geben Sie im Suchfeld für Asset-IDs die ID Ihres Assets ein und klicken Sie auf die Option zum **Übergeben**. Beispiel: `CON123`
  Zum Anzeigen von Blockchain-Daten für mehrere Assets, die denselben Vertrag verwenden, geben Sie den Assetnamen ein und klicken Sie auf die Option zum **Übergeben**. Klicken Sie auf **Zurücksetzen**, um neu zu beginnen.
  **Tipps:**
    - Durch Einschalten der Funktion für Abfragen von Änderungen (Poll for changes) wird sichergestellt, dass die Benutzerschnittstelle fortlaufend Abfragen nach Änderungen des Assets ausführt, das beobachtet/überwacht wird, und die Daten aktualisiert, sobald in Blockchain eine Änderung festgeschrieben wird.
    - Der Standardwert für 'assetID' des Blockchain-Geräts lautet 'CON123'. Wenn Sie die Gerätenachricht geändert haben oder die Asset-ID (assetID) im Node-RED-Gerätesimulator aktualisiert haben, können Sie die Asset-ID in {{site.data.keyword.iot_short_notm}} suchen. Wechseln Sie zur Seite **Geräte** und klicken Sie auf Ihr Gerät, um die Seite mit den Gerätedetails zu öffnen. Blättern Sie abwärts zum Abschnitt **Sensorinformationen**, um eine Liste der Datenpunkte für das Gerät anzuzeigen. Verwenden Sie als Asset-ID (assetID) den Wert für den Datenpunkt `d.assetID`.

## Nächste Schritte
{: #next_steps}
Sie haben nun eine grundlegende {{site.data.keyword.iot_short_notm}}-Umgebung mit IoT-Blockchain-Integration installiert und konfiguriert. In diesem Mindestszenario lässt der intelligente Basisvertrag zu, dass Sie Gerätedaten in das Blockchain-Konto schreiben, um ein unlöschbares Gerätedatenprotokoll zu erstellen. Nachdem Sie nun diese ersten Schritte abgeschlossen und den einfach gehaltenen Vertrag getestet haben, können Sie es mit dem Beispiel für einen erweiterten Trade Lane-Vertrag versuchen und eigene Verträge schreiben.

Anweisungen zu diesen weiterführenden Schritten finden Sie im Abschnitt [Intelligente Verträge für die {{site.data.keyword.iot_short_notm}}-Blockchain-Integration entwickeln](blockchain/dev_blockchain.html).


text:
(function (scope) {

	scope.Box = Polymer({
		is: "strand-box",

		behaviors: [
			StrandTraits.Resolvable,
			StrandTraits.Refable
		],

		properties: {
			direction: {
				// options: row | row-reverse | column | column-reverse
				type: String,
				value: 'horizontal'
			},
			align: {
				// options: flex-start | flex-end | center | baseline | stretch
				type: String,
				value: 'flex-start'
			},
			justify: {
				// options: flex-start | flex-end | center | space-between | space-around
				type: String,
				value: 'flex-start'
			}
		},

		observers: [
			'_updateStyle(direction, align, justify)'
		],

		_updateStyle: function(direction, align, justify) {
			var flexDir = direction === 'horizontal' ? 'row' : 'column';

			this.style.flexDirection = flexDir;
			this.style.justifyContent = justify;
			this.style.alignItems = align;
		}

	});

})(window.Strand = window.Strand || {});


text:
#include "resize2fs.h"
#ifdef HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif
#include <sys/stat.h>
#include <fcntl.h>

extern char *program_name;

errcode_t online_resize_fs(ext2_filsys fs, const char *mtpt,
			   blk_t *new_size, int flags EXT2FS_ATTR((unused)))
{
#ifdef __linux__
	struct ext2_new_group_input input;
	struct ext4_new_group_input input64;
	struct ext2_super_block *sb = fs->super;
	unsigned long		new_desc_blocks;
	ext2_filsys 		new_fs;
	errcode_t 		retval;
	double			percent;
	dgrp_t			i;
	blk_t			size;
	int			fd, overhead;
	int			use_old_ioctl = 1;

	printf(_("Filesystem at %s is mounted on %s; "
		 "on-line resizing required\n"), fs->device_name, mtpt);

	if (*new_size < sb->s_blocks_count) {
		printf(_("On-line shrinking from %u to %u not supported.\n"),
		       sb->s_blocks_count, *new_size);
		exit(1);
	}

	/*
	 * If the number of descriptor blocks is going to increase,
	 * the on-line resizing inode must be present.
	 */
	new_desc_blocks = ext2fs_div_ceil(
		ext2fs_div_ceil(*new_size -
				fs->super->s_first_data_block,
				EXT2_BLOCKS_PER_GROUP(fs->super)),
		EXT2_DESC_PER_BLOCK(fs->super));
	printf("old desc_blocks = %lu, new_desc_blocks = %lu\n",
	       fs->desc_blocks, new_desc_blocks);
	if (!(fs->super->s_feature_compat &
	      EXT2_FEATURE_COMPAT_RESIZE_INODE) &&
	    new_desc_blocks != fs->desc_blocks) {
		com_err(program_name, 0,
			_("Filesystem does not support online resizing"));
		exit(1);
	}

	fd = open(mtpt, O_RDONLY);
	if (fd < 0) {
		com_err(program_name, errno,
			_("while trying to open mountpoint %s"), mtpt);
		exit(1);
	}

	size=sb->s_blocks_count;
	if (ioctl(fd, EXT2_IOC_GROUP_EXTEND, &size)) {
		if (errno == EPERM)
			com_err(program_name, 0,
				_("Permission denied to resize filesystem"));
		else if (errno == ENOTTY)
			com_err(program_name, 0,
			_("Kernel does not support online resizing"));
		else
			com_err(program_name, errno,
			_("While checking for on-line resizing support"));
		exit(1);
	}

	percent = (sb->s_r_blocks_count * 100.0) / sb->s_blocks_count;

	retval = ext2fs_read_bitmaps(fs);
	if (retval)
		return retval;

	retval = ext2fs_dup_handle(fs, &new_fs);
	if (retval)
		return retval;

	/* The current method of adding one block group at a time to a
	 * mounted filesystem means it is impossible to accomodate the
	 * flex_bg allocation method of placing the metadata together
	 * in a single block group.  For now we "fix" this issue by
	 * using the traditional layout for new block groups, where
	 * each block group is self-contained and contains its own
	 * bitmap blocks and inode tables.  This means we don't get
	 * the layout advantages of flex_bg in the new block groups,
	 * but at least it allows on-line resizing to function.
	 */
	new_fs->super->s_feature_incompat &= ~EXT4_FEATURE_INCOMPAT_FLEX_BG;
	retval = adjust_fs_info(new_fs, fs, 0, *new_size);
	if (retval)
		return retval;

	printf(_("Performing an on-line resize of %s to %u (%dk) blocks.\n"),
	       fs->device_name, *new_size, fs->blocksize / 1024);

	size = fs->group_desc_count * sb->s_blocks_per_group +
		sb->s_first_data_block;
	if (size > *new_size)
		size = *new_size;

	if (ioctl(fd, EXT2_IOC_GROUP_EXTEND, &size)) {
		com_err(program_name, errno,
			_("While trying to extend the last group"));
		exit(1);
	}

	for (i = fs->group_desc_count;
	     i < new_fs->group_desc_count; i++) {

		overhead = (int) (2 + new_fs->inode_blocks_per_group);

		if (ext2fs_bg_has_super(new_fs, new_fs->group_desc_count - 1))
			overhead += 1 + new_fs->desc_blocks +
				new_fs->super->s_reserved_gdt_blocks;

		input.group = i;
		input.block_bitmap = new_fs->group_desc[i].bg_block_bitmap;
		input.inode_bitmap = new_fs->group_desc[i].bg_inode_bitmap;
		input.inode_table = new_fs->group_desc[i].bg_inode_table;
		input.blocks_count = sb->s_blocks_per_group;
		if (i == new_fs->group_desc_count-1) {
			input.blocks_count = new_fs->super->s_blocks_count -
				sb->s_first_data_block -
				(i * sb->s_blocks_per_group);
		}
		input.reserved_blocks = (blk_t) (percent * input.blocks_count
						 / 100.0);

#if 0
		printf("new block bitmap is at 0x%04x\n", input.block_bitmap);
		printf("new inode bitmap is at 0x%04x\n", input.inode_bitmap);
		printf("new inode table is at 0x%04x-0x%04x\n",
		       input.inode_table,
		       input.inode_table + new_fs->inode_blocks_per_group-1);
		printf("new group has %u blocks\n", input.blocks_count);
		printf("new group will reserve %d blocks\n",
		       input.reserved_blocks);
		printf("new group has %d free blocks\n",
		       new_fs->group_desc[i].bg_free_blocks_count);
		printf("new group has %d free inodes (%d blocks)\n",
		       new_fs->group_desc[i].bg_free_inodes_count,
		       new_fs->inode_blocks_per_group);
		printf("Adding group #%d\n", input.group);
#endif

		if (use_old_ioctl &&
		    ioctl(fd, EXT2_IOC_GROUP_ADD, &input) == 0)
			continue;
		else
			use_old_ioctl = 0;

		input64.group = input.group;
		input64.block_bitmap = input.block_bitmap;
		input64.inode_bitmap = input.inode_bitmap;
		input64.inode_table = input.inode_table;
		input64.blocks_count = input.blocks_count;
		input64.reserved_blocks = input.reserved_blocks;
		input64.unused = input.unused;

		if (ioctl(fd, EXT4_IOC_GROUP_ADD, &input64) < 0) {
			com_err(program_name, errno,
				_("While trying to add group #%d"),
				input.group);
			exit(1);
		}
	}

	ext2fs_free(new_fs);
	close(fd);

	return 0;
#else
	printf(_("Filesystem at %s is mounted on %s, and on-line resizing is "
		 "not supported on this system.\n"), fs->device_name, mtpt);
	exit(1);
#endif
}


text:
<?xml version="1.0" encoding="utf-8"?>
<!--
     Copyright (C) 2013 AChep@xda <artemchep@gmail.com>

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
                android:layout_width="fill_parent"
                android:layout_height="fill_parent">

    <com.achep.ringlocker.locker.LockerSurfaceView
            android:id="@+id/locker"
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"/>

    <TextView
            android:id="@+id/time"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:textColor="@android:color/white"
            android:textSize="80sp" />
    <TextView
            android:id="@+id/date"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerHorizontal="true"
            android:layout_marginTop="-10dip"
            android:layout_below="@id/time"
            android:textColor="@android:color/white"
            android:textSize="16sp" />

</RelativeLayout>


text:
require 'netaddr'

helpers do
  def base_url
    @base_url ||= "#{request.env['rack.url_scheme']}://{request.env['HTTP_HOST']}"
  end

  def return_err(code, message)
    halt code, { message: message }.to_json
  end

  def json_params
    begin
      JSON.parse(request.body.read)
    rescue
      return_err(400, "Invalid JSON")
    end
  end
end