First, you need to install the json gem for ruby, as the plugin requires it:

gem install json

then you need to setup the redmine plugin. For this you have to go to your redmine install folder, and then from here head to vendor/plugins folder. Once there, clone the redmine github hook plugin:

git clone https://github.com/koppen/redmine_github_hook.git

then do the usual plugin installation thingies to install the plugin into redmine:

rake db:migrate:plugin NAME=redmine_github_hook RAILS_ENV=production

and then restart your Redmine. Now you’re set on Redmine site.

Your git repository need to be have as remote origin your BitBucket repository, so you’ll want to run something like:

git –git-dir=’your_repositories/your_repository.git’ remote add origin g...@bitbucket.org:your_user/your_repository.git

This completes your server side setup. In your BitBucket account, you’ll need to setup a POST service which will notify your Redmine to update it’s repository. For this you’ll have to go to your repository admin page, then select services on the right menu. Then in the drop-down select POST and for the URL enter your an URL like this:

http://your redmine web address/github_hook?project_id=your redmine project name

That’s it. Now each time you do a commit in your BitBucket repository, your Redmine repository will get updated accordingly (and everything else depending on this, like activity,etc).

P.S. These steps can be applied also to your GitHub account, should work without any problem.

Happy commiting

The workflow is simple:

1. load the xsd file we want to validate against. For this I’ll use the handy class which searches the classpath for the given resource.
2. transform the node into xml document.
3. validate the document against the schema.

public static String xmlToString(Node node)
    {
        try
        {
            Source source = new DOMSource(node);
            StringWriter stringWriter = new StringWriter();
            Result result = new StreamResult(stringWriter);
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer();
            transformer.transform(source, result);
            return stringWriter.getBuffer().toString();
        }
        catch (TransformerConfigurationException e)
        {
            e.printStackTrace();
        }
        catch (TransformerException e)
        {
            e.printStackTrace();
        }

        return null;
    }

then we’ll use this string as a stream to create the document from and validate against the schema as bellow:

StringReader r = new StringReader(xmlToString(node));
validator.validate(new StreamSource(r));

The entire code is attached here (as example only, in production you’ll probably have to close the open input streams returned by the ClassPathSearcher class)

So, let’s assume we have couple of property files, or xml files or whatever, which could be possibly embedded in the jar files of the web application located in WEB-INF/libs folder. So, how can we retrieve the list of them, as we aren’t even aware of the jar files which could be in the libs folder?

By searching the net, I found this thread discussing the issue, however seems like the code fails to work in Tomcat 6. After a bit of debugging the code and tweaking it, turned out the issue was related to the way the ClassLoader  was retrieved. The code which should be used (at least in case of Tomcat 6) is:

ClassLoader applicationClassLoader = Thread.currentThread()
                .getContextClassLoader();

After a bit more tweaking around and fixing some small issue, I ended up with a handy singleton which is really easy to be used:

package some.package;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * Adapted source from
 * http://www.coderanch.com/t/278514/Streams/java/Reading-files-classpath-searching-pattern
 */
public class ClassPathSearcher
{
    static ClassPathSearcher instance = null;
    Set<String> classPathSet = new HashSet<String>();
    static final Logger log = Logger.getLogger(
            ClassPathSearcher.class.getName());

    private ClassPathSearcher()
    {
    }

    public static ClassPathSearcher getInstance()
    {
        if (instance == null)
        {
            instance = new ClassPathSearcher();
            instance.init();
            log.log(Level.INFO, "ClassPathSearcher initialized");
        }

        return instance;
    }

    private void init()
    {
        ClassLoader applicationClassLoader = Thread.currentThread()
                .getContextClassLoader();

        URL[] urls = ((URLClassLoader) applicationClassLoader).getURLs();

        for (URL url : urls)
        {
            String urlStr = url.getPath();
            if (urlStr.startsWith("file:"))
            {
                urlStr = urlStr.substring(5);
            }

            if (urlStr.endsWith("!/"))
            {
                urlStr = urlStr.substring(0,urlStr.length() - 2);
            }

            classPathSet.add(urlStr);
        }

        String classPath = System.getProperty("java.class.path");

        String[] pathElements = classPath.split(
                System.getProperty("path.separator"));

        for (String el : pathElements)
        {
            classPathSet.add(el);
        }
    }

    public Map<String, InputStream> findFilesInClassPath(String fileNamePattern)
    {
        Map<String, InputStream> result = new TreeMap<String, InputStream>();

        for (String element : classPathSet)
        {
            try
            {
                File newFile = new File(element);

                if (newFile.isDirectory())
                {
                    result.putAll(findResourceInDirectory(newFile,
                            fileNamePattern));
                }
                else
                {
                    result.putAll(findResourceInFile(newFile, fileNamePattern));
                }
            }
            catch (IOException e)
            {
                log.log(Level.WARNING, "Exception:"+ e);
            }
        }

        return result;
    }

    private Map<String, InputStream> findResourceInFile(File resourceFile,
            String fileNamePattern)
            throws IOException
    {
        Map<String, InputStream> result = new TreeMap<String, InputStream>();

        if (resourceFile.canRead() &&
                resourceFile.getAbsolutePath().endsWith(".jar"))
        {
            JarFile jarFile = new JarFile(resourceFile);

            Enumeration<JarEntry> entries = jarFile.entries();

            while (entries.hasMoreElements())
            {
                JarEntry singleEntry = entries.nextElement();

                if (singleEntry.getName().matches(fileNamePattern))
                {
                    result.put(jarFile.getName() + "/" + singleEntry.getName(),
                            jarFile.getInputStream(singleEntry));
                }
            }
        }
        return result;
    }

    private Map<String, InputStream> findResourceInDirectory(File directory,
            String fileNamePattern)
        throws IOException
    {
        Map<String, InputStream> result = new TreeMap<String, InputStream>();

        File[] files = directory.listFiles();

        for (File currentFile : files)
        {
            if (currentFile.getAbsolutePath().matches(fileNamePattern))
            {
                result.put(currentFile.getAbsolutePath(), new FileInputStream(
                        currentFile));
            }
            else if (currentFile.isDirectory())
            {
                result.putAll(findResourceInDirectory(currentFile,
                        fileNamePattern));
            }
            else
            {
                result.putAll(findResourceInFile(currentFile, fileNamePattern));
            }
        }

        return result;
    }
}

Using it is really easy:

Map<String, InputStream> files = ClassPathSearcher.
                getInstance().findFilesInClassPath("<your pattern here>");

Sources can be found here: ClassPathSearcher.java

• Multiple alarms.
• Day by day alarm selection (not just weekdays/weekend….)
• Internet radio as alarm or sleep music.
• Playlist for sleep & wake up -possibility to choose between multiple text/background colors.

This application is featuring in a Qt developers contest, so if you feel like want to give to developer your vote, feel free to do it here by voting the “Night stand music alarm” application.

Some screen shots of the application:

If anybody experiences any issues related to this, let us known.

One regexp which fits the bill quite ok is in the Perl module  found at this address: http://ex-parrot.com/~pdw/Mail-RFC822-Address.html which validates against to RFC 822 grammar.

A utility class with the regexp from the perl module can be downloaded from here: EmailAddressUtil

Our generated code is using RestDataSource on client side, which implements the 4 core DataSource operations (add, remove, update, fetch) using a simple protocol of XML or JSON requests and responses sent over HTTP. This being completed already, let’s turn to server side and see how can we make things a bit better when generating the response XMLs we need to return when these operations are called on server side.

The server provided with smartclient handles all DataSource communication using a servlet called IDACall. The server will instantiate a server side object which will take care of retriving the data (from datasource, computing it, etc) and returning it back to servlet.Then it will serialize it and will send it to the client side DataSource object.

Checking the examples of smartgwt ee and smartclient enterprise and checking the provided java docs, seems like the servlet will create a DSRequest object which will be handled to the method called for fetch, add, remove, update. The response will be returned as a DSResponse object.

We’ll recreate these objects on server and we’ll try to write a servlet which will try to successfully replace the one provided with the smartclient server when working with DataSources, not functionally, but maybe as how easy requests can be processed on server side.

Let’s get first some information about the client side RestDataSource.

• The format of data sent to the server is determined by the dataProtocol specified for the operation. Request data is sent as parameters if the format is specified as “getParams” or “postParams”. We already set this in the DataSource which is extended by the client side DataSource we generate with generator as described in previous post.

• There is a standardized way to send back the answer. For example for fetch it looks like the following:

  <response>
  	<status>0</status>
  	<startRow>start row number</startRow>
          <endRow>the end row number</endRow>
          <totalRows>total number of rows</totalRows>
          <data>
  		<record>
  			<field1>value</field1>
  			<field2>value</field2>
  		</record>
  		<record>
  			<field1>value</field1>
  			<field2>value</field2>
  		</record>
                 ... 75 total records ... 
         </data>
  </response>

considering this and the information provided in javadocs DSRequest should at least contain , the DataSource id of DataSource which makes the request on client side, start row, end row, what kind of operation is requested, the field after which the sort is made, and a hash map with field value pair as a criteria of the request. For easy handling, we also include HttpServletRequest, HTTPServletResponse and HTTPSession objects of the servlet. We end up with something pretty much like:

import java.util.HashMap;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class DSRequest
{
	HttpSession session;
	HttpServletResponse response;
	HttpServletRequest request;

	private static String OPERATION_FETCH = "fetch";
	private static String OPERATION_UPDATE = "update";
	private static String OPERATION_REMOVE = "remove";
	private static String OPERATION_ADD = "add";

	String dataSourceName;
	String operationType;

	HashMap criteria;

	int startRow;
	int endRow;
	boolean paged;

	String sortBy;

	public DSRequest(String dataSourceName, String opType)
	{
		this.dataSourceName = dataSourceName;
		this.operationType = opType;
		endRow = -1;
		startRow = -1;
		paged = true;
	}

	public HttpSession getSession()
	{
		return session;
	}

	public void setSession(HttpSession session)
	{
		this.session = session;
	}

	public HttpServletResponse getResponse()
	{
		return response;
	}

	public void setResponse(HttpServletResponse response)
	{
		this.response = response;
	}

	public HttpServletRequest getRequest()
	{
		return request;
	}

	public void setRequest(HttpServletRequest request)
	{
		this.request = request;
	}

	public String getDataSourceName()
	{
		return dataSourceName;
	}

	public void setDataSourceName(String dataSourceName)
	{
		this.dataSourceName = dataSourceName;
	}

	public String getOperationType()
	{
		return operationType;
	}

	public void setOperationType(String operationType)
	{
		this.operationType = operationType;
	}

	public HashMap getCriteria()
	{
		return criteria;
	}

	public void setCriteria(HashMap criteria)
	{
		this.criteria = criteria;
	}

	public int getStartRow()
	{
		return startRow;
	}

	public void setStartRow(int startRow)
	{
		this.startRow = startRow;
	}

	public int getEndRow()
	{
		return endRow;
	}

	public void setEndRow(int endRow)
	{
		this.endRow = endRow;
	}

	public boolean isPaged()
	{
		return paged;
	}

	public void setPaged(boolean paged)
	{
		this.paged = paged;
	}

	public String getSortBy()
	{
		return sortBy;
	}

	public void setSortBy(String sortBy)
	{
		this.sortBy = sortBy;
	}

	public boolean isAdd()
	{
		return OPERATION_ADD.equals(operationType);
	}

	public boolean isRemove()
	{
		return OPERATION_REMOVE.equals(operationType);
	}

	public boolean isUpdate()
	{
		return OPERATION_UPDATE.equals(operationType);
	}

	public boolean isFetch()
	{
		return OPERATION_FETCH.equals(operationType);
	}
}

The DMI invocation passes the result back to the servlet wrapped in a DSResponse object. This DSResponse object should contain at least status of the response, start row, end row, total rows, data itself and a list of errors. Wrapping up, we get something pretty much like:

import java.util.ArrayList;
import java.util.List;

public class DSResponse
{
	public static int STATUS_FAILURE = -1;
	public static int STATUS_LOGIN_INCORRECT = -5;
	public static int STATUS_LOGIN_REQUIRED = -7;
	public static int STATUS_LOGIN_SUCCESS = -8;
	public static int STATUS_MAX_LOGIN_ATTEMPTS_EXCEEDED = -6;
	public static int STATUS_SERVER_TIMEOUT = -100;
	public static int STATUS_SUCCESS = 0;
	public static int STATUS_TRANSPORT_ERROR = -90;
	public static int STATUS_VALIDATION_ERROR = -4;

	int status;
	long startRow;
	long endRow;
	long totalRows;
	Object data;
	List errors;

	public int getStatus()
	{
		return status;
	}

	public void setStatus(int status)
	{
		this.status = status;
	}

	public long getStartRow()
	{
		return startRow;
	}

	public void setStartRow(long startRow)
	{
		this.startRow = startRow;
	}

	public long getEndRow()
	{
		return endRow;
	}

	public void setEndRow(long endRow)
	{
		this.endRow = endRow;
	}

	public long getTotalRows()
	{
		return totalRows;
	}

	public void setTotalRows(long totalRows)
	{
		this.totalRows = totalRows;
	}

	public Object getData()
	{
		return data;
	}

	public void setData(Object data)
	{
		this.data = data;
	}

	public List getErrors()
	{
		return errors;
	}

	public void setErrors(List errors)
	{
		this.errors = errors;
	}

	public DSResponse()
	{
		status = STATUS_SUCCESS;

		errors = new ArrayList();
       		startRow = 0;
        	endRow = 0;
        	totalRows = -1;
	}

	public DSResponse(int status)
	{
		this.status = status;

		errors = new ArrayList();
        	startRow = 0;
        	endRow = 0;
        	totalRows = -1;
	}
}

The DMI object will return it’s answer in form of DSResponse object. The data member will contain the data part of the answer – the record or the records – returned to the client side DataSource while the additional fields of the DSResponse help the servlet build the REST response required by the client side DataSource.

Having these set up, now we need a servlet which gets the request from the DataSource, creates a DSRequest object and fills it with information passed in parameter of the request / post parameters by the client side DataSource object, identifies the XML describing the DataSource, instantiate the class defined in the DataSource as responsible for DMI operations, then using reflection calls one of add(), remove(), fetch(), update() methods of the instantiated object, which will return a DSResponse object to the servlet. Using this DSResponse object, the servlet builds the XML response using the information from the object and also using reflection to generate the data part. If written carefully, we can reuse the code we used in DataSource generator to load DataSources and their fields, except in this case probably the best would be to load them at server startup and maybe create a mapping between the id of the DataSource and the DataSource object itself, for easier and faster referencing.

The steps of doing this are:

1. First we need to make a servlet and map it to the URL we declared in the generator (“/DMI” or anything else). This servlet will be used for all our DataSources.
2. When servlet initializes, it should go over the defined DataSource xmls and should load them one by one, and create a mapping between the DataSource object and its id, which would make real fast lookup of DataSource by its ID.
3. On incoming request, should parse the request and get all _dataSource, _operationType, _startRow, _endRow, _sort_by parameters and use these to build the DSRequest object. Then should get all the other parameter value fields and cross-check them against the datasource fields, and if they are found,create a HashMap with their name / value as criteria of the operation, and store it also in the DSRequest object.
4. Handle the operation – instantiate the DMI object and call the operation method (add(), fetch(), remove(), update() ) and get back the DSResponse object.
5. Build the XML response according to the operation and information stored in DSResponse, and serialize the data part of the DSResponse using a generic XML serializer based on reflection, cross-referencing the name of fields with the fields declared in the DataSource xml.
6. Send back the answer to DataSource.

Some notes on building the response:

• it will be easier if you write a generic XML serializer which can chew any kind of object (using reflection to get the object’s fields) and throw out the fields of the object in form of XML.
• make sure you can serialize both simple object and a collection of objects. By doing this, DSResponse won’t change, and there is no much difference in a DMI object related to returning a record or a list of records to DataSource. If a collection is returned, simply serialize each member of the collection using the serializer I’ve discussed about.
• do take in consideration the status flag of DSResponse. There are couple of standard values predefined as constants. In case of failure and success serialise the objects normally with status field and so (however on error there is no reason to serialize the data itself) but in case of authorization errors, instead of returning the status response, return the various markers defined by smartclient. The server side will detect them and will automatically trigger relogin flow. There will be a next article with more detail about implementing the relogin flow using SmartGWT.

One of things which can make development faster is the way DataSources are created.
Currently you have to define the DataSource class in java file in the client package (which gets compiled / translated to javascript) or alternatively you have to declare it in javascript. You have to manually create each of the DataSource fields, and add it manually to the DataSource itself. Also, DataSources themselves arent really useful without back-end support so you need to somehow get the data from server. For this there are various possibilities, like Web Services, REST, simple XML, etc.

There is however a better way to do this. The smartclient server allows you (next to some other things) to define the DataSource in XML. Then this is used to actually generate the DataSource based on what information is in the XML (fields, field names, titles, length, and various other fields). Also it allows defining a so called DMI object, which is the server side part of the DataSource, tightly integrated with it. The server itself offers a hierarchy of classes and a servlet which basically allows one to define a class which provides the data to the DataSource. This class is actually a simple object wich provides fetch(), add(), update() and delete() methods, and return the information in a standardised way. The server takes care of processing this and sending it back to the DataSource who requested the information.

These two functionalities allow shorter development time, and also centralize the place where datasource information is stored. In the server-less approach you have to specify the structure of the DataSource when you define the DataSource and also you have to know the structure of that DataSource at least in the places where you send back the information requested by fetch(), add(), update() and delete().And also, you have to take care of serializing the data.
In the smartclient server, all this is handled automatically. You just need to create the XML for DataSource, and the DMI object which has the role of returning the (list / collection) of objects. More easy. Much cleaner.

So, let’s take them in order.

First, let’s see how can we improve working with DataSource.

Creating a DataSource would mean creating a new class which extends DataSource, then set up it’s fields, the place where the data is retrieved, it’s id, etc. Something like the code bellow (class declaration omitted, only the initialisation itself is shown):

setID(id);
setRecordXPath("/List/country");
DataSourceField countryNameField = new DataSourceField("countryName", FieldType.TEXT, "Country");
DataSourceField countryCodeField = new DataSourceField("countryCode", FieldType.TEXT, "Code");
DataSourceField independenceField = new DataSourceField("independence", FieldType.DATE, "Independence");
DataSourceField populationField = new DataSourceField("population", FieldType.INTEGER, "Population");
DataSourceField gdpField = new DataSourceField("gdp", FieldType.FLOAT, "GDP ($B)");

setFields(countryNameField, countryCodeField, independenceField, populationField, gdpField);
setDataURL("ds/test_data/country.data.xml");

Having this kind of code written for each DataSource we define is tiresome and unnecessary, if we can define a generator which does this for us, based on a XML specifying the information to be generated.

The DataSource declaration could be something like:

<?xml version="1.0" encoding="UTF-8"?>
<DataSource ID="DataSourceId">
<fields>
<field title="ID" name="id" type="text" required="true" primaryKey="true"/>
<field title="Creator" name="creator" type="text" valueXPath="creator/displayName"/>
<field title="Name" name="name" type="text"/>
<field title="Description" name="description" type="text"/>
<field title="Bla Bla" name="blabla" type="text"/>
</fields>
<serverObject className="DMIPackage.DMIHandler"/>
</DataSource>

Because later we need to identify the DataSource on server side also (to retrieve the DMI object) we need to store this somewhere in a package which is not compiled to Javascript. Also, for that purpose we added the serverObject tag. But our front-end is Javascript, we need a way to create some code based on this XML, code which ends up running on the client side. For this we can use a GWT generator.

First, we need to define an interface which will trigger the generator itself (somewhere in the client package). Something like:

public interface IDataSource
{
public void initFields();
}

is a good place to start. In initFields() we will generate the boilerplate code. We need to configure the module to trigger the generator for this interface. For this we need to edit the module XML file and add something like

<generate-with>
<when-type-assignable />
</generate-with>

In order to trigger the generator for a given DataSource, we need to create a interface for that DataSource and extend it from our IDataSource interface. Each time code like this is encountered:

IDataSource aDS = (IDataSource) GWT.create(ADataSource.class);

where ADataSource is a interface extending our IDataSource interface, our generator will be called to generate the source of that class. I won’t go in detail about how one writes a code generator for GWT, there is already lot if info about this subject available on Internet. Still, some clarifications are required:

• the file name of the XML is generated from the class name to be generated. This can be made in various ways, this was easier to implement (alternatively we could add a tag in XML file to specify for which datasource provides information, load all the DataSource XMLs and search the one we need)
• resources can be retrieved using ResourceOracle:

  ResourceOracle oracle = context.getResourcesOracle();
  Map<String, Resource> map = oracle.getResourceMap();
  Resource res = map.get(resourceName);
  
  // find our resource

• In order to make things easier and to reduce the quantity of code generated, the class we generate extends a base class. This base class extends REST DataSource and set up the add() fetch() remove() update()URLs to point to our servlet which simulates DMI, something like (the constructor is shown):

  public BaseDataSource()
  {
  setID(id);
  setFetchDataURL("/DMI");
  setAddDataURL("/DMI");
  setRemoveDataURL("/DMI");
  setUpdateDataURL("/DMI");
  
  OperationBinding fetch = new OperationBinding();
  fetch.setOperationType(DSOperationType.FETCH);
  fetch.setDataProtocol(DSProtocol.POSTPARAMS);
  
  OperationBinding add = new OperationBinding();
  add.setOperationType(DSOperationType.ADD);
  add.setDataProtocol(DSProtocol.POSTPARAMS);
  
  OperationBinding update = new OperationBinding();
  update.setOperationType(DSOperationType.UPDATE);
  update.setDataProtocol(DSProtocol.POSTPARAMS);
  
  OperationBinding remove = new OperationBinding();
  remove.setOperationType(DSOperationType.REMOVE);
  remove.setDataProtocol(DSProtocol.POSTPARAMS);
  setOperationBindings(fetch, add, update, remove);
  
  initFields();
  }

All left now is to generate the code which set up the fields and add them to DataSource. I wont go in detail of this either. It’s as easy as getting all the fields, checking their type, and based on their type write the code which create the fields, set them up according to the information in XML and at the end add those fields to the DataSource. That’s all.

Handling server side of DataSources will be in a separate post.

GL_OES_byte_coordinates

GL_OES_fixed_point

GL_OES_single_precision

GL_OES_matrix_get

GL_OES_read_format

GL_OES_compressed_paletted_texture

GL_OES_point_sprite

GL_OES_point_size_array

GL_OES_matrix_palette

GL_OES_draw_texture

GL_OES_query_matrix

GL_OES_texture_env_crossbar

GL_OES_texture_mirrored_repeat

GL_OES_texture_cube_map

GL_OES_blend_subtract

GL_OES_blend_func_separate

GL_OES_blend_equation_separate

GL_OES_stencil_wrap

GL_OES_extended_matrix_palette

GL_OES_framebuffer_object

GL_OES_rgb8_rgba8

GL_OES_depth24

GL_OES_stencil8

GL_OES_compressed_ETC1_RGB8_texture

GL_OES_mapbuffer

GL_OES_EGL_image

GL_EXT_multi_draw_arrays

GL_OES_required_internalformat

GL_IMG_read_format

GL_IMG_texture_compression_pvrtc

GL_IMG_texture_format_BGRA8888

GL_EXT_texture_format_BGRA8888

GL_IMG_texture_stream

GL_IMG_vertex_program

The most of the steps are the same as in the previous post about integrating NDK with Eclipse.

First, we need to convert the project to C++ project:

• right click on project root,then select New Project -> Other -> C++ -> Convert to C++
• check C++ project, choose Makefile and for toolchain choose other.
• accept to open the C++ perspective.

Until this, the project was converted to C++ project. We now need to set up the input and output folders for C++ build:

• create the libs, jni and obj folders. Set the output folders to libs and obj, then set the source folder to jni (in project properties, C++ General)

And finally we need to set up a new builder:

• while in C++ perspective, open project properties and choose builders, then uncheck everything related to CDT builder.
• create a new builder of type program.
• in the window with builder properties: first text field contains the ndk-build script location, second text field contains project location and the last one should contain -C ${build_project}

And that’s it. You should be able to build your project, Clean and eclipse will run the required builders in order to build both java and C++ code and finally create the APK file.
Before first build it is possible there will be some errors, but those will disappear after the build.