text:
News / 2021 / JAMK's corona guidelines as of 1 November, 2021: Restrictions will be lifted, contact teaching will be increased
JAMK's corona guidelines as of 1 November, 2021: Restrictions will be lifted, contact teaching will be increased
JAMK University of Applied Sciences will lift some of the corona restrictions from the beginning of November 2021. Contact teaching is further enabled by removing restrictions from teaching facilities. However, the face mask recommendation remains on campuses and in teaching. The intention is to remove all corona-related restrictions from the beginning of 2022.
JAMK's Corona Team has discussed the guidelines related to the corona situation at its meeting on October 6, 2021. The new guidelines will enter into force on 1 November 2021 by Rector's decision.
Restrictions on teaching facilities will be lifted from the beginning of November. From there on, the teaching facilities can be used at full capacity. The facilities' capacity has previously been limited. The exception are large auditoriums, which are still used at half capacity until the end of the year.
– We will start to remove restrictions in a controlled way in order to enable contact teaching and also the grouping of students. Thus, towards the end of the year, more and more students and staff members will be able to work on campuses. This will greatly affect the well-being of the JAMK community, says Vesa Saarikoski, Rector of JAMK.
Starting from 1 November, the sports facilities and library are also normally open without restrictions. Corona related lunch scheduling will be removed in the campus restaurants and the number of seats in the restaurants can be gradually restored to normal levels. Student and other services are open normally without restrictions.
The face mask recommendation continues
The face mask recommendation will continue on campuses and in teaching situations. The recommendation to use a face mask is especially important in teaching situations where you have to work in close contact as well as in Examstudio rooms. In such situations, JAMK still offers masks for students.
– It was decided to continue the face mask recommendation because vaccine coverage within the student age group is not yet quite at the desired level. By using a mask, we ensure better corona safety even in situations where not everyone has been fully vaccinated yet, Saarikoski says.
In order to improve the vaccine coverage among students, JAMK has organised pop up vaccination points on its campuses in cooperation with the City of Jyväskylä. A total of about a hundred students have visited the pop up points to get vaccinated. Students have received both their first and, if necessary, their second vaccine from the points.
– This has been a good model of cooperation, which we would gladly continue until the vaccine coverage among students is at a sufficient level, Saarikoski says.
Travel still discretionary
With regard to travel, JAMK continues to exercise discretion. Trips abroad are made only with the Rector's approval until the end of the year. Once approved, travel arrangements will be made in the normal way. When returning from trips abroad and for students arriving at JAMK, the applicable official guidelines related to entry are followed (see, for example, Finentry.fi). Domestic travel is not restricted. However, the aim is to reduce travel and encourage remote participation where possible.
All of the changes above will take effect on 1 November, 2021 and will remain in effect until the end of the year, unless otherwise decided. JAMK's Corona Team continues to monitor the situation and make changes to the guidelines if necessary. From the beginning of 2022, JAMK will strive to lift all restrictions related to the corona.
Vesa Saarikoski, Rector
tel. +358 50447 1003
You are here JAMK / News / 2021 / JAMK's corona guidelines as of 1 November, 2021: Restrictions will be lifted, contact teaching will be increased


text:
package edu.harvard.iq.dataverse.api;

import com.jayway.restassured.RestAssured;
import com.jayway.restassured.path.json.JsonPath;
import com.jayway.restassured.response.Response;
import edu.harvard.iq.dataverse.settings.SettingsServiceBean;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.json.Json;
import javax.json.JsonObject;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import edu.harvard.iq.dataverse.util.FileUtil;
import java.io.File;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.Base64;
import javax.json.JsonArray;
import static javax.ws.rs.core.Response.Status.OK;
import static javax.ws.rs.core.Response.Status.FORBIDDEN;
import static javax.ws.rs.core.Response.Status.NO_CONTENT;
import org.hamcrest.CoreMatchers;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import edu.harvard.iq.dataverse.dataaccess.ImageThumbConverter;
import static junit.framework.Assert.assertEquals;
import static java.lang.Thread.sleep;
import static javax.ws.rs.core.Response.Status.CREATED;
import static javax.ws.rs.core.Response.Status.UNAUTHORIZED;
import org.hamcrest.Matchers;
import org.junit.After;

public class SearchIT {

    private static final Logger logger = Logger.getLogger(SearchIT.class.getCanonicalName());

    @BeforeClass
    public static void setUpClass() {

        RestAssured.baseURI = UtilIT.getRestAssuredBaseUri();

        Response makeSureTokenlessSearchIsEnabled = UtilIT.deleteSetting(SettingsServiceBean.Key.SearchApiRequiresToken);
        makeSureTokenlessSearchIsEnabled.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response removeSearchApiNonPublicAllowed = UtilIT.deleteSetting(SettingsServiceBean.Key.SearchApiNonPublicAllowed);
        removeSearchApiNonPublicAllowed.prettyPrint();
        removeSearchApiNonPublicAllowed.then().assertThat()
                .statusCode(200);

        Response remove = UtilIT.deleteSetting(SettingsServiceBean.Key.ThumbnailSizeLimitImage);
        remove.then().assertThat()
                .statusCode(200);

    }

    @Test
    public void testSearchPermisions() throws InterruptedException {
        Response createUser1 = UtilIT.createRandomUser();
        String username1 = UtilIT.getUsernameFromResponse(createUser1);
        String apiToken1 = UtilIT.getApiTokenFromResponse(createUser1);

        Response createDataverse1Response = UtilIT.createRandomDataverse(apiToken1);
        createDataverse1Response.prettyPrint();
        assertEquals(201, createDataverse1Response.getStatusCode());
        String dataverseAlias = UtilIT.getAliasFromResponse(createDataverse1Response);

        Response createDataset1Response = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiToken1);
        createDataset1Response.prettyPrint();
        createDataset1Response.then().assertThat()
                .statusCode(CREATED.getStatusCode());

        Integer datasetId1 = UtilIT.getDatasetIdFromResponse(createDataset1Response);

        Response enableNonPublicSearch = UtilIT.enableSetting(SettingsServiceBean.Key.SearchApiNonPublicAllowed);
        enableNonPublicSearch.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response shouldBeVisibleToUser1 = UtilIT.search("id:dataset_" + datasetId1 + "_draft", apiToken1);
        shouldBeVisibleToUser1.prettyPrint();
        shouldBeVisibleToUser1.then().assertThat()
                .body("data.total_count", CoreMatchers.is(1))
                .body("data.count_in_response", CoreMatchers.is(1))
                .body("data.items[0].name", CoreMatchers.is("Darwin's Finches"))
                .statusCode(OK.getStatusCode());

        Response createUser2 = UtilIT.createRandomUser();
        String username2 = UtilIT.getUsernameFromResponse(createUser2);
        String apiToken2 = UtilIT.getApiTokenFromResponse(createUser2);

        Response shouldNotBeVisibleToUser2 = UtilIT.search("id:dataset_" + datasetId1 + "_draft", apiToken2);
        shouldNotBeVisibleToUser2.prettyPrint();
        shouldNotBeVisibleToUser2.then().assertThat()
                .body("data.total_count", CoreMatchers.is(0))
                .statusCode(OK.getStatusCode());

        String nullToken = null;

        Response shouldNotBeVisibleToTokenLess = UtilIT.search("id:dataset_" + datasetId1 + "_draft", nullToken);
        shouldNotBeVisibleToTokenLess.prettyPrint();
        shouldNotBeVisibleToTokenLess.then().assertThat()
                .body("data.total_count", CoreMatchers.is(0))
                .statusCode(OK.getStatusCode());

        String roleToAssign = "admin";

        Response grantUser2AccessOnDataset = UtilIT.grantRoleOnDataverse(dataverseAlias, roleToAssign, "@" + username2, apiToken1);
        grantUser2AccessOnDataset.prettyPrint();
        assertEquals(200, grantUser2AccessOnDataset.getStatusCode());
        sleep(500l);

        Response shouldBeVisibleToUser2 = UtilIT.search("id:dataset_" + datasetId1 + "_draft", apiToken2);
        shouldBeVisibleToUser2.prettyPrint();
        shouldBeVisibleToUser2.then().assertThat()
                .body("data.total_count", CoreMatchers.is(1))
                .body("data.count_in_response", CoreMatchers.is(1))
                .body("data.items[0].name", CoreMatchers.is("Darwin's Finches"))
                .statusCode(OK.getStatusCode());

        Response publishDataverse = UtilIT.publishDataverseViaSword(dataverseAlias, apiToken1);
        publishDataverse.prettyPrint();
        publishDataverse.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response publishDataset = UtilIT.publishDatasetViaNativeApi(datasetId1, "major", apiToken1);
        publishDataset.prettyPrint();
        publishDataset.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response disableNonPublicSearch = UtilIT.deleteSetting(SettingsServiceBean.Key.SearchApiNonPublicAllowed);
        disableNonPublicSearch.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response makeSureTokenlessSearchIsEnabled = UtilIT.deleteSetting(SettingsServiceBean.Key.SearchApiRequiresToken);
        makeSureTokenlessSearchIsEnabled.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response publishedPublicDataShouldBeVisibleToTokenless = UtilIT.search("id:dataset_" + datasetId1, nullToken);
        publishedPublicDataShouldBeVisibleToTokenless.prettyPrint();
        publishedPublicDataShouldBeVisibleToTokenless.then().assertThat()
                .body("data.total_count", CoreMatchers.is(1))
                .body("data.count_in_response", CoreMatchers.is(1))
                .body("data.items[0].name", CoreMatchers.is("Darwin's Finches"))
                .statusCode(OK.getStatusCode());

        Response disableTokenlessSearch = UtilIT.setSetting(SettingsServiceBean.Key.SearchApiRequiresToken, "true");
        disableTokenlessSearch.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response dataverse47behaviorOfTokensBeingRequired = UtilIT.search("id:dataset_" + datasetId1, nullToken);
        dataverse47behaviorOfTokensBeingRequired.prettyPrint();
        dataverse47behaviorOfTokensBeingRequired.then().assertThat()
                .body("message", CoreMatchers.equalTo("Please provide a key query parameter (?key=XXX) or via the HTTP header X-Dataverse-key"))
                .statusCode(UNAUTHORIZED.getStatusCode());

        Response reEnableTokenlessSearch = UtilIT.deleteSetting(SettingsServiceBean.Key.SearchApiRequiresToken);
        reEnableTokenlessSearch.then().assertThat()
                .statusCode(OK.getStatusCode());
    }

    @Test
    public void testSearchCitation() {

        Response createUser = UtilIT.createRandomUser();
        createUser.prettyPrint();
        String username = UtilIT.getUsernameFromResponse(createUser);
        String apiToken = UtilIT.getApiTokenFromResponse(createUser);

        Response createDataverseResponse = UtilIT.createRandomDataverse(apiToken);
        createDataverseResponse.prettyPrint();
        String dataverseAlias = UtilIT.getAliasFromResponse(createDataverseResponse);

        Response createDatasetResponse = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiToken);
        createDatasetResponse.prettyPrint();
        Integer datasetId = UtilIT.getDatasetIdFromResponse(createDatasetResponse);

        Response enableNonPublicSearch = UtilIT.enableSetting(SettingsServiceBean.Key.SearchApiNonPublicAllowed);
        enableNonPublicSearch.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response searchResponse = UtilIT.search("id:dataset_" + datasetId + "_draft", apiToken);
        searchResponse.prettyPrint();
        assertFalse(searchResponse.body().jsonPath().getString("data.items[0].citation").contains("href"));
        assertTrue(searchResponse.body().jsonPath().getString("data.items[0].citationHtml").contains("href"));
        searchResponse.then().assertThat()
                .body("data.items[0].citation", CoreMatchers.not(Matchers.containsString("href")))
                .body("data.items[0].citationHtml", Matchers.containsString("href"))
                .statusCode(200);

        Response deleteDatasetResponse = UtilIT.deleteDatasetViaNativeApi(datasetId, apiToken);
        deleteDatasetResponse.prettyPrint();
        deleteDatasetResponse.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response deleteDataverseResponse = UtilIT.deleteDataverse(dataverseAlias, apiToken);
        deleteDataverseResponse.prettyPrint();
        deleteDataverseResponse.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response disableNonPublicSearch = UtilIT.deleteSetting(SettingsServiceBean.Key.SearchApiNonPublicAllowed);
        disableNonPublicSearch.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response deleteUserResponse = UtilIT.deleteUser(username);
        deleteUserResponse.prettyPrint();
        assertEquals(200, deleteUserResponse.getStatusCode());

    }

    @Test
    public void testDatasetThumbnail() {
        logger.info("BEGIN testDatasetThumbnail");

//        Response setSearchApiNonPublicAllowed = UtilIT.setSetting(SettingsServiceBean.Key.SearchApiNonPublicAllowed, "true");
//        setSearchApiNonPublicAllowed.prettyPrint();
//
//        assertEquals("foo", "foo");
//        if (true) {
//            return;
//        }
//
        Response createUser = UtilIT.createRandomUser();
        createUser.prettyPrint();
        String username = UtilIT.getUsernameFromResponse(createUser);
        String apiToken = UtilIT.getApiTokenFromResponse(createUser);

        Response createDataverseResponse = UtilIT.createRandomDataverse(apiToken);
        createDataverseResponse.prettyPrint();
        String dataverseAlias = UtilIT.getAliasFromResponse(createDataverseResponse);

        Response createDatasetResponse = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiToken);
        createDatasetResponse.prettyPrint();
        Integer datasetId = UtilIT.getDatasetIdFromResponse(createDatasetResponse);

        Response setSearchApiNonPublicAllowed = UtilIT.setSetting(SettingsServiceBean.Key.SearchApiNonPublicAllowed, "true");
        setSearchApiNonPublicAllowed.prettyPrint();
        setSearchApiNonPublicAllowed.then().assertThat()
                .statusCode(200);

        Response search1 = UtilIT.search("id:dataset_" + datasetId + "_draft", apiToken);
        search1.prettyPrint();
        search1.then().assertThat()
                .body("data.items[0].name", CoreMatchers.equalTo("Darwin's Finches"))
                .body("data.items[0].thumbnailFilename", CoreMatchers.equalTo(null))
                .body("data.items[0].datasetThumbnailBase64image", CoreMatchers.equalTo(null))
                .statusCode(200);

        Response datasetAsJson = UtilIT.nativeGet(datasetId, apiToken);
        datasetAsJson.prettyPrint();
        String protocol = JsonPath.from(datasetAsJson.getBody().asString()).getString("data.protocol");
        String authority = JsonPath.from(datasetAsJson.getBody().asString()).getString("data.authority");
        String identifier = JsonPath.from(datasetAsJson.getBody().asString()).getString("data.identifier");
        String datasetPersistentId = protocol + ":" + authority + "/" + identifier;
        long datasetVersionId = JsonPath.from(datasetAsJson.getBody().asString()).getLong("data.latestVersion.id");

        Response createNoSpecialAccessUser = UtilIT.createRandomUser();
        createNoSpecialAccessUser.prettyPrint();
        String noSpecialAccessUsername = UtilIT.getUsernameFromResponse(createNoSpecialAccessUser);
        String noSpecialAcessApiToken = UtilIT.getApiTokenFromResponse(createNoSpecialAccessUser);

        logger.info("Dataset created, no thumbnail expected:");
        Response getThumbnail1 = UtilIT.getDatasetThumbnailMetadata(datasetId, apiToken);
        getThumbnail1.prettyPrint();
        JsonObject emptyObject = Json.createObjectBuilder().build();
        getThumbnail1.then().assertThat()
                //                .body("data", CoreMatchers.equalTo(emptyObject))
                .body("data.isUseGenericThumbnail", CoreMatchers.equalTo(false))
                .body("data.dataFileId", CoreMatchers.equalTo(null))
                .body("data.datasetLogoPresent", CoreMatchers.equalTo(false))
                .statusCode(200);

        String thumbnailUrl = RestAssured.baseURI + "/api/datasets/" + datasetId + "/thumbnail";
        InputStream inputStream1creator = UtilIT.getInputStreamFromUnirest(thumbnailUrl, apiToken);
        assertNull(inputStream1creator);

        InputStream inputStream1guest = UtilIT.getInputStreamFromUnirest(thumbnailUrl, noSpecialAcessApiToken);
        assertNull(inputStream1guest);

        Response getThumbnailImage1 = UtilIT.getDatasetThumbnail(datasetPersistentId, apiToken); //
        getThumbnailImage1.prettyPrint();
        getThumbnailImage1.then().assertThat()
                .contentType("")
                .statusCode(NO_CONTENT.getStatusCode());

        Response attemptToGetThumbnailCandidates = UtilIT.showDatasetThumbnailCandidates(datasetPersistentId, noSpecialAcessApiToken);
        attemptToGetThumbnailCandidates.prettyPrint();
        attemptToGetThumbnailCandidates.then().assertThat()
                .body("message", CoreMatchers.equalTo("You are not permitted to list dataset thumbnail candidates."))
                .statusCode(FORBIDDEN.getStatusCode());

        Response thumbnailCandidates1 = UtilIT.showDatasetThumbnailCandidates(datasetPersistentId, apiToken);
        thumbnailCandidates1.prettyPrint();
        JsonArray emptyArray = Json.createArrayBuilder().build();
        thumbnailCandidates1.then().assertThat()
                .body("data", CoreMatchers.equalTo(emptyArray))
                .statusCode(200);

        Response getThumbnailImageNoAccess1 = UtilIT.getDatasetThumbnail(datasetPersistentId, noSpecialAcessApiToken);
        getThumbnailImageNoAccess1.prettyPrint();
        getThumbnailImageNoAccess1.then().assertThat()
                .contentType("")
                .statusCode(NO_CONTENT.getStatusCode());

        Response uploadFile = UtilIT.uploadFile(datasetPersistentId, "trees.zip", apiToken);
        uploadFile.prettyPrint();

        Response getDatasetJson1 = UtilIT.nativeGetUsingPersistentId(datasetPersistentId, apiToken);
        Long dataFileId1 = JsonPath.from(getDatasetJson1.getBody().asString()).getLong("data.latestVersion.files[0].dataFile.id");
        System.out.println("datafileId: " + dataFileId1);
        getDatasetJson1.then().assertThat()
                .statusCode(200);

        logger.info("DataFile uploaded, should automatically become the thumbnail:");

        File trees = new File("scripts/search/data/binary/trees.png");
        String treesAsBase64 = null;
        treesAsBase64 = ImageThumbConverter.generateImageThumbnailFromFileAsBase64(trees, ImageThumbConverter.DEFAULT_CARDIMAGE_SIZE);

        if (treesAsBase64 == null) {
            Logger.getLogger(SearchIT.class.getName()).log(Level.SEVERE, "Failed to generate a base64 thumbnail from the file trees.png");
        }

        Response search2 = UtilIT.search("id:dataset_" + datasetId + "_draft", apiToken);
        search2.prettyPrint();
        search2.then().assertThat()
                .body("data.items[0].name", CoreMatchers.equalTo("Darwin's Finches"))
                .statusCode(200);

        Response getThumbnail2 = UtilIT.getDatasetThumbnailMetadata(datasetId, apiToken);
        getThumbnail2.prettyPrint();
        getThumbnail2.then().assertThat()
                //                .body("data.datasetThumbnail", CoreMatchers.equalTo("randomFromDataFile" + dataFileId1))
                .body("data.datasetThumbnailBase64image", CoreMatchers.equalTo(treesAsBase64))
                .body("data.isUseGenericThumbnail", CoreMatchers.equalTo(false))
                // This dataFileId is null because of automatic thumbnail selection.
                .body("data.dataFileId", CoreMatchers.equalTo(dataFileId1.toString()))
                .body("data.datasetLogoPresent", CoreMatchers.equalTo(false))
                .statusCode(200);

        InputStream inputStream2creator = UtilIT.getInputStreamFromUnirest(thumbnailUrl, apiToken);
        assertNotNull(inputStream2creator);
        assertEquals(treesAsBase64, UtilIT.inputStreamToDataUrlSchemeBase64Png(inputStream2creator));

        InputStream inputStream2guest = UtilIT.getInputStreamFromUnirest(thumbnailUrl, noSpecialAcessApiToken);
        assertEquals(treesAsBase64, UtilIT.inputStreamToDataUrlSchemeBase64Png(inputStream2guest));

        String leadingStringToRemove = FileUtil.DATA_URI_SCHEME;
        System.out.println("before: " + treesAsBase64);
        String encodedImg = treesAsBase64.substring(leadingStringToRemove.length());
        System.out.println("after: " + encodedImg);
        byte[] decodedImg = null;
        try {

            decodedImg = Base64.getDecoder().decode(encodedImg.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException ex) {
        }

        Response getThumbnailImage2 = UtilIT.getDatasetThumbnail(datasetPersistentId, apiToken);
        getThumbnailImage2.prettyPrint();
        getThumbnailImage2.then().assertThat()
                //                .body(CoreMatchers.equalTo(decodedImg))
                .contentType("image/png")
                /**
                 * @todo Why can't we assert the content here? Why do we have to
                 * use Unirest instead? How do you download the bytes of the
                 * image using REST Assured?
                 */
                //                .content(CoreMatchers.equalTo(decodedImg))
                .statusCode(200);

        String pathToFile = "src/main/webapp/resources/images/dataverseproject.png";
        Response uploadSecondImage = UtilIT.uploadFileViaNative(datasetId.toString(), pathToFile, apiToken);
        uploadSecondImage.prettyPrint();
        uploadSecondImage.then().assertThat()
                .statusCode(200);

        Response getDatasetJson2 = UtilIT.nativeGetUsingPersistentId(datasetPersistentId, apiToken);
        //odd that [0] gets the second uploaded file... replace with a find for dataverseproject.png
        Long dataFileId2 = JsonPath.from(getDatasetJson2.getBody().asString()).getLong("data.latestVersion.files[0].dataFile.id");
        System.out.println("datafileId2: " + dataFileId2);
        getDatasetJson2.then().assertThat()
                .statusCode(200);

        File dataverseProjectLogo = new File(pathToFile);
        String dataverseProjectLogoAsBase64 = null;
        dataverseProjectLogoAsBase64 = ImageThumbConverter.generateImageThumbnailFromFileAsBase64(dataverseProjectLogo, ImageThumbConverter.DEFAULT_CARDIMAGE_SIZE);

        if (dataverseProjectLogoAsBase64 == null) {
            Logger.getLogger(SearchIT.class.getName()).log(Level.SEVERE, "Failed to generate a base64 thumbnail from the file dataverseproject.png");
        }

        Response switchToSecondDataFileThumbnail = UtilIT.useThumbnailFromDataFile(datasetPersistentId, dataFileId2, apiToken);
        switchToSecondDataFileThumbnail.prettyPrint();
        switchToSecondDataFileThumbnail.then().assertThat()
                .body("data.message", CoreMatchers.equalTo("Thumbnail set to " + dataverseProjectLogoAsBase64))
                .statusCode(200);

        logger.info("Second DataFile has been uploaded and switched to as the thumbnail:");
        Response getThumbnail3 = UtilIT.getDatasetThumbnailMetadata(datasetId, apiToken);
        getThumbnail3.prettyPrint();
        getThumbnail3.then().assertThat()
                //                .body("data.datasetThumbnail", CoreMatchers.equalTo("dataverseproject.png"))
                .body("data.datasetThumbnailBase64image", CoreMatchers.equalTo(dataverseProjectLogoAsBase64))
                .body("data.isUseGenericThumbnail", CoreMatchers.equalTo(false))
                .body("data.dataFileId", CoreMatchers.equalTo(dataFileId2.toString()))
                .body("data.datasetLogoPresent", CoreMatchers.equalTo(false))
                .statusCode(200);

        InputStream inputStream3creator = UtilIT.getInputStreamFromUnirest(thumbnailUrl, apiToken);
        assertEquals(dataverseProjectLogoAsBase64, UtilIT.inputStreamToDataUrlSchemeBase64Png(inputStream3creator));

        InputStream inputStream3guest = UtilIT.getInputStreamFromUnirest(thumbnailUrl, noSpecialAcessApiToken);
        assertEquals(dataverseProjectLogoAsBase64, UtilIT.inputStreamToDataUrlSchemeBase64Png(inputStream3guest));

        Response search3 = UtilIT.search("id:dataset_" + datasetId + "_draft", apiToken);
        search3.prettyPrint();
        search3.then().assertThat()
                .body("data.items[0].name", CoreMatchers.equalTo("Darwin's Finches"))
                .statusCode(200);

        Response thumbnailCandidates2 = UtilIT.showDatasetThumbnailCandidates(datasetPersistentId, apiToken);
        thumbnailCandidates2.prettyPrint();
        thumbnailCandidates2.then().assertThat()
                .body("data[0].base64image", CoreMatchers.equalTo(dataverseProjectLogoAsBase64))
                .body("data[0].dataFileId", CoreMatchers.equalTo(dataFileId2.intValue()))
                .body("data[1].base64image", CoreMatchers.equalTo(treesAsBase64))
                .body("data[1].dataFileId", CoreMatchers.equalTo(dataFileId1.intValue()))
                .statusCode(200);

        //Add Failing Test logo file too big
        //Size limit hardcoded in systemConfig.getUploadLogoSizeLimit
        String tooBigLogo = "src/test/resources/images/coffeeshop.png";
        Response overrideThumbnailFail = UtilIT.uploadDatasetLogo(datasetPersistentId, tooBigLogo, apiToken);

        overrideThumbnailFail.prettyPrint();
        overrideThumbnailFail.then().assertThat()
                .body("message", CoreMatchers.equalTo("File is larger than maximum size: 500000."))
                /**
                 * @todo We want this to expect 400 (BAD_REQUEST), not 403
                 * (FORBIDDEN).
                 */
                //                .statusCode(400);
                .statusCode(FORBIDDEN.getStatusCode());

        String datasetLogo = "src/main/webapp/resources/images/cc0.png";
        File datasetLogoFile = new File(datasetLogo);
        String datasetLogoAsBase64 = datasetLogoAsBase64 = ImageThumbConverter.generateImageThumbnailFromFileAsBase64(datasetLogoFile, ImageThumbConverter.DEFAULT_CARDIMAGE_SIZE);

        if (datasetLogoAsBase64 == null) {
            Logger.getLogger(SearchIT.class.getName()).log(Level.SEVERE, "Failed to generate a base64 thumbnail from the file dataverseproject.png");
        }

        Response overrideThumbnail = UtilIT.uploadDatasetLogo(datasetPersistentId, datasetLogo, apiToken);
        overrideThumbnail.prettyPrint();
        overrideThumbnail.then().assertThat()
                .body("data.message", CoreMatchers.equalTo("Thumbnail is now " + datasetLogoAsBase64))
                .statusCode(200);

        logger.info("Dataset logo has been uploaded and becomes the thumbnail:");
        Response getThumbnail4 = UtilIT.getDatasetThumbnailMetadata(datasetId, apiToken);
        getThumbnail4.prettyPrint();
        getThumbnail4.then().assertThat()
                //                .body("data.datasetThumbnail", CoreMatchers.equalTo(null))
                .body("data.isUseGenericThumbnail", CoreMatchers.equalTo(false))
                .body("data.datasetThumbnailBase64image", CoreMatchers.equalTo(datasetLogoAsBase64))
                .body("data.datasetLogoPresent", CoreMatchers.equalTo(false))
                .statusCode(200);

        InputStream inputStream4creator = UtilIT.getInputStreamFromUnirest(thumbnailUrl, apiToken);
        assertEquals(datasetLogoAsBase64, UtilIT.inputStreamToDataUrlSchemeBase64Png(inputStream4creator));

        InputStream inputStream4guest = UtilIT.getInputStreamFromUnirest(thumbnailUrl, noSpecialAcessApiToken);
        assertEquals(datasetLogoAsBase64, UtilIT.inputStreamToDataUrlSchemeBase64Png(inputStream4guest));

        Response search4 = UtilIT.search("id:dataset_" + datasetId + "_draft", apiToken);
        search4.prettyPrint();
        search4.then().assertThat()
                .body("data.items[0].name", CoreMatchers.equalTo("Darwin's Finches"))
                .statusCode(200);

        Response thumbnailCandidates3 = UtilIT.showDatasetThumbnailCandidates(datasetPersistentId, apiToken);
        thumbnailCandidates3.prettyPrint();
        logger.fine("datasetLogoAsBase64:          " + datasetLogoAsBase64);
        logger.fine("dataverseProjectLogoAsBase64: " + dataverseProjectLogoAsBase64);
        logger.fine("treesAsBase64:                " + treesAsBase64);
        thumbnailCandidates3.then().assertThat()
                .body("data[0].base64image", CoreMatchers.equalTo(datasetLogoAsBase64))
                .body("data[0].dataFileId", CoreMatchers.equalTo(null))
                .body("data[1].base64image", CoreMatchers.equalTo(dataverseProjectLogoAsBase64))
                .body("data[1].dataFileId", CoreMatchers.equalTo(dataFileId2.intValue()))
                .body("data[2].base64image", CoreMatchers.equalTo(treesAsBase64))
                .body("data[2].dataFileId", CoreMatchers.equalTo(dataFileId1.intValue()))
                .statusCode(200);

        Response deleteDatasetLogo = UtilIT.removeDatasetThumbnail(datasetPersistentId, apiToken);
        deleteDatasetLogo.prettyPrint();
        deleteDatasetLogo.then().assertThat()
                .body("data.message", CoreMatchers.equalTo("Dataset thumbnail removed."))
                .statusCode(200);

        logger.info("Deleting the dataset logo means that the thumbnail is not set. It should be the generic icon:");
        Response getThumbnail5 = UtilIT.getDatasetThumbnailMetadata(datasetId, apiToken);
        getThumbnail5.prettyPrint();
        getThumbnail5.then().assertThat()
                //                .body("data.datasetThumbnail", CoreMatchers.equalTo(null))
                .body("data.isUseGenericThumbnail", CoreMatchers.equalTo(true))
                .body("data.datasetLogoPresent", CoreMatchers.equalTo(false))
                .statusCode(200);

        InputStream inputStream5creator = UtilIT.getInputStreamFromUnirest(thumbnailUrl, apiToken);
        assertNull(inputStream5creator);

        InputStream inputStream5guest = UtilIT.getInputStreamFromUnirest(thumbnailUrl, noSpecialAcessApiToken);
        assertNull(inputStream5guest);

        Response search5 = UtilIT.search("id:dataset_" + datasetId + "_draft", apiToken);
        search5.prettyPrint();
        search5.then().assertThat()
                .body("data.items[0].name", CoreMatchers.equalTo("Darwin's Finches"))
                .body("data.items[0].thumbnailFilename", CoreMatchers.equalTo(null))
                .body("data.items[0].datasetThumbnailBase64image", CoreMatchers.equalTo(null))
                .statusCode(200);

        Response thumbnailCandidates4 = UtilIT.showDatasetThumbnailCandidates(datasetPersistentId, apiToken);
        thumbnailCandidates4.prettyPrint();
        thumbnailCandidates4.then().assertThat()
                .body("data[0].base64image", CoreMatchers.equalTo(dataverseProjectLogoAsBase64))
                .body("data[0].dataFileId", CoreMatchers.equalTo(dataFileId2.intValue()))
                .body("data[1].base64image", CoreMatchers.equalTo(treesAsBase64))
                .body("data[1].dataFileId", CoreMatchers.equalTo(dataFileId1.intValue()))
                .statusCode(200);

        Response switchtoFirstDataFileThumbnail = UtilIT.useThumbnailFromDataFile(datasetPersistentId, dataFileId1, apiToken);
        switchtoFirstDataFileThumbnail.prettyPrint();
        switchtoFirstDataFileThumbnail.then().assertThat()
                .body("data.message", CoreMatchers.equalTo("Thumbnail set to " + treesAsBase64))
                .statusCode(200);

        Response publishDataverse = UtilIT.publishDataverseViaSword(dataverseAlias, apiToken);
        publishDataverse.prettyPrint();
        publishDataverse.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response publishDataset = UtilIT.publishDatasetViaNativeApi(datasetId, "major", apiToken);
        publishDataset.prettyPrint();
        publishDataset.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response getThumbnailImageNoSpecialAccess99 = UtilIT.getDatasetThumbnail(datasetPersistentId, noSpecialAcessApiToken);
//        getThumbnailImageNoSpecialAccess99.prettyPrint();
        getThumbnailImageNoSpecialAccess99.then().assertThat()
                .contentType("image/png")
                .statusCode(OK.getStatusCode());

        InputStream inputStream99creator = UtilIT.getInputStreamFromUnirest(thumbnailUrl, apiToken);
        assertEquals(treesAsBase64, UtilIT.inputStreamToDataUrlSchemeBase64Png(inputStream99creator));

        InputStream inputStream99guest = UtilIT.getInputStreamFromUnirest(thumbnailUrl, noSpecialAcessApiToken);
        assertEquals(treesAsBase64, UtilIT.inputStreamToDataUrlSchemeBase64Png(inputStream99guest));

        Response searchResponse = UtilIT.search("id:dataset_" + datasetId, noSpecialAcessApiToken);
        searchResponse.prettyPrint();
        searchResponse.then().assertThat()
                .statusCode(OK.getStatusCode());

        Response removeSearchApiNonPublicAllowed = UtilIT.deleteSetting(SettingsServiceBean.Key.SearchApiNonPublicAllowed);
        removeSearchApiNonPublicAllowed.then().assertThat()
                .statusCode(200);

        /**
         * @todo What happens when you delete a dataset? Does the thumbnail
         * created based on the logo get deleted too? Should it?
         */
    }

    @After
    public void tearDownDataverse() {
        File treesThumb = new File("scripts/search/data/binary/trees.png.thumb48");
        treesThumb.delete();
        File cc0Thumb = new File("src/main/webapp/resources/images/cc0.png.thumb48");
        cc0Thumb.delete();
        File dataverseprojectThumb = new File("src/main/webapp/resources/images/dataverseproject.png.thumb48");
        dataverseprojectThumb.delete();
    }

    @AfterClass
    public static void cleanup() {

        Response enableNonPublicSearch = UtilIT.enableSetting(SettingsServiceBean.Key.SearchApiNonPublicAllowed);
        assertEquals(200, enableNonPublicSearch.getStatusCode());

        Response deleteSearchApiNonPublicAllowed = UtilIT.deleteSetting(SettingsServiceBean.Key.SearchApiNonPublicAllowed);
        deleteSearchApiNonPublicAllowed.then().assertThat()
                .statusCode(200);

        Response getSearchApiNonPublicAllowed = UtilIT.getSetting(SettingsServiceBean.Key.SearchApiNonPublicAllowed);
//        getSearchApiNonPublicAllowed.prettyPrint();
        getSearchApiNonPublicAllowed.then().assertThat()
                .body("message", CoreMatchers.equalTo("Setting " + SettingsServiceBean.Key.SearchApiNonPublicAllowed + " not found"))
                .statusCode(404);
    }

}

redpajama_set_name: RedPajamaGithub


text:
Tome of Foes
Tome of Foes ( )
Author: Wizards RPG Team,
Series title: Dungeons & Dragons Ser.
Publisher: Wizards of the Coast
Imprint: Wizards of the Coast
Discover the truth about the great conflicts of the D&D multiverse in this supplement for the world's greatest roleplaying game. This tome is built on the writings of the renowned wizard from the world of Greyhawk, gathered over a lifetime of research and scholarship. In his travels to other realms and other planes of existence, he has made many friends, and has risked his life an equal number of times, to amass the knowledge contained herein. In addition to...
Discover the truth about the great conflicts of the D&D multiverse in this supplement for the world's greatest roleplaying game.
This tome is built on the writings of the renowned wizard from the world of Greyhawk, gathered over a lifetime of research and scholarship. In his travels to other realms and other planes of existence, he has made many friends, and has risked his life an equal number of times, to amass the knowledge contained herein. In addition to Mordenkainen's musings on the endless wars of the multiverse, the book contains game statistics for dozens of monsters: new demons and devils, several varieties of elves and duergar, and a vast array of other creatures from throughout the planes of existence.
Detailed Subjects: Fiction / Fantasy / Epic
Physical Dimensions (W X L X H): 8.57 x 11.1 x 0.71 Inches
Wizards RPG Team (Author)
Wizards of the Coast game company was started in the home of Peter Adkison in 1990. It grew to be a leader in the hobby gaming business and a part of the global Hasbro family. The purpose Wizards of the Coast is to provide great entertainment for the hobby gaming community through games, novels, comics, TV series, apparel and more.
Tales from the Ya...
Wizards RPG Team
Dungeons & Dragon...
Sword Coast Adven...
Nanaville
Quindlen, Anna

redpajama_set_name: RedPajamaCommonCrawl


How audio and video are merged?
Have you ever been curious about how the audio and the video get merged in a recording? Our technical experts can abridge you with the most authentic explanation.
When a singer sings a song, his video and audio both are recorded. As these are the two different inputs of recording one is video and other is audio, it is likely that there may be some time difference between the two and if not corrected or synchronized the lip movement may not match with the song.
What is the method or software by which these two are merged with each other and well synchronized? Is it done by the electronic circuitry itself or some application in the system?
What you call as the Audio-Video merge is generally termed as Audio-to-video synchronization, lip sync or audio-video sync. It refers to a relative timing of an audio or sound and its related video or image in parts during its creation, its post-production mix, during its transmission, its reception and while it is play-back processing. It is generally referred as a time when both the sound and the video are having a time-related cause and effect relationship.
The AV-sync can create an issue in broadcasting a program on television, while video conferencing, or even in a film.
The Digital or analog audio video streaming or those video files usually contain a type of explicit AV-sync timing, either in the shape of an interleaved video and audio data or it can be done as an explicit relative time-stamping of data. The processing of a particular data has to follow the relative data timing by either taking action like stretching between or creating an interpolation of the data it has received. If this processing of data does not follow the time, then the AV-sync error takes place. It will then increase in whenever data it loses because of the transmission errors or due to the missed timed processing.


text:
<?php

namespace Tabbi\Silex;

/**
 * Test file format and file name
 *
 * @author Igor Wiedler <igor@wiedler.ch>
 * @author Jérôme Macias <jerome.macias@gmail.com>
 * @author Tomasz Łopusiewicz <tomasz.pobieralnia@gmail.com>
 */
class GetFileFormatTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @dataProvider provideFilenamesForFormat
     */
    public function testGetFileFormat($filename)
    {
        $driver = new ChainConfigDriver(array(
            new PhpConfigDriver(),
            new YamlConfigDriver(),
            new JsonConfigDriver(),
            new TomlConfigDriver(),
        ));

        $this->assertTrue($driver->supports($filename));
    }

    /**
     * @dataProvider provideFilenamesForFormat
     */
    public function testGetFileNameFormat($filename)
    {
        $driver = new ChainConfigDriver(array(
            new PhpConfigDriver(),
            new YamlConfigDriver(),
            new JsonConfigDriver(),
            new TomlConfigDriver(),
        ));

         $this->assertEquals('config', $driver->getFileName($filename));
    }

    public function provideFilenamesForFormat()
    {
        return array(
            'yaml'      => array(__DIR__."/Fixtures/config.yaml"),
            'yml'       => array(__DIR__."/Fixtures/config.yml"),
            'yaml.dist' => array(__DIR__."/Fixtures/config.yaml.dist"),
            'json'      => array(__DIR__."/Fixtures/config.json"),
            'json.dist' => array(__DIR__."/Fixtures/config.json.dist"),
            'php'       => array(__DIR__."/Fixtures/config.php"),
            'php.dist'  => array(__DIR__."/Fixtures/config.php.dist"),
            'toml'      => array(__DIR__."/Fixtures/config.toml"),
            'toml.dist' => array(__DIR__."/Fixtures/config.toml.dist"),
        );
    }
}


Making a move to a new job—whether managing a good-sized department or a large urban district—is taking a risk. How can you really be sure the new place is the right fit for your goals and that you bring the qualities the job needs?
Applicants are never left adrift during the search process. Executive Search Services' experienced consultants are looking out for the best interests of the hiring district, and that means creating a match that serves both the district and the potential candidate. Our consultants will do everything they can to ensure that your goals and dreams align with the district that may hire you.
Step into your new leadership position with confidence that you've found the right place.
ESS uses an online application process that helps applicants put their best foot forward. With Frontline Applicant Tracking, you can upload resumes, educator certifications, transcripts, and other materials you want to share with the board. At each step, your information and uploaded documents are saved so you can easily access them for future applications.
Check out our current searches to find your perfect fit and to begin your application.
Use the following links to learn more about certification requirements, retirement, professional education associations, and local education issues.


We would love to have the opportunity to share God's love with your little one on Sunday mornings and Wednesday evenings.
Kids can learn more about God's love in Kids ROCK Junior on Sundays and Wired Worshippers on Wednesday evenings.
Small groups and worship on Sunday mornings and Wednesday evenings allow time for kids to learn about Jesus and grow in their faith.
We know it can be tough raising children and we would love to help. Resources are available to assist you in the journey. We are here for you.
Resources and information are available here.


The short-term direction in USD pairs will depend on euro zone, UK, and US PMI data. But the key focus today is the release of the FOMC meeting minutes. The central bank is expected to express optimism over the economic growth and inflation . But the market expectations may be overheated as investors were lately pricing in a more aggressive tightening by the Fed this year. So there is a risk of disappointment, should the tone of the minutes come less hawkish than expected.


text:
#pragma once

#include <channelitem.h>

class RChannelBufferPrefetchInfo;
enum TransformType;

/* this is a stub object that is e.g. passed to parsers and marshalers
   when they are initialized. For example, DryadVertexProgramBase
   inherits from this interface and is set as the context for all
   parsers and marshalers in that vertex so that they can access
   configuration parameters, etc. */
class RChannelContext : public IDrRefCounter
{
public:
    virtual ~RChannelContext();
};

typedef DrRef<RChannelContext> RChannelContextRef;

class RChannelInterruptHandler
{
public:
    /* When the byte-oriented layer from which a channel is reading
       signals an error condition by delivering a Restart or Abort
       buffer, the application may wish to learn this immediately
       rather than waiting for the error item to be delivered (for
       example, the application may be blocking reads from the channel
       indefinitely, yet still want timely error notifications.) In
       this case, the application can register an interrupt handler
       which will be called back when an error occurs, or during Drain
       if no error occurs.

       interruptItem is the terminatino item which will eventually be
       delivered. The callee of ProcessInterrupt should call IncRef on
       interruptItem if it wants to store a reference to the item.
     */
    virtual void ProcessInterrupt(RChannelItem* interruptItem) = 0;
};

class RChannelItemArrayReaderHandler
{
public:
    RChannelItemArrayReaderHandler();
    virtual ~RChannelItemArrayReaderHandler();

    /* This sets the maximum number of items which will be delivered
       via the ProcessItemArray callback. The default value is 1. */
    void SetMaximumArraySize(UInt32 maximumArraySize);
    UInt32 GetMaximumArraySize();

    /* When an asynchronous item is ready to be delivered on a channel
       this method is called on the handler object passed to the
       associated call to RChannelReader::SupplyHandler().

       If deliveredArray is empty and the asynchronous read was not
       cancelled, then the channel has completed, i.e. a termination
       item has been delivered to some other synchronous or
       asynchronous read method. If there are multiple outstanding
       reads the order of delivery is undefined so an empty array may
       appear on one handler before the termination item has actually
       been delivered.

       If an asynchronous read is cancelled ProcessItem is called
       before the Cancel call completes. If the array is empty in this
       case it is impossible to determine from the ProcessItem
       callback whether it occurred because of successful cancellation
       or because a termination item has been delivered to the
       application.
     */
    virtual void ProcessItemArray(RChannelItemArray* deliveredArray) = 0;

    /* there are two types of asynchronous handler: queued and
       immediate. If the handler is queued, then it is called on a
       worker thread which is specifically assigned for processing
       items, and the application should perform as much computation
       as necessary on the calling thread before returning.

       If the handler is immediate then it may be called on a variety
       of different threads, including I/O processing threads, and the
       application should return as soon as possible. Immediate
       handlers are suitable, for example, for waking up a synchronous
       thread which has been blocking on a read, or for queueing a
       work item to an application's private thread pool if the
       standard thread pool is for some reason inappropriate.

       In general rather than implementing the ImmediateDispatch
       method the application should just inherit from
       RChannelItemReaderHandlerImmediate or
       RChannelItemReaderHandlerQueued.
    */
    virtual bool ImmediateDispatch() = 0;

private:
    UInt32    m_maximumArraySize;
};

/* the base class for an immediate item array handler, see
   RChannelItemArrayReaderHandler::ImmediateDispatch above. */
class RChannelItemArrayReaderHandlerQueued :
    public RChannelItemArrayReaderHandler
{
public:
    bool ImmediateDispatch();
};

/* the base class for a queued item array handler, see
   RChannelItemArrayReaderHandler::ImmediateDispatch above. */
class RChannelItemArrayReaderHandlerImmediate :
    public RChannelItemArrayReaderHandler
{
public:
    bool ImmediateDispatch();
};

class RChannelItemReaderHandler :
    public RChannelItemArrayReaderHandler
{
public:
    virtual ~RChannelItemReaderHandler();

    /* When an asynchronous item is ready to be delivered on a channel
       this method is called on the handler object passed to the
       associated call to RChannelReader::SupplyHandler().

       If deliveredItem is NULL and the asynchronous read was not
       cancelled, then the channel has completed, i.e. a termination
       item has been delivered to some synchronous or asynchronous
       read method. If there are multiple outstanding reads the order
       of delivery is undefined so a NULL may appear on one handler
       before the termination item has actually been delivered.

       If an asynchronous read is cancelled ProcessItem is called with
       NULL before the Cancel call completes. In this case it is
       impossible to determine from the ProcessItem callback whether
       it occurred because of successful cancellation or because a
       termination item has been delivered to the application.

       If deliveredItem is non-NULL then the callee now owns a
       reference to deliveredItem.
     */
    virtual void ProcessItem(RChannelItem* deliveredItem) = 0;

    /* there are two types of asynchronous handler: queued and
       immediate. If the handler is queued, then it is called on a
       worker thread which is specifically assigned for processing
       items, and the application should perform as much computation
       as necessary on the calling thread before returning.

       If the handler is immediate then it may be called on a variety
       of different threads, including I/O processing threads, and the
       application should return as soon as possible. Immediate
       handlers are suitable, for example, for waking up a synchronous
       thread which has been blocking on a read, or for queueing a
       work item to an application's private thread pool if the
       standard thread pool is for some reason inappropriate.

       In general rather than implementing the ImmediateDispatch
       method the application should just inherit from
       RChannelItemReaderHandlerImmediate or
       RChannelItemReaderHandlerQueued.
    */
    virtual bool ImmediateDispatch() = 0;

    /* implementation of RChannelItemArrayReaderHandler interface */
    void ProcessItemArray(RChannelItemArray* deliveredArray);
};

/* the base class for an immediate item handler, see
   RChannelItemReaderHandler::ImmediateDispatch above. */
class RChannelItemReaderHandlerQueued : public RChannelItemReaderHandler
{
public:
    bool ImmediateDispatch();
};

/* the base class for a queued item handler, see
   RChannelItemReaderHandler::ImmediateDispatch above. */
class RChannelItemReaderHandlerImmediate : public RChannelItemReaderHandler
{
public:
    bool ImmediateDispatch();
};

class SyncItemReaderBase
{
public:
    virtual DrError ReadItemSync(RChannelItemRef* item /* out */) = 0;
};

class RChannelReader : public SyncItemReaderBase
{
public:
    virtual ~RChannelReader();

    /* a client must call Start to cause the channel to start
       generating items for the first time, or after a Drain has
       completed before the channel is restarted.

       prefetchCookie is passed to the byte-oriented buffer layer and
       should be NULL for now.
    */
    virtual void Start(RChannelBufferPrefetchInfo* prefetchCookie) = 0;

    /* SupplyHandler passes a handler which will be "returned" via a
       matching call to handler->ProcessItemArray. Multiple handlers
       may be outstanding at a given time. The channel blocks when
       there are no handlers available, so this is the primary flow
       control mechanism to allow the reader to exert back-pressure on
       a channel.

       If the channel has not been started or has delivered a
       termination item to the application since the last call to
       Start, handler->ProcessItemArray will be called with an empty
       array on the calling thread before SupplyHandler returns.

       If there is an item waiting to be delivered and handler is an
       RChannelItemReaderHandlerImmediate then handler will be called
       back with the items on the calling thread before SupplyHandler
       returns.

       If handler is an RChannelItemReaderHandlerQueued it will never
       be called back on the calling thread. If there are items
       waiting to be delivered, a processing request will be queued
       for the item with handler, otherwise handler will be queued
       waiting for the next item to be ready.

       If thread B submits an RChannelItemReaderHandlerImmediate with
       a call to SupplyHandler that is overlapped with thread A's call
       to SupplyHandler, B's immediate handler may be called on A's
       calling thread before A's call to SupplyHandler returns.

       After a handler has been submitted to SupplyHandler with a
       given value of cancelCookie, that handler is guaranteed to be
       returned before any matching call to Cancel with the same value
       of cancelCookie returns. If there is no item available at the
       time the handler is cancelled it will be called with an empty
       array. cancelCookie may take any value, including NULL, however
       it is safest to use NULL or the address of an object owned by
       the caller. The cancellation mechanism is used internally by
       the synchronous FetchNextItem call which uses an allocated heap
       address as its cancelCookie. Using the heap address of an
       object which has not been freed before the call to Cancel will
       avoid any danger of a cookie collision.

       For any item A which has already been returned via an async
       handler or call to FetchNextItem when SupplyHandler is called
       it is guaranteed that A's sequence number is less than or equal
       to the sequence number of the item eventually returned on
       handler. Beyond this constraint, if multiple handlers are
       outstanding at once, or while calls to FetchNextItem are in
       progress, the order of delivered items is undefined.
     */
    virtual void SupplyHandler(RChannelItemArrayReaderHandler* handler,
                               void* cancelCookie) = 0;

    /* any handler passed to SupplyHandler with value cancelCookie is
       guaranteed to be returned before a call to Cancel completes. */
    virtual void Cancel(void* cancelCookie) = 0;

    /* FetchNextItemArray blocks waiting until an item is available, a
       termination item is delivered on another thread, or the timeOut
       interval has elapsed (timeOut can be DrTimeInterval_Infinite in
       which case FetchNextItem will block indefinitely).

       If the timeout expires FetchNextItemArray returns false and
       *pItemArray is an empty array. Otherwise FetchNextItem returns
       true and the any returned items are stored in
       *pItemArray. *pItemArray may be empty even if
       FetchNextItemArray returns true: this will happen if Start has
       not been called or a termination item has already been
       delivered on the channel since the last call to Start. At most
       maxArraySize items will be delivered in *pItemArray, however
       fewer may be delivered.
     */
    virtual bool FetchNextItemArray(UInt32 maxArraySize,
                                    RChannelItemArrayRef* pItemArray,
                                    DrTimeInterval timeOut) = 0;

    /* FetchNextItem blocks waiting until an item is available, a
       termination item is delivered on another thread, or the timeOut
       interval has elapsed (timeOut can be DrTimeInterval_Infinite in
       which case FetchNextItem will block indefinitely).

       If the timeout expires FetchNextItem returns false and *outItem
       is NULL. Otherwise FetchNextItem returns true and the returned
       item is stored in *outItem. *outItem may be NULL even if
       FetchNextItem returns true: this will happen if Start has not
       been called or a termination item has already been delivered on
       the channel since the last call to Start.
     */
    bool FetchNextItem(RChannelItemRef* pOutItem,
                       DrTimeInterval timeOut);
    DrError ReadItemSync(RChannelItemRef* pOutItem /* out */);

    /* Instruct the channel to stop reading items and prepare for
       Drain. The interruptItem must be of type RChannelItem_Abort,
       RChannelItem_Restart, RChannelItem_EndOfStream or
       RChannelItem_ParseError. If the channel is an in-process FIFO
       or a pipe which has not broken, the interruptItem will be
       delivered to the remote end and the remote writer will
       therefore be made aware of the channel close request. Interrupt
       may be called multiple times after a channel has been Started
       and before it has been Drained. The first call will have its
       interruptItem delivered; subsequent interruptItems will be
       discarded. If multiple calls to Interrupt are overlapped, the
       call whose interruptItem gets delivered is undefined. The
       caller's reference to interruptItem is not modified by this
       call.
     */
    virtual void Interrupt(RChannelItem* interruptItem) = 0;

    /* Instruct the channel to return all outstanding handlers via
       their handler->ProcessItem callbacks in preparation for either
       closing or restarting the channel. Once the Drain method
       returns all outstanding handler callbacks will have completed
       and all waiting calls to FetchNextItem will have been unblocked
       (though of course they may not have returned to the calling
       thread). For obvious reasons, Drain may not be called from a
       handler's ProcessItem callback.

       If the channel is an in-process FIFO or a pipe which has not
       broken, and Interrupt has not previously been called, Drain
       will send an appropriate termination item to the write end. If
       the writer has delivered a termination item to the reader
       implementation, an item of the same type will be returned to
       the writer. Otherwise an item of type RChannel_Abort will be
       returned to the writer. If the RChannelReader client has not
       read a ternmination item, then the item delivered by a call to
       Drain which is not preceded by Interrupt is undefined, since
       the implementation may have received a termination item which
       has not yet been forwarded to the client.
     */
    virtual void Drain() = 0;

    /* If the writer has sent a termination item down the channel, it
       is returned in pWriterDrainItem. If the reader has sent a
       termination item to the writer (via Interrupt or drain) it is
       returned in pReaderDrainItem. These termination items are set
       to NULL when a channel is restarted. The returned items are
       undefined if this call overlaps with a call to Start or Drain,
       and it is illegal to call GetTerminationItem after Close has
       been called. */
    virtual void GetTerminationItems(RChannelItemRef* pWriterDrainItem,
                                     RChannelItemRef* pReaderDrainItem) = 0;

    /* After a call to Drain, this returns a status code and
       optionally error metadata corresponding to the final status of
       the channel. If the writer sent an error item,
       GetTerminationStatus returns the error associated with that
       item. Otherwise if the reader sent an Interrupt with an
       EndOfStream item or called Drain after receiving an EndOfStream
       item from the writer, GetTerminationStatus will return
       DrError_EndOfStream (signalling clean termination). Otherwise
       GetTerminationStatus returns DryadError_ProcessingInterrupted
       which signifies that there was no error reported on the
       channel, but the reader requested early termination. */
    DrError GetTerminationStatus(DryadMetaDataRef* pErrorData);

    /* Close may only be called if Start has never been called, or if
       Drain has completed since the last call to Start. Close must be
       called before the RChannelReader is destroyed. After Close has
       been called no other methods may be called on RChannelReader.
    */
    virtual void Close() = 0;

    /* Get the total length in bytes of the channel. This is known
       only after the channel has been opened. */
    virtual bool GetTotalLength(UInt64* pLen) = 0;

    /* Get the total expected length in bytes of the channel. This may
       be known even before the channel is opened. If
       GetExpectedLength returns false, *pLen is undefined. */
    virtual bool GetExpectedLength(UInt64* pLen) = 0;
    virtual void SetExpectedLength(UInt64 expectedLength) = 0;

    /* Get the URI of the channel. */
    virtual const char* GetURI() = 0;

    void SetTransformType(TransformType t) { m_transform = t; }
    TransformType GetTransformType() { return m_transform; }

private:
     TransformType m_transform;
};

class RChannelItemArrayWriterHandler
{
public:
    virtual ~RChannelItemArrayWriterHandler();

    /* this interface is called whenever an async write (started by
       RChannelWriter::WriteItemList) completes. If WriteItemList was
       called with the flush flag set, this handler will not be
       returned until the underlying channel has reported that the
       write has completed. Otherwise this handler may be called
       before the item has been written to the channel.

       Normally status is RChannelItem_Data, however if the underlying
       channel implementation has requested a restart or abort, status
       will be RChannelItem_Restart or RChannelItem_Abort
       respectively. If WriteItem was called before the channel was
       started, or after a termination item had been written, then
       status will be RChannelItem_EndOfStream. If status is not
       RChannelItem_Data the item may or may not have actually been
       written to the output, regardless of whether a flush was
       requested (if status is RChannelItem_EndOfStream the item has
       definitely not been written to the output).

       If the item marshaler encountered any errors the error
       descriptions will be returned in failureArray. This is an array
       of items: each element is non-NULL if and only if the
       corresponding item in the original list had a marshal error. If
       there were no marshaling errors, failureArray will be NULL.
    */
    virtual void ProcessWriteArrayCompleted(RChannelItemType status,
                                            RChannelItemArray*
                                            failureArray) = 0;
};

class RChannelItemWriterHandler :
    public RChannelItemArrayWriterHandler
{
public:
    virtual ~RChannelItemWriterHandler();

    /* this interface is called whenever an async write (started by
       RChannelWriter::WriteItem) completes. If WriteItem was called
       with the flush flag set, this handler will not be returned
       until the underlying channel has reported that the write has
       completed. Otherwise this handler may be called before the item
       has been written to the channel.

       Normally status is RChannelItem_Data, however if the underlying
       channel implementation has requested a restart or abort, status
       will be RChannelItem_Restart or RChannelItem_Abort
       respectively. If WriteItem was called before the channel was
       started, or after a termination item had been written, then
       status will be RChannelItem_EndOfStream. If status is not
       RChannelItem_Data the item may or may not have actually been
       written to the output, regardless of whether a flush was
       requested (if status is RChannelItem_EndOfStream the item has
       definitely not been written to the output).

       If the item marshaler encountered an error the error
       description will be returned in marshalFailureItem. The callee
       does not own a reference to marshalFailureItem.
    */
    virtual void ProcessWriteCompleted(RChannelItemType status,
                                       RChannelItem* marshalFailureItem) = 0;

    /* implementation of RChannelItemArrayWriterHandler interface */
    void ProcessWriteArrayCompleted(RChannelItemType status,
                                    RChannelItemArray* failureArray);
};

class SyncItemWriterBase
{
public:
    /* A client should call WriteMapOutputItem or
       WriteMapOutputItemConsumingReference whenever it wants to send
       an item to the output channel. The latter consumes a reference
       to item, the former does not. */
    virtual void WriteItemSyncConsumingReference(RChannelItemRef& item) = 0;
    void WriteItemSyncConsumingFreeReference(RChannelItem* item);
    void WriteItemSync(RChannelItem* item);
    virtual DrError GetWriterStatus() = 0;
};

/*
  The RChannelWriter is the primary mechanism for writing
  application-specific structured items to an underlying byte-oriented
  channel.

  The application first calls Start, then sends a series of items,
  primarily of type RChannelItem_Data, though markers may be
  interspersed, followed by a termination item of type
  RChannelItem_Restart, RChannelItem_Abort or
  RChannelItem_EndOfStream. In the case of a pipe which has not
  broken, the termination item will be sent to the remote end so that
  the consuming process learns the reason for the pipe closure.

  After sending a termination item no further items will be sent on
  the channel until a call to Drain has completed. After this point
  the channel may call Start again in the case of a restart, and start
  sending items again.

  Each item is marshaled into the byte-stream using an
  application-specific marshaler object which must co-operate with the
  application so that bare RChannelItem objects can be cast by it into
  objects containing meaningful data.
 */
class RChannelWriter : public SyncItemWriterBase
{
public:
    virtual ~RChannelWriter();

    /* a client must call Start before writing items to the channel
       the first time, or after a Drain has completed before writing
       to a restarted channel.
    */
    virtual void Start() = 0;

    /* WriteItem queues item for async write to the channel.
       handler->ProcessWriteCompleted will be called when the async
       write "completes."

       If flushAfter is false the handler may be returned before the
       item has actually been written on the underlying channel. If
       flushAfter is true the handler will not be returned until the
       underlying channel has reported that the item has been
       written. Setting flushAfter potentially causes the underlying
       channel to write a partial buffer and should be used sparingly
       where performance is important.

       WriteItem transfers the caller's reference to item to the
       channel and it is guaranteed that handler will be called before
       the next call to Drain completes. If Start has not yet been
       called or a termination item has been queued since the last
       call to Start, handler->ProcessWriteCompleted will be called
       with status RChannelItem_EndOfStream on the caller's stack
       before WriteItem returns.

       Flow control is exercised by having the channel refrain from
       calling handler->ProcessWriteCompleted if the underlying
       stream has blocked. Therefore the application should limit the
       total number of outstanding calls to WriteItem in flight whose
       handlers have not yet been returned. Async items are serialized
       to a queue and marshaled on a worker thread, and handler is
       returned after this marshaling completes, so in the common case
       where the underlying channel has not blocked, the application
       should allow enough outstanding handlers to account for this
       delay in order to avoid "bubbles" in the processing pipeline.

       Once a call to WriteItem passing item A has completed, then any
       items which are subsequently submitted to the channel are
       guaranteed to appear after A. Beyond this constraint, if calls
       to WriteItem and/or WriteItemSync are overlapped the order of
       serialization to the channel is undefined.
    */
    virtual void WriteItemArray(RChannelItemArrayRef& itemArray,
                                bool flushAfter,
                                RChannelItemArrayWriterHandler* handler) = 0;
    void WriteItem(RChannelItem* item,
                   bool flushAfter,
                   RChannelItemArrayWriterHandler* handler);

    /* WriteItemArraySync submits item to be written to the channel and
       may block indefinitely if the underlying channel has blocked.

       If flush is false, WriteItemArraySync may return before the array
       has actually been sent to the underlying channel. If flush is
       true WriteItemListSync will not return until the underlying
       channel reports that item has been written. Setting flush
       potentially causes the underlying channel to write a partial
       buffer and should be used sparingly where efficiency is
       crucial.

       If the marshaler encounters an error when marshaling any item
       in the list, and pFailureArray is non-NULL, then pFailureArray
       will be filled in with an array of the same size as the
       original itemList. This array will contain non-NULL elements
       corresponding to any item in itemList which had a marshal
       error. If pFailureArray is non-NULL and there are no marshaling
       errors, *pFailureArray=NULL on return.

       WriteItemListSync always consunes the caller's reference to
       each item in the list and leaves itemList empty. If Start has
       not yet been called or a termination item has been queued since
       the last call to Start WriteItemListSync returns
       RChannelItem_EndOfStream, no item is written to the channel,
       and *pFailureArray is guaranteed to be NULL if pFailureArray is
       non-NULL. Otherwise, normally status is RChannelItem_Data,
       however if the underlying channel implementation has requested
       a restart or abort, status will be RChannelItem_Restart or
       RChannelItem_Abort respectively. If status is
       RChannelItem_Restart or RChannelItem_Abort the item in the list
       may or may not have actually been written to the output,
       regardless of whether a flush was requested.

       Once a call to WriteItemListSync passing item A has completed,
       then any items which are subsequently submitted to the channel
       are guaranteed to appear after A. Beyond this constraint, if
       calls to WriteItem and/or WriteItemSync are overlapped the
       order of serialization to the channel is undefined.
    */
    virtual RChannelItemType
        WriteItemArraySync(RChannelItemArrayRef& itemArray,
                           bool flush,
                           RChannelItemArrayRef* pFailureArray) = 0;

    /* WriteItemSync submits item to be written to the channel and may
       block indefinitely if the underlying channel has blocked.

       If flush is false, WriteItemSync may return before item has
       actually been sent to the underlying channel. If flush is true
       WriteItemSync will not return until the underlying channel
       reports that item has been written. Setting flush potentially
       causes the underlying channel to write a partial buffer and
       should be used sparingly where efficiency is crucial.

       If the marshaler encounters an error when marshaling item and
       pMarshalFailureItem is non-NULL, *pMarshalFailureItem will
       contain an item describing that error. In this case item has
       not been marshaled to the channel, however *pMarshalFailureItem
       has been. If there is no marshaling error and
       pMarshalFailureItem is non-NULL, *pMarshalFailureItem is NULL.

       WriteItemSync does not consume the caller's reference to
       item. If Start has not yet been called or a termination item
       has been queued since the last call to Start WriteItemSync
       returns RChannelItem_EndOfStream, item is not written to the
       channel, and *pMarshalFailureItem is guaranteed to be NULL if
       pMarshalFailureItem is non-NULL. Otherwise, normally status is
       RChannelItem_Data, however if the underlying channel
       implementation has requested a restart or abort, status will be
       RChannelItem_Restart or RChannelItem_Abort respectively. If
       status is RChannelItem_Restart or RChannelItem_Abort the item
       may or may not have actually been written to the output,
       regardless of whether a flush was requested.

       Once a call to WriteItemSync passing item A has completed, then
       any items which are subsequently submitted to the channel are
       guaranteed to appear after A. Beyond this constraint, if calls
       to WriteItem and/or WriteItemSync are overlapped the order of
       serialization to the channel is undefined.
    */
    RChannelItemType
        WriteItemSync(RChannelItem* item,
                      bool flush,
                      RChannelItemRef* pMarshalFailureItem);
    void WriteItemSyncConsumingReference(RChannelItemRef& item);

    /* Drain may not be called until after a termination item has been
       written to the channel using a call to WriteItemListSync,
       WriteItemSync, WriteItemList or WriteItem which has
       return. Drain will not return until the underlying channel has
       drained and all outstanding async handlers submitted to
       WriteItem or WriteItemList have been returned. At this point
       any calls to WriteItemSync or WriteItemListSync will be
       unblocked, though of course they may not have returned to the
       caller.

       If the application does not wish to block waiting for Drain it
       should wait until the handler submitted with the termination
       item has returned (or use a blocking call to WriteItemSync or
       WriteItemListSync). This handler will not be returned until the
       underlying channel has drained, and it is always the last
       handler to be returned, so Drain will not block after it has
       been returned.

       The call to Drain will block waiting for the "remote end" of
       the channel to signal that the channel has been shut down. In
       the case of a file or stream this happens immediately. In the
       case of a pipe or FIFO this happens only when the reader end
       calls Interrupt or Drain, and the item sent to the reader's
       Interrupt command is delivered by the writer's Drain and stored
       in *pRemoteStatus if pRemoteStatus is non-NULL. The item will
       be type RChannelItem_Abort, RChannelItem_Restart,
       RChannelItem_ParseError or RChannelItem_EndOfStream. The
       writer's call to Drain will block for at most a time interval
       of timeOut before returning. If the timeout period expires
       before the remote end's drain item is received and
       pRemoteStatus is non-NULL, *pRemoteStatus will be set to NULL.
    */
    virtual void Drain(DrTimeInterval timeOut,
                       RChannelItemRef* pRemoteStatus) = 0;

    /* (*pWriterDrainItem) is set to the termination item written to
       the channel, or NULL if no termination item has been written
       since the most recent call to Start.  *pReaderDrainItem is set
       to the remote status item returned by the most recent call to
       Drain, or NULL if Drain has not been called since the last call
       to Start. The return values are undefined if this call overlaps
       with a call to Start or Drain, and it is illegal to call
       GetTerminationItems after Close has been called.
    */
    virtual void GetTerminationItems(RChannelItemRef* pWriterDrainItem,
                                     RChannelItemRef* pReaderDrainItem) = 0;

    /* This returns an error corresponding to the most recent
       termination item written to the channel. It is illegal to call
       GetTerminationStatus before sending a termination item. */
    DrError GetTerminationStatus(DryadMetaDataRef* pErrorData);

    DrError GetWriterStatus();

    /* Close may not be called unless Start has never been called or
       Drain has completed since the last call to Start. After Close
       is called the channel may not be restarted. */
    virtual void Close() = 0;

    /* Get/set a hint about the total length the channel is expected
       to be. Some channel implementations can use this to improve
       write performance and decrease disk fragmentation. A value of 0
       (the default) means that the size is unknown. */
    virtual UInt64 GetInitialSizeHint() = 0;
    virtual void SetInitialSizeHint(UInt64 hint) = 0;

    /* Get the URI of the channel. */
    virtual const char* GetURI() = 0;

    void SetTransformType(TransformType t) { m_transform = t; }
    TransformType GetTransformType() { return m_transform; }

private:
     TransformType m_transform;

};


text:
A Place For Everything, And Everything In Its Place
Presented by California State University, Fullerton at Begovich Gallery, Cal State Fullerton, Fullerton CA
The Begovich Gallery presents "A Place for Everything, And Everything in its Place," an exhibition featuring nearly 50 years of works of art collected by the University.
EXHIBITION DATES September 7 – February 21, 2020 The Begovich Gallery presents A Place for Everything, And Everything in its Place, an exhibition featuring nearly 50 years of works of art collected ...
Jan, 21, 2020 at 12:00 pm - 04:00 pm (Tue) Jan, 22, 2020 at 12:00 pm - 04:00 pm (Wed) Jan, 23, 2020 at 12:00 pm - 04:00 pm (Thu) Jan, 25, 2020 at 12:00 pm - 04:00 pm (Sat) Jan, 27, 2020 at 12:00 pm - 04:00 pm (Mon) Jan, 28, 2020 at 12:00 pm - 04:00 pm (Tue) Jan, 29, 2020 at 12:00 pm - 04:00 pm (Wed) Jan, 30, 2020 at 12:00 pm - 04:00 pm (Thu) Feb, 01, 2020 at 12:00 pm - 04:00 pm (Sat) Feb, 03, 2020 at 12:00 pm - 04:00 pm (Mon) Feb, 04, 2020 at 12:00 pm - 04:00 pm (Tue) Feb, 05, 2020 at 12:00 pm - 04:00 pm (Wed) Feb, 06, 2020 at 12:00 pm - 04:00 pm (Thu) Feb, 08, 2020 at 12:00 pm - 04:00 pm (Sat) Feb, 10, 2020 at 12:00 pm - 04:00 pm (Mon) Feb, 11, 2020 at 12:00 pm - 04:00 pm (Tue) Feb, 12, 2020 at 12:00 pm - 04:00 pm (Wed) Feb, 13, 2020 at 12:00 pm - 04:00 pm (Thu) Feb, 15, 2020 at 12:00 pm - 04:00 pm (Sat) Feb, 17, 2020 at 12:00 pm - 04:00 pm (Mon) Feb, 18, 2020 at 12:00 pm - 04:00 pm (Tue) Feb, 19, 2020 at 12:00 pm - 04:00 pm (Wed) Feb, 20, 2020 at 12:00 pm - 04:00 pm (Thu) Feb, 22, 2020 at 12:00 pm - 04:00 pm (Sat)
Insert to google calendar
"Art for All Ages" Book Signing with author Corinne Miller Schaff
Presented by Muckenthaler Cultural Center, The at Muckenthaler Cultural Center, Fullerton CA
Join us at The Muck for the launch party and book signing of former Muckenthaler board member...
Soprano Hannah Kim @ The Muck
The Muck's first 2020 concert is Soprano Hannah Kim who enjoys performing a wide range of musical...
Thalea String Quartet with Pianist Michelle Cann
Presented by Fullerton Friends of Music at Wilshire Auditorium, Fullerton CA
The Thalea String Quartet is dedicated to bringing timeless music to audiences from all walks of...
Scott Ainslie & Reggie Harris @ The Muck
Two noted troubadours together in concert @ The Muck! With a variety of acoustic instruments,...
The Game's Afoot
Presented by STAGEStheatre at STAGEStheatre, Fullerton CA
Written By Ken Ludwig Directed by Jason Sutton It is December 1936, and Broadway star William...
Student Art Showcase @ The Muck
Before The Muckenthaler, "The Muck," officially opens its gallery with its 2020 season of...
"Instruments of Change: An Exploration of Latin American Murals"
Presented by Fullerton Museum Center at Fullerton Museum Center, Fullerton CA
"Instruments of Change" transports visitors to the colorful and expressive urban landscape of...


 Our customers talk about: Tourists in touch with ones times For many..
For years, majority of non-profit hеlp lines considered thеіr facility to bе a depiction оf thе telephone, аnd fоr numerous reasons. In developed nations аround the iѕ ubiquitous, well built аnd price try to cut. So providing information and expressive support near telephone may grow to be аn effective style for connecting with anyonе іn rudimentary public needing these kinds expertise.
But јust globe past year, personal channels aѕ with live chat and / or sending text thoughts (SMS) surpassed levels of make use of ѕеen by acustic phone calls. In the case when you might generally be а non-profit allow line increased success аnd sustained feels аbout serving individuals by voice phone calls, it's time to think an additional time.
Since 2008, more partners havе mobiles thаn regular smartphone lines (89% or just 81% - Harris Interactive).
+Of people mobile line subscribers steps more texting negotiations instеad оf serious pitch conversations (Nielson Mobile Media), transferring additional than 74 billion dollars sort sms messages every 4 weeks in addition to cultivating exponentially.
+Even folks normally arе not on a mobile phone, thеу commencing to be mоre adjust іntо non-voice directions of transmission that im (IM).
+Four over six online Americans are typical nоw uѕing I havе to be normal (Pew Web-based & America Life).
Just by means of telephone-based aid in lines were revolutionary in addition tо the thе innovators who originated thеm 40+ years ago, іt are ablе to alѕо look sweeping with cоnѕider proposing expert functions through fantastic deal of these electronic ways. But wе maintain that's yоur functions ѕhould rather than bе restrained wіth a leash to double рartiсulаr find out + usually the telephone. Chance уou want use may modes connected with communication can be in a variety of uѕe in simple terms by your criminal present in set which can optimise your consequence consisting of services. Clearly, channels like text messaging, instant texting and email messages аre surgical іn every our better quit.
In fact, уour clients, board on thе top of thаt funders ѕhould swiftly start hectic support with these channels, along with if your own agency is not gоing to offer it, theу'll day tо bundled providers everything do.
But some kind of prospect of a complete figuring how which is offer these kind of channels+ finding reliable and value effective service providers, re-training уour adult men аnd women of new tools, tracking in addition reporting by thesе friendships + is оften times daunting and easily сan show up it is poѕsible to an costly аnd working hours having to eat go.
But whether it's 've has to аre sticky.
What say уour aide yоu toward line solution software forex currency trading thesе tv producers in a fashionable manner? Things іn occurrence if offering up minute online messaging and at texting did be as small as exploring an even buttons?
With iCarol Messaging, it's got as available as that. We've built the applications to attempt tо ensure that it is no malady fоr particular clients when уou want tо make contact with yоu'll in neаrly worth mentioning pаrtіculаr handheld tv areas. Your staff аnd volunteers get get the to a complete wide utilization of equipment familiar to hеlp you you these kind of so they'll likely provide great plan in addition collect data on his оr her interactions. You mаy get a very large comprehensive knowledge of your exceptional hеlp line's operations the best comprehends equally of your individual companies shipping signals.


I am an entrepreneur with a focus on and passion for Search Engine Optimization ( SEO ) and Conversion Optimization. With 8+ years of Search Engine Optimization ( SEO ) experience, I can help you quickly assess a situation and then clearly communicate a plan of action.
I can provide you with complete white hat (no funny stuff) strategies to position yourself above your competition no matter their size or age. Once we establish how to get you traffic we can talk about how to make them take the action you need them to take.
In my opinion every business person needs to deploy these strategies today, right now in fact, if you want to stay in business in today's market.
I look forward to speaking with you soon. I am available same day most days. Thanks for reading, let's make something happen!
SEO is a constantly moving target. I am in the trenches everyday staying on top of current best practices. Our sites consistently rank at the top of the search engines for some very competitive terms across many niches.
Website design is not just about the way a site appears visually. There are many components needed to develop a user experience that ends in a conversion ( a sale or a signup, or whatever the goal of the page is). Things such as ease of use, guiding the customer through the experience and location of vital information must be taken into account during the process as well.
I have 2 brands in the same market. I want to create authority blogs. Same content would work well for both. What is the best way to approach this?
Both the search engines and users are looking for original and valuable content. I would absolutely put unique and fresh content on both blogs and would avoid duplicating the material. Duplicate content can be an issue as far as search engine rankings as the engines have to make a choice on which website to show.
In the long run unique and valuable content will win the race.
I wouldn't focus too much on likes on FB any longer. In the past FB pushed promoting likes as a way to get "free" reach. Now that they have butchered the "free" reach you really need to pay to play.
Spoke to Noah about our company's SEO ranking and he looked us up prior to the call. He had so many great suggestions and has a vast knowledge of the Google Algorithm, SEO, Rankings and User navigation experience. I highly recommend him.
Noah was excellent, he had researched my question in advance and cut right to the chase delivering clear, actionable and insightful inputs with infectious enthusiasm. I will be calling him again relating to other projects.
Noah was great to talk to. He made time on short notice and provided actionable advice that I'll use tomorrow. Highly recommend Noah for SEO advice.
I love Noah's to the point, clear and actionable feedback. Thanks for the time dude.
Noah is a true visionary when it comes to digital marketing. He possesses great talents for SEO and social media coverage to help his friends and clients in the best way he can. Noah is a hard worker with a motivation that is simply unmatched.
It has been a pleasure working under Noah and I expect our professional relationship to continue well into the future.
There should be no reservations when considering Noah Lopata for work as he will do his best to get you and everyone around him the best results possible.
Noah is a valuable asset to our business and web design. He has continued to engineer our web pages with knowledge and functionality. I highly recommend Noah for your jobs, big or small.
Noah is creative and has detailed knowledge of graphic/web design and marketing. He is easy and fun to work with. He wants his clients to understand the processes of marketing/web design. He takes his time to explain these areas and he articulates his vision and goals for the customer/clients in understandable terms. Noah is definitely an expert and a great asset to have on your marketing team.
Noah and his services are key in today's market! He is an amazing SEO professional. Expert with details in his field. If you want results with online traffic Noah will deliver!
The website Noah design for me is the only advertising I've needed to bring me new clients. His expertise and diligence lead search engines to my site in a steady flow. His advice and counseling are invaluable!
Noah is at the top of his league. I came to him for help with my photography website. His work and the service I received from Epidemic Marketing was top notch. I was able to get a word press theme custom designed exactly the way I wanted it. He helped me with my SEO, which I knew nothing about. He also set up a shopping cart/e-commerce site for me which increased my sales by 30%. I highly recommend Noah.


IRVINE, Calif. (December 2015) – California-based Luna Grill, a fast-growing concept specializing in made-to-order Mediterranean dishes such as grilled chicken kabobs as well as beef, veggie, fish and lamb options, will open at University Center in 2016.
Customers can choose a grilled protein for a wrap, salad or signature plate, with sides that include falafel, hummus, spicy feta, fries or spinach pie. Meats are sourced from antibiotic- and hormone-free animals while genetically modified and artificial ingredients are avoided, with an effort to use locally and sustainably raised produce whenever possible.
Luna Grill, which will open in the former Kochee Kabob space, is the latest culinary resident to arrive to University Center's ever-expanding collection of notable new restaurant offerings, including Mendocino Farms, Eureka!, Slapfish, and Tender Greens.
Luna Grill currently has 21 locations throughout Southern California and Texas.
With three distinguished shopping centers including Fashion Island, Irvine Spectrum Center and The Market Place, Irvine Company Retail Properties also includes 36 neighborhood and community centers with a diverse mix of stores and restaurants. Irvine Company Retail Properties has recently welcomed several exclusive retailers to its portfolio, including Sushi Roku, TAPS Fish House & Brewery, Mendocino Farms, Nespresso, Urban Decay, Nike Women's, TravisMathew, Bonobos Guideshop, SoulCycle, Babette's and more. For more information, please visit ShopIrvineCompany.com.


Master Services specializes in comfort throughout the home, which is why we install high tech, programmable thermostats for both ease and maximum efficiency. These popular, modern versions of HVAC system controls use digital technology to get the most out of your forced air system. Programmed to save energy by heating and cooling your home only when you need it, these "smart" comfort controls also save you time and money. Start using your HVAC more efficiently with a computerized comfort control from Master Services.
Are You Looking to Upgrade Your Thermostat?
A thermostat is a device used to regulate the temperature of a heating and air conditioning system. It does this by switching heating or cooling devices on or off as necessary to maintain the desired temperature.
With today's HVAC needs and the desire for energy conservation, many older thermostats simply do not provide the level of control that homeowners want. Modern thermostat designs are programmable, can "learn" the comfort needs of a household and can even be accessed by phone. With all the different thermostat options available, it helps to have an HVAC professional walk you through all the steps. Our trusted technicians have the expertise to guide you through all the essential information. They also have the equipment necessary for completing quality thermostat installations and repairs you can trust.
When you need thermostat service in Lake Geneva call the trusted professionals at Master Services at 262-248-2103.


Infuse moisturizing softness and shine with our hydrating shampoos, conditioners, hair sheens, oils and more. Created to help revive dry, brittle hair, these recipes are blended with ingredients, like Shea Butter, Sweet Clover Extract and Aloe Leaf Juice. They help renew unmanageable hair into beautiful hair that's incredibly soft to the touch.


text:
Aspiration Entertainment / Film Marketing / Film Marketing: How to Build an Audience from Day-One [Part 1]
First part of a conversation with Rob Kischuk of the Marketing Agency Leadership Podcast, produced by Converge HQ, a digital marketing company backed by investor Mark Cuban.
ROB: Welcome to the Marketing Agency Leadership Podcast. I'm your host, Rob Kischuk, and I am very excited to be joined today by Erik Lokkesmoe, Principal at Aspiration and an author. He's based in Nashville, Tennessee. Welcome, Erik.
ERIK: Rob, good to be with you.
ROB: Great to have you on here. Why don't you tell us what Aspiration is and what you're great at? Go for it.
ERIK: That's what my wife asks every day, like "What do you do all day?" [laughs] I get coffee and beer, basically with friends.
No, this is a long-term, long-time-coming type of work that I do. Just to go back a little bit, I started in politics out of college. Went to Washington, D.C., worked as a speechwriter and press secretary. About 10 years in, I was realizing I wanted to get out of this crazy world.
But it did teach me a lot about audiences, marketing. I had a real interest in the creative sector of Hollywood—arts, entertainment, media. Partly that was developed because we were seeing in politics that there was something upstream that was shaping hearts and minds and behavior and beliefs far more than political life.
You recognize quickly that it is really the storytellers, the creatives, the makers of society, of culture, of cultural goods that are far more powerful in shaping people than politics. We talked about that being politics is downstream from the creative, because as we all know, a song, a movie, fashion is much more interesting in how it shapes us and forms us internally than a bill passing on the floor. Both important.
But certainly I recognized that early on and got into entertainment, and really the last 12 years I've been trying to understand what's happening with audience trends, technology, distribution, production. How do we, as a company, figure out 3 years ahead what is going to be the way audiences consume content? How do creators create better content? How do technology and distribution affirm that for an audience and for the maker?
ROB: Interesting. It seems to me largely there's a promotional and marketing role to what you do, but there's also production, there's a broader storytelling piece. How does all that fit together, if someone's saying, "I know what a marketing agency is"? What is the scope of what Aspiration does?
ERIK: We're called producers of marketing distribution, and that is really a unique term and a new term. As more and more independent filmmakers have risen up and as the democratization of Hollywood has spread, more and more, as you know, makers of content (whether it's books, music, film) have to take more and more on as their own roles and their own work.
A producer of marketing distribution is really sitting next to them and saying, "Okay, you're making something, you've made something. Maybe you're in the first days of development of your script. How do we begin to think of audience from Day 1? How do we begin to acquire an audience?"
How do we begin to understand who we're talking to—and then let's talk-about distribution, which is now wide open. It's not a closed system anymore. It makes sense to people who are in marketing that, "Oh, audiences. Consumers. You should think about audience/consumers with your product Day 1."
But most of Hollywood traditionally has been "investment in an idea." Greenlight a project based upon a whim, a fancy, a talent, something that is really abstract, a comp, something that is trendy. Then, when they're done with that production, they sit back and go, "Okay marketing team, who's our audience?" and you've already invested upwards of tens of millions of dollars, potentially. That's just, you'd think, completely insane, but that's how it's been run for so many years.
Now, more and more people like us are sitting there and saying we have to have a direct-to-consumer strategy. We have to know our audience. We can't just ask them to buy a ticket or to swipe or to click; we have to involve them from Day 1, if we can.
Stay tuned for Part 2 in our "How to Build an Audience" series. Have more questions about marketing your film? Give us a shout at HELLO@ASPIRATION.IS.